LBFGS-Lite

https://github.com/zju-fast-lab/lbfgs-lite
Admin
LBFGS-Lite is a header-only C++ library for unconstrained optimization, implementing the...
Tokens:6,384
Snippets:20
Trust Score:7.7
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Configure L-BFGS Optimization Parameters (C++)

Source: https://context7.com/zju-fast-lab/lbfgs-lite/llms.txt

This snippet illustrates how to configure the `lbfgs::lbfgs_parameter_t` struct to control the L-BFGS optimization process. It covers settings for memory size, convergence criteria, line search, and advanced parameters. The example shows default initialization and modification of parameters for specific use cases, such as nonsmooth functions.

```cpp
#include "lbfgs.hpp"

int main()
{
    // Create parameter struct with default values
    lbfgs::lbfgs_parameter_t params;

    // Memory configuration
    params.mem_size = 8;              // Number of corrections (3-20 recommended)

    // Convergence criteria
    params.g_epsilon = 1.0e-5;        // Gradient norm threshold (set to 0.0 for nonsmooth)
    params.past = 3;                  // Iterations for delta-based test
    params.delta = 1.0e-6;            // Minimum cost decrease rate
    params.max_iterations = 0;        // Maximum iterations (0 = unlimited)

    // Line search parameters
    params.max_linesearch = 64;       // Maximum line search evaluations
    params.min_step = 1.0e-20;        // Minimum step size
    params.max_step = 1.0e+20;        // Maximum step size
    params.f_dec_coeff = 1.0e-4;      // Armijo condition coefficient
    params.s_curv_coeff = 0.9;        // Weak Wolfe condition coefficient

    // Advanced parameters
    params.cautious_factor = 1.0e-6;  // Global convergence factor for nonconvex
    params.machine_prec = 1.0e-16;    // Machine precision

    // For nonsmooth functions, disable gradient test
    params.g_epsilon = 0.0;
    params.past = 5;
    params.delta = 1.0e-8;

    // Use configured parameters in optimization
    Eigen::VectorXd x(10);
    double cost;
    // ... initialize x and call lbfgs_optimize with params ...

    return 0;
}
```

--------------------------------

### Step Bound Callback for Box Constraints in C++

Source: https://context7.com/zju-fast-lab/lbfgs-lite/llms.txt

Implements a step bound callback function to enforce box constraints during L-BFGS optimization. It calculates the maximum feasible step size in each dimension and returns 95% of the minimum to maintain safety. This example uses Eigen for vector operations and demonstrates its integration within the lbfgs_optimize function.

```cpp
#include "lbfgs.hpp"
#include <Eigen/Eigen>
#include <iostream>
#include <cmath>

// Step bound callback for box constraints: x in [lower, upper]
struct BoxConstraints
{
    Eigen::VectorXd lower;
    Eigen::VectorXd upper;
};

double stepbound_callback(void *instance,
                          const Eigen::VectorXd &xp,
                          const Eigen::VectorXd &d)
{
    BoxConstraints *box = static_cast<BoxConstraints*>(instance);

    double max_step = 1.0e20;

    // For each dimension, compute maximum feasible step
    for (int i = 0; i < xp.size(); ++i)
    {
        if (d(i) > 1.0e-10)
        {
            // Moving towards upper bound
            double step_to_bound = (box->upper(i) - xp(i)) / d(i);
            max_step = std::min(max_step, step_to_bound);
        }
        else if (d(i) < -1.0e-10)
        {
            // Moving towards lower bound
            double step_to_bound = (box->lower(i) - xp(i)) / d(i);
            max_step = std::min(max_step, step_to_bound);
        }
    }

    // Return 95% of max step for safety margin
    return 0.95 * max_step;
}

// Cost function for constrained optimization
double constrained_cost(void *instance,
                        const Eigen::VectorXd &x,
                        Eigen::VectorXd &g)
{
    // Simple quadratic with minimum at (2, 2, 2)
    Eigen::VectorXd target = Eigen::VectorXd::Constant(x.size(), 2.0);
    g = 2.0 * (x - target);
    return (x - target).squaredNorm();
}

int main()
{
    const int N = 3;

    // Define box constraints: x in [0, 5]
    BoxConstraints box;
    box.lower = Eigen::VectorXd::Zero(N);
    box.upper = Eigen::VectorXd::Constant(N, 5.0);

    // Start outside optimal point but within bounds
    Eigen::VectorXd x = Eigen::VectorXd::Constant(N, 0.5);
    double finalCost;

    lbfgs::lbfgs_parameter_t params;
    params.g_epsilon = 1.0e-6;

    int ret = lbfgs::lbfgs_optimize(
        x,
        finalCost,
        constrained_cost,
        stepbound_callback,  // Step bound callback
        nullptr,
        &box,                // Pass constraint data
        params
    );

    std::cout << "Status: " << lbfgs::lbfgs_strerror(ret) << std::endl;
    std::cout << "Solution: " << x.transpose() << std::endl;
    std::cout << "Final cost: " << finalCost << std::endl;
    // Expected: x ≈ [2, 2, 2] (optimal point within bounds)

    return 0;
}

```

--------------------------------

### Error Message Conversion Utility in C++

Source: https://context7.com/zju-fast-lab/lbfgs-lite/llms.txt

Demonstrates the use of the `lbfgs_strerror` function to convert numeric optimization return codes into human-readable error messages. This is crucial for debugging and understanding the outcome of the optimization process. The example shows how to handle various success and failure codes.

```cpp
#include "lbfgs.hpp"
#include <iostream>

// Example demonstrating error handling
double simple_cost(void *instance,
                   const Eigen::VectorXd &x,
                   Eigen::VectorXd &g)
{
    g = 2.0 * x;
    return x.squaredNorm();
}

void run_optimization_with_error_handling()
{
    Eigen::VectorXd x(5);
    x << 1.0, 2.0, 3.0, 4.0, 5.0;
    double finalCost;

    lbfgs::lbfgs_parameter_t params;
    params.max_iterations = 50;
    params.g_epsilon = 1.0e-6;

    // Run optimization
    int ret = lbfgs::lbfgs_optimize(
        x,
        finalCost,
        simple_cost,
        nullptr,
        nullptr,
        nullptr,
        params
    );

    // Handle different return codes
    std::cout << "Return code: " << ret << std::endl;
    std::cout << "Message: " << lbfgs::lbfgs_strerror(ret) << std::endl;

    if (ret == lbfgs::LBFGS_CONVERGENCE)
    {
        std::cout << "SUCCESS: Optimization converged!" << std::endl;
        std::cout << "Final cost: " << finalCost << std::endl;
        std::cout << "Solution: " << x.transpose() << std::endl;
    }
    else if (ret == lbfgs::LBFGS_STOP)
    {
        std::cout << "SUCCESS: Stopping criteria met" << std::endl;
    }
    else if (ret == lbfgs::LBFGSERR_MAXIMUMITERATION)
    {
        std::cout << "WARNING: Maximum iterations reached" << std::endl;
        std::cout << "Current best cost: " << finalCost << std::endl;
    }
    else if (ret < 0)
    {
        std::cerr << "ERROR: Optimization failed" << std::endl;
        std::cerr << "Error description: " << lbfgs::lbfgs_strerror(ret) << std::endl;
    }
}

int main()
{
    try
    {
        run_optimization_with_error_handling();
    }
    catch (const std::exception &e)
    {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

```

--------------------------------

### Implement L-BFGS Progress Monitor Callback in C++

Source: https://context7.com/zju-fast-lab/lbfgs-lite/llms.txt

Implement the `progress_monitor` function to observe optimization progress. This callback receives iteration details such as the current variables `x`, gradient `g`, cost `fx`, step size, iteration count `k`, and line search evaluations `ls`. It returns an integer to control the optimization flow (0 to continue, non-zero to cancel).

```cpp
#include "lbfgs.hpp"
#include <iostream>
#include <iomanip>

// Progress monitoring callback
int progress_monitor(void *instance,
                     const Eigen::VectorXd &x,
                     const Eigen::VectorXd &g,
                     const double fx,
                     const double step,
                     const int k,
                     const int ls)
{
    std::cout << std::setprecision(6)
              << "Iter " << std::setw(4) << k
              << " | Cost: " << std::setw(12) << fx
              << " | ||g||_inf: " << std::setw(10) << g.cwiseAbs().maxCoeff()
              << " | Step: " << std::setw(10) << step
              << " | LS evals: " << ls
              << std::endl;

    // Return 0 to continue, non-zero to cancel
    if (fx < 1.0e-10)
    {
        std::cout << "Early termination: cost below threshold" << std::endl;
        return 1;  // Cancel optimization
    }

    return 0;  // Continue optimization
}

// Simple quadratic cost function
double quadratic_cost(void *instance,
                      const Eigen::VectorXd &x,
                      Eigen::VectorXd &g)
{
    g = 2.0 * x;
    return x.squaredNorm();
}

int main()
{
    Eigen::VectorXd x = Eigen::VectorXd::Random(5) * 10.0;
    double finalCost;

    std::cout << "Starting L-BFGS optimization with progress monitoring:" << std::endl;
    std::cout << std::string(80, '-') << std::endl;

    lbfgs::lbfgs_parameter_t params;
    params.max_iterations = 100;

    int ret = lbfgs::lbfgs_optimize(
        x,
        finalCost,
        quadratic_cost,
        nullptr,
        progress_monitor,  // Progress callback
        nullptr,
        params
    );

    std::cout << std::string(80, '-') << std::endl;
    std::cout << "Status: " << lbfgs::lbfgs_strerror(ret) << std::endl;

    return 0;
}
```

--------------------------------

### C++ L-BFGS Optimization with Custom Class

Source: https://context7.com/zju-fast-lab/lbfgs-lite/llms.txt

This C++ code demonstrates how to use the L-BFGS optimizer within a class structure. It defines an `OptimizationProblem` class that manages the optimization state, objective function (Rosenbrock), and progress monitoring. The `lbfgs::lbfgs_optimize` function is called with static member function wrappers to interface with the class methods. It requires the L-BFGS library and Eigen for vector/matrix operations.

```cpp
#include "lbfgs.hpp"
#include <Eigen/Eigen>
#include <iostream>
#include <vector>
#include <cmath>

class OptimizationProblem
{
public:
    OptimizationProblem(int dim) : dimension(dim), iter_count(0)
    {
        x_opt = Eigen::VectorXd(dim);
        x_opt.setZero();
    }

    // Solve optimization problem
    int solve(const Eigen::VectorXd &x_init)
    {
        x_opt = x_init;
        iter_count = 0;
        cost_history.clear();

        // Configure parameters
        lbfgs::lbfgs_parameter_t params;
        params.mem_size = 8;
        params.g_epsilon = 1.0e-6;
        params.past = 3;
        params.delta = 1.0e-8;
        params.max_iterations = 200;

        // Run optimization
        int ret = lbfgs::lbfgs_optimize(
            x_opt,
            final_cost,
            &OptimizationProblem::evaluate,
            nullptr,
            &OptimizationProblem::monitor,
            this,
            params
        );

        return ret;
    }

    // Get results
    const Eigen::VectorXd& getSolution() const { return x_opt; }
    double getFinalCost() const { return final_cost; }
    const std::vector<double>& getCostHistory() const { return cost_history; }

private:
    int dimension;
    int iter_count;
    Eigen::VectorXd x_opt;
    double final_cost;
    std::vector<double> cost_history;

    // Static wrapper for cost function
    static double evaluate(void *instance,
                          const Eigen::VectorXd &x,
                          Eigen::VectorXd &g)
    {
        OptimizationProblem *self = static_cast<OptimizationProblem*>(instance);
        return self->computeCost(x, g);
    }

    // Actual cost computation (Rosenbrock function)
    double computeCost(const Eigen::VectorXd &x, Eigen::VectorXd &g)
    {
        const int n = x.size();
        double fx = 0.0;
        g.setZero();

        for (int i = 0; i < n - 1; ++i)
        {
            double t1 = 1.0 - x(i);
            double t2 = x(i + 1) - x(i) * x(i);

            g(i) += -2.0 * t1 - 400.0 * x(i) * t2;
            g(i + 1) += 200.0 * t2;

            fx += t1 * t1 + 100.0 * t2 * t2;
        }

        return fx;
    }

    // Static wrapper for progress monitor
    static int monitor(void *instance,
                      const Eigen::VectorXd &x,
                      const Eigen::VectorXd &g,
                      const double fx,
                      const double step,
                      const int k,
                      const int ls)
    {
        OptimizationProblem *self = static_cast<OptimizationProblem*>(instance);
        return self->monitorProgress(x, g, fx, step, k, ls);
    }

    // Actual progress monitoring
    int monitorProgress(const Eigen::VectorXd &x,
                       const Eigen::VectorXd &g,
                       double fx, double step, int k, int ls)
    {
        cost_history.push_back(fx);
        iter_count = k;

        if (k % 10 == 0)
        {
            std::cout << "Iter " << k << ": cost = " << fx
                     << ", ||g|| = " << g.norm() << std::endl;
        }

        return 0;  // Continue
    }
};

int main()
{
    // Create problem
    const int N = 10;
    OptimizationProblem problem(N);

    // Set initial guess
    Eigen::VectorXd x_init(N);
    for (int i = 0; i < N; i += 2)
    {
        x_init(i) = -1.2;
        x_init(i + 1) = 1.0;
    }

    std::cout << "Starting optimization..." << std::endl;

    // Solve
    int ret = problem.solve(x_init);

    // Display results
    std::cout << "\n" << std::string(60, '=') << std::endl;
    std::cout << "Optimization complete!" << std::endl;
    std::cout << "Status: " << lbfgs::lbfgs_strerror(ret) << std::endl;
    std::cout << "Final cost: " << problem.getFinalCost() << std::endl;
    std::cout << "Solution (first 5 elements): "
              << problem.getSolution().head(5).transpose() << std::endl;
    std::cout << "Total iterations: " << problem.getCostHistory().size() << std::endl;

    // Verify solution (should be close to all ones)
    Eigen::VectorXd expected = Eigen::VectorXd::Ones(N);
    double error = (problem.getSolution() - expected).norm();
    std::cout << "Error from expected solution: " << error << std::endl;

    return (ret >= 0) ? 0 : 1;
}

```

--------------------------------

### Perform L-BFGS Optimization with Rosenbrock Function (C++)

Source: https://context7.com/zju-fast-lab/lbfgs-lite/llms.txt

This snippet demonstrates the main `lbfgs_optimize` function for solving unconstrained optimization problems. It defines the Rosenbrock cost function and its gradient, sets up optimization parameters, and calls the L-BFGS solver. The output includes the optimization status, final cost, and the solution vector.

```cpp
#include "lbfgs.hpp"
#include <Eigen/Eigen>
#include <iostream>

// Define cost function: Rosenbrock function
double rosenbrock_cost(
    void *instance,
    const Eigen::VectorXd &x,
    Eigen::VectorXd &g)
{
    const int n = x.size();
    double fx = 0.0;

    for (int i = 0; i < n; i += 2)
    {
        const double t1 = 1.0 - x(i);
        const double t2 = 10.0 * (x(i + 1) - x(i) * x(i));

        // Compute gradient
        g(i + 1) = 20.0 * t2;
        g(i) = -2.0 * (x(i) * g(i + 1) + t1);

        // Compute cost
        fx += t1 * t1 + t2 * t2;
    }

    return fx;
}

int main()
{
    const int N = 10;
    Eigen::VectorXd x(N);
    double finalCost;

    // Set initial guess
    for (int i = 0; i < N; i += 2)
    {
        x(i) = -1.2;
        x(i + 1) = 1.0;
    }

    // Configure optimization parameters
    lbfgs::lbfgs_parameter_t params;
    params.mem_size = 8;          // Memory size for L-BFGS
    params.g_epsilon = 1.0e-8;    // Gradient convergence threshold
    params.past = 3;              // Iterations for delta test
    params.delta = 1.0e-8;        // Cost decrease threshold
    params.max_iterations = 1000; // Maximum iterations

    // Run optimization
    int ret = lbfgs::lbfgs_optimize(
        x,                 // Variable vector (input/output)
        finalCost,         // Final cost value (output)
        rosenbrock_cost,   // Cost function callback
        nullptr,           // Step bound callback (optional)
        nullptr,           // Progress monitor callback (optional)
        nullptr,           // User instance data
        params             // Optimization parameters
    );

    // Check result
    std::cout << "Status: " << lbfgs::lbfgs_strerror(ret) << std::endl;
    std::cout << "Final cost: " << finalCost << std::endl;
    std::cout << "Solution: " << x.transpose() << std::endl;

    return (ret == lbfgs::LBFGS_CONVERGENCE || ret == lbfgs::LBFGS_STOP) ? 0 : 1;
}
```

--------------------------------

### Implement L-BFGS Cost Function Callback in C++

Source: https://context7.com/zju-fast-lab/lbfgs-lite/llms.txt

Implement the `cost_callback` function to provide cost function values and gradient evaluations. This function takes a void pointer to user data, the current variable vector `x`, and a gradient vector `g` to be filled. It returns the computed cost value. Dependencies include Eigen for vector operations.

```cpp
#include "lbfgs.hpp"
#include <Eigen/Eigen>
#include <cmath>

// User-defined data structure
struct OptimizationProblem
{
    Eigen::VectorXd target;
    double weight;
};

// Cost function: weighted squared distance from target
double cost_callback(void *instance,
                     const Eigen::VectorXd &x,
                     Eigen::VectorXd &g)
{
    // Cast instance to user data type
    OptimizationProblem *problem = static_cast<OptimizationProblem*>(instance);

    // Compute residual
    Eigen::VectorXd residual = x - problem->target;

    // Compute gradient: g = 2 * weight * (x - target)
    g = 2.0 * problem->weight * residual;

    // Compute cost: f = weight * ||x - target||^2
    double fx = problem->weight * residual.squaredNorm();

    return fx;
}

int main()
{
    // Setup problem
    OptimizationProblem problem;
    problem.target = Eigen::VectorXd::Ones(5);
    problem.weight = 0.5;

    // Initial guess
    Eigen::VectorXd x = Eigen::VectorXd::Zero(5);
    double finalCost;

    // Optimize with user data
    lbfgs::lbfgs_parameter_t params;
    int ret = lbfgs::lbfgs_optimize(
        x,
        finalCost,
        cost_callback,
        nullptr,
        nullptr,
        &problem,  // Pass user data instance
        params
    );

    std::cout << "Optimized x: " << x.transpose() << std::endl;
    // Expected output: x ≈ [1, 1, 1, 1, 1]

    return 0;
}
```
Tokens:
Raw