高斯曲线拟合 - 参数估计 - Android / Java

Question

I have to fit a Gaussian curve to a noisy set of data and then take it's FWHM for a certain application. I used MATLAB to demo the concept, and curve fitting in MATLAB is extremely easy.

However, I eventually have to translate the code into Java/Android. I tried looking for libraries in Android that would help me fit a Gaussian curve to data set, but I couldn't find anything. Consequently, I started trying to learn all the math involved so I could do it manually.

My question: How do I go about estimating the three parameters (center, width, height) for a single-term gaussian model? I tried looking into the Expectation-Maximization algorithm but that went way over my head.

In general, I assume it would have something to do with error minimization? I'm just having trouble figuring out the step-by-step method of fitting a gaussian curve to my data.

EDIT:

One of the things I tried already involved taking the natural log of my data, fitting a parabola to the result using LSQR, and then transforming back. However, the results I'm getting aren't accurate, probably because this method is biased in some way or another.

If you don't know how to do parameter estimation, do you have any other suggestions of fitting a curve to my data? (Remember, it has to be manual since Android seems to be fairly limited on it's statistics libraries)

Answer 1

I recently did a similar thing using the Apache Commons math class, specifically the Levenberg-Marquardt Optimizer, CurveFitter, and GaussianFunction classes.

The code I used to get the data ready was something like:

    // Initialize analyzers
    _optimizer = new LevenbergMarquardtOptimizer();
    _fitter = new CurveFitter(_optimizer);

    // Initialize the analysis results
    _gaussians = new ArrayList<GaussianFunction>();

    // Load the data into the gaussian fitter
    for (int i = 0; i != data.length; i++)
        _fitter.addObservedPoint(i, data[i]);

and then to actually perform the fit:

public void analyze() {
    // Calculate Mean
    double sum_yx = 0.0;
    double sum_y = 0.0;
    for (int i = 0; i != _data.length; i++) {
        sum_yx += _data[i] * (i + 1);
        sum_y += _data[i];
    }

    double mean = sum_yx / sum_y;

    // Peform the gaussian fit

    // If no guesses given, fit to the mean of the data
    if (_guesses.size() == 0) {
        double[] guess = new double[] { 0, 1, mean, 1 };
        double ret[];
        try {
            ret = _fitter.fit(new ParametricGaussianFunction(), guess);
            _gaussians.add(new GaussianFunction(ret[0], ret[1], ret[2],
                    ret[3]));
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    // If guesses are given, fit to each one
    else {
        try {
            for (double[] guess : _guesses) {
                double ret[] = _fitter.fit(
                        new ParametricGaussianFunction(), guess);
                _gaussians.add(new GaussianFunction(ret[0], ret[1], ret[2],
                        ret[3]));
            }
        } catch (Exception e) {
            e.printStackTrace();
            // _gaussian = null;
        }
    }
}

You mentioned your data is noisy; I included the guesses because I had to fit to peaks with Gaussianish distributions that formed a Gaussian shape themselves. The initial condition has to be very accurate. If my guesses were off by a few pixels, I got a fit over the entire data set instead of just the peak. I imagine if there's no fallback / larger trend to fit to, it would just fail.

GaussianFunction has the cryptic parameters A, B, C, and D which are, respectively, y offset, amplitude, centroid position, and sigma.

I don't know a single thing about Android, so I don't know if you'll be able to use this package, but I found this question while looking for a related one (I'm also replicating a Matlab application in Java, not fun) and figured if you haven't figured it out yet, this might help!

Answer 2

With 3.3 version of org.apache.commons.math3 is even easier using GaussianCurveFitter:

        GaussianCurveFitter fitter = GaussianCurveFitter.create();

        WeightedObservedPoints obs = new WeightedObservedPoints();

        for (int index = 0; index < data.length; index++) {
            obs.add(data[i].x, data[i].y);
        }

        double[] bestFit = fitter.fit(obs.toList());

The results will be norm, mean, sigma, where norm will be your amplitude.