
TheGauss–Newton algorithm is used to solvenon-linear least squares problems, which is equivalent to minimizing a sum of squared function values. It is an extension ofNewton's method for finding aminimum of a non-linearfunction. Since a sum of squares must be nonnegative, the algorithm can be viewed as using Newton's method to iteratively approximatezeroes of the components of the sum, and thus minimizing the sum. In this sense, the algorithm is also an effective method forsolving overdetermined systems of equations. It has the advantage that second derivatives, which can be challenging to compute, are not required.[1]
Non-linear least squares problems arise, for instance, innon-linear regression, where parameters in a model are sought such that the model is in good agreement with available observations.
The method is named after the mathematiciansCarl Friedrich Gauss andIsaac Newton, and first appeared in Gauss's 1809 workTheoria motus corporum coelestium in sectionibus conicis solem ambientum.[2]
Given functions (often called residuals) of variables with the Gauss–Newton algorithmiteratively finds the value of that minimize the sum of squares[3]
Starting with an initial guess for the minimum, the method proceeds by the iterations
where, ifr andβ arecolumn vectors, the entries of theJacobian matrix are
and the symbol denotes thematrix transpose.
At each iteration, the update can be found by rearranging the previous equation in the following two steps:
With substitutions,, and, this turns into the conventional matrix equation of form, which can then be solved in a variety of methods (seeNotes).
Ifm =n, the iteration simplifies to
which is a direct generalization ofNewton's method in one dimension.
In data fitting, where the goal is to find the parameters such that a given model function best fits some data points, the functionsare theresiduals:
Then, the Gauss–Newton method can be expressed in terms of the Jacobian of the function as
Note that is the leftpseudoinverse of.
The assumptionm ≥n in the algorithm statement is necessary, as otherwise the matrix is not invertible and the normal equations cannot be solved (at least uniquely).
The Gauss–Newton algorithm can be derived bylinearly approximating the vector of functionsri. UsingTaylor's theorem, we can write at every iteration:
with. The task of finding minimizing the sum of squares of the right-hand side; i.e.,
is alinear least-squares problem, which can be solved explicitly, yielding the normal equations in the algorithm.
The normal equations aren simultaneous linear equations in the unknown increments. They may be solved in one step, usingCholesky decomposition, or, better, theQR factorization of. For large systems, aniterative method, such as theconjugate gradient method, may be more efficient. If there is a linear dependence between columns ofJr, the iterations will fail, as becomes singular.
When is complex the conjugate form should be used:.

In this example, the Gauss–Newton algorithm will be used to fit a model to some data by minimizing the sum of squares of errors between the data and model's predictions.
In a biology experiment studying the relation between substrate concentration[S] and reaction rate in an enzyme-mediated reaction, the data in the following table were obtained.
| i | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|---|---|---|---|---|---|---|---|
| [S] | 0.038 | 0.194 | 0.425 | 0.626 | 1.253 | 2.500 | 3.740 |
| Rate | 0.050 | 0.127 | 0.094 | 0.2122 | 0.2729 | 0.2665 | 0.3317 |
It is desired to find a curve (model function) of the form
that fits best the data in the least-squares sense, with the parameters and to be determined.
Denote by and the values of[S] andrate respectively, with. Let and. We will find and such that the sum of squares of the residuals
is minimized.
The Jacobian of the vector of residuals with respect to the unknowns is a matrix with the-th row having the entries
Starting with the initial estimates of and, after five iterations of the Gauss–Newton algorithm, the optimal values and are obtained. The sum of squares of residuals decreased from the initial value of 1.445 to 0.00784 after the fifth iteration. The plot in the figure on the right shows the curve determined by the model for the optimal parameters with the observed data.
The Gauss-Newton iteration is guaranteed to converge toward a local minimum point under 4 conditions:[4] The functions are twice continuously differentiable in an open convex set, the Jacobian is of full column rank, the initial iterate is near, and the local minimum value is small. The convergence is quadratic if.
It can be shown[5] that the increment Δ is adescent direction forS, and, if the algorithm converges, then the limit is astationary point ofS. For large minimum value, however, convergence is not guaranteed, not evenlocal convergence as inNewton's method, or convergence under the usual Wolfe conditions.[6]
The rate of convergence of the Gauss–Newton algorithm can approachquadratic.[7] The algorithm may converge slowly or not at all if the initial guess is far from the minimum or the matrix isill-conditioned. For example, consider the problem with equations and variable, given by
For, is a local optimum. If, then the problem is in fact linear and the method finds the optimum in one iteration. If |λ| < 1, then the method converges linearly and the error decreases asymptotically with a factor |λ| at every iteration. However, if |λ| > 1, then the method does not even converge locally.[8]
The Gauss-Newton iterationis an effective method for solvingoverdetermined systems of equations in the form of withand where is theMoore-Penrose inverse (also known aspseudoinverse) of theJacobian matrix of. It can be considered an extension ofNewton's method and enjoys the same local quadratic convergence[4] toward isolated regular solutions.
If the solution doesn't exist but the initial iterate is near a point at which the sum of squares reaches a small local minimum, the Gauss-Newton iteration linearly converges to. The point is often called aleast squares solution of the overdetermined system.
In what follows, the Gauss–Newton algorithm will be derived fromNewton's method for function optimization via an approximation. As a consequence, the rate of convergence of the Gauss–Newton algorithm can be quadratic under certain regularity conditions. In general (under weaker conditions), the convergence rate is linear.[9]
The recurrence relation for Newton's method for minimizing a functionS of parameters is
whereg denotes thegradient vector ofS, andH denotes theHessian matrix ofS.
Since, the gradient is given by
Elements of the Hessian are calculated by differentiating the gradient elements,, with respect to:
The Gauss–Newton method is obtained by ignoring the second-order derivative terms (the second term in this expression). That is, the Hessian is approximated by
where are entries of the JacobianJr. Note that when the exact hessian is evaluated near an exact fit we have near-zero, so the second term becomes near-zero as well, which justifies the approximation. The gradient and the approximate Hessian can be written in matrix notation as
These expressions are substituted into the recurrence relation above to obtain the operational equations
Convergence of the Gauss–Newton method is not guaranteed in all instances. The approximation
that needs to hold to be able to ignore the second-order derivative terms may be valid in two cases, for which convergence is to be expected:[10]
With the Gauss–Newton method the sum of squares of the residualsS may not decrease at every iteration. However, since Δ is a descent direction, unless is a stationary point, it holds that for all sufficiently small. Thus, if divergence occurs, one solution is to employ a fraction of the increment vector Δ in the updating formula:
In other words, the increment vector is too long, but it still points "downhill", so going just a part of the way will decrease the objective functionS. An optimal value for can be found by using aline search algorithm, that is, the magnitude of is determined by finding the value that minimizesS, usually using adirect search method in the interval or abacktracking line search such asArmijo-line search. Typically, should be chosen such that it satisfies theWolfe conditions or theGoldstein conditions.[11]
In cases where the direction of the shift vector is such that the optimal fraction α is close to zero, an alternative method for handling divergence is the use of theLevenberg–Marquardt algorithm, atrust region method.[3] The normal equations are modified in such a way that the increment vector is rotated towards the direction ofsteepest descent,
whereD is a positive diagonal matrix. Note that whenD is the identity matrixI and, then, therefore thedirection of Δ approaches the direction of the negative gradient.
The so-called Marquardt parameter may also be optimized by a line search, but this is inefficient, as the shift vector must be recalculated every time is changed. A more efficient strategy is this: When divergence occurs, increase the Marquardt parameter until there is a decrease inS. Then retain the value from one iteration to the next, but decrease it if possible until a cut-off value is reached, when the Marquardt parameter can be set to zero; the minimization ofS then becomes a standard Gauss–Newton minimization.
For large-scale optimization, the Gauss–Newton method is of special interest because it is often (though certainly not always) true that the matrix is moresparse than the approximate Hessian. In such cases, the step calculation itself will typically need to be done with an approximate iterative method appropriate for large and sparse problems, such as theconjugate gradient method.
In order to make this kind of approach work, one needs at least an efficient method for computing the product
for some vectorp. Withsparse matrix storage, it is in general practical to store the rows of in a compressed form (e.g., without zero entries), making a direct computation of the above product tricky due to the transposition. However, if one definesci as rowi of the matrix, the following simple relation holds:
so that every row contributes additively and independently to the product. In addition to respecting a practical sparse storage structure, this expression is well suited forparallel computations. Note that every rowci is the gradient of the corresponding residualri; with this in mind, the formula above emphasizes the fact that residuals contribute to the problem independently of each other.
In aquasi-Newton method, such as that due toDavidon, Fletcher and Powell or Broyden–Fletcher–Goldfarb–Shanno (BFGS method) an estimate of the full Hessian is built up numerically using first derivatives only so that aftern refinement cycles the method closely approximates to Newton's method in performance. Note that quasi-Newton methods can minimize general real-valued functions, whereas Gauss–Newton, Levenberg–Marquardt, etc. fits only to nonlinear least-squares problems.
Another method for solving minimization problems using only first derivatives isgradient descent. However, this method does not take into account the second derivatives even approximately. Consequently, it is highly inefficient for many functions, especially if the parameters have strong interactions.
The following implementation inJulia provides one method which uses a provided Jacobian and another computing withautomatic differentiation.
""" gaussnewton(r, J, β₀, maxiter, tol)Perform Gauss–Newton optimization to minimize the residual function `r` with Jacobian `J` starting from `β₀`. The algorithm terminates when the norm of the step is less than `tol` or after `maxiter` iterations."""functiongaussnewton(r,J,β₀,maxiter,tol)β=copy(β₀)for_in1:maxiterJβ=J(β);Δ=-(Jβ'*Jβ)\(Jβ'*r(β))β+=Δifsqrt(sum(abs2,Δ))<tolbreakendendreturnβendimportAbstractDifferentiationasAD,Zygotebackend=AD.ZygoteBackend()# other backends are available""" gaussnewton(r, β₀, maxiter, tol)Perform Gauss–Newton optimization to minimize the residual function `r` starting from `β₀`. The relevant Jacobian is calculated using automatic differentiation. The algorithm terminates when the norm of the step is less than `tol` or after `maxiter` iterations."""functiongaussnewton(r,β₀,maxiter,tol)β=copy(β₀)for_in1:maxiterrβ,Jβ=AD.value_and_jacobian(backend,r,β)Δ=-(Jβ[1]'*Jβ[1])\(Jβ[1]'*rβ)β+=Δifsqrt(sum(abs2,Δ))<tolbreakendendreturnβend
{{cite web}}: CS1 maint: archived copy as title (link){{cite book}}: CS1 maint: publisher location (link)