{
"cells": [
{
"cell_type": "markdown",
"id": "decc2ca4",
"metadata": {},
"source": [
"$$\n",
"\\newcommand{\\argmax}{arg\\,max}\n",
"\\newcommand{\\argmin}{arg\\,min}\n",
"$$"
]
},
{
"cell_type": "markdown",
"id": "c44fc4f8",
"metadata": {},
"source": [
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "7a8c472d",
"metadata": {},
"source": [
"# Job Search II: Search and Separation"
]
},
{
"cell_type": "markdown",
"id": "a6d8afae",
"metadata": {},
"source": [
"# GPU\n",
"\n",
"This lecture was built using a machine with access to a GPU — although it will also run without one.\n",
"\n",
"[Google Colab](https://colab.research.google.com/) has a free tier with GPUs\n",
"that you can access as follows:\n",
"\n",
"1. Click on the “play” icon top right \n",
"1. Select Colab \n",
"1. Set the runtime environment to include a GPU \n",
"\n",
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "5bad36a6",
"metadata": {},
"source": [
"## Contents\n",
"\n",
"- [Job Search II: Search and Separation](#Job-Search-II:-Search-and-Separation) \n",
" - [Overview](#Overview) \n",
" - [The model](#The-model) \n",
" - [Solving the model](#Solving-the-model) \n",
" - [Code](#Code) \n",
" - [A simplifying transformation](#A-simplifying-transformation) \n",
" - [Implementation](#Implementation) \n",
" - [Impact of parameters](#Impact-of-parameters) \n",
" - [Exercises](#Exercises) "
]
},
{
"cell_type": "markdown",
"id": "1b1f08cf",
"metadata": {},
"source": [
"In addition to what’s in Anaconda, this lecture will need the following libraries:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2cb30426",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"!pip install quantecon jax myst-nb"
]
},
{
"cell_type": "markdown",
"id": "c4920d23",
"metadata": {},
"source": [
"## Overview\n",
"\n",
"Previously [we looked](https://python.quantecon.org/mccall_model.html) at the McCall job search model [[McCall, 1970](https://python.quantecon.org/zreferences.html#id208)] as a way of understanding unemployment and worker decisions.\n",
"\n",
"One unrealistic feature of that version of the model was that every job is permanent.\n",
"\n",
"In this lecture, we extend the model by introducing job separation.\n",
"\n",
"Once separation enters the picture, the agent comes to view\n",
"\n",
"- the loss of a job as a capital loss, and \n",
"- a spell of unemployment as an *investment* in searching for an acceptable job \n",
"\n",
"\n",
"The other minor addition is that a utility function will be included to make\n",
"worker preferences slightly more sophisticated.\n",
"\n",
"We’ll need the following imports"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3f3ad10e",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import jax\n",
"import jax.numpy as jnp\n",
"from typing import NamedTuple\n",
"from quantecon.distributions import BetaBinomial\n",
"from myst_nb import glue"
]
},
{
"cell_type": "markdown",
"id": "82b33a15",
"metadata": {},
"source": [
"## The model\n",
"\n",
"The model is similar to the [baseline McCall job search model](https://python.quantecon.org/mccall_model.html).\n",
"\n",
"It concerns the life of an infinitely lived worker and\n",
"\n",
"- the opportunities he or she (let’s say he to save one character) has to work at different wages \n",
"- exogenous events that destroy his current job \n",
"- his decision making process while unemployed \n",
"\n",
"\n",
"The worker can be in one of two states: employed or unemployed.\n",
"\n",
"He wants to maximize\n",
"\n",
"\n",
"\n",
"$$\n",
"{\\mathbb E} \\sum_{t=0}^\\infty \\beta^t u(y_t) \\tag{43.1}\n",
"$$\n",
"\n",
"At this stage the only difference from the [baseline model](https://python.quantecon.org/mccall_model.html) is that we’ve added some flexibility to preferences by\n",
"introducing a utility function $ u $.\n",
"\n",
"It satisfies $ u'> 0 $ and $ u'' < 0 $.\n",
"\n",
"Wage offers $ \\{ W_t \\} $ are IID with common distribution $ q $.\n",
"\n",
"The set of possible wage values is denoted by $ \\mathbb W $."
]
},
{
"cell_type": "markdown",
"id": "8e723ffe",
"metadata": {},
"source": [
"### Timing and decisions\n",
"\n",
"At the start of each period, the agent can be either\n",
"\n",
"- unemployed or \n",
"- employed at some existing wage level $ w $. \n",
"\n",
"\n",
"If currently employed at wage $ w $, the worker\n",
"\n",
"1. receives utility $ u(w) $ from their current wage and \n",
"1. is fired with some (small) probability $ \\alpha $, becoming unemployed next period. \n",
"\n",
"\n",
"If currently unemployed, the worker receives random wage offer $ W_t $ and either accepts or rejects.\n",
"\n",
"If he accepts, then he begins work immediately at wage $ W_t $.\n",
"\n",
"If he rejects, then he receives unemployment compensation $ c $.\n",
"\n",
"The process then repeats.\n",
"\n",
">**Note**\n",
">\n",
">We do not allow for job search while employed—this topic is taken up in a [later lecture](https://python.quantecon.org/jv.html)."
]
},
{
"cell_type": "markdown",
"id": "4ee3fe70",
"metadata": {},
"source": [
"## Solving the model\n",
"\n",
"We drop time subscripts in what follows and primes denote next period values.\n",
"\n",
"Let\n",
"\n",
"- $ v_e(w) $ be maximum lifetime value for a worker who enters the current\n",
" period employed with wage $ w $ \n",
"- $ v_u(w) $ be maximum lifetime for a worker who who enters the\n",
" current period unemployed and receives wage offer $ w $. \n",
"\n",
"\n",
"Here, **maximum lifetime value** means the value of [(43.1)](#equation-objective) when\n",
"the worker makes optimal decisions at all future points in time.\n",
"\n",
"As we now show, obtaining these functions is key to solving the model."
]
},
{
"cell_type": "markdown",
"id": "770a71b6",
"metadata": {},
"source": [
"### The Bellman equations\n",
"\n",
"We recall that, in [the original job search model](https://python.quantecon.org/mccall_model.html), the\n",
"value function (the value of being unemployed with a given wage offer) satisfied\n",
"a Bellman equation.\n",
"\n",
"Here this function again satisfies a Bellman equation that looks very similar.\n",
"\n",
"\n",
"\n",
"$$\n",
"v_u(w) = \\max \n",
" \\left\\{ \n",
" v_e(w), \\, \n",
" u(c) + \\beta \\sum_{w' \\in \\mathbb W} v_u(w') q(w') \n",
" \\right\\} \\tag{43.2}\n",
"$$\n",
"\n",
"The difference is that the value of accepting is $ v_e(w) $ rather than\n",
"$ w/(1-\\beta) $.\n",
"\n",
"We have to make this change because jobs are not permanent.\n",
"\n",
"Accepting transitions the worker to employment and hence yields reward $ v_e(w) $,\n",
"which we discuss below.\n",
"\n",
"Rejecting leads to unemployment compensation and unemployment tomorrow.\n",
"\n",
"Equation [(43.2)](#equation-bell2-mccall) expresses the value of being unemployed with offer\n",
"$ w $ in hand as a maximum over the value of two options: accept or reject\n",
"the current offer.\n",
"\n",
"The function $ v_e $ also satisfies a Bellman equation:\n",
"\n",
"\n",
"\n",
"$$\n",
"v_e(w) = u(w) + \\beta\n",
" \\left[\n",
" (1-\\alpha)v_e(w) + \\alpha \\sum_{w' \\in \\mathbb W} v_u(w') q(w')\n",
" \\right] \\tag{43.3}\n",
"$$\n",
"\n",
">**Note**\n",
">\n",
">This equation differs from a traditional Bellman equation because there is no max.\n",
"\n",
"There is no max because an employed agent has no choices.\n",
"\n",
"Nonetheless, in keeping with most of the literature, we also refer to it as a\n",
"Bellman equation.\n",
"\n",
"Equation [(43.3)](#equation-bell1-mccall) expresses the value of being employed at wage $ w $ in terms of\n",
"\n",
"- current reward $ u(w) $ plus \n",
"- discounted expected reward tomorrow, given the $ \\alpha $ probability of being fired \n",
"\n",
"\n",
"As we will see, equations [(43.3)](#equation-bell1-mccall) and [(43.2)](#equation-bell2-mccall) provide\n",
"enough information to solve for both $ v_e $ and $ v_u $.\n",
"\n",
"Once we have them in hand, we will be able to make optimal choices."
]
},
{
"cell_type": "markdown",
"id": "6dec9815",
"metadata": {},
"source": [
"### The reservation wage\n",
"\n",
"Let\n",
"\n",
"\n",
"\n",
"$$\n",
"h := u(c) + \\beta \\sum_{w' \\in \\mathbb W} v_u(w') q(w') \\tag{43.4}\n",
"$$\n",
"\n",
"This is the **continuation value** for an unemployed agent – the value of rejecting the current offer and then making optimal choices.\n",
"\n",
"From [(43.2)](#equation-bell2-mccall), we see that an unemployed agent accepts current offer $ w $ if $ v_e(w) \\geq h $.\n",
"\n",
"This means precisely that the value of accepting is higher than the value of rejecting.\n",
"\n",
"The function $ v_e $ is increasing in $ w $, since an employed agent is never made worse off by a higher current wage.\n",
"\n",
"Hence, we can express the optimal choice as accepting wage offer $ w $ if and only if $ w \\geq \\bar w $,\n",
"where the **reservation wage** $ \\bar w $ is the first wage level $ w \\in \\mathbb W $ such that\n",
"\n",
"$$\n",
"v_e(w) \\geq h\n",
"$$"
]
},
{
"cell_type": "markdown",
"id": "4088cc13",
"metadata": {},
"source": [
"## Code\n",
"\n",
"Let’s now implement a solution method based on the two Bellman equations\n",
"[(43.2)](#equation-bell2-mccall) and [(43.3)](#equation-bell1-mccall)."
]
},
{
"cell_type": "markdown",
"id": "82529942",
"metadata": {},
"source": [
"### Set up\n",
"\n",
"The default utility function is a CRRA utility function"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c686e537",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def u(x, γ):\n",
" return (x**(1 - γ) - 1) / (1 - γ)"
]
},
{
"cell_type": "markdown",
"id": "6c02f043",
"metadata": {},
"source": [
"Also, here’s a default wage distribution, based around the BetaBinomial\n",
"distribution:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95dc5947",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"n = 60 # n possible outcomes for w\n",
"w_default = jnp.linspace(10, 20, n) # wages between 10 and 20\n",
"a, b = 600, 400 # shape parameters\n",
"dist = BetaBinomial(n-1, a, b) # distribution\n",
"q_default = jnp.array(dist.pdf()) # probabilities as a JAX array"
]
},
{
"cell_type": "markdown",
"id": "2e7f1022",
"metadata": {},
"source": [
"Here’s our model class for the McCall model with separation."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0520918f",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"class Model(NamedTuple):\n",
" α: float = 0.2 # job separation rate\n",
" β: float = 0.98 # discount factor\n",
" γ: float = 2.0 # utility parameter (CRRA)\n",
" c: float = 6.0 # unemployment compensation\n",
" w: jnp.ndarray = w_default # wage outcome space\n",
" q: jnp.ndarray = q_default # probabilities over wage offers"
]
},
{
"cell_type": "markdown",
"id": "f4e4c651",
"metadata": {},
"source": [
"### Operators\n",
"\n",
"We’ll use a similar iterative approach to solving the Bellman equations that we\n",
"adopted in the [first job search lecture](https://python.quantecon.org/mccall_model.html).\n",
"\n",
"As a first step, to iterate on the Bellman equations, we define two operators, one for each value function.\n",
"\n",
"These operators take the current value functions as inputs and return updated versions."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c8ac9e4d",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def T_u(model, v_u, v_e):\n",
" \"\"\"\n",
" Apply the unemployment Bellman update rule and return new guess of v_u.\n",
"\n",
" \"\"\"\n",
" α, β, γ, c, w, q = model\n",
" h = u(c, γ) + β * (v_u @ q)\n",
" v_u_new = jnp.maximum(v_e, h)\n",
" return v_u_new"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "27817474",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def T_e(model, v_u, v_e):\n",
" \"\"\"\n",
" Apply the employment Bellman update rule and return new guess of v_e.\n",
"\n",
" \"\"\"\n",
" α, β, γ, c, w, q = model\n",
" v_e_new = u(w, γ) + β * ((1 - α) * v_e + α * (v_u @ q))\n",
" return v_e_new"
]
},
{
"cell_type": "markdown",
"id": "578c45cd",
"metadata": {},
"source": [
"### Iteration\n",
"\n",
"Now we write an iteration routine, which updates the pair of arrays $ v_u $, $ v_e $ until convergence.\n",
"\n",
"More precisely, we iterate until successive realizations are closer together\n",
"than some small tolerance level."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b4e98ae3",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def solve_full_model(\n",
" model,\n",
" tol: float = 1e-6,\n",
" max_iter: int = 1_000,\n",
" ):\n",
" \"\"\"\n",
" Solves for both value functions v_u and v_e iteratively.\n",
"\n",
" \"\"\"\n",
" α, β, γ, c, w, q = model\n",
" i = 0\n",
" error = tol + 1\n",
" v_e = v_u = w / (1 - β)\n",
"\n",
" while i < max_iter and error > tol:\n",
" v_u_next = T_u(model, v_u, v_e)\n",
" v_e_next = T_e(model, v_u, v_e)\n",
" error_u = jnp.max(jnp.abs(v_u_next - v_u))\n",
" error_e = jnp.max(jnp.abs(v_e_next - v_e))\n",
" error = jnp.max(jnp.array([error_u, error_e]))\n",
" v_u = v_u_next\n",
" v_e = v_e_next\n",
" i += 1\n",
"\n",
" return v_u, v_e"
]
},
{
"cell_type": "markdown",
"id": "1feabef3",
"metadata": {},
"source": [
"### Computing the reservation wage\n",
"\n",
"Now that we can solve for both value functions, let’s investigate the reservation wage.\n",
"\n",
"Recall from above that the reservation wage $ \\bar w $ is the first $ w \\in \\mathbb\n",
"W $ satisfying $ v_e(w) \\geq h $, where $ h $ is the continuation value defined in [(43.4)](#equation-defh-mm).\n",
"\n",
"Let’s compare $ v_e $ and $ h $ to see what they look like.\n",
"\n",
"We’ll use the default parameterizations found in the code above."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4ab80cac",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"model = Model()\n",
"α, β, γ, c, w, q = model\n",
"v_u, v_e = solve_full_model(model)\n",
"h = u(c, γ) + β * (v_u @ q)\n",
"\n",
"fig, ax = plt.subplots()\n",
"ax.plot(w, v_e, 'b-', lw=2, alpha=0.7, label='$v_e$')\n",
"ax.plot(w, [h] * len(w), 'g-', lw=2, alpha=0.7, label='$h$')\n",
"ax.set_xlim(min(w), max(w))\n",
"ax.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "a8f3780c",
"metadata": {},
"source": [
"The value $ v_e $ is increasing because higher $ w $ generates a higher wage flow conditional on staying employed.\n",
"\n",
"The reservation wage is the $ w $ where these lines meet.\n",
"\n",
"Let’s compute this reservation wage explicitly:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "dd4c9e1d",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def compute_reservation_wage_full(model):\n",
" \"\"\"\n",
" Computes the reservation wage using the full model solution.\n",
" \"\"\"\n",
" α, β, γ, c, w, q = model\n",
" v_u, v_e = solve_full_model(model)\n",
" h = u(c, γ) + β * (v_u @ q)\n",
" # Find the first w such that v_e(w) >= h, or +inf if none exist\n",
" accept = v_e >= h\n",
" i = jnp.argmax(accept) # returns first accept index\n",
" w_bar = jnp.where(jnp.any(accept), w[i], jnp.inf)\n",
" return w_bar\n",
"\n",
"w_bar_full = compute_reservation_wage_full(model)\n",
"print(f\"Reservation wage (full model): {w_bar_full:.4f}\")"
]
},
{
"cell_type": "markdown",
"id": "7e255714",
"metadata": {},
"source": [
"This value seems close to where the two lines meet.\n",
"\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"id": "e4c4c404",
"metadata": {},
"source": [
"## A simplifying transformation\n",
"\n",
"The approach above works, but iterating over two vector-valued functions is computationally expensive.\n",
"\n",
"With some mathematics and some brain power, we can form a solution method that\n",
"is far more efficient.\n",
"\n",
"(This process will be analogous to our [second pass](https://python.quantecon.org/mccall_model.html#mm-op2) at the plain vanilla\n",
"McCall model, where we reduced the Bellman equation to an equation in an unknown\n",
"scalar value, rather than an unknown vector.)\n",
"\n",
"First, we use the continuation value $ h $, as defined in [(43.4)](#equation-defh-mm), to write [(43.2)](#equation-bell2-mccall) as\n",
"\n",
"$$\n",
"v_u(w) = \\max \\left\\{ v_e(w), \\, h \\right\\}\n",
"$$\n",
"\n",
"Taking the expectation of both sides and then discounting, this becomes\n",
"\n",
"$$\n",
"\\beta \\sum_{w'} v_u(w') q(w')\n",
" = \\beta \\sum_{w'} \\max \\left\\{ v_e(w'), \\, h \\right\\} q(w')\n",
"$$\n",
"\n",
"Adding $ u(c) $ to both sides and using [(43.4)](#equation-defh-mm) again gives\n",
"\n",
"\n",
"\n",
"$$\n",
"h = u(c) + \\beta \\sum_{w'} \\max \\left\\{ v_e(w'), \\, h \\right\\} q(w') \\tag{43.5}\n",
"$$\n",
"\n",
"This is a nice scalar equation in the continuation value, which is already\n",
"useful.\n",
"\n",
"But we can go further, but eliminating $ v_e $ from the above equation."
]
},
{
"cell_type": "markdown",
"id": "14eb4bec",
"metadata": {},
"source": [
"### Simplifying to a single equation\n",
"\n",
"As a first step, we rearrange the expression defining $ h $ (see [(43.4)](#equation-defh-mm)) to obtain\n",
"\n",
"$$\n",
"\\sum_{w'} v_u(w') q(w') = \\frac{h - u(c)}{\\beta}\n",
"$$\n",
"\n",
"Using this, the Bellman equation for $ v_e $, as given in [(43.3)](#equation-bell1-mccall), can now be rewritten as\n",
"\n",
"\n",
"\n",
"$$\n",
"v_e(w) = u(w) + \\beta\n",
" \\left[\n",
" (1-\\alpha)v_e(w) + \\alpha \\frac{h - u(c)}{\\beta}\n",
" \\right] \\tag{43.6}\n",
"$$\n",
"\n",
"Our next step is to solve [(43.6)](#equation-bell01-mccall) for $ v_e $ as a function of $ h $.\n",
"\n",
"Rearranging [(43.6)](#equation-bell01-mccall) gives\n",
"\n",
"$$\n",
"v_e(w) = u(w) + \\beta(1-\\alpha)v_e(w) + \\alpha(h - u(c))\n",
"$$\n",
"\n",
"or\n",
"\n",
"$$\n",
"v_e(w) - \\beta(1-\\alpha)v_e(w) = u(w) + \\alpha(h - u(c))\n",
"$$\n",
"\n",
"Solving for $ v_e(w) $ gives\n",
"\n",
"\n",
"\n",
"$$\n",
"v_e(w) = \\frac{u(w) + \\alpha(h - u(c))}{1 - \\beta(1-\\alpha)} \\tag{43.7}\n",
"$$\n",
"\n",
"Substituting this into [(43.5)](#equation-bell02-mccall) yields\n",
"\n",
"\n",
"\n",
"$$\n",
"h = u(c) + \\beta \\sum_{w' \\in \\mathbb W} \\max \\left\\{ \\frac{u(w') + \\alpha(h - u(c))}{1 - \\beta(1-\\alpha)}, \\, h \\right\\} q(w') \\tag{43.8}\n",
"$$\n",
"\n",
"Finally we have a single scalar equation in $ h $!\n",
"\n",
"If we can solve this for $ h $, we can easily recover $ v_e $ using\n",
"[(43.7)](#equation-v-e-closed).\n",
"\n",
"Then we have enough information to compute the reservation wage."
]
},
{
"cell_type": "markdown",
"id": "f4601b57",
"metadata": {},
"source": [
"### Solving the Bellman equations\n",
"\n",
"To solve [(43.8)](#equation-bell-scalar), we use the iteration rule\n",
"\n",
"\n",
"\n",
"$$\n",
"h_{n+1} = u(c) + \\beta \\sum_{w' \\in \\mathbb W}\n",
" \\max \\left\\{ \\frac{u(w') + \\alpha(h_n - u(c))}{1 - \\beta(1-\\alpha)}, \\, h_n \\right\\} q(w') \\tag{43.9}\n",
"$$\n",
"\n",
"starting from some initial condition $ h_0 $.\n",
"\n",
"(It is possible to prove that [(43.9)](#equation-bell-iter) converges via the Banach contraction mapping theorem.)"
]
},
{
"cell_type": "markdown",
"id": "a249b703",
"metadata": {},
"source": [
"## Implementation\n",
"\n",
"To implement iteration on $ h $, we provide a function that provides one update,\n",
"from $ h_n $ to $ h_{n+1} $"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "90582fec",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def update_h(model, h):\n",
" \" One update of the scalar h. \"\n",
" α, β, γ, c, w, q = model\n",
" v_e = compute_v_e(model, h)\n",
" h_new = u(c, γ) + β * (jnp.maximum(v_e, h) @ q)\n",
" return h_new"
]
},
{
"cell_type": "markdown",
"id": "4d6caa60",
"metadata": {},
"source": [
"Also, we provide a function to compute $ v_e $ from [(43.7)](#equation-v-e-closed)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "53716a7e",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def compute_v_e(model, h):\n",
" \" Compute v_e from h using the closed-form expression. \"\n",
" α, β, γ, c, w, q = model\n",
" return (u(w, γ) + α * (h - u(c, γ))) / (1 - β * (1 - α))"
]
},
{
"cell_type": "markdown",
"id": "94075cbe",
"metadata": {},
"source": [
"This function will be applied once convergence is achieved.\n",
"\n",
"Now we can write our model solver."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b1890e88",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"@jax.jit\n",
"def solve_model(model, tol=1e-5, max_iter=2000):\n",
" \" Iterates to convergence on the Bellman equations. \"\n",
"\n",
" def cond(loop_state):\n",
" h, i, error = loop_state\n",
" return jnp.logical_and(error > tol, i < max_iter)\n",
"\n",
" def update(loop_state):\n",
" h, i, error = loop_state\n",
" h_new = update_h(model, h)\n",
" error_new = jnp.abs(h_new - h)\n",
" return h_new, i + 1, error_new\n",
"\n",
" # Initialize\n",
" h_init = u(model.c, model.γ) / (1 - model.β)\n",
" i_init = 0\n",
" error_init = tol + 1\n",
" init_state = (h_init, i_init, error_init)\n",
"\n",
" final_state = jax.lax.while_loop(cond, update, init_state)\n",
" h_final, _, _ = final_state\n",
"\n",
" # Compute v_e from the converged h\n",
" v_e_final = compute_v_e(model, h_final)\n",
"\n",
" return v_e_final, h_final"
]
},
{
"cell_type": "markdown",
"id": "50b08f42",
"metadata": {},
"source": [
"Finally, here’s a function `compute_reservation_wage` that uses all the logic above,\n",
"taking an instance of `Model` and returning the associated reservation wage."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "29a4f1ac",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def compute_reservation_wage(model):\n",
" \"\"\"\n",
" Computes the reservation wage of an instance of the McCall model\n",
" by finding the smallest w such that v_e(w) >= h.\n",
"\n",
" \"\"\"\n",
" # Find the first i such that v_e(w_i) >= h and return w[i]\n",
" # If no such w exists, then w_bar is set to np.inf\n",
" v_e, h = solve_model(model)\n",
" accept = v_e >= h\n",
" i = jnp.argmax(accept) # take first accept index\n",
" w_bar = jnp.where(jnp.any(accept), model.w[i], jnp.inf)\n",
" return w_bar"
]
},
{
"cell_type": "markdown",
"id": "61424cb8",
"metadata": {},
"source": [
"Let’s verify that this simplified approach gives the same answer as the full model:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b34097be",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"w_bar_simplified = compute_reservation_wage(model)\n",
"print(f\"Reservation wage (simplified): {w_bar_simplified:.4f}\")\n",
"print(f\"Reservation wage (full model): {w_bar_full:.4f}\")\n",
"print(f\"Difference: {abs(w_bar_simplified - w_bar_full):.6f}\")"
]
},
{
"cell_type": "markdown",
"id": "2277dea8",
"metadata": {},
"source": [
"As we can see, both methods produce essentially the same reservation wage.\n",
"\n",
"However, the simplified method is far more efficient.\n",
"\n",
"Next we will investigate how the reservation wage varies with parameters."
]
},
{
"cell_type": "markdown",
"id": "ee4dfa72",
"metadata": {},
"source": [
"## Impact of parameters\n",
"\n",
"In each instance below, we’ll show you a figure and then ask you to reproduce it in the exercises."
]
},
{
"cell_type": "markdown",
"id": "9d3d5a4f",
"metadata": {},
"source": [
"### The reservation wage and unemployment compensation\n",
"\n",
"First, let’s look at how $ \\bar w $ varies with unemployment compensation.\n",
"\n",
"In the figure below, we use the default parameters in the `Model` class, apart from\n",
"c (which takes the values given on the horizontal axis)\n",
"\n",
"\n",
"\n",
" \n",
"As expected, higher unemployment compensation causes the worker to hold out for higher wages.\n",
"\n",
"In effect, the cost of continuing job search is reduced."
]
},
{
"cell_type": "markdown",
"id": "66ca7ce3",
"metadata": {},
"source": [
"### The reservation wage and discounting\n",
"\n",
"Next, let’s investigate how $ \\bar w $ varies with the discount factor.\n",
"\n",
"The next figure plots the reservation wage associated with different values of\n",
"$ \\beta $\n",
"\n",
"\n",
"\n",
" \n",
"Again, the results are intuitive: More patient workers will hold out for higher wages."
]
},
{
"cell_type": "markdown",
"id": "6ecc5b50",
"metadata": {},
"source": [
"### The reservation wage and job destruction\n",
"\n",
"Finally, let’s look at how $ \\bar w $ varies with the job separation rate $ \\alpha $.\n",
"\n",
"Higher $ \\alpha $ translates to a greater chance that a worker will face termination in each period once employed.\n",
"\n",
"\n",
"\n",
" \n",
"Once more, the results are in line with our intuition.\n",
"\n",
"If the separation rate is high, then the benefit of holding out for a higher wage falls.\n",
"\n",
"Hence the reservation wage is lower."
]
},
{
"cell_type": "markdown",
"id": "631f29a4",
"metadata": {},
"source": [
"## Exercises"
]
},
{
"cell_type": "markdown",
"id": "e20c3076",
"metadata": {},
"source": [
"## Exercise 43.1\n",
"\n",
"Reproduce all the reservation wage figures shown above.\n",
"\n",
"Regarding the values on the horizontal axis, use"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "37571978",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"grid_size = 25\n",
"c_vals = jnp.linspace(2, 12, grid_size) # unemployment compensation\n",
"β_vals = jnp.linspace(0.8, 0.99, grid_size) # discount factors\n",
"α_vals = jnp.linspace(0.05, 0.5, grid_size) # separation rate"
]
},
{
"cell_type": "markdown",
"id": "2b51e062",
"metadata": {},
"source": [
"## Solution\n",
"\n",
"Here’s the first figure."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a943af52",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def compute_res_wage_given_c(c):\n",
" model = Model(c=c)\n",
" w_bar = compute_reservation_wage(model)\n",
" return w_bar\n",
"\n",
"w_bar_vals = jax.vmap(compute_res_wage_given_c)(c_vals)\n",
"\n",
"fig, ax = plt.subplots()\n",
"ax.set(xlabel='unemployment compensation', ylabel='reservation wage')\n",
"ax.plot(c_vals, w_bar_vals, lw=2, label=r'$\\bar w$ as a function of $c$')\n",
"ax.legend()\n",
"glue(\"mccall_resw_c\", fig, display=False)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "62221374",
"metadata": {},
"source": [
"Here’s the second one."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9f74e6b0",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def compute_res_wage_given_beta(β):\n",
" model = Model(β=β)\n",
" w_bar = compute_reservation_wage(model)\n",
" return w_bar\n",
"\n",
"w_bar_vals = jax.vmap(compute_res_wage_given_beta)(β_vals)\n",
"\n",
"fig, ax = plt.subplots()\n",
"ax.set(xlabel='discount factor', ylabel='reservation wage')\n",
"ax.plot(β_vals, w_bar_vals, lw=2, label=r'$\\bar w$ as a function of $\\beta$')\n",
"ax.legend()\n",
"glue(\"mccall_resw_beta\", fig, display=False)\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "908f18aa",
"metadata": {},
"source": [
"Here’s the third."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b3b06e36",
"metadata": {
"hide-output": false
},
"outputs": [],
"source": [
"def compute_res_wage_given_alpha(α):\n",
" model = Model(α=α)\n",
" w_bar = compute_reservation_wage(model)\n",
" return w_bar\n",
"\n",
"w_bar_vals = jax.vmap(compute_res_wage_given_alpha)(α_vals)\n",
"\n",
"fig, ax = plt.subplots()\n",
"ax.set(xlabel='separation rate', ylabel='reservation wage')\n",
"ax.plot(α_vals, w_bar_vals, lw=2, label=r'$\\bar w$ as a function of $\\alpha$')\n",
"ax.legend()\n",
"glue(\"mccall_resw_alpha\", fig, display=False)\n",
"plt.show()"
]
}
],
"metadata": {
"date": 1770028421.1708686,
"filename": "mccall_model_with_separation.md",
"kernelspec": {
"display_name": "Python",
"language": "python3",
"name": "python3"
},
"title": "Job Search II: Search and Separation"
},
"nbformat": 4,
"nbformat_minor": 5
}![\"QuantEcon\"](\"https://assets.quantecon.org/img/qe-menubar-logo.svg\"){kind=logo}
\n",
" \n",
"