Revert to a default GaussianProcessRansac which always accepts (#179)

the candidate (instead of doing a chi squared acceptance test)

Author: akleeman

include/albatross/src/core/declarations.hpp

@@ -133,8 +133,11 @@ template <typename InlierMetric, typename ConsensusMetric,
           typename IndexingFunction>
 struct GenericRansacStrategy;
 
+struct AlwaysAcceptCandidateMetric;
+
 template <typename InlierMetric, typename ConsensusMetric,
-          typename IndexingFunction>
+          typename IndexingFunction,
+          typename IsValidCandidateMetric = AlwaysAcceptCandidateMetric>
 struct GaussianProcessRansacStrategy;
 
 /*

include/albatross/src/models/ransac_gp.hpp

@@ -41,25 +41,18 @@ inline
   };
 }
 
-template <typename ModelType, typename FeatureType>
+template <typename ModelType, typename FeatureType,
+          typename IsValidCandidateMetric>
 inline typename RansacFunctions<
     FitAndIndices<ModelType, FeatureType>>::IsValidCandidate
 get_gp_ransac_is_valid_candidate(const RegressionDataset<FeatureType> &dataset,
                                  const FoldIndexer &indexer,
-                                 const Eigen::MatrixXd &cov) {
-  return [&, indexer, cov, dataset](const std::vector<FoldName> &groups) {
-    auto inds = indices_from_names(indexer, groups);
-    const auto train_dataset = subset(dataset, inds);
-    const auto train_cov = symmetric_subset(cov, inds);
+                                 const Eigen::MatrixXd &cov,
+                                 const IsValidCandidateMetric &metric) {
 
-    const JointDistribution prior(Eigen::VectorXd::Zero(train_cov.rows()),
-                                  train_cov);
-    // These thresholds are under the assumption of a perfectly
-    // representative prior.
-    const double probability_prior_exceeded =
-        chi_squared_cdf(prior, train_dataset.targets);
-    const double skip_every_1000th_candidate = 0.999;
-    return (probability_prior_exceeded < skip_every_1000th_candidate);
+  return [&, indexer, cov, dataset](const std::vector<FoldName> &groups) {
+    const auto inds = indices_from_names(indexer, groups);
+    return metric(inds, dataset, cov);
   };
 }
 
@@ -145,14 +138,43 @@ class ChiSquaredConsensusMetric {
   Eigen::MatrixXd cov_;
 };
 
+struct ChiSquaredIsValidCandidateMetric {
+
+  template <typename FeatureType>
+  bool operator()(const FoldIndices &inds,
+                  const RegressionDataset<FeatureType> &dataset,
+                  const Eigen::MatrixXd &cov) const {
+    const auto train_dataset = subset(dataset, inds);
+    const auto train_cov = symmetric_subset(cov, inds);
+
+    const JointDistribution prior(Eigen::VectorXd::Zero(train_cov.rows()),
+                                  train_cov);
+    // These thresholds are under the assumption of a perfectly
+    // representative prior.
+    const double probability_prior_exceeded =
+        chi_squared_cdf(prior, train_dataset.targets);
+    const double skip_every_1000th_candidate = 0.999;
+    return (probability_prior_exceeded < skip_every_1000th_candidate);
+  };
+};
+
+struct AlwaysAcceptCandidateMetric {
+  template <typename FeatureType>
+  bool operator()(const FoldIndices &inds,
+                  const RegressionDataset<FeatureType> &dataset,
+                  const Eigen::MatrixXd &cov) const {
+    return true;
+  }
+};
+
 template <typename ModelType, typename FeatureType, typename InlierMetric,
-          typename ConsensusMetric>
+          typename ConsensusMetric, typename IsValidCandidateMetric>
 inline RansacFunctions<FitAndIndices<ModelType, FeatureType>>
-get_gp_ransac_functions(const ModelType &model,
-                        const RegressionDataset<FeatureType> &dataset,
-                        const FoldIndexer &indexer,
-                        const InlierMetric &inlier_metric,
-                        const ConsensusMetric &consensus_metric) {
+get_gp_ransac_functions(
+    const ModelType &model, const RegressionDataset<FeatureType> &dataset,
+    const FoldIndexer &indexer, const InlierMetric &inlier_metric,
+    const ConsensusMetric &consensus_metric,
+    const IsValidCandidateMetric &is_valid_candidate_metric) {
 
   static_assert(is_prediction_metric<InlierMetric>::value,
                 "InlierMetric must be an PredictionMetric.");
@@ -170,16 +192,16 @@ get_gp_ransac_functions(const ModelType &model,
                                                     full_cov);
 
   const auto is_valid_candidate =
-      get_gp_ransac_is_valid_candidate<ModelType, FeatureType>(dataset, indexer,
-                                                               full_cov);
+      get_gp_ransac_is_valid_candidate<ModelType, FeatureType>(
+          dataset, indexer, full_cov, is_valid_candidate_metric);
 
   return RansacFunctions<FitAndIndices<ModelType, FeatureType>>(
       fitter, inlier_metric_from_group, consensus_metric_from_group,
       is_valid_candidate);
 };
 
 template <typename InlierMetric, typename ConsensusMetric,
-          typename IndexingFunction>
+          typename IndexingFunction, typename IsValidCandidateMetric>
 struct GaussianProcessRansacStrategy {
 
   GaussianProcessRansacStrategy() = default;
@@ -188,15 +210,15 @@ struct GaussianProcessRansacStrategy {
                                 const ConsensusMetric &consensus_metric,
                                 const IndexingFunction &indexing_function)
       : inlier_metric_(inlier_metric), consensus_metric_(consensus_metric),
-        indexing_function_(indexing_function){};
+        indexing_function_(indexing_function), is_valid_candidate_(){};
 
   template <typename ModelType, typename FeatureType>
   RansacFunctions<FitAndIndices<ModelType, FeatureType>>
   operator()(const ModelType &model,
              const RegressionDataset<FeatureType> &dataset) const {
     const auto indexer = get_indexer(dataset);
     return get_gp_ransac_functions(model, dataset, indexer, inlier_metric_,
-                                   consensus_metric_);
+                                   consensus_metric_, is_valid_candidate_);
   }
 
   template <typename FeatureType>
@@ -208,6 +230,7 @@ struct GaussianProcessRansacStrategy {
   InlierMetric inlier_metric_;
   ConsensusMetric consensus_metric_;
   IndexingFunction indexing_function_;
+  IsValidCandidateMetric is_valid_candidate_;
 };
 
 using DefaultGPRansacStrategy =

tests/test_models.h

@@ -164,8 +164,10 @@ struct AdaptedRansacStrategy : public GaussianProcessRansacStrategy<
         adapted::convert_features(dataset.features), dataset.targets);
     const auto indexer = get_indexer(converted);
     const FeatureCountConsensusMetric consensus_metric;
+    const AlwaysAcceptCandidateMetric always_accept;
     return get_gp_ransac_functions(model, converted, indexer,
-                                   this->inlier_metric_, consensus_metric);
+                                   this->inlier_metric_, consensus_metric,
+                                   always_accept);
   }
 };