{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "
\n", " \n", " \"QuantEcon\"\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Job Search V: On-the-Job Search\n", "\n", "\n", "" ] }, { "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" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Model features\n", "\n", "\n", "\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": [ "### 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, QuantEcon, Interpolations, Expectations, Parameters\n", "using Plots, NLsolve, Random" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Model\n", "\n", "\n", "\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", "\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}\\} \\tag{1}\n", "$$\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", "\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\\}. \\tag{2}\n", "$$\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", "\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 Beta(2,2) distribution is supported on $ (0,1) $. It has a unimodal, symmetric density peaked at 0.5\n", "\n", "\n", "" ] }, { "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 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 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", "\n", "The following code solves the DP problem described above" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "T (generic function with 1 method)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using Distributions, QuantEcon, Interpolations, Expectations, Parameters\n", "\n", " # model object\n", " function JvWorker(;A = 1.4,\n", " α = 0.6,\n", " β = 0.96,\n", " grid_size = 50,\n", " ϵ = 1e-4)\n", "\n", " G(x, ϕ) = A .* (x .* ϕ).^α\n", " π_func = sqrt\n", " F = Beta(2, 2)\n", "\n", " # expectation operator\n", " E = expectation(F)\n", "\n", " # Set up grid over the state space for DP\n", " # Max of grid is the max of a large quantile value for F and the\n", " # fixed point y = G(y, 1).\n", " grid_max = max(A^(1.0 / (1.0 - α)), quantile(F, 1 - ϵ))\n", "\n", " # range for range(ϵ, grid_max, grid_size). Needed for\n", " # CoordInterpGrid below\n", " x_grid = range(ϵ, grid_max, length = grid_size)\n", "\n", " return (A = A, α = α, β = β, x_grid = x_grid, G = G,\n", " π_func = π_func, F = F, E = E, ϵ = ϵ)\n", " end\n", "\n", "function T!(jv,\n", " V,\n", " new_V::AbstractVector)\n", "\n", " # simplify notation\n", " @unpack G, π_func, F, β, E, ϵ = jv\n", "\n", " # prepare interpoland of value function\n", " Vf = LinearInterpolation(jv.x_grid, V, extrapolation_bc=Line())\n", "\n", " # instantiate the linesearch variables\n", " max_val = -1.0\n", " cur_val = 0.0\n", " max_s = 1.0\n", " max_ϕ = 1.0\n", " search_grid = range(ϵ, 1.0, length = 15)\n", "\n", " for (i, x) in enumerate(jv.x_grid)\n", "\n", " function w(z)\n", " s, ϕ = z\n", " h(u) = Vf(max(G(x, ϕ), u))\n", " integral = E(h)\n", " q = π_func(s) * integral + (1.0 - π_func(s)) * Vf(G(x, ϕ))\n", "\n", " return - x * (1.0 - ϕ - s) - β * q\n", " end\n", "\n", " for s in search_grid\n", " for ϕ in search_grid\n", " cur_val = ifelse(s + ϕ <= 1.0, -w((s, ϕ)), -1.0)\n", " if cur_val > max_val\n", " max_val, max_s, max_ϕ = cur_val, s, ϕ\n", " end\n", " end\n", " end\n", "\n", " new_V[i] = max_val\n", " end\n", "end\n", "\n", "function T!(jv,\n", " V,\n", " out::Tuple{AbstractVector, AbstractVector})\n", "\n", " # simplify notation\n", " @unpack G, π_func, F, β, E, ϵ = jv\n", "\n", " # prepare interpoland of value function\n", " Vf = LinearInterpolation(jv.x_grid, V, extrapolation_bc=Line())\n", "\n", " # instantiate variables\n", " s_policy, ϕ_policy = out[1], out[2]\n", "\n", " # instantiate the linesearch variables\n", " max_val = -1.0\n", " cur_val = 0.0\n", " max_s = 1.0\n", " max_ϕ = 1.0\n", " search_grid = range(ϵ, 1.0, length = 15)\n", "\n", " for (i, x) in enumerate(jv.x_grid)\n", "\n", " function w(z)\n", " s, ϕ = z\n", " h(u) = Vf(max(G(x, ϕ), u))\n", " integral = E(h)\n", " q = π_func(s) * integral + (1.0 - π_func(s)) * Vf(G(x, ϕ))\n", "\n", " return - x * (1.0 - ϕ - s) - β * q\n", " end\n", "\n", " for s in search_grid\n", " for ϕ in search_grid\n", " cur_val = ifelse(s + ϕ <= 1.0, -w((s, ϕ)), -1.0)\n", " if cur_val > max_val\n", " max_val, max_s, max_ϕ = cur_val, s, ϕ\n", " end\n", " end\n", " end\n", "\n", " s_policy[i], ϕ_policy[i] = max_s, max_ϕ\n", "end\n", "end\n", "\n", "function T(jv, V; ret_policies = false)\n", " out = ifelse(ret_policies, (similar(V), similar(V)), similar(V))\n", " T!(jv, V, out)\n", " return out\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The code is written to be relatively generic—and hence reusable\n", "\n", "- For example, we use generic $ G(x,\\phi) $ instead of specific $ A (x \\phi)^{\\alpha} $ \n", "\n", "\n", "Regarding the imports\n", "\n", "- `fixed_quad` is a simple non-adaptive integration routine \n", "- `fmin_slsqp` is a minimization routine that permits inequality constraints \n", "\n", "\n", "Next we write a constructor called `JvWorker` that\n", "\n", "- packages all the parameters and other basic attributes of a given model \n", "- implements the method `T` for value function iteration \n", "\n", "\n", "The `T` method\n", "takes a candidate value function $ V $ and updates it to $ TV $ via\n", "\n", "$$\n", "TV(x)\n", "= - \\min_{s + \\phi \\leq 1} w(s, \\phi)\n", "$$\n", "\n", "where\n", "\n", "\n", "\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\\} \\tag{3}\n", "$$\n", "\n", "Here we are minimizing instead of maximizing to fit with optimization routines\n", "\n", "When we represent $ V $, it will be with a Julia 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 `Vf` that gives linear\n", "interpolation of `V` on `x_grid`\n", "\n", "Hence in the preliminaries of `T`\n", "\n", "- from the array `V` we define a linear interpolation `Vf` of its values \n", " \n", " - `c1` is used to implement the constraint $ s + \\phi \\leq 1 $ \n", " - `c2` is used to implement $ s \\geq \\epsilon $, a numerically stable \n", " alternative to the true constraint $ s \\geq 0 $ \n", " - `c3` does the same for $ \\phi $ \n", " \n", "\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, either by brute-force search over a grid, or specialized solver routines\n", "\n", "The latter is much faster, but convergence to the global optimum is not\n", "guaranteed. Grid search is a simple way to check results" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solving for Policies\n", "\n", "\n", "\n", "Let’s plot the optimal policies and see what they look like\n", "\n", "The code is as follows" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using Plots, NLsolve\n", "gr(fmt=:png);\n", "\n", "wp = JvWorker(grid_size=25)\n", "v_init = collect(wp.x_grid) .* 0.5\n", "\n", "f(x) = T(wp, x)\n", "V = fixedpoint(f, v_init)\n", "sol_V = V.zero\n", "\n", "s_policy, ϕ_policy = T(wp, sol_V, ret_policies = true)\n", "\n", "# plot solution\n", "p = plot(wp.x_grid, [ϕ_policy s_policy sol_V],\n", " title = [\"phi policy\" \"s policy\" \"value function\"],\n", " color = [:orange :blue :green],\n", " xaxis = (\"x\", (0.0, maximum(wp.x_grid))),\n", " yaxis = ((-0.1, 1.1)), size = (800, 800),\n", " legend = false, layout = (3, 1),\n", " bottom_margin = Plots.PlotMeasures.Length(:mm, 20))" ] }, { "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", "" ] }, { "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 $. Plot this with one dot for each realization, in the form of a 45 degree\n", "diagram. Set" ] }, { "cell_type": "markdown", "metadata": { "hide-output": false }, "source": [ "```julia\n", "K = 50\n", "plot_grid_max, plot_grid_size = 1.2, 100\n", "plot_grid = range(0, plot_grid_max, length = plot_grid_size)\n", "plot(plot_grid, plot_grid, color = :black, linestyle = :dash,\n", " lims = (0, plot_grid_max), legend = :none)\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", "" ] }, { "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": 5, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "h_func (generic function with 1 method)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "wp = JvWorker(grid_size=25)\n", "# simplify notation\n", "@unpack G, π_func, F = wp\n", "\n", "v_init = collect(wp.x_grid) * 0.5\n", "f2(x) = T(wp, x)\n", "V2 = fixedpoint(f2, v_init)\n", "sol_V2 = V2.zero\n", "s_policy, ϕ_policy = T(wp, sol_V2, ret_policies=true)\n", "\n", "# Turn the policy function arrays into CoordInterpGrid objects for interpolation\n", "s = LinearInterpolation(wp.x_grid, s_policy, extrapolation_bc=Line())\n", "ϕ = LinearInterpolation(wp.x_grid, ϕ_policy, extrapolation_bc=Line())\n", "\n", "h_func(x, b, U) = (1 - b) * G(x, ϕ(x)) + b * max(G(x, ϕ(x)), U)" ] }, { "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": [ "using Random\n", "Random.seed!(42)\n", "K = 50\n", "\n", "plot_grid_max, plot_grid_size = 1.2, 100\n", "plot_grid = range(0, plot_grid_max, length = plot_grid_size)\n", "ticks = [0.25, 0.5, 0.75, 1.0]\n", "\n", "xs = []\n", "ys = []\n", "for x in plot_grid\n", " for i=1:K\n", " b = rand() < π_func(s(x)) ? 1 : 0\n", " U = rand(wp.F)\n", " y = h_func(x, b, U)\n", " push!(xs, x)\n", " push!(ys, y)\n", " end\n", "end\n", "\n", "plot(plot_grid, plot_grid, color=:black, linestyle=:dash, legend=:none)\n", "scatter!(xs, ys, alpha=0.25, color=:green, lims=(0, plot_grid_max), ticks=ticks)\n", "plot!(xlabel=\"x_t\", ylabel=\"x_{t+1}\", guidefont=font(16))" ] }, { "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\n", "\n", "[https://lectures.quantecon.org/jl/jv.html#Solving-for-Policies](https://lectures.quantecon.org/jl/jv.html#Solving-for-Policies)\n", "\n", "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" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "wp = JvWorker(grid_size=25)\n", "\n", "xbar(ϕ) = (wp.A * ϕ^wp.α)^(1.0 / (1.0 - wp.α))\n", "\n", "ϕ_grid = range(0, 1, length = 100)\n", "\n", "plot(ϕ_grid, [xbar(ϕ) * (1 - ϕ) for ϕ in ϕ_grid], color = :blue,\n", " label = \"w^phi\", legendfont = font(12), xlabel = \"phi\",\n", " guidefont = font(16), grid = false, legend = :topleft)" ] }, { "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": "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 V: On-the-Job Search" }, "nbformat": 4, "nbformat_minor": 2 }