Как использовать Java Math Commons CurveFitter?

Как я могу использовать Math Commons CurveFitter для подгонки функции к набору данных? Мне сказали использовать CurveFitter с LevenbergMarquardtOptimizer и ParametricUnivariateFunction, но я не знаю, что писать в методах градиента и значения ParametricUnivariateFunction. Кроме того, после их написания, как получить подобранные параметры функции? Моя функция:

public static double fnc(double t, double a, double b, double c){
  return a * Math.pow(t, b) * Math.exp(-c * t);
}
Источник

2 ответа

Решение

Итак, это старый вопрос, но я недавно столкнулся с той же проблемой, и в итоге мне пришлось вникать в списки рассылки и исходный код Apache Commons Math, чтобы разобраться в этом.

Этот API-документ замечательно плохо документирован, но в текущей версии Apache Common Math (3.3+) есть две части, при условии, что у вас есть одна переменная с несколькими параметрами: функция для соответствия (которая реализует ParametricUnivariateFunction) и подгонщик кривой (который расширяет AbstractCurveFitter).

Функция, чтобы соответствовать

  • public double value(double t, double... parameters)
    • Ваше уравнение Это где вы бы положили fnc логика.
  • public double[] gradient(double t, double... parameters)
    • Возвращает массив частной производной вышеуказанного по каждому параметру. Этот калькулятор может быть полезен, если (как и я) у вас проблемы с исчислением, но любая хорошая система компьютерной алгебры может вычислить эти значения.

Кривая Fitter

  • protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> points)
    • Устанавливает кучу дерьма шаблона и возвращает проблему наименьших квадратов для использования установщиком.

Собирая все вместе, вот пример решения в вашем конкретном случае:

import java.util.*;
import org.apache.commons.math3.analysis.ParametricUnivariateFunction;
import org.apache.commons.math3.fitting.AbstractCurveFitter;
import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder;
import org.apache.commons.math3.fitting.leastsquares.LeastSquaresProblem;
import org.apache.commons.math3.fitting.WeightedObservedPoint;
import org.apache.commons.math3.linear.DiagonalMatrix;

class MyFunc implements ParametricUnivariateFunction {
    public double value(double t, double... parameters) {
        return parameters[0] * Math.pow(t, parameters[1]) * Math.exp(-parameters[2] * t);
    }

    // Jacobian matrix of the above. In this case, this is just an array of
    // partial derivatives of the above function, with one element for each parameter.
    public double[] gradient(double t, double... parameters) {
        final double a = parameters[0];
        final double b = parameters[1];
        final double c = parameters[2];

        return new double[] {
            Math.exp(-c*t) * Math.pow(t, b),
            a * Math.exp(-c*t) * Math.pow(t, b) * Math.log(t),
            a * (-Math.exp(-c*t)) * Math.pow(t, b+1)
        };
    }
}

public class MyFuncFitter extends AbstractCurveFitter {
    protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> points) {
        final int len = points.size();
        final double[] target  = new double[len];
        final double[] weights = new double[len];
        final double[] initialGuess = { 1.0, 1.0, 1.0 };

        int i = 0;
        for(WeightedObservedPoint point : points) {
            target[i]  = point.getY();
            weights[i] = point.getWeight();
            i += 1;
        }

        final AbstractCurveFitter.TheoreticalValuesFunction model = new
            AbstractCurveFitter.TheoreticalValuesFunction(new MyFunc(), points);

        return new LeastSquaresBuilder().
            maxEvaluations(Integer.MAX_VALUE).
            maxIterations(Integer.MAX_VALUE).
            start(initialGuess).
            target(target).
            weight(new DiagonalMatrix(weights)).
            model(model.getModelFunction(), model.getModelFunctionJacobian()).
            build();
    }

    public static void main(String[] args) {
        MyFuncFitter fitter = new MyFuncFitter();
        ArrayList<WeightedObservedPoint> points = new ArrayList<WeightedObservedPoint>();

        // Add points here; for instance,
        WeightedObservedPoint point = new WeightedObservedPoint(1.0,
            1.0,
            1.0);
        points.add(point);

        final double coeffs[] = fitter.fit(points);
        System.out.println(Arrays.toString(coeffs));
    }
}
Источник

Я знаю, что этот вопрос довольно старый, и i80and отлично i80and него, но я просто подумал добавить (для будущих SO), что есть довольно простой способ вычисления производных или частных производных с помощью Apache Math (так что у вас нет сделать свою собственную дифференциацию для матрицы Якобиана). Это производная структура.

Расширение i80and и использование класса DerivativeStructure:

//Everything stays the same except for the Jacobian Matrix

import java.util.*;
import org.apache.commons.math3.analysis.ParametricUnivariateFunction;
import org.apache.commons.math3.fitting.AbstractCurveFitter;
import org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder;
import org.apache.commons.math3.fitting.leastsquares.LeastSquaresProblem;
import org.apache.commons.math3.fitting.WeightedObservedPoint;
import org.apache.commons.math3.linear.DiagonalMatrix;
import org.apache.commons.math3.analysis.differentiation.DerivativeStructure;

class MyFunc implements ParametricUnivariateFunction {
    public double value(double t, double... parameters) {
        return parameters[0] * Math.pow(t, parameters[1]) * Math.exp(-parameters[2] * t);
    }

    // Jacobian matrix of the above. In this case, this is just an array of
    // partial derivatives of the above function, with one element for each parameter.
    public double[] gradient(double t, double... parameters) {
        final double a = parameters[0];
        final double b = parameters[1];
        final double c = parameters[2];

        // Jacobian Matrix Edit

        // Using Derivative Structures...
        // constructor takes 4 arguments - the number of parameters in your
        // equation to be differentiated (3 in this case), the order of
        // differentiation for the DerivativeStructure, the index of the
        // parameter represented by the DS, and the value of the parameter itself
        DerivativeStructure aDev = new DerivativeStructure(3, 1, 0, a);
        DerivativeStructure bDev = new DerivativeStructure(3, 1, 1, b);
        DerivativeStructure cDev = new DerivativeStructure(3, 1, 2, c);

        // define the equation to be differentiated using another DerivativeStructure
        DerivativeStructure y = aDev.multiply(DerivativeStructure.pow(t, bDev))
                .multiply(cDev.negate().multiply(t).exp());

        // then return the partial derivatives required
        // notice the format, 3 arguments for the method since 3 parameters were
        // specified first order derivative of the first parameter, then the second, 
        // then the third
        return new double[] {
                y.getPartialDerivative(1, 0, 0),
                y.getPartialDerivative(0, 1, 0),
                y.getPartialDerivative(0, 0, 1)
        };

    }
}

public class MyFuncFitter extends AbstractCurveFitter {
    protected LeastSquaresProblem getProblem(Collection<WeightedObservedPoint> points) {
        final int len = points.size();
        final double[] target  = new double[len];
        final double[] weights = new double[len];
        final double[] initialGuess = { 1.0, 1.0, 1.0 };

        int i = 0;
        for(WeightedObservedPoint point : points) {
            target[i]  = point.getY();
            weights[i] = point.getWeight();
            i += 1;
        }

        final AbstractCurveFitter.TheoreticalValuesFunction model = new
                AbstractCurveFitter.TheoreticalValuesFunction(new MyFunc(), points);

        return new LeastSquaresBuilder().
                maxEvaluations(Integer.MAX_VALUE).
                maxIterations(Integer.MAX_VALUE).
                start(initialGuess).
                target(target).
                weight(new DiagonalMatrix(weights)).
                model(model.getModelFunction(), model.getModelFunctionJacobian()).
                build();
    }

    public static void main(String[] args) {
        MyFuncFitter fitter = new MyFuncFitter();
        ArrayList<WeightedObservedPoint> points = new ArrayList<WeightedObservedPoint>();

        // Add points here; for instance,
        WeightedObservedPoint point = new WeightedObservedPoint(1.0,
                1.0,
                1.0);
        points.add(point);

        final double coeffs[] = fitter.fit(points);
        System.out.println(Arrays.toString(coeffs));
    }
}

И это все. Я знаю, что это довольно запутанный / запутанный класс для использования, но он определенно пригодится, когда вы имеете дело с очень сложными уравнениями, которые затрудняют получение частных производных вручную (это случилось со мной не так давно), или когда вы хотите получить частные производные, скажем, второго или третьего порядка.

В случае производных второго, третьего и так далее порядка, все, что вам нужно сделать, это:

// specify the required order as the second argument, say second order so 2
DerivativeStructure aDev = new DerivativeStructure(3, 2, 0, a);        
DerivativeStructure bDev = new DerivativeStructure(3, 2, 1, b);
DerivativeStructure cDev = new DerivativeStructure(3, 2, 2, c);

// and then specify the order again here
y.getPartialDerivative(2, 0, 0),
y.getPartialDerivative(0, 2, 0),
y.getPartialDerivative(0, 0, 2)

Надеюсь, это поможет кому-нибудь когда-нибудь.

Источник
Другие вопросы по тегам