{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "
\n", " \n", " \"QuantEcon\"\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Job Search III: Search with Learning" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Contents\n", "\n", "- [Job Search III: Search with Learning](#Job-Search-III:-Search-with-Learning) \n", " - [Overview](#Overview) \n", " - [Model](#Model) \n", " - [Take 1: Solution by VFI](#Take-1:-Solution-by-VFI) \n", " - [Take 2: A More Efficient Method](#Take-2:-A-More-Efficient-Method) \n", " - [Exercises](#Exercises) \n", " - [Solutions](#Solutions) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Overview\n", "\n", "In this lecture we consider an extension of the [previously studied](mccall_model.html) job search model of McCall [[McC70]](../zreferences.html#mccall1970).\n", "\n", "In the McCall model, an unemployed worker decides when to accept a permanent position at a specified wage, given\n", "\n", "- his or her discount rate \n", "- the level of unemployment compensation \n", "- the distribution from which wage offers are drawn \n", "\n", "\n", "In the version considered below, the wage distribution is unknown and must be learned.\n", "\n", "- The following is based on the presentation in [[LS18]](../zreferences.html#ljungqvist2012), section 6.6. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Model features\n", "\n", "- Infinite horizon dynamic programming with two states and one binary control. \n", "- Bayesian updating to learn the unknown distribution. " ] }, { "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": "markdown", "metadata": {}, "source": [ "## Model\n", "\n", "\n", "\n", "Let’s first review the basic McCall model [[McC70]](../zreferences.html#mccall1970) and then add the variation we want to consider." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### The Basic McCall Model\n", "\n", "\n", "\n", "Recall that, [in the baseline model](mccall_model.html), an unemployed worker is presented in each period with a\n", "permanent job offer at wage $ W_t $.\n", "\n", "At time $ t $, our worker either\n", "\n", "1. accepts the offer and works permanently at constant wage $ W_t $ \n", "1. rejects the offer, receives unemployment compensation $ c $ and reconsiders next period \n", "\n", "\n", "The wage sequence $ \\{W_t\\} $ is iid and generated from known density $ h $.\n", "\n", "The worker aims to maximize the expected discounted sum of earnings $ \\mathbb{E} \\sum_{t=0}^{\\infty} \\beta^t y_t $\n", "The function $ V $ satisfies the recursion\n", "\n", "\n", "\n", "$$\n", "V(w)\n", "= \\max \\left\\{\n", "\\frac{w}{1 - \\beta}, \\, c + \\beta \\int V(w')h(w') dw'\n", "\\right\\} \\tag{1}\n", "$$\n", "\n", "The optimal policy has the form $ \\mathbf{1}\\{w \\geq \\bar w\\} $, where\n", "$ \\bar w $ is a constant depending called the *reservation wage*." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Offer Distribution Unknown\n", "\n", "Now let’s extend the model by considering the variation presented in [[LS18]](../zreferences.html#ljungqvist2012), section 6.6.\n", "\n", "The model is as above, apart from the fact that\n", "\n", "- the density $ h $ is unknown \n", "- the worker learns about $ h $ by starting with a prior and updating based on wage offers that he/she observes \n", "\n", "\n", "The worker knows there are two possible distributions $ F $ and $ G $ — with densities $ f $ and $ g $.\n", "\n", "At the start of time, “nature” selects $ h $ to be either $ f $ or\n", "$ g $ — the wage distribution from which the entire sequence $ \\{W_t\\} $ will be drawn.\n", "\n", "This choice is not observed by the worker, who puts prior probability $ \\pi_0 $ on $ f $ being chosen.\n", "\n", "Update rule: worker’s time $ t $ estimate of the distribution is $ \\pi_t f + (1 - \\pi_t) g $, where $ \\pi_t $ updates via\n", "\n", "\n", "\n", "$$\n", "\\pi_{t+1}\n", "= \\frac{\\pi_t f(w_{t+1})}{\\pi_t f(w_{t+1}) + (1 - \\pi_t) g(w_{t+1})} \\tag{2}\n", "$$\n", "\n", "This last expression follows from Bayes’ rule, which tells us that\n", "\n", "$$\n", "\\mathbb{P}\\{h = f \\,|\\, W = w\\}\n", "= \\frac{\\mathbb{P}\\{W = w \\,|\\, h = f\\}\\mathbb{P}\\{h = f\\}}\n", "{\\mathbb{P}\\{W = w\\}}\n", "\\quad \\text{and} \\quad\n", "\\mathbb{P}\\{W = w\\} = \\sum_{\\psi \\in \\{f, g\\}} \\mathbb{P}\\{W = w \\,|\\, h = \\psi\\} \\mathbb{P}\\{h = \\psi\\}\n", "$$\n", "\n", "The fact that [(2)](#equation-odu-pi-rec) is recursive allows us to progress to a recursive solution method.\n", "\n", "Letting\n", "\n", "$$\n", "h_{\\pi}(w) := \\pi f(w) + (1 - \\pi) g(w)\n", "\\quad \\text{and} \\quad\n", "q(w, \\pi) := \\frac{\\pi f(w)}{\\pi f(w) + (1 - \\pi) g(w)}\n", "$$\n", "\n", "we can express the value function for the unemployed worker recursively as\n", "follows\n", "\n", "\n", "\n", "$$\n", "V(w, \\pi)\n", "= \\max \\left\\{\n", "\\frac{w}{1 - \\beta}, \\, c + \\beta \\int V(w', \\pi') \\, h_{\\pi}(w') \\, dw'\n", "\\right\\}\n", "\\quad \\text{where} \\quad\n", "\\pi' = q(w', \\pi) \\tag{3}\n", "$$\n", "\n", "Notice that the current guess $ \\pi $ is a state variable, since it affects the worker’s perception of probabilities for future rewards." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Parameterization\n", "\n", "Following section 6.6 of [[LS18]](../zreferences.html#ljungqvist2012), our baseline parameterization will be\n", "\n", "- $ f $ is $ \\operatorname{Beta}(1, 1) $ scaled (i.e., draws are multiplied by) some factor $ w_m $ \n", "- $ g $ is $ \\operatorname{Beta}(3, 1.2) $ scaled (i.e., draws are multiplied by) the same factor $ w_m $ \n", "- $ \\beta = 0.95 $ and $ c = 0.6 $ \n", "\n", "\n", "With $ w_m = 2 $, the densities $ f $ and $ g $ have the following shape" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "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" }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "using LinearAlgebra, Statistics\n", "using Distributions, Plots, QuantEcon, Interpolations, Parameters\n", "\n", "gr(fmt=:png);\n", "\n", "w_max = 2\n", "x = range(0, w_max, length = 200)\n", "\n", "G = Beta(3, 1.6)\n", "F = Beta(1, 1)\n", "plot(x, pdf.(G, x/w_max)/w_max, label=\"g\")\n", "plot!(x, pdf.(F, x/w_max)/w_max, label=\"f\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Looking Forward\n", "\n", "What kind of optimal policy might result from [(3)](#equation-odu-mvf) and the parameterization specified above?\n", "\n", "Intuitively, if we accept at $ w_a $ and $ w_a \\leq w_b $, then — all other things being given — we should also accept at $ w_b $.\n", "\n", "This suggests a policy of accepting whenever $ w $ exceeds some threshold value $ \\bar w $.\n", "\n", "But $ \\bar w $ should depend on $ \\pi $ — in fact it should be decreasing in $ \\pi $ because\n", "\n", "- $ f $ is a less attractive offer distribution than $ g $ \n", "- larger $ \\pi $ means more weight on $ f $ and less on $ g $ \n", "\n", "\n", "Thus larger $ \\pi $ depresses the worker’s assessment of her future prospects, and relatively low current offers become more attractive.\n", "\n", "**Summary:** We conjecture that the optimal policy is of the form\n", "$ \\mathbb 1\\{w \\geq \\bar w(\\pi) \\} $ for some decreasing function\n", "$ \\bar w $." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Take 1: Solution by VFI\n", "\n", "Let’s set about solving the model and see how our results match with our intuition.\n", "\n", "We begin by solving via value function iteration (VFI), which is natural but ultimately turns out to be second best.\n", "\n", "The code is as follows.\n", "\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "hide-output": false }, "outputs": [ { "data": { "text/plain": [ "res_wage_operator (generic function with 1 method)" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# use key word argment\n", "function SearchProblem(;β = 0.95, c = 0.6, F_a = 1, F_b = 1,\n", " G_a = 3, G_b = 1.2, w_max = 2.0,\n", " w_grid_size = 40, π_grid_size = 40)\n", "\n", " F = Beta(F_a, F_b)\n", " G = Beta(G_a, G_b)\n", "\n", " # scaled pdfs\n", " f(x) = pdf.(F, x/w_max)/w_max\n", " g(x) = pdf.(G, x/w_max)/w_max\n", "\n", " π_min = 1e-3 # avoids instability\n", " π_max = 1 - π_min\n", "\n", " w_grid = range(0, w_max, length = w_grid_size)\n", " π_grid = range(π_min, π_max, length = π_grid_size)\n", "\n", " nodes, weights = qnwlege(21, 0.0, w_max)\n", "\n", " return (β = β, c = c, F = F, G = G, f = f,\n", " g = g, n_w = w_grid_size, w_max = w_max,\n", " w_grid = w_grid, n_π = π_grid_size, π_min = π_min,\n", " π_max = π_max, π_grid = π_grid, quad_nodes = nodes,\n", " quad_weights = weights)\n", "end\n", "\n", "function q(sp, w, π_val)\n", " new_π = 1.0 / (1 + ((1 - π_val) * sp.g(w)) / (π_val * sp.f(w)))\n", "\n", " # Return new_π when in [π_min, π_max] and else end points\n", " return clamp(new_π, sp.π_min, sp.π_max)\n", "end\n", "\n", "function T!(sp, v, out;\n", " ret_policy = false)\n", " # simplify names\n", " @unpack f, g, β, c = sp\n", " nodes, weights = sp.quad_nodes, sp.quad_weights\n", "\n", " vf = extrapolate(interpolate((sp.w_grid, sp.π_grid), v,\n", " Gridded(Linear())), Flat())\n", "\n", " # set up quadrature nodes/weights\n", " # q_nodes, q_weights = qnwlege(21, 0.0, sp.w_max)\n", "\n", " for (w_i, w) in enumerate(sp.w_grid)\n", " # calculate v1\n", " v1 = w / (1 - β)\n", "\n", " for (π_j, _π) in enumerate(sp.π_grid)\n", " # calculate v2\n", " integrand(m) = [vf(m[i], q.(Ref(sp), m[i], _π)) *\n", " (_π * f(m[i]) + (1 - _π) * g(m[i])) for i in 1:length(m)]\n", " integral = do_quad(integrand, nodes, weights)\n", " # integral = do_quad(integrand, q_nodes, q_weights)\n", " v2 = c + β * integral\n", "\n", " # return policy if asked for, otherwise return max of values\n", " out[w_i, π_j] = ret_policy ? v1 > v2 : max(v1, v2)\n", " end\n", " end\n", " return out\n", "end\n", "\n", "function T(sp, v;\n", " ret_policy = false)\n", " out_type = ret_policy ? Bool : Float64\n", " out = zeros(out_type, sp.n_w, sp.n_π)\n", " T!(sp, v, out, ret_policy=ret_policy)\n", "end\n", "\n", "\n", "get_greedy!(sp, v, out) = T!(sp, v, out, ret_policy = true)\n", "\n", "get_greedy(sp, v) = T(sp, v, ret_policy = true)\n", "\n", "function res_wage_operator!(sp, ϕ, out)\n", " # simplify name\n", " @unpack f, g, β, c = sp\n", "\n", " # Construct interpolator over π_grid, given ϕ\n", " ϕ_f = LinearInterpolation(sp.π_grid, ϕ, extrapolation_bc = Line())\n", "\n", " # set up quadrature nodes/weights\n", " q_nodes, q_weights = qnwlege(7, 0.0, sp.w_max)\n", "\n", " for (i, _π) in enumerate(sp.π_grid)\n", " integrand(x) = max.(x, ϕ_f.(q.(Ref(sp), x, _π))) .* (_π * f(x) + (1 - _π) * g(x))\n", " integral = do_quad(integrand, q_nodes, q_weights)\n", " out[i] = (1 - β) * c + β * integral\n", " end\n", "end\n", "\n", "function res_wage_operator(sp, ϕ)\n", " out = similar(ϕ)\n", " res_wage_operator!(sp, ϕ, out)\n", " return out\n", "end" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The type `SearchProblem` is used to store parameters and methods needed to compute optimal actions.\n", "\n", "The Bellman operator is implemented as the method `T()`, while `get_greedy()`\n", "computes an approximate optimal policy from a guess `v` of the value function.\n", "\n", "We will omit a detailed discussion of the code because there is a more efficient solution method.\n", "\n", "These ideas are implemented in the `.res_wage_operator()` method.\n", "\n", "Before explaining it let’s look at solutions computed from value function iteration.\n", "\n", "Here’s the value function:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "hide-output": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Compute iterate 10 with error 0.19801710153283736\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Compute iterate 20 with error 0.007608221868107279\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Compute iterate 30 with error 0.0002901698734376623\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Converged in 34 steps\n" ] }, { "data": { "image/png": "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" }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Set up the problem and initial guess, solve by VFI\n", "sp = SearchProblem(;w_grid_size=100, π_grid_size=100)\n", "v_init = fill(sp.c / (1 - sp.β), sp.n_w, sp.n_π)\n", "f(x) = T(sp, x)\n", "v = compute_fixed_point(f, v_init)\n", "policy = get_greedy(sp, v)\n", "\n", "# Make functions for the linear interpolants of these\n", "vf = extrapolate(interpolate((sp.w_grid, sp.π_grid), v, Gridded(Linear())),\n", " Flat())\n", "pf = extrapolate(interpolate((sp.w_grid, sp.π_grid), policy,\n", " Gridded(Linear())), Flat())\n", "\n", "function plot_value_function(;w_plot_grid_size = 100,\n", " π_plot_grid_size = 100)\n", " π_plot_grid = range(0.001, 0.99, length = π_plot_grid_size)\n", " w_plot_grid = range(0, sp.w_max, length = w_plot_grid_size)\n", " Z = [vf(w_plot_grid[j], π_plot_grid[i])\n", " for j in 1:w_plot_grid_size, i in 1:π_plot_grid_size]\n", " p = contour(π_plot_grid, w_plot_grid, Z, levels=15, alpha=0.6,\n", " fill=true, size=(400, 400), c=:lightrainbow)\n", " plot!(xlabel=\"pi\", ylabel=\"w\", xguidefont=font(12))\n", " return p\n", "end\n", "\n", "plot_value_function()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "\n", "The optimal policy:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "hide-output": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAGQCAIAAADZeHv+AAAABmJLR0QA/wD/AP+gvaeTAAAgAElEQVR4nO3deXxTVdoH8OfeLE3Tfd8oLS0tBSpLoUApKtCCZV8L6IsbbjPDCIMyg4I4DB/c0BcUx2XUAcVREHwtg6KALUWUVYrsS6V0T/e9TZrtnvePQCayMylJDv19/8q95+bmSaG/nnPuyY3AGCMAAJcnOrsAAICbgrQCAD4grQCAD0grAOAD0goA+IC0AgA+yB38eoyx7OzsnTt3VldX9+jR43e/+52/v7+11WQyvf/++wcPHoyNjf3Tn/7k6+vr4PIAwGU5um/V1tY2f/58f3//UaNG/fzzzykpKVqt1tq6cOHC9evXT5w48ezZs+PGjXNwbQDgygQHrw61vJwgCERkMplCQ0M3bdo0cuRIImpsbIyIiDhy5EiPHj1MJlN4eHhWVlZqaqojywMAl+XovpUgCJaoIiKtVtva2hoUFGTZPH78uI+PT48ePYhILpenpqYeOHDAweUBgMty9LyVrblz544bN+6uu+6ybFZWVgYEBFhbg4KCKioqrJuL5z330/c/WB53i46Oj493ZKkdhRGxO+LShqVDLji5ig4g3RH/HMT/G3ng9490S+h2/WOcllaLFy8+ffr0rl27rHtUKpXRaLRu6vV6tVpt3dzw4bru+nZPkhFR87lzh3fscGS1AHD7nGPteoN++XuvXv8w56TV8uXLv/nmm127dvn4+Fh3dunSRaPRmEwmuVxORCUlJUOHDv3PcwQhU/SPIKXjqwWA2+oLqe5mDnNC53HVqlWfffbZjh07AgMDLXuKi4u//fbbfv36BQUFbdmyhYguXLhw6NChCRMmOL48AHBNju5bVVZWPvvss0FBQcOGDbPseeONN1paWlasWJGfn7969eo5c+Z8/PHHeXl5zz//fHh4uIPLAwCX5ei0CgwMLCgosN0THBxMRJZFDBMnTjx9+vTx48ejo6O7d+/u4NoAwJU5Oq3kcnlMTMyV+z09PS0PgoOD09PTHVsUAHCA64ueANCJIK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQC4MlM8/n7zQU3Pu5OhLQCAD4grQCugtl9jD2tN39Mp+Lo7xMEcFnVZNwpNeWRtoIZW8msIrGX4D5D8E8U3K3HtJO0hTX+yFrKmYER+ZGsj6CeLvp3JSURGYltY425rLmYGczE/EjeW3CfKvjFCSoikoh2sKadrKmQ6U3EQkhxr+A1Q/RXXeo0/FUq9yTxaTFkvVS3hzU3ktmf5KME75ligJKEs6z9X6y2nZhA7AWpzPKUaHJ7XAxy+I/KOZBWABcdYdovWH28oBokeLiTWEaGX1jbUda2RAwfLHgSUROZl0hlRUwfQPJ7BS8ViRoy/MRa4pmqq6BsJ+lFqfw00/mQ7G7By4PESjL+zNoiSBknqMzEXpEqDrBWP5KnCJ5qEk8z3SZWf1zSvixGKkkgomNM602yZVJ5GTOkCJ4yEg6w1i9YfYGk/6sYISfyJJlARESeJLPU7N6ZhkdIK4CLEgX3j2TdQkhh3XOcaV+Uyj+SagbJPAWit6WqIqYfLnjNF0MVZMkNaiFzK0lE9JFUc5rpBggez4th1u6SlqQ6MhHR/7GGA6w1WfD4sximJpGIzMTelqqyWfNXrH6WEGA5vp5MKia+K4v2JhkRPUKBz0tlh1nb96xptODznBA203xeJOE5McyBPxhX0YmCGeD6upDSNqqIqI+gHix4VpCxlAzlZDjIWv1JPs8mqojIi2RhpGgmczZrVpG4UAxV2fxaqUmMJKWZWJbU4EbCAjFUfalVRsKTYrCKxO+lZtsXvV/0977UdVKR+JAQSETfsabb9K45gr4VwH+YiJ1gulIy1DFjG0lEpCEDEVUzYx2ZGFGSoFbaRJXVGaYzEesnqL0uBY2tC0zfQuaegrtI1Epmy05G1EZSqKAoYvpWMlsHdymCp+1z+wtqFYkXmN5A7Kov3XkgrQAuKiXDCrOmnAxEpCLRk0Q5CS1kJiL9pQFdqKC86nPrLa2/7ZpZWZ57hulmXWOpVCtJlrTyJJnqihFPEMlLydBM5sDO/Qvbqd88gK1XpQoNGWaLARmCr++lns4HUs1W1kBEIglEZGbsqv2bi63XXXXQU3CfJPhetcn6cqarncGyE7M2SCsAIiINGYqZvpfgbp3wtqgkg+VBCMnp0sDwSsGkICINGa/TqiVpmOB1/TLaSWohs+1w0kysjkxKEryvNsbsVJDXAEREBsaIyPO3vxG1ZDrKtJbHfQW1nITDrK350sSTrZ6CSk3iKaarulpgdRPcAklewvSFTH/DSnJZi+3mPtZqINZTcJeTQETeJNOR1DkXjiKtAIiIwgWlnITjTHfhUqC0kHm1VGm8NDTzJ3mG4NNG0kuSxjIPZVHA9L+ydhWJU0V/E7EVkqbCJrDKyHCK6QSi2WIgI3pJ0vzK2q2tjCiPtVlGmhYC0SaprvhSDVVk/ESqJaJJgp9lT4igMBH7gTVfdcx4Z8NIEICISEnCVMFvE6t/RiqJF1RuJJxh7X4kGy347Li0emCOGFQtGQ+xtsfMhbGCm4KEGmaqIuPvxOA4Us0Q/DWCYRdrfspcGCOo1CTWMGMlGWcKAb0F93TBu1owbmB1z0glQaQIERStZK5mxjaSkgWPiZfCKIDkfQT1fKkkQVDJSDjDdAZi4wXfQYKH5YDxgu9xpn1DqnyDKokoUXB/VYx0yk/M8ZBWABc9KAaGM+VPrKWSGT0FcZLgO1X0P860AlEoKYlIScJSMWIva9nDWsrIoCPqIijHCb6W2SiR6Bkx9B7mtYs1l5ChkZlCBEWa4JMmeFvO/4AYMIR57mRN+dRey4y+gnyA4NFfUA/67ZKFBWJoAlP9yFprmamn4D5K8B5+6QxENETw/Lss+ijT1jKjlqTwa1yjvCMhrQAuEojSBe90m2ggohTB03YBlEA0TPC6zmT5QMFj4KV+0JViBLffCcE3LGOs4Dv2GlcPiagrKbsKnXHpFeatAIAPSCsA4ANGggCuIoQUPkJnX1R1HUgrAFfxD1m0s0twaRgJAgAfkFYAwAekFQDwAWkFAHxAWgEAH5BWAMAHpBUA8AFpBQB84Gl1aB7TFtKNb2ZmFUiKBEF1++oBAEfiJq3qFcosdYBc5n7jQy9pajj5pOSZTje4tywAcIGbtGKiokufP7t7RNz8U3StpR/te1pvYuN+ew8QAOARN/NWKvcAucLzxsfZcPeMjB/23qcKw9esuZXM1/8+EgBwcdz0rf47KnVYfOo7n+9f8ImhXG/WM1cNrB5y36UswLfTf6kJwHXc4WlFRCp12F1pG51dxXUxqfzsP/9YlLWMBXbHZQGAa+BmJHgnE8SInk+E9n9uiVB71uYLUQDA1p3ft+KFf+g94kD3xYeXyokCRfdQUni69t+SLhKbQt6KTnh7cHASpJUL8Q1KHjhmu1Hf0K6rbNRW1JnanF3R9Zyq3L+9/sQzkm+icAvLSgD+a0grl6Nw81O4+Xn59nR2ITcQ0nVCfdW+FcdWTjTrM8kHnSy43ZBW8N/zDxnqde/a7w8v/b+mX3vLvFPNshBSOLuo6/EmWYzg5uwq4L+EtAK7KNz841LfMRlbGmt+/j/NbpO+ztkVXY9OWxlobpohuQ8VPGXoDPIGaQUdQK7wCgwfGRg+0tmF3AiT6qv2r/310w9aS+Yy3yHCra03Budy6atOAB1MEP1DU+Pufj88ecXf3cX5Ys0ppnN2TXCz0LeCzsgnMMln+PpaTfaK0++bjNXOLud6FIIsRlT3NQs9SdVbcO/Mw1ekFXRWghgYMTogPM1s0jq7lOsxm7StjWdy6o5vqdrX36h7hvl32gER0go6NUGQyRUufU8hucLLzT0kIGy41PPJ0wefe7a56Dnm5+LXXm8TpBUAH0SZqvvQ1ZUFm57O/3iE4OXKcSUQeUiSL8l8SXaXoPbooPlxpBUAR4TQ2JnewYNPVu9zdiU3wIxaSVetbyv1bNW8yoI6JLCQVgCcUXtFq72inV3FTWKlJ978S3nuChboZ3faIK0A4PYRIu9aoHHzm3dh87OS37U+qF9H5uibOBfSCgBur/D4R9w8o9658KXe2HLVA3RGGhwQdMPzIK0A4LYLCB8RED7iWq3lBZ+LnuobnqTTLt0AAFfh4d09Jib+hoc5oW/V1NR08ODBkydPRkZGZmZm2jZ9++23J06csDxWKpULFixwfHkA4JqckFZr1qzZunUrEQUHB1+WVps3by4pKUlOTiYipVLp+NoAwGU5Ia2WLl26dOnS1atXZ2dnX9k6fvx4dKkA4EouN8u+e/fu2tra2NjY+++/390dt9AFgItca5Y9ISEhMTHRw8Nj3bp1SUlJLS3/ud4pSZITCwOA24pJN/6uT9fqWy1atMj6YODAgR9//PHTTz9t2SMInflWGQB3OEG88S+4a/WtrGQyWd++fUtLS617kFYAnZxLpJVOp9uyZYter29qarLsqa2tzcnJ6devn3MLAwDX4YSR4I4dO5YsWVJVVdXS0jJw4MCJEyc+8sgjU6ZM0Wg0PXr0GDBggKen5969e8eOHTtr1izHlwcArskJaZWamrpp0ybrppeXl5+f35kzZ4KDgwsLC48fP67Vat96662YmBjH1wYALssJaeXp6enpefl3jSQkJBBRQEDAiBHX/DARAHRmLjFvBQBwQ0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAP8g45y/nz58+cOcMYmzhxIhE1Nja6u7u7ubl1yMkBAMj+vlVtbe3o0aPj4uImTpy4cuVKy85JkyY988wzdtcGAPAf9qbV//zP/5w9e3bTpk2vv/66deeDDz64bds2O88MAGDLrrQqLS3duXPn+vXrMzMzg4ODrft79epVUlJiMBjsLg8A4CK70qq8vJyIkpOTL9uvUqkYY62trfacHADAll1pFRISQkT5+fmX7T948KCPj4+vr689JwcAsGVXWnXr1i0pKWn+/Pm1tbWCIFh2Hj58ePny5dOmTRNFLI8AgA5j7wqGdevWpaWlRUdHh4WFNTY2Dhgw4NixYzExMa+++mqH1AcAYGFv96dPnz7Hjx//4x//GBgY6O3trVKpli5d+vPPPwcFBXVIfQAAFnb1rRhjR44cIaLMzMzMzEzr/vPnz/v7+0dGRsrlHbP6FADArjQxGo0DBw68VqtCoXjggQfWrFnj7e1tz6sAAJCdaSWXy9esWfPCCy/MmjUrLS3Nx8enpKRk7dq1zc3Ny5cvP3To0Ntvv63Vajdt2tRR5YKzNNUdNRka/YJTRBk+UAXOYe9I7Z133lm1atVjjz1m3TNnzpz09PSzZ8++9tprCQkJjz32WG1tbWBgoJ0vBM5Vmr+uue7YwPQvlXanlWTWG/R1MrlaocQaF7gFds2ynz59+ty5czNnzrTdKZPJpk+fvmXLFiKaNm0aY+z8+fN21Qh3lpbG00d2PVBy9kNnFwKcsatvZflsTVlZWUJCgu3+0tJSvV5PRCqVShRFpVJpz6uAK0hMecvZJUBnZ1ffKjExMTQ0dM6cOQUFBZY9jLGsrKw1a9aMHj2aiE6fPs0Y69q1q+2zqqqqtm3b9sYbbxw8ePCyE0qS9Mknn/zhD3/43//937a2Nntqg+tjTNLrqrQthYxJtrstO02G5ps5icnYqm0patdq6Dcn+Q1De622pdCorydidlcNnZpdfSulUvmvf/1r6tSpPXr0iI6O9vb2Lisrq6mpSUlJefHFF4koPz9/7ty5l01aPfzwwy0tLSUlJWazefDgwbZNixcv/u677+bNm7dly5Zvv/02JyfHnvLgMuUFn5ef3xBz1wKzSVua/7GhvZaIBqR94eYewpi5vGBjZeFXBn0dEZEg+vj36ZY4T+0VY3numZ+fb6k/2W/4x0q3ACJqaTxTcuYfTfXHLTmlcPOLiH0gPGY60cWPNBCTKoq+0hR+qddWWnYo3PxCuk4wG1uqy3YQUU3ZzrqKPZamrgmPh0ZNcuBPArhk7yx7WlramTNnPv3009OnT9fV1Q0dOjQ1NTUzM9Oy0mrGjBkzZsy47Cnbt28nosmTJ1+2v6Wl5d133923b19iYuLs2bPDw8MPHTo0aNAgOysEK8lsMBlbqkq2Ndcd8wsZovaKMerrBFFOTDqXt6y+8keVR0SXyNkKN7/WpnM15dkn9j7dZ9i77p5RRGQ2aU3GFmKMiBprDp39eQljUnDEaA+f7kZDU03590Wn3zHq66N6PkVERCz/6Eu15TkKN7/wmJkqjwijvq6l4XRD1d4ucQ8Zjc215Tkqz65+QRf/VlkzEeA6OmD1ZnBwcEZGRkJCgvUWMVlZWR4eHmPHjr2l8xw9elStVicmJhKRm5vbsGHDfvrpJ6RVh2uqPdJr8ErfoP/cOaOyeGt95Y++QckJyS+J4sVJRv+QoefylhWeervX4Ddsn242aX/95SUiShz6tpdfL8vOiNhZx3/6fXnBxqAu96m9oqtLd9SW57h7RiUOfcv2wp/R0KhQ+sqV3rXlOV6+CVE9n7zt7xbuIPam1bFjx6ZMmVJYWHjZ/piYmFtNq8rKStvP6wQHB1dUVFg3JemaMyNwS/yCB9tGFRFVFn1FRDF3PWONKiIKCBvu6dOjsSbPaGhSKH2s+2s1OUZDU1i3adaoIiKZ3KNL3IO//vJSrWZX1x5zKou3EFFM4vzL1ihgyQJcC5NuPK1pb1rNmjXLx8fnp59+Wrhw4YQJE9LT0zdu3Pj555+vXbv2Vk+lVCpNJpN102g02t7Z3XqPB7CTl19v202TsVnbUixXeOu1Gr1WY9skV3oTMV1rscK/j3Vnc/0JIpLJ1U21ebYHSyYdEelaiyTJ0NaULwgy74A+BHBzbub32660qqysPHv27KFDh5KTk93d3QMCAgYNGjRo0CC1Wr18+fJbnSOPiIioqKgwm80ymYyIysrKbIeBSKuOolT95qKHUd9AxEzG5lMHnr3q8WaT9rfH1xNR2a+flv366VUPNhmaGZPc3EMEAZ8ShZt2E7/gdv1/Ki0tJSLLTJO7u3tz88XL3tOmTXvllVfa29tVKtXNnEej0Zw/fz41NdXHx+e7774bP358WVnZ/v37/4sOGtyQIIi/3ZQTkUodHj9g2VWPd/eIuPL4mMQ/edqMBK3kcrUoUxKR2YQFKNDB7Eory9KE+vr6iIiILl26nDhxwrK/vr6eMWY7rLP18ssvf/XVVwUFBYcPH968efPf/va3urq6FStW5Ofnr1y58tFHHx01atS+ffuefvrpyxZqwe2gdA8SRaVeV632jLqZzwCqPLoQkWTWe/rEX+MQplD6Gg2NRn2Dws3vymaBRCJiDMuv4NbYlVZRUVEhISH79u3LzMycNGnSlClTevToERkZ+fLLL/fp08fT0/Oqz5o9e/Z9991n3YyOjhZF0TLomzlz5pAhQ/Ly8hYtWtS3b197aoObJIpKv+AhdZV7qkq+Ces27YbHB4TdXVH4ZVXpt6HdptjOytsQ/ENTq0q2VRR91bXHY1c2K9x8ichkvKkFqABWdqWVKIorV660/JEcM2bMI488smzZMpPJ1K1bt88+++xaz+rateuVnSY/v4t/hKOioqKiouypCm5V14THGmt/LjrzPmOm4MixcoUXERkNjQ1VBxprD8f3f8H2YG//vgGh99RV7jlz6LluveaqvbqRIEqSsa3p1+rS7wLDR/gEJkV0n12r2V1+/jNRpgqLniqTuxOxtqbzjbWHI2Lvd3MPEUVlU+0v9VV73T27CoJMofSRyT2c9O6BG/bOgz700EOWB4Ig/OMf/3jrrbdqamq6dOmCSXGOuHtG9Rz0an7e8qLT7xWdfk/h5ieZ280mHRGpvbpdeXz3/ouFY7JaTe7RPY+JolKu9Da01xExIiEg7F4iUqnDeg569VzeiyVnPyw9t06p8jfqGyTJqPaKiYi9X5SpusQ/VHL2n2d/XmI5YXSvueExmVe+EIAte+/GN2nSpLS0tLS0tD59+oiiqFKpIiMjO6o46Fh+IUOVqoDLVjBYePv3TRr5Wa1md0vDCaOhUSb3dFMFeQf09Qnod/EIyzSTIBCRTKaKT/prWMyMhsq9urYyYpLSPcjdM8o/ZKj1gqO3/11JIz6rKc9ubThtMrUqlD5qrxhLlhFRl+6zA8PTrJ8fvGpJAJexK60EQdDpdEuWLFm4cGFgYOCIESMsydW9e/eOqg86kKdP/LWnxkmUqYIjM4IjM67aajK2CoJou0zUy7enl2/P67ycTK4OjZpIUROv2qpSh6nUYTdXOACRnfdgkMvlubm59fX1O3bsmDNnzoULF/7whz/ExcVFR0cvXLiwo0oEp9O1luhai93cQ7GECpyoA77yT61Wjx49+rXXXjt06NDOnTtTUlKKi4uzsrLsPzM4ncnYmpcz8+gPcxgzh8VMd3Y50Kl1wJ/KgoKCnJyc7Ozs3Nzc2tra3r17z5s371Y/JAiuSRAEd8+uvkHJvkHJ1lknAKewK61MJlNcXFxRUVHXrl3T0tLefPPNtLS00NDQjioOnE4m9+g1+HVnVwFAZOdIUJKkoqIiT0/P4cOHDx8+fMSIEYgqALhN7EorpVKp0WjWrl2rUqmWLFkSERERGxv71FNPbd68uaGhoaNKBAAg++etwsLCLF/UzBg7ceLErl27NmzY8MEHH8TGxuKrbgCgA3XMBem2trY9e/ZY5tqPHz9ORCEhIR1yZgAAC7vSSpKkFStW5OTkHDhwwGAwBAUFjRw5cu7cuSNHjoyNje2oEgEAyP5rgitXrkxJSVm+fHl6enr//v1FsQMWcAEAXMmutFIoFI2NjZavtwEAuK3s6goJgoCoAgDHwMANAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+CB3yqtu3rx5//79UVFRTzzxhFqttu7fvXt3fn6+5bFCoXj00UedUh4AuCAn9K1eeumlpUuXdu/e/fvvvx83bpxt0yeffPLFF19cuHDhwoULhYWFjq8NAFyWo/tWOp1u9erV33777aBBgx5//PHIyMi9e/empqZaDxg/fvyCBQscXBUAuD5H961OnTplMpmSk5OJSKlU3nPPPXv27LE94MCBA6+99trmzZuNRqODawMAV+botKqsrAwKChIEwbIZEhKi0WisrVFRUcHBwc3Nza+88srgwYO1Wq21SZIkB5cKAA7DJHbDYxw9ElQoFCaTybppNBq9vLysm8uWLbM+6N+//yeffPL73//esscacABw57mZ329H963CwsKqq6uto7zy8vKwsLArD1MoFMnJybYT7UgrgDvZTfyCOzqtEhMTQ0NDt23bRkQ1NTV79uyZMGGCXq/PyckxGAw6nc5yWHNz8+7duxMTEx1cHgC4LEePBEVRfPXVV5944oktW7bs27fvwQcfjI+PLykpSU9P12g0d911V0pKire3d25ubnJy8gMPPODg8gDAZTlhdWhmZuaAAQMOHTr01FNPpaSkEFFoaOihQ4cCAwPz8vKOHj1qMBj+8pe/9O3b1/G1AYDLcs5a9piYmJiYGOumUqm0rGmIioqKiopySkkA4OLwOUEA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPcse/pF6vX7duXVFR0ZAhQyZPnnxZa1ZW1sGDB7t16/bII4+4ubk5vjwAcE1O6FtNmTLlyy+/DA0Nfe6551asWGHbtHz58ueffz40NHTTpk3Tpk1zfG0A4LIc3bfKy8vbv39/eXm5Wq2+55570tPTn332WXd3dyJqa2tbvXp1Tk5OUlLSk08+GRERcfTo0X79+jm4QgBwTY7uW+3evfvuu+9Wq9VElJSUJJfLj4RmHEoAAAnKSURBVB49amk6evSoUqlMSkoiIrVaPWzYsNzcXAeXBwAuy9F9q4qKiuDgYOtmSEiIRqOxNgUFBdk2VVRUWDcFUSjLXyvKlEQkkECC4KiSOxJjEhEJAvcXN+6kN8LvfydbkmQWRZGIyzdiaK9paoy54WGOTiu5XC5JknXTaDQqFIqrNplMJmsTEf3j789v3LjR8jgyMrJbt24OqRcAHGHqpGE3PMbRaRUeHv7LL79YHkuSVFVVFR4ebm2qqKiQJEkURSLSaDQDBw60PnHy5MlXXkAEgM7D0T35sWPH/vTTT9XV1USUnZ3t4eHRr1+/6urqvLy8pKQktVqdk5NDRNXV1Xv37h07dqyDywMAl+XovlX37t0ffvjhu+++e8SIEVlZWStXrpTL5du3b1+xYkV+fv6KFStmz549ZcqU3NzcRx99NCbmxkNZF7d3797du3eHh4fff//9KpXKur+6unr79u1lZWVdu3adNm2a5aqoy2pvb//8888rKipGjhyZkpJy5QENDQ3Z2dkDBw508RF6c3Pzhg0b6uvrx4wZc+Xl5l9//fXrr782GAyDBg0aOXKkUyq8STU1NRs3btRqtVOnTo2Li7Ntqqur+/LLL+vr63v37j1+/HjLSOXO4IR38u6773700UdDhgzZvXv3ww8/TEQZGRkbNmwgokcffTQ3N3fIkCH//Oc///73vzu+to718ccfT58+3Ww2f/755xkZGYwxa1NycvK2bdv0ev3atWuTkpKam5udWOf1McZGjRq1YcMGs9k8derUTz/99Mpj5s2b9/DDD1v6xS6rvb196NChO3bs0Ol0I0eO3LFjh23r5s2bBw8eXFBQ0Nra+uGHHzqryJtRW1ublJSUl5fX0NCQnJx85MgRa1NFRUXv3r0PHDigVCr/+te/Wn6/7hwMbg+z2RwbG/vvf/+bMabX6yMjI3NycqytDQ0NlgcmkykuLu7TTz91TpU3YefOnZGRkXq9njG2ZcuWuLg4SZJsD9i2bdu4ceNSU1M//PBDJ9V4U9avX9+/f3+z2cwYe//994cNG2Ztamxs9PHx2b17t/OquwWvvPLKuHHjLI9ffPHFGTNmWJvWrVs3YMAAy+NTp07JZLL29nYnlHh73Dm9RFdTWFhYVFR03333EZFSqUxLS8vOzra2+vr6Wh7IZDJRFG2vfrqa7OzsUaNGKZVKIsrIyLhw4UJRUZG1tbm5+c9//vN7773ntPpuWnZ29pgxYywjI8v8qU6nszTl5uZ26dIlOjp6/fr1O3futL027YKys7OtU7pjx461/X8VHR1dXV3d1tZGRIWFhREREZZ/uDsD0up20Wg0fn5+1o86hoWFWVeW2frwww9NJtOECRMcW90t0Gg0oaGhlsdubm5+fn62b2ThwoVz586NjIx0UnW3wPaNhIaGCoJgfSMXLlywzAEdP3588eLFEyZMYDbDdldz2Rupr6+3xu7w4cPnz58fHx8/dOjQP/7xj1u3bhX4X0pm5YRPNXcSMpnM9k+02WyWyWSXHbNjx44XXnjhu+++syzud03XeSO5ubknT558//33nVTarbF9I5bBrPWNSJJUWlr6448/RkREaLXaqKioXbt2paWlOa/Y67nsjQiCYJ1KP3bs2KpVq15++eUePXqsW7du/vz5OTk5V/7H4xTS6nYJCwtrbGzU6XSW632VlZWXdUByc3MfeuihrKwsy4eNXFZYWJj1QwU6na6pqSksLMyy+cEHHzQ3N1tGu6dOnVq1alVTU9Ozzz7rtFqvy/aNVFRUCIJg7aGEh4cHBwdHREQQkVqtTkhIKCgocNm0uuyNBAQEWLvwH3300bhx4yyT68nJyb6+vnl5eYMGDXJarR0KI8HbJTo6Oj4+/ptvviEinU73/fffZ2RkmM3mo0eP6vX6ffv2zZo1a+PGjUOHDnV2pTeQkZGxc+dOy1jj66+/TkhIiIqKqqmpOX/+/OLFi998881FixYtWrQoIiJizJgxY8aMcXa915SRkbFt2zaTyUREW7duHTFihEql0mg0xcXF6enpTU1NlgjQ6XTnzp3r3r27s+u9poyMjK1bt1oe//vf/87IyCCi4uLi8vJyLy+vqqoqS1NDQ4Ner/fy8nJaoR3O2dP8d7JNmzYFBQUtWLBgyJAhlos4DQ0NRHTmzBk/P7/4+PjMSzZv3uzsYq8nIyNjyJAhCxYsCAoK+vLLLxljK1eutL2mxhhz/WuCer0+OTk5PT193rx5fn5+P/zwA2PsmWeeyczMZIy98MILCQkJzz///KBBgyZPnnzZdU+X0tDQEBcXN3ny5Keeesrf3//kyZOMsZkzZ86fP7+wsDA4OHjatGlLlizp1avXtGnTnF1sRxKYC88m3gFOnjz5ww8/REREjB8/Xi6Xm0ym7Ozsu+++++DBg7aTQTExMa68FNZkMn3zzTfl5eXDhw/v3bs3ERUVFVVXV9sOMQ4fPhwWFmYZTLms9vb2rVu31tXVjR49OjY2lojOnTvX3t7et29fIvrxxx9PnDgRFxeXnp7u4pPTzc3NW7du1Wq148ePt3x27dixY25ubgkJCU1NTTt27Kirq+vZs+e9997r4m/kliCtAIAPmLcCAD4grQCAD0grAOAD0goA+IC0Ag40NzdbFn9AZ4a0Ag5Mnz59wIABzq4CnAxpBRzw8PDw9vZ2dhXgZFhvBQB8wKeawfmMRuMPP/wQHR0dHh6elZWVn58fHh4+ffr0gIAAywEHDx7UarUjRoxwbp3gXOhbgfPV1dUFBgY+/vjj+/btKy4uDgwMLC4uDgoK2r59u+UGFaNHjz5//vyFCxecXSk4E+atwFWsW7cuNTW1oaGhqKho3759ZrN55syZRqPR2XWBq0BagasICgpas2aN5abPKSkpixYtOn/+/Pbt251dF7gKpBW4CssNp6yblltlHTx40HkVgWtBWoGrCAkJsd203Nizvr7eSeWAy0Fagauoq6uz3aytrSWiO+rWl2AfpBW4CsvMunXzxx9/JKL+/fs7ryJwLUgrcBUFBQWvv/665XFxcfErr7wSHBw8ceJE51YFrgOrQ8FVzJgxY9WqVZ999ll4ePj+/fsNBkNWVpYrf3cZOBj6VuAqYmJifvnll6lTp/r7+z/55JNHjhyxfoPO3Llzly1b5tTqwPnQtwIXEhER8be//e3K/ZMmTXJ8MeBq0LcCAD4grQCADxgJgvP5+voWFBT4+vo6uxBwabgHAwDwASNBAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPiAtAIAPiCtAIAPSCsA4APSCgD4gLQCAD4grQCAD0grAOAD0goA+IC0AgA+IK0AgA9IKwDgA9IKAPjw/1Ko5MVho+BrAAAAAElFTkSuQmCC" }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "function plot_policy_function(;w_plot_grid_size = 100,\n", " π_plot_grid_size = 100)\n", " π_plot_grid = range(0.001, 0.99, length = π_plot_grid_size)\n", " w_plot_grid = range(0, sp.w_max, length = w_plot_grid_size)\n", " Z = [pf(w_plot_grid[j], π_plot_grid[i])\n", " for j in 1:w_plot_grid_size, i in 1:π_plot_grid_size]\n", " p = contour(π_plot_grid, w_plot_grid, Z, levels=1, alpha=0.6, fill=true,\n", " size=(400, 400), c=:coolwarm)\n", " plot!(xlabel=\"pi\", ylabel=\"wage\", xguidefont=font(12), cbar=false)\n", " annotate!(0.4, 1.0, \"reject\")\n", " annotate!(0.7, 1.8, \"accept\")\n", " return p\n", "end\n", "\n", "plot_policy_function()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The code takes several minutes to run.\n", "\n", "The results fit well with our intuition from section [looking forward](#looking-forward).\n", "\n", "- The black line in the figure above corresponds to the function $ \\bar w(\\pi) $ introduced there. \n", "- It is decreasing as expected. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Take 2: A More Efficient Method\n", "\n", "Our implementation of VFI can be optimized to some degree.\n", "\n", "But instead of pursuing that, let’s consider another method to solve for the optimal policy.\n", "\n", "We will use iteration with an operator that has the same contraction rate as the Bellman operator, but\n", "\n", "- one dimensional rather than two dimensional \n", "- no maximization step \n", "\n", "\n", "As a consequence, the algorithm is orders of magnitude faster than VFI.\n", "\n", "This section illustrates the point that when it comes to programming, a bit of\n", "mathematical analysis goes a long way." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Another Functional Equation\n", "\n", "To begin, note that when $ w = \\bar w(\\pi) $, the worker is indifferent\n", "between accepting and rejecting.\n", "\n", "Hence the two choices on the right-hand side of [(3)](#equation-odu-mvf) have equal value:\n", "\n", "\n", "\n", "$$\n", "\\frac{\\bar w(\\pi)}{1 - \\beta}\n", "= c + \\beta \\int V(w', \\pi') \\, h_{\\pi}(w') \\, dw' \\tag{4}\n", "$$\n", "\n", "Together, [(3)](#equation-odu-mvf) and [(4)](#equation-odu-mvf2) give\n", "\n", "\n", "\n", "$$\n", "V(w, \\pi) =\n", "\\max\n", "\\left\\{\n", " \\frac{w}{1 - \\beta} ,\\, \\frac{\\bar w(\\pi)}{1 - \\beta}\n", "\\right\\} \\tag{5}\n", "$$\n", "\n", "Combining [(4)](#equation-odu-mvf2) and [(5)](#equation-odu-mvf3), we obtain\n", "\n", "$$\n", "\\frac{\\bar w(\\pi)}{1 - \\beta}\n", "= c + \\beta \\int \\max \\left\\{\n", " \\frac{w'}{1 - \\beta} ,\\, \\frac{\\bar w(\\pi')}{1 - \\beta}\n", "\\right\\}\n", "\\, h_{\\pi}(w') \\, dw'\n", "$$\n", "\n", "Multiplying by $ 1 - \\beta $, substituting in $ \\pi' = q(w', \\pi) $ and using $ \\circ $ for composition of functions yields\n", "\n", "\n", "\n", "$$\n", "\\bar w(\\pi)\n", "= (1 - \\beta) c +\n", "\\beta \\int \\max \\left\\{ w', \\bar w \\circ q(w', \\pi) \\right\\} \\, h_{\\pi}(w') \\, dw' \\tag{6}\n", "$$\n", "\n", "Equation [(6)](#equation-odu-mvf4) can be understood as a functional equation, where $ \\bar w $ is the unknown function.\n", "\n", "- Let’s call it the *reservation wage functional equation* (RWFE). \n", "- The solution $ \\bar w $ to the RWFE is the object that we wish to compute. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Solving the RWFE\n", "\n", "To solve the RWFE, we will first show that its solution is the\n", "fixed point of a [contraction mapping](https://en.wikipedia.org/wiki/Contraction_mapping).\n", "\n", "To this end, let\n", "\n", "- $ b[0,1] $ be the bounded real-valued functions on $ [0,1] $ \n", "- $ \\| \\psi \\| := \\sup_{x \\in [0,1]} | \\psi(x) | $ \n", "\n", "\n", "Consider the operator $ Q $ mapping $ \\psi \\in b[0,1] $ into $ Q\\psi \\in b[0,1] $ via\n", "\n", "\n", "\n", "$$\n", "(Q \\psi)(\\pi)\n", "= (1 - \\beta) c +\n", "\\beta \\int \\max \\left\\{ w', \\psi \\circ q(w', \\pi) \\right\\} \\, h_{\\pi}(w') \\, dw' \\tag{7}\n", "$$\n", "\n", "Comparing [(6)](#equation-odu-mvf4) and [(7)](#equation-odu-dq), we see that the set of fixed points of $ Q $ exactly coincides with the set of solutions to the RWFE.\n", "\n", "- If $ Q \\bar w = \\bar w $ then $ \\bar w $ solves [(6)](#equation-odu-mvf4) and vice versa. \n", "\n", "\n", "Moreover, for any $ \\psi, \\phi \\in b[0,1] $, basic algebra and the\n", "triangle inequality for integrals tells us that\n", "\n", "\n", "\n", "$$\n", "|(Q \\psi)(\\pi) - (Q \\phi)(\\pi)|\n", "\\leq \\beta \\int\n", "\\left|\n", "\\max \\left\\{w', \\psi \\circ q(w', \\pi) \\right\\} -\n", "\\max \\left\\{w', \\phi \\circ q(w', \\pi) \\right\\}\n", "\\right|\n", "\\, h_{\\pi}(w') \\, dw' \\tag{8}\n", "$$\n", "\n", "Working case by case, it is easy to check that for real numbers $ a, b, c $ we always have\n", "\n", "\n", "\n", "$$\n", "| \\max\\{a, b\\} - \\max\\{a, c\\}| \\leq | b - c| \\tag{9}\n", "$$\n", "\n", "Combining [(8)](#equation-odu-nt) and [(9)](#equation-odu-nt2) yields\n", "\n", "\n", "\n", "$$\n", "|(Q \\psi)(\\pi) - (Q \\phi)(\\pi)|\n", "\\leq \\beta \\int\n", "\\left| \\psi \\circ q(w', \\pi) - \\phi \\circ q(w', \\pi) \\right|\n", "\\, h_{\\pi}(w') \\, dw'\n", "\\leq \\beta \\| \\psi - \\phi \\| \\tag{10}\n", "$$\n", "\n", "Taking the supremum over $ \\pi $ now gives us\n", "\n", "\n", "\n", "$$\n", "\\|Q \\psi - Q \\phi\\|\n", "\\leq \\beta \\| \\psi - \\phi \\| \\tag{11}\n", "$$\n", "\n", "In other words, $ Q $ is a contraction of modulus $ \\beta $ on the\n", "complete metric space $ (b[0,1], \\| \\cdot \\|) $.\n", "\n", "Hence\n", "\n", "- A unique solution $ \\bar w $ to the RWFE exists in $ b[0,1] $. \n", "- $ Q^k \\psi \\to \\bar w $ uniformly as $ k \\to \\infty $, for any $ \\psi \\in b[0,1] $. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Implementation\n", "\n", "These ideas are implemented in the `.res_wage_operator()` method from `odu.jl` as shown above.\n", "\n", "The method corresponds to action of the operator $ Q $.\n", "\n", "The following exercise asks you to exploit these facts to compute an approximation to $ \\bar w $." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exercises\n", "\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1\n", "\n", "Use the default parameters and the `.res_wage_operator()` method to compute an optimal policy.\n", "\n", "Your result should coincide closely with the figure for the optimal policy [shown above](#odu-pol-vfi).\n", "\n", "Try experimenting with different parameters, and confirm that the change in\n", "the optimal policy coincides with your intuition." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Solutions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Exercise 1\n", "\n", "This code solves the “Offer Distribution Unknown” model by iterating on\n", "a guess of the reservation wage function. You should find that the run\n", "time is much shorter than that of the value function approach in\n", "`examples/odu_vfi_plots.jl`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "hide-output": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Compute iterate 10 with error 0.007194437603255555\n", "Compute iterate 20 with error 0.0004348703417873523\n", "Converged in 26 steps\n" ] }, { "data": { "image/png": "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" }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sp = SearchProblem(π_grid_size = 50)\n", "\n", "ϕ_init = ones(sp.n_π)\n", "f_ex1(x) = res_wage_operator(sp, x)\n", "w̄ = compute_fixed_point(f_ex1, ϕ_init)\n", "\n", "plot(sp.π_grid, w̄, linewidth = 2, color=:black,\n", " fillrange = 0, fillalpha = 0.15, fillcolor = :blue)\n", "plot!(sp.π_grid, 2 * ones(length(w̄)), linewidth = 0, fillrange = w̄,\n", " fillalpha = 0.12, fillcolor = :green, legend = :none)\n", "plot!(ylims = (0, 2), annotations = [(0.42, 1.2, \"reject\"),\n", " (0.7, 1.8, \"accept\")])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The next piece of code is not one of the exercises from QuantEcon – it’s\n", "just a fun simulation to see what the effect of a change in the\n", "underlying distribution on the unemployment rate is.\n", "\n", "At a point in the simulation, the distribution becomes significantly\n", "worse. It takes a while for agents to learn this, and in the meantime\n", "they are too optimistic, and turn down too many jobs. As a result, the\n", "unemployment rate spikes.\n", "\n", "The code takes a few minutes to run." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "hide-output": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Compute iterate 10 with error 0.007194437603255555\n", "Compute iterate 20 with error 0.0004348703417873523\n", "Converged in 26 steps\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 20\n", "date = 40\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 60\n", "date = 80\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 100\n", "date = 120\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 140\n", "date = 160\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 180\n", "date = 200\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 220\n", "date = 240\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 260\n", "date = 280\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 300\n", "date = 320\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 340\n", "date = 360\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 380\n", "date = 400\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 420\n", "date = 440\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 460\n", "date = 480\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 500\n", "date = 520\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 540\n", "date = 560\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "date = 580\n", "date = 600\n" ] }, { "data": { "image/png": "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" }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Determinism and random objects.\n", "using Random\n", "Random.seed!(42)\n", "\n", "# Set up model and compute the function w̄\n", "sp = SearchProblem(π_grid_size = 50, F_a = 1, F_b = 1)\n", "ϕ_init = ones(sp.n_π)\n", "g(x) = res_wage_operator(sp, x)\n", "w̄_vals = compute_fixed_point(g, ϕ_init)\n", "w̄ = extrapolate(interpolate((sp.π_grid, ), w̄_vals,\n", " Gridded(Linear())), Flat())\n", "\n", "# Holds the employment state and beliefs of an individual agent.\n", "mutable struct Agent{TF <: AbstractFloat, TI <: Integer}\n", " _π::TF\n", " employed::TI\n", "end\n", "\n", "Agent(_π=1e-3) = Agent(_π, 1)\n", "\n", "function update!(ag, H)\n", " if ag.employed == 0\n", " w = rand(H) * 2 # account for scale in julia\n", " if w ≥ w̄(ag._π)\n", " ag.employed = 1\n", " else\n", " ag._π = 1.0 ./ (1 .+ ((1 - ag._π) .* sp.g(w)) ./ (ag._π * sp.f(w)))\n", " end\n", " end\n", " nothing\n", "end\n", "\n", "num_agents = 5000\n", "separation_rate = 0.025 # Fraction of jobs that end in each period\n", "separation_num = round(Int, num_agents * separation_rate)\n", "agent_indices = collect(1:num_agents)\n", "agents = [Agent() for i=1:num_agents]\n", "sim_length = 600\n", "H = sp.G # Start with distribution G\n", "change_date = 200 # Change to F after this many periods\n", "unempl_rate = zeros(sim_length)\n", "\n", "for i in 1:sim_length\n", " if i % 20 == 0\n", " println(\"date = $i\")\n", " end\n", "\n", " if i == change_date\n", " H = sp.F\n", " end\n", "\n", " # Randomly select separation_num agents and set employment status to 0\n", " shuffle!(agent_indices)\n", " separation_list = agent_indices[1:separation_num]\n", "\n", " for agent in agents[separation_list]\n", " agent.employed = 0\n", " end\n", "\n", " # update agents\n", " for agent in agents\n", " update!(agent, H)\n", " end\n", " employed = Int[agent.employed for agent in agents]\n", " unempl_rate[i] = 1.0 - mean(employed)\n", "end\n", "\n", "plot(unempl_rate, linewidth = 2, label = \"unemployment rate\")\n", "vline!([change_date], color = :red, label = \"\")" ] } ], "metadata": { "date": 1591310616.3748114, "download_nb": 1, "download_nb_path": "https://julia.quantecon.org/", "filename": "odu.rst", "filename_with_path": "dynamic_programming/odu", "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 III: Search with Learning" }, "nbformat": 4, "nbformat_minor": 2 }