Skip to content

Instantly share code, notes, and snippets.

@natashawatkins

natashawatkins/jv.ipynb Secret

Created October 19, 2018 18:26
Show Gist options
  • Save natashawatkins/807eb4e19fd86ae1ebc8f6dcadd530fb to your computer and use it in GitHub Desktop.
Save natashawatkins/807eb4e19fd86ae1ebc8f6dcadd530fb to your computer and use it in GitHub Desktop.
Download ZIP
jv.ipynb
Display the source blob
Display the rendered blob
Raw
jv.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"<a id='jv'></a>\n",
"<a href=\"#\"><img src=\"/_static/img/jupyter-notebook-download-blue.svg\" id=\"notebook_download_badge\"></a>\n",
"\n",
"<script>\n",
"var path = window.location.pathname;\n",
"var pageName = path.split(\"/\").pop().split(\".\")[0];\n",
"var downloadLink = [\"/\", \"_downloads/ipynb/py/\", pageName, \".ipynb\"].join(\"\");\n",
"document.getElementById('notebook_download_badge').parentElement.setAttribute('href', downloadLink);\n",
"</script>\n",
"\n",
"<a href=\"/status.html\"><img src=\"https://img.shields.io/badge/Execution%20test-not%20available-lightgrey.svg\" id=\"executability_status_badge\"></a>\n",
"\n",
"<div class=\"how-to\">\n",
" <a href=\"#\" class=\"toggle\"><span class=\"icon icon-angle-double-down\"></span>How to read this lecture...</a>\n",
" <div class=\"how-to-content\">\n",
" <p>Code should execute sequentially if run in a Jupyter notebook</p>\n",
" <ul>\n",
" <li>See the <a href=\"/py/getting_started.html\">set up page</a> to install Jupyter, Python and all necessary libraries</li>\n",
" <li>Please direct feedback to <a href=\"mailto:contact@quantecon.org\">contact@quantecon.org</a> or the <a href=\"http://discourse.quantecon.org/\">discourse forum</a></li>\n",
" </ul>\n",
" </div>\n",
"</div>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Job Search V: On-the-Job Search\n",
"\n",
"\n",
"<a id='index-1'></a>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Contents\n",
"\n",
"- [Job Search V: On-the-Job Search](#Job-Search-V:-On-the-Job-Search) \n",
" - [Overview](#Overview) \n",
" - [Model](#Model) \n",
" - [Implementation](#Implementation) \n",
" - [Solving for Policies](#Solving-for-Policies) \n",
" - [Exercises](#Exercises) \n",
" - [Solutions](#Solutions) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Overview\n",
"\n",
"In this section we solve a simple on-the-job search model\n",
"\n",
"- based on [[LS18]](zreferences.html#ljungqvist2012), exercise 6.18, and [[Jov79]](zreferences.html#jovanovic1979) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Model features\n",
"\n",
"\n",
"<a id='index-2'></a>\n",
"- job-specific human capital accumulation combined with on-the-job search \n",
"- infinite horizon dynamic programming with one state variable and two controls "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Model\n",
"\n",
"\n",
"<a id='index-3'></a>\n",
"Let\n",
"\n",
"- $ x_t $ denote the time-$ t $ job-specific human capital of a worker employed at a given firm \n",
"- $ w_t $ denote current wages \n",
"\n",
"\n",
"Let $ w_t = x_t(1 - s_t - \\phi_t) $, where\n",
"\n",
"- $ \\phi_t $ is investment in job-specific human capital for the current role \n",
"- $ s_t $ is search effort, devoted to obtaining new offers from other firms \n",
"\n",
"\n",
"For as long as the worker remains in the current job, evolution of\n",
"$ \\{x_t\\} $ is given by $ x_{t+1} = g(x_t, \\phi_t) $\n",
"\n",
"When search effort at $ t $ is $ s_t $, the worker receives a new job\n",
"offer with probability $ \\pi(s_t) \\in [0, 1] $\n",
"\n",
"Value of offer is $ u_{t+1} $, where $ \\{u_t\\} $ is iid with common distribution $ f $\n",
"\n",
"Worker has the right to reject the current offer and continue with existing job\n",
"\n",
"In particular, $ x_{t+1} = u_{t+1} $ if accepts and $ x_{t+1} = g(x_t, \\phi_t) $ if rejects\n",
"\n",
"Letting $ b_{t+1} \\in \\{0,1\\} $ be binary with $ b_{t+1} = 1 $ indicating an offer, we can write\n",
"\n",
"\n",
"<a id='equation-jd'></a>\n",
"<table width=100%><tr style='background-color: #FFFFFF !important;'>\n",
"<td width=10%></td>\n",
"<td width=80%>\n",
"$$\n",
"x_{t+1}\n",
"= (1 - b_{t+1}) g(x_t, \\phi_t) + b_{t+1}\n",
" \\max \\{ g(x_t, \\phi_t), u_{t+1}\\}\n",
"$$\n",
"</td><td width=10% style='text-align:center !important;'>\n",
"(1)\n",
"</td></tr></table>\n",
"\n",
"Agent’s objective: maximize expected discounted sum of wages via controls $ \\{s_t\\} $ and $ \\{\\phi_t\\} $\n",
"\n",
"Taking the expectation of $ v(x_{t+1}) $ and using [(1)](#equation-jd),\n",
"the Bellman equation for this problem can be written as\n",
"\n",
"\n",
"<a id='equation-jvbell'></a>\n",
"<table width=100%><tr style='background-color: #FFFFFF !important;'>\n",
"<td width=10%></td>\n",
"<td width=80%>\n",
"$$\n",
"v(x)\n",
"= \\max_{s + \\phi \\leq 1}\n",
" \\left\\{\n",
" x (1 - s - \\phi) + \\beta (1 - \\pi(s)) v[g(x, \\phi)] +\n",
" \\beta \\pi(s) \\int v[g(x, \\phi) \\vee u] f(du)\n",
" \\right\\}\n",
"$$\n",
"</td><td width=10% style='text-align:center !important;'>\n",
"(2)\n",
"</td></tr></table>\n",
"\n",
"Here nonnegativity of $ s $ and $ \\phi $ is understood, while\n",
"$ a \\vee b := \\max\\{a, b\\} $"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Parameterization\n",
"\n",
"\n",
"<a id='index-4'></a>\n",
"In the implementation below, we will focus on the parameterization\n",
"\n",
"$$\n",
"g(x, \\phi) = A (x \\phi)^{\\alpha},\n",
"\\quad\n",
"\\pi(s) = \\sqrt s\n",
"\\quad \\text{and} \\quad\n",
"f = \\text{Beta}(2, 2)\n",
"$$\n",
"\n",
"with default parameter values\n",
"\n",
"- $ A = 1.4 $ \n",
"- $ \\alpha = 0.6 $ \n",
"- $ \\beta = 0.96 $ \n",
"\n",
"\n",
"The $ \\text{Beta}(2,2) $ distribution is supported on $ (0,1) $ - it has a unimodal, symmetric density peaked at 0.5\n",
"\n",
"\n",
"<a id='jvboecalc'></a>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Back-of-the-Envelope Calculations\n",
"\n",
"Before we solve the model, let’s make some quick calculations that\n",
"provide intuition on what the solution should look like\n",
"\n",
"To begin, observe that the worker has two instruments to build\n",
"capital and hence wages:\n",
"\n",
"1. invest in capital specific to the current job via $ \\phi $ \n",
"1. search for a new job with better job-specific capital match via $ s $ \n",
"\n",
"\n",
"Since wages are $ x (1 - s - \\phi) $, marginal cost of investment via either $ \\phi $ or $ s $ is identical\n",
"\n",
"Our risk neutral worker should focus on whatever instrument has the highest expected return\n",
"\n",
"The relative expected return will depend on $ x $\n",
"\n",
"For example, suppose first that $ x = 0.05 $\n",
"\n",
"- If $ s=1 $ and $ \\phi = 0 $, then since $ g(x,\\phi) = 0 $,\n",
" taking expectations of [(1)](#equation-jd) gives expected next period capital equal to $ \\pi(s) \\mathbb{E} u\n",
" = \\mathbb{E} u = 0.5 $ \n",
"- If $ s=0 $ and $ \\phi=1 $, then next period capital is $ g(x, \\phi) = g(0.05, 1) \\approx 0.23 $ \n",
"\n",
"\n",
"Both rates of return are good, but the return from search is better\n",
"\n",
"Next suppose that $ x = 0.4 $\n",
"\n",
"- If $ s=1 $ and $ \\phi = 0 $, then expected next period capital is again $ 0.5 $ \n",
"- If $ s=0 $ and $ \\phi = 1 $, then $ g(x, \\phi) = g(0.4, 1) \\approx 0.8 $ \n",
"\n",
"\n",
"Return from investment via $ \\phi $ dominates expected return from search\n",
"\n",
"Combining these observations gives us two informal predictions:\n",
"\n",
"1. At any given state $ x $, the two controls $ \\phi $ and $ s $ will\n",
" function primarily as substitutes — worker will focus on whichever instrument has the higher expected return \n",
"1. For sufficiently small $ x $, search will be preferable to investment in\n",
" job-specific human capital. For larger $ x $, the reverse will be true \n",
"\n",
"\n",
"Now let’s turn to implementation, and see if we can match our predictions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Implementation\n",
"\n",
"\n",
"<a id='index-5'></a>\n",
"We will set up a class JVWorker that holds the parameters of the model described above"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import scipy.stats as stats\n",
"from interpolation import interp\n",
"from numba import njit, prange\n",
"import matplotlib.pyplot as plt\n",
"from math import gamma\n",
"from quantecon.optimize import maximize"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"class JVWorker:\n",
" r\"\"\"\n",
" A Jovanovic-type model of employment with on-the-job search.\n",
"\n",
" \"\"\"\n",
"\n",
" def __init__(self,\n",
" A=1.4,\n",
" α=0.6,\n",
" β=0.96, # Discount factor\n",
" π=np.sqrt, # Search effort function\n",
" a=2, # Parameter of f\n",
" b=2, # Parameter of f\n",
" grid_size=50,\n",
" mc_size=100,\n",
" ɛ=1e-4):\n",
"\n",
" self.A, self.α, self.β, self.π = A, α, β, π\n",
" self.mc_size, self.ɛ = mc_size, ɛ\n",
"\n",
" self.g = njit(lambda x, ϕ: A * (x * ϕ)**α) # Transition function\n",
" self.f_rvs = np.random.beta(a, b, mc_size)\n",
"\n",
" # Max of grid is the max of a large quantile value for f and the\n",
" # fixed point y = g(y, 1)\n",
" ɛ = 1e-4\n",
" grid_max = max(A**(1 / (1 - α)), stats.beta(a, b).ppf(1 - ɛ))\n",
"\n",
" # Human capital\n",
" self.x_grid = np.linspace(ɛ, grid_max, grid_size)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The function operator_factory takes an instance of this class and returns a\n",
"jitted version of the Bellman operator T, ie.\n",
"\n",
"$$\n",
"Tv(x)\n",
"= - \\min_{s + \\phi \\leq 1} w(s, \\phi)\n",
"$$\n",
"\n",
"where\n",
"\n",
"\n",
"<a id='equation-defw'></a>\n",
"<table width=100%><tr style='background-color: #FFFFFF !important;'>\n",
"<td width=10%></td>\n",
"<td width=80%>\n",
"$$\n",
"w(s, \\phi)\n",
" := - \\left\\{\n",
" x (1 - s - \\phi) + \\beta (1 - \\pi(s)) v[g(x, \\phi)] +\n",
" \\beta \\pi(s) \\int v[g(x, \\phi) \\vee u] f(du)\n",
"\\right\\}\n",
"$$\n",
"</td><td width=10% style='text-align:center !important;'>\n",
"(3)\n",
"</td></tr></table>\n",
"\n",
"Here we are minimizing instead of maximizing to fit with SciPy’s optimization routines\n",
"\n",
"When we represent $ v $, it will be with a NumPy array `v` giving values on grid `x_grid`\n",
"\n",
"But to evaluate the right-hand side of [(3)](#equation-defw), we need a function, so\n",
"we replace the arrays `v` and `x_grid` with a function `v_func` that gives linear\n",
"interpolation of `v` on `x_grid`\n",
"\n",
"Inside the `for` loop, for each `x` in the grid over the state space, we\n",
"set up the function $ w(z) = w(s, \\phi) $ defined in [(3)](#equation-defw)\n",
"\n",
"The function is minimized over all feasible $ (s, \\phi) $ pairs"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"def operator_factory(jv, parallel_flag=True):\n",
"\n",
" \"\"\"\n",
" Returns a jitted version of the Bellman operator T.\n",
"\n",
" If the brute_force flag is True, then grid search is\n",
" performed at each maximization step.\n",
"\n",
" \"\"\"\n",
"\n",
" π, β = jv.π, jv.β\n",
" x_grid, ɛ, mc_size = jv.x_grid, jv.ɛ, jv.mc_size\n",
" f_rvs, g = jv.f_rvs, jv.g\n",
"\n",
" @njit\n",
" def objective(z, x, v):\n",
" s, ϕ = z\n",
" v_func = lambda x: interp(x_grid, v, x)\n",
"\n",
" integral = 0\n",
" for m in range(mc_size):\n",
" u = f_rvs[m]\n",
" integral += v_func(max(g(x, ϕ), u))\n",
" integral = integral / mc_size\n",
"\n",
" q = π(s) * integral + (1 - π(s)) * v_func(g(x, ϕ))\n",
" return x * (1 - ϕ - s) + β * q\n",
"\n",
" @njit(parallel=parallel_flag)\n",
" def T(v):\n",
" \"\"\"\n",
" The Bellman operator\n",
" \"\"\"\n",
"\n",
" v_new = np.empty_like(v)\n",
" for i in prange(len(x_grid)):\n",
" x = x_grid[i]\n",
" z_guess = np.ones(2) * 1e-3\n",
" v_max = maximize(objective, z_guess, args=(x, v))[1]\n",
" v_new[i] = v_max\n",
"\n",
" # === Search on a grid === #\n",
"# search_grid = np.linspace(ɛ, 1.0, 15)\n",
"# max_val = -1\n",
"# for s in search_grid:\n",
"# for ϕ in search_grid:\n",
"# current_val = objective((s, ϕ), x, v) if s + ϕ <= 1 else -1\n",
"# if current_val > max_val:\n",
"# max_val = current_val\n",
"# v_new[i] = max_val\n",
"\n",
" return v_new\n",
"\n",
" @njit\n",
" def get_greedy(v):\n",
" \"\"\"\n",
" Computes the v-greedy policy of a given function v\n",
" \"\"\"\n",
" s_policy, ϕ_policy = np.empty_like(v), np.empty_like(v)\n",
"\n",
" for i in range(len(x_grid)):\n",
" x = x_grid[i]\n",
" # === Search on a grid === #\n",
" search_grid = np.linspace(ɛ, 1.0, 15)\n",
" max_val = -1\n",
" for s in search_grid:\n",
" for ϕ in search_grid:\n",
" current_val = objective((s, ϕ), x, v) if s + ϕ <= 1 else -1\n",
" if current_val > max_val:\n",
" max_val = current_val\n",
" max_s, max_ϕ = s, ϕ\n",
" s_policy[i], ϕ_policy[i] = max_s, max_ϕ\n",
" return s_policy, ϕ_policy\n",
"\n",
" return T, get_greedy"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Another function, get_greedy returns the optimal policies of s and $ \\phi $\n",
"given a value function\n",
"\n",
"To solve the model, we will write a function that uses the Bellman operator\n",
"and iterates to find a fixed point"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"def solve_model(jv,\n",
" use_parallel=True,\n",
" tol=1e-4,\n",
" max_iter=1000,\n",
" verbose=True,\n",
" print_skip=25):\n",
"\n",
" T, _ = operator_factory(jv, parallel_flag=use_parallel)\n",
"\n",
" # Set up loop\n",
" v = jv.x_grid * 0.5 # Initial condition\n",
" i = 0\n",
" error = tol + 1\n",
"\n",
" while i < max_iter and error > tol:\n",
" v_new = T(v)\n",
" error = np.max(np.abs(v - v_new))\n",
" i += 1\n",
" if verbose and i % print_skip == 0:\n",
" print(f\"Error at iteration {i} is {error}.\")\n",
" v = v_new\n",
"\n",
" if i == max_iter:\n",
" print(\"Failed to converge!\")\n",
"\n",
" if verbose and i < max_iter:\n",
" print(f\"\\nConverged in {i} iterations.\")\n",
"\n",
" return v_new"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Solving for Policies\n",
"\n",
"\n",
"<a id='index-6'></a>\n",
"Let’s plot the optimal policies and see what they look like\n",
"\n",
"\n",
"<a id='jv-policies'></a>"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0.01067166, 0.28218205, 0.24232917, 0.25001739, 0.27844405,\n",
" 0.31885461, 0.3628996 , 0.40827483, 0.4502868 , 0.50061965,\n",
" 0.54727787, 0.59404979, 0.6409304 , 0.6878976 , 0.73492317,\n",
" 0.78193181, 0.82910132, 0.87608854, 0.92307371, 0.97033106,\n",
" 1.01738383, 1.0649249 , 1.11169034, 1.15930742, 1.20649978,\n",
" 1.253258 , 1.29996842, 1.34835727, 1.39442578, 1.44283795,\n",
" 1.49022109, 1.53694527, 1.58434709, 1.631863 , 1.67934266,\n",
" 1.72662995, 1.77391952, 1.82075732, 1.86820691, 1.91580004,\n",
" 1.9629891 , 2.00981046, 2.05694886, 2.10425969, 2.14986381,\n",
" 2.19836777, 2.24566034, 2.29399005, 2.33996704, 2.38744521])"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"jv = JVWorker()\n",
"T, get_greedy = operator_factory(jv)\n",
"v = jv.x_grid * 0.5\n",
"T(v)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0.0100408 , 0.25757153, 0.23090093, 0.2392882 , 0.27258888,\n",
" 0.31524506, 0.35959354, 0.40516723, 0.45217528, 0.49922067,\n",
" 0.54602981, 0.59294848, 0.63994378, 0.6870005 , 0.73409945,\n",
" 0.78123241, 0.82839241, 0.87547993, 0.9221669 , 0.96947186,\n",
" 1.01711864, 1.06416318, 1.11125585, 1.15859897, 1.20592479,\n",
" 1.25332212, 1.29919108, 1.34744953, 1.39517136, 1.44254327,\n",
" 1.48879117, 1.53671401, 1.58412564, 1.63171526, 1.6790292 ,\n",
" 1.7263259 , 1.77362433, 1.82024504, 1.86779431, 1.91458521,\n",
" 1.96085292, 2.00886714, 2.05735774, 2.10391579, 2.15200044,\n",
" 2.19784941, 2.24514347, 2.2939885 , 2.34129967, 2.38692887])"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"solver"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Error at iteration 25 is 0.13548171477271032.\n",
"Error at iteration 50 is 0.33170477216723526.\n",
"Error at iteration 75 is 30.75932236089605.\n",
"Error at iteration 100 is 16826.229637671444.\n",
"Error at iteration 125 is 25189488.882535975.\n",
"Error at iteration 150 is 6.6229870895071424e+47.\n",
"Error at iteration 175 is 2.963076685228901e+75.\n",
"Error at iteration 200 is 1.0678831091550286e+75.\n",
"Error at iteration 225 is 3.848615665276069e+74.\n",
"Error at iteration 250 is 1.3870284502138379e+74.\n",
"Error at iteration 275 is 4.998804996457318e+73.\n",
"Error at iteration 300 is 1.8015529089366773e+73.\n",
"Error at iteration 325 is 6.492737536267926e+72.\n",
"Error at iteration 350 is 2.339961291491773e+72.\n",
"Error at iteration 375 is 8.43314367028486e+71.\n",
"Error at iteration 400 is 3.039277291562631e+71.\n",
"Error at iteration 425 is 1.0953455575003075e+71.\n",
"Error at iteration 450 is 3.9475894274812546e+70.\n",
"Error at iteration 475 is 1.4226982691676705e+70.\n",
"Error at iteration 500 is 5.127357852876165e+69.\n",
"Error at iteration 525 is 1.847882936332743e+69.\n",
"Error at iteration 550 is 6.659709433922774e+68.\n",
"Error at iteration 575 is 2.400137415214139e+68.\n",
"Error at iteration 600 is 8.650016444512634e+67.\n",
"Error at iteration 625 is 3.117437527370223e+67.\n",
"Error at iteration 650 is 1.1235142498742187e+67.\n",
"Error at iteration 675 is 4.0491084699786484e+66.\n",
"Error at iteration 700 is 1.4592853987822984e+66.\n",
"Error at iteration 725 is 5.259216666799841e+65.\n",
"Error at iteration 750 is 1.895404419959635e+65.\n",
"Error at iteration 775 is 6.830975300716375e+64.\n",
"Error at iteration 800 is 2.4618610713163663e+64.\n",
"Error at iteration 825 is 8.872466474629887e+63.\n",
"Error at iteration 850 is 3.1976077878894316e+63.\n",
"Error at iteration 875 is 1.1524073485549818e+63.\n",
"Error at iteration 900 is 4.153238249022698e+62.\n",
"Error at iteration 925 is 1.4968134292769293e+62.\n",
"Error at iteration 950 is 5.394466456603979e+61.\n",
"Error at iteration 975 is 1.9441480001607803e+61.\n",
"Error at iteration 1000 is 7.006645563440322e+60.\n",
"Failed to converge!\n"
]
},
{
"data": {
"image/png": "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\n",
"text/plain": [
"<matplotlib.figure.Figure at 0x1c17fd84e0>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"v_star = solve_model(jv)\n",
"s_star, ϕ_star = get_greedy(v_star)\n",
"plots = [s_star, ϕ_star, v_star]\n",
"titles = [\"ϕ policy\", \"s policy\", \"value function\"]\n",
"\n",
"fig, axes = plt.subplots(3, 1, figsize=(12, 12))\n",
"\n",
"for ax, plot, title in zip(axes, plots, titles):\n",
" ax.plot(jv.x_grid, plot)\n",
" ax.set(title=title)\n",
" ax.grid()\n",
"\n",
"axes[-1].set_xlabel(\"x\")\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The horizontal axis is the state $ x $, while the vertical axis gives $ s(x) $ and $ \\phi(x) $\n",
"\n",
"Overall, the policies match well with our predictions from [section](#jvboecalc)\n",
"\n",
"- Worker switches from one investment strategy to the other depending on relative return \n",
"- For low values of $ x $, the best option is to search for a new job \n",
"- Once $ x $ is larger, worker does better by investing in human capital specific to the current position "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercises\n",
"\n",
"\n",
"<a id='jv-ex1'></a>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercise 1\n",
"\n",
"Let’s look at the dynamics for the state process $ \\{x_t\\} $ associated with these policies\n",
"\n",
"The dynamics are given by [(1)](#equation-jd) when $ \\phi_t $ and $ s_t $ are\n",
"chosen according to the optimal policies, and $ \\mathbb{P}\\{b_{t+1} = 1\\}\n",
"= \\pi(s_t) $\n",
"\n",
"Since the dynamics are random, analysis is a bit subtle\n",
"\n",
"One way to do it is to plot, for each $ x $ in a relatively fine grid\n",
"called `plot_grid`, a\n",
"large number $ K $ of realizations of $ x_{t+1} $ given $ x_t =\n",
"x $\n",
"\n",
"Plot this with one dot for each realization, in the form of a 45 degree\n",
"diagram, setting"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"```python3\n",
"jv = JVWorker(grid_size=25, mc_size=50)\n",
"plot_grid_max, plot_grid_size = 1.2, 100\n",
"plot_grid = np.linspace(0, plot_grid_max, plot_grid_size)\n",
"fig, ax = plt.subplots()\n",
"ax.set_xlim(0, plot_grid_max)\n",
"ax.set_ylim(0, plot_grid_max)\n",
"```\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"By examining the plot, argue that under the optimal policies, the state\n",
"$ x_t $ will converge to a constant value $ \\bar x $ close to unity\n",
"\n",
"Argue that at the steady state, $ s_t \\approx 0 $ and $ \\phi_t \\approx 0.6 $\n",
"\n",
"\n",
"<a id='jv-ex2'></a>"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercise 2\n",
"\n",
"In the preceding exercise we found that $ s_t $ converges to zero\n",
"and $ \\phi_t $ converges to about 0.6\n",
"\n",
"Since these results were calculated at a value of $ \\beta $ close to\n",
"one, let’s compare them to the best choice for an *infinitely* patient worker\n",
"\n",
"Intuitively, an infinitely patient worker would like to maximize steady state\n",
"wages, which are a function of steady state capital\n",
"\n",
"You can take it as given—it’s certainly true—that the infinitely patient worker does not\n",
"search in the long run (i.e., $ s_t = 0 $ for large $ t $)\n",
"\n",
"Thus, given $ \\phi $, steady state capital is the positive fixed point\n",
"$ x^*(\\phi) $ of the map $ x \\mapsto g(x, \\phi) $\n",
"\n",
"Steady state wages can be written as $ w^*(\\phi) = x^*(\\phi) (1 - \\phi) $\n",
"\n",
"Graph $ w^*(\\phi) $ with respect to $ \\phi $, and examine the best\n",
"choice of $ \\phi $\n",
"\n",
"Can you give a rough interpretation for the value that you see?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Solutions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercise 1\n",
"\n",
"Here’s code to produce the 45 degree diagram"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"jv = JVWorker(grid_size=25, mc_size=50)\n",
"π, g, f_rvs, x_grid = jv.π, jv.g, jv.f_rvs, jv.x_grid\n",
"T, get_greedy = operator_factory(jv)\n",
"v_star = solve_model(jv, verbose=False)\n",
"s_policy, ϕ_policy = get_greedy(v_star)\n",
"\n",
"# Turn the policy function arrays into actual functions\n",
"s = lambda y: interp(x_grid, s_policy, y)\n",
"ϕ = lambda y: interp(x_grid, ϕ_policy, y)\n",
"\n",
"def h(x, b, u):\n",
" return (1 - b) * g(x, ϕ(x)) + b * max(g(x, ϕ(x)), u)\n",
"\n",
"\n",
"plot_grid_max, plot_grid_size = 1.2, 100\n",
"plot_grid = np.linspace(0, plot_grid_max, plot_grid_size)\n",
"fig, ax = plt.subplots(figsize=(8, 8))\n",
"ticks = (0.25, 0.5, 0.75, 1.0)\n",
"ax.set(xticks=ticks, yticks=ticks,\n",
" xlim=(0, plot_grid_max),\n",
" ylim=(0, plot_grid_max),\n",
" xlabel='$x_t$', ylabel='$x_{t+1}$')\n",
"\n",
"ax.plot(plot_grid, plot_grid, 'k--', alpha=0.6) # 45 degree line\n",
"for x in plot_grid:\n",
" for i in range(jv.mc_size):\n",
" b = 1 if np.random.uniform(0, 1) < π(s(x)) else 0\n",
" u = f_rvs[i]\n",
" y = h(x, b, u)\n",
" ax.plot(x, y, 'go', alpha=0.25)\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Looking at the dynamics, we can see that\n",
"\n",
"- If $ x_t $ is below about 0.2 the dynamics are random, but\n",
" $ x_{t+1} > x_t $ is very likely \n",
"- As $ x_t $ increases the dynamics become deterministic, and\n",
" $ x_t $ converges to a steady state value close to 1 \n",
"\n",
"\n",
"Referring back to the figure [here](#jv-policies) we see that $ x_t \\approx 1 $ means that\n",
"$ s_t = s(x_t) \\approx 0 $ and\n",
"$ \\phi_t = \\phi(x_t) \\approx 0.6 $"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Exercise 2\n",
"\n",
"The figure can be produced as follows"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"jv = JVWorker()\n",
"\n",
"def xbar(ϕ):\n",
" A, α = jv.A, jv.α\n",
" return (A * ϕ**α)**(1 / (1 - α))\n",
"\n",
"ϕ_grid = np.linspace(0, 1, 100)\n",
"fig, ax = plt.subplots(figsize=(9, 7))\n",
"ax.set(xlabel='$\\phi$')\n",
"ax.plot(ϕ_grid, [xbar(ϕ) * (1 - ϕ) for ϕ in ϕ_grid], label='$w^*(\\phi)$')\n",
"ax.legend()\n",
"\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Observe that the maximizer is around 0.6\n",
"\n",
"This this is similar to the long run value for $ \\phi $ obtained in\n",
"exercise 1\n",
"\n",
"Hence the behaviour of the infinitely patent worker is similar to that\n",
"of the worker with $ \\beta = 0.96 $\n",
"\n",
"This seems reasonable, and helps us confirm that our dynamic programming\n",
"solutions are probably correct"
]
}
],
"metadata": {
"filename": "jv.rst",
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.4"
},
"title": "Job Search V: On-the-Job Search"
},
"nbformat": 4,
"nbformat_minor": 2
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment