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

Introduction

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

Prototype

public LeastSquaresProblem build() 

Source Link

Document

Construct a LeastSquaresProblem from the data in this builder.

Usage

From source file:de.bund.bfr.knime.pmm.common.math.ParameterOptimizer.java

private void optimize(List<Double> startValues) throws Exception {
    double[] targets = new double[targetValues.size()];
    double[] startValueArray = new double[startValues.size()];

    for (int i = 0; i < targetValues.size(); i++) {
        targets[i] = targetValues.get(i);
    }//from www .  ja  v  a 2 s.  c om

    for (int i = 0; i < startValues.size(); i++) {
        startValueArray[i] = startValues.get(i);
    }

    OptimizerFunction optimizerFunction = new OptimizerFunction(parser, function, parameters, arguments,
            argumentValues, targetValues);
    OptimizerFunctionJacobian optimizerFunctionJacobian = new OptimizerFunctionJacobian(parser, function,
            parameters, derivatives, arguments, argumentValues, targetValues);

    LeastSquaresBuilder builder = new LeastSquaresBuilder().model(optimizerFunction, optimizerFunctionJacobian)
            .maxEvaluations(MAX_EVAL).maxIterations(MAX_EVAL).target(targets).start(startValueArray);

    optimizerValues = new LevenbergMarquardtOptimizer().optimize(builder.build());
}

---

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 www .j  a  va 2s . c om
    }

    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 va2 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");
    }
}

---