Collaboration diagram for ComputationLoopedOptimizer:

[legend]

Public Member Functions
	ComputationLoopedOptimizer (const Nnet &nnet, NnetComputation *computation)

bool	Optimize ()

Static Private Member Functions
static int32	FindTimeShift (const NnetComputation &computation)

static void	CreateMatrixPairs (const NnetComputation &computation, std::vector< std::pair< int32, int32 > > *matrix_to_pair)

static int32	NormalizeCindexes (std::vector< Cindex > *cindexes)

static void	GetPairToMatrixMap (std::vector< std::pair< int32, int32 > > &matrix_to_pair, unordered_map< std::pair< int32, int32 >, int32, PairHasher< int32 > > *pair_to_matrix)

static void	ConvertListsToPairLists (const std::vector< std::vector< int32 > > &active_matrices, const std::vector< std::pair< int32, int32 > > &matrix_to_pair, std::vector< std::vector< std::pair< int32, int32 > > > *active_pairs)

static bool	ListsAreEqualExceptForPossibleShift (const std::vector< std::pair< int32, int32 > > &a, const std::vector< std::pair< int32, int32 > > &b, int32 shift)

static bool	FindFirstRepeat (const std::vector< std::vector< std::pair< int32, int32 > > > &active_pairs, int32 time_shift_per_segment, int32 seg1, int32 seg2)

static void	GetIdentifiedMatrices (const std::vector< std::pair< int32, int32 > > &pair_list1, const std::vector< std::pair< int32, int32 > > &pair_list2, const unordered_map< std::pair< int32, int32 >, int32, PairHasher< int32 > > &pair_to_matrix, std::vector< int32 > matrix_list1, std::vector< int32 > matrix_list2)

static void	CheckIdentifiedMatrices (const NnetComputation &computation, const std::vector< int32 > &list1, const std::vector< int32 > &list2, int32 time_difference)

static void	FormInfiniteLoop (int32 command1, int32 command2, NnetComputation *computation)

static void	AddMatrixSwapCommands (const std::vector< int32 > &matrices1, const std::vector< int32 > &matrices2, NnetComputation *computation)

static void	GetMatrixSwapOrder (const std::vector< int32 > &matrices1, const std::vector< int32 > &matrices2, std::vector< std::pair< int32, int32 > > *swaps)

static void	FindActiveMatrices (const NnetComputation &computation, const Analyzer &analyzer, const std::vector< int32 > &splice_point_commands, std::vector< std::vector< int32 > > *active_matrices)
	Given a list of command indexes ('splice_point_commands') which are expected to be command indexes of the kNoOperationMarker at segment boundaries, this function outputs for each of these command indexes a list of matrices which are 'active' at that point in time. More...

Private Attributes
const Nnet &	nnet_

NnetComputation *	computation_

Analyzer	analyzer_

std::vector< std::pair< int32, int32 > >	matrix_to_pair_

std::vector< int32 >	splice_point_commands_

Detailed Description

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

Constructor & Destructor Documentation

◆ ComputationLoopedOptimizer()

ComputationLoopedOptimizer	(	const Nnet &	nnet,
		NnetComputation *	computation
	)

inline

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

References kaldi::nnet3::Optimize().

3893 :

3894 nnet_(nnet), computation_(computation) { }

kaldi::nnet3::ComputationLoopedOptimizer::nnet_

const Nnet & nnet_

Definition: nnet-optimize-utils.cc:4061

kaldi::nnet3::ComputationLoopedOptimizer::computation_

NnetComputation * computation_

Definition: nnet-optimize-utils.cc:4062

Member Function Documentation

◆ AddMatrixSwapCommands()

void AddMatrixSwapCommands	(	const std::vector< int32 > &	matrices1,
		const std::vector< int32 > &	matrices2,
		NnetComputation *	computation
	)

staticprivate

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

References NnetComputation::Command::command_type, NnetComputation::commands, NnetComputation::GetWholeSubmatrices(), rnnlm::i, KALDI_ASSERT, kaldi::nnet3::kGotoLabel, and kaldi::nnet3::kSwapMatrix.

                                   {
   std::vector<std::pair<int32, int32> > swaps;
   // Note: in 'easy' cases where matrices1 and matrices2 are disjoint,
   // 'swaps' will just be the vector { (matrices1[0],matrices2[0]),
   // (matrices1[1],matrices2[1]), ... },
   // but in some cases these may need to get reordered.
   GetMatrixSwapOrder(matrices1, matrices2, &swaps);
 
   NnetComputation::Command goto_label_command = computation->commands.back();
   KALDI_ASSERT(goto_label_command.command_type == kGotoLabel);
   computation->commands.pop_back();
 
   // the following vector gives us, for each matrix index, a submatrix index
   // that covers the whole of that matrix (needed because the commands
   // require submatrix indexes)
   std::vector<int32> whole_submatrices;
   computation->GetWholeSubmatrices(&whole_submatrices);
   size_t num_matrices = whole_submatrices.size();
 
   for (size_t i = 0; i < swaps.size(); i++) {
     int32 m1 = swaps[i].first, m2 = swaps[i].second;
     KALDI_ASSERT(static_cast<size_t>(m1) < num_matrices &&
                  static_cast<size_t>(m2) < num_matrices);
     int32 s1 = whole_submatrices[m1], s2 = whole_submatrices[m2];
     computation->commands.push_back(
         NnetComputation::Command(kSwapMatrix, s1, s2));
   }
   computation->commands.push_back(goto_label_command);
 }

◆ CheckIdentifiedMatrices()

void CheckIdentifiedMatrices	(	const NnetComputation &	computation,
		const std::vector< int32 > &	list1,
		const std::vector< int32 > &	list2,
		int32	time_difference
	)

staticprivate

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

References NnetComputation::MatrixDebugInfo::cindexes, rnnlm::i, NnetComputation::MatrixDebugInfo::is_deriv, KALDI_ASSERT, kaldi::nnet3::kNoTime, NnetComputation::matrices, NnetComputation::matrix_debug_info, NnetComputation::MatrixInfo::num_cols, NnetComputation::MatrixInfo::num_rows, and NnetComputation::MatrixInfo::stride_type.

                            {
   KALDI_ASSERT(time_difference > 0);
   KALDI_ASSERT(list1.size() == list2.size());
   KALDI_ASSERT(!computation.matrix_debug_info.empty());
   for (size_t i = 0; i < list1.size(); i++) {
     int32 m1 = list1[i], m2 = list2[i];
     const NnetComputation::MatrixInfo
         &matrix_info1 = computation.matrices[m1],
         &matrix_info2 = computation.matrices[m2];
     KALDI_ASSERT(matrix_info1.num_rows == matrix_info2.num_rows &&
                  matrix_info1.num_cols == matrix_info2.num_cols &&
                  matrix_info1.stride_type == matrix_info2.stride_type);
     const NnetComputation::MatrixDebugInfo
         &debug_info1 = computation.matrix_debug_info[m1],
         &debug_info2 = computation.matrix_debug_info[m2];
     KALDI_ASSERT(debug_info1.is_deriv == debug_info2.is_deriv);
     KALDI_ASSERT(debug_info1.cindexes.size() == debug_info2.cindexes.size());
     std::vector<Cindex>::const_iterator iter1 = debug_info1.cindexes.begin(),
         end1 = debug_info1.cindexes.end(),
         iter2 = debug_info2.cindexes.begin();
     for (; iter1 != end1; iter1++,iter2++) {
       KALDI_ASSERT(iter2->first == iter1->first &&
                    iter2->second.n == iter1->second.n &&
                    ((iter1->second.t == kNoTime && iter2->second.t == kNoTime) ||
                     iter2->second.t == iter1->second.t + time_difference) &&
                    iter2->second.x == iter1->second.x);
     }
   }
 }

◆ ConvertListsToPairLists()

void ConvertListsToPairLists	(	const std::vector< std::vector< int32 > > &	active_matrices,
		const std::vector< std::pair< int32, int32 > > &	matrix_to_pair,
		std::vector< std::vector< std::pair< int32, int32 > > > *	active_pairs
	)

staticprivate

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

References KALDI_ASSERT.

                                                                    {
   active_pairs->clear();
   active_pairs->resize(active_matrices.size());
   int32 num_matrices = matrix_to_pair.size();
   for (size_t seg = 0; seg < active_matrices.size(); seg++) {
     const std::vector<int32> &this_active_matrix_list = active_matrices[seg];
     std::vector<std::pair<int32, int32> > &this_active_pair_list =
         (*active_pairs)[seg];
     this_active_pair_list.resize(this_active_matrix_list.size());
     std::vector<int32>::const_iterator iter = this_active_matrix_list.begin(),
         end = this_active_matrix_list.end();
     std::vector<std::pair<int32, int32> >::iterator
         out_iter = this_active_pair_list.begin();
     for (; iter != end; ++iter, ++out_iter) {
       KALDI_ASSERT(*iter > 0 && *iter < num_matrices);
       *out_iter = matrix_to_pair[*iter];
     }
   }
 }

◆ CreateMatrixPairs()

void CreateMatrixPairs	(	const NnetComputation &	computation,
		std::vector< std::pair< int32, int32 > > *	matrix_to_pair
	)

staticprivate

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

References KALDI_ASSERT, NnetComputation::matrices, and NnetComputation::matrix_debug_info.

                                                        {
   typedef unordered_map<std::vector<Cindex>, int32,
                         CindexVectorHasher> MapType;
   int32 cur_vector_id = 1;
   // Note: cindex_map just maps the vector<Cindex> to a unique value,
   // and then we manually work out a unique id that takes into
   // account the 'is_deriv' values.
   MapType cindex_map;
   int32 num_matrices = computation.matrices.size();
   matrix_to_pair->resize(num_matrices);
   KALDI_ASSERT(computation.matrix_debug_info.size() == num_matrices);
   for (int32 m = 1; m < num_matrices; m++) {
     KALDI_ASSERT(!computation.matrix_debug_info[m].cindexes.empty());
     std::vector<Cindex> cindexes = computation.matrix_debug_info[m].cindexes;
     int32 t_offset = NormalizeCindexes(&cindexes);
     MapType::const_iterator iter = cindex_map.find(cindexes);
     int32 vector_id;
     if (iter != cindex_map.end()) {
       vector_id = iter->second;
     } else {
       vector_id = cur_vector_id++;
       cindex_map[cindexes] = vector_id;
     }
     bool is_deriv = computation.matrix_debug_info[m].is_deriv;
     int32 unique_id = 2 * vector_id + (is_deriv ? 1 : 0);
     (*matrix_to_pair)[m].first = unique_id;
     (*matrix_to_pair)[m].second = t_offset;
   }
 }

◆ FindActiveMatrices()

void FindActiveMatrices	(	const NnetComputation &	computation,
		const Analyzer &	analyzer,
		const std::vector< int32 > &	splice_point_commands,
		std::vector< std::vector< int32 > > *	active_matrices
	)

staticprivate

Given a list of command indexes ('splice_point_commands') which are expected to be command indexes of the kNoOperationMarker at segment boundaries, this function outputs for each of these command indexes a list of matrices which are 'active' at that point in time.

By 'active' we mean that the matrix has been written to before that time (including zeroing), and will be read after that time. These is the list of matrices that 'need to be in scope' at those points in time. '*active_matrices' is indexed by the same index as 'splice_point_commands', and is then a list of active matrices, in numerical order of matrix index. Note: for each i, (*active_matrices)[i] will be sorted and unique.

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

References ComputationAnalysis::FirstNontrivialAccess(), NnetComputation::GetWholeSubmatrices(), rnnlm::i, kaldi::IsSortedAndUniq(), KALDI_ASSERT, ComputationAnalysis::LastAccess(), and NnetComputation::matrices.

                                                    {
   int32 num_matrices = computation.matrices.size();
   int32 num_splice_points = splice_point_commands.size();
   active_matrices->clear();
   active_matrices->resize(num_splice_points);
   // this object just makes available some extra functions, vs. the Analyzer
   // object.
   ComputationAnalysis analysis(computation, analyzer);
   KALDI_ASSERT(IsSortedAndUniq(splice_point_commands));
 
   // the following vector gives us, for each matrix index, a submatrix index
   // that covers the whole of that matrix (needed by interface of 'analysis' object).
   std::vector<int32> whole_submatrices;
   computation.GetWholeSubmatrices(&whole_submatrices);
   for (int32 m = 1; m < num_matrices; m++) {
     // the following are command indexes, comparable with the indexes
     // in 'splice_point_commands'.
     int32 s = whole_submatrices[m],  // submatrix consisting of the whole of
                                      // 'm'.
         first_access = analysis.FirstNontrivialAccess(s),
         last_access = analysis.LastAccess(s);
     for (int32 i = 0; i < num_splice_points; i++) {
       int32 splice_point = splice_point_commands[i];
       if (first_access < splice_point && last_access > splice_point) {
         // If the block of time during which the matrix is accessed, includes
         // this command index, then the matrix is considered 'active' at this
         // time.
         (*active_matrices)[i].push_back(m);
       }
     }
   }
 }

◆ FindFirstRepeat()

bool FindFirstRepeat	(	const std::vector< std::vector< std::pair< int32, int32 > > > &	active_pairs,
		int32	time_shift_per_segment,
		int32 *	seg1,
		int32 *	seg2
	)

staticprivate

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

References KALDI_ASSERT.

                               {
   int32 num_segments = active_pairs.size();
   // This algorithm may seem like it would be very slow, but the number of
   // segments will normally be quite small (e.g. 10), and the comparison of
   // elements of 'active_pairs' should be fast in cases where they
   // differ.
   KALDI_ASSERT(num_segments >= 2);
 
   for (int32 s = 0; s < num_segments; s++) {
     for (int32 t = s + 1; t < num_segments; t++) {
       if (ListsAreEqualExceptForPossibleShift(active_pairs[s],
                                               active_pairs[t],
                                               (t - s) * time_shift_per_segment)) {
         *seg1 = s;
         *seg2 = t;
         return true;
       }
     }
   }
   return false;
 }

◆ FindTimeShift()

int32 FindTimeShift ( const NnetComputation & computation )

staticprivate

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

References NnetComputation::Command::arg1, NnetComputation::Command::arg2, NnetComputation::commands, kaldi::nnet3::GetCommandsOfType(), NnetComputation::IsWholeMatrix(), KALDI_ASSERT, KALDI_ERR, kaldi::nnet3::kNoOperationMarker, kaldi::nnet3::kProvideOutput, NnetComputation::matrices, NnetComputation::matrix_debug_info, and NnetComputation::submatrices.

                                         {
   std::vector<int32> segment_ends;
   GetCommandsOfType(computation, kNoOperationMarker, &segment_ends);
   KALDI_ASSERT(segment_ends.size() >= 3);
   // Ignore the first segment as it tends to be a special case
   // (it has more left context),
   int32 second_segment_begin = segment_ends[0],
       third_segment_begin = segment_ends[1],
       fourth_segment_begin = segment_ends[2];
   int32 first_output_command_seg2 = -1,
       first_output_command_seg3 = -1;
   for (int32 c = second_segment_begin; c < third_segment_begin; c++)
     if (computation.commands[c].command_type == kProvideOutput &&
         first_output_command_seg2 < 0)
       first_output_command_seg2 = c;
   for (int32 c = third_segment_begin; c < fourth_segment_begin; c++)
     if (computation.commands[c].command_type == kProvideOutput &&
         first_output_command_seg3 < 0)
       first_output_command_seg3 = c;
   if (first_output_command_seg2 < 0 ||
       first_output_command_seg3 < 0)
     KALDI_ERR << "Could not locate output commands for segments 2 and 3.";
   const NnetComputation::Command
       &command2 = computation.commands[first_output_command_seg2],
       &command3 = computation.commands[first_output_command_seg3];
   int32 seg2_node = command2.arg2, seg3_node = command3.arg2;
   KALDI_ASSERT(seg2_node == seg3_node);
   int32 seg2_submatrix = command2.arg1,
       seg3_submatrix = command3.arg1;
   KALDI_ASSERT(computation.IsWholeMatrix(seg2_submatrix) &&
                computation.IsWholeMatrix(seg3_submatrix));
   int32 seg2_matrix = computation.submatrices[seg2_submatrix].matrix_index,
       seg3_matrix = computation.submatrices[seg3_submatrix].matrix_index;
   KALDI_ASSERT(computation.matrices[seg2_matrix].num_rows ==
                computation.matrices[seg3_matrix].num_rows);
   KALDI_ASSERT(!computation.matrix_debug_info.empty());
   const NnetComputation::MatrixDebugInfo
       &debug_info2 = computation.matrix_debug_info[seg2_matrix],
       &debug_info3 = computation.matrix_debug_info[seg3_matrix];
   int32 t_offset = debug_info3.cindexes[0].second.t -
       debug_info2.cindexes[0].second.t;
   int32 num_rows = debug_info2.cindexes.size();
   for (int32 r = 0; r < num_rows; r++) {
     KALDI_ASSERT(debug_info3.cindexes[r].second.t ==
                  debug_info2.cindexes[r].second.t + t_offset);
   }
   return t_offset;
 }

◆ FormInfiniteLoop()

void FormInfiniteLoop	(	int32	command1,
		int32	command2,
		NnetComputation *	computation
	)

staticprivate

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

References NnetComputation::commands, KALDI_ASSERT, kaldi::nnet3::kGotoLabel, kaldi::nnet3::kNoOperationLabel, and kaldi::nnet3::kNoOperationPermanent.

                                   {
   KALDI_ASSERT(static_cast<int32>(computation->commands.size()) >=
                command2 + 1 && command1 < command2);
   KALDI_ASSERT(
       computation->commands[command1].command_type == kNoOperationPermanent &&
       computation->commands[command2].command_type == kNoOperationPermanent);
   // Remove any commands after 'command2'.
   computation->commands.resize(command2 + 1);
   computation->commands[command2].command_type = kGotoLabel;
   computation->commands[command2].arg1 = command1;
   NnetComputation::Command c(kNoOperationLabel);
   computation->commands.insert(computation->commands.begin() + command1,
                                c);
   // Now the kNoOperationLabel command is at position 'command1'.
 }

◆ GetIdentifiedMatrices()

void GetIdentifiedMatrices	(	const std::vector< std::pair< int32, int32 > > &	pair_list1,
		const std::vector< std::pair< int32, int32 > > &	pair_list2,
		const unordered_map< std::pair< int32, int32 >, int32, PairHasher< int32 > > &	pair_to_matrix,
		std::vector< int32 > *	matrix_list1,
		std::vector< int32 > *	matrix_list2
	)

staticprivate

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

References KALDI_ASSERT, and KALDI_ERR.

                                     {
   size_t size = pair_list1.size();
   KALDI_ASSERT(pair_list2.size() == size);
   matrix_list1->clear();
   matrix_list2->clear();
   matrix_list1->reserve(size);
   matrix_list2->reserve(size);
   std::vector<std::pair<int32, int32> >::const_iterator
       iter1 = pair_list1.begin(), end1 = pair_list1.end(),
       iter2 = pair_list2.begin();
   for (; iter1 != end1; ++iter1, ++iter2) {
     if (iter1->second == iter2->second)
       continue;
     // skip those that have no time shift, we won't have to do any swapping for
     // those.
     unordered_map<std::pair<int32, int32>, int32,
                   PairHasher<int32> >::const_iterator
         map_iter1 = pair_to_matrix.find(*iter1),
         map_iter2 = pair_to_matrix.find(*iter2);
     if (map_iter1 == pair_to_matrix.end() ||
         map_iter2 == pair_to_matrix.end())
       KALDI_ERR << "Could not find pair in map (code error)";
     matrix_list1->push_back(map_iter1->second);
     matrix_list2->push_back(map_iter2->second);
   }
 }

◆ GetMatrixSwapOrder()

void GetMatrixSwapOrder	(	const std::vector< int32 > &	matrices1,
		const std::vector< int32 > &	matrices2,
		std::vector< std::pair< int32, int32 > > *	swaps
	)

staticprivate

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

References rnnlm::i, and KALDI_ASSERT.

                                               {
   KALDI_ASSERT(matrices1.size() == matrices2.size());
   swaps->clear();
   int32 num_matrices = matrices1.size();
   std::vector<bool> processed(num_matrices, false);
   std::vector<int32> queue;
 
   // num_loops is just for infinite-loop detection.
   int32 num_loops = 0;
   for (; static_cast<int32>(swaps->size()) < num_matrices; num_loops++) {
     for (int32 i = 0; i < num_matrices; i++) {
       if (processed[i])
         continue;
       int32 m1 = matrices1[i], m2 = matrices2[i];
       std::vector<int32>::const_iterator iter =
           std::lower_bound(matrices2.begin(), matrices2.end(), m1);
       if (iter == matrices2.end() || *iter != m1) {
         // Matrix m1 does not appear in the list 'matrices2', so
         // we are safe to process it at any time.
         swaps->push_back(std::pair<int32,int32>(m1, m2));
         processed[i] = true;
       } else {
         int32 m1_pos_in_matrices2 = iter - matrices2.begin();
         if (processed[m1_pos_in_matrices2]) {
           // We're safe to do this swap now, because the matrix m1 has already
           // appeared on the RHS of a swap, and by this point has been
           // deallocated, in effect.
           swaps->push_back(std::pair<int32,int32>(m1, m2));
           processed[i] = true;
         }
         // else do nothing, we cannot process m1 yet because
         // at this point in the computation it is still allocated.
       }
     }
     // The following assert is to check that we don't loop infinitely.  We can
     // prove that infinite looping won't happen, after on proving that there can
     // be no cycles like (m1, m2), (m2, m3), (m3, m1) (the length of 3 is chosen
     // arbitrarily as an example).  If such a cycle existed, we can reach a
     // contradiction based on the time-index (t) of the first cindex in m1.
     // Define t1 = that time index, t2 the same for m2, t3 the same for m3.  The
     // existence of the three pairs [as pairs like (matrices1[i], matrices2[i])]
     // implies that t2 > t1, t3 > t2, and t1 > t3 respectively, but this is
     // impossible.
     // This shows that all chains of dependencies must terminate.
     KALDI_ASSERT(num_loops <= num_matrices);
   }
 }

◆ GetPairToMatrixMap()

void GetPairToMatrixMap	(	std::vector< std::pair< int32, int32 > > &	matrix_to_pair,
		unordered_map< std::pair< int32, int32 >, int32, PairHasher< int32 > > *	pair_to_matrix
	)

staticprivate

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

                                                                                        {
   int32 num_matrices = matrix_to_pair.size();
   // actually there are one fewer matrices than num_matrices.
   pair_to_matrix->clear();
   for (int32 m = 1; m < num_matrices; m++)
     (*pair_to_matrix)[matrix_to_pair[m]] = m;
 }

◆ ListsAreEqualExceptForPossibleShift()

bool ListsAreEqualExceptForPossibleShift	(	const std::vector< std::pair< int32, int32 > > &	a,
		const std::vector< std::pair< int32, int32 > > &	b,
		int32	shift
	)

staticprivate

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

References rnnlm::i.

                  {
   size_t size = a.size();
   if (b.size() != size)
     return false;
   for (size_t i = 0; i < size; i++) {
     const std::pair<int32, int32> &p1 = a[i],
         &p2 = b[i];
     if (p1.first != p2.first)
       return false;
     if (p2.second != p1.second + shift && p2.second != p1.second)
       return false;
   }
   return true;
 }

◆ NormalizeCindexes()

int32 NormalizeCindexes ( std::vector< Cindex > * cindexes )

inlinestaticprivate

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

References KALDI_ERR, and kaldi::nnet3::kNoTime.

                                  {
   std::vector<Cindex>::iterator iter = cindexes->begin(),
       end = cindexes->end();
   int32 ans;
   for (; iter != end; iter++) {
     if (iter->second.t != kNoTime) {
       ans = iter->second.t;
       break;
     }
   }
   if (iter == end) {
     // this should not happen.
     KALDI_ERR << "All t values are kNoTime in matrix.";
   }
   iter = cindexes->begin();
   for (; iter != end; iter++)
     if (iter->second.t != kNoTime)
       iter->second.t -= ans;
   return ans;
 }

◆ Optimize()

bool Optimize ( )

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

References DerivativeTimeLimiter::computation_, kaldi::nnet3::FixGotoLabel(), kaldi::nnet3::GetCommandsOfType(), KALDI_ASSERT, KALDI_VLOG, kaldi::nnet3::kNoOperationPermanent, NnetComputation::matrix_debug_info, DerivativeTimeLimiter::nnet_, and kaldi::nnet3::RenumberComputation().

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

                                           {
   analyzer_.Init(nnet_, *computation_);
   KALDI_ASSERT(!computation_->matrix_debug_info.empty() &&
                "You must request matrix debug info when compiling "
                "looped computations.");
 
   // get the indexes of potential splice points, one per segment of the
   // computation.  We locate the splice points where kNoOperationPermanent is.
   // This is guaranteed to be after the inputs have been received, and before
   // the bulk of the computation in the segment, and of course before we provide
   // the output.  It happens that by choosing this as the splice point we avoid
   // certain problems that would arise, for instance, if we chose the segment
   // boundaries (kNoOperationMarker).
   std::vector<int32> splice_points;
   GetCommandsOfType(*computation_, kNoOperationPermanent,
                     &splice_points);
   int32 time_shift_per_segment = FindTimeShift(*computation_);
 
 
   std::vector<std::vector<int32> > active_matrices;
   // Find the list of matrices active at each of the potential splice points.
   FindActiveMatrices(*computation_, analyzer_, splice_points,
                      &active_matrices);
 
   // Find a representation of the matrices of the computation as pairs
   // (unique_id, time_offset) that are more amenable to finding
   // matrices that represet lists of Cindexes that differ only by
   // a time offset.
   std::vector<std::pair<int32, int32> > matrix_to_pair;
   CreateMatrixPairs(*computation_, &matrix_to_pair);
 
   // Create the reverse map from pair to matrix index; we'll need it later.
   unordered_map<std::pair<int32, int32>, int32, PairHasher<int32> > pair_to_matrix;
   GetPairToMatrixMap(matrix_to_pair, &pair_to_matrix);
 
   // get lists of matrix per splice-point in the pair representation.
   std::vector<std::vector<std::pair<int32, int32> > > pair_lists;
   ConvertListsToPairLists(active_matrices, matrix_to_pair,
                           &pair_lists);
 
   // Note: seg1 and seg2 are indexes into 'splice_points', representing
   // potential splice points (located near the beginnings of segments).
   int32 seg1, seg2;
   if (!FindFirstRepeat(pair_lists,
                        time_shift_per_segment,
                        &seg1, &seg2)) {
     KALDI_VLOG(2) << "Could not find repeats of variables.";
     return false;
   }
 
   std::vector<int32> seg1_matrices, seg2_matrices;
   GetIdentifiedMatrices(pair_lists[seg1], pair_lists[seg2],
                         pair_to_matrix,
                         &seg1_matrices, &seg2_matrices);
 
   int32 time_difference = time_shift_per_segment * (seg2 - seg1);
   CheckIdentifiedMatrices(*computation_, seg1_matrices, seg2_matrices,
                           time_difference);
 
   FormInfiniteLoop(splice_points[seg1], splice_points[seg2], computation_);
 
   AddMatrixSwapCommands(seg1_matrices, seg2_matrices, computation_);
 
   RenumberComputation(computation_);
 
   FixGotoLabel(computation_);
 
   return true;
 }

Member Data Documentation

◆ analyzer_

Analyzer analyzer_

private

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

◆ computation_

NnetComputation* computation_

private

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

◆ matrix_to_pair_

std::vector<std::pair<int32, int32> > matrix_to_pair_

private

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

◆ nnet_

const Nnet& nnet_

private

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

◆ splice_point_commands_

std::vector<int32> splice_point_commands_

private

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

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

nnet3/nnet-optimize-utils.cc

Public Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ComputationLoopedOptimizer()

Member Function Documentation

◆ AddMatrixSwapCommands()

◆ CheckIdentifiedMatrices()

◆ ConvertListsToPairLists()

◆ CreateMatrixPairs()

◆ FindActiveMatrices()

◆ FindFirstRepeat()

◆ FindTimeShift()

◆ FormInfiniteLoop()

◆ GetIdentifiedMatrices()

◆ GetMatrixSwapOrder()

◆ GetPairToMatrixMap()

◆ ListsAreEqualExceptForPossibleShift()

◆ NormalizeCindexes()

◆ Optimize()

Member Data Documentation

◆ analyzer_

◆ computation_

◆ matrix_to_pair_

◆ nnet_

◆ splice_point_commands_