{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "
\n", " \n", " \"QuantEcon\"\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Job Search I: The McCall Search Model" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Contents\n", "\n", "- [Job Search I: The McCall Search Model](#Job-Search-I:-The-McCall-Search-Model) \n", " - [Overview](#Overview) \n", " - [The McCall Model](#The-McCall-Model) \n", " - [Computing the Optimal Policy: Take 1](#Computing-the-Optimal-Policy:-Take-1) \n", " - [Computing the Optimal Policy: Take 2](#Computing-the-Optimal-Policy:-Take-2) \n", " - [Exercises](#Exercises) \n", " - [Solutions](#Solutions) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> “Questioning a McCall worker is like having a conversation with an out-of-work friend:\n", "> ‘Maybe you are setting your sights too high’, or ‘Why did you quit your old job before you\n", "> had a new one lined up?’ This is real social science: an attempt to model, to understand,\n", "> human behavior by visualizing the situation people find themselves in, the options they face\n", "> and the pros and cons as they themselves see them.” – Robert E. Lucas, Jr." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview\n", "\n", "The McCall search model [[McC70]](https://lectures.quantecon.org/zreferences.html#mccall1970) helped transform economists’ way of thinking about labor markets\n", "\n", "To clarify vague notions such as “involuntary” unemployment, McCall modeled the decision problem of unemployed agents directly, in terms of factors such as\n", "\n", "- current and likely future wages \n", "- impatience \n", "- unemployment compensation \n", "\n", "\n", "To solve the decision problem he used dynamic programming\n", "\n", "Here we set up McCall’s model and adopt the same solution method\n", "\n", "As we’ll see, McCall’s model is not only interesting in its own right but also an excellent vehicle for learning dynamic programming" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The McCall Model\n", "\n", "\n", "\n", "An unemployed worker receives in each period a job offer at wage $ W_t $\n", "\n", "At time $ t $, our worker has two choices:\n", "\n", "1. Accept the offer and work permanently at constant wage $ W_t $ \n", "1. Reject the offer, receive unemployment compensation $ c $, and reconsider next period \n", "\n", "\n", "The wage sequence $ \\{W_t\\} $ is assumed to be iid with probability mass function $ p_1, \\ldots, p_n $\n", "\n", "Here $ p_i $ is the probability of observing wage offer $ W_t = w_i $ in the set $ w_1, \\ldots, w_n $\n", "\n", "The worker is infinitely lived and aims to maximize the expected discounted sum of earnings\n", "\n", "$$\n", "\\mathbb{E} \\sum_{t=0}^{\\infty} \\beta^t Y_t\n", "$$\n", "\n", "The constant $ \\beta $ lies in $ (0, 1) $ and is called a **discount factor**\n", "\n", "The smaller is $ \\beta $, the more the worker discounts future utility relative to current utility\n", "\n", "The variable $ Y_t $ is income, equal to\n", "\n", "- his wage $ W_t $ when employed \n", "- unemployment compensation $ c $ when unemployed " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### A Trade Off\n", "\n", "The worker faces a trade-off:\n", "\n", "- Waiting too long for a good offer is costly, since the future is discounted \n", "- Accepting too early is costly, since better offers might arrive in the future \n", "\n", "\n", "To decide optimally in the face of this trade off, we use dynamic programming\n", "\n", "Dynamic programming can be thought of as a two step procedure that\n", "\n", "1. first assigns values to “states” and \n", "1. then deduces optimal actions given those values \n", "\n", "\n", "We’ll go through these steps in turn" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Value Function\n", "\n", "In order to optimally trade off current and future rewards, we need to think about two things:\n", "\n", "1. the current payoffs we get from different choices \n", "1. the different states that those choices will lead to next period (in this case, either employment or unemployment) \n", "\n", "\n", "To weigh these two aspects of the decision problem, we need to assign *values* to states\n", "\n", "To this end, let $ V(w) $ be the total lifetime *value* accruing to an unemployed worker who enters the current period unemployed but with wage offer $ w $ in hand\n", "\n", "More precisely, $ V(w) $ denotes the value of the objective function [(1)](https://lectures.quantecon.org/mccall_model_with_separation.html#equation-objective) when an agent in this situation makes *optimal* decisions now and at all future points in time\n", "\n", "Of course $ V(w) $ is not trivial to calculate because we don’t yet know what decisions are optimal and what aren’t!\n", "\n", "But think of $ V $ as a function that assigns to each possible wage $ w $ the maximal lifetime value that can be obtained with that offer in hand\n", "\n", "A crucial observation is that this function $ V $ must satisfy the recursion\n", "\n", "\n", "\n", "$$\n", "V(w)\n", "= \\max \\left\\{\n", " \\frac{w}{1 - \\beta}, \\, c + \\beta \\sum_{i=1}^n V(w_i) p_i\n", " \\right\\} \\tag{1}\n", "$$\n", "\n", "for every possible $ w_i $ in $ w_1, \\ldots, w_n $\n", "\n", "This important equation is a version of the **Bellman equation**, which is\n", "ubiquitous in economic dynamics and other fields involving planning over time\n", "\n", "The intuition behind it is as follows:\n", "\n", "- the first term inside the max operation is the lifetime payoff from accepting current offer $ w $, since \n", "\n", "\n", "$$\n", "w + \\beta w + \\beta^2 w + \\cdots = \\frac{w}{1 - \\beta}\n", "$$\n", "\n", "- the second term inside the max operation is the **continuation value**, which is the lifetime payoff from rejecting the current offer and then behaving optimally in all subsequent periods \n", "\n", "\n", "If we optimize and pick the best of these two options, we obtain maximal lifetime value from today, given current offer $ w $\n", "\n", "But this is precisely $ V(w) $, which is the l.h.s. of [(1)](#equation-odu-pv)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Optimal Policy\n", "\n", "Suppose for now that we are able to solve [(1)](#equation-odu-pv) for the unknown\n", "function $ V $\n", "\n", "Once we have this function in hand we can behave optimally (i.e., make the\n", "right choice between accept and reject)\n", "\n", "All we have to do is select the maximal choice on the r.h.s. of [(1)](#equation-odu-pv)\n", "\n", "The optimal action is best thought of as a **policy**, which is, in general, a map from\n", "states to actions\n", "\n", "In our case, the state is the current wage offer $ w $\n", "\n", "Given *any* $ w $, we can read off the corresponding best choice (accept or\n", "reject) by picking the max on the r.h.s. of [(1)](#equation-odu-pv)\n", "\n", "Thus, we have a map from $ \\mathbb{R} $ to $ \\{0, 1\\} $, with 1 meaning accept and zero meaning reject\n", "\n", "We can write the policy as follows\n", "\n", "$$\n", "\\sigma(w) := \\mathbf{1}\n", " \\left\\{\n", " \\frac{w}{1 - \\beta} \\geq c + \\beta \\sum_{i=1}^n V(w_i) p_i\n", " \\right\\}\n", "$$\n", "\n", "Here $ \\mathbf{1}\\{ P \\} = 1 $ if statement $ P $ is true and equals zero otherwise\n", "\n", "We can also write this as\n", "\n", "$$\n", "\\sigma(w) := \\mathbf{1} \\{ w \\geq \\bar w \\}\n", "$$\n", "\n", "where\n", "\n", "\n", "\n", "$$\n", "\\bar w := (1 - \\beta) \\left\\{ c + \\beta \\sum_{i=1}^n V(w_i) p_i \\right\\} \\tag{2}\n", "$$\n", "\n", "Here $ \\bar w $ is a constant depending on $ \\beta, c $ and the wage distribution, called the *reservation wage*\n", "\n", "The agent should accept if and only if the current wage offer exceeds the reservation wage\n", "\n", "Clearly, we can compute this reservation wage if we can compute the value function" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Computing the Optimal Policy: Take 1\n", "\n", "To put the above ideas into action, we need to compute the value function at\n", "points $ w_1, \\ldots, w_n $\n", "\n", "In doing so, we can identify these values with the vector $ v = (v_i) $ where $ v_i := V(w_i) $\n", "\n", "In view of [(1)](#equation-odu-pv), this vector satisfies the nonlinear system of equations\n", "\n", "\n", "\n", "$$\n", "v_i\n", "= \\max \\left\\{\n", " \\frac{w_i}{1 - \\beta}, \\, c + \\beta \\sum_{i=1}^n v_i p_i\n", " \\right\\}\n", "\\quad\n", "\\text{for } i = 1, \\ldots, n \\tag{3}\n", "$$\n", "\n", "It turns out that there is exactly one vector $ v := (v_i)_{i=1}^n $ in\n", "$ \\mathbb R^n $ that satisfies this equation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Algorithm\n", "\n", "To compute this vector, we proceed as follows:\n", "\n", "Step 1: pick an arbitrary initial guess $ v \\in \\mathbb R^n $\n", "\n", "Step 2: compute a new vector $ v' \\in \\mathbb R^n $ via\n", "\n", "\n", "\n", "$$\n", "v'_i\n", "= \\max \\left\\{\n", " \\frac{w_i}{1 - \\beta}, \\, c + \\beta \\sum_{i=1}^n v_i p_i\n", " \\right\\}\n", "\\quad\n", "\\text{for } i = 1, \\ldots, n \\tag{4}\n", "$$\n", "\n", "Step 3: calculate a measure of the deviation between $ v $ and $ v' $, such as $ \\max_i |v_i - v_i'| $\n", "\n", "Step 4: if the deviation is larger than some fixed tolerance, set $ v = v' $ and go to step 2, else continue\n", "\n", "Step 5: return $ v $\n", "\n", "This algorithm returns an arbitrarily good approximation to the true solution\n", "to [(3)](#equation-odu-pv2), which represents the value function\n", "\n", "(Arbitrarily good means here that the approximation converges to the true\n", "solution as the tolerance goes to zero)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Fixed Point Theory\n", "\n", "What’s the math behind these ideas?\n", "\n", "First, one defines a mapping $ T $ from $ \\mathbb R^n $ to\n", "itself via\n", "\n", "\n", "\n", "$$\n", "Tv_i\n", "= \\max \\left\\{\n", " \\frac{w_i}{1 - \\beta}, \\, c + \\beta \\sum_{i=1}^n v_i p_i\n", " \\right\\}\n", "\\quad\n", "\\text{for } i = 1, \\ldots, n \\tag{5}\n", "$$\n", "\n", "(A new vector $ Tv $ is obtained from given vector $ v $ by evaluating\n", "the r.h.s. at each $ i $)\n", "\n", "One can show that the conditions of the Banach contraction mapping theorem are\n", "satisfied by $ T $ as a self-mapping on $ \\mathbb{R}^n $\n", "\n", "One implication is that $ T $ has a unique fixed point in $ \\mathbb R^n $\n", "\n", "Moreover, it’s immediate from the definition of $ T $ that this fixed\n", "point is precisely the value function\n", "\n", "The iterative algorithm presented above corresponds to iterating with\n", "$ T $ from some initial guess $ v $\n", "\n", "The Banach contraction mapping theorem tells us that this iterative process\n", "generates a sequence that converges to the fixed point" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Implementation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Setup" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "hide-output": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\u001b[32m\u001b[1mActivated\u001b[0m /home/qebuild/repos/lecture-source-jl/_build/website/jupyter/Project.toml\u001b[39m\n", "\u001b[36m\u001b[1mInfo\u001b[0m quantecon-notebooks-julia 0.1.0 activated, 0.2.0 requested\u001b[39m\n" ] } ], "source": [ "using InstantiateFromURL\n", "github_project(\"QuantEcon/quantecon-notebooks-julia\", version = \"0.2.0\")" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "hide-output": true }, "outputs": [], "source": [ "using LinearAlgebra, Statistics\n", "using Distributions, Expectations, NLsolve, Roots, Random, Plots, Parameters" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "hide-output": false }, "outputs": [], "source": [ "gr(fmt = :png);;" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here’s the distribution of wage offers we’ll work with" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "hide-output": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "support(dist) = 0:50\n" ] }, { "data": { "image/png": "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" }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "n = 50\n", "dist = BetaBinomial(n, 200, 100) # probability distribution\n", "@show support(dist)\n", "w = range(10.0, 60.0, length = n+1) # linearly space wages\n", "\n", "using StatsPlots\n", "plt = plot(w, dist, xlabel = \"wages\", ylabel = \"probabilities\", legend = false)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can explore taking expectations over this distribution" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "hide-output": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(E_w, E_w_2) = (43.333333333335695, 12.919896640724573)\n", "E * w = " ] }, { "name": "stdout", "output_type": "stream", "text": [ "43.3333333333357\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "dot(pdf.(dist, support(dist)), w) = 43.3333333333357\n" ] } ], "source": [ "E = expectation(dist) # expectation operator\n", "\n", "# exploring the properties of the operator\n", "wage(i) = w[i+1] # +1 to map from support of 0\n", "E_w = E(wage)\n", "E_w_2 = E(i -> wage(i)^2) - E_w^2 # variance\n", "@show E_w, E_w_2\n", "\n", "# use operator with left-multiply\n", "@show E * w # the `w` are values assigned for the discrete states\n", "@show dot(pdf.(dist, support(dist)), w); # identical calculation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To implement our algorithm, let’s have a look at the sequence of approximate value functions that\n", "this fixed point algorithm generates\n", "\n", "Default parameter values are embedded in the function\n", "\n", "Our initial guess $ v $ is the value of accepting at every given wage" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# parameters and constant objects\n", "\n", "c = 25\n", "β = 0.99\n", "num_plots = 6\n", "\n", "# Operator\n", "T(v) = max.(w/(1 - β), c + β * E*v) # (5) broadcasts over the w, fixes the v\n", "# alternatively, T(v) = [max(wval/(1 - β), c + β * E*v) for wval in w]\n", "\n", "# fill in matrix of vs\n", "vs = zeros(n + 1, 6) # data to fill\n", "vs[:, 1] .= w / (1-β) # initial guess of \"accept all\"\n", "\n", "# manually applying operator\n", "for col in 2:num_plots\n", " v_last = vs[:, col - 1]\n", " vs[:, col] .= T(v_last) # apply operator\n", "end\n", "plot(vs)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "One approach to solving the model is to directly implement this sort of iteration, and continues until measured deviation\n", "between successive iterates is below tol" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "compute_reservation_wage_direct (generic function with 1 method)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function compute_reservation_wage_direct(params; v_iv = collect(w ./(1-β)), max_iter = 500,\n", " tol = 1e-6)\n", " @unpack c, β, w = params\n", "\n", " # create a closure for the T operator\n", " T(v) = max.(w/(1 - β), c + β * E*v) # (5) fixing the parameter values\n", "\n", " v = copy(v_iv) # start at initial value. copy to prevent v_iv modification\n", " v_next = similar(v)\n", " i = 0\n", " error = Inf\n", " while i < max_iter && error > tol\n", " v_next .= T(v) # (4)\n", " error = norm(v_next - v)\n", " i += 1\n", " v .= v_next # copy contents into v. Also could have used v[:] = v_next\n", " end\n", " # now compute the reservation wage\n", " return (1 - β) * (c + β * E*v) # (2)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In the above, we use `v = copy(v_iv)` rather than just `v_iv = v`\n", "\n", "To understand why, first recall that `v_iv` is a function argument – either defaulting to the given value, or passed into the function\n", "\n", "> - If we had gone `v = v_iv` instead, then it would have simply created a new name `v` which binds to whatever is located at `v_iv` \n", "- Since we later use `v .= v_next` later in the algorithm, the values in it would be modified \n", "- Hence, we would be modifying the `v_iv` vector we were passed in, which may not be what the caller of the function wanted \n", "- The big issue this creates are “side-effects” where you can call a function and strange things can happen outside of the function that you didn’t expect \n", "- If you intended for the modification to potentially occur, then the Julia style guide says that we should call the function `compute_reservation_wage_direct!` to make the possible side-effects clear \n", "\n", "\n", "\n", "As usual, we are better off using a package, which may give a better algorithm and is likely to less error prone\n", "\n", "In this case, we can use the `fixedpoint` algorithm discussed in [our Julia by Example lecture](https://lectures.quantecon.org/getting_started_julia/julia_by_example.html) to find the fixed point of the $ T $ operator" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "compute_reservation_wage (generic function with 1 method)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function compute_reservation_wage(params; v_iv = collect(w ./(1-β)), iterations = 500,\n", " ftol = 1e-6, m = 6)\n", " @unpack c, β, w = params\n", " T(v) = max.(w/(1 - β), c + β * E*v) # (5) fixing the parameter values\n", "\n", " v_star = fixedpoint(T, v_iv, iterations = iterations, ftol = ftol,\n", " m = 6).zero # (5)\n", " return (1 - β) * (c + β * E*v_star) # (3)\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let’s compute the reservation wage at the default parameters" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "47.316499766546215" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "mcm = @with_kw (c=25.0, β=0.99, w=w) # named tuples\n", "\n", "compute_reservation_wage(mcm()) # call with default parameters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Comparative Statics\n", "\n", "Now we know how to compute the reservation wage, let’s see how it varies with\n", "parameters\n", "\n", "In particular, let’s look at what happens when we change $ \\beta $ and\n", "$ c $" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "hide-output": false }, "outputs": [], "source": [ "grid_size = 25\n", "R = rand(grid_size, grid_size)\n", "\n", "c_vals = range(10.0, 30.0, length = grid_size)\n", "β_vals = range(0.9, 0.99, length = grid_size)\n", "\n", "for (i, c) in enumerate(c_vals)\n", " for (j, β) in enumerate(β_vals)\n", " R[i, j] = compute_reservation_wage(mcm(c=c, β=β)) # change from defaults\n", " end\n", "end" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "name": "stderr", "output_type": "stream", "text": [ "GKS: invalid bitmap size\n" ] } ], "source": [ "contour(c_vals, β_vals, R',\n", " title = \"Reservation Wage\",\n", " xlabel = \"c\",\n", " ylabel = \"beta\",\n", " fill = true)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As expected, the reservation wage increases both with patience and with\n", "unemployment compensation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Computing the Optimal Policy: Take 2\n", "\n", "The approach to dynamic programming just described is very standard and\n", "broadly applicable\n", "\n", "For this particular problem, there’s also an easier way, which circumvents the\n", "need to compute the value function\n", "\n", "Let $ \\psi $ denote the value of not accepting a job in this period but\n", "then behaving optimally in all subsequent periods\n", "\n", "That is,\n", "\n", "\n", "\n", "$$\n", "\\psi\n", "= c + \\beta\n", " \\sum_{i=1}^n V(w_i) p_i \\tag{6}\n", "$$\n", "\n", "where $ V $ is the value function\n", "\n", "By the Bellman equation, we then have\n", "\n", "$$\n", "V(w_i)\n", "= \\max \\left\\{ \\frac{w_i}{1 - \\beta}, \\, \\psi \\right\\}\n", "$$\n", "\n", "Substituting this last equation into [(6)](#equation-j1) gives\n", "\n", "\n", "\n", "$$\n", "\\psi\n", "= c + \\beta\n", " \\sum_{i=1}^n\n", " \\max \\left\\{\n", " \\frac{w_i}{1 - \\beta}, \\psi\n", " \\right\\} p_i \\tag{7}\n", "$$\n", "\n", "Which we could also write as $ \\psi = T_{\\psi}(\\psi) $ for the appropriate operator\n", "\n", "This is a nonlinear equation that we can solve for $ \\psi $\n", "\n", "One solution method for this kind of nonlinear equation is iterative\n", "\n", "That is,\n", "\n", "Step 1: pick an initial guess $ \\psi $\n", "\n", "Step 2: compute the update $ \\psi' $ via\n", "\n", "\n", "\n", "$$\n", "\\psi'\n", "= c + \\beta\n", " \\sum_{i=1}^n\n", " \\max \\left\\{\n", " \\frac{w_i}{1 - \\beta}, \\psi\n", " \\right\\} p_i \\tag{8}\n", "$$\n", "\n", "Step 3: calculate the deviation $ |\\psi - \\psi'| $\n", "\n", "Step 4: if the deviation is larger than some fixed tolerance, set $ \\psi = \\psi' $ and go to step 2, else continue\n", "\n", "Step 5: return $ \\psi $\n", "\n", "Once again, one can use the Banach contraction mapping theorem to show that this process always converges\n", "\n", "The big difference here, however, is that we’re iterating on a single number, rather than an $ n $-vector\n", "\n", "Here’s an implementation:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "47.093334768880695" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function compute_reservation_wage_ψ(c, β; ψ_iv = E * w ./ (1 - β), max_iter = 500,\n", " tol = 1e-5)\n", " T_ψ(ψ) = [c + β * E*max.((w ./ (1 - β)), ψ[1])] # (7)\n", " # using vectors since fixedpoint doesn't support scalar\n", " ψ_star = fixedpoint(T_ψ, [ψ_iv]).zero[1]\n", " return (1 - β) * (c + β * ψ_star) # (2)\n", "end\n", "compute_reservation_wage_ψ(c, β)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can use this code to solve the exercise below\n", "\n", "Another option is to solve for the root of the $ T_{\\psi}(\\psi) - \\psi $ equation" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "47.09333476888073" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function compute_reservation_wage_ψ2(c, β; ψ_iv = E * w ./ (1 - β), max_iter = 500,\n", " tol = 1e-5)\n", " root_ψ(ψ) = c + β * E*max.((w ./ (1 - β)), ψ) - ψ # (7)\n", " ψ_star = find_zero(root_ψ, ψ_iv)\n", " return (1 - β) * (c + β * ψ_star) # (2)\n", "end\n", "compute_reservation_wage_ψ2(c, β)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercises" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1\n", "\n", "Compute the average duration of unemployment when $ \\beta=0.99 $ and\n", "$ c $ takes the following values\n", "\n", "> `c_vals = range(10, 40, length = 25)`\n", "\n", "\n", "That is, start the agent off as unemployed, computed their reservation wage\n", "given the parameters, and then simulate to see how long it takes to accept\n", "\n", "Repeat a large number of times and take the average\n", "\n", "Plot mean unemployment duration as a function of $ c $ in `c_vals`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solutions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1\n", "\n", "Here’s one solution" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function compute_stopping_time(w̄; seed=1234)\n", " Random.seed!(seed)\n", " stopping_time = 0\n", " t = 1\n", " # make sure the constraint is sometimes binding\n", " @assert length(w) - 1 ∈ support(dist) && w̄ <= w[end]\n", " while true\n", " # Generate a wage draw\n", " w_val = w[rand(dist)] # the wage dist set up earlier\n", " if w_val ≥ w̄\n", " stopping_time = t\n", " break\n", " else\n", " t += 1\n", " end\n", " end\n", " return stopping_time\n", "end\n", "\n", "compute_mean_stopping_time(w̄, num_reps=10000) = mean(i ->\n", " compute_stopping_time(w̄,\n", " seed = i), 1:num_reps)\n", "c_vals = range(10, 40, length = 25)\n", "stop_times = similar(c_vals)\n", "\n", "beta = 0.99\n", "for (i, c) in enumerate(c_vals)\n", " w̄ = compute_reservation_wage_ψ(c, beta)\n", " stop_times[i] = compute_mean_stopping_time(w̄)\n", "end\n", "\n", "plot(c_vals, stop_times, label = \"mean unemployment duration\",\n", " xlabel = \"unemployment compensation\", ylabel = \"months\")" ] } ], "metadata": { "filename": "mccall_model.rst", "kernelspec": { "display_name": "Julia 1.2", "language": "julia", "name": "julia-1.2" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.2.0" }, "title": "Job Search I: The McCall Search Model" }, "nbformat": 4, "nbformat_minor": 2 }