Limited-memory BFGS (L-BFGS orLM-BFGS) is anoptimizationalgorithm in the collection ofquasi-Newton methods that approximates theBroyden–Fletcher–Goldfarb–Shanno algorithm (BFGS) using a limited amount ofcomputer memory.^[1] It is a popular algorithm for parameter estimation inmachine learning.^[2][3] The algorithm's target problem is to minimize${\displaystyle f(\mathbf{x})}$ over unconstrained values of the real-vector${\displaystyle \mathbf{x}}$ where${\displaystyle f}$ is a differentiable scalar function.

Like the original BFGS, L-BFGS uses an estimate of the inverseHessian matrix to steer its search through variable space, but where BFGS stores a dense${\displaystyle n\times n}$ approximation to the inverse Hessian (n being the number of variables in the problem), L-BFGS stores only a few vectors that represent the approximation implicitly. Due to its resulting linear memory requirement, the L-BFGS method is particularly well suited for optimization problems with many variables. Instead of the inverse HessianH_k, L-BFGS maintains a history of the pastm updates of the positionx and gradient ∇f(x), where generally the history sizem can be small (often). These updates are used to implicitly do operations requiring theH_k-vector product.

The algorithm starts with an initial estimate of the optimal value,${\displaystyle {\mathbf{x}}_0}$, and proceeds iteratively to refine that estimate with a sequence of better estimates${\displaystyle {\mathbf{x}}_1,{\mathbf{x}}_2,\dots }$. The derivatives of the function${\displaystyle g_k:=\mathrm{\nabla }f({\mathbf{x}}_k)}$ are used as a key driver of the algorithm to identify the direction of steepest descent, and also to form an estimate of the Hessian matrix (second derivative) of${\displaystyle f(\mathbf{x})}$.

L-BFGS shares many features with other quasi-Newton algorithms, but is very different in how the matrix-vector multiplication${\displaystyle d_k=-H_k{g}_k}$ is carried out, where${\displaystyle d_k}$ is the approximate Newton's direction,${\displaystyle g_k}$ is the current gradient, and${\displaystyle H_k}$ is the inverse of the Hessian matrix. There are multiple published approaches using a history of updates to form this direction vector. Here, we give a common approach, the so-called "two loop recursion."^[4][5]

We take as given${\displaystyle x_k}$, the position at thek-th iteration, and${\displaystyle g_k\equiv \mathrm{\nabla }f(x_k)}$ where${\displaystyle f}$ is the function being minimized, and all vectors are column vectors. We also assume that we have stored the lastm updates of the form

${\displaystyle s_k=x_{k+1}-x_k}$

${\displaystyle y_k=g_{k+1}-g_k}$.

We define${\displaystyle {\rho }_k=\frac{1}{y_k^{\mathrm{\top }}{s}_k}}$, and${\displaystyle H_k^0}$ will be the 'initial' approximate of the inverse Hessian that our estimate at iterationk begins with.

The algorithm is based on the BFGS recursion for the inverse Hessian as

${\displaystyle H_{k+1}=(I-{\rho }_k{s}_k{y}_k^{\mathrm{\top }})H_k(I-{\rho }_k{y}_k{s}_k^{\mathrm{\top }})+{\rho }_k{s}_k{s}_k^{\mathrm{\top }}.}$

For a fixedk we define a sequence of vectors${\displaystyle q_{k-m},\dots ,q_k}$ as${\displaystyle q_k:=g_k}$ and${\displaystyle q_i:=(I-{\rho }_i{y}_i{s}_i^{\mathrm{\top }})q_{i+1}}$. Then a recursive algorithm for calculating${\displaystyle q_i}$ from${\displaystyle q_{i+1}}$ is to define${\displaystyle {\alpha }_i:={\rho }_i{s}_i^{\mathrm{\top }}{q}_{i+1}}$ and${\displaystyle q_i=q_{i+1}-{\alpha }_i{y}_i}$. We also define another sequence of vectors${\displaystyle z_{k-m},\dots ,z_k}$ as${\displaystyle z_i:=H_i{q}_i}$. There is another recursive algorithm for calculating these vectors which is to define${\displaystyle z_{k-m}=H_k^0{q}_{k-m}}$ and then recursively define${\displaystyle {\beta }_i:={\rho }_i{y}_i^{\mathrm{\top }}{z}_i}$ and${\displaystyle z_{i+1}=z_i+({\alpha }_i-{\beta }_i)s_i}$. The value of${\displaystyle z_k}$ is then our ascent direction.

Thus we can compute thedescent direction as follows:

${\displaystyle \begin{array}{l}q=g_k\\ \mathtt{F}\mathtt{o}\mathtt{r}i=k-1,k-2,\dots ,k-m\\ {\alpha }_i={\rho }_i{s}_i^{\mathrm{\top }}q\\ q=q-{\alpha }_i{y}_i\\ {\gamma }_k=\frac{s_{k-m}^{\mathrm{\top }}{y}_{k-m}}{y_{k-m}^{\mathrm{\top }}{y}_{k-m}}\\ H_k^0={\gamma }_{k}I\\ z=H_k^{0}q\\ \mathtt{F}\mathtt{o}\mathtt{r}i=k-m,k-m+1,\dots ,k-1\\ {\beta }_i={\rho }_i{y}_i^{\mathrm{\top }}z\\ z=z+s_i({\alpha }_i-{\beta }_i)\\ z=-z\end{array}}$

This formulation gives the search direction for the minimization problem, i.e.,${\displaystyle z=-H_k{g}_k}$. For maximization problems, one should thus take-z instead. Note that the initial approximate inverse Hessian${\displaystyle H_k^0}$ is chosen as adiagonal matrix or even a multiple of the identity matrix since this is numerically efficient.

The scaling of the initial matrix${\displaystyle {\gamma }_k}$ ensures that the search direction is well scaled and therefore the unit step length is accepted in most iterations. AWolfe line search is used to ensure that the curvature condition is satisfied and the BFGS updating is stable. Note that some software implementations use an Armijobacktracking line search, but cannot guarantee that the curvature condition${\displaystyle y_k^{\mathrm{\top }}{s}_k>0}$ will be satisfied by the chosen step since a step length greater than${\displaystyle 1}$ may be needed to satisfy this condition. Some implementations address this by skipping the BFGS update when${\displaystyle y_k^{\mathrm{\top }}{s}_k}$ is negative or too close to zero, but this approach is not generally recommended since the updates may be skipped too often to allow the Hessian approximation${\displaystyle H_k}$ to capture important curvature information. Some solvers employ so called damped (L)BFGS update which modifies quantities${\displaystyle s_k}$ and${\displaystyle y_k}$ in order to satisfy the curvature condition.

The two-loop recursion formula is widely used by unconstrained optimizers due to its efficiency in multiplying by the inverse Hessian. However, it does not allow for the explicit formation of either the direct or inverse Hessian and is incompatible with non-box constraints. An alternative approach is thecompact representation, which involves a low-rank representation for the direct and/or inverse Hessian.^[6] This represents the Hessian as a sum of a diagonal matrix and a low-rank update. Such a representation enables the use of L-BFGS in constrained settings, for example, as part of the SQP method.

L-BFGS has been called "the algorithm of choice" for fittinglog-linear (MaxEnt) models andconditional random fields with${\displaystyle {\ell }_2}$-regularization.^[2][3]

Since BFGS (and hence L-BFGS) is designed to minimizesmooth functions withoutconstraints, the L-BFGS algorithm must be modified to handle functions that include non-differentiable components or constraints. A popular class of modifications are called active-set methods, based on the concept of theactive set. The idea is that when restricted to a small neighborhood of the current iterate, the function and constraints can be simplified.

TheL-BFGS-B algorithm extends L-BFGS to handle simple box constraints (aka bound constraints) on variables; that is, constraints of the forml_i ≤x_i ≤u_i wherel_i andu_i are per-variable constant lower and upper bounds, respectively (for eachx_i, either or both bounds may be omitted).^[7][8] The method works by identifying fixed and free variables at every step (using a simple gradient method), and then using the L-BFGS method on the free variables only to get higher accuracy, and then repeating the process.

Orthant-wise limited-memory quasi-Newton (OWL-QN) is an L-BFGS variant for fitting${\displaystyle {\ell }_1}$-regularized models, exploiting the inherentsparsity of such models.^[3]It minimizes functions of the form

${\displaystyle f(\overrightarrow{x})=g(\overrightarrow{x})+C\Vert \overrightarrow{x}{\Vert }_1}$

where${\displaystyle g}$ is adifferentiableconvexloss function. The method is an active-set type method: at each iterate, it estimates thesign of each component of the variable, and restricts the subsequent step to have the same sign. Once the sign is fixed, the non-differentiable${\displaystyle \Vert \overrightarrow{x}{\Vert }_1}$ term becomes a smooth linear term which can be handled by L-BFGS. After an L-BFGS step, the method allows some variables to change sign, and repeats the process.

Schraudolphet al. present anonline approximation to both BFGS and L-BFGS.^[9] Similar tostochastic gradient descent, this can be used to reduce the computational complexity by evaluating theerror function and gradient on a randomly drawn subset of the overall dataset in each iteration. It has been shown that O-LBFGS has a global almost sure convergence^[10] while the online approximation of BFGS (O-BFGS) is not necessarily convergent.^[11]

Notable open source implementations include:

• ALGLIB implements L-BFGS in C++ and C# as well as a separate box/linearly constrained version, BLEIC.
• R'soptim general-purpose optimizer routine uses the L-BFGS-B method.
• SciPy's optimization module's minimize method also includes an option to use L-BFGS-B.
• Julia'sOptim.jl also implements the L-BFGS and L-BFGS-B algorithm.^[12]
• Stan implements L-BFGS together withautomatic differentiation as an option to solvemaximum likelihood estimation andmaximum a posteriori estimation problems.

Notable non open source implementations include:

• The L-BFGS-B variant also exists as ACM TOMS algorithm 778.^[8][13] In February 2011, some of the authors of the original L-BFGS-B code posted a major update (version 3.0).
• A reference implementation inFortran 77 (and with aFortran 90 interface).^[14][15] This version, as well as older versions, has been converted to many other languages.
• An OWL-QN C++ implementation by its designers.^[3][16]

• Liu, D. C.; Nocedal, J. (1989)."On the Limited Memory Method for Large Scale Optimization".Mathematical Programming B.45 (3):503–528.CiteSeerX 10.1.1.110.6443.doi:10.1007/BF01589116.S2CID 5681609.
• Haghighi, Aria (2 Dec 2014)."Numerical Optimization: Understanding L-BFGS".
• Pytlak, Radoslaw (2009)."Limited Memory Quasi-Newton Algorithms".Conjugate Gradient Algorithms in Nonconvex Optimization. Springer. pp. 159–190.ISBN 978-3-540-85633-7.

• Optimization algorithms and methods

• Articles with short description
• Short description matches Wikidata