Example usage for org.apache.commons.math3.fitting.leastsquares LeastSquaresBuilder checker

Introduction

In this page you can find the example usage for org.apache.commons.math3.fitting.leastsquares LeastSquaresBuilder checker.

Prototype

ConvergenceChecker checker

To view the source code for org.apache.commons.math3.fitting.leastsquares LeastSquaresBuilder checker.

Click Source Link

Document

convergence checker

Usage

From source file:de.bund.bfr.math.LeastSquaresOptimization.java

@Override
public Result optimize(int nParameterSpace, int nOptimizations, boolean stopWhenSuccessful,
        Map<String, Double> minStartValues, Map<String, Double> maxStartValues, int maxIterations,
        DoubleConsumer progressListener, ExecutionContext exec) throws CanceledExecutionException {
    if (exec != null) {
        exec.checkCanceled();//from w  ww.  ja  va2 s.com
    }

    progressListener.accept(0.0);

    List<ParamRange> ranges = MathUtils.getParamRanges(parameters, minStartValues, maxStartValues,
            nParameterSpace);
    RealVector targetVector = new ArrayRealVector(Doubles.toArray(targetValues));
    List<StartValues> startValuesList = MathUtils.createStartValuesList(ranges, nOptimizations,
            values -> targetVector
                    .getDistance(new ArrayRealVector(optimizerFunction.value(Doubles.toArray(values)))),
            progress -> progressListener.accept(0.5 * progress), exec);
    LevenbergMarquardtOptimizer optimizer = new LevenbergMarquardtOptimizer();
    Result result = new Result();
    AtomicInteger count = new AtomicInteger(0);

    for (StartValues startValues : startValuesList) {
        if (exec != null) {
            exec.checkCanceled();
        }

        progressListener.accept(0.5 * count.get() / startValuesList.size() + 0.5);

        try {
            LeastSquaresBuilder builder = createLeastSquaresBuilder(startValues.getValues(), maxIterations);

            builder.checker((iteration, previous, current) -> {
                double currentProgress = (double) iteration / (double) maxIterations;

                if (exec != null) {
                    try {
                        exec.checkCanceled();
                    } catch (CanceledExecutionException e) {
                        return true;
                    }
                }

                progressListener.accept(0.5 * (count.get() + currentProgress) / startValuesList.size() + 0.5);
                return iteration == maxIterations;
            });

            LeastSquaresOptimizer.Optimum optimizerResults = optimizer.optimize(builder.build());

            if (exec != null) {
                exec.checkCanceled();
            }

            double cost = optimizerResults.getCost();

            if (result.sse == null || cost * cost < result.sse) {
                result = getResults(optimizerResults);

                if (result.sse == 0.0) {
                    break;
                }

                if (result.r2 != null && result.r2 > 0.0 && stopWhenSuccessful) {
                    break;
                }
            }
        } catch (TooManyEvaluationsException | TooManyIterationsException | ConvergenceException e) {
        }

        count.incrementAndGet();
    }

    return result;
}

---

From source file:uk.ac.diamond.scisoft.analysis.optimize.ApacheOptimizer.java

/**
 * create a multivariateJacobianFunction from MVF and MMF (using builder?)
 * /*from   ww w.  j  a v a2 s .co m*/
 */
private void internalLeastSquaresOptimize() {
    LeastSquaresOptimizer opt = createLeastSquaresOptimizer();

    try {

        LeastSquaresBuilder builder = new LeastSquaresBuilder().model(createJacobianFunction())
                .target(data.getData()).start(getParameterValues()).lazyEvaluation(false)
                .maxEvaluations(MAX_EVAL).maxIterations(MAX_ITER);

        builder.checker(new EvaluationRmsChecker(REL_TOL, ABS_TOL));

        if (weight != null) {
            builder.weight(MatrixUtils.createRealDiagonalMatrix(weight.getData()));
        }

        // TODO add checker, validator
        LeastSquaresProblem problem = builder.build();

        Optimum result = opt.optimize(problem);

        RealVector res = result.getPoint();
        setParameterValues(
                res instanceof ArrayRealVector ? ((ArrayRealVector) res).getDataRef() : res.toArray());
        try {
            RealVector err = result.getSigma(1e-14);

            //            sqrt(S / (n - m) * C[i][i]);
            double c = result.getCost();
            int n = data.getSize();
            int m = getParameterValues().length;

            double[] s = err instanceof ArrayRealVector ? ((ArrayRealVector) err).getDataRef() : err.toArray();

            errors = new double[s.length];

            for (int i = 0; i < errors.length; i++)
                errors[i] = Math.sqrt(((c * c) / ((n - m)) * (s[i] * s[i])));

        } catch (SingularMatrixException e) {
            logger.warn("Could not find errors as covariance matrix was singular");
        }

        logger.trace("Residual: {} from {}", result.getRMS(), Math.sqrt(calculateResidual()));
    } catch (Exception e) {
        logger.error("Problem with least squares optimizer", e);
        throw new IllegalArgumentException("Problem with least squares optimizer");
    }
}

---