Conjugate Gradient Methods

Conjugate Gradient Methods
MA 348
Kurt Bryan
Introduction
We want to minimize a nonlinear twice continuously differentiable function of n variables.
Taylor’s Theorem shows that such functions are locally well-approximated by quadratic
polynomials. It then seems reasonable that methods which do well on quadratics should do
well on more general nonlinear functions, at least once we get close enough to a minimum.
This simple observation was the basis for Newton’s Method.
But Newton’s Method has some drawbacks. First, we have to be able to compute the
Hessian matrix, which is n by n, and we have to do this at every iteration. This is a serious
problem for a function of 1000 variables, both in computational time and storage. Second,
we have to solve a dense n by n system of equations, also time consuming. Finite difference
approximations for the derivatives doesn’t really resolve these issues.
It would be nice to come up with optimization algorithms that don’t require use of the
full Hessian, but which, like Newton’s method, perform well on quadratic functions. This
is what conjugate gradient methods do (and also quasi-Newton methods, which we’ll talk
about later). First, we’ll study the efficient minimization of quadratic functions (without
the use of second derivatives).
Quadratic Functions
Suppose that f(x) is a quadratic function of n real variables in the form. Such a function
can always be written in the form
f(x) =
1
2
xT
Ax + xT
b + c (1)
for some n by n matrix A, n vector b and scalar c. The 1/2 in front isn’t essential, but it make
things a bit cleaner later. You should convince yourself of this (see exercise below). Also,
there’s no loss of generality in assuming that A is symmetric, because (xT
Ax)T
= xT
AT
x
for all x, and so we have
xT
Ax = xT
(
1
2
(A + AT
))x
for all x, and 1
2
(A + AT
) is symmetric. In short, A can be replaced with 1
2
(A + AT
).
Exercise 1
• Write f(x1, x2) = x2
1 + x1x2 + 4x2
2 − 3x1 + x2 + 1 in the form (1) with A symmetric.
1

We’ll consider for now the problem of minimizing a function of the form (1) with A
symmetric. It will be useful to note, as we did in deriving Newton’s method, that
∇f(x) = Ax + b (2)
where ∇f is written as a column of partial derivatives. You can convince yourself of this
fact by writing things out in summation notation,
f(x) = c +
1
2
n
∑
i=1
n
∑
j=1
Aijxixj +
n
∑
i=1
bixi
then differentiating with respect to xk (and using the symmetry of A, i.e., Aik = Aki) to
obtain
∂f
∂xk
=
1
2
n
∑
i=1
Aikxi +
1
2
n
∑
j=1
Akjxj + bk
=
n
∑
i=1
Akixi + bk
which is exactly the component-by-component statement of equation (2). You can use the
same reasoning to check that the Hessian matrix for f is exactly A.
We also will assume that A is positive definite. In this case f has a unique critical point,
and this critical point is a minimum. To see this, note that since A is positive definite, A is
invertible, and hence from (2) the only critical point is −A−1
b. As we showed in analyzing
Newton’s method, this must be a minimum if the Hessian of f (in this case just A) is positive
definite.
Minimizing Quadratic Functions
Let’s start with an example. Let n = 3 and let A = 2I, the n by n identity matrix. In
this case f(x) = x2
1 +x2
2 +x2
3. Of course the unique minimum is at the origin, but pretend we
want to find it with the “one-variable at a time” algorithm, in which we take an initial guess
and then do line searches in directions e1, e2, e3, and then repeat the cycle (here ei is the
standard coordinate vector in the xi direction). If we start with initial guess x0 = (1, 2, 3)
and minimize in direction e1 (i.e., in the variable x1) we find x1 = (0, 2, 3) from this line
search. Now do a line search from point x1 using search direction e2 to find x2 = (0, 0, 3).
Note an important fact: the second line search didn’t mess up the first line search, in the
sense that if we now repeated the e1 search from x2 we’d find we’re ALREADY at the
minimum. Of course the third line search from x2 in the direction e3 takes us to the origin,
2

and doesn’t mess up the results from the previous line searches—we’re still at a minimum
with respect to x1 and x2, i.e., the global minimum. This approach has taken us to the
minimum in exactly 3 iterations.
Contrast the above situation with that obtain by using this technique but instead on the
function f(x1, x2, x3) = x2
1 + x1x2 + x2
2 + x2
3, again with x0 = (1, 2, 3). The first line search
in direction e1 takes us to x1 = (−1, 2, 3). The second line search from x1 in direction e2
takes us to x2 = (−1, 1/2, 3). But now note that the e2 search has “messed up” the first line
search, in that if we now repeat a line search from x2 in the direction e1 we find we’re no
longer at a minimum in the x1 variable (it has shifted to x1 = −1/4).
The problem in the second case is that the search directions ei partially conflict with each
other, so each line search partly undoes the progress made by the previous line searches. This
didn’t happen for f(x) = xT
Ix, and so we got to the minimum quickly.
Line Searches and Quadratic Functions
Most of the algorithms we’ve developed for finding minima involve a series of line searches.
Consider performing a line search on the function f(x) = c + xT
b + 1
2
xT
Ax from some base
point a in the direction v, i.e., minimizing f along the line L(t) = a + tv. This amounts to
minimizing the function
g(t) = f(a + tv) =
1
2
vT
Avt2
+ (vT
Aa + vT
b)t +
1
2
aT
Aa + aT
b + c. (3)
Since 1
2
vT
Av > 0 (A is positive definite), the quadratic function g(t) ALWAYS has a unique
global minimum in t, for g is quadratic in t with a positive coefficient in front of t2
. The
minimum occurs when g′
(t) = (vT
Av)t + (vT
Aa + vT
b) = 0, i.e., at t = t∗
where
t∗
= −
vT
(Aa + b)
vT Av
= −
vT
∇f(a)
vT Av
. (4)
Note that if v is a descent direction (vT
∇f(a) < 0) then t∗
> 0.
Another thing to note is this: Let p = a + t∗
v, so p is the minimum of f on the line
a+tv. Since g′
(t) = ∇f(a+tv)·v and g′
(t∗
) = 0, we see that the minimizer p is the unique
point on the line a + tv for which (note vT
∇f = v · ∇f)
∇f(p) · v = 0. (5)
Thus if we are at some point b in lRn
and want to test whether we’re at a minimum for a
quadratic function f with respect to some direction v, we merely test whether ∇f(b)·v = 0.
3

Conjugate Directions
Look back at the example for minimizing f(x) = xT
Ix = x2
1 + x2
2 + x2
3. We minimized
in direction e1 = (1, 0, 0), and then in direction e2 = (0, 1, 0), and arrived at the point
x2 = (0, 0, 3). Did the e2 line search mess up the fact that we were at a minimum with
respect to e1? No! You can check that ∇f(x2) · e1 = 0, that is, x2 minimizes f in BOTH
directions e1 AND e2. For this function e1 and e2 are “non-interfering”. Of course e3 shares
this property.
But now look at the second example, of minimizing f(x) = x2
1 + x1x2 + x2
2 + x2
3. Af-
ter minimizing in e1 and e2 we find ourselves at the point x2 = (−1, 1/2, 3). Of course
∇f(x2) · e2 = 0 (that’s how we got to x2 from x1—by minimizing in direction e2). But the
minimization in direction e2 has destroyed the fact that we’re at a minimum with respect
to direction e1: we find that ∇f(x2) · e1 = −3/2. So at some point we’ll have to redo the
e1 minimization again, which will mess up the e2 minimization, and probably e3 too. Every
direction in the set e1, e2, e3 conflicts with every other direction.
The idea behind the conjugate direction approach for minimizing quadratic functions is
to use search directions which don’t interfere with one another. Given a symmetric positive
definite matrix A, we will call a set of vectors d0, d1, . . . , dn−1 conjugate (or “A conjugate”,
or even “A orthogonal”) if
dT
i Adj = 0 (6)
for i ̸= j. Note that dT
i Adi > 0 for all i, since A is positive definite.
Theorem 1: If the set S = {d0, d1, . . . , dn−1} is conjugate and all di are non-zero then
S forms a basis for lRn
.
Proof: Since S has n vectors, all we need to show is that S is linearly independent, since it
then automatically spans lRn
. Start with
c1d1 + c2d2 + · · · + cndn = 0.
Multiply on the right by A, distribute over the sum, and then multiply the whole mess by
dT
i to obtain
cidT
i Adi = 0.
We immediately conclude that ci = 0, so the set S is linearly independent and hence a basis
for lRn
.
Example 1: Let
A =



3 1 0
1 2 2
0 2 4


 .
4

Choose d0 = (1, 0, 0)T
. We want to choose d1 = (a, b, c) so that dT
1 Ad0 = 0, which leads to
3a + b = 0. So choose d1 = (1, −3, 0). Now let d2 = (a, b, c) and require dT
2 Ad0 = 0 and
dT
2 Ad0 = 0, which yields 3a + b = 0 and −5b − 6c = 0. This can be written as a = −b/3
and c = −5b/6. We can take d2 = (−2, 6, −5).
Here’s a simple version of a conjugate direction algorithm for minimizing f(x) = 1
2
xT
Ax+
xT
b + c, assuming we already have a set of conjugate directions di:
1. Make an initial guess x0. Set k = 0.
2. Perform a line search from xk in the direction dk. Let xk+1 be the unique minimum of
f along this line.
3. If k = n − 1, terminate with minimum xn, else increment k and return to the previous
step.
Note that the assertion is that the above algorithm locates the minimum in n line searches.
It’s also worth pointing out that from equation (5) (with p = xk+1 and v = dk) we have
∇f(xk+1) · dk = 0 (7)
after each line search.
Theorem 2: For a quadratic function f(x) = 1
2
xT
Ax + bT
x + c with A positive deﬁ-
nite the conjugate direction algorithm above locates the minimum of f in (at most) n line
searches.
Proof:
We’ll show that xn is the minimizer of f by showing ∇f(xn) = 0. Since f has a unique
critical point, this shows that xn is it, and hence the minimum.
First, the line search in step two of the above algorithm consists of minimizing the function
g(t) = f(xk + tdk). (8)
Equations (3) and (4) (with v = dk and a = xk) show that
xk+1 = xk + αkdk (9)
where
αk = −
dT
k Axk + dT
k b
dT
k Adk
= −
dT
k ∇f(xk)
dT
k Adk
. (10)
Repeated use of equation (9) shows that for any k with 0 ≤ k ≤ n − 1 we have
xn = xk+1 + αk+1dk+1 + αk+2dk+2 + · · · + αn−1dn−1. (11)
5

Since ∇f(xn) = Axn + b we have, by making use of (11),
∇f(xn) = Axk+1 + b + αk+1Adk+1 + · · · αn−1Adn−1
= ∇f(xk+1) +
n−1
∑
i=k+1
αiAdi. (12)
Multiply both sides of equation (12) by dT
k to obtain
dT
k ∇f(xn) = dT
k ∇f(xk+1) +
n−1
∑
i=k+1
αidT
k Adi.
But equation (7) and the conjugacy of the directions di immediately yield
dT
k ∇f(xn) = 0
for k = 0 to k = n − 1. Since the dk form a basis, we conclude that ∇f(xn) = 0, so xn is
the unique critical point (and minimizer) of f.
Example 2: For case in lR3
in which A = I, it’s easy to see that the directions e1, e2, e3 are
conjugate, and so the one-variable-at-a-time approach works, in at most 3 line searches.
Example 3: Let A be the matrix in Example 1, f(x) = 1
2
xT
Ax, and we already com-
puted d0 = (1, 0, 0), d1 = (1, −3, 0), and d2 = (−2, 6, −5). Take initial guess x0 = (1, 2, 3).
A line search from x0 in direction d0 requires us to minimize
g(t) = f(x0 + td0) =
3
2
t2
+ 5t +
75
2
which occurs at t = −5/3, yielding x1 = x0 − 5
3
d0 = (−2/3, 2, 3). A line search from x1 in
direction d1 requires us to minimize
g(t) = f(x1 + td1) =
15
2
t2
− 28t +
100
3
which occurs at t = 28/15, yielding x2 = x1 + 28
15
d1 = (6/5, −18/5, 3). The ﬁnal line search
from x2 in direction d2 requires us to minimize
g(t) = f(x2 + td2) = 20t2
− 24t +
36
5
which occurs at t = 3/5, yielding x3 = x2 + 3
5
d2 = (0, 0, 0), which is of course correct.
6

Exercise 2
• Show that for each k, dT
j ∇f(xk) = 0 for j = 0 . . . k − 1 (i.e., the gradient ∇f(xk) is
orthogonal to not only the previous search direction dk−1, but ALL previous search
directions). Hint: For any 0 ≤ k < n, write
xk = xj+1 + αj+1dj+1 + · · · + αk−1dk−1
where 0 ≤ j < k. Multiply by A and follow the reasoning before (12) to get
∇f(xk) = ∇f(xj+1) +
k−1
∑
i=j+1
αiAdi.
Now multiply both sides by dT
j , 0 ≤ j < k.
Conjugate Gradients
One drawback to the algorithm above is that we need an entire set of conjugate directions
di before we start, and computing them in the manner of Example 1 would be a lot of work—
more than simply solving Ax = −b for the critical point.
Here’s a way to generate the conjugate directions “on the ﬂy” as needed, with a minimal
amount of computation. First, we take d0 = −∇f(x0) = −(Ax0 + b). We then perform the
line minimization to obtain point x1 = x0 + α0d0, with α0 given by equation (10).
The next direction d1 is computed as a linear combination d1 = −∇f(x1) + β0d0 of the
current gradient and the last search direction. We choose β0 so that dT
1 Ad0 = 0, which gives
β0 =
∇f(x1)T
Ad0
dT
0 Ad0
.
Of course d0 and d1 form a conjugate set of directions, by construction. We then perform a
line search from x1 in the direction d1 to locate x2.
In general we compute the search direction dk as a linear combination
dk = −∇f(xk) + βk−1dk−1 (13)
of the current gradient and the last search direction. We choose βk−1 so that dT
k Adk−1 = 0,
which forces
βk−1 =
∇f(xk)T
Adk−1
dT
k−1Adk−1
. (14)
We then perform a line search from xk in the direction dk to locate xk+1, and then repeat
the whole procedure. This is a traditional conjugate gradient algorithm.
7

By construction we have dT
k Adk−1 = 0, that is, each search direction is conjugate to the
previous direction, but we need dT
i Adj = 0 for ALL choices of i ̸= j. It turns out that this
is true!
Theorem 3: The set of search directions deﬁned by equations (13) and (14) for k = 1
to k = n (with d0 = −∇f(x0)) satisfy dT
i Adj = 0, and so are conjugate.
Proof: We’ll do this by induction. We’ve already seen that d0 and d1 are conjugate.
This is the base case for the induction.
Now suppose that the set d0, d1, . . . , dm are all conjugate. We’ll show that dm+1 is
conjugate to each of these directions.
First, it will be convenient to note that if the directions dk are generated according to
(13) and (14) then ∇f(xk+1) is orthogonal to ∇f(xj) for 0 ≤ j ≤ k ≤ m. To see this rewrite
equation (13) as
∇f(xj) = βj−1dj−1 − dj.
Multiply both sides by ∇f(xk+1)T
to obtain
∇f(xk+1)T
∇f(xj) = βj−1∇f(xk+1)T
dj−1 − ∇f(xk+1)T
dj.
But from the induction hypothesis (the directions d0, . . . , dm are already known to be con-
jugate) and Exercise 2 it follows that the right side above is zero, so
∇f(xk+1)T
∇f(xj) = 0 (15)
for 0 ≤ j ≤ k as asserted.
Now we can ﬁnish the proof. We already know that dm+1 is conjugate to dm, so we need
only show that dm+1 is conjugate to dk for 0 ≤ k < m. To this end, recall that
dm+1 = −∇f(xm+1) + βmdm.
Multiply both sides by dT
k A where 0 ≤ k < m to obtain
dT
k Adm+1 = −dT
k A∇f(xm+1) + βmdT
k Adm.
But dT
k Adm = 0 by the induction hypothesis, so we have
dT
k Adm+1 = −dT
k A∇f(xm+1) = −∇f(xm+1)T
Adk. (16)
We need to show that the right side of equation (16) is zero.
First, start with equation (9) and multiply by A to obtain Axk+1 − Axk = αkAdk, or
(Axj+k + b) − (Axk + b) = αkAdk. But since ∇f(x) = Ax + b, we have
∇f(xk+1) − ∇f(xk) = αkAdk.
8

or
Adk =
1
αk
(∇f(xk+1) − ∇f(xk)) (17)
Substitute the right side of (17) into equation (16) for Adk to obtain
dT
k Adm+1 = −
1
αk
(∇f(xm+1)T
∇f(xk+1) − ∇f(xm+1)T
∇f(xk))
for k < m. From equation (15) the right side above is zero, so dT
k Adm+1 = 0 for k < m.
Since dT
mAdm+1 = 0 by construction, we’ve shown that if d0, . . . , dm satisﬁes dT
i Adj = 0
for i ̸= j then so does d0, . . . , dm, dm+1. From induction it follows that d0, . . . , dn also has
this property. This completes the proof.
Exercise 3
• It may turn out that all di = 0 for i ≥ m for some m < n—namely, if the mth line
search takes us to the minimum. However, show that if we’re not at the minimum at
iteration k (so ∇f(xk) ̸= 0) then dk ̸= 0.
Here’s the “pseudocode” for this conjugate gradient algorithm for minimizing f(x) =
1
2
xT
Ax + xT
b + c:
1. Make an initial guess x0. Set d0 = −∇f(x0) (note ∇f(x) = Ax + b) and k = 0.
2. Let xk+1 be the unique minimum of f along the line L(t) = xk + tdk, given by xk+1 =
xk + tkdk where
tk = −
dT
k ∇f(xk)
dT
k Adk
= −
dT
k (Axk + b)
dT
k Adk
.
3. If k = n − 1, terminate with minimum xn.
4. Compute new search direction dk+1 = −∇f(xk+1) + βkdk where
βk =
∇f(xk+1)T
Adk
dT
k Adk
. (18)
Increment k and return to step 2.
Exercise 4:
• Run the conjugate gradient algorithm above on the function f(x) = 1
2
xT
Ax + xT
b
with
A =



3 0 2
0 1 1
2 1 3


 , b =



1
0
−1


 .
Use initial guess (1, 1, 1).
9

An Application
As discussed earlier, if A is symmetric positive definite, the problems of minimizing
f(x) = 1
2
xT
Ax + xT
b + c and solving Ax + b = 0 are completely equivalent. Systems like
Ax+b = 0 with positive definite matrices occur quite commonly in applied math, especially
when one is solving partial differential equations numerically. They are also frequently
LARGE, with thousands to even millions of variables.
However, the matrix A is usually sparse, that is, it contains mostly zeros. Typically the
matrix will have only a handful of non-zero elements in each row. This is great news for
storage—storing an entire n by n matrix requires 8n2
bytes in double precision, but if A has
only a few non-zero elements per row, say 5, then we can store A in a little more than 5n
bytes.
Still, solving Ax + b = 0 is a challenge. You can’t use standard techniques like LU or
Cholesky decomposition—the usual implementations require one to store on the order of n2
numbers, at least as the algorithms progress.
A better way is to use conjugate gradient techniques, to solve Ax = −b by minimizing
1
2
xT
Ax + xT
b + c. If you look at the algorithm carefully you’ll see that we don’t need to
store the matrix A in any conventional way. All we really need is the ability to compute Ax
for a given vector x.
As an example, suppose that A is an n by n matrix with all 4’s on the diagonal, −1’s on
the closest fringes, and zero everywhere else, so A looks like
A =








4 −1 0 0 0
−1 4 −1 0 0
0 −1 4 −1 0
0 0 −1 4 −1
0 0 0 −1 4








in the five by five case. But try to imagine the 10,000 by 10,000 case. We could still store
such a matrix in only about 240K of memory (double precision, 8 bytes per entry). This
matrix is clearly symmetric, and it turns out it’s positive definite.
There are different data structures for describing sparse matrices. One obvious way
results in the first row of the matrix above being encoded as [[1, 4.0], [2, −1.0]]. The [1, 4.0]
piece means the first column in the row is 4.0, and the [2, −1.0] means the second column
entry in the first row is −1.0. The other elements in row 1 are assumed to be zero. The rest
of the rows would be encoded as [[1, −1.0], [2, −4.0], [3, −1.0]], [[2, −1.0], [3, 4.0], [4, −1.0]],
[[3, −1.0], [4, 4.0], [5, −1.0]], and [[4, −1.0], [5, 4.0]]. If you stored a matrix this way you could
fairly easily write a routing to compute the product Ax for any vector x, and so use the
conjugate gradient algorithm to solve Ax = −b.
A couple last words: Although the solution will be found exactly in n iterations (modulo
round-off) people don’t typically run conjugate gradient (or any other iterative solver) for
10

the full distance. Usually some small percentage of the full n iterations is taken, for by then
you’re usually sufficiently close to the solution. Also, it turns out that the performance of
conjugate gradient, as well as many other linear solvers, can be improved by preconditioning.
This means replacing the system Ax = −b by (BA)x = −Bb where B is some easily com-
puted approximate inverse for A (it can be pretty approximate). It turns out that conjugate
gradient performs best when the matrix involved is close to the identity in some sense, so
preconditioning can decrease the number of iterations needed in conjugate gradients. Of
course the ultimate preconditioner would be to take B = A−1
, but this would defeat the
whole purpose of the iterative method, and be far more work!
Non-quadratic Functions
The algorithm above only works for quadratic functions, since it explicitly uses the matrix
A. We’re going to modify the algorithm so that the specific quadratic nature of the objective
function does not appear explicitly—in fact, only ∇f will appear, but the algorithm will
remain unchanged if f is truly quadratic. However, since only ∇f will appear, the algorithm
will immediately generalize to any function f for which we can compute ∇f.
Here are the modifications. The first step in the algorithm on page 9 involves computing
d0 = −∇f(x0). There’s no mention of A here—we can compute ∇f for any differentiable
function.
In step 2 of the algorithm on page 9 we do a line search from xk in direction dk. For
the quadratic case we have the luxury of a simple formula (involving tk) for the unique
minimum. But the computation of tk involves A. Let’s replace this formula with a general
(exact) line search, using Golden Section or whatever line search method you like. This will
change nothing in the quadratic case, but generalizes things, in that we know how to do line
searches for any function. Note this gets rid of any explicit mention of A in step 2.
Step 4 is the only other place we use A, in which we need to compute Adk in order to
compute βk. There are several ways to modify this to eliminate explicit mention of A. First
(still thinking of f as quadratic) note that since (from step 2) we have xk+1 − xk = cdk for
some constant c (where c depends on how far we move to get from xk to xk+1) we have
∇f(xk+1) − ∇f(xk) = (Axk+1 + b) − (Axk + b) = cAdk. (19)
Thus Adk = 1
c
(∇f(xk+1)−∇f(xk)). Use this fact in the numerator and denominator of the
definition for βk in step 4 to obtain
βk =
∇f(xk+1)T
(∇f(xk+1) − ∇f(xk))
dT
k (∇f(xk+1) − ∇f(xk))
. (20)
Note that the value of c was irrelevant! The search direction dk+1 is as before, dk+1 =
−∇f(xk+1)+βkdk. If f is truly quadratic then definitions (18) and (20) are equivalent. But
the new algorithm can be run for ANY differentiable function.
11

Equation (20) is the Hestenes-Stiefel formula. It yields one version of the conjugate
gradient algorithm for non-quadratic problems.
Here’s another way to get rid of A. Again, assume f is quadratic. Multiply out the
denominator in (20) to find
dT
k (∇f(xk+1) − ∇f(xk)) = dT
k ∇f(xk+1) − dT
k ∇f(xk).
But from equation (7) (or Exercise 2) we have dT
k ∇f(xk+1) = 0, so really
dT
k (∇f(xk+1) − ∇f(xk)) = −dT
k ∇f(xk).
Now note dk = −∇f(xk) + βk−1dk−1 so that
dT
k (∇f(xk+1) − ∇f(xk)) = −(−∇f(xk)T
+ βk−1dT
k−1)∇f(xk) = |∇f(xk)|2
since by equation (7) again, dT
k−1∇f(xk) = 0. All in all, the denominator in (20) is, in the
quadratic case, |∇f(xk)|2
. We can thus give an alternate definition of βk as
βk =
∇f(xk+1)T
(∇f(xk+1) − ∇f(xk))
|∇f(xk)|2
. (21)
Again, no change occurs if f is quadratic, but this formula generalizes to the non-quadratic
case. This formula is called the Polak-Ribiere formula.
Exercise 5
• Derive the Fletcher-Reeves formula (assuming f is quadratic)
βk =
|∇f(xk+1)|2
|∇f(xk)|2
. (22)
Formulas (20), (21), and (22) all give a way to generalize the algorithm to any differ-
entiable function. They require only gradient evaluations. But they are NOT equivalent
for nonquadratic functions. However, all are used in practice (though Polak-Ribiere and
Fletcher-Reeves seem to be the most common). Our general conjugate gradient algorithm
now looks like this:
1. Make an initial guess x0. Set d0 = −∇f(x0) and k = 0.
2. Do a line search from xk in the direction dk. Let xk+1 be the minimum found along
the line.
3. If a termination criteria is met, terminate with minimum xk+1.
12

4. Compute new search direction dk+1 = −∇f(xk+1) + βkdk where βk is given by one of
equations (20), (21), or (22). Increment k and return to step 2.
Exercise 6
• Verify that all three of the conjugate gradient algorithms are descent methods for any
function f. Hint: it’s really easy.
Some people advocate periodic “restarting” of conjugate gradient methods. After some
number of iterations (n or some fraction of n) we re-initialize dk = −∇f(xk). There’s some
evidence this improves the performance of the algorithm.
13

Conjugate Gradient Methods

More Related Content

Similar to Conjugate Gradient Methods (20)

Recently uploaded (20)

Conjugate Gradient Methods