How to estimate parameter uncertainty using Ceres Solver?

Question

I am using Ceres Solver to perform non-linear curve fits on small data sets. Following the examples I am able to generate perfectly reasonable fit parameters for models that match my data well. I am also trying to compute the parameter variances and this is where things are falling apart. The code executes but results seem incorrect, often many orders of magnitude larger than the the parameter itself. The number of points (x, y) in the data sets I am fitting is similar to the number of parameter in the fit models, e.g. 4 data points, 3 parameters.

I came across a similar SO question here: Ceres: Compute uncertainty on parameter, which was helpful in linking the Ceres wiki on using the covariance class, but the issue was not marked as resolved. I, like the previous poster, looked at the parameter variances produced using the Python lmfit (https://lmfit.github.io/lmfit-py/index.html) package and found that it provides much more reasonable results.

The Ceres description of the covariance class (http://ceres-solver.org/nnls_covariance.html#example-usage) described a potential issue where if the residuals of the cost functor are not scaled correctly, i.e. by the positive semi-definite covariance matrix of the observed data, then the parameter covariance matrix computation can't be trusted. Not being a mathematician, I am not certain how to satisfy this requirement.

Below is some sample code showing the cost function that I've implemented as well as the usage of the covariance class. Any advice would be greatly appreciated.

Cost function:

struct BiExponential1 {
BiExponential1( double x, double y, double s ) : x_( x ), y_( y ), s_( s ) {}
template <typename T>
bool operator()( const T* const a, const T* const b, const T* const c, T* residual ) const {
    residual[0] = y_ - a[0] * ( exp( -b[0] * x_ ) - exp( -c[0] * x_ ) ); // observed - estimated = y - ( a' [exp( -b' * x ) - exp(-c' * x)] )
    return true;
}
private:
    const double x_;
    const double y_;
};

Solver/Covariance usage:

    double a = init_value_a;
    double b = init_value_b;
    double c = init_value_c;

    double data_x[nData] = {<dummy data>}
    double data_y[nData] = {<dummy data>}

    for ( int i = 0; i < nData; ++i ) {
        problem.AddParameterBlock( &a, 1 );
        problem.AddParameterBlock( &b, 1 );
        problem.AddParameterBlock( &c, 1 );
        problem.AddResidualBlock(
            new ceres::AutoDiffCostFunction<BiExponential1, 1, 1, 1, 1>(
                new BiExponential1( data_x[i], data_y[i] ) ), 
            nullptr,
            &a,
            &b,
            &c );
    }

    // Run the solver and record the results.
    ceres::Solve( solverOptions, &problem, &summary );

    // Variance estimates
    // Code adapted from: http://ceres-solver.org/nnls_covariance.html#example-usage
    Covariance::Options covOptions;
    // TESTED non-default algorithm type - no effect.
    //covOptions.algorithm_type = ceres::CovarianceAlgorithmType::DENSE_SVD;
    Covariance covariance( covOptions );

    std::vector<std::pair<const double*, const double*> > covariance_blocks;
    covariance_blocks.push_back( std::make_pair( &a, &a ) );
    covariance_blocks.push_back( std::make_pair( &b, &b ) );
    covariance_blocks.push_back( std::make_pair( &c, &c ) );
    covariance_blocks.push_back( std::make_pair( &a, &b ) );
    covariance_blocks.push_back( std::make_pair( &a, &c ) );
    covariance_blocks.push_back( std::make_pair( &b, &c ) );

    CHECK( covariance.Compute( covariance_blocks, &problem ) );

    // Get the diagonal variance terms
    double covariance_aa[1 * 1];
    double covariance_bb[1 * 1];
    double covariance_cc[1 * 1];
    covariance.GetCovarianceBlock( &a, &a, covariance_aa );
    covariance.GetCovarianceBlock( &b, &b, covariance_bb );
    covariance.GetCovarianceBlock( &c, &c, covariance_cc );

How to estimate parameter uncertainty using Ceres Solver?

0 Answers0