GreedySampler.h

 
// Description: This class greedily selects parameter points
//              for the construction of a ROM database. The implemented
//              greedy algorithm is derived from algorithm 2 of Choi et. al's
//              paper "Gradient-based constrained optimization using a database
//              of linear reduced-order models": https://arxiv.org/abs/1506.07849
//
//              The greedy algorithm workflow is as follows:
//              1. Construct the GreedySampler by giving it a
//                 domain of parameter points.
//              2. Request a parameter point to create a local ROM at.
//              3. Request a parameter point to compute an error error indicator
//                 for using the nearest local ROM.
//              4. Give the computed error indicator to the GreedySampler.
//              5. Repeat steps 3 and 4 until the GreedySampler
//                 no longer requires more error indicators to be computed.
//              6. Repeat steps 2 to 5 until the GreedySampler
//                 no longer requires more local ROMs to be created.
//              7. The ROM database is now complete, meeting the error tolerance
//                 for all parameter points within the domain.
 
#ifndef included_GreedySampler_h
#define included_GreedySampler_h
 
#include "linalg/Vector.h"
#include <string>
#include <vector>
#include <set>
#include <random>
 
/* Use C++11 built-in shared pointers if available; else fallback to Boost. */
#if __cplusplus >= 201103L
#include <memory>
#else
#include <boost/shared_ptr.hpp>
#endif
 
namespace CAROM {
 
class Vector;
 
struct GreedyErrorIndicatorPoint {
 
    std::shared_ptr<Vector> point;
 
    std::shared_ptr<Vector> localROM;
};
 
class GreedySampler
{
public:
    GreedySampler(
        const std::vector<Vector> & parameter_points,
        bool check_local_rom,
        double relative_error_tolerance,
        double alpha,
        double max_clamp,
        int subset_size,
        int convergence_subset_size,
        std::string output_log_path = "",
        std::string warm_start_file_name = "",
        bool use_centroid = true,
        int random_seed = 1,
        bool debug_algorithm = false);
 
    GreedySampler(
        const std::vector<double> & parameter_points,
        bool check_local_rom,
        double relative_error_tolerance,
        double alpha,
        double max_clamp,
        int subset_size,
        int convergence_subset_size,
        std::string output_log_path = "",
        std::string warm_start_file_name = "",
        bool use_centroid = true,
        int random_seed = 1,
        bool debug_algorithm = false);
 
    GreedySampler(
        const Vector & param_space_min,
        const Vector & param_space_max,
        int num_parameter_points,
        bool check_local_rom,
        double relative_error_tolerance,
        double alpha,
        double max_clamp,
        int subset_size,
        int convergence_subset_size,
        std::string output_log_path = "",
        std::string warm_start_file_name = "",
        bool use_centroid = true,
        int random_seed = 1,
        bool debug_algorithm = false);
 
    GreedySampler(
        double param_space_min,
        double param_space_max,
        int num_parameter_points,
        bool check_local_rom,
        double relative_error_tolerance,
        double alpha,
        double max_clamp,
        int subset_size,
        int convergence_subset_size,
        std::string output_log_path = "",
        std::string warm_start_file_name = "",
        bool use_centroid = true,
        int random_seed = 1,
        bool debug_algorithm = false);
 
    GreedySampler(
        std::string base_file_name,
        std::string output_log_path = "");
 
    virtual ~GreedySampler();
 
    std::shared_ptr<Vector>
    getNextParameterPoint();
 
    GreedyErrorIndicatorPoint
    getNextPointRequiringRelativeError();
 
    GreedyErrorIndicatorPoint
    getNextPointRequiringErrorIndicator();
 
    void
    setPointRelativeError(double error);
 
    void
    setPointErrorIndicator(double error, int vec_size);
 
    int
    getNearestNonSampledPoint(const Vector & point);
 
    std::shared_ptr<Vector>
    getNearestROM(const Vector & point);
 
    std::vector<Vector>
    getParameterPointDomain();
 
    std::vector<Vector>
    getSampledParameterPoints();
 
    virtual void
    save(std::string base_file_name);
 
    bool
    isComplete();
 
protected:
 
    void addDatabaseFromFile(
        std::string const& warm_start_file_name);
 
    virtual void load(
        std::string base_file_name);
 
    virtual void constructParameterPoints() = 0;
 
    void checkParameterPointInput();
 
    void constructObject(
        bool check_local_rom,
        double relative_error_tolerance,
        double alpha,
        double max_clamp,
        int subset_size,
        int convergence_subset_size,
        std::string output_log_path,
        bool use_centroid,
        int random_seed,
        bool debug_algorithm);
 
    void initializeParameterPoints();
 
    GreedyErrorIndicatorPoint getNextSubsetPointRequiringErrorIndicator();
 
    GreedyErrorIndicatorPoint
    getNextConvergencePointRequiringErrorIndicator();
 
    std::vector<Vector> generateRandomPoints(int num_points);
 
    void agnosticPrint(std::string str);
 
    void printErrorIndicator(const Vector & errorIndicatorPoint,
                             double proc_errors);
 
    void printErrorIndicatorToleranceNotMet();
 
    void printSamplingType(std::string sampling_type);
 
    void printConvergenceAchieved();
 
    void setSubsetErrorIndicator(double proc_errors);
 
    void setConvergenceErrorIndicator(double proc_errors);
 
    void generateConvergenceSubset();
 
    void startConvergence();
 
    virtual void getNextParameterPointAfterConvergenceFailure() = 0;
 
    int
    getNearestROMIndexToParameterPoint(int index, bool ignore_self);
 
    std::vector<Vector> d_parameter_points;
 
    std::vector<Vector> d_convergence_points;
 
    Vector d_min_param_point;
 
    Vector d_max_param_point;
 
    std::set<int> d_parameter_sampled_indices;
 
    std::vector<int> d_parameter_point_random_indices;
 
    std::vector<double> d_parameter_point_errors;
 
    std::vector<int> d_parameter_point_local_rom;
 
    std::string d_output_log_path;
 
    double d_max_error;
 
    double d_curr_relative_error;
 
    double d_alpha;
 
    double d_max_clamp;
 
    double d_error_indicator_tol;
 
    double d_relative_error_tol;
 
    int d_num_parameter_points;
 
    int d_subset_size;
 
    int d_convergence_subset_size;
 
    int d_next_point_to_sample;
 
    int d_next_point_requiring_error_indicator;
 
    bool d_use_centroid;
 
    bool d_check_local_rom;
 
    bool d_iteration_started;
 
    bool d_convergence_started;
 
    bool d_next_parameter_point_computed;
 
    bool d_point_requiring_error_indicator_computed;
 
    bool d_subset_created;
 
    bool d_debug_algorithm;
 
    int d_counter;
 
    int d_subset_counter;
 
    bool d_procedure_completed;
 
    int d_rank;
 
    int d_random_seed;
 
    std::default_random_engine rng;
};
 
GreedyErrorIndicatorPoint createGreedyErrorIndicatorPoint(
    const std::shared_ptr<Vector> & point,
    const std::shared_ptr<Vector> & localROM);
 
Vector getNearestPoint(const std::vector<Vector> & paramPoints,
                       const Vector & point);
 
double getNearestPoint(const std::vector<double> & paramPoints, double point);
 
int getNearestPointIndex(const std::vector<Vector> & paramPoints,
                         Vector & point);
 
int getNearestPointIndex(const std::vector<double> & paramPoints, double point);
}
 
#endif