Lecture 1: Introduction to computation

Transcription

1 UNIVERSITY OF WESTERN ONTARIO LONDON ONTARIO Paul Klein Office: SSC 4044 Extension: URL: Economics 9619 Computational methods in macroeconomics Winter 2017 Lecture 1: Introduction to computation 1 Numerical software For the most part, I ll assume that you ll be working with Matlab. However, I am quite happy for you to use Fortran, Scilab, C++, Python, R or whatever language you prefer. I will not give advice on what software to use, except to inform you of the distinction between compiled and interpreted languages, nor on how to acquire any particular kind of software. I am, however, happy to give programming advice for Matlab and Fortran. The former will be my canonical example of an interpreted language and Fortran of a compiled one. 2 Finite precision arithmetic Computational mathematics and ordinary mathematics are not the same. ordinary mathematics, there is no smallest number ε such that For example, in 1 + ε > 1 but in finite precision arithmetic, there is. How would you go about determining that number, approximately? 1

2 The magnitude of ε ( machine epsilon ) is determined by the number of bytes (1 byte=8 bits) allocated to representing a floating-point number. In double precision, which has emerged as a standard, a floating-point number takes up 64 bits (8 bytes), 52 of which are reserved for what is called the mantissa (see below for a definition). A floating-point number is stored on a computer in the following way, supposing for the sake of argument that computers operate in base 10. (They don t of course, they operate in base 2.) ± ±N Here the sequence is called the mantissa (or significand) and N is called the exponent. Notice that the leading digit is not zero meaning that in binary it does not need to be stored at all; it is implicit. For instance, the number 1/2 is represented as in binary rather than It is simply a convention that the leading digit is always one. It is often called an implicit bit, because it does not need to be (and isn t) stored in memory. In double precision, 11 bits are allocated to the exponent, so 2 11 = 2048 distinct exponents can be represented. To be precise, the exponent can take any integer value between and (By the way, the number is not treated as a proper number in double precision; instead it is the improper number Inf. Special rules apply to Inf. For instance, Inf+Inf=Inf but Inf Inf=NaN.) Meanwhile, the smallest number ɛ such that ɛ > 0 is a bit smaller than , in fact it is The way this works is as follows. When the exponent is minimal, the number is known as subnormal, meaning that the implicit bit is set to zero to enable storage of very small numbers. Meanwhile, the exponent is interpreted as being one larger than otherwise, i.e rather than 1023; that makes sense, doesn t it? So the smallest possible strictly positive number is represented by = =

3 In any case, the smallest strictly positive number in double precision is known as machine zero. Is it the same number as machine epsilon? No, it is not! The magnitude of machine epsilon is determined by the number of bits assigned to the mantissa, not the number of bits assigned to the exponent. So let s continue with our example and suppose that five base 10 bits are assigned to the mantissa. Then what is machine epsilon? It should be clear that it s 10 4 (where 4 is, not coincidentally, the number of base 10 bits allocated to the mantissa minus one). Consider x = and let s try to add it to 1. Notice that and one differ by five orders of magnitude one more than we can deal with. So things don t look good. But let s try. First let s represent the two numbers on the computer. 1 = = This representation is fine as far as it goes, but to add the two numbers, they need first to be put on a common exponent. 1 = Ooops! By putting on a common exponent with 1, it vanished! In double precision, the mantissa is allocated 52 bits. So you d expect machine epsilon to be But here s a subtlety: in binary, as we have seen, the leading digit of the mantissa is always one (unless we are dealing with a subnormal number). So there are in fact 53 binary bits in the mantissa if we include the implicit bit. As a result, machine epsilon is equal to Here s why machine epsilon is so important. For any reasonable x, the smallest number y such that x(1 + y) > x is precisely machine epsilon ε. Can you prove it? This has important implications for the sorts of things you can meaningfully compute, or more to the point, what things cannot be meaningfully computed. In particular, consider x + y y. In ordinary mathematics, this is equal to x. In finite precision arithmetic, if x and y differ in 3

4 magnitude by a sufficiently large factor, then it is garbage. For example, in double precision arithmetic, = 0. For more on this topic, see K. Kopecky s Computing Basics. 3 Solving the growth model by discretization Suppose a social planner maximizes subject to β t ln c t t=0 c t + k t+1 = (1 δ)k t + Ak θ t k 0 > 0 given and k t+1 0. If δ = 1 then you should know the solution to this problem. It can be represented via k t+1 = βθak θ t. But what if δ < 1? Then there are many ways to proceed. We will pursue one here. It is based on Bellman s principle of optimality, which says the following (ignoring some crucial mathematical subtleties). If the function v : R + R satisfies { v(k) = sup ln(ak θ + (1 δ)k k ) + βv(k ) } k 0 for all k > 0 and the sequence {k t } t=1 satisfies for all t = 0, 1,... then {k t } t=1 is optimal. v(k t ) = ln ( Ak θ t + (1 δ)k t k t+1 ) + βv(kt+1 ) What we will do is to force k t to belong to the same finite set for all t. This turns an infinitedimensional problem into a finite-dimensional one. We then solve the finite-dimensional problem. We start by computing the steady state. Apparently ( ) 1 k ss Aθ 1 θ =. β 1 + δ 1 4

5 You may want to set A = (β 1 + δ 1)/θ in which case k ss = 1. Alternatively, you may want steady state output to equal one in which case and ( 1 β(1 δ) A = βθ k ss = ) θ βθ 1 β(1 δ). The next step is to create a grid of values of k. Let there be n points in this grid and denote them by k 1, k 2,..., k n. (These superscripts are not powers.) One possibility is to let the points be equally spaced. Perhaps a better idea is to let them be equally spaced in logs. For example, suppose k 1 is half the steady state value and k n is twice the steady state value. Then k i = 1 { } 2(i 1) 2 kss exp n 1 ln Scalar by scalar If k t is confined to the grid, then we have a new, constrained problem. The Bellman equation associated with that new problem is for i = 1, 2,..., n. v(k i ) = max 1 j n {ln(a(ki ) θ + (1 δ)k i k j ) + βv(k j )} To find the value function (and hence the decision rule), we proceed as follows. Start with a guess of the value function consisting of its values at the grid points. Denote them by v 0 (k i ) for i = 1, 2,..., n. Now you may want to be more or less sophisticated about your choice of initial guess. Any initial guess is guaranteed to work, but the question is how quickly you will find an approximate solution. One possible, but not very intelligent guess is zero, v 0 (k i ) = 0 for all i. More on that a bit later. For now, let s talk about how to update the guess to something better. Inspired by Bellman s equation, and denoting the updated value function by v 1, let for i = 1, 2,..., n. v 1 (k i ) = max 1 j n {ln(a(ki ) θ + (1 δ)k i k j ) + βv 0 (k j )} (1) 5

6 Suppose now that our initial guess really was zero, or for that matter any constant. Then the optimal choice in the first round of updating will be to save as little as possible, i.e. to choose k = k 1 or j = 1 every time. That is quite far from the true solution. How can we come up with a more intelligent initial guess? Well, coming up with an initial guess of the value function may be hard, but guessing the decision rule is easier. How about k = k or j = i? At the steady state that s precisely accurate, and away from the steady state it s surely not too bad unless it involves negative consumption. Let s pause for a minute here to contemplate what safeguards should be taken to avoid tempting the computer to stray into negative consumption territory. You should define the utility function in terms of k and k in such a way that it delivers a very large negative real number if consumption is negative. A naive approach won t do this. Alternatively, you can choose your grid so that it never happens. This may or may not be possible depending on the model you re dealing with. Anyway, let s say that maintaining the current level of capital is a reasonable initial guess. What does that imply for the associated (not maximal) value function. Well, with this stay put policy we have Solving for v 0 (k), we get v 0 (k) = ln(ak θ + (1 δ)k k) + βv 0 (k). v 0 (k) = ln(akθ δk). 1 β Incidentally, if β is a number close to 1, 1 β is an awfully small number to be dividing by a dangerous thing numerically. You may therefore want to define your period utility function via (1 β) ln c instead of ln c. But let s not do that here. Anyhow, we now have a respectable initial guess and we can find a good approximation to the true value function of the constrained problem by iterating on Equation (1). An obvious approach to coding these iterations is to write explicit loops. However, in an interpreted language such as Matlab (as opposed to a compiled language like C++ or Fortran), loops are slow. The reason is that the code is reinterpreted at every iteration on the loop. To avoid looping, we vectorize the code. 6

7 3.2 Vectorizing We begin by defining k = (k 1 k 2 k 3... k n ) T. Similarly, define the vector v via v = (v(k 1 ) v(k 2 ) v(k 3 )... v(k n )) T. Second, define the matrix K via and similarly the matrix V via K = [k k... k] }{{} n times V = [v v... v] }{{} n times The remarkable thing about these definitions is that Bellman s equation now becomes v = max{ln ( AK θ + (1 δ)k K T ) + βv T } provided that we interpret the max operator when applied to a matrix as operating on the rows, picking out the maximal element of each row to create a column vector of maxima. (Also, scalar multiplication and raising to powers is interpreted element-wise as is the application of the natural logarithm.) We are now ready to describe an algorithm. Step 1. Create, once and for all, the matrix U = ln ( AK θ + (1 δ)k K T ), remembering to put a large negative value whenever the argument of the natural logarithm happens to be negative (if it ever is). Notice that Bellman s equation can now be written v = max{u + βv T }. Step 2. Create an initial guess of the value function v 0 and hence an initial guess V 0. Step 3. Iterate on Bellman s equation via the following recipe v 1 = max{u + βv T 0 }. Stop when the norm of the vector v 1 v 0 falls below some reasonable threshold. At this stage, before we get into the thick of finite-precision arithmetic, let me suggest 10 7 or, in computer jargon, 1E-7. Or maybe you should stop iterating when decisions no longer change. What do you think makes more sense? 7

8 3.3 Howard s improvement In the algorithm described above, maximization is carried out at each iteration. This is not efficient. Decision rules converge faster than value functions and maximization is time-consuming. Howard s improvement (see Howard, 1960) consists in iterating on the value function while keeping the decision rule fixed. How do we represent a decision rule? By a vector of indices, each index telling us what column of the right hand side of the Bellman equation matrix to pick out. Call this vector d. Denote by A(d) the column vector that results from this selection process from a matrix A. Howard s improvement, then, consists in iterating on v 1 = (U + βv0 T )(d). As a rule of thumb, you may want to apply Howard s improvement 10 or 20 times before applying another round of optimization. 3.4 Matlab tips and tricks To replace complex numbers from a matrix with something unattractively small, write U(imag(U) =0) = -1000; To create an n n matrix A, each column of which is equal to the column vector x, write A = repmat(x,1,n). If you apply Matlab s max operator to an m n matrix A, the result is a 1 n row vector consisting of the maxima of each column. That is the exact opposite of what we want. To get a column vector consisting of all the row-wise maxima, write max(a ). If you want to extract the d k :th element from each row k of an n n matrix A for all k = 1, 2,..., n and put them all into a column vector a, here is how you do it. idcs = sub2ind([n n],1:n,d ); a = A(idcs) ; 8

9 How do you compute the vector d? Wouldn t it be nice if we could code it like this: [v,d] = max(u+beta*v ); The problem with this is that it mixes up rows and columns and that the resulting vector d is a row vector, not a column vector. I leave to the reader the problem of sorting this out. You may of course conclude at this stage that it is better to work with row vectors in the first place since that is what Matlab seems to prefer. But for pedagogical purposes (writing these lecture notes) it is better to work with column vectors because it forces you, the reader, to be explicitly aware of what s going on when you do the coding. 4 Solving for a deterministic transition Consider the one-sector growth model with exogenous labour supply. A social planner maximizes subject to β t ln c t t=0 c t + k t+1 = Akt θ + (1 δ)k t and k t+1 0 where of course k 0 is given. As you know, the optimality conditions can be written as 1 = β 1 + Aθkθ 1 t+1 δ. c t c t+1 To solve for a transition from an arbitrary point to the steady state, we can just stack all these equations and solve them numerically. Well, not quite, because there are infinitely many equations. So we fix an integer T and force the economy to converge to the steady state in T 9

10 periods. Thus we solve the following system. Ak0 θ + (1 δ)k 0 c 0 k 1 = 0 1 β 1 + Aθkθ 1 1 δ = 0 c 0 c 1 Ak θ 1 + (1 δ)k 1 c 1 k 2 = 0 1 β 1 + Aθkθ 1 2 δ = 0 c 1 c 2 1 β 1 + Aθkθ 1 T δ = 0 c T 1 c T Ak θ T + (1 δ)k T c T k T +1 = 0. Notice that we repeat one of the equations T times, but the other is repeated T + 1 times. This means that we have 2T +1 equations. Why not repeat both equations T +1 times? Because we want to force the economy to converge to a steady state. This is important because a dynamic model will typically have explosive solutions that we are not interested in. So we will insist on k T +1 = k where k is defined by the steady state condition β(1 + θa k θ 1 δ) = 1. Having fixed k 0 and k T +1, we have T values of k t to solve for. Meanwhile, we have T + 1 values for c t to solve for: t = 0, 1,..., T. Thus we have 2T + 1 unknowns. Now let s consider this problem at a somewhat higher level of generality. It turns out to be useful to distinguish between static and dynamic equilibrium conditions.. The static equilibrium conditions don t involve d t+1, and there are n d of them. The dynamic conditions do involve d t+1 and there are n x of them. More precisely, let the equilibrium conditions be given by f(x t, x t+1, d t, d t+1 ) = 0 for t = 0, 1,... g(x t, x t+1, d t ) = 0 Here it is not crucial that f and g do not depend explicitly on t as long as any dependence ceases after finitely many periods. In any case, here s how the approach works: 10

11 1. Fix a time horizon T after which you think the economy is very close to the steady state. 2. Set up your equilibrium conditions. Using the notation already established, we have g(x 0, x 1, d 0 ) = 0 f(x 0, x 1, d 0, d 1 ) = 0 g(x 1, x 2, d 1 ) = 0 f(x 1, x 2, d 1, d 2 ) = 0 f(x T 1, x T, d T 1, d T ) = 0. g(x T, x T +1, d T ) = 0 3. Don t forget that x 0 fixed by an initial condition! 4. Meanwhile, x T +1 is fixed by the steady state (if known) or by the equation x T +1 = x T if the steady state is not known. 5. Solve for x 1, x 2,..., x T and d 0, d 1,..., d T. Notice that there are just as many equations as there are unknowns! 11

12 5 Exercises 1. Derive a formula for the maximum sustainable level of capital k max. By definition, k max is the largest value of k such that Ak θ δk Write a program that solves the model described in these lecture notes. Use a grid that s evenly spaced in logs, has 1000 points and ranges from k ss /2 to k max. Verify that it works by comparing the computed value function and decision rule with the true counterparts when δ = How long does the program take to converge without Howard s improvement? What is (roughly) the optimal number of Howard improvements in between optimizations and how much does that cut computation time? (Set parameter values as you like.) 4. Set β =.96, θ = 0.36, δ = 0.08 and k 0 = k ss /2. How many periods does it take for k t 3k ss /4? (What if δ = 0.1? How long does it take then?) 5. The following first-order condition should hold along your computed transition path. 1 = β Aθkθ 1 t δ c t c t+1 Report by what percentage consumption c t would have to change in order for this condition to hold exactly in each period t. When you compute this number for a particular t, keep all the other variables (c t+1, k t+1 ) unchanged. t = 0, 1,..., 20. Compute the number for 6. Revisit Question 4 by computing a deterministic transition as described in Section 4. Do you get the same answer? 7. The Hodrick-Prescott filter defines the trend as the sequence { ˆX t } T t=0 that solves { T } min (X t ˆX ) 2 T 1 (( t + λ ˆXt+1 ˆX ) ( t ˆXt ˆX )) 2 t 1 ˆX t T t=0 t=0 t=1 where λ is a parameter and {X t } T t=0 is some observed time series. (2) (a) Write down the first order conditions for this minimization problem. (b) Describe the precise type of sparseness that the linear system you derived in (a) exhibits. (c) Code a function that solves for the trend, exploiting the sparseness. 12

13 References Howard, R. A. (1960). Dynamic Programming and Markov Processes. The M.I.T. Press. 13