NonlinearModelFit
NonlinearModelFit[{{x1,y1},{x2,y2},…},form,{β1,…},x]
constructs a nonlinear model with formula form that fits the yi for each xi using the free parameters βi.
NonlinearModelFit[data,form,params,{x1,…}]
constructs a nonlinear model where form depends on the variables xk.
NonlinearModelFit[data,{form,cons},params,{x1,…}]
constructs a nonlinear model subject to the parameter constraints cons.
Details and Options
- NonlinearModelFit attempts to model the input data using a general mathematical formula with free parameters.
- NonlinearModelFit produces a nonlinear model of the form
under the assumption that the original 
are independent normally distributed with mean 
and common standard deviation. - NonlinearModelFit returns a symbolic FittedModel object to represent the nonlinear model it constructs. The properties and diagnostics of the model can be obtained from model["property"].
- The value of the best-fit function from NonlinearModelFit at a particular point x1, … can be found from model[x1,…].
- The best-fit function from NonlinearModelFit[data,form,pars,vars] is the same as the result from FindFit[data,form,pars,vars].
- NonlinearModelFit[data,form,{{β1,val1},…},vars] starts the search for a fit with {β1->val1,…}.
- Possible forms of data are:
-
{y1,y2,…} equivalent to the form {{1,y1},{2,y2},…} {{x11,x12,…,y1},…} a list of independent values xij and the responses yi {{x11,x12,…}y1,…} a list of rules between input values and response {{x11,x12,…},…}{y1,y2,…} a rule between a list of input values and responses {{x11,…,y1,…},…}n fit the n 
column of a matrixTabular[…]name fit the column name in a tabular object - With multivariate data such as
, the number of coordinates xi1, xi2, … should equal the number of variables xi. - The data points can be approximate real numbers. Uncertainty can be specified using Around.
- NonlinearModelFit takes the following options:
-
AccuracyGoal Automatic the number of digits of accuracy sought ConfidenceLevel 95/100 confidence level for parameters and predictions EvaluationMonitor None expression to evaluate whenever form is evaluated Gradient Automatic the list of gradient components for form MaxIterations Automatic maximum number of iterations to use Method Automatic method to use PrecisionGoal Automatic the precision sought StepMonitor None the expression to evaluate whenever a step is taken VarianceEstimatorFunction Automatic function for estimating the error variance Weights Automatic weights for data elements WorkingPrecision Automatic the precision used in internal computations - With ConfidenceLevel->p, probability-p confidence intervals are computed for parameter and prediction intervals.
- With the setting Weights->{w1,w2,…}, the error variance for yi is assumed to be proportional to
. - With the setting Weights->Automatic, the weights will be set to 1 if the data contains exact values. If the data contains Around values, the weights will be set to
, with 
the total response variance. - The total response variance
is a function of the initial response variance Δyi2 and the independent values variance 
. - The uncertainties
are propagated through the model using AroundReplace, and the resulting variance is added to response variance Δyi2. The function FindRoot is used internally to find a self-consistent solution according to the Fasano and Vio method. - With the setting VarianceEstimatorFunction->f, the common variance is estimated by f[res,w], where res={y1-
,y2-
,…} is the list of residuals and w is the list of weights. - Using VarianceEstimatorFunction->(1&) and Weights->{1/Δy12,1/Δy22,…}, Δyi is treated as the known uncertainty of measurement yi, and parameter standard errors are effectively computed only from the weights.
- Possible settings for Method include:
-
"ConjugateGradient" nonlinear conjugate gradient "Gradient" gradient descent "LevenbergMarquardt" Gauss–Newton method for least squares "Newton" Newton method "QuasiNewton" quasi-Newton BFGS "InteriorPoint" interior point method "NMinimize" use NMinimize for optimization Automatic automatic default method - Additional method suboptions can be given in the form Method->{…,opts}.
- The Method option can take any local optimization method as specified in the tutorial Unconstrained Optimization: Methods for Local Minimization. »
- Any global optimization method can be specified as a submethod to the "NMinimize" method. They can be found in the Numerical Algorithms for Constrained Global Optimization tutorial. »
- For constrained models, properties based on approximate normality assumptions may not be valid. When such values are computed, the values are generated along with a warning message.
- Properties related to data and the fitted function using model["property"] include:
-
"BestFit" fitted function "BestFitAround" fitted function and mean uncertainty "BestFitDataAround" fitted function and data uncertainty "BestFitParameters" parameter estimates "Data" the input data or design matrix and response vector "Function" best-fit pure function "Response" response values in the input data "Weights" weights used to fit the data - Types of residuals include:
-
"FitResiduals" difference between actual and predicted responses "StandardizedResiduals" fit residuals divided by the standard error for each residual "StudentizedResiduals" fit residuals divided by single deletion error estimates - Properties related to the sum of squared errors include:
-
"ANOVA" analysis of variance data "EstimatedVariance" estimate of the error variance - Properties and diagnostics for parameter estimates include:
-
"CorrelationMatrix" asymptotic parameter correlation matrix "CovarianceMatrix" asymptotic parameter covariance matrix "ParameterEstimates" table of fitted parameter information "ParameterBias" estimated bias in the parameter estimates "ParameterConfidenceRegion" ellipsoidal parameter confidence region - Properties for curvature diagnostics include:
-
"CurvatureConfidenceRegion" confidence region for curvature diagnostics "FitCurvature" table of fit curvature information "MaxIntrinsicCurvature" measure of maximum intrinsic curvature "MaxParameterEffectsCurvature" measure of maximum parameter effects curvature - Properties related to influence measures include:
-
"HatDiagonal" diagonal elements of the hat matrix "SingleDeletionVariances" list of variance estimates with the 
data point omitted - Properties of predicted values include:
-
"MeanPredictionBands" confidence bands for mean predictions "MeanPredictions" data about mean predictions "PredictedResponse" fitted values for the data "SinglePredictionBands" confidence bands based on single observations "SinglePredictions" data about the predicted response of single observations - Properties that measure goodness of fit include:
-
"AdjustedRSquared" 
adjusted for the number of model parameters"AIC" Akaike Information Criterion "AICc" finite sample corrected AIC "BIC" Bayesian Information Criterion "RSquared" coefficient of determination 
- The properties "BestFit", "BestFitAround", "BestFitDataAround", "SinglePredictionBands" and "MeanPredictionBands" can also be called as {"prop",x} or {"prop",{x1,x2,…}} to evaluate these properties at specific independent values.
Data
Options
Properties
Examples
open all close allBasic Examples (2)
Fit a nonlinear model to some data:
nlm = NonlinearModelFit[{...}, Log[a + b x ^ 2], {a, b}, x]Evaluate the model at a point:
nlm[2.3]Visualize the fitted function with the data:
Show[ListPlot[nlm["Data"]], Plot[nlm[x], {x, 0, 7}], Frame -> True]nlm = NonlinearModelFit[{...}, a x^b y^c, {a, b, c}, {x, y}]Obtain the functional form as an expression:
Normal[nlm]Extract information about the fitting:
nlm["FitResiduals"]Scope (17)
Data (7)
Fit a model of one variable, assuming increasing integer-independent values:
NonlinearModelFit[{Log[3], Log[5], Log[7], Log[9], Log[11]}, Log[a x + b], {a, b}, x]Fit a model of more than one variable:
SeedRandom[0];
data = Flatten[Table[{x, y, Exp[.3x - .7y] + RandomReal[{-1, 1}]}, {x, 5}, {y, 5}], 1];NonlinearModelFit[data, Exp[a x + b y], {a, b}, {x, y}]Normal[%]NonlinearModelFit[
{0 -> 0, 1 -> 1, 2 -> 2, 3 -> 3, 4 -> 3, 5 -> 4},
Log[a + b x ^ 2], {a, b}, {x}]Fit a rule of input values and responses:
NonlinearModelFit[
{0, 1, 2, 3, 4, 5} -> {0, 1, 2, 3, 3, 4},
Log[a + b x ^ 2], {a, b}, {x}]Specify a column as the response:
NonlinearModelFit[(| | | |
| ------------------- | - | - |
| 1.0010978759544942 | 1 | 1 |
| 0.8949819317774829 | 1 | 2 |
| -0.6851122183910994 | 1 | 3 |
| 0.7639434166108392 | 3 | 1 |
| 1.3567934196980815 | 3 | 2 |
| 0.18537374908770277 | 3 | 3 |) -> 1, Exp[a x + b y], {a, b}, {x, y}]Give starting values when parameters are far from the default value 1:
data = {{25., 0.001}, {25.5, 0.002}, {26., 0.011}, {26.5, 0.045}, {27., 0.112}, {27.5, 0.215}, {28., 0.259}, {28.5, 0.206}, {29., 0.112}, {29.5, 0.044}, {30., 0.011}};nlm = NonlinearModelFit[data, a Exp[-(x - b) ^ 2], {{a, .5}, {b, 25}}, x]Plot[nlm[x], {x, 25, 30}, Epilog :> Point[data], PlotStyle -> {Orange, Thick}]With the default starting values, the model is effectively 0:
nlmd = NonlinearModelFit[data, a Exp[-(x - b) ^ 2], {a, b}, x]Plot[Chop[nlmd[x]], {x, 25, 30}, Epilog :> Point[data], PlotStyle -> {Orange, Thick}]Obtain a list of available properties for a nonlinear model:
nlm = NonlinearModelFit[Range[10], Exp[a x], a, x]nlm["Properties"]Constraints (2)
Specify a constraint on a model parameter to ensure that the model expression is well defined:
NonlinearModelFit[{...}, {a Log[b x], b > 0.01}, {a, b}, x]Use a constraint to link model parameters together:
NonlinearModelFit[{...}, {a x + b y + c, a + b == 0}, {a, b, c}, {x, y}]Properties (8)
Data & Fitted Functions (1)
data = {{0.1, 0.9, 0.2}, {0, 0.3, 0.5}, {0.7, 0.6, 3.}, {0.4, 0.3, 3.5}, {0.5, 0.8, 0.6}, {0.8, 0.6, 2.7}, {0.1, 0.1, 1.3}, {0.2, 0.8, 0.7}, {0.6, 0.6, 2.2}, {0.7, 0.8, 1.8}};nlm = NonlinearModelFit[data, Exp[a x - b y], {a, b}, {x, y}]nlm["Data"]{fit = nlm["BestFit"], Show[Plot3D[fit, {x, 0, 1}, {y, 0, 1}, PlotRange -> All], Graphics3D[{PointSize[0.025], Point[data]}]]}Obtain the fitted function as a pure function:
nlm["Function"]Residuals (1)
SeedRandom[0];
data = Table[{x, Log[2 + 3 x ^ 2] + RandomReal[{0, 0.5}]}, {x, RandomReal[{-10, 10}, 100]}];nlm = NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x]{fr, sr1, sr2} = nlm[{"FitResiduals", "StandardizedResiduals", "StudentizedResiduals"}];ListPlot[fr]Visualize scaled residuals in stem plots:
Map[ListPlot[#, Filling -> 0]&, {sr1, sr2}]Plot the absolute differences between the standardized and Studentized residuals:
ListPlot[sr1 - sr2]Sums of Squares (1)
Fit a nonlinear model to some data:
SeedRandom[0];
data = Flatten[Table[{x, y, .2Log[5x + .1y] + RandomReal[.1]}, {x, RandomReal[5, 10]}, {y, RandomReal[5, 10]}], 1];nlm = NonlinearModelFit[data, a Log[b x + c y], {a, b, c}, {x, y}]Extract the estimated error variance:
nlm["EstimatedVariance"]Obtain the analysis of variance table:
nlm["ANOVA"]Get the sums of squares column from the table:
nlm["ANOVA"][All, "SumOfSquares"]//NormalParameter Estimation Diagnostics (1)
Obtain a formatted table of parameter information:
SeedRandom[0];
data = Table[{x, Exp[2x + Sqrt[ x]] + RandomReal[{0, 0.5}]}, {x, RandomReal[100, 100]}];nlm = NonlinearModelFit[data, Exp[a x + Sqrt[b x]], {a, b}, x]nlm["ParameterEstimates"]Extract the column of 
-statistic values:
nlm["ParameterEstimates"][All, "TStatistic"]//NormalCurvature Diagnostics (1)
Fit a nonlinear model to some data:
data = {{8.76, 7.73, 0.17}, {5.34, 3.05, 1.16}, {7.65, 1.98, 0.95}, {1.21, 6.7, 0.42}, {2.04, 1.12, 0.42}, {3.13, 3.78, 0.71}, {2.93, 0.21, 0.9}, {6.05, 2.71, 1.14}, {7.67, 3.88, 0.61}, {7.26, 9.11, 0.72}, {0.88, 3.84, 0.61}, {5.32, 4.53, 0.69}, {6.46, 0.79, 0.83}, {4.5, 0.44, 0.46}, {1.1, 9.64, 0.2}};
nlm = NonlinearModelFit[data, a x / (b y + c x ^ 2), {a, b, c}, {x, y}]Obtain a table of curvature measures for the fitted model:
nlm["FitCurvature"]Extract the list of numeric values from the table:
nlm["FitCurvature"][All, "Curvature"]//NormalExtract the max parameter effects curvature value:
nlm["FitCurvature"][
SelectFirst[#Type === "Max Parameter Effects"& ],
"Curvature"
]Influence Measures (1)
Fit some data containing extreme values to a nonlinear model:
data = {{2., 2.33}, {3., 1.02}, {4., 2.42}, {5., 1.25}, {6., 3.36}, {7., 1.04}, {8., 2.}, {9., 1.39}, {10., 1.73}, {11., 2.34}, {12., 1.37}, {13., 2.45}, {14., 1.8}, {15., 1.45}, {16., 5.82}, {17., 2.61}, {18., 2.81}, {19., 2.12}, {20., 1.55}};
nlm = NonlinearModelFit[data, Exp[-a x / (b x ^ 3 - c x)], {a, b, c}, x]Use single deletion variances to check the impact on the error variance of removing each point:
ListPlot[nlm["SingleDeletionVariances"], PlotRange -> {0, All}, Filling -> 0]Check the diagonal elements of the hat matrix to assess influence of points on the fitting:
ListPlot[nlm["HatDiagonal"], PlotRange -> {0, All}, Filling -> 0]Prediction Values (1)
data = {{2.8, 9.1}, {3.5, 14.8}, {4.4, 24.1}, {3.9, 19.}, {2.7, 7.9}, {2.9, 10.6}, {0.6, 1.3}, {0.7, 1.6}, {0.2, 3.2}, {3.9, 18.3}};
nlm = NonlinearModelFit[data, a Exp[-b x ^ 2 / (c + x)], {a, b, c}, x]Plot the predicted values against the observed values:
ListPlot[Transpose[nlm[{"Response", "PredictedResponse"}]], FrameLabel -> {"observed", "predicted"}, Frame -> True, Axes -> False]Obtain tabular results for mean- and single-prediction confidence intervals:
nlm["MeanPredictions"]nlm["SinglePredictions"]Get the single-prediction intervals from the table:
nlm["SinglePredictions"][All, "ConfidenceInterval"]//NormalExtract 99% mean prediction bands:
nlm["MeanPredictionBands", ConfidenceLevel -> .99]Compute the 99% mean prediction bands at a specific location:
nlm[{"MeanPredictionBands", 3.5}, ConfidenceLevel -> .99]Goodness-of-Fit Measures (1)
Obtain a table of goodness-of-fit measures for a nonlinear model:
data = {{6.6, 9.4, 14.4}, {0.1, 5.6, 11.1}, {0.1, 3.1, 6.5}, {9.5, 4.7, 11.1}, {6.6, 2., 6.8}, {7., 6.2, 11.1}, {7., 6.9, 12.4}, {7., 1.5, 8.9}, {6.6, 0.2, 8.6}, {6.6, 2.1, 11.4}, {6.6, 9.3, 11.8}, {9.5, 2.5, 10.9}};nlm = NonlinearModelFit[data, Exp[a x + b y] + c, {a, b, c}, {x, y}]Grid[Transpose[{#, nlm[#]}&[{"AdjustedRSquared", "AIC", "BIC", "RSquared"}]], Alignment -> Left]Generalizations & Extensions (2)
Fit data to a model defined by a numerical operation:
data = {{6.47, 3.65}, {7.43, 3.45}, {3.9, -2.94}, {4.8, -1.29}, {2.48, -0.35}, {6.32, 3.16}, {2.59, -1.19}, {9.13, -2.}, {3.81, -3.04}, {3.33, -2.68}};model[a_ ? NumberQ, b_ ? NumberQ, c_ ? NumberQ] := Module[{y, x},
NDSolveValue[{y''[x] + a y[x] == 0, y[0] == b, y'[0] == c}, y, {x, 0, 10}]
]nlm = NonlinearModelFit[data, model[a, b, c][x], {a, b, c}, x, Method -> "Gradient"]Show[ListPlot[data], Plot[nlm[x], {x, 0, 10}, PlotStyle -> Orange]]Use ParametricNDSolveValue to make the computation much faster by caching solutions of the differential equation:
Clear[model];
model = ParametricNDSolveValue[{y''[x] + a y[x] == 0, y[0] == b, y'[0] == c}, y, {x, 0, 10}, {a, b, c}]nlm = NonlinearModelFit[data, model[a, b, c][x], {a, b, c}, x, Method -> "Gradient"]Perform other mathematical operations on the functional form of the model:
SeedRandom[0];
data = Exp[Range[10]] + RandomReal[1, 10];
nlm = NonlinearModelFit[data, Exp[a + b x], {a, b}, x]Integrate symbolically and numerically:
Integrate[nlm[x], x]NIntegrate[nlm[x], {x, 1, 5}]Find a predictor value that gives a particular value for the model:
FindRoot[nlm[x] == 10, {x, 1}]Options (14)
ConfidenceLevel (1)
The default gives 95% confidence intervals:
data = {{0, 1}, {1, 0}, {3, 2}, {5, 4}};nlm = NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x]nlm["ParameterEstimates"][All, "ConfidenceInterval"]//Normalnlm = NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x, ConfidenceLevel -> .99]nlm["ParameterEstimates"][All, "ConfidenceInterval"]//NormalSet the level to 90% within FittedModel:
nlm["ParameterEstimates", ConfidenceLevel -> .9][All, "ConfidenceInterval"]//NormalEvaluationMonitor (1)
Count evaluations of the model with numerical values of the parameters:
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.}};Block[{count = 0}, {NonlinearModelFit[data, 60 + 70Exp[-a x], a, x, EvaluationMonitor :> count++], count}]Gradient (1)
Specify the model gradient to avoid problems with a removable singularity:
data = {{0., -1.}, {.2, 2.}, {.5, 5.}, {.6, 4.}, {1., 0.}, {2., 0.}};With symbolic derivatives, NonlinearModelFit fails, since the derivative for Sinc is given as a generic formula:
NonlinearModelFit[data, a Sinc[ω(x - x0)], {a, ω, x0}, x]
The gradient has a singularity when 
, since there is a point in the data with 
:
D[a Sinc[ω(x - x0)], {{a, ω, x0}}]Specify finite differences to avoid the removable singularity:
fit = NonlinearModelFit[data, a Sinc[ω(x - x0)], {a, ω, x0}, x, Gradient -> "FiniteDifference"]Show[ListPlot[data], Plot[fit[x], {x, 0, 2}]]MaxIterations (1)
When convergence is slow, increasing MaxIterations may allow convergence to the best fit:
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:
NonlinearModelFit[data, model[x], {{a, 2.3}, {b, 3.2}, {c, 3.9}, {d, 4.9}}, x]
Convergence is reached before 1000 iterations are used:
NonlinearModelFit[data, model[x], {{a, 2.3}, {b, 3.2}, {c, 3.9}, {d, 4.9}}, x, MaxIterations -> 1000]Method (3)
Use the default method for minimizing the least-squares objective function:
NonlinearModelFit[{{0, 1}, {1, 0}, {3, 2}, {5, 4}}, Log[a + b x ^ 2], {a, b}, x]Use Newton's method for optimization:
NonlinearModelFit[{{0, 1}, {1, 0}, {3, 2}, {5, 4}}, Log[a + b x ^ 2], {a, b}, x, Method -> "Newton"]Configure the step control method for Newton's algorithm:
NonlinearModelFit[{{0, 1}, {1, 0}, {3, 2}, {5, 4}}, Log[a + b x ^ 2], {a, b}, x, Method -> {"Newton", "StepControl" -> {"LineSearch", Method -> "Brent"}}]Use the interior point method with constraints:
NonlinearModelFit[{{0, 1}, {1, 0}, {3, 2}, {5, 4}}, {Log[a + b x ^ 2], a > 0 && b > 0}, {a, b}, x, Method -> "InteriorPoint"]Perform a more exhaustive search with the global optimization methods from NMinimize:
NonlinearModelFit[{{0, 1}, {1, 0}, {3, 2}, {5, 4}}, {Log[a + b x ^ 2], a > 0 && b > 0}, {a, b}, x, Method -> "NMinimize"]Use the submethod "RandomSearch":
NonlinearModelFit[{{0, 1}, {1, 0}, {3, 2}, {5, 4}}, {Log[a + b x ^ 2], a > 0 && b > 0}, {a, b}, x, Method -> {"NMinimize", Method -> "RandomSearch"}]Specify the number of initial search points for the "RandomSearch" algorithm:
NonlinearModelFit[{{0, 1}, {1, 0}, {3, 2}, {5, 4}}, {Log[a + b x ^ 2], a > 0 && b > 0}, {a, b}, x, Method -> {"NMinimize", Method -> {"RandomSearch", "SearchPoints" -> 250}}]StepMonitor (1)
Show steps taken in parameter space to fit the Michaelis–Menten model to experimental data:
model = (Subscript[θ, 1]x/Subscript[θ, 2] + x);Data from an experiment on the rate of an enzymatic reaction:
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.}};{fit, steps} = Reap[NonlinearModelFit[data, model, {Subscript[θ, 1], Subscript[θ, 2]}, x, StepMonitor :> Sow[{Subscript[θ, 1], Subscript[θ, 2]}]]]fit["BestFitParameters"]Show how the parameters evolve during the search:
ListPlot[steps, Epilog -> {Red, Point[{Subscript[θ, 1], Subscript[θ, 2]} /. fit["BestFitParameters"]]}]VarianceEstimatorFunction (1)
Use the default unbiased estimate of error variance:
data = {{0, 1}, {1, 0}, {3, 2}, {5, 4}};nlm = NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x]nlm["EstimatedVariance"]Assume a known error variance:
nlm["EstimatedVariance", VarianceEstimatorFunction -> (1&)]Estimate the variance by the mean squared error:
nlm["EstimatedVariance", VarianceEstimatorFunction -> (Mean[# ^ 2]&)]Weights (4)
Fit a model using equal weights:
data = {{0, 1}, {1, 0}, {3, 2}, {5, 4}};NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x]//NormalGive explicit weights for the data points:
NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x, Weights -> {1, 1 / 2, 1 / 3, 1 / 4}]//NormalUse Around values to give different weights to data points:
data = {Around[1, 0.2], Around[2, 0.1], Around[4, 2]};
fit = NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x, Weights -> Automatic]Show[Plot[fit[x], {x, 0, 3}], ListPlot[data], PlotRange -> All]Find the weights that were used to account for the uncertainty in the data:
fit["Weights"]Use Around values in both the independent values and responses:
SeedRandom[1];
data = Table[
{Around[x, RandomReal[0.25]], Around[Log[2 + 3 x ^ 2] + RandomReal[0.25], RandomReal[0.25]]},
{x, 0, 3, 0.2}
];
fit = NonlinearModelFit[data, Log[a + b x ^ 2], {a, b}, x]Show[Plot[fit[x], {x, 0, 3}], ListPlot[data], PlotRange -> All]In some cases, the root finding algorithm that handles uncertainty in the independent variates does not converge using the standard option settings:
data = {...};
NonlinearModelFit[data, Exp[a x + b y], {a, b}, {x, y},
Weights -> {Automatic, Method -> FindRoot}
]
Use the FixedPoint algorithm with a low damping factor and high MaxIterations to reach convergence:
NonlinearModelFit[data, Exp[a x + b y], {a, b}, {x, y},
Weights -> {Automatic,
Method -> {FixedPoint, MaxIterations -> 500, DampingFactor -> 0.25, Tolerance -> 10 ^ (-10)
}
}
]WorkingPrecision (1)
Use WorkingPrecision to get higher precision in parameter estimates:
data = Table[{x, x ^ 2}, {x, 10}]nlm = NonlinearModelFit[data, Exp[a x], a, x, WorkingPrecision -> 50]nlm["BestFit"]Reduce the precision in property computations after the fitting:
nlm["BestFit", WorkingPrecision -> 20]Obtain the best fit at a specific point:
nlm[{"BestFit", 3.5}]Applications (1)
data = BlockRandom[SeedRandom[12345];Table[{x, Exp[-2.3 x / (11 + .4 x + x ^ 2)] + RandomReal[{-.5, .5}]}, {x, RandomReal[{1, 15}, 20]}]];Fit a nonlinear model to the data:
nlm = NonlinearModelFit[data, Exp[a x / (b + c x)], {a, b, c}, x]Obtain and visualize 90% confidence bands for the fit:
bands90[x_] = nlm["MeanPredictionBands", ConfidenceLevel -> .9];
Show[ListPlot[data], Plot[{nlm[x], bands90[x]}, {x, 1, 15}, Filling -> {2 -> {1}}]]Obtain 95%, 99%, and 99.9% confidence bands:
{bands95[x_], bands99[x_], bands999[x_]} = Table[nlm["MeanPredictionBands", ConfidenceLevel -> cl], {cl, {.95, .99, .999}}];Visualize the confidence bands for the various levels:
Show[ListPlot[data], Plot[{nlm[x], bands90[x], bands95[x], bands99[x], bands999[x]}, {x, 1, 15}, Filling -> {2 -> {1}, 3 -> {2}, 4 -> {3}, 5 -> {4}}, PlotLegends -> {"model", "90% confidence bands", "95% confidence bands", "99% confidence bands", "99.9% confidence bands"}]]Properties & Relations (6)
NonlinearModelFit fits linear and nonlinear models assuming normally distributed errors:
data = Table[{i, i}, {i, 10}];NonlinearModelFit[data, a + b x ^ 2, {a, b}, x]//NormalNonlinearModelFit[data, Exp[Sqrt[a x ^ b]], {a, b}, x]//NormalLinearModelFit fits linear models assuming normally distributed errors:
LinearModelFit[Range[10], x ^ 2, x]//NormalFindFit and NonlinearModelFit fit equivalent models:
SeedRandom[0];
data = Table[{i, Exp[RandomReal[{i - 1, i}]]}, {i, 10}];FindFit[data, Exp[a x], a, x]nlm = NonlinearModelFit[data, Exp[a x], a, x]nlm["BestFitParameters"]NonlinearModelFit allows for extraction of additional information about the fitting:
nlm["FitResiduals"]NonlinearModelFit assumes normally distributed responses:
SeedRandom[0];
data = Table[{i, RandomReal[{i - 1, i}] / 10}, {i, 10}];nm = NonlinearModelFit[data, 1 / (1 + Exp[a + b x]), {a, b}, x]LogitModelFit assumes binomially distributed responses:
lm = LogitModelFit[data, x, x]{Normal[lm], Normal[nm]}Plot[{lm[x], nm[x]}, {x, 1, 5}]The same is true for ProbitModelFit:
pm = ProbitModelFit[data, x, x]nm2 = NonlinearModelFit[data, 1 / 2(1 + Erf[(a + b x) / Sqrt[2]]), Transpose[{{a, b}, pm["BestFitParameters"]}], x]{Normal[pm], Normal[nm2]}NonlinearModelFit will use the time stamps of a TimeSeries as variables:
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];ts1["Times"]NonlinearModelFit[ts1, Exp[a + b x], {a, b}, x]Rescale the time stamps and fit again:
ts2 = TimeSeriesRescale[ts1, {.1, 2}]ts2["Times"]NonlinearModelFit[ts2, Exp[a + b x], {a, b}, x]NonlinearModelFit[ts1["Values"], Exp[a + b x], {a, b}, x]NonlinearModelFit acts pathwise on a multipath TemporalData:
NonlinearModelFit[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]Compute the AIC from first principles:
data = {{0, 1}, {1, 0}, {3, 2}, {5, 4}, {6, 4}, {7, 5}};
n = Length[data];
params = {a, b};
k = Length[params] + 1; (* +1 for the estimation of the variance *)
nlm = NonlinearModelFit[data, Log[a + b x ^ 2], params, x];
errorSumOfSquares = Total[nlm["FitResiduals"] ^ 2];
varianceMLE = errorSumOfSquares / n;
logLike = (-1 / 2) * (n * Log[2Pi * varianceMLE] +
errorSumOfSquares / varianceMLE);
aic = 2 * k - 2 * logLikeCompare against the "AIC" property:
nlm["AIC"] == aicnlm["AICc"] == aic + (2k * (k + 1)) / (n - k - 1)nlm["BIC"] == Log[n] * k - 2 * logLikePossible Issues (3)
Distributional assumptions are based upon an unconstrained model:
data = {{1., 0.75}, {2., 0.89}, {3., 0.42}, {4., 0.99}, {5., 0.84}, {6., 0.34}, {7., 0.83}, {8., 0.93}, {9., 0.76}, {10., 0.11}};
nlm = NonlinearModelFit[data, {Exp[a + b x ^ 2], b < -1 / 2}, {{a, 0}, {b, -1}}, x]Here the confidence interval for 
contains points that violate the constraint:
nlm["ParameterEstimates"]
The coefficient of determination 
in NonlinearModelFit is calculated with uncorrected data:
data = {{6.6, 9.4, 14.4}, {0.1, 5.6, 11.1}, {0.1, 3.1, 6.5}, {9.5, 4.7, 11.1}, {6.6, 2., 6.8}, {7., 6.2, 11.1}, {7., 6.9, 12.4}, {7., 1.5, 8.9}, {6.6, 0.2, 8.6}, {6.6, 2.1, 11.4}, {6.6, 9.3, 11.8}, {9.5, 2.5, 10.9}};nlm = NonlinearModelFit[data, Exp[a x + b y] + c, {a, b, c}, {x, y}]The coefficient of determination:
nlm["RSquared"]Direct calculation using residuals and data:
1 - (nlm["FitResiduals"].nlm["FitResiduals"]) / (data[[All, 3]].data[[All, 3]])Sometimes 
is defined using centralized data:
centralized = data[[All, 3]] - Mean[data[[All, 3]]];
1 - (nlm["FitResiduals"].nlm["FitResiduals"]) / (centralized.centralized)Fit data that spans over multiple orders of magnitude:
SeedRandom[4];
data = Table[{x, Exp[-x + .5RandomReal[]]}, {x, 0, 10, .1}];
ListPlot[data]An exponential fit might appear correct at first glance:
fit = NonlinearModelFit[data, a Exp[-b x], {a, b}, x]Show[
Plot[fit[x], {x, 0, 10}, PlotRange -> All],
ListPlot[data]
]But shows significant deviations on a log scale:
Show[
LogPlot[fit[x], {x, 0, 10}, PlotRange -> All],
ListLogPlot[data]
]This can be addressed by using weights inversely proportional to the variance:
fit2 = NonlinearModelFit[data, a Exp[-b x], {a, b}, x, Weights -> (1/data[[All, 2]] ^ 2)]Show[
LogPlot[fit2[x], {x, 0, 10}, PlotRange -> All],
ListLogPlot[data]
]Text
Wolfram Research (2008), NonlinearModelFit, Wolfram Language function, https://reference.wolfram.com/language/ref/NonlinearModelFit.html (updated 2025).
CMS
Wolfram Language. 2008. "NonlinearModelFit." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2025. https://reference.wolfram.com/language/ref/NonlinearModelFit.html.
APA
Wolfram Language. (2008). NonlinearModelFit. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/NonlinearModelFit.html