{ "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": [], "source": [ "using InstantiateFromURL\n", "# optionally add arguments to force installation: instantiate = true, precompile = true\n", "github_project(\"QuantEcon/quantecon-notebooks-julia\", version = \"0.8.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\n", "gr(fmt = :png);" ] }, { "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": [ "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://julia.quantecon.org/dynamic_programming/jv.html#Solving-for-Policies](https://julia.quantecon.org/dynamic_programming/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": { "date": 1591310615.5272672, "download_nb": 1, "download_nb_path": "https://julia.quantecon.org/", "filename": "jv.rst", "filename_with_path": "dynamic_programming/jv", "kernelspec": { "display_name": "Julia 1.4.2", "language": "julia", "name": "julia-1.4" }, "language_info": { "file_extension": ".jl", "mimetype": "application/julia", "name": "julia", "version": "1.4.2" }, "title": "Job Search V: On-the-Job Search" }, "nbformat": 4, "nbformat_minor": 2 }