Ceres学习笔记应用篇002_使用Ceres求解Powell方程

已于 2022-12-27 15:51:00 修改
阅读量387 收藏 4
点赞数
分类专栏： # Ceres 文章标签： 学习
于 2022-07-19 19:24:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37829462/article/details/125879004
版权
本文详细介绍了使用Ceres求解器解决Powell方程的方法，包括构建最小二乘问题和求解最小二乘问题的步骤。通过自定义残差计算模型，创建了不同结构的代价函数，如4个独立的1维代价函数或1个4维代价函数，并使用自动微分、数值微分和解析法计算导数。最终展示了各种实现方式下的优化过程和结果，所有实现均得到了接近零的最小值，验证了Ceres求解器的有效性。
摘要由CSDN通过智能技术生成

1 Powell方程

Powell方程如下：

F ( x ) = [ f 1 ( x ) , f 2 ( x ) , f 3 ( x ) , f 4 ( x ) ] F(x)=[f_1(x),f_2(x),f_3(x),f_4(x)] F(x)=[f1​(x),f2​(x),f3​(x),f4​(x)] （1）

其中：
{ f 1 ( x ) = x 1 + 10 ∗ x 2 f 2 ( x ) = 5 ∗ ( x 3 − x 4 ) f 3 ( x ) = ( x 2 − 2 ∗ x 3 ) 2 f 4 ( x ) = 10 ∗ ( x 1 − x 4 ) 2 \left\{\begin{matrix} \begin{aligned} &f_1(x)=x_1+10*x_2\\ &f_2(x)=\sqrt{5}*(x_3-x_4)\\ &f_3(x)=(x_2-2*x_3)^2\\ &f_4(x)=\sqrt{10}*(x_1-x_4)^2\\ \end{aligned} \end{matrix}\right. ⎩ ⎨ ⎧​​f1​(x)=x1​+10∗x2​f2​(x)=5 ​∗(x3​−x4​)f3​(x)=(x2​−2∗x3​)2f4​(x)=10 ​∗(x1​−x4​)2​​ （2）

Powell方程中，含有4个参数，4个残差项，目标是找到参数块 [ x 1 , x 2 , x 3 , x 4 ] [x_1,x_2,x_3,x_4] [x1​,x2​,x3​,x4​]，使得下式能够取得最小值（实际上一般是极小值）：
1 2 ∗ ∣ ∣ F ( x ) ∣ ∣ 2 = 1 2 ∗ ( ∣ ∣ f 1 ( x ) ∣ ∣ 2 + ∣ ∣ f 2 ( x ) ∣ ∣ 2 + ∣ ∣ f 3 ( x ) ∣ ∣ 2 + ∣ ∣ f 4 ( x ) ∣ ∣ 2 ) \frac{1}{2}*||F(x)||^2=\frac{1}{2}*(||f_1(x)||^2+||f_2(x)||^2+||f_3(x)||^2+||f_4(x)||^2) 21​∗∣∣F(x)∣∣2=21​∗(∣∣f1​(x)∣∣2+∣∣f2​(x)∣∣2+∣∣f3​(x)∣∣2+∣∣f4​(x)∣∣2) （3）

2 Ceres使用基本步骤

Ceres求解过程主要有两大步骤，构建最小二乘问题和求解最小二乘问题，具体步骤如下：
一、 构建最小二乘问题

  1. 用户自定义残差计算模型，可能存在多个；
  2. 构建Ceres代价函数（CostFuntion），将用户自定义残差计算模型添加至CostFuntion，可能存在多个CostFuntion，为每个CostFuntion添加用户自定义残差计算模型，并指定用户自定义残差计算模型的导数计算方法；
  3. 构建Ceres问题（Problem），并在Problem中添加残差块（ResidualBlock），可能存在多个ResidualBlock，为每个ResidualBlock指定CostFuntion，LossFuntion以及参数块（ParameterBlock）；

二、 求解最小二乘问题

  1. 配置求解器参数Options，即设置Problem求解方法及参数。例如迭代次数、步长等等；
  2. 输出日志内容Summary；
  3. 优化求解Solve。

构建最小二乘问题时的一些思考：

  1. 目标函数有4个维度，可以拆成4个代价函数，每1个代价函数包含1项残差；也可以合并成1个代价函数，包含4项残差；
  2. 有4个参数，可以拆成4个参数块，每个参数块包含1个参数；也可以合并成1个参数块，包含4个参数；
  3. 计算导数时，可以使用自动微分法、数值微分法、解析解法。

接下来将通过多种方式实现。

3 代码实现

3.1 cost4_x4_auto

  1. 4个代价函数，每个代价函数的输出残差维度为1；
  2. 4个参数块，每个参数块的输入参数维度为1；
  3. 导数计算采用自动微分。

完整代码如下：

#include "ceres/ceres.h"
#include "gflags/gflags.h"
#include "glog/logging.h"

// 用户自定义第1个维度的残差计算模型
// 输入2个参数块，每个参数块的维度为1
// 输出1个残差块，残差块的维度为1
struct F1 
{
    template <typename T>
    bool operator()(const T* const x1, const T* const x2, T* residual) const 
    {
        residual[0] = x1[0] + 10.0 * x2[0];
        return true;
    }
};

// 用户自定义第1个维度的残差计算模型
struct F2 
{
    template <typename T>
    bool operator()(const T* const x3, const T* const x4, T* residual) const 
    {
        residual[0] = sqrt(5.0) * (x3[0] - x4[0]);
        return true;
    }
};

// 用户自定义第1个维度的残差计算模型
struct F3 
{
    template <typename T>
    bool operator()(const T* const x2, const T* const x3, T* residual) const 
    {
        residual[0] = (x2[0] - 2.0 * x3[0]) * (x2[0] - 2.0 * x3[0]);
        return true;
    }
};

// 用户自定义第1个维度的残差计算模型
struct F4 
{
    template <typename T>
    bool operator()(const T* const x1, const T* const x4, T* residual) const 
    {
        residual[0] = sqrt(10.0) * (x1[0] - x4[0]) * (x1[0] - x4[0]);
        return true;
    }
};


int main(int argc, char** argv) {
    GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
    google::InitGoogleLogging(argv[0]);

    // 设置参数初始值，输入4个参数块，每个参数块的维度为1
    double x1 = 3.0;
    double x2 = -1.0;
    double x3 = 0.0;
    double x4 = 1.0;

    // 构建非线性最小二乘问题
    ceres::Problem problem;
    // 添加残差块，需要依次指定代价函数，损失函数，参数块
    // 本例中损失函数为单位函数，每个代价函数需要输入2个参数块
    problem.AddResidualBlock(
        new ceres::AutoDiffCostFunction<F1, 1, 1, 1>(new F1), NULL, &x1, &x2);
    problem.AddResidualBlock(
        new ceres::AutoDiffCostFunction<F2, 1, 1, 1>(new F2), NULL, &x3, &x4);
    problem.AddResidualBlock(
        new ceres::AutoDiffCostFunction<F3, 1, 1, 1>(new F3), NULL, &x2, &x3);
    problem.AddResidualBlock(
        new ceres::AutoDiffCostFunction<F4, 1, 1, 1>(new F4), NULL, &x1, &x4);

    // 配置求解器参数
    ceres::Solver::Options options;
    // 设置最大迭代次数
    options.max_num_iterations = 100;
    // 指定线性求解器来求解问题
    options.linear_solver_type = ceres::DENSE_QR;
    // 输出每次迭代的信息
    options.minimizer_progress_to_stdout = true;

    // 输出日志内容
    ceres::Solver::Summary summary;

    std::cout << "Initial x1 = " << x1
        << ", x2 = " << x2
        << ", x3 = " << x3
        << ", x4 = " << x4
        << "\n";

    // 开始优化求解
    ceres::Solve(options, &problem, &summary);

    // 输出优化过程及结果
    std::cout << summary.FullReport() << "\n";
    std::cout << "Final x1 = " << x1
        << ", x2 = " << x2
        << ", x3 = " << x3
        << ", x4 = " << x4
        << "\n";

    std::system("pause");
    return 0;
}

结果如下：

Initial x1 = 3, x2 = -1, x3 = 0, x4 = 1
iter      cost      cost_change  |gradient|   |step|    tr_ratio  tr_radius  ls_iter  iter_time  total_time
   0  1.075000e+02    0.00e+00    1.55e+02   0.00e+00   0.00e+00  1.00e+04        0    4.77e-04    1.01e-03
   1  5.036190e+00    1.02e+02    2.00e+01   2.16e+00   9.53e-01  3.00e+04        1    8.67e-04    2.00e-03
   2  3.148168e-01    4.72e+00    2.50e+00   6.23e-01   9.37e-01  9.00e+04        1    4.34e-04    2.50e-03
   3  1.967760e-02    2.95e-01    3.13e-01   3.08e-01   9.37e-01  2.70e+05        1    4.35e-04    3.06e-03
   4  1.229900e-03    1.84e-02    3.91e-02   1.54e-01   9.37e-01  8.10e+05        1    4.44e-04    3.56e-03
   5  7.687123e-05    1.15e-03    4.89e-03   7.69e-02   9.37e-01  2.43e+06        1    4.36e-04    4.06e-03
   6  4.804625e-06    7.21e-05    6.11e-04   3.85e-02   9.37e-01  7.29e+06        1    4.54e-04    4.56e-03
   7  3.003028e-07    4.50e-06    7.64e-05   1.92e-02   9.37e-01  2.19e+07        1    4.49e-04    5.07e-03
   8  1.877006e-08    2.82e-07    9.54e-06   9.62e-03   9.37e-01  6.56e+07        1    4.66e-04    5.60e-03
   9  1.173223e-09    1.76e-08    1.19e-06   4.81e-03   9.37e-01  1.97e+08        1    4.58e-04    6.11e-03
  10  7.333425e-11    1.10e-09    1.49e-07   2.40e-03   9.37e-01  5.90e+08        1    4.79e-04    6.65e-03
  11  4.584044e-12    6.88e-11    1.86e-08   1.20e-03   9.37e-01  1.77e+09        1    5.80e-04    7.34e-03
  12  2.865573e-13    4.30e-12    2.33e-09   6.02e-04   9.37e-01  5.31e+09        1    4.97e-04    7.92e-03
  13  1.791438e-14    2.69e-13    2.91e-10   3.01e-04   9.37e-01  1.59e+10        1    4.79e-04    8.46e-03
  14  1.120029e-15    1.68e-14    3.64e-11   1.51e-04   9.37e-01  4.78e+10        1    4.61e-04    8.99e-03

Solver Summary (v 2.0.0-eigen-(3.3.8)-no_lapack-eigensparse-no_openmp)

                                     Original                  Reduced
Parameter blocks                            4                        4
Parameters                                  4                        4
Residual blocks                             4                        4
Residuals                                   4                        4

Minimizer                        TRUST_REGION

Dense linear algebra library            EIGEN
Trust region strategy     LEVENBERG_MARQUARDT

                                        Given                     Used
Linear solver                        DENSE_QR                 DENSE_QR
Threads                                     1                        1
Linear solver ordering              AUTOMATIC                        4

Cost:
Initial                          1.075000e+02
Final                            1.120029e-15
Change                           1.075000e+02

Minimizer iterations                       15
Successful steps                           15
Unsuccessful steps                          0

Time (in seconds):
Preprocessor                         0.000534

  Residual only evaluation           0.000297 (14)
  Jacobian & residual evaluation     0.002385 (15)
  Linear solver                      0.003162 (14)
Minimizer                            0.008568

Postprocessor                        0.000036
Total                                0.009139

Termination:                      CONVERGENCE (Gradient tolerance reached. Gradient max norm: 3.642190e-11 <= 1.000000e-10)
Final x1 = 0.000146222, x2 = -1.46222e-05, x3 = 2.40957e-05, x4 = 2.40957e-05

根据优化结果，当 x 1 = x 2 = x 3 = x 4 = 0 x_1=x_2=x_3=x_4=0 x1​=x2​=x3​=x4​=0时，能够得到最小值。

3.2 cost1_x1_auto

  1. 1个代价函数，输出残差维度为4；
  2. 1个参数块，输入参数维度为4；
  3. 导数计算采用自动微分。

完整代码如下：

#include "ceres/ceres.h"
#include "gflags/gflags.h"
#include "glog/logging.h"

// 用户自定义残差计算模型
// 输入1个参数块，参数块维度为4
// 输出1个残差块，残差块的维度为4
struct F1234
{
    template <typename T>
    bool operator()(const T* const x, T* residual) const
    {
        residual[0] = x[0] + 10.0 * x[1];
        residual[1] = sqrt(5.0) * (x[2] - x[3]);
        residual[2] = (x[1] - 2.0 * x[2]) * (x[1] - 2.0 * x[2]);
        residual[3] = sqrt(10.0) * (x[0] - x[3]) * (x[0] - x[3]);
        return true;
    }
};

int main(int argc, char** argv) {
    GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
    google::InitGoogleLogging(argv[0]);

    // 设置参数初始值，输入1个参数块，参数块的维度为4
    double x1234[4] = { 3,-1,0,1 };

    // 构建非线性最小二乘问题
    ceres::Problem problem;
    // 添加残差块，需要依次指定代价函数，损失函数，参数块
    // 本例中损失函数为单位函数，代价函数需要输入1个参数块
    problem.AddResidualBlock(
        new ceres::AutoDiffCostFunction<F1234, 4, 4>(new F1234), NULL, x1234);

    // 配置求解器参数
    ceres::Solver::Options options;
    // 设置最大迭代次数
    options.max_num_iterations = 100;
    // 指定线性求解器来求解问题
    options.linear_solver_type = ceres::DENSE_QR;
    // 输出每次迭代的信息
    options.minimizer_progress_to_stdout = true;

    // 输出日志内容
    ceres::Solver::Summary summary;

    std::cout << "Initial x1 = " << x1234[0]
        << ", x2 = " << x1234[1]
        << ", x3 = " << x1234[2]
        << ", x4 = " << x1234[3]
        << "\n";

    // 开始优化求解
    ceres::Solve(options, &problem, &summary);

    // 输出优化过程及结果
    std::cout << summary.FullReport() << "\n";
    std::cout << "Final x1 = " << x1234[0]
        << ", x2 = " << x1234[1]
        << ", x3 = " << x1234[2]
        << ", x4 = " << x1234[3]
        << "\n";

    std::system("pause");
    return 0;
}

结果与之前的基本一致。

3.3 cost1_x4_auto

  1. 1个代价函数，输出残差维度为4；
  2. 4个参数块，每个参数块的输入参数维度为1；
  3. 导数计算采用自动微分。

完整代码如下：

#include "ceres/ceres.h"
#include "gflags/gflags.h"
#include "glog/logging.h"

// 用户自定义残差计算模型
// 输入1个参数块，参数块维度为4
// 输出1个残差块，残差块的维度为4
struct F1234
{
    template <typename T>
    bool operator()(const T* const x1, const T* const x2, 
        const T* const x3, const T* const x4, T* residual) const
    {
        residual[0] = x1[0] + 10.0 * x2[0];
        residual[1] = sqrt(5.0) * (x3[0] - x4[0]);
        residual[2] = (x2[0] - 2.0 * x3[0]) * (x2[0] - 2.0 * x3[0]);
        residual[3] = sqrt(10.0) * (x1[0] - x4[0]) * (x1[0] - x4[0]);
        return true;
    }
};

int main(int argc, char** argv) {
    GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
    google::InitGoogleLogging(argv[0]);

    // 设置参数初始值，输入4个参数块，每个参数块的维度为1
    double x1 = 3.0;
    double x2 = -1.0;
    double x3 = 0.0;
    double x4 = 1.0;

    // 构建非线性最小二乘问题
    ceres::Problem problem;
    // 添加残差块，需要依次指定代价函数，损失函数，参数块
    // 本例中损失函数为单位函数，代价函数需要输入4个参数块
    problem.AddResidualBlock(
        new ceres::AutoDiffCostFunction<F1234, 4, 1, 1, 1, 1>(new F1234), NULL, &x1, &x2, &x3, &x4);

    // 配置求解器参数
    ceres::Solver::Options options;
    // 设置最大迭代次数
    options.max_num_iterations = 100;
    // 指定线性求解器来求解问题
    options.linear_solver_type = ceres::DENSE_QR;
    // 输出每次迭代的信息
    options.minimizer_progress_to_stdout = true;

    // 输出日志内容
    ceres::Solver::Summary summary;

    std::cout << "Initial x1 = " << x1
        << ", x2 = " << x2
        << ", x3 = " << x3
        << ", x4 = " << x4
        << "\n";

    // 开始优化求解
    ceres::Solve(options, &problem, &summary);

    // 输出优化过程及结果
    std::cout << summary.FullReport() << "\n";
    std::cout << "Final x1 = " << x1
        << ", x2 = " << x2
        << ", x3 = " << x3
        << ", x4 = " << x4
        << "\n";

    std::system("pause");
    return 0;
}

同样，也可以按照cost4_x1_auto，cost2_x2_auto等多种方式实现，读者可举一反三，自行实现验证，关键是一定要确保ceres::AutoDiffCostFunction<>中，输出残差维度和输入每个参数块维度，要和用户自定义残差计算模型（或代价函数）中，输出残差维度和输入每个参数块维度保持一致（通俗但不严谨的讲，可以理解成x[]和residual[]的长度），否则很有可能无法迭代出正确结果。

另外，按照cost1_x1指定输入和输出的维度，分别通过数值法和解析解法求解Powell方程的最小值。

3.4 cost1_x1_numeric

  1. 1个代价函数，输出残差维度为4；
  2. 1个参数块，输入参数维度为4；
  3. 导数计算采用数值微分法。

完整代码如下：

#include "ceres/ceres.h"
#include "gflags/gflags.h"
#include "glog/logging.h"

// 用户自定义残差计算模型
// 输入1个参数块，参数块维度为4
// 输出1个残差块，残差块的维度为4
// 用户自定义残差计算模型
struct F1234
{
    bool operator()(const double* const x, double* residual) const
    {
        residual[0] = x[0] + 10.0 * x[1];
        residual[1] = sqrt(5.0) * (x[2] - x[3]);
        residual[2] = (x[1] - 2.0 * x[2]) * (x[1] - 2.0 * x[2]);
        residual[3] = sqrt(10.0) * (x[0] - x[3]) * (x[0] - x[3]);
        return true;
    }
};

int main(int argc, char** argv) {
    GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
    google::InitGoogleLogging(argv[0]);

    // 设置参数初始值，输入1个参数块，参数块的维度为4
    double x1234[4] = { 3,-1,0,1 };

    // 构建非线性最小二乘问题
    ceres::Problem problem;
    // 添加残差块，需要依次指定代价函数，损失函数，参数块
    // 本例中损失函数为单位函数，代价函数需要输入1个参数块
    // 本例中数值计算导数方法为CENTAL
    problem.AddResidualBlock(
        new ceres::NumericDiffCostFunction<F1234, ceres::CENTRAL, 4, 4>(new F1234), NULL, x1234);

    // 配置求解器参数
    ceres::Solver::Options options;
    // 设置最大迭代次数
    options.max_num_iterations = 100;
    // 指定线性求解器来求解问题
    options.linear_solver_type = ceres::DENSE_QR;
    // 输出每次迭代的信息
    options.minimizer_progress_to_stdout = true;

    // 输出日志内容
    ceres::Solver::Summary summary;

    std::cout << "Initial x1 = " << x1234[0]
        << ", x2 = " << x1234[1]
        << ", x3 = " << x1234[2]
        << ", x4 = " << x1234[3]
        << "\n";

    // 开始优化求解
    ceres::Solve(options, &problem, &summary);

    // 输出优化过程及结果
    std::cout << summary.FullReport() << "\n";
    std::cout << "Final x1 = " << x1234[0]
        << ", x2 = " << x1234[1]
        << ", x3 = " << x1234[2]
        << ", x4 = " << x1234[3]
        << "\n";

    std::system("pause");
    return 0;
}

3.5 cost1_x1_analytic

  1. 1个代价函数，输出残差维度为4；
  2. 1个参数块，输入参数维度为4；
  3. 导数计算采用解析法。

Ceres中，每个雅克比分量表示如下：

jacobian[i][r * parameters_block_size_[i] + c]= ∂ residual [ r ] ∂ parameters [ i ] [ c ] \frac{\partial\text{residual}[r]} {\partial\text{parameters}[i][c]} ∂parameters[i][c]∂residual[r]​ （4）

式中， i i i表示参数块索引， c c c表示某个参数块中的参数索引， r r r表示残差的索引。
由此可见，雅克比可以理解成是一个二维的数组，（不同于 C++中的二维数组，因为 C++中的二维数组列数都一样，类似于 std::vector<std::vector<double>>类型），是 double**类型，表示一个数组，数组中的每个元素也是数组，有几个参数块就有几行，每一行对应一个参数块，每行的列数为当前行参数块中参数的数量与残差维度的乘积。
对于本例，只有1个参数块，因此只有 jacobian[0]，残差的维度为4，参数块中参数数量为4，因此 jacobian[0]中共有 4*4个分量。

完整代码如下：

#include "ceres/ceres.h"
#include "gflags/gflags.h"
#include "glog/logging.h"

class CostFunction1234
    : public ceres::SizedCostFunction<4, /*输出（resudual）维度大小*/\
    4 /*输入参数块维度大小*/> 
{
public:
    virtual ~CostFunction1234() {}

    // 用户自定义残差计算方法
    virtual bool Evaluate(double const* const* x, /*输入参数块*/\
        double* residuals, /*输出残差*/\
        double** jacobians /*输出雅克比矩阵*/) const
    {
        // 本例中1个参数块中有4个输入参数
        double x1 = x[0][0];
        double x2 = x[0][1];
        double x3 = x[0][2];
        double x4 = x[0][3];

        // 本例中输出残差维度为4
        residuals[0] = x1 + 10.0 * x2;
        residuals[1] = sqrt(5.0) * (x3 - x4);
        residuals[2] = (x2 - 2.0 * x3) * (x2 - 2.0 * x3);
        residuals[3] = sqrt(10.0) * (x1 - x4) * (x1 - x4);

        if (jacobians != NULL && jacobians[0] != NULL) {
            // 第1个维度残差对参数块中的参数依次求偏导
            jacobians[0][0] = 1.0;
            jacobians[0][1] = 10.0;
            jacobians[0][2] = 0.0;
            jacobians[0][3] = 0.0;
            // 第2个维度残差对参数块中的参数依次求偏导
            jacobians[0][4] = 0.0;
            jacobians[0][5] = 0.0;
            jacobians[0][6] = sqrt(5.0);
            jacobians[0][7] = -sqrt(5.0);
            // 第3个维度残差对参数块中的参数依次求偏导
            jacobians[0][8] = 0.0;
            jacobians[0][9] = 2 * (x2 - 2 * x3);
            jacobians[0][10] = -4 * (x2 - 2 * x3);
            jacobians[0][11] = 0.0;
            // 第4个维度残差对参数块中的参数依次求偏导
            jacobians[0][12] = 2 * sqrt(10.0) * (x1 - x4);
            jacobians[0][13] = 0.0;
            jacobians[0][14] = 0.0;
            jacobians[0][15] = -2 * sqrt(10.0) * (x1 - x4);
        }
        return true;
    }
};

int main(int argc, char** argv) {
    GFLAGS_NAMESPACE::ParseCommandLineFlags(&argc, &argv, true);
    google::InitGoogleLogging(argv[0]);

    // 设置参数初始值，输入1个参数块，参数块的维度为4
    double x1234[4] = { 3,-1,0,1 };

    // 构建非线性最小二乘问题
    ceres::Problem problem;
    // 添加残差块，需要依次指定代价函数，损失函数，参数块
    // 本例中损失函数为单位函数，代价函数需要输入1个参数块
    problem.AddResidualBlock(
        new CostFunction1234, NULL, x1234);

    // 配置求解器参数
    ceres::Solver::Options options;
    // 设置最大迭代次数
    options.max_num_iterations = 100;
    // 指定线性求解器来求解问题
    options.linear_solver_type = ceres::DENSE_QR;
    // 输出每次迭代的信息
    options.minimizer_progress_to_stdout = true;

    // 输出日志内容
    ceres::Solver::Summary summary;

    std::cout << "Initial x1 = " << x1234[0]
        << ", x2 = " << x1234[1]
        << ", x3 = " << x1234[2]
        << ", x4 = " << x1234[3]
        << "\n";

    // 开始优化求解
    ceres::Solve(options, &problem, &summary);

    // 输出优化过程及结果
    std::cout << summary.FullReport() << "\n";
    std::cout << "Final x1 = " << x1234[0]
        << ", x2 = " << x1234[1]
        << ", x3 = " << x1234[2]
        << ", x4 = " << x1234[3]
        << "\n";

    std::system("pause");
    return 0;
    }
wang.chen.xue
关注
专栏目录
用Ceres-Solver求解非线性最小二乘问题
ruincity的专栏
12-30 2326
简介 Ceres-Solver是谷歌推出的开源C++库，用于求解优化问题。本文主要介绍用Ceres求解优化问题中最常见的最小二乘问题。参考 http://www.ceres-solver.org 中Tutorial: Non-linear Least Squares章节, Ceres版本为1.14. 最小二乘问题 从官方文档看，Ceres可以求解如下问题： x∗=arg min⁡x∑iρi(∣∣f......
Ceres-solver examples之pose_graph_3d学习笔记
幽冥小龙的博客
10-29 3541
Ceres-solver examples之pose_graph_3d学习笔记简要说明变量说明关键步骤一、Costfunction的搭建其中包括：二、构造Problem 简要说明 ceres-solver库是google的非线性优化库，可以对slam问题，机器人位姿进行优化，使其建图的效果得到改善。pose_graph_3d是官方给出的二维平面上机器人位姿优化问题，需要读取一个g2o文件，运行程序...
Ceres学习笔记003--使用Ceres进行曲线拟合
不学会C++不改名
11-02 1277
使用Ceres进行曲线拟合例程
Ceres学习笔记002--使用Ceres求解Powell方程
不学会C++不改名
11-02 376
本文将介绍如何使用Ceres构建最小二乘问题求解Powell方程
ceres求解非线性方程组
xinxiangwangzhi_的博客
01-08 1265
参考官网和一些文档试着写下以下非线性方程组求解 除了官网文档，以下文档也值得学习： 博客1 博客2 后方交会 使用 Ceres Solver 求解非线性优化问题，主要包括以下几部分： 【STEP 1】构建优化问题(ceres::Problem) 【STEP 2】构建代价函数(ceres::CostFunction) 或残差(residual) 【STEP 3】配置代价函数和损失函数(ceres::Problem::AddResidualBlock)：通过 AddResidualBlock 添加代价函数(co
Ceres求解最小二乘问题
qq_41537288的博客
03-13 343
待优化的函数是： y=ax2+bx+c y=ax^2+bx+c y=ax2+bx+c 采用自动求导与解析求导两种方式进行求解 自动求导： #include <iostream> #include <ceres/ceres.h> #include <opencv2/core/core.hpp> #include <vector> using namespace std; struct Curve_Factor { Curve_Fact
Ceres求解优化问题
最新发布
qq_20604231的博客
05-26 937
本文讲解了如何使用Ceres Solver求解一个最小二乘问题，并深入介绍了在SLAM领域中如何实现对位姿的优化，以及Ceres自动求导的原理。
Ceres Solver 官方教程学习笔记（三） ——鲍威尔方程Powell`s Function
小政哥的私房博客
03-26 3913
本节主要翻译自官方教程Powell’s Function（鲍威尔方程） 在这一节我们使用一个复杂一些的例子——求解鲍威尔方程的最小值。我们定义参数块x=[x1,x2,x3,x4]x=[x1,x2,x3,x4]x = \left[x_1, x_2, x_3, x_4 \right] 。以及代价函数如下： f1(x)f2(x)f3(x)f4(x)F(x)=x1+10x2=5–√(x3−...
ceres-hellow_ceres_TheTest_
09-29
本篇文章将深入探讨Ceres Solver的基本概念，以及如何通过"Hello Ceres - TheTest"这个例子来理解其工作原理。 Ceres Solver是由Google开发并维护的一个库，它提供了灵活且高效的工具，用于解决多维非线性最小二乘...
第三章作业代码及Ceres学习笔记-kaho1
08-03
【Ceres 求解器入门与自定义参数化】\n\nCeres求解器是一个强大的开源优化库，尤其适用于解决非线性最小二乘问题。在SLAM（Simultaneous Localization and Mapping）领域，它被广泛应用于曲线拟合和参数估计。本章节...
ceres非线性求解代码
09-23
ceres非线性问题求解器，解决SLAM，及方程求解，fitting等等问题
ceres的学习笔记
daxiang10m的博客
09-13 774
Ceres solver 是谷歌开发的一款用于非线性优化的库，在谷歌的开源激光雷达slam项目cartographer中被大量使用。本文参考官网教程，编译了静态库使用。
slam 基本算法 --- 使用【Ceres】进行slam中BA问题求解 （理论+实践）
CGJustDoIT的博客
09-11 2578
slam 基本算法 --- 使用【Ceres】进行slam中BA问题求解 （理论+实践）注1. 简要2. ceres求解关键步骤2.1 定义误差项结构2.2 构建 BA 问题2.3 配置求解器并求解3.3 代码实践 注 ceres 相比g2o 能自动对误差项关于优化变量的导数求导，简易方便很多； 后续再具体的原理，这里先暂时应用。 1. 简要 ceres 解BA 官方链接： http://www.ceres-solver.org/nnls_tutorial.html#bundle-adjustment B
【Ceres基本使用方法】使用Ceres拟合曲线求解最小二乘问题
个人博客
10-23 2396
Ceres是一个最小二乘问题求解库，我们只需要定义待优化的问题，然后交给它计算即可。 使用方法： 1. 定义每个参数块。参数块就是简单的向量，也可以是四元数、李代数等特殊的结构。 2. 定义残差块的计算方式。残差块对参数块进行自定义计算，返回残差值，然后求平方和作为目标函数的值。 3. 定义雅可比的计算方式。 4. 把所有的参数块和残差块加入Ceres定义的Problem对象中，调用Solve函数求解
Ceres求解非线性优化问题步骤与示例
叶子的博客
03-21 1370
Ceres求解非线性优化问题步骤与示例
Ceres求解直接法BA实现自动求导
3D视觉工坊
07-16 1950
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达BA，即Bundle Adjustment，通常译为光束法平差，束调整，捆绑调整等。但高翔博士觉得这些译名不如英文名称来得直观，所以...
利用ceres solver解大规模线性方程组
VisualMan_whu的专栏
12-03 6902
在工程应用中，最后要求解的线性方程组往往是原来的残差模型进行线性化后的误差方程。通常情况下，模型的线性化由人工完成，而求解误差方程则借助Eigen等矩阵运算库（参考1）来实现。现在，我们有了另一种选择，那就是ceres solver。ceres是Google公司用来解决非线性优化问题的开源库，主要是为了解决SFM问题中的光束法平差而设计的。与一般的矩阵运算库不同的是，我们只需要给ceres提供原始
ceres解析解数值解以及协方差
lovely_yoshino的博客
04-26 3717
0. 简介 ceres作为最常用的求解最小线性二乘的工具，常常被用于SLAM求解当中。最近想着如何确定每一个优化项的准确度对的问题。发现有一些之前忽略的知识没有谈及，这里也一并展开说一下。 1. 解析解与数值解 1.1 数值解(Numeric solution) 数值解，即采用某种计算方法，如有限元的方法，数值逼近，插值的方法，得到的解。当无法由微积分技巧求得解析解时，这时便只能利用数值分析的方法来求得其数值解了。在数值分析的过程中，首先会将原方程式加以简化，以利后来的数值分析。例如，会先将微分符号改为差分
Ceres实践
fb_help的专栏
07-08 294
Ceres实践 Ceres是最小二乘优化库．对于一个最小二乘优化问题，我们其实在求： min 0.5*||f(x)||2其中f(x)是残差z-f(x)或称之为代价函数再或称观测误差（无偏的假设下），f(x)可以是线性或非线性． 所以只需定义优化变量，和每个代价函数，再调用Ceres进行求解． 实例：取自（slambook) #include <iostream> #include &l...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值