internal/ceres/parameter_block_ordering.cc

   1 // Ceres Solver - A fast non-linear least squares minimizer
   2 // Copyright 2015 Google Inc. All rights reserved.
   3 // http://ceres-solver.org/
   4 //
   5 // Redistribution and use in source and binary forms, with or without
   6 // modification, are permitted provided that the following conditions are met:
   7 //
   8 // * Redistributions of source code must retain the above copyright notice,
   9 //   this list of conditions and the following disclaimer.
  10 // * Redistributions in binary form must reproduce the above copyright notice,
  11 //   this list of conditions and the following disclaimer in the documentation
  12 //   and/or other materials provided with the distribution.
  13 // * Neither the name of Google Inc. nor the names of its contributors may be
  14 //   used to endorse or promote products derived from this software without
  15 //   specific prior written permission.
  16 //
  17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  18 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  21 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  22 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  23 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  24 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  25 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  26 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  27 // POSSIBILITY OF SUCH DAMAGE.
  28 //
  29 // Author: sameeragarwal@google.com (Sameer Agarwal)
  30
  31 #include "ceres/parameter_block_ordering.h"
  32
  33 #include "ceres/graph.h"
  34 #include "ceres/graph_algorithms.h"
  35 #include "ceres/internal/scoped_ptr.h"
  36 #include "ceres/map_util.h"
  37 #include "ceres/parameter_block.h"
  38 #include "ceres/program.h"
  39 #include "ceres/residual_block.h"
  40 #include "ceres/wall_time.h"
  41 #include "glog/logging.h"
  42
  43 namespace ceres {
  44 namespace internal {
  45
  46 using std::map;
  47 using std::set;
  48 using std::vector;
  49
  50 int ComputeStableSchurOrdering(const Program& program,
  51                          vector<ParameterBlock*>* ordering) {
  52   CHECK_NOTNULL(ordering)->clear();
  53   EventLogger event_logger("ComputeStableSchurOrdering");
  54   scoped_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
  55   event_logger.AddEvent("CreateHessianGraph");
  56
  57   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
  58   const HashSet<ParameterBlock*>& vertices = graph->vertices();
  59   for (int i = 0; i < parameter_blocks.size(); ++i) {
  60     if (vertices.count(parameter_blocks[i]) > 0) {
  61       ordering->push_back(parameter_blocks[i]);
  62     }
  63   }
  64   event_logger.AddEvent("Preordering");
  65
  66   int independent_set_size = StableIndependentSetOrdering(*graph, ordering);
  67   event_logger.AddEvent("StableIndependentSet");
  68
  69   // Add the excluded blocks to back of the ordering vector.
  70   for (int i = 0; i < parameter_blocks.size(); ++i) {
  71     ParameterBlock* parameter_block = parameter_blocks[i];
  72     if (parameter_block->IsConstant()) {
  73       ordering->push_back(parameter_block);
  74     }
  75   }
  76   event_logger.AddEvent("ConstantParameterBlocks");
  77
  78   return independent_set_size;
  79 }
  80
  81 int ComputeSchurOrdering(const Program& program,
  82                          vector<ParameterBlock*>* ordering) {
  83   CHECK_NOTNULL(ordering)->clear();
  84
  85   scoped_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
  86   int independent_set_size = IndependentSetOrdering(*graph, ordering);
  87   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
  88
  89   // Add the excluded blocks to back of the ordering vector.
  90   for (int i = 0; i < parameter_blocks.size(); ++i) {
  91     ParameterBlock* parameter_block = parameter_blocks[i];
  92     if (parameter_block->IsConstant()) {
  93       ordering->push_back(parameter_block);
  94     }
  95   }
  96
  97   return independent_set_size;
  98 }
  99
 100 void ComputeRecursiveIndependentSetOrdering(const Program& program,
 101                                             ParameterBlockOrdering* ordering) {
 102   CHECK_NOTNULL(ordering)->Clear();
 103   const vector<ParameterBlock*> parameter_blocks = program.parameter_blocks();
 104   scoped_ptr<Graph< ParameterBlock*> > graph(CreateHessianGraph(program));
 105
 106   int num_covered = 0;
 107   int round = 0;
 108   while (num_covered < parameter_blocks.size()) {
 109     vector<ParameterBlock*> independent_set_ordering;
 110     const int independent_set_size =
 111         IndependentSetOrdering(*graph, &independent_set_ordering);
 112     for (int i = 0; i < independent_set_size; ++i) {
 113       ParameterBlock* parameter_block = independent_set_ordering[i];
 114       ordering->AddElementToGroup(parameter_block->mutable_user_state(), round);
 115       graph->RemoveVertex(parameter_block);
 116     }
 117     num_covered += independent_set_size;
 118     ++round;
 119   }
 120 }
 121
 122 Graph<ParameterBlock*>* CreateHessianGraph(const Program& program) {
 123   Graph<ParameterBlock*>* graph = CHECK_NOTNULL(new Graph<ParameterBlock*>);
 124   const vector<ParameterBlock*>& parameter_blocks = program.parameter_blocks();
 125   for (int i = 0; i < parameter_blocks.size(); ++i) {
 126     ParameterBlock* parameter_block = parameter_blocks[i];
 127     if (!parameter_block->IsConstant()) {
 128       graph->AddVertex(parameter_block);
 129     }
 130   }
 131
 132   const vector<ResidualBlock*>& residual_blocks = program.residual_blocks();
 133   for (int i = 0; i < residual_blocks.size(); ++i) {
 134     const ResidualBlock* residual_block = residual_blocks[i];
 135     const int num_parameter_blocks = residual_block->NumParameterBlocks();
 136     ParameterBlock* const* parameter_blocks =
 137         residual_block->parameter_blocks();
 138     for (int j = 0; j < num_parameter_blocks; ++j) {
 139       if (parameter_blocks[j]->IsConstant()) {
 140         continue;
 141       }
 142
 143       for (int k = j + 1; k < num_parameter_blocks; ++k) {
 144         if (parameter_blocks[k]->IsConstant()) {
 145           continue;
 146         }
 147
 148         graph->AddEdge(parameter_blocks[j], parameter_blocks[k]);
 149       }
 150     }
 151   }
 152
 153   return graph;
 154 }
 155
 156 void OrderingToGroupSizes(const ParameterBlockOrdering* ordering,
 157                           vector<int>* group_sizes) {
 158   CHECK_NOTNULL(group_sizes)->clear();
 159   if (ordering == NULL) {
 160     return;
 161   }
 162
 163   const map<int, set<double*> >& group_to_elements =
 164       ordering->group_to_elements();
 165   for (map<int, set<double*> >::const_iterator it = group_to_elements.begin();
 166        it != group_to_elements.end();
 167        ++it) {
 168     group_sizes->push_back(it->second.size());
 169   }
 170 }
 171
 172 }  // namespace internal
 173 }  // namespace ceres