gd.h

Go to the documentation of this file.

 
#pragma once
#include <random>
 
#include "type.h"
 
namespace gymbo {
 
struct GDOptimizer {
    int num_epochs;    
    float lr;          
    float eps;         
    float param_low;   
    float param_high;  
    bool sign_grad;    
    bool init_param_uniform_int;  
    bool contain_randomized_vars;  
    int seed;          
    int num_used_itr;  
 
    GDOptimizer(int num_epochs = 100, float lr = 1.0, float eps = 1.0,
                float param_low = -10.0, float param_high = 10.0,
                bool sign_grad = true, bool init_param_uniform_int = true,
                int seed = 42)
        : num_epochs(num_epochs),
          lr(lr),
          eps(eps),
          param_low(param_low),
          param_high(param_high),
          sign_grad(sign_grad),
          init_param_uniform_int(init_param_uniform_int),
          seed(seed),
          num_used_itr(0) {}
 
    bool eval(std::vector<Sym> &path_constraints,
              std::unordered_map<int, float> params) {
        bool result = true;
        for (int i = 0; i < path_constraints.size(); i++) {
            result = result && (path_constraints[i].eval(params, eps) <= 0.0f);
        }
        return result;
    }
 
    bool solve(std::vector<Sym> &path_constraints,
               std::unordered_map<int, float> &params,
               bool is_init_params_const = true) {
        if (path_constraints.size() == 0) {
            return true;
        }
 
        std::mt19937 gen(seed);
        std::uniform_int_distribution<> idist(param_low, param_high);
        std::uniform_real_distribution<float> rdist(param_low, param_high);
 
        std::unordered_map<int, bool> is_const;
        std::unordered_set<int> unique_var_ids;
 
        for (int i = 0; i < path_constraints.size(); i++) {
            path_constraints[i].gather_var_ids(unique_var_ids);
        }
 
        for (int i : unique_var_ids) {
            if (params.find(i) == params.end()) {
                if (init_param_uniform_int) {
                    params.emplace(std::make_pair(i, idist(gen)));
                } else {
                    params.emplace(std::make_pair(i, rdist(gen)));
                }
                is_const.emplace(std::make_pair(i, false));
            } else {
                is_const.emplace(std::make_pair(i, is_init_params_const));
            }
        }
 
        int itr = 0;
        bool is_sat = eval(path_constraints, params);
        bool is_converge = false;
 
        while ((!is_sat) && (!is_converge) && (itr < num_epochs)) {
            Grad grads = Grad({});
            for (int i = 0; i < path_constraints.size(); i++) {
                if (path_constraints[i].eval(params, eps) > 0.0f) {
                    grads = grads + path_constraints[i].grad(params, eps);
                }
            }
            is_converge = true;
            for (auto &g : grads.val) {
                if (!is_const.at(g.first)) {
                    if (g.second != 0.0f) {
                        is_converge = false;
                    }
                    if (!sign_grad) {
                        params.at(g.first) -= lr * g.second;
                    } else {
                        float sign = 0.0f;
                        if (g.second > 0.0f) {
                            sign = 1.0;
                        } else if (g.second < 0.0f) {
                            sign = -1.0f;
                        }
                        params.at(g.first) -= lr * sign;
                    }
                }
            }
            is_sat = eval(path_constraints, params);
            itr++;
            num_used_itr++;
        }
        return is_sat;
    }
};
}  // namespace gymbo