├── README.md ├── finite_life_job_search └── job_search_finite.ipynb ├── firm_problems └── inventory_dp.ipynb ├── infinite_horizon_job_search ├── iid_job_search.ipynb ├── lininterp.py └── odu.ipynb ├── jit_vs_vectorization ├── efficient_inventory_dynamics.ipynb ├── inventory_dynamics.ipynb └── vectorization_numba.ipynb ├── lectures ├── lecture1.pdf ├── lecture10.pdf ├── lecture12.pdf ├── lecture13.pdf ├── lecture14.pdf ├── lecture2.pdf ├── lecture3.pdf ├── lecture4.pdf ├── lecture5.pdf ├── lecture6.pdf ├── lecture7.pdf ├── lecture8.pdf └── lecture9.pdf ├── notes.pdf ├── optimal_savings ├── optgrowth.ipynb └── toda_crra.ipynb ├── sept_7_seminar ├── .ipynb_checkpoints │ ├── supply_and_demand-checkpoint.ipynb │ ├── supply_and_demand_solution_1-checkpoint.ipynb │ └── supply_and_demand_solution_2-checkpoint.ipynb ├── supply_and_demand.ipynb ├── supply_and_demand_solution_1.ipynb └── supply_and_demand_solution_2.ipynb └── wealth_dynamics ├── wealth_ineq_plots.ipynb └── wealth_sk_plots.ipynb /README.md: -------------------------------------------------------------------------------- 1 | 2 | ## ECON-GA 1025 -- Macroeconomic Theory I 3 | 4 | This is the public course page for the first half of ECON-GA 1025 – Macroeconomic Theory I 5 | 6 | It will run over Sept 5 -- Oct 22 in the fall Semester of 2018 7 | 8 | ### Course notes 9 | 10 | * Download the whole repository or [click here](https://github.com/jstac/nyu_macro_fall_2018/raw/master/notes.pdf) 11 | 12 | (If you know how to use git then it might be best to clone the repo and then 13 | pull changes periodically. If not then just follow the instructions above.) 14 | 15 | 16 | 17 | 18 | ### Other resources 19 | 20 | * [The QuantEcon lectures](https://lectures.quantecon.org/) 21 | 22 | 23 | ### Further reading 24 | 25 | *Recursive Macroeconomic Theory* by Lars Ljungqvist and Thomas J. Sargent, MIT Press, fourth edition, 2018, chapters 1-7 26 | 27 | *Recursive Methods in Dynamic Economics* by Nancy Stokey and Robert E. Lucas, Harvard University Press, 1989 28 | 29 | 30 | ### Assignments 31 | 32 | See NYU Classes 33 | 34 | 35 | ### Lecture slides 36 | 37 | * [Lecture 1](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture1.pdf) 38 | * [Lecture 2](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture2.pdf) 39 | * [Lecture 3](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture3.pdf) 40 | * [Lecture 4](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture4.pdf) 41 | * [Lecture 5](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture5.pdf) 42 | * [Lecture 6](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture6.pdf) 43 | * [Lecture 7](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture7.pdf) 44 | * [Lecture 8](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture8.pdf) 45 | * [Lecture 9](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture9.pdf) 46 | * [Lecture 10](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture10.pdf) 47 | * Lecture 11 given by TJS 48 | * [Lecture 12](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture12.pdf) 49 | * [Lecture 13](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture13.pdf) 50 | * [Lecture 14](https://github.com/jstac/nyu_macro_fall_2018/raw/master/lectures/lecture14.pdf) -- not for assessment 51 | -------------------------------------------------------------------------------- /finite_life_job_search/job_search_finite.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Problem Set 2: Job Search" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "A Python solution to the finite life Job Search problem.\n", 15 | "\n", 16 | "We start with some imports" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 151, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "import numpy as np\n", 26 | "import quantecon as qe\n", 27 | "\n", 28 | "from numba import njit, prange\n", 29 | "import matplotlib.pyplot as plt" 30 | ] 31 | }, 32 | { 33 | "cell_type": "markdown", 34 | "metadata": {}, 35 | "source": [ 36 | "To keep the code simple, some variables will be global." 37 | ] 38 | }, 39 | { 40 | "cell_type": "code", 41 | "execution_count": 152, 42 | "metadata": {}, 43 | "outputs": [], 44 | "source": [ 45 | "T = 65\n", 46 | "w_vals = (7, 10, 11)\n", 47 | "p = (0.25, 0.5, 0.25)\n", 48 | "p_cdf = np.cumsum(p)" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "Here's a little function to draw from $p$" 56 | ] 57 | }, 58 | { 59 | "cell_type": "code", 60 | "execution_count": 153, 61 | "metadata": {}, 62 | "outputs": [], 63 | "source": [ 64 | "@njit\n", 65 | "def draw_from_offer_distribution():\n", 66 | " return qe.random.draw(p_cdf)" 67 | ] 68 | }, 69 | { 70 | "cell_type": "markdown", 71 | "metadata": {}, 72 | "source": [ 73 | "\n", 74 | "The next function computes values and policies.\n", 75 | "\n", 76 | "The possible wage values are $w_0, w_1, w_2$\n", 77 | "\n", 78 | "The value functions $v_t(w)$ are returned as a matrix $V$ of the form\n", 79 | "\n", 80 | "$$\n", 81 | "V = \n", 82 | "\\begin{pmatrix}\n", 83 | " v_0(w_0) & v_0(w_1) & v_0(w_2) \\\\\n", 84 | " v_1(w_0) & v_1(w_1) & v_1(w_2) \\\\\n", 85 | " & \\vdots & \\\\\n", 86 | " v_t(w_0) & v_t(w_1) & v_t(w_2) \\\\\n", 87 | " & \\vdots & \n", 88 | "\\end{pmatrix}\n", 89 | "$$\n", 90 | "\n", 91 | "The policy functions, which give the optimal choice at each state and time, have the interpretation\n", 92 | "\n", 93 | "$$ \\sigma_t(w) =\n", 94 | "\\begin{cases}\n", 95 | " 1 & \\text{if accept $w$ at time $t$} \\\\\n", 96 | " 0 & \\text{otherwise}\n", 97 | "\\end{cases}\n", 98 | "$$\n", 99 | "\n", 100 | "The policy functions are returned as a matrix $\\sigma$ of the form\n", 101 | "\n", 102 | "$$\n", 103 | "\\sigma = \n", 104 | "\\begin{pmatrix}\n", 105 | " \\sigma_0(w_0) & \\sigma_0(w_1) & \\sigma_0(w_2) \\\\\n", 106 | " \\sigma_1(w_0) & \\sigma_1(w_1) & \\sigma_1(w_2) \\\\\n", 107 | " & \\vdots & \\\\\n", 108 | " \\sigma_t(w_0) & \\sigma_t(w_1) & \\sigma_t(w_2) \\\\\n", 109 | " & \\vdots & \n", 110 | "\\end{pmatrix}\n", 111 | "$$" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 154, 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [ 120 | "@njit\n", 121 | "def compute_values_and_policies(β=0.96, c=8):\n", 122 | "\n", 123 | " n = len(w_vals) \n", 124 | " V = np.empty((T, n))\n", 125 | " σ = np.zeros((T, n), dtype=np.int64)\n", 126 | "\n", 127 | " t = T-1\n", 128 | " for i, w in enumerate(w_vals):\n", 129 | " V[t, i] = max(c, w) \n", 130 | " σ[t, i] = (w > c)\n", 131 | "\n", 132 | " while t > 0:\n", 133 | " for i, w in enumerate(w_vals):\n", 134 | " \n", 135 | " accept_val = w * (1 - β**(T-t+1)) / (1 - β)\n", 136 | " EV = 0.0\n", 137 | " for j in range(n):\n", 138 | " EV += V[t, j] * p[j]\n", 139 | " continue_val = c + β * EV\n", 140 | " \n", 141 | " if accept_val > continue_val:\n", 142 | " σ[t-1, i] = 1\n", 143 | " V[t-1, i] = accept_val\n", 144 | " else:\n", 145 | " V[t-1, i] = continue_val\n", 146 | " \n", 147 | " t -= 1\n", 148 | "\n", 149 | " return V, σ" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "Here's jitted code that simulates the life of one agent, recording the wage that they accept at and their age when they accept." 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 166, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [ 165 | "@njit\n", 166 | "def sim_life(σ):\n", 167 | " for t in range(T):\n", 168 | " i = draw_from_offer_distribution()\n", 169 | " if σ[t, i] == 1:\n", 170 | " accepted_wage = w_vals[i]\n", 171 | " start_work_age = t\n", 172 | " return accepted_wage, start_work_age+1\n", 173 | " \n", 174 | " start_work_age = T\n", 175 | " accepted_wage = 0\n", 176 | " return accepted_wage, start_work_age" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": {}, 182 | "source": [ 183 | "Here's a function that simulates the lives of many agents and takes an average over their statistics.\n", 184 | "\n", 185 | "Parallelization is not implemented because the individual calculations are so short." 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": 167, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [ 194 | "@njit\n", 195 | "def sim_stats(σ, m=1_000_000):\n", 196 | " wage_mean = 0\n", 197 | " age_mean = 0\n", 198 | " for i in range(m):\n", 199 | " accepted_wage, start_work_age = sim_life(σ)\n", 200 | " age_mean += start_work_age\n", 201 | " wage_mean += accepted_wage\n", 202 | " return wage_mean / m, age_mean / m\n", 203 | " " 204 | ] 205 | }, 206 | { 207 | "cell_type": "markdown", 208 | "metadata": {}, 209 | "source": [ 210 | "Now let's actually compute the optimal policies and simulate some agents to calculate statistics." 211 | ] 212 | }, 213 | { 214 | "cell_type": "code", 215 | "execution_count": 178, 216 | "metadata": {}, 217 | "outputs": [], 218 | "source": [ 219 | "\n", 220 | "V, σ = compute_values_and_policies()" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": 179, 226 | "metadata": {}, 227 | "outputs": [ 228 | { 229 | "name": "stdout", 230 | "output_type": "stream", 231 | "text": [ 232 | "CPU times: user 153 ms, sys: 0 ns, total: 153 ms\n", 233 | "Wall time: 151 ms\n" 234 | ] 235 | } 236 | ], 237 | "source": [ 238 | "%%time\n", 239 | "\n", 240 | "wage_mean, age_mean = sim_stats(σ)" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 180, 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "data": { 250 | "text/plain": [ 251 | "11.0" 252 | ] 253 | }, 254 | "execution_count": 180, 255 | "metadata": {}, 256 | "output_type": "execute_result" 257 | } 258 | ], 259 | "source": [ 260 | "wage_mean" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": 181, 266 | "metadata": {}, 267 | "outputs": [ 268 | { 269 | "data": { 270 | "text/plain": [ 271 | "3.999721" 272 | ] 273 | }, 274 | "execution_count": 181, 275 | "metadata": {}, 276 | "output_type": "execute_result" 277 | } 278 | ], 279 | "source": [ 280 | "age_mean" 281 | ] 282 | }, 283 | { 284 | "cell_type": "markdown", 285 | "metadata": {}, 286 | "source": [ 287 | "Total time to simulate for 1,000,000 agents is a few hundred ms on my machine." 288 | ] 289 | }, 290 | { 291 | "cell_type": "markdown", 292 | "metadata": {}, 293 | "source": [ 294 | "What happens when we change $c$?" 295 | ] 296 | }, 297 | { 298 | "cell_type": "code", 299 | "execution_count": 182, 300 | "metadata": {}, 301 | "outputs": [], 302 | "source": [ 303 | "\n", 304 | "V, σ = compute_values_and_policies(c=4.5)" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": 183, 310 | "metadata": {}, 311 | "outputs": [ 312 | { 313 | "name": "stdout", 314 | "output_type": "stream", 315 | "text": [ 316 | "CPU times: user 103 ms, sys: 0 ns, total: 103 ms\n", 317 | "Wall time: 101 ms\n" 318 | ] 319 | } 320 | ], 321 | "source": [ 322 | "%%time\n", 323 | "\n", 324 | "wage_mean, age_mean = sim_stats(σ)" 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": 184, 330 | "metadata": {}, 331 | "outputs": [ 332 | { 333 | "data": { 334 | "text/plain": [ 335 | "10.71835" 336 | ] 337 | }, 338 | "execution_count": 184, 339 | "metadata": {}, 340 | "output_type": "execute_result" 341 | } 342 | ], 343 | "source": [ 344 | "wage_mean" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": 185, 350 | "metadata": {}, 351 | "outputs": [ 352 | { 353 | "data": { 354 | "text/plain": [ 355 | "2.876221" 356 | ] 357 | }, 358 | "execution_count": 185, 359 | "metadata": {}, 360 | "output_type": "execute_result" 361 | } 362 | ], 363 | "source": [ 364 | "age_mean" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": null, 370 | "metadata": {}, 371 | "outputs": [], 372 | "source": [] 373 | } 374 | ], 375 | "metadata": { 376 | "kernelspec": { 377 | "display_name": "Python 3", 378 | "language": "python", 379 | "name": "python3" 380 | }, 381 | "language_info": { 382 | "codemirror_mode": { 383 | "name": "ipython", 384 | "version": 3 385 | }, 386 | "file_extension": ".py", 387 | "mimetype": "text/x-python", 388 | "name": "python", 389 | "nbconvert_exporter": "python", 390 | "pygments_lexer": "ipython3", 391 | "version": "3.6.4" 392 | } 393 | }, 394 | "nbformat": 4, 395 | "nbformat_minor": 2 396 | } 397 | -------------------------------------------------------------------------------- /firm_problems/inventory_dp.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Inventories and Dynamic Programming\n", 8 | "\n", 9 | "#### John Stachurski\n", 10 | "\n", 11 | "Fall semester 2018\n", 12 | "\n", 13 | "Attempts to generate $(s, S)$ dynamics in an optimizing model." 14 | ] 15 | }, 16 | { 17 | "cell_type": "code", 18 | "execution_count": 1, 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "import numpy as np\n", 23 | "import matplotlib.pyplot as plt\n", 24 | "from numba import njit" 25 | ] 26 | }, 27 | { 28 | "cell_type": "code", 29 | "execution_count": 2, 30 | "metadata": {}, 31 | "outputs": [], 32 | "source": [ 33 | "p = 0.4 # Higher p means lower demand\n", 34 | "\n", 35 | "@njit\n", 36 | "def ϕ(d):\n", 37 | " return (1 - p)**d * p\n", 38 | "\n", 39 | "@njit\n", 40 | "def mx(a):\n", 41 | " return max(a, 0)\n", 42 | "\n", 43 | "d_max = 100" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": 3, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [ 52 | "@njit\n", 53 | "def bellman_op(v, v_out, σ, β, S, c, k):\n", 54 | "\n", 55 | " n = len(v) \n", 56 | " \n", 57 | " for x in range(n):\n", 58 | " # compute the value of not ordering\n", 59 | " vno = 0.0\n", 60 | " for d in range(d_max):\n", 61 | " vno += (min(x, d) + β * v[mx(x-d)]) * ϕ(d)\n", 62 | " # compute the value of ordering\n", 63 | " if x <= (k - 1) * S:\n", 64 | " vo = -c\n", 65 | " for d in range(d_max):\n", 66 | " vo += (min(x, d) + β * v[mx(x-d) + S]) * ϕ(d)\n", 67 | " else:\n", 68 | " vo = -np.inf\n", 69 | " \n", 70 | " # take the max\n", 71 | " v_out[x] = max(vo, vno)\n", 72 | " if vo > vno:\n", 73 | " σ[x] = 1\n" 74 | ] 75 | }, 76 | { 77 | "cell_type": "code", 78 | "execution_count": 4, 79 | "metadata": {}, 80 | "outputs": [], 81 | "source": [ 82 | "β = 0.98\n", 83 | "S = 100\n", 84 | "c = 2\n", 85 | "k = 2\n", 86 | "n = k * S + 1" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 5, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [ 95 | "v_in = np.ones(n, dtype=int)\n", 96 | "v_out = np.ones(n, dtype=int)\n", 97 | "σ = np.zeros(n, dtype=int)\n" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": 6, 103 | "metadata": {}, 104 | "outputs": [], 105 | "source": [ 106 | "i = 0\n", 107 | "iter_max = 500\n", 108 | "tol = 1e-6\n", 109 | "ϵ = tol + 1\n", 110 | "\n", 111 | "while i < iter_max and ϵ > tol:\n", 112 | " bellman_op(v_in, v_out, σ, β, S, c, k)\n", 113 | " ϵ = np.max(np.abs(v_in - v_out))\n", 114 | " v_in[:] = v_out\n", 115 | " i += 1" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": 7, 121 | "metadata": {}, 122 | "outputs": [ 123 | { 124 | "data": { 125 | "text/plain": [ 126 | "28" 127 | ] 128 | }, 129 | "execution_count": 7, 130 | "metadata": {}, 131 | "output_type": "execute_result" 132 | } 133 | ], 134 | "source": [ 135 | "i" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 8, 141 | "metadata": {}, 142 | "outputs": [ 143 | { 144 | "data": { 145 | "image/png": "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\n", 146 | "text/plain": [ 147 | "
" 148 | ] 149 | }, 150 | "metadata": {}, 151 | "output_type": "display_data" 152 | } 153 | ], 154 | "source": [ 155 | "fig, ax = plt.subplots()\n", 156 | "\n", 157 | "ax.plot(np.arange(n), v_out, label=\"$v^*$\")\n", 158 | "ax.set_xlabel(\"inventory\", fontsize=12)\n", 159 | "ax.set_ylabel(\"value\", fontsize=12)\n", 160 | "ax.legend(fontsize=12)\n", 161 | "plt.show()" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 9, 167 | "metadata": {}, 168 | "outputs": [ 169 | { 170 | "data": { 171 | "image/png": "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\n", 172 | "text/plain": [ 173 | "
" 174 | ] 175 | }, 176 | "metadata": {}, 177 | "output_type": "display_data" 178 | } 179 | ], 180 | "source": [ 181 | "fig, ax = plt.subplots()\n", 182 | "\n", 183 | "ax.plot(np.arange(len(v_out)), σ, label=\"$\\\\sigma^*$\")\n", 184 | "ax.set_xlabel(\"inventory\")\n", 185 | "\n", 186 | "ax.set_yticks((0, 1))\n", 187 | "\n", 188 | "ax.legend()\n", 189 | "plt.show()" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 10, 195 | "metadata": {}, 196 | "outputs": [], 197 | "source": [ 198 | "def simulate(ts_length, x_init=S):\n", 199 | " x = np.empty(ts_length, dtype=int)\n", 200 | " x[0] = x_init\n", 201 | " for t in range(ts_length-1):\n", 202 | " d = np.random.geometric(p)\n", 203 | " x[t+1] = mx(x[t] - d) + S * σ[x[t]]\n", 204 | " return x\n", 205 | " " 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 11, 211 | "metadata": {}, 212 | "outputs": [], 213 | "source": [ 214 | "x = simulate(100)" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": 12, 220 | "metadata": {}, 221 | "outputs": [ 222 | { 223 | "data": { 224 | "image/png": "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\n", 225 | "text/plain": [ 226 | "
" 227 | ] 228 | }, 229 | "metadata": {}, 230 | "output_type": "display_data" 231 | } 232 | ], 233 | "source": [ 234 | "fig, ax = plt.subplots()\n", 235 | "\n", 236 | "ax.plot(x)\n", 237 | "\n", 238 | "ax.set_xlabel(\"time\")\n", 239 | "ax.set_ylabel(\"inventory\")\n", 240 | "\n", 241 | "plt.show()" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": {}, 248 | "outputs": [], 249 | "source": [] 250 | } 251 | ], 252 | "metadata": { 253 | "kernelspec": { 254 | "display_name": "Python 3", 255 | "language": "python", 256 | "name": "python3" 257 | }, 258 | "language_info": { 259 | "codemirror_mode": { 260 | "name": "ipython", 261 | "version": 3 262 | }, 263 | "file_extension": ".py", 264 | "mimetype": "text/x-python", 265 | "name": "python", 266 | "nbconvert_exporter": "python", 267 | "pygments_lexer": "ipython3", 268 | "version": "3.6.5" 269 | } 270 | }, 271 | "nbformat": 4, 272 | "nbformat_minor": 2 273 | } 274 | -------------------------------------------------------------------------------- /infinite_horizon_job_search/lininterp.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | from numba import jit 3 | 4 | @jit(nopython=True) 5 | def interp1d(grid, vals, x): 6 | """ 7 | Linearly interpolate (grid, vals) to evaluate at x. 8 | 9 | Parameters 10 | ---------- 11 | grid and vals are numpy arrays, x is a float 12 | 13 | Returns 14 | ------- 15 | a float, the interpolated value 16 | 17 | """ 18 | 19 | a, b, G = np.min(grid), np.max(grid), len(grid) 20 | 21 | s = (x - a) / (b - a) 22 | 23 | q_0 = max(min(int(s * (G - 1)), (G - 2)), 0) 24 | v_0 = vals[q_0] 25 | v_1 = vals[q_0 + 1] 26 | 27 | λ = s * (G - 1) - q_0 28 | 29 | return (1 - λ) * v_0 + λ * v_1 30 | 31 | 32 | @jit(nopython=True) 33 | def interp1d_vectorized(grid, vals, x_vec): 34 | """ 35 | Linearly interpolate (grid, vals) to evaluate at x_vec. 36 | 37 | All inputs are numpy arrays. 38 | 39 | Return value is a numpy array of length len(x_vec). 40 | """ 41 | 42 | out = np.empty_like(x_vec) 43 | 44 | for i, x in enumerate(x_vec): 45 | out[i] = interp1d(grid, vals, x) 46 | 47 | return out 48 | 49 | 50 | -------------------------------------------------------------------------------- /infinite_horizon_job_search/odu.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Job Search with Learning\n", 8 | "\n", 9 | "#### John Stachurski\n", 10 | "\n", 11 | "Fall semester 2018" 12 | ] 13 | }, 14 | { 15 | "cell_type": "code", 16 | "execution_count": 1, 17 | "metadata": {}, 18 | "outputs": [], 19 | "source": [ 20 | "import numpy as np\n", 21 | "import matplotlib.pyplot as plt\n", 22 | "from lininterp import interp1d\n", 23 | "from numba import njit, vectorize, prange\n", 24 | "\n", 25 | "from math import gamma\n", 26 | "from scipy.stats import beta\n" 27 | ] 28 | }, 29 | { 30 | "cell_type": "code", 31 | "execution_count": 2, 32 | "metadata": {}, 33 | "outputs": [], 34 | "source": [ 35 | "from matplotlib import rc\n", 36 | "#rc('font',**{'family':'sans-serif','sans-serif':['Helvetica']})\n", 37 | "rc('text', usetex=True)" 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "Let's set up some fast jitted functions that implement beta distributions. In doing so we recall that the beta density is\n", 45 | "\n", 46 | "$$ \n", 47 | " p(x, a, b) = \\frac{\\Gamma(a + b)}{\\Gamma(a)\\Gamma(b)}\n", 48 | " x^{a-1} (1 - x)^{b-1}\n", 49 | " \\qquad (0 \\leq x \\leq 1)\n", 50 | "$$\n" 51 | ] 52 | }, 53 | { 54 | "cell_type": "code", 55 | "execution_count": 4, 56 | "metadata": {}, 57 | "outputs": [], 58 | "source": [ 59 | "def beta_function_factory(a, b):\n", 60 | " \n", 61 | " @vectorize\n", 62 | " def p(x):\n", 63 | " r = gamma(a + b) / (gamma(a) * gamma(b))\n", 64 | " return r * x**(a-1) * (1 - x)**(b-1)\n", 65 | " \n", 66 | " @njit\n", 67 | " def p_rvs():\n", 68 | " return np.random.beta(a, b)\n", 69 | " \n", 70 | " return p, p_rvs\n", 71 | "\n" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": 5, 77 | "metadata": {}, 78 | "outputs": [ 79 | { 80 | "data": { 81 | "image/png": "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\n", 82 | "text/plain": [ 83 | "
" 84 | ] 85 | }, 86 | "metadata": {}, 87 | "output_type": "display_data" 88 | } 89 | ], 90 | "source": [ 91 | "x_grid = np.linspace(0, 1, 100)\n", 92 | "f, f_rvs = beta_function_factory(4, 2)\n", 93 | "g, g_rvs = beta_function_factory(2, 4)\n", 94 | "\n", 95 | "fig, ax = plt.subplots()\n", 96 | "\n", 97 | "plt.plot(x_grid, f(x_grid), label='$f$', lw=2)\n", 98 | "plt.plot(x_grid, g(x_grid), label='$g$', lw=2)\n", 99 | "\n", 100 | "plt.legend(fontsize=12)\n", 101 | "plt.show()" 102 | ] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "A convex combination" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 6, 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "data": { 118 | "image/png": "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\n", 119 | "text/plain": [ 120 | "
" 121 | ] 122 | }, 123 | "metadata": {}, 124 | "output_type": "display_data" 125 | } 126 | ], 127 | "source": [ 128 | "\n", 129 | "fig, ax = plt.subplots()\n", 130 | "\n", 131 | "plt.plot(x_grid, 0.5 * f(x_grid) + 0.5 * g(x_grid), label='$q$', lw=2)\n", 132 | "plt.legend()\n", 133 | "plt.show()" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 7, 139 | "metadata": {}, 140 | "outputs": [], 141 | "source": [ 142 | "class SearchProblem:\n", 143 | "\n", 144 | " def __init__(self, \n", 145 | " β=0.95, \n", 146 | " c=0.1, \n", 147 | " F_a=4, \n", 148 | " F_b=2, \n", 149 | " G_a=2, \n", 150 | " G_b=4,\n", 151 | " π_grid_size=20):\n", 152 | "\n", 153 | " self.β, self.c = β, c\n", 154 | " self.f, self.f_rvs = beta_function_factory(F_a, F_b)\n", 155 | " self.g, self.g_rvs = beta_function_factory(G_a, G_b)\n", 156 | " \n", 157 | " self.π_grid = np.linspace(0, 1, π_grid_size)\n", 158 | " " 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 17, 164 | "metadata": {}, 165 | "outputs": [], 166 | "source": [ 167 | "def Q_factory(sp, mc_size=10000, seed=123):\n", 168 | "\n", 169 | " # == Simplify names == #\n", 170 | " β, c, π_grid = sp.β, sp.c, sp.π_grid\n", 171 | " f, f_rvs = sp.f, sp.f_rvs\n", 172 | " g, g_rvs = sp.g, sp.g_rvs\n", 173 | "\n", 174 | "\n", 175 | " @njit\n", 176 | " def κ(w, π):\n", 177 | " \"\"\"\n", 178 | " Updates π using Bayes' rule and the current wage observation w.\n", 179 | " \"\"\"\n", 180 | " pf, pg = π * f(w), (1 - π) * g(w)\n", 181 | " new_π = pf / (pf + pg)\n", 182 | " return new_π\n", 183 | " \n", 184 | " @njit\n", 185 | " def Q(ψ):\n", 186 | " \n", 187 | " np.random.seed(seed)\n", 188 | " U = np.random.uniform(0, 1, mc_size)\n", 189 | "\n", 190 | " \n", 191 | " # == Turn ψ into a function == #\n", 192 | " def ψ_f(x):\n", 193 | " return interp1d(π_grid, ψ, x)\n", 194 | " \n", 195 | " new_ψ = np.empty_like(ψ)\n", 196 | " w_prime = np.empty(mc_size)\n", 197 | "\n", 198 | " for i in range(len(π_grid)):\n", 199 | " π = π_grid[i]\n", 200 | " \n", 201 | " # Generate draws from q_π\n", 202 | " for m in range(mc_size):\n", 203 | " if U[m] < π:\n", 204 | " wp = f_rvs()\n", 205 | " else:\n", 206 | " wp = g_rvs()\n", 207 | " w_prime[m] = wp\n", 208 | "\n", 209 | " # Evaluate expectation\n", 210 | " integral = 0.0\n", 211 | " for m, wp in enumerate(w_prime):\n", 212 | " integral += max(wp, ψ_f(κ(wp, π)))\n", 213 | " integral = integral / mc_size\n", 214 | "\n", 215 | " # Update Qψ\n", 216 | " new_ψ[i] = (1 - β) * c + β * integral\n", 217 | "\n", 218 | " return new_ψ\n", 219 | " \n", 220 | " return Q" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": 18, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [ 229 | "def Q_iterator(sp, max_iter=500, tol=1e-4):\n", 230 | " \n", 231 | " ψ_init = np.ones(len(sp.π_grid))\n", 232 | " Q = Q_factory(sp)\n", 233 | " ψ = ψ_init\n", 234 | " ϵ = tol + 1\n", 235 | " i = 0\n", 236 | " \n", 237 | " while i < max_iter and ϵ > tol:\n", 238 | " new_ψ = Q(ψ)\n", 239 | " ϵ = np.max(np.abs(ψ - new_ψ))\n", 240 | " ψ = new_ψ\n", 241 | " i += 1\n", 242 | " \n", 243 | " if i == max_iter:\n", 244 | " print(\"Warning: hit maximum iterations\")\n", 245 | " \n", 246 | " \n", 247 | " return ψ" 248 | ] 249 | }, 250 | { 251 | "cell_type": "code", 252 | "execution_count": 19, 253 | "metadata": {}, 254 | "outputs": [], 255 | "source": [ 256 | "sp1 = SearchProblem()\n" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": 20, 262 | "metadata": {}, 263 | "outputs": [ 264 | { 265 | "name": "stdout", 266 | "output_type": "stream", 267 | "text": [ 268 | "CPU times: user 3.02 s, sys: 6.67 ms, total: 3.03 s\n", 269 | "Wall time: 3.03 s\n" 270 | ] 271 | } 272 | ], 273 | "source": [ 274 | "%%time\n", 275 | "ψ_1 = Q_iterator(sp1)\n" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 21, 281 | "metadata": {}, 282 | "outputs": [], 283 | "source": [ 284 | "sp2 = SearchProblem(c=0.2)\n", 285 | "ψ_2 = Q_iterator(sp2)" 286 | ] 287 | }, 288 | { 289 | "cell_type": "code", 290 | "execution_count": 14, 291 | "metadata": {}, 292 | "outputs": [ 293 | { 294 | "data": { 295 | "image/png": "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\n", 296 | "text/plain": [ 297 | "" 298 | ] 299 | }, 300 | "metadata": {}, 301 | "output_type": "display_data" 302 | } 303 | ], 304 | "source": [ 305 | "fig, ax = plt.subplots()\n", 306 | "\n", 307 | "ax.plot(sp2.π_grid, ψ_2, lw=2, alpha=0.6, label='$c = 0.2$')\n", 308 | "ax.plot(sp1.π_grid, ψ_1, lw=2, alpha=0.6, label='$c = 0.1$')\n", 309 | "\n", 310 | "ax.legend(fontsize=14)\n", 311 | "ax.set_xlabel(\"belief state $\\\\pi$\", fontsize=12)\n", 312 | "ax.set_ylabel(\"reservation wage\", fontsize=12)\n", 313 | "plt.show()" 314 | ] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "execution_count": null, 319 | "metadata": {}, 320 | "outputs": [], 321 | "source": [] 322 | } 323 | ], 324 | "metadata": { 325 | "kernelspec": { 326 | "display_name": "Python 3", 327 | "language": "python", 328 | "name": "python3" 329 | }, 330 | "language_info": { 331 | "codemirror_mode": { 332 | "name": "ipython", 333 | "version": 3 334 | }, 335 | "file_extension": ".py", 336 | "mimetype": "text/x-python", 337 | "name": "python", 338 | "nbconvert_exporter": "python", 339 | "pygments_lexer": "ipython3", 340 | "version": "3.6.5" 341 | } 342 | }, 343 | "nbformat": 4, 344 | "nbformat_minor": 2 345 | } 346 | -------------------------------------------------------------------------------- /jit_vs_vectorization/efficient_inventory_dynamics.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Efficient Simulation in the Inventory Model\n", 8 | "\n", 9 | "\n", 10 | "#### John Stachurski" 11 | ] 12 | }, 13 | { 14 | "cell_type": "markdown", 15 | "metadata": {}, 16 | "source": [ 17 | "Simulation can be time consuming, especially if we need to simulate many paths\n", 18 | "\n", 19 | "And it's often true that large sample sizes are necessary to get an accurate picture\n", 20 | "\n", 21 | "Let's look at speeding up our simulations using [Numba](https://numba.pydata.org/)" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 1, 27 | "metadata": {}, 28 | "outputs": [], 29 | "source": [ 30 | "import numpy as np\n", 31 | "from numba import jit, njit, prange" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "Parameters:" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 2, 44 | "metadata": {}, 45 | "outputs": [], 46 | "source": [ 47 | "s, S = 10, 100\n", 48 | "p = 0.4\n", 49 | "initial_x = 50.0" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "### Simulating One Path" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "Let's look at simulating one path with minimal optimization.\n", 64 | "\n", 65 | "(There's at least some efficiency gain over pure Python because we'll use a vectorized function to generate the random variables.)" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 3, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "def sim_one_inventory_path(sim_length=10_000_000):\n", 75 | " \n", 76 | " dvals = np.random.geometric(p, size=sim_length-1) - 1\n", 77 | " X = np.empty(sim_length, dtype=np.int64)\n", 78 | " X[0] = initial_x\n", 79 | " \n", 80 | " for t, d in enumerate(dvals):\n", 81 | " x = X[t]\n", 82 | " if x <= s:\n", 83 | " X[t+1] = max(S - d, 0)\n", 84 | " else:\n", 85 | " X[t+1] = max(x - d, 0)\n", 86 | " \n", 87 | " return X" 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "How fast does this run?" 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": 4, 100 | "metadata": {}, 101 | "outputs": [ 102 | { 103 | "name": "stdout", 104 | "output_type": "stream", 105 | "text": [ 106 | "CPU times: user 6.22 s, sys: 10 ms, total: 6.23 s\n", 107 | "Wall time: 6.23 s\n" 108 | ] 109 | } 110 | ], 111 | "source": [ 112 | "%%time\n", 113 | "\n", 114 | "X = sim_one_inventory_path()" 115 | ] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "Now let's build a jitted version." 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 5, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [ 130 | "@jit(nopython=True)\n", 131 | "def update(x): \n", 132 | " d = np.random.geometric(p) - 1\n", 133 | " if x <= s:\n", 134 | " y = np.maximum(S - d, 0)\n", 135 | " else:\n", 136 | " y = np.maximum(x - d, 0)\n", 137 | " return y" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 6, 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "data": { 147 | "text/plain": [ 148 | "16" 149 | ] 150 | }, 151 | "execution_count": 6, 152 | "metadata": {}, 153 | "output_type": "execute_result" 154 | } 155 | ], 156 | "source": [ 157 | "update(20)" 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": 7, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [ 166 | "@jit(nopython=True)\n", 167 | "def sim_one_path_jitted(sim_length=10_000_000):\n", 168 | " X = np.empty(sim_length, dtype=np.int64)\n", 169 | " X[0] = initial_x\n", 170 | " for t in range(sim_length-1):\n", 171 | " X[t+1] = update(X[t])" 172 | ] 173 | }, 174 | { 175 | "cell_type": "markdown", 176 | "metadata": {}, 177 | "source": [ 178 | "This is **much** faster:" 179 | ] 180 | }, 181 | { 182 | "cell_type": "code", 183 | "execution_count": 9, 184 | "metadata": { 185 | "scrolled": true 186 | }, 187 | "outputs": [ 188 | { 189 | "name": "stdout", 190 | "output_type": "stream", 191 | "text": [ 192 | "CPU times: user 390 ms, sys: 6.67 ms, total: 397 ms\n", 193 | "Wall time: 396 ms\n" 194 | ] 195 | } 196 | ], 197 | "source": [ 198 | "%%time\n", 199 | "\n", 200 | "X = sim_one_path_jitted()" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": 11, 206 | "metadata": { 207 | "scrolled": true 208 | }, 209 | "outputs": [ 210 | { 211 | "name": "stdout", 212 | "output_type": "stream", 213 | "text": [ 214 | "CPU times: user 393 ms, sys: 3.33 ms, total: 397 ms\n", 215 | "Wall time: 396 ms\n" 216 | ] 217 | } 218 | ], 219 | "source": [ 220 | "%%time\n", 221 | "\n", 222 | "X = sim_one_path_jitted()" 223 | ] 224 | }, 225 | { 226 | "cell_type": "markdown", 227 | "metadata": {}, 228 | "source": [ 229 | "### Task: Calculate Stationary Order Rate" 230 | ] 231 | }, 232 | { 233 | "cell_type": "markdown", 234 | "metadata": {}, 235 | "source": [ 236 | "As we've seen, the inventory model has a stationary distribution.\n", 237 | "\n", 238 | "Let's call it $\\psi^*$, with the corresponding random variable denoted $X^*$.\n", 239 | "\n", 240 | "For a large population with independent demand shocks,\n", 241 | "\n", 242 | "$$ \\mathbb P\\{X^* = k\\} \\simeq \\text{fraction of firms with inventory } k $$\n", 243 | "\n", 244 | "We are interested in calculating\n", 245 | "\n", 246 | "$$ \\mathbb P\\{X^* \\leq s\\} \\simeq \\text{fraction of firms currently placing orders } $$\n", 247 | "\n", 248 | "The law of large numbers for stationary and ergodic sequences tells us that\n", 249 | "\n", 250 | "$$ \\mathbb P\\{X^* \\leq s\\} \\simeq \\frac{1}{n} \\sum_{t=1}^n \\mathbb 1\\{X_t \\leq s\\} $$\n", 251 | "\n", 252 | "In other words, we can calculate the stationary probability $\\mathbb P\\{X^* \\leq s\\}$ by generating a single time series and calculating the fraction of time that it spends below $s$.\n", 253 | "\n", 254 | "We can do this fast with the jitted code above, thanks to Numba.\n", 255 | "\n", 256 | "#### Exploiting parallelization\n", 257 | "\n", 258 | "However, the above approach is difficult to parallelize because it's inherently sequential\n", 259 | "\n", 260 | "An approach that's easier to parallelize is to \n", 261 | "\n", 262 | "* pick some large value $T$\n", 263 | "\n", 264 | "* generate many independent observations $X^i_T$ of $X_T$\n", 265 | "\n", 266 | "* calculate the fraction of observations that are less than $s$\n", 267 | "\n", 268 | "This works because \n", 269 | "\n", 270 | "$$ \\mathbb P\\{X^* \\leq s\\} \\simeq \\mathbb P \\{X_T \\leq s\\} $$\n", 271 | "\n", 272 | "when $T$ is large (since, as previously discussed, $\\psi_t \\to \\psi^*$).\n", 273 | "\n", 274 | "Thus, letting $m$ be the number of paths we'll generate, our goal is to fix large $T$ and compute\n", 275 | "\n", 276 | "$$ p(m, T) = \\frac{1}{m} \\sum_{i=1}^m \\mathbb 1\\{X_T^i \\leq s\\} $$" 277 | ] 278 | }, 279 | { 280 | "cell_type": "markdown", 281 | "metadata": {}, 282 | "source": [ 283 | "### Simulating Many Paths" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": {}, 289 | "source": [ 290 | "Here's a jitted (and hence fast) piece of code for simulating many paths." 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": 12, 296 | "metadata": {}, 297 | "outputs": [], 298 | "source": [ 299 | "@njit\n", 300 | "def sim_prob(m=500_000, T=1000):\n", 301 | " \n", 302 | " is_below_s = 0\n", 303 | " for i in range(m):\n", 304 | " x = initial_x\n", 305 | " for t in range(T):\n", 306 | " x = update(x)\n", 307 | " if x <= s:\n", 308 | " is_below_s += 1\n", 309 | " p_m_T = is_below_s / m\n", 310 | " return p_m_T\n" 311 | ] 312 | }, 313 | { 314 | "cell_type": "markdown", 315 | "metadata": {}, 316 | "source": [ 317 | "Let's get a reading on the time." 318 | ] 319 | }, 320 | { 321 | "cell_type": "code", 322 | "execution_count": 13, 323 | "metadata": {}, 324 | "outputs": [ 325 | { 326 | "name": "stdout", 327 | "output_type": "stream", 328 | "text": [ 329 | "CPU times: user 20 s, sys: 16.7 ms, total: 20.1 s\n", 330 | "Wall time: 20.1 s\n" 331 | ] 332 | } 333 | ], 334 | "source": [ 335 | "%%time\n", 336 | "\n", 337 | "p = sim_prob()\n" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": 14, 343 | "metadata": {}, 344 | "outputs": [ 345 | { 346 | "data": { 347 | "text/plain": [ 348 | "0.01652" 349 | ] 350 | }, 351 | "execution_count": 14, 352 | "metadata": {}, 353 | "output_type": "execute_result" 354 | } 355 | ], 356 | "source": [ 357 | "p" 358 | ] 359 | }, 360 | { 361 | "cell_type": "markdown", 362 | "metadata": {}, 363 | "source": [ 364 | "Now let's try a simple parallelization:" 365 | ] 366 | }, 367 | { 368 | "cell_type": "code", 369 | "execution_count": 15, 370 | "metadata": {}, 371 | "outputs": [], 372 | "source": [ 373 | "@njit(parallel=True)\n", 374 | "def sim_prob_parallel(m=500_000, T=1000):\n", 375 | " \n", 376 | " is_below_s = 0\n", 377 | " for i in prange(m):\n", 378 | " x = initial_x\n", 379 | " for t in range(T):\n", 380 | " x = update(x)\n", 381 | " if x <= s:\n", 382 | " is_below_s += 1\n", 383 | " p_m_T = is_below_s / m\n", 384 | " return p_m_T\n" 385 | ] 386 | }, 387 | { 388 | "cell_type": "code", 389 | "execution_count": 16, 390 | "metadata": {}, 391 | "outputs": [ 392 | { 393 | "name": "stdout", 394 | "output_type": "stream", 395 | "text": [ 396 | "CPU times: user 21.1 s, sys: 6.67 ms, total: 21.1 s\n", 397 | "Wall time: 5.53 s\n" 398 | ] 399 | } 400 | ], 401 | "source": [ 402 | "%%time\n", 403 | "\n", 404 | "p = sim_prob_parallel()" 405 | ] 406 | }, 407 | { 408 | "cell_type": "code", 409 | "execution_count": 17, 410 | "metadata": {}, 411 | "outputs": [ 412 | { 413 | "data": { 414 | "text/plain": [ 415 | "0.016224" 416 | ] 417 | }, 418 | "execution_count": 17, 419 | "metadata": {}, 420 | "output_type": "execute_result" 421 | } 422 | ], 423 | "source": [ 424 | "p" 425 | ] 426 | }, 427 | { 428 | "cell_type": "markdown", 429 | "metadata": {}, 430 | "source": [ 431 | "Let's try for a more efficient parallelization, where the work is divided into a smaller number of chunks." 432 | ] 433 | }, 434 | { 435 | "cell_type": "code", 436 | "execution_count": 18, 437 | "metadata": {}, 438 | "outputs": [], 439 | "source": [ 440 | "@njit(parallel=True)\n", 441 | "def sim_prob_parallel(m=500_000, T=1000, chunks=500):\n", 442 | " \n", 443 | " chunk_size = m // chunks\n", 444 | " p_m_T_vals = np.empty(chunks)\n", 445 | " \n", 446 | " for i in prange(chunks):\n", 447 | " p_m_T_vals[i] = sim_prob(m=chunk_size)\n", 448 | "\n", 449 | " return p_m_T_vals.mean()" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": 19, 455 | "metadata": {}, 456 | "outputs": [ 457 | { 458 | "name": "stdout", 459 | "output_type": "stream", 460 | "text": [ 461 | "CPU times: user 21.2 s, sys: 13.3 ms, total: 21.2 s\n", 462 | "Wall time: 5.7 s\n" 463 | ] 464 | } 465 | ], 466 | "source": [ 467 | "%%time\n", 468 | "\n", 469 | "X = sim_prob_parallel()\n" 470 | ] 471 | }, 472 | { 473 | "cell_type": "markdown", 474 | "metadata": {}, 475 | "source": [ 476 | "There's essentially no difference --- so `prange` is already optimizing the load across CPUs for us!" 477 | ] 478 | }, 479 | { 480 | "cell_type": "code", 481 | "execution_count": null, 482 | "metadata": {}, 483 | "outputs": [], 484 | "source": [] 485 | } 486 | ], 487 | "metadata": { 488 | "kernelspec": { 489 | "display_name": "Python 3", 490 | "language": "python", 491 | "name": "python3" 492 | }, 493 | "language_info": { 494 | "codemirror_mode": { 495 | "name": "ipython", 496 | "version": 3 497 | }, 498 | "file_extension": ".py", 499 | "mimetype": "text/x-python", 500 | "name": "python", 501 | "nbconvert_exporter": "python", 502 | "pygments_lexer": "ipython3", 503 | "version": "3.6.4" 504 | } 505 | }, 506 | "nbformat": 4, 507 | "nbformat_minor": 2 508 | } 509 | -------------------------------------------------------------------------------- /lectures/lecture1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture1.pdf -------------------------------------------------------------------------------- /lectures/lecture10.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture10.pdf -------------------------------------------------------------------------------- /lectures/lecture12.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture12.pdf -------------------------------------------------------------------------------- /lectures/lecture13.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture13.pdf -------------------------------------------------------------------------------- /lectures/lecture14.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture14.pdf -------------------------------------------------------------------------------- /lectures/lecture2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture2.pdf -------------------------------------------------------------------------------- /lectures/lecture3.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture3.pdf -------------------------------------------------------------------------------- /lectures/lecture4.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture4.pdf -------------------------------------------------------------------------------- /lectures/lecture5.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture5.pdf -------------------------------------------------------------------------------- /lectures/lecture6.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture6.pdf -------------------------------------------------------------------------------- /lectures/lecture7.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture7.pdf -------------------------------------------------------------------------------- /lectures/lecture8.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture8.pdf -------------------------------------------------------------------------------- /lectures/lecture9.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/lectures/lecture9.pdf -------------------------------------------------------------------------------- /notes.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jstac/nyu_macro_fall_2018/45c94ea6b3577216156a0b00fc3905de00fb6ba5/notes.pdf -------------------------------------------------------------------------------- /sept_7_seminar/supply_and_demand_solution_1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Writing Clean Code: Solution with Functions" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "#### John Stachurski" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 1, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "import numpy as np\n", 24 | "import matplotlib.pyplot as plt\n", 25 | "from scipy.optimize import bisect" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "First let's define supply and demand functions" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 2, 38 | "metadata": {}, 39 | "outputs": [], 40 | "source": [ 41 | "def qs(p, α, β):\n", 42 | " return np.exp(α * p) - β\n", 43 | "\n", 44 | "def qd(p, γ, δ):\n", 45 | " return γ * p**(-δ)\n" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Here's a function to compute the equilibrium:" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": 3, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [ 61 | "def compute_equilibrium(α=0.1, β=1, γ=1, δ=1):\n", 62 | " # Define excess demand function\n", 63 | " def h(p):\n", 64 | " return qd(p, γ, δ) - qs(p, α, β)\n", 65 | " \n", 66 | " p_star = bisect(h, 2, 4)\n", 67 | " q_star = qs(p_star, α, β)\n", 68 | " \n", 69 | " print(f'Equilibrium price is {p_star: .2f}')\n", 70 | " print(f'Equilibrium quantity is {q_star: .2f}')" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 4, 76 | "metadata": {}, 77 | "outputs": [ 78 | { 79 | "name": "stdout", 80 | "output_type": "stream", 81 | "text": [ 82 | "Equilibrium price is 2.93\n", 83 | "Equilibrium quantity is 0.34\n" 84 | ] 85 | } 86 | ], 87 | "source": [ 88 | "compute_equilibrium()" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 5, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [ 97 | "def plot_equilibrium(α=0.1, β=1, γ=1, δ=1):\n", 98 | " grid = np.linspace(2, 4, 100)\n", 99 | " fig, ax = plt.subplots(figsize=(8, 6))\n", 100 | "\n", 101 | " ax.plot(grid, qd(grid, γ, δ), 'b-', lw=2, label='demand')\n", 102 | " ax.plot(grid, qs(grid, α, β), 'g-', lw=2, label='supply')\n", 103 | "\n", 104 | " ax.set_xlabel('price', fontsize=14)\n", 105 | " ax.set_ylabel('quantity', fontsize=14)\n", 106 | " ax.legend(loc='upper center')\n", 107 | "\n", 108 | " plt.show()" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 6, 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "data": { 118 | "image/png": "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\n", 119 | "text/plain": [ 120 | "" 121 | ] 122 | }, 123 | "metadata": {}, 124 | "output_type": "display_data" 125 | } 126 | ], 127 | "source": [ 128 | "plot_equilibrium()" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 7, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | "Equilibrium price is 2.66\n", 141 | "Equilibrium quantity is 0.38\n" 142 | ] 143 | } 144 | ], 145 | "source": [ 146 | "compute_equilibrium(α=0.12)" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": 8, 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "data": { 156 | "image/png": "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\n", 157 | "text/plain": [ 158 | "" 159 | ] 160 | }, 161 | "metadata": {}, 162 | "output_type": "display_data" 163 | } 164 | ], 165 | "source": [ 166 | "plot_equilibrium(α=0.12)" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": null, 172 | "metadata": {}, 173 | "outputs": [], 174 | "source": [] 175 | } 176 | ], 177 | "metadata": { 178 | "anaconda-cloud": {}, 179 | "kernelspec": { 180 | "display_name": "Python 3", 181 | "language": "python", 182 | "name": "python3" 183 | }, 184 | "language_info": { 185 | "codemirror_mode": { 186 | "name": "ipython", 187 | "version": 3 188 | }, 189 | "file_extension": ".py", 190 | "mimetype": "text/x-python", 191 | "name": "python", 192 | "nbconvert_exporter": "python", 193 | "pygments_lexer": "ipython3", 194 | "version": "3.6.4" 195 | } 196 | }, 197 | "nbformat": 4, 198 | "nbformat_minor": 1 199 | } 200 | --------------------------------------------------------------------------------