Wolfram Language & System Documentation Center

FindFit

FindFit[data,expr,pars,vars]

finds numerical values of the parameters pars that make expr give a best fit to data as a function of vars.

FindFit[data,{expr,cons},pars,vars]

finds a best fit subject to the parameter constraints cons.

FindFit[data,exprspec,pars,vars,"prop"]

specifies what fit property prop should be returned.

Details and Options

The data can have the form {{x₁,y₁,…,f₁},{x₂,y₂,…,f₂},…}, where the number of coordinates x, y, … is equal to the number of variables in the list vars.
The data can also be of the form {f₁,f₂,…}, with a single coordinate assumed to take values 1, 2, ….
FindFit returns a list of replacements for par₁, par₂, ….
The expression expr must yield a numerical value when pars and vars are all numerical.
The expression expr can depend either linearly or nonlinearly on the par_i.
The constraints cons can contain equations, inequalities, or logical combinations of these.
In the linear case, FindFit finds a globally optimal fit.
In the nonlinear case, it finds in general only a locally optimal fit.
FindFit[data,expr,{{par₁,p₁},{par₂,p₂},…},vars] starts the search for a fit with {par₁->p₁,par₂->p₂,…}.
FindFit by default finds a least‐squares fit.
The possible fit properties "prop" include:

"BestFit"		the best fit linear combination of basis functions
"BestFitParameters"		the vector that gives the best fit
"Coordinates"	{{x₁,y₁,…},…}	the coordinates of vars in data
"FitResiduals"		the differences between the model and the fit at the coordinates
"Function"	Function[{x,y,…},a₁ f₁+…+a_n f_n]	best fit pure function
"PredictedResponse"		fitted values for the data coordinates
"Response"		the response vector from the input data
{"prop₁","prop₂",…}		several fit properties

The option NormFunction->f specifies that the norm f[residual] should be minimized.
The following options can be given:

AccuracyGoal	Automatic	the accuracy sought
EvaluationMonitor	None	expression to evaluate whenever expr is evaluated
FitRegularization	None	regularization for pars for models
Gradient	Automatic	the list of gradient components for expr
MaxIterations	Automatic	maximum number of iterations to use
Method	Automatic	method to use
NormFunction	Norm	the norm to minimize
PrecisionGoal	Automatic	the precision sought
StepMonitor	None	expression to evaluate whenever a step is taken
WorkingPrecision	Automatic	the precision used in internal computations

The default settings for AccuracyGoal and PrecisionGoal are WorkingPrecision/2.
The settings for AccuracyGoal and PrecisionGoal specify the number of digits to seek in both the values of the parameters returned, and the value of the NormFunction.
With NormFunction->f and FitRegularization->rfun, Fit finds the values of pars that minimize normf[{expr(pars,x₁,y₁,…)-f₁,…}]+rfun[pars].
The setting for NormFunction can be given in the following forms:

	f	a function f that is applied to the residual
	{"HuberPenalty",α}	sum of the Huber penalty function for each component
	{"DeadzoneLinearPenalty",α}	sum of deadzone linear penalty function for each component

The setting for FitRegularization may be given in the following forms:

	None	no regularization
	rfun	regularize with rfun[a]
	{"Tikhonov", λ}	regularize with
	{"LASSO",λ}	regularize with
	{"Variation",λ}	regularize with $lambda\|\|TemplateBox[{Differences, paclet:ref/Differences}, RefLink, BaseStyle -> {2ColumnTableMod}][a]\|\|^2$
	{"TotalVariation",λ}	regularize with $lambda\|\|TemplateBox[{Differences, paclet:ref/Differences}, RefLink, BaseStyle -> {2ColumnTableMod}][a]\|\|_1$
	{"Curvature",λ}	regularize with $lambda\|\|TemplateBox[{Differences, paclet:ref/Differences}, RefLink, BaseStyle -> {2ColumnTableMod}][a,2]\|\|^2$
	{r₁,r₂,…}	regularize with the sum of terms from r₁,…

FindFit continues until either of the goals specified by AccuracyGoal or PrecisionGoal is achieved.
Possible settings for Method include "ConjugateGradient", "PrincipalAxis", "LevenbergMarquardt", "Newton", "NMinimize", and "QuasiNewton", with the default being Automatic.

Examples

open all close all

Basic Examples (1)

Find a nonlinear fit to a list of primes:

Wolfram Language code: Table[Prime[x], {x, 20}]

Fit the best-fit parameters , , and :

Wolfram Language code: FindFit[%, a x Log[b + c x], {a, b, c}, x]

Evaluate the fitted function:

Wolfram Language code: Table[a x Log[b + c x] /. %, {x, 10}]

Scope (7)

Simple Exponential Fitting (3)

Fit data to a model of exponential decay:

Wolfram Language code: data = {{1.0, 12.}, {1.9, 10.}, {2.6, 8.2}, {3.4, 6.9}, {5.0, 5.9}};

Wolfram Language code: model = a Exp[-k t];

Wolfram Language code: fit = FindFit[data, model, {a, k}, t]

The resulting model function:

Wolfram Language code: modelf = Function[{t}, Evaluate[model /. fit]]

Show the data with the model:

Wolfram Language code: Plot[modelf[t], {t, 0, 6}, Epilog -> Map[Point, data]]

Separate the time from the response:

Wolfram Language code: {tl, yl} = Transpose[data];

Looking at residuals gives a good indication of whether the model is a good fit:

Wolfram Language code: residuals = yl - Map[modelf, tl]

Wolfram Language code: ListPlot[residuals, Filling -> Axis, DataRange -> {Min[tl], Max[tl]}, PlotRange -> {{0, 6}, All}]

Use a linear fit on the logarithm of the data for a model of exponential decay:

Wolfram Language code:

data = {{1.0, 12.}, {1.9, 10.}, {2.6, 8.2}, {3.4, 6.9}, {5.0, 5.9}};
logdata = Apply[Function[{t, v}, {t, Log[v]}], data, {1}];

The logarithm of the exponential model is a linear model for the logarithm of the data:

Wolfram Language code: logmodel = la - k t;

Wolfram Language code: lfit = FindFit[logdata, logmodel, {la, k}, t]

The exponential model formed by exponentiating the model for the logarithm:

Wolfram Language code: Exp[logmodel /. lfit] /. Exp[a_ + b_ t] :> Exp[a]Exp[b t]

Exponential fit as parameters in a differential equation:

Wolfram Language code: data = {{1.0, 12.}, {1.9, 10.}, {2.6, 8.2}, {3.4, 6.9}, {5.0, 5.9}};

The model function is the solution of a differential equation:

Wolfram Language code: demodel[a_ ? NumberQ, k_ ? NumberQ] := First[x /. NDSolve[{x'[t] + k x[t] == 0, x[0] == a}, x, {t, 0, 6}]]

Wolfram Language code: Timing[FindFit[data, demodel[a, k][t], {a, k}, t]]//Quiet

Using caching is faster:

Wolfram Language code:

demodel[a_ ? NumberQ, k_ ? NumberQ] := demodel[a, k] = First[x /. NDSolve[{x'[t] + k x[t] == 0, x[0] == a}, x, {t, 0, 6}]]

Wolfram Language code: Timing[FindFit[data, demodel[a, k][t], {a, k}, t]]//Quiet

Constraints and Starting Values (2)

Find a constrained fit:

Wolfram Language code: model = a Cos[ω t];

Wolfram Language code: data = Table[{t, Cos[2.1t]}, {t, 0, 10, .25}] + RandomReal[.1, 41];

Fit to the model with positive amplitude and frequency between 1 and 2:

Wolfram Language code: fit = FindFit[data, {model, {a > 0, 1 < ω < 2}}, {a, ω}, t]

Compare the fitted model to the data:

Wolfram Language code: Show[Plot[model /. fit, {t, 0, 10}], ListPlot[data, PlotRange -> All]]

The residuals show a pattern, indicating that the frequency constraint is too strict:

Wolfram Language code: residuals = Apply[Function[{t, y}, Evaluate[{t, y - model /. fit}]], data, 1];

Wolfram Language code: ListPlot[residuals, PlotRange -> All]

Give starting values for some parameters to get a better fit:

Wolfram Language code: model = a Exp[-b(x - c) ^ 2] + d Sin[ω x + ϕ];

Wolfram Language code:

data = Table[{x, model /. {a -> 2, b -> 1, c -> 0, d -> 2, ω -> 0.67, ϕ -> 0.1}}, {x, -5, 5, .1}] + RandomReal[.25, 101];

Search with all parameters starting at 1:

Wolfram Language code: f1 = FindFit[data, model, {a, b, c, d, ω, ϕ}, x]

Search with a better starting value for the parameter c:

Wolfram Language code: f2 = FindFit[data, model, {a, b, {c, 0}, d, ω, ϕ}, x]

Compare the quality of the two fits:

Wolfram Language code: Show[Plot[Evaluate[model /. {f1, f2}], {x, -5, 5}, PlotStyle -> {Red, Green}], ListPlot[data, PlotRange -> All]]

Multivariate Data (2)

Fit a surface to data in two dimensions:

Wolfram Language code: model = a Exp[-b((x - x0) ^ 2 + (y - y0) ^ 2)];

Wolfram Language code:

data = MapThread[{#1[[1]], #1[[2]], 1.2Exp[-34((#1 - .56).(#1 - .56))] + #2}&, {RandomReal[1, {100, 2}], RandomReal[{-.1, .1}, 100]}];

Find the fit starting from an approximate position for the peak:

Wolfram Language code: fit = FindFit[data, model, {a, b, {x0, .5}, {y0, .6}}, {x, y}]

Show the fitted surface with the data:

Wolfram Language code:

Show[Plot3D[model /. fit, {x, 0, 1}, {y, 0, 1}, PlotRange -> All], ListPointPlot3D[data, PlotStyle -> Directive[PointSize[Medium], Red]]]

Fit a model to data in four dimensions:

Wolfram Language code: model[x1_, x2_, x3_, x4_] := a0 Cos[a1 x1 ^ 2 + a2 x2 ^ 2 + a3 x3 ^ 3 + a4 x4 ^ 4];

Wolfram Language code:

g = N[Range[-5, 5] / 5];
data = Block[{a0 = 1, a1 = 1, a2 = 2, a3 = 3, a4 = 4}, Flatten[Outer[{##, model[##]}&, g, g, g, g], 3]];
data[[All, -1]] += RandomReal[{-0.1, 0.1}, Length[data]];

Wolfram Language code: fit = FindFit[data, model[x1, x2, x3, x4], {a0, a1, a2, a3, a4}, {x1, x2, x3, x4}]

The residual is comparable in size to the randomness added to the data:

Wolfram Language code: residual = Apply[Function[{x1, x2, x3, x4, r}, Evaluate[r - (model[x1, x2, x3, x4] /. fit)]], data, {1}];

Wolfram Language code: Norm[residual, Infinity]

Options (7)

EvaluationMonitor (1)

Count evaluations of the model with numerical values of the parameters:

Wolfram Language code:

data = {{4.00, 126.}, {5.00, 125.}, {7.00, 123.}, {12.0, 120.}, {14.0, 119.}, {16.0, 118.}, {20.0, 116.}, {24.0, 115.}, {28.0, 114.}, {31.0, 113.}, {34.0, 112.}, {37.5, 111.}, {41.0, 110.}};

Wolfram Language code: Block[{count = 0}, {FindFit[data, 60 + 70Exp[-a x], a, x, EvaluationMonitor :> count++], count}]

Gradient (1)

Specify the model gradient to avoid problems with a removable singularity:

Wolfram Language code: data = {{0., -1.}, {.2, 2.}, {.5, 5.}, {.6, 4.}, {1., 0.}, {2., 0.}};

With symbolic derivatives FindFit fails since the derivative for Sinc is given as a generic formula:

Wolfram Language code: FindFit[data, a Sinc[ω(x - x0)], {a, ω, x0}, x]

The gradient has a singularity when since there is a point in the data with :

Wolfram Language code: D[a Sinc[ω(x - x0)], {{a, ω, x0}}]

Specify finite differences to avoid the removable singularity:

Wolfram Language code: fit = FindFit[data, a Sinc[ω(x - x0)], {a, ω, x0}, x, Gradient -> "FiniteDifference"]

Show the data with the fit:

Wolfram Language code: Show[ListPlot[data], Plot[a Sinc[ω(x - x0)] /. fit, {x, 0, 2}]]

MaxIterations (1)

When convergence is slow, increasing MaxIterations may allow convergence to the best fit:

Wolfram Language code:

model[x_] := d + 33c((0.7818074748209513b/4b^2 + (-47a + 2x π)^2) + (0.6686926778600345b/32b^2 + (-46a + 2x π)^2) + (0.8311998722869463b/21b^2 + (-44a + 2x π)^2));
xv = RandomReal[1, 500];
data = Block[{a = 2, b = 3, c = 4, d = 5}, Transpose[{xv, model[xv]}]];

With the default, convergence is not reached:

Wolfram Language code: FindFit[data, model[x], {{a, 2.3}, {b, 3.2}, {c, 3.9}, {d, 4.9}}, x]

Convergence is reached before 1000 iterations are used:

Wolfram Language code: FindFit[data, model[x], {{a, 2.3}, {b, 3.2}, {c, 3.9}, {d, 4.9}}, x, MaxIterations -> 1000]

Method (1)

Use Method->NMinimize to search more exhaustively for a global minimum:

Wolfram Language code: model = a Exp[-b(x - c) ^ 2] + d Sin[ω x + ϕ];

Wolfram Language code:

data = Table[{x, model /. {a -> 2, b -> 1, c -> 0, d -> 2, ω -> 0.67, ϕ -> 0.1}}, {x, -5, 5, .1}] + RandomReal[.25, 101];

Find a local minimum:

Wolfram Language code: f1 = FindFit[data, model, {a, b, c, d, ω, ϕ}, x]

Search for a global minimum:

Wolfram Language code: f2 = FindFit[data, model, {a, b, c, d, ω, ϕ}, x, Method -> NMinimize]

Compare the quality of the two fits (the global best fit is shown in red):

Wolfram Language code: Show[{Plot[Evaluate[model /. {f1, f2}], {x, -5, 5}, PlotStyle -> {{Green}, {Red}}], ListPlot[data]}]

NormFunction (1)

Wolfram Language code: data = Table[Prime[x], {x, 20}]

The default is to find the best least-squares fit:

Wolfram Language code: FindFit[data, a x Log[b + cx], {a, b, c}, x]

Use the -norm instead:

Wolfram Language code: FindFit[data, a x Log[b + cx], {a, b, c}, x, NormFunction -> (Norm[#, Infinity]&)]

Wolfram Language code: FindFit[data, a x Log[b + cx], {a, b, c}, x, NormFunction -> (Norm[#, 1]&)]

StepMonitor (1)

Show steps taken in parameter space to fit the Michaelis–Menten model to experimental data:

Wolfram Language code: model = (Subscript[θ, 1]x/Subscript[θ, 2] + x);

Data from an experiment on the rate of an enzymatic reaction:

Wolfram Language code:

data = {{0.02, 76.}, {0.02, 47.}, {0.06, 97.}, {0.06, 107.}, {0.11, 123.}, {0.11, 139.}, {0.22, 159.}, {0.22, 152.}, {0.56, 191.}, {0.56, 201.}, {1.1, 207.}, {1.1, 200.}};

Wolfram Language code:

{fit, steps} = Reap[FindFit[data, model, {Subscript[θ, 1], Subscript[θ, 2]}, x, StepMonitor :> Sow[{Subscript[θ, 1], Subscript[θ, 2]}]]];

Show how the parameters evolve during the search:

Wolfram Language code: ListPlot[steps, Epilog -> {Red, Point[{Subscript[θ, 1], Subscript[θ, 2]} /. fit]}]

WorkingPrecision (1)

Use a higher WorkingPrecision to get a more precise parameter estimate:

Wolfram Language code:

data = {{4, 126}, {5, 125}, {7, 123}, {12, 120}, {14, 119}, {16, 118}, {20, 116}, {24, 115}, {28, 114}, {31, 113}, {34, 112}, {75 / 2, 111}, {41, 110}};

Wolfram Language code: FindFit[data, 60 + 70Exp[-a x], a, x, WorkingPrecision -> 50]

Applications (7)

Mathematical Data (2)

Fit a list of Fibonacci numbers:

Wolfram Language code: Table[Fibonacci[x], {x, 15}]

The base is approximately the golden ratio:

Wolfram Language code: FindFit[%, a c ^ x + b c ^ -x, {a, b, c}, x]

Generate data with some noise present:

Wolfram Language code: Table[Sqrt[x]Cos[x] + RandomReal[{-1, 1}], {x, 100}];

Wolfram Language code: ListLinePlot[%]

Fit the data:

Wolfram Language code: FindFit[%%, a x ^ b Cos[c x], {a, b, c}, x]

Experimental Data (3)

Determine the approximate complexity of a computation:

Wolfram Language code: data = Block[{n, v}, Table[n = 2 ^ k;v = RandomComplex[1 + I, n];{n, First[RepeatedTiming[Fourier[v]]]}, {k, 16, 20}]]

Fit to the theoretical model for the complexity of an FFT:

Wolfram Language code: model = c n Log[n];

Wolfram Language code: fit = FindFit[data, model, c, n]

Show the timing data and the fit in a log-log plot:

Wolfram Language code: LogLogPlot[Evaluate[model /. fit], {n, 2 ^ 16, 2 ^ 20}, Epilog -> Map[Point, Log[data]]]

Fit a model for lubricant viscosity to experimental data:

Wolfram Language code: data = Import["ExampleData/lubricant.tsv", "TSV", "HeaderLines" -> 7];

Model for lubricant viscosity as a function of temperature and pressure/1000 :

Wolfram Language code:

model = (Subscript[θ, 1]/Subscript[θ, 2] + Subscript[x, 1]) + Subscript[θ, 3]Subscript[x, 2] + Subscript[θ, 4]Subscript[x, 2]^2 + Subscript[θ, 5]Subscript[x, 2]^3 + (Subscript[θ, 6] + Subscript[θ, 7]Subscript[x, 2]^2)Subscript[x, 2] Exp[(-Subscript[x, 1]/Subscript[θ, 8] + Subscript[θ, 9]Subscript[x, 2]^2)];

Scale the pressure to improve the conditioning of the model:

Wolfram Language code:

sdata = data;
sdata[[All, 2]] *= 0.001;

Find the parameters that best fit the scaled data:

Wolfram Language code:

fit = FindFit[sdata, model, {Subscript[θ, 1], Subscript[θ, 2], Subscript[θ, 3], Subscript[θ, 4], Subscript[θ, 5], Subscript[θ, 6], Subscript[θ, 7], Subscript[θ, 8], Subscript[θ, 9]}, {Subscript[x, 1], Subscript[x, 2]}]

Show a plot of the fit with the scaled experimental data:

Wolfram Language code:

Show[{Plot3D[Evaluate[model /. fit], {Subscript[x, 1], 0, 100}, {Subscript[x, 2], 0, 8}], Graphics3D[{Red, PointSize[.025], Map[Point, sdata]}]}]

Fit a model for the rate of isomerization of n-pentane to isopentane with experimental data:

Wolfram Language code: data = Import["ExampleData/isomerization.dat", "Table", "HeaderLines" -> 7];

Nonlinear model for rate as a function of hydrogen , n-pentane , and isopentane :

Wolfram Language code:

model = Subscript[θ, 1] Subscript[θ, 3](Subscript[x, 2] - Subscript[x, 3] / 1.632) / (1 + Subscript[θ, 2]Subscript[x, 1] + Subscript[θ, 3]Subscript[x, 2] + Subscript[θ, 4]Subscript[x, 3]);

Find the parameters that best fit the data starting with values having the right size:

Wolfram Language code:

FindFit[data, model, {{Subscript[θ, 1], 1}, {Subscript[θ, 2], .1}, {Subscript[θ, 3], .1}, {Subscript[θ, 4], .1}}, {Subscript[x, 1], Subscript[x, 2], Subscript[x, 3]}]

Differential Equations (2)

Find parameters in a differential equation model that give the best fit:

Wolfram Language code:

sol = First[x /. NDSolve[{x''[t] + .33x'[t] + .72x[t] ^ 3 == 0, x[0] == 2, x'[0] == 0}, x, {t, 20}]];
times = N[Range[0, 100] / 5];
data = Transpose[{times, sol[times] + RandomReal[.1, 101]}];
lp = ListPlot[data, PlotRange -> All]

Define a model so the solution for a set of parameters is reused for all values:

Wolfram Language code:

model[γ_ ? NumberQ, a_ ? NumberQ, b_ ? NumberQ] := (model[γ, a, b] = First[x /. NDSolve[{x''[t] + γ x'[t] + a x[t] + b x[t] ^ 3 == 0, x[0] == 2, x'[0] == 0}, x, {t, 20}]]);

Find the fit with tolerance appropriate to the precision of the solutions of the ODE:

Wolfram Language code: fit = FindFit[data, model[γ, a, b][x], {{γ, .1}, {a, .1}, {b, 1}}, x, PrecisionGoal -> 4, AccuracyGoal -> 4]

Show the fitted model with the data and the residuals:

Wolfram Language code:

{Show[Plot[model[γ, a, b][x] /. fit, {x, 0, 20}], lp], ListPlot[Transpose[{times, data[[All, 2]] - (model[γ, a, b][times] /. fit)}]]}

Find how a nonsoliton initial condition for the KdV equation breaks down into two solitons:

Wolfram Language code:

xl = 25;
tend = 15;
sol = First[u /. NDSolve[{D[u[t, x], t] + D[u[t, x], {x, 3}] + 3u[t, x]D[u[t, x], x] == 0, u[0, x] == 3Sech[x / 2] ^ 2, u[t, -xl] == u[t, 3xl]}, u, {t, 0, tend}, {x, -xl, 3xl}, Method -> {"MethodOfLines", "SpatialDiscretization" -> {"TensorProductGrid", "DifferenceOrder" -> "Pseudospectral"}}]]

The initial wave breaks into two separate waves:

Wolfram Language code: Plot3D[sol[t, x], {t, 0, tend}, {x, -xl, 3xl}, PlotRange -> All, PlotPoints -> 100, Mesh -> False]

Get the spatial grid used by NDSolve to solve the PDE:

Wolfram Language code: xg = sol[[3, 2]];

The discretized solution at the final time:

Wolfram Language code: dsol = Transpose[{xg, sol[tend, xg]}];

Wolfram Language code: ListPlot[dsol, PlotRange -> All]

Model of two solitons with different velocities:

Wolfram Language code: model[t_, x_] = k1 ^ 2Sech[k1(x - k1 ^ 2t) / 2] ^ 2 + k2 ^ 2Sech[k2(x - k2 ^ 2t) / 2] ^ 2;

Find fit with starting conditions estimated from the graph of the discretized solution:

Wolfram Language code: fit = FindFit[dsol, model[tend, x], {{k1, 1}, {k2, 2}}, x]

Plots of the two-soliton model and residuals at intermediate times:

Wolfram Language code:

Table[{Show[ListPlot[sol[t, xg], PlotRange -> All, DataRange -> {-xl, 3xl}], Plot[model[t, x] /. fit, {x, -xl, 3xl}, PlotRange -> All]], ListPlot[sol[t, xg] - (model[t, xg] /. fit), PlotRange -> All, DataRange -> {-xl, 3xl}]}, {t, 0, tend, tend / 3}]//Grid

Properties & Relations (6)

FindFit gives the parameter estimates:

Wolfram Language code: data = Table[{i, Exp[RandomReal[{i - 1, i}]]}, {i, 10}];

Wolfram Language code: FindFit[data, Exp[a + b x], {a, b}, x]

NonlinearModelFit allows for extraction of additional information about the fitting:

Wolfram Language code: nlm = NonlinearModelFit[data, Exp[a + b x], {a, b}, x]

Extract the parameter estimates:

Wolfram Language code: nlm["BestFitParameters"]

Extract additional results and diagnostics:

Wolfram Language code: nlm[{"BestFit", "FitResiduals", "ParameterTable"}]

For linear models, Fit and FindFit are equivalent and use LeastSquares:

Wolfram Language code: data = {{0, 1}, {1, 0}, {2, 3}, {3, 4}, {4, 10}, {5, 20}};

Use Fit with the basis {1,x,x²}:

Wolfram Language code:

basis = {1, x, x ^ 2};
Fit[data, basis, x]

This is equivalent to FindFit with the model function a linear combination of the basis:

Wolfram Language code:

model = {a[0], a[1], a[2]}.basis;
FindFit[data, model, {a[0], a[1], a[2]}, x]

Construct a design matrix and use LeastSquares to find the coefficients:

Wolfram Language code: m = Map[Function[{x}, Evaluate[basis]], data[[All, 1]]]

Wolfram Language code: LeastSquares[m, N[data[[All, 2]]]]

LinearModelFit fits linear models and gives additional results about the fitting:

Wolfram Language code: lm = LinearModelFit[data, basis, x]

Wolfram Language code: lm["BestFitParameters"]

Wolfram Language code: lm[{"RSquared", "FitResiduals"}]

FindFit effectively uses FindMinimum to minimize a norm of the residual function:

Wolfram Language code:

data = {{0, 1}, {1, 0}, {2, 3}, {3, 4}, {4, 10}, {5, 20}};
{xp, response} = Transpose[data];

Wolfram Language code: model = a Exp[b x];

The residual is the difference between response and model prediction:

Wolfram Language code: residual = response - Map[Function[{x}, Evaluate[model]], xp]

Wolfram Language code: FindMinimum[residual.residual, {a, b}]

Wolfram Language code: FindFit[data, model, {a, b}, x]

FindFit gives a result consistent with normally distributed responses by default:

Wolfram Language code: data = Table[{i, RandomReal[{11 - i, 10 - i}] / 10}, {i, 10, 1, -1}];

Wolfram Language code: ff = FindFit[data, 1 / (1 + Exp[a + b x]), {a, b}, x]

LogitModelFit assumes binomially distributed responses:

Wolfram Language code: lm = LogitModelFit[data, x, x]

The fits are not identical:

Wolfram Language code: {Normal[lm], 1 / (1 + Exp[a + b x]) /. ff}

The same is true for ProbitModelFit:

Wolfram Language code: pm = ProbitModelFit[data, x, x]

Wolfram Language code: ff2 = FindFit[data, 1 / 2(1 + Erf[(a + b x) / Sqrt[2]]), Transpose[{{a, b}, pm["BestFitParameters"]}], x]

Wolfram Language code: {Normal[pm], 1 / 2(1 + Erf[(a + b x) / Sqrt[2]]) /. ff2}

GeneralizedLinearModelFit allows for binomial and other distributional structures.

Model gamma-distributed responses:

Wolfram Language code: gam = GeneralizedLinearModelFit[data, x, x, ExponentialFamily -> "Gamma"]

Compare with the result for normally distributed responses:

Wolfram Language code: {Normal[gam], 1 / (a + b x) /. FindFit[data, 1 / (a + b x), {a, b}, x]}

FindFit will use the time stamps of a TimeSeries as variables:

Wolfram Language code:

ts1 = TemporalData[TimeSeries, {{{1.102448341846048, 6.331833897009389, 7.5843632999043455, 
    44.59969789743589, 98.76273258351092, 150.00729051003992, 644.7367359379259, 
    1724.3968817536402, 5903.697723461762, 19468.09340765025}}, {{0, 9, 1}}, 1, {"Continuous", 1}, 
  {"Discrete", 1}, 1, {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 
 10.1];

Wolfram Language code: ts1["Times"]

Wolfram Language code: FindFit[ts1, Exp[a + b x], {a, b}, x]

Rescale the time stamps and fit again:

Wolfram Language code: ts2 = TimeSeriesRescale[ts1, {.1, 2}]

Wolfram Language code: ts2["Times"]

Wolfram Language code: FindFit[ts2, Exp[a + b x], {a, b}, x]

Find fit for the values:

Wolfram Language code: FindFit[ts1["Values"], Exp[a + b x], {a, b}, x]

FindFit acts pathwise on a multipath TemporalData:

Wolfram Language code:

FindFit[TemporalData[Automatic, {{{1.102448341846048, 6.331833897009389, 7.5843632999043455, 
    44.59969789743589, 98.76273258351092, 150.00729051003992, 644.7367359379259, 
    1724.3968817536402, 5903.697723461762, 19468.09340765025}, 
   {1.1024483418 ... 7359379259, 1724.3968817536402, 5903.697723461762, 
    19468.09340765025}}, {{0, 9, 1}, {0.1, 2., 0.2111111111111111}}, 2, {"Continuous", 2}, 
  {"Discrete", 2}, 1, {ResamplingMethod -> {"Interpolation", InterpolationOrder -> 1}}}, False, 
 10.1], Exp[a + b x], {a, b}, x]

Possible Issues (1)

Starting Values (1)

Good starting values may be necessary to get a reasonable fit:

Wolfram Language code: model = a1 Exp[-(b1(x - x1)) ^ 2] + a2 Exp[-(b2(x - x2)) ^ 2];

Wolfram Language code:

data = Block[{a1 = 1, b1 = 5, x1 = -.5, a2 = 2, b2 = 10, x2 = .25, x = Sort[RandomReal[{-1, 1}, 100]]}, 
	Transpose[{x, model + RandomReal[{-.1, .1}, 100]}]];

Find the fit with the default starting values of 1. The local minimum is far from correct:

Wolfram Language code: fit = FindFit[data, model, {a1, b1, x1, a2, b2, x2}, x];

Wolfram Language code: Show[ListPlot[data, PlotRange -> All], Plot[Evaluate[model /. fit], {x, -1, 1}, PlotStyle -> Directive[Thick, Red]]]

Typically, better starting values are required to get a good fit:

Wolfram Language code: sfit = FindFit[data, model, {{a1, 1}, {b1, 5}, {x1, -.5}, {a2, 2}, {b2, 10}, {x2, .25}}, x];

Wolfram Language code: Show[ListPlot[data, PlotRange -> All], Plot[Evaluate[model /. sfit], {x, -1, 1}, PlotStyle -> Red]]

Top

FindFit

Details and Options

Examples

Basic Examples (1)

Scope (7)

Simple Exponential Fitting (3)

Constraints and Starting Values (2)

Multivariate Data (2)

Options (7)

EvaluationMonitor (1)

Gradient (1)

MaxIterations (1)

Method (1)

NormFunction (1)

StepMonitor (1)

WorkingPrecision (1)

Applications (7)

Mathematical Data (2)

Experimental Data (3)

Differential Equations (2)

Properties & Relations (6)

Possible Issues (1)

Starting Values (1)

See Also

Tech Notes

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX