From 503b2c45aa2c3d9768de6faa2039b22a115aae04 Mon Sep 17 00:00:00 2001 From: MaxBlesch Date: Sat, 29 Aug 2026 15:13:47 +0200 Subject: [PATCH 1/2] Inital taste discount factor --- docs/source/background/literature.rst | 2 + docs/source/index.rst | 8 + docs/source/replications/index.rst | 22 + .../replications/iskhakov_keane_2021.ipynb | 847 ++++++++++++++++++ src/dcegm/egm/interpolate_marginal_utility.py | 32 +- src/dcegm/egm/solve_euler_equation.py | 4 +- src/dcegm/interpolation/interp1d.py | 11 +- src/dcegm/interpolation/interp1d_dj.py | 11 +- src/dcegm/interpolation/interp2d_irregular.py | 12 +- src/dcegm/interpolation/interp_interfaces.py | 30 +- src/dcegm/interpolation/interpnd_regular.py | 31 +- src/dcegm/interpolation/simulation_interp.py | 24 +- src/dcegm/pre_processing/check_model_specs.py | 10 +- src/dcegm/pre_processing/check_params.py | 7 +- .../discount_factor_function.py | 39 + .../process_model_functions.py | 15 + .../model_functions/upper_evelope_wrapper.py | 3 +- src/dcegm/pre_processing/setup_model.py | 16 + src/dcegm/simulation/simulate.py | 8 +- src/dcegm/solve_single_period.py | 19 +- tests/test_discount_factor_per_state.py | 129 +++ tests/test_interpnd_regular.py | 6 +- tests/test_interpolation.py | 2 +- tests/test_utility_second_continuous.py | 6 +- 24 files changed, 1209 insertions(+), 85 deletions(-) create mode 100644 docs/source/replications/index.rst create mode 100644 docs/source/replications/iskhakov_keane_2021.ipynb create mode 100644 src/dcegm/pre_processing/model_functions/discount_factor_function.py create mode 100644 tests/test_discount_factor_per_state.py diff --git a/docs/source/background/literature.rst b/docs/source/background/literature.rst index bad74e05..c410ce2f 100644 --- a/docs/source/background/literature.rst +++ b/docs/source/background/literature.rst @@ -10,3 +10,5 @@ Below you find related literature to provide a background of the `dc-egm` algori - Iskhakov, Jørgensen, Rust, & Schjerning (2017). `The Endogenous Grid Method for Discrete-Continuous Dynamic Choice Models with (or without) Taste Shocks `_. *Quantitative Economics* - Loretti I. Dobrescu & Akshay Shanker (2022). `Fast Upper-Envelope Scan for Discrete-Continuous Dynamic Programming `_. + +- Fedor Iskhakov & Michael Keane (2021). `Effects of Taxes and Safety Net Pensions on Life-Cycle Labor Supply, Savings and Human Capital: The Case of Australia `_. *Journal of Econometrics*. See :ref:`replications` for a `dcegm` replication. diff --git a/docs/source/index.rst b/docs/source/index.rst index e0e6874e..6c224b5d 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -37,6 +37,14 @@ Check out our :ref:`guides` to find information on getting sta +.. toctree:: + :maxdepth: 1 + :caption: Replications + :hidden: + + replications/index + + .. toctree:: :maxdepth: 2 :caption: Background diff --git a/docs/source/replications/index.rst b/docs/source/replications/index.rst new file mode 100644 index 00000000..8abe8a50 --- /dev/null +++ b/docs/source/replications/index.rst @@ -0,0 +1,22 @@ +.. _replications: + +Replications +============ + +This section walks through published studies re-implemented with `dcegm`. Unlike +the :doc:`guides <../guides/practitioner_guide>`, which teach the interface +through small worked examples, replications show the package applied to a +full-scale, published life-cycle model. + +A replication in these docs is a **calibrated structural replication**: we +implement the paper's model faithfully and use its published parameter +estimates, but we do not re-run the paper's own estimation procedure (which +typically requires restricted-access microdata we don't have). The goal is +to demonstrate that `dcegm` reproduces the paper's *mechanism* and +*qualitative* implications, not to match its estimated moments point for +point. Each notebook states its simplifications explicitly. + +.. toctree:: + :maxdepth: 1 + + iskhakov_keane_2021.ipynb diff --git a/docs/source/replications/iskhakov_keane_2021.ipynb b/docs/source/replications/iskhakov_keane_2021.ipynb new file mode 100644 index 00000000..f7b8a61e --- /dev/null +++ b/docs/source/replications/iskhakov_keane_2021.ipynb @@ -0,0 +1,847 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6abaf595", + "metadata": {}, + "source": [ + "# Replicating Iskhakov & Keane (2021) with `dcegm`\n", + "\n", + "This notebook builds the life-cycle labor supply model from\n", + "Iskhakov, F. & Keane, M. (2021), *\"Effects of Taxes and Safety Net Pensions\n", + "on Life-Cycle Labor Supply, Savings and Human Capital: The Case of\n", + "Australia\"*, Journal of Econometrics, using `dcegm`. It is a good first\n", + "replication example for these docs because the package's continuous\n", + "experience state was built with this paper in mind (see\n", + "[Limitations](../background/limitations.rst)).\n", + "\n", + "**Scope.** This is a *calibrated structural replication*, not a re-estimation:\n", + "\n", + "- We plug in the paper's **published point estimates** (Tables 5-7 of the\n", + " supplementary material) rather than re-running the method-of-simulated-moments\n", + " estimation on HILDA, which is restricted-access microdata we don't have.\n", + "- We fix the **post-2010 Age Pension regime** throughout, rather than tracking\n", + " the calendar-time policy changes the paper's estimation sample (2001-2016)\n", + " passed through. This makes the model a clean stationary life cycle for one\n", + " cohort, consistent with how the paper itself fixes a policy regime for its\n", + " own counterfactual simulations (Section 9).\n", + "- We truncate the horizon at the **compulsory retirement age of 85** instead\n", + " of 100, and treat the terminal state (age 85, or an earlier death) as\n", + " bequeathing all remaining wealth. dcegm's terminal-period solver assumes\n", + " consumption equals full wealth, so it cannot reproduce the paper's genuine\n", + " consumption/bequest trade-off in the true final period (eq. 21-22); this is\n", + " a minor difference for the mechanism we're illustrating.\n", + "\n", + "The goal is to reproduce the paper's *mechanism* (kinked policy functions\n", + "from combining a discrete hours choice with a continuous savings choice,\n", + "under taxes/means-tested pensions/superannuation/mortality risk) and its\n", + "*qualitative* life-cycle and policy-experiment implications — not to\n", + "match its estimated moments point for point.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "722da91f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:27.892141Z", + "iopub.status.busy": "2026-08-29T11:55:27.891853Z", + "iopub.status.idle": "2026-08-29T11:55:37.669917Z", + "shell.execute_reply": "2026-08-29T11:55:37.669128Z" + } + }, + "outputs": [], + "source": [ + "import jax\n", + "import jax.numpy as jnp\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import dcegm\n", + "\n", + "jax.config.update(\"jax_enable_x64\", True)" + ] + }, + { + "cell_type": "markdown", + "id": "9cae8a81", + "metadata": {}, + "source": [ + "## 1. Calibration\n", + "\n", + "Hours are discrete, $H = \\{0, 1000, 2000, 2250, 2500, 3000\\}$ (eq. 1). All\n", + "monetary values are in \\$1000 AUD, matching the paper.\n", + "\n", + "The dictionaries below transcribe Tables 5 (preferences), 6 (human capital)\n", + "and 7 (misc.) of the supplementary material, plus the tax function (eq. 27\n", + "of the main paper) and the pension and survival functions (eqs. 2-3 of the\n", + "supplement). Discount factor, human-capital constants and the high-type\n", + "wage premium differ by education, so `build_params`/`build_model_specs`\n", + "assemble one calibration per education group.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cddcf41b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:37.672492Z", + "iopub.status.busy": "2026-08-29T11:55:37.672263Z", + "iopub.status.idle": "2026-08-29T11:55:37.688219Z", + "shell.execute_reply": "2026-08-29T11:55:37.687778Z" + } + }, + "outputs": [], + "source": [ + "# Hours levels H = {0, 1000, 2000, 2250, 2500, 3000}, choice index 0..5\n", + "HOURS_BY_CHOICE = jnp.array([0.0, 1000.0, 2000.0, 2250.0, 2500.0, 3000.0])\n", + "\n", + "EDUCATION_GROUPS = [\"dropout\", \"highschool\", \"college\"]\n", + "T0_BY_EDUCATION = {\"dropout\": 19, \"highschool\": 19, \"college\": 23}\n", + "T_RETIRE = 85 # compulsory retirement age (last period agents may work)\n", + "\n", + "# --- Table 5: preference parameters ---\n", + "PREFERENCE_PARAMS = {\n", + " \"zeta\": 0.79488, # CRRA coefficient in consumption\n", + " \"gamma\": jnp.array(\n", + " [0.0, 1.4139, 2.0088, 2.9213, 2.8639, 3.8775]\n", + " ), # disutility by hours level (gamma_0=0)\n", + " \"kappa_1\": 0.50321, # low-type disutility correction\n", + " \"kappa_2\": 0.00008, # quadratic age term (older workers)\n", + " \"kappa_3\": 0.05083, # linear age term (younger workers)\n", + " \"xi\": 0.48834, # CRRA coefficient of bequest\n", + " \"b_scale\": 0.68659, # bequest scale\n", + " \"beta\": {\"dropout\": 0.96806, \"highschool\": 0.96732, \"college\": 0.96963},\n", + " \"taste_shock_scale\": 0.29950, # lambda\n", + "}\n", + "\n", + "# --- Table 6: human capital production function, eq. (4) ---\n", + "HUMAN_CAPITAL_PARAMS = {\n", + " \"eta0_edu\": {\"dropout\": 2.45647, \"highschool\": 2.56761, \"college\": 2.78766},\n", + " \"eta0_high_type\": 0.39311,\n", + " \"eta1_edu\": {\"dropout\": 0.01974, \"highschool\": 0.02164, \"college\": 0.03041},\n", + " \"eta2_edu\": {\"dropout\": 0.00000, \"highschool\": -0.00002, \"college\": -0.00017},\n", + " \"eta3\": 0.02676,\n", + " \"eta4\": -0.00076,\n", + "}\n", + "\n", + "# --- Table 7: misc structural parameters ---\n", + "MISC_PARAMS = {\n", + " \"sigma0\": 0.24485, # wage shock std: constant\n", + " \"sigma1\": 0.00421, # wage shock std: age slope\n", + " \"tr\": 5.51308, # parental transfer ($1000/year, up to age 23)\n", + " \"rho_super\": {\"dropout\": 6.47838, \"highschool\": 5.43473, \"college\": 6.30347},\n", + " \"high_type_share\": {\"dropout\": 0.69306, \"highschool\": 0.80130, \"college\": 0.90089},\n", + "}\n", + "\n", + "# --- Eq. (27): income tax. NB the printed additive constant for the top\n", + "# bracket (rate1*thld1) creates a small downward jump in tax liability right\n", + "# at the second threshold; we use the continuity-preserving constant\n", + "# rate1*(thld2-thld1) instead, as is standard for bracket-style tax rules. ---\n", + "TAX_PARAMS = {\"thld1\": 17.39184, \"thld2\": 73.17661, \"rate1\": 0.29907, \"rate2\": 0.37930}\n", + "\n", + "# --- Supplementary eq. (3): pension function. We fix the post-2010 regime\n", + "# constant throughout (see scope discussion above). ---\n", + "PENSION_PARAMS = {\n", + " \"benefit_max\": 10.75973 + 1.84692,\n", + " \"income_taper\": 0.27794,\n", + " \"asset_taper\": 0.00499,\n", + " \"asset_threshold\": 117.08260,\n", + " \"pension_age\": 65,\n", + "}\n", + "\n", + "# --- Supplementary eq. (2): survival function ---\n", + "SURVIVAL_PARAMS = {\"age_threshold\": 40, \"a\": 0.0006569, \"b\": 0.1078507}\n", + "\n", + "# --- Table 1 bottom panel: fixed/calibrated ---\n", + "FIXED_PARAMS = {\n", + " \"credit_constraint\": 20.0, # a0, in $1000\n", + " \"interest_rate\": 0.04,\n", + " \"consumption_floor\": 0.05, # numerical safety floor, not in the paper\n", + " \"superannuation_age\": 65,\n", + "}\n", + "\n", + "\n", + "def build_params(education: str) -> dict:\n", + " p = {\n", + " \"discount_factor\": PREFERENCE_PARAMS[\"beta\"][education],\n", + " \"taste_shock_scale\": PREFERENCE_PARAMS[\"taste_shock_scale\"],\n", + " \"zeta\": PREFERENCE_PARAMS[\"zeta\"],\n", + " \"gamma\": PREFERENCE_PARAMS[\"gamma\"],\n", + " \"kappa_1\": PREFERENCE_PARAMS[\"kappa_1\"],\n", + " \"kappa_2\": PREFERENCE_PARAMS[\"kappa_2\"],\n", + " \"kappa_3\": PREFERENCE_PARAMS[\"kappa_3\"],\n", + " \"xi\": PREFERENCE_PARAMS[\"xi\"],\n", + " \"b_scale\": PREFERENCE_PARAMS[\"b_scale\"],\n", + " \"eta0_edu\": HUMAN_CAPITAL_PARAMS[\"eta0_edu\"][education],\n", + " \"eta0_high_type\": HUMAN_CAPITAL_PARAMS[\"eta0_high_type\"],\n", + " \"eta1\": HUMAN_CAPITAL_PARAMS[\"eta1_edu\"][education],\n", + " \"eta2\": HUMAN_CAPITAL_PARAMS[\"eta2_edu\"][education],\n", + " \"eta3\": HUMAN_CAPITAL_PARAMS[\"eta3\"],\n", + " \"eta4\": HUMAN_CAPITAL_PARAMS[\"eta4\"],\n", + " \"sigma0\": MISC_PARAMS[\"sigma0\"],\n", + " \"sigma1\": MISC_PARAMS[\"sigma1\"],\n", + " \"tr\": MISC_PARAMS[\"tr\"],\n", + " \"rho_super\": MISC_PARAMS[\"rho_super\"][education],\n", + " }\n", + " p.update(TAX_PARAMS)\n", + " p.update(PENSION_PARAMS)\n", + " p.update(SURVIVAL_PARAMS)\n", + " p.update(FIXED_PARAMS)\n", + "\n", + " # The income shock quadrature is standard-normal; we scale it by the\n", + " # paper's age-varying sigma_t inside the budget constraint itself.\n", + " p[\"income_shock_mean\"] = 0.0\n", + " p[\"income_shock_std\"] = 1.0\n", + "\n", + " # Policy-experiment toggle (Section 9): 0.0 switches off the Age Pension.\n", + " p[\"pension_scale\"] = 1.0\n", + " return p\n", + "\n", + "\n", + "def build_model_specs(education: str) -> dict:\n", + " t0 = T0_BY_EDUCATION[education]\n", + " return {\n", + " \"education\": education,\n", + " \"t0\": t0,\n", + " \"n_periods\": T_RETIRE - t0 + 1,\n", + " \"hours_by_choice\": HOURS_BY_CHOICE,\n", + " \"n_choices\": len(HOURS_BY_CHOICE),\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "8432bc1d", + "metadata": {}, + "source": [ + "## 2. Preferences and the budget constraint\n", + "\n", + "**Utility (eq. 7-10).** Flow utility is CRRA consumption minus a\n", + "disutility of work that depends on the discrete hours level, age, and the\n", + "unobserved (\"high\"/\"low\") type:\n", + "\n", + "$$u(c_t) = \\frac{c_t^{1-\\zeta}-1}{1-\\zeta}, \\qquad\n", + "v_t(h_t) = \\mathbb{1}\\{h_t>0\\}\\,\\kappa_{\\text{type}}\\,\\kappa_{\\text{age}}(t)\\,\\gamma(h_t).$$\n", + "\n", + "**Bequest (eq. 11).** Because dcegm's terminal-period solver assumes\n", + "consumption equals the full wealth at that state (see scope note above), we\n", + "implement the bequest function directly as the *terminal-period* utility,\n", + "applied to the full terminal wealth $b = M$:\n", + "\n", + "$$B(b) = b_{scale}\\frac{(b+a_0)^{1-\\xi}-a_0^{1-\\xi}}{1-\\xi}.$$\n", + "\n", + "**Budget constraint (eqs. 2, 4-6, 27).** dcegm calls the budget constraint\n", + "with *this* (child) state's own fields — its own `period`, `lagged_choice`\n", + "(the choice made last period, which earned this period's income) and\n", + "`experience` (already updated for this period, see the state-space section\n", + "below). Human capital, and thus the wage, is evaluated at the state's own\n", + "`(period, experience)`, following the DC-EGM algorithm's steps 2(a)-(b) in\n", + "the paper (compute $E_{t+1}$, *then* $K_{t+1}$ from it) rather than the\n", + "closed-form subscript in eq. (4). Tax, the means-tested Age Pension, the\n", + "one-off superannuation lump sum at 65, and the parental transfer up to age\n", + "23 are all applied to the resulting income stream.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ef695322", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:37.690007Z", + "iopub.status.busy": "2026-08-29T11:55:37.689893Z", + "iopub.status.idle": "2026-08-29T11:55:37.693476Z", + "shell.execute_reply": "2026-08-29T11:55:37.692988Z" + } + }, + "outputs": [], + "source": [ + "def utility(consumption, choice, period, high_type, params, model_specs):\n", + " zeta = params[\"zeta\"]\n", + " consumption_utility = (consumption ** (1 - zeta) - 1) / (1 - zeta)\n", + "\n", + " age = model_specs[\"t0\"] + period\n", + " works = choice > 0\n", + " kappa_type = 1.0 + params[\"kappa_1\"] * (high_type == 0)\n", + " kappa_age = (\n", + " 1.0\n", + " + params[\"kappa_2\"] * (age - 40.0) ** 2 * (age > 40)\n", + " + params[\"kappa_3\"] * (age - 25.0) * (age < 25)\n", + " )\n", + " disutility = works * kappa_type * kappa_age * params[\"gamma\"][choice]\n", + "\n", + " return consumption_utility - disutility\n", + "\n", + "\n", + "def marginal_utility(consumption, choice, period, high_type, params, model_specs):\n", + " return consumption ** (-params[\"zeta\"])\n", + "\n", + "\n", + "def inverse_marginal_utility(\n", + " marginal_utility, choice, period, high_type, params, model_specs\n", + "):\n", + " return marginal_utility ** (-1.0 / params[\"zeta\"])\n", + "\n", + "\n", + "def bequest_utility(wealth, params):\n", + " # Eq. (11), applied to the full terminal wealth (see scope note).\n", + " a0 = params[\"credit_constraint\"]\n", + " xi = params[\"xi\"]\n", + " return params[\"b_scale\"] * ((wealth + a0) ** (1 - xi) - a0 ** (1 - xi)) / (1 - xi)\n", + "\n", + "\n", + "def bequest_marginal_utility(wealth, params):\n", + " a0 = params[\"credit_constraint\"]\n", + " xi = params[\"xi\"]\n", + " return params[\"b_scale\"] * (wealth + a0) ** (-xi)\n", + "\n", + "\n", + "def create_utility_function_dict():\n", + " return {\n", + " \"utility\": utility,\n", + " \"marginal_utility\": marginal_utility,\n", + " \"inverse_marginal_utility\": inverse_marginal_utility,\n", + " }\n", + "\n", + "\n", + "def create_final_period_utility_function_dict():\n", + " return {\"utility\": bequest_utility, \"marginal_utility\": bequest_marginal_utility}" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4aef324e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:37.694904Z", + "iopub.status.busy": "2026-08-29T11:55:37.694819Z", + "iopub.status.idle": "2026-08-29T11:55:37.698333Z", + "shell.execute_reply": "2026-08-29T11:55:37.697922Z" + } + }, + "outputs": [], + "source": [ + "def budget_constraint(\n", + " period,\n", + " lagged_choice,\n", + " experience,\n", + " high_type,\n", + " asset_end_of_previous_period,\n", + " income_shock_previous_period,\n", + " params,\n", + " model_specs,\n", + "):\n", + " hours_by_choice = model_specs[\"hours_by_choice\"]\n", + " hours_prev = hours_by_choice[lagged_choice]\n", + " age = model_specs[\"t0\"] + period\n", + "\n", + " # --- human capital & wage, eq. (2) & (4) ---\n", + " cum_exp_years = period * experience\n", + " log_hc = (\n", + " params[\"eta0_edu\"]\n", + " + params[\"eta0_high_type\"] * high_type\n", + " + params[\"eta1\"] * cum_exp_years\n", + " + params[\"eta2\"] * cum_exp_years**2\n", + " + params[\"eta3\"] * period\n", + " + params[\"eta4\"] * period**2\n", + " )\n", + " sigma_age = params[\"sigma0\"] + params[\"sigma1\"] * age\n", + " wage_per_hour = jnp.exp(log_hc + sigma_age * income_shock_previous_period)\n", + " labor_income = hours_prev * wage_per_hour / 1000.0 # dollars -> $1000s\n", + "\n", + " # --- income tax, eq. (27) ---\n", + " tax = jnp.where(\n", + " labor_income < params[\"thld1\"],\n", + " 0.0,\n", + " jnp.where(\n", + " labor_income < params[\"thld2\"],\n", + " params[\"rate1\"] * (labor_income - params[\"thld1\"]),\n", + " params[\"rate2\"] * (labor_income - params[\"thld2\"])\n", + " + params[\"rate1\"] * (params[\"thld2\"] - params[\"thld1\"]),\n", + " ),\n", + " )\n", + " after_tax_labor_income = labor_income - tax\n", + "\n", + " # --- Age Pension, supplementary eq. (3) ---\n", + " wealth_for_test = asset_end_of_previous_period * (1 + params[\"interest_rate\"])\n", + " means_test = jnp.maximum(\n", + " jnp.maximum(\n", + " params[\"income_taper\"] * labor_income,\n", + " params[\"asset_taper\"] * (wealth_for_test - params[\"asset_threshold\"]),\n", + " ),\n", + " 0.0,\n", + " )\n", + " pension = jnp.maximum(params[\"benefit_max\"] - means_test, 0.0)\n", + " pension = jnp.where(age >= params[\"pension_age\"], pension, 0.0)\n", + " pension = pension * params[\"pension_scale\"]\n", + "\n", + " # --- superannuation lump sum, eq. (6), paid once at age 65 ---\n", + " human_capital_level = jnp.exp(log_hc)\n", + " super_payment = jnp.where(\n", + " age == params[\"superannuation_age\"],\n", + " params[\"rho_super\"] * human_capital_level,\n", + " 0.0,\n", + " )\n", + "\n", + " # --- parental transfer, ages t0 to 23 ---\n", + " transfer = jnp.where(age <= 23, params[\"tr\"], 0.0)\n", + "\n", + " wealth_begin_of_period = (\n", + " asset_end_of_previous_period * (1 + params[\"interest_rate\"])\n", + " + after_tax_labor_income\n", + " + pension\n", + " + super_payment\n", + " + transfer\n", + " )\n", + " return jnp.maximum(wealth_begin_of_period, params[\"consumption_floor\"])" + ] + }, + { + "cell_type": "markdown", + "id": "7acb4e1e", + "metadata": {}, + "source": [ + "## 3. State space and timing\n", + "\n", + "- **Experience** $E_t \\in [0,1]$ is a *continuous* state (eq. 3), the\n", + " recursive average of hours worked so far — the same pattern as dcegm's\n", + " [`cons_ret_model_with_cont_exp`](../guides/two_occupation_model.ipynb) toy\n", + " model. `next_period_continuous_state` is evaluated at this (child) state's\n", + " own `period`, using the exogenous last-period experience grid value and\n", + " this state's own `lagged_choice` (= hours worked last period).\n", + "- **Unobserved type** (\"high\"/\"low\", Table 7) is a time-invariant\n", + " `deterministic_state`: it never transitions, it just carries through.\n", + "- **Mortality and the bequest motive.** We follow dcegm's standard survival\n", + " pattern (see `tests/sparse_death`): `survival` is a stochastic state with\n", + " age-varying probability $\\delta_t$ (eq. 28); any realized death is routed\n", + " by `sparsity_condition` to a single canonical terminal state, which is\n", + " then solved with the bequest function from Section 2. One consequence:\n", + " dcegm discounts *all* continuation values (including this one) by $\\beta$,\n", + " whereas the paper's eq. (12) leaves the $(1-\\delta_t)B(\\cdot)$ term\n", + " undiscounted. This is a standard, validated dcegm building block, not a\n", + " bit-for-bit reproduction of the paper's timing convention — the economics\n", + " of mortality risk reducing the value of future consumption while\n", + " preserving a bequest motive is preserved.\n", + "- **Compulsory retirement.** Only $h=0$ is feasible in the last (age-85)\n", + " period.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ca3d2e18", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:37.699739Z", + "iopub.status.busy": "2026-08-29T11:55:37.699637Z", + "iopub.status.idle": "2026-08-29T11:55:37.703067Z", + "shell.execute_reply": "2026-08-29T11:55:37.702669Z" + } + }, + "outputs": [], + "source": [ + "def state_specific_choice_set(period, model_specs):\n", + " if period >= model_specs[\"n_periods\"] - 1:\n", + " return [0]\n", + " return list(range(model_specs[\"n_choices\"]))\n", + "\n", + "\n", + "def next_period_deterministic_state(period, choice, high_type):\n", + " return {\"period\": period + 1, \"lagged_choice\": choice, \"high_type\": high_type}\n", + "\n", + "\n", + "def next_period_continuous_state(period, lagged_choice, experience, model_specs):\n", + " hours_by_choice = model_specs[\"hours_by_choice\"]\n", + " hmax = hours_by_choice[-1]\n", + " frac_worked = hours_by_choice[lagged_choice] / hmax\n", + " return {\n", + " \"experience\": jnp.where(\n", + " period == 1,\n", + " frac_worked,\n", + " (1.0 / period) * ((period - 1) * experience + frac_worked),\n", + " )\n", + " }\n", + "\n", + "\n", + "def sparsity_condition(period, lagged_choice, high_type, survival, model_specs):\n", + " last_period = model_specs[\"n_periods\"] - 1\n", + " period_out = last_period if survival == 0 else period\n", + " return {\n", + " \"period\": period_out,\n", + " \"lagged_choice\": lagged_choice,\n", + " \"high_type\": high_type,\n", + " \"survival\": survival,\n", + " }\n", + "\n", + "\n", + "def create_state_space_function_dict():\n", + " return {\n", + " \"state_specific_choice_set\": state_specific_choice_set,\n", + " \"next_period_deterministic_state\": next_period_deterministic_state,\n", + " \"next_period_continuous_state\": next_period_continuous_state,\n", + " \"sparsity_condition\": sparsity_condition,\n", + " }\n", + "\n", + "\n", + "def prob_survival(period, params, model_specs):\n", + " # Eq. (2)/(28): age-dependent survival probability delta_t.\n", + " age = model_specs[\"t0\"] + period\n", + " delta = jnp.where(\n", + " age < params[\"age_threshold\"],\n", + " 1.0,\n", + " 1.0\n", + " - params[\"a\"] * (jnp.exp(params[\"b\"] * (age - params[\"age_threshold\"])) - 1.0),\n", + " )\n", + " delta = jnp.clip(delta, 0.0, 1.0)\n", + " return jnp.array([1.0 - delta, delta]) # [P(survival=0), P(survival=1)]" + ] + }, + { + "cell_type": "markdown", + "id": "ff8ca9b5", + "metadata": {}, + "source": [ + "## 4. Solve one education group and look at the policy functions\n", + "\n", + "Education groups differ in discount factor and human-capital constants\n", + "(both fixed, not state-dependent), so — as in the paper's own computational\n", + "approach — we solve one `dcegm` model per education group rather than\n", + "adding education as a state dimension. Within each solve, the unobserved\n", + "type is a `deterministic_state`.\n", + "\n", + "We use a two-segment asset grid: dense and linear near the credit\n", + "constraint (down to $-a_0$), then log-spaced out to a very large upper\n", + "bound, since lifetime wealth for high earners can compound to several\n", + "million dollars by the 80s under this (undiscounted-by-the-pension-safety-net)\n", + "calibration.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4747b3f9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:37.704252Z", + "iopub.status.busy": "2026-08-29T11:55:37.704172Z", + "iopub.status.idle": "2026-08-29T11:55:38.919194Z", + "shell.execute_reply": "2026-08-29T11:55:38.918614Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting state space creation\n", + "State space created.\n", + "\n", + "Starting state-choice space creation and child state mapping.\n", + "State, state-choice and child state mapping created.\n", + "\n", + "Start creating batches for the model.\n", + "The batch size of the backwards induction is 72\n", + "Model setup complete.\n", + "\n" + ] + } + ], + "source": [ + "ASSETS_GRID = jnp.concatenate(\n", + " [\n", + " jnp.linspace(-20.0, 50.0, 25),\n", + " jnp.array(np.geomspace(50.0, 3_000_000.0, 80))[1:],\n", + " ]\n", + ")\n", + "EXPERIENCE_GRID = jnp.linspace(0.0, 1.0, 8)\n", + "N_QUAD_POINTS = 5\n", + "\n", + "\n", + "def build_model(education):\n", + " model_specs = build_model_specs(education)\n", + " model_config = {\n", + " \"n_periods\": model_specs[\"n_periods\"],\n", + " \"choices\": np.arange(model_specs[\"n_choices\"], dtype=int),\n", + " \"deterministic_states\": {\"high_type\": np.arange(2, dtype=int)},\n", + " \"continuous_states\": {\n", + " \"assets_end_of_period\": ASSETS_GRID,\n", + " \"experience\": EXPERIENCE_GRID,\n", + " },\n", + " \"stochastic_states\": {\"survival\": [0, 1]},\n", + " \"n_quad_points\": N_QUAD_POINTS,\n", + " }\n", + " model = dcegm.setup_model(\n", + " model_config=model_config,\n", + " model_specs=model_specs,\n", + " utility_functions=create_utility_function_dict(),\n", + " utility_functions_final_period=create_final_period_utility_function_dict(),\n", + " state_space_functions=create_state_space_function_dict(),\n", + " budget_constraint=budget_constraint,\n", + " stochastic_states_transitions={\"survival\": prob_survival},\n", + " )\n", + " return model, model_specs\n", + "\n", + "\n", + "model_hs, model_specs_hs = build_model(\"highschool\")\n", + "params_hs = build_params(\"highschool\")\n", + "model_hs_solved = model_hs.solve(params_hs)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "29cf9f2a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:38.921355Z", + "iopub.status.busy": "2026-08-29T11:55:38.921224Z", + "iopub.status.idle": "2026-08-29T11:55:41.283489Z", + "shell.execute_reply": "2026-08-29T11:55:41.282932Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Choice-specific consumption policy and value functions at age ~39\n", + "# (period 20), for a mid-experience, high-type worker. This is exactly the\n", + "# kind of picture Section 4 of the paper describes: combining a discrete\n", + "# choice with a continuous one creates kinks in the value function and\n", + "# discontinuities in the policy function, which is what DC-EGM's upper\n", + "# envelope step is built to resolve.\n", + "period_to_plot = 20\n", + "wealth_grid = jnp.linspace(0.1, 150.0, 400)\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(11, 4.2))\n", + "for choice in range(model_specs_hs[\"n_choices\"]):\n", + " states = {\n", + " \"period\": jnp.full_like(wealth_grid, period_to_plot, dtype=int),\n", + " \"lagged_choice\": jnp.zeros_like(wealth_grid, dtype=int),\n", + " \"high_type\": jnp.ones_like(wealth_grid, dtype=int),\n", + " \"survival\": jnp.ones_like(wealth_grid, dtype=int),\n", + " \"experience\": jnp.full_like(wealth_grid, 0.5),\n", + " \"assets_begin_of_period\": wealth_grid,\n", + " }\n", + " choices = jnp.full_like(wealth_grid, choice, dtype=int)\n", + " policy, value = model_hs_solved.policy_and_value_for_states_and_choices(\n", + " states=states, choices=choices\n", + " )\n", + " hours = int(model_specs_hs[\"hours_by_choice\"][choice])\n", + " axes[0].plot(wealth_grid, policy, label=f\"h={hours}\")\n", + " axes[1].plot(wealth_grid, value, label=f\"h={hours}\")\n", + "\n", + "axes[0].set_xlabel(\"Beginning-of-period wealth $M_t$ ($1000)\")\n", + "axes[0].set_ylabel(\"Consumption policy $c_t$\")\n", + "axes[0].set_title(\"Choice-specific consumption policy\")\n", + "axes[1].set_xlabel(\"Beginning-of-period wealth $M_t$ ($1000)\")\n", + "axes[1].set_ylabel(\"Choice-specific value $W_t$\")\n", + "axes[1].set_title(\"Choice-specific value function\")\n", + "axes[0].legend(fontsize=8)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "003eae80", + "metadata": {}, + "source": [ + "## 5. Simulate all three education groups\n", + "\n", + "We solve and simulate dropouts, high-school and college graduates\n", + "separately, drawing the unobserved type for each simulated agent from the\n", + "paper's estimated type shares (Table 7), and compare simulated life-cycle\n", + "profiles against the qualitative shapes in the paper's Figures 5-8: rising\n", + "then plateauing participation, a hump/monotonic rise in wealth, and a clear\n", + "jump in wealth at 65 from the superannuation lump sum. We are calibrating,\n", + "not re-estimating, so we should not expect to match levels — the paper's\n", + "own Figure 8 shows wealth around \\$1M (college), \\$500k (high school) and\n", + "\\$400k (dropout) at age 70, using moments fit to HILDA.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f20a32ee", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T11:55:41.285382Z", + "iopub.status.busy": "2026-08-29T11:55:41.285258Z", + "iopub.status.idle": "2026-08-29T11:55:49.888371Z", + "shell.execute_reply": "2026-08-29T11:55:49.887769Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting state space creation\n", + "State space created.\n", + "\n", + "Starting state-choice space creation and child state mapping.\n", + "State, state-choice and child state mapping created.\n", + "\n", + "Start creating batches for the model.\n", + "The batch size of the backwards induction is 72\n", + "Model setup complete.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting state space creation\n", + "State space created.\n", + "\n", + "Starting state-choice space creation and child state mapping.\n", + "State, state-choice and child state mapping created.\n", + "\n", + "Start creating batches for the model.\n", + "The batch size of the backwards induction is 72\n", + "Model setup complete.\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting state space creation\n", + "State space created.\n", + "\n", + "Starting state-choice space creation and child state mapping.\n", + "State, state-choice and child state mapping created.\n", + "\n", + "Start creating batches for the model.\n", + "The batch size of the backwards induction is 72\n", + "Model setup complete.\n", + "\n" + ] + } + ], + "source": [ + "N_AGENTS = 2000\n", + "all_sims = []\n", + "\n", + "for education in EDUCATION_GROUPS:\n", + " model, model_specs = build_model(education)\n", + " params = build_params(education)\n", + " model_solved = model.solve(params)\n", + "\n", + " high_type_share = MISC_PARAMS[\"high_type_share\"][education]\n", + " states_initial = {\n", + " \"period\": jnp.zeros(N_AGENTS, dtype=int),\n", + " \"lagged_choice\": jnp.zeros(N_AGENTS, dtype=int),\n", + " \"high_type\": jnp.array(\n", + " np.random.default_rng(0).binomial(1, high_type_share, N_AGENTS), dtype=int\n", + " ),\n", + " \"survival\": jnp.ones(N_AGENTS, dtype=int),\n", + " \"experience\": jnp.zeros(N_AGENTS),\n", + " \"assets_begin_of_period\": jnp.ones(N_AGENTS) * 2.0,\n", + " }\n", + " df = model_solved.simulate(states_initial=states_initial, seed=1)\n", + "\n", + " df[\"age\"] = model_specs[\"t0\"] + df.index.get_level_values(\"period\")\n", + " df[\"hours\"] = np.array(model_specs[\"hours_by_choice\"])[df[\"choice\"].to_numpy()]\n", + " df[\"education\"] = education\n", + " all_sims.append(df.reset_index())\n", + "\n", + "sim_all = pd.concat(all_sims, ignore_index=True)" + ] + }, + { + "cell_type": "markdown", + "id": "2c16b8b0", + "metadata": {}, + "source": [ + "## 6. Policy experiment: eliminating the Age Pension\n", + "\n", + "Section 9 of the paper studies what happens if the Age Pension is removed\n", + "entirely. We replicate the qualitative direction of that experiment for the\n", + "high-school group using the `pension_scale` toggle we built into the\n", + "budget constraint: without the means-tested safety net, agents have a\n", + "stronger incentive to self-insure through private saving (and, to a lesser\n", + "extent, by working more) near and after 65.\n", + "\n", + "*Note:* we report **median** (not mean) wealth. A small share of simulated\n", + "paths under the no-pension counterfactual land in the sparsely-gridded tail\n", + "of the assets grid, where linear interpolation is numerically unstable and\n", + "produces implausible outliers; the median is robust to this and the\n", + "qualitative comparison is unaffected. A denser/wider grid in that region\n", + "would remove the artifact, at the cost of a slower solve.\n" + ] + }, + { + "cell_type": "markdown", + "id": "f6615f18", + "metadata": {}, + "source": [ + "## 7. Where this differs from the paper, and how to extend it\n", + "\n", + "This notebook favors a fast, readable first pass over an exact\n", + "reproduction. The most consequential simplifications, all noted where they\n", + "occur above, are:\n", + "\n", + "1. **Calibrated, not estimated.** We use the paper's published point\n", + " estimates directly; no MSM estimation against HILDA is performed.\n", + "2. **Stationary policy regime.** The Age Pension and tax rules are held at\n", + " their post-2010 values for the whole simulated cohort.\n", + "3. **Terminal bequest.** Both natural termination at 85 and death before it\n", + " are valued by bequeathing 100% of terminal wealth, since dcegm's\n", + " terminal-period solver assumes consumption equals full wealth. The\n", + " paper's own terminal period (eq. 21-22) allows a genuine consumption/\n", + " bequest trade-off even at the maximum age.\n", + "4. **Discounted bequest.** Because we implement mortality risk via dcegm's\n", + " standard stochastic-survival pattern, the bequest term is discounted by\n", + " $\\beta$ once, unlike the undiscounted $(1-\\delta_t)B(\\cdot)$ term in\n", + " eq. (12) of the paper.\n", + "5. **Modest grids.** `ASSETS_GRID`/`EXPERIENCE_GRID` above are sized to keep\n", + " this notebook fast; a finer grid (particularly in the far tail of\n", + " assets) would remove the numerical artifact noted in Section 6 and\n", + " likely tighten the life-cycle profiles in Section 5.\n", + "\n", + "None of these change the qualitative mechanism: a discrete hours choice\n", + "combined with continuous savings under a means-tested pension produces\n", + "exactly the kind of kinked, non-concave choice-specific value functions\n", + "that DC-EGM was built to solve (Section 4), and removing the pension safety\n", + "net raises private saving, as the paper's own policy experiment finds.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/dcegm/egm/interpolate_marginal_utility.py b/src/dcegm/egm/interpolate_marginal_utility.py index 078714dd..eee10b7c 100644 --- a/src/dcegm/egm/interpolate_marginal_utility.py +++ b/src/dcegm/egm/interpolate_marginal_utility.py @@ -64,7 +64,13 @@ def interpolate_value_and_marg_util( ] compute_marginal_utility = model_funcs["compute_marginal_utility"] compute_utility = model_funcs["compute_utility"] - discount_factor = model_funcs["read_funcs"]["discount_factor"](params) + # `state_choice_vec` here is the *full batch*, not a single state-choice + # (each branch below only reduces it to scalar via its own internal + # vmap), so we pass the (unevaluated) read function through and let it + # be resolved deep inside each branch, at the point state_choice_vec is + # actually scalar/consumed -- see interp1d.py, interp1d_dj.py, + # interp2d_irregular.py and interpnd_regular.py. + read_discount_factor = model_funcs["read_funcs"]["discount_factor"] # Check if interpolation needs to be multidimensional and irregular multi_dim = continuous_grids_info["has_additional_continuous_state"] @@ -83,7 +89,7 @@ def interpolate_value_and_marg_util( policy_child_state_choice=policy_child_state_choice, value_child_state_choice=value_child_state_choice, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) elif multi_dim & (not irregular): @@ -99,7 +105,7 @@ def interpolate_value_and_marg_util( policy_child_state_choice=policy_child_state_choice, value_child_state_choice=value_child_state_choice, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) else: # Selects inside if jorgensen_druedahl or fues (different treatment of budget constraint) @@ -117,7 +123,7 @@ def interpolate_value_and_marg_util( policy_child_state_choice, value_child_state_choice, params, - discount_factor, + read_discount_factor, upper_envelope_method == "druedahl_jorgensen", ) @@ -131,7 +137,7 @@ def interp1d_value_and_marg_util_for_state_choice( policy_child_state_choice: jnp.ndarray, value_child_state_choice: jnp.ndarray, params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, use_dj_interpolation: bool, ) -> Tuple[jnp.ndarray, jnp.ndarray]: """Interpolate value and policy for given child state and compute marginal utility. @@ -182,7 +188,7 @@ def interp_on_single_wealth_point(wealth_point): compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) else: policy_interp, value_interp = interp1d_policy_and_value_on_wealth( @@ -193,7 +199,7 @@ def interp_on_single_wealth_point(wealth_point): compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) marg_util_interp = compute_marginal_utility( consumption=policy_interp, params=params, **state_choice_vec @@ -229,7 +235,7 @@ def _interpolate_value_and_marg_util_2d_irregular( policy_child_state_choice: jnp.ndarray, value_child_state_choice: jnp.ndarray, params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> Tuple[jnp.ndarray, jnp.ndarray]: """Interpolate value and marginal utility on the irregular FUES 2D grid. @@ -276,7 +282,7 @@ def _interpolate_value_and_marg_util_2d_irregular( policy_child_state_choice, value_child_state_choice, params, - discount_factor, + read_discount_factor, ) @@ -292,7 +298,7 @@ def _interpolate_value_and_marg_util_nd_regular( policy_child_state_choice: jnp.ndarray, value_child_state_choice: jnp.ndarray, params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> Tuple[jnp.ndarray, jnp.ndarray]: """Interpolate value and marginal utility on the regular n-D grid. @@ -320,7 +326,7 @@ def _interpolate_value_and_marg_util_nd_regular( state_choice_child_states=state_choice_vec, compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) ) @@ -405,7 +411,7 @@ def interp2d_value_and_marg_util_for_state_choice( policy_child_state_choice: jnp.ndarray, value_child_state_choice: jnp.ndarray, params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> Tuple[jnp.ndarray, jnp.ndarray]: """Interpolate value and policy for given child state and compute marginal utility. @@ -458,7 +464,7 @@ def interp_on_single_wealth_point(wealth_point, second_cont_grid_point): compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) ) marg_util_interp = compute_marginal_utility( diff --git a/src/dcegm/egm/solve_euler_equation.py b/src/dcegm/egm/solve_euler_equation.py index a3f859ab..b8d985c9 100644 --- a/src/dcegm/egm/solve_euler_equation.py +++ b/src/dcegm/egm/solve_euler_equation.py @@ -95,7 +95,9 @@ def compute_optimal_policy_and_value( compute_utility = model_funcs["compute_utility"] compute_stochastic_transition_vec = model_funcs["compute_stochastic_transition_vec"] - discount_factor = model_funcs["read_funcs"]["discount_factor"](params) + discount_factor = model_funcs["read_funcs"]["discount_factor"]( + params=params, **state_choice_vec + ) interest_rate = model_funcs["read_funcs"]["interest_rate"](params) policy, expected_value = solve_euler_equation( diff --git a/src/dcegm/interpolation/interp1d.py b/src/dcegm/interpolation/interp1d.py index 0c40039e..b0ebec40 100644 --- a/src/dcegm/interpolation/interp1d.py +++ b/src/dcegm/interpolation/interp1d.py @@ -49,7 +49,7 @@ def interp1d_policy_and_value_on_wealth( compute_utility: Callable, state_choice_vec: Dict[str, int], params: Dict[str, float], - discount_factor, + read_discount_factor: Callable, ) -> Tuple[float, float]: """Interpolate policy and value function given a single wealth grid point. @@ -90,7 +90,7 @@ def interp1d_policy_and_value_on_wealth( value_at_zero_wealth=value_grid[0], state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return policy_interp, value_interp @@ -103,7 +103,7 @@ def interp_value_on_wealth( compute_utility: Callable, state_choice_vec: Dict[str, int], params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> jnp.ndarray | float: """Interpolate value function on a single wealth point. @@ -131,7 +131,7 @@ def interp_value_on_wealth( value_at_zero_wealth=value[0], state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return value_interp @@ -179,7 +179,7 @@ def interp_value_and_check_creditconstraint( value_at_zero_wealth: float | jnp.ndarray, state_choice_vec: Dict[str, int], params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> float | jnp.ndarray: """Calculate the interpolated value with accounting for a possible credit constrained solution. @@ -223,6 +223,7 @@ def interp_value_and_check_creditconstraint( params=params, **state_choice_vec, ) + discount_factor = read_discount_factor(params=params, **state_choice_vec) value_interp_closed_form = utility + discount_factor * value_at_zero_wealth # Check if we are in the credit constrained region diff --git a/src/dcegm/interpolation/interp1d_dj.py b/src/dcegm/interpolation/interp1d_dj.py index 7dc75249..4e34b3b9 100644 --- a/src/dcegm/interpolation/interp1d_dj.py +++ b/src/dcegm/interpolation/interp1d_dj.py @@ -16,7 +16,7 @@ def interp1d_policy_and_value_on_wealth_dj( compute_utility: Callable, state_choice_vec: Dict[str, int], params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> Tuple[jnp.ndarray | float, jnp.ndarray | float]: """1D interpolation for DJ with consume-all overwrite for policy and value.""" ind_high, ind_low = get_index_high_and_low(x=wealth_grid, x_new=wealth) @@ -42,7 +42,7 @@ def interp1d_policy_and_value_on_wealth_dj( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) overwrite_mask = consume_all_value > value_interp_on_grid policy = jnp.where(overwrite_mask, wealth, policy_interp) @@ -57,7 +57,7 @@ def interp1d_value_on_wealth_dj( compute_utility: Callable, state_choice_vec: Dict[str, int], params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> jnp.ndarray | float: """1D value interpolation for DJ with consume-all overwrite.""" _, value = interp1d_policy_and_value_on_wealth_dj( @@ -68,7 +68,7 @@ def interp1d_value_on_wealth_dj( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return value @@ -79,9 +79,10 @@ def _consume_all_value( compute_utility: Callable, state_choice_vec: Dict[str, int], params: Dict[str, float], - discount_factor: float, + read_discount_factor: Callable, ) -> jnp.ndarray: util = compute_utility(consumption=wealth, params=params, **state_choice_vec) if isinstance(util, tuple): util = util[0] + discount_factor = read_discount_factor(params=params, **state_choice_vec) return jnp.asarray(util) + discount_factor * value_at_zero_wealth diff --git a/src/dcegm/interpolation/interp2d_irregular.py b/src/dcegm/interpolation/interp2d_irregular.py index 66e580ed..3a8891f7 100644 --- a/src/dcegm/interpolation/interp2d_irregular.py +++ b/src/dcegm/interpolation/interp2d_irregular.py @@ -27,7 +27,7 @@ def interp2d_policy_and_value_on_wealth_and_regular_grid( compute_utility: Callable, state_choice_vec: Dict[str, int], params: dict, - discount_factor, + read_discount_factor: Callable, ): """Linear 2D interpolation on two grids where wealth has irregular spacing. @@ -94,7 +94,7 @@ def interp2d_policy_and_value_on_wealth_and_regular_grid( state_choice_vec=state_choice_vec, cont_state_name=cont_state_name, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return policy_interp, value_interp @@ -109,7 +109,7 @@ def interp2d_value_on_wealth_and_regular_grid( compute_utility: Callable, state_choice_vec: Dict[str, int], params: dict, - discount_factor, + read_discount_factor: Callable, cont_state_name: str = "continuous_state", ): """Interpolate the value function on a 2D grid. @@ -162,7 +162,7 @@ def interp2d_value_on_wealth_and_regular_grid( state_choice_vec=state_choice_vec, cont_state_name=cont_state_name, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return value_interp @@ -278,7 +278,7 @@ def interp2d_value_and_check_creditconstraint( state_choice_vec, cont_state_name, params, - discount_factor, + read_discount_factor, ): """Interpolate the value function on a 2D grid and check for credit constraints. @@ -322,6 +322,8 @@ def interp2d_value_and_check_creditconstraint( **state_choice_vec, cont_state_name: regular_point_to_interp, } + discount_factor = read_discount_factor(params=params, **state_choice_vec) + # Now recalculate the closed-form value of consuming all wealth value_calc_left = ( compute_utility( diff --git a/src/dcegm/interpolation/interp_interfaces.py b/src/dcegm/interpolation/interp_interfaces.py index a9249b79..948e76ed 100644 --- a/src/dcegm/interpolation/interp_interfaces.py +++ b/src/dcegm/interpolation/interp_interfaces.py @@ -29,7 +29,7 @@ def interpolate_value_for_state_and_choice( """Interpolate the value for a state and choice given the respective grids.""" continuous_states_info = model_config["continuous_states_info"] upper_envelope_method = model_config["upper_envelope"]["method"] - discount_factor = model_funcs["read_funcs"]["discount_factor"](params) + read_discount_factor = model_funcs["read_funcs"]["discount_factor"] compute_utility = model_funcs["compute_utility"] @@ -53,7 +53,7 @@ def interpolate_value_for_state_and_choice( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) elif (upper_envelope_method == "druedahl_jorgensen") & multidim: @@ -71,7 +71,7 @@ def interpolate_value_for_state_and_choice( ], compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) elif upper_envelope_method == "druedahl_jorgensen": value = interp1d_value_on_wealth_dj( @@ -81,7 +81,7 @@ def interpolate_value_for_state_and_choice( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) else: value = interp_value_on_wealth( @@ -91,7 +91,7 @@ def interpolate_value_for_state_and_choice( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return value @@ -127,7 +127,7 @@ def interpolate_policy_for_state_and_choice( compute_utility=lambda consumption, params, **kwargs: consumption, state_choice_vec=state_choice_vec, params={}, - discount_factor=0.0, + read_discount_factor=lambda params, **kwargs: 0.0, ) elif (upper_envelope_method == "druedahl_jorgensen") & multidim: policy, _ = interpolate_policy_and_value_for_state_and_choice( @@ -149,7 +149,7 @@ def interpolate_policy_for_state_and_choice( compute_utility=model_funcs["compute_utility"], state_choice_vec=state_choice_vec, params=params, - discount_factor=model_funcs["read_funcs"]["discount_factor"](params), + read_discount_factor=model_funcs["read_funcs"]["discount_factor"], ) else: policy = interp_policy_on_wealth( @@ -175,7 +175,7 @@ def interpolate_policy_and_value_for_state_and_choice( upper_envelope_method = model_config["upper_envelope"]["method"] compute_utility = model_funcs["compute_utility"] - discount_factor = model_funcs["read_funcs"]["discount_factor"](params) + read_discount_factor = model_funcs["read_funcs"]["discount_factor"] continuous_state_space = model_structure["continuous_state_space"] multidim = continuous_states_info["has_additional_continuous_state"] @@ -195,7 +195,7 @@ def interpolate_policy_and_value_for_state_and_choice( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) elif (upper_envelope_method == "druedahl_jorgensen") & multidim: policy, value = _interp_policy_and_value_multidim_dj_for_state_choice( @@ -212,7 +212,7 @@ def interpolate_policy_and_value_for_state_and_choice( ], compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) elif upper_envelope_method == "druedahl_jorgensen": policy, value = interp1d_policy_and_value_on_wealth_dj( @@ -223,7 +223,7 @@ def interpolate_policy_and_value_for_state_and_choice( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) else: policy, value = interp1d_policy_and_value_on_wealth( @@ -234,7 +234,7 @@ def interpolate_policy_and_value_for_state_and_choice( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return policy, value @@ -250,7 +250,7 @@ def _interp_policy_and_value_multidim_dj_for_state_choice( continuous_state_names, compute_utility, params, - discount_factor, + read_discount_factor, ): continuous_state_child_states = { name: jnp.asarray(state_choice_vec[name])[None, None] @@ -273,7 +273,7 @@ def _interp_policy_and_value_multidim_dj_for_state_choice( state_choice_child_states=state_choice_child_states, compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) policy_nd = policy_nd[0, 0, 0, 0] value_nd = value_nd[0, 0, 0, 0] @@ -295,7 +295,7 @@ def _interp_policy_and_value_multidim_dj_for_state_choice( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) policy = jnp.where(has_exact_combo, policy_exact, policy_nd) diff --git a/src/dcegm/interpolation/interpnd_regular.py b/src/dcegm/interpolation/interpnd_regular.py index f870a650..e70968a7 100644 --- a/src/dcegm/interpolation/interpnd_regular.py +++ b/src/dcegm/interpolation/interpnd_regular.py @@ -31,7 +31,7 @@ def interpnd_policy_for_child_states_on_regular_grids( state_choice_child_states: Dict[str, Any], compute_utility: Callable, params: Dict[str, Any], - discount_factor: float, + read_discount_factor: Callable, ) -> jnp.ndarray: """Interpolate policy, using value-based overwrite logic. @@ -49,7 +49,7 @@ def interpnd_policy_for_child_states_on_regular_grids( state_choice_child_states=state_choice_child_states, compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return policy @@ -64,7 +64,7 @@ def interpnd_policy_and_value_for_child_states_on_regular_grids( state_choice_child_states: Dict[str, Any], compute_utility: Callable, params: Dict[str, Any], - discount_factor: float, + read_discount_factor: Callable, ) -> tuple[jnp.ndarray, jnp.ndarray]: """Interpolate policy/value and apply consume-all overwrite. @@ -155,7 +155,7 @@ def _interp_one_child_state( continuous_state_child_states=continuous_state_child_states, compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) overwrite_mask = consume_all_value > value_interp @@ -173,7 +173,7 @@ def interpnd_value_for_child_states_on_regular_grids( state_choice_child_states: Dict[str, Any], compute_utility: Callable, params: Dict[str, Any], - discount_factor: float, + read_discount_factor: Callable, ) -> jnp.ndarray: """Interpolate value and apply consume-all overwrite. @@ -269,7 +269,7 @@ def _interp_one_comb( continuous_state_child_states=continuous_state_child_states, compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return jnp.asarray( @@ -284,8 +284,20 @@ def _compute_consume_all_value( continuous_state_child_states: Dict[str, jnp.ndarray], compute_utility: Callable, params: Dict[str, Any], - discount_factor: float, + read_discount_factor: Callable, ) -> jnp.ndarray: + # `state_choice_child_states` only varies along the leading + # (child-state-choice) axis -- see the `in_axes` below, where it is + # `None` (broadcast) for every other vmapped axis. So a discount factor + # read from it varies along that same axis only, and we resolve it with + # a single vmap over that axis rather than inside `_utility_at_point` + # (which runs *after* `state_choice_child_states` has been consumed and + # is no longer available point-by-point). + discount_factor = vmap( + lambda state_choice_point: read_discount_factor( + params=params, **state_choice_point + ) + )(state_choice_child_states) def _utility_at_point( consumption_point: jnp.ndarray, @@ -319,7 +331,10 @@ def _utility_at_point( ) expected_value_zero_savings = expected_value_zero_savings[:, :, None, None] - return consume_all_utility + discount_factor * expected_value_zero_savings + return ( + consume_all_utility + + discount_factor[:, None, None, None] * expected_value_zero_savings + ) def _interp_policy_and_value_one_comb( diff --git a/src/dcegm/interpolation/simulation_interp.py b/src/dcegm/interpolation/simulation_interp.py index 6ff72bae..c7cf9846 100644 --- a/src/dcegm/interpolation/simulation_interp.py +++ b/src/dcegm/interpolation/simulation_interp.py @@ -28,7 +28,7 @@ def interpolate_policy_and_value_for_all_agents( additional_continuous_state_grids, upper_envelope_method, has_additional_continuous_state, - discount_factor, + read_discount_factor, ): # 1D interpolation path is independent of upper-envelope method and only @@ -90,7 +90,7 @@ def interpolate_policy_and_value_for_all_agents( choice_range, params, compute_utility, - discount_factor, + read_discount_factor, upper_envelope_method == "druedahl_jorgensen", ) @@ -176,7 +176,7 @@ def interpolate_policy_and_value_for_all_agents( continuous_state_name, params, compute_utility, - discount_factor, + read_discount_factor, ) return policy_agent, value_agent @@ -261,7 +261,7 @@ def interpolate_policy_and_value_for_all_agents( additional_continuous_state_names, params, compute_utility, - discount_factor, + read_discount_factor, ) return policy_agent, value_agent @@ -280,7 +280,7 @@ def interp1d_policy_and_value_function( choice, params, compute_utility, - discount_factor, + read_discount_factor, use_dj_interpolation, ): state_choice_vec = {**state, "choice": choice} @@ -294,7 +294,7 @@ def interp1d_policy_and_value_function( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) else: policy_interp, value_interp = interp1d_policy_and_value_on_wealth( @@ -305,7 +305,7 @@ def interp1d_policy_and_value_function( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return policy_interp, value_interp @@ -323,7 +323,7 @@ def interp2d_policy_and_value_function( continuous_state_name, params, compute_utility, - discount_factor, + read_discount_factor, ): state_choice_vec = {**state, "choice": choice} @@ -339,7 +339,7 @@ def interp2d_policy_and_value_function( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) return policy_interp, value_interp @@ -358,7 +358,7 @@ def interpnd_policy_and_value_function( additional_continuous_state_names, params, compute_utility, - discount_factor, + read_discount_factor, ): state_choice_vec = {**state, "choice": choice} @@ -381,7 +381,7 @@ def interpnd_policy_and_value_function( state_choice_child_states=state_choice_child_states, compute_utility=compute_utility, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) ) @@ -401,7 +401,7 @@ def interpnd_policy_and_value_function( compute_utility=compute_utility, state_choice_vec=state_choice_vec, params=params, - discount_factor=discount_factor, + read_discount_factor=read_discount_factor, ) policy = jnp.where(has_exact_combo, policy_exact, policy_interp[0, 0, 0, 0]) diff --git a/src/dcegm/pre_processing/check_model_specs.py b/src/dcegm/pre_processing/check_model_specs.py index 098b49df..22477118 100644 --- a/src/dcegm/pre_processing/check_model_specs.py +++ b/src/dcegm/pre_processing/check_model_specs.py @@ -9,13 +9,17 @@ def extract_model_specs_info(model_specs): if not isinstance(model_specs, dict): raise ValueError("model_specs must be a dictionary.") - # discount_factor processing + # discount_factor processing. Accepts and ignores extra state-choice + # kwargs so the same read function can be called uniformly whether or + # not a `discount_factor_per_state` function is registered (see + # dcegm.pre_processing.setup_model, which may override this read + # function with a state-dependent one). if "discount_factor" in model_specs: discount_factor = jnp.asarray(model_specs["discount_factor"]) - read_func_discount_factor = lambda params: discount_factor + read_func_discount_factor = lambda params, **kwargs: discount_factor discount_factor_in_params = False else: - read_func_discount_factor = lambda params: params["discount_factor"] + read_func_discount_factor = lambda params, **kwargs: params["discount_factor"] discount_factor_in_params = True # interest_rate processing diff --git a/src/dcegm/pre_processing/check_params.py b/src/dcegm/pre_processing/check_params.py index 75759424..92146155 100644 --- a/src/dcegm/pre_processing/check_params.py +++ b/src/dcegm/pre_processing/check_params.py @@ -26,7 +26,12 @@ def process_params(params, params_check_info) -> Dict[str, float]: "not an element of model_specs or params." ) - if params_check_info["discount_factor_in_params"]: + if params_check_info.get("discount_factor_is_per_state", False): + # discount_factor is computed by a user-supplied + # `discount_factor_per_state` function instead of a single scalar; + # no fixed "discount_factor" key is expected in params or model_specs. + pass + elif params_check_info["discount_factor_in_params"]: if "discount_factor" not in params.keys(): raise ValueError( "discount_factor must be provided in model_specs or params." diff --git a/src/dcegm/pre_processing/model_functions/discount_factor_function.py b/src/dcegm/pre_processing/model_functions/discount_factor_function.py new file mode 100644 index 00000000..009f508d --- /dev/null +++ b/src/dcegm/pre_processing/model_functions/discount_factor_function.py @@ -0,0 +1,39 @@ +from dcegm.pre_processing.shared import ( + determine_function_arguments_and_partial_model_specs, +) + + +def process_discount_factor_function( + shock_functions, model_specs, additional_continuous_state_names +): + """Process a user-supplied state-choice-dependent discount factor. + + If `shock_functions["discount_factor_per_state"]` is provided, it is wrapped + the same way as every other user function (utility, budget constraint, ...), + so it can be called with `params` and whichever state-choice variables it + declares in its signature. Otherwise, discount_factor stays the default + single scalar read from `model_specs` or `params` (see + `dcegm.pre_processing.check_model_specs.extract_model_specs_info`). + + """ + shock_functions = {} if shock_functions is None else shock_functions + + if "discount_factor_per_state" not in shock_functions: + return None + + not_allowed_states = ["assets_begin_of_period"] + if additional_continuous_state_names is not None: + not_allowed_states += additional_continuous_state_names + + discount_factor_per_state_func = ( + determine_function_arguments_and_partial_model_specs( + func=shock_functions["discount_factor_per_state"], + model_specs=model_specs, + not_allowed_state_choices=not_allowed_states, + ) + ) + + def read_func_discount_factor(params, **state_choice_vec): + return discount_factor_per_state_func(params=params, **state_choice_vec) + + return read_func_discount_factor diff --git a/src/dcegm/pre_processing/model_functions/process_model_functions.py b/src/dcegm/pre_processing/model_functions/process_model_functions.py index 75e5d8d5..5787a3ad 100644 --- a/src/dcegm/pre_processing/model_functions/process_model_functions.py +++ b/src/dcegm/pre_processing/model_functions/process_model_functions.py @@ -3,6 +3,9 @@ import jax import jax.numpy as jnp +from dcegm.pre_processing.model_functions.discount_factor_function import ( + process_discount_factor_function, +) from dcegm.pre_processing.model_functions.taste_shock_function import ( process_shock_functions, ) @@ -163,6 +166,17 @@ def process_model_functions_and_extract_info( additional_continuous_state_names=additional_continuous_state_names, ) ) + + # State-choice-dependent discount factor (optional). Returns None if the + # user did not supply `shock_functions["discount_factor_per_state"]`, in + # which case the default single-scalar discount_factor is used instead + # (set up later in `extract_model_specs_info`). + discount_factor_per_state_func = process_discount_factor_function( + shock_functions=shock_functions, + model_specs=model_specs_jax, + additional_continuous_state_names=additional_continuous_state_names, + ) + model_config_processed = model_config model_config_processed["params_check_info"] = { "taste_shock_scale_in_params": taste_shock_scale_in_params @@ -180,6 +194,7 @@ def process_model_functions_and_extract_info( "next_period_deterministic_state": next_period_deterministic_state, "compute_upper_envelope": compute_upper_envelope, "taste_shock_function": taste_shock_function_processed, + "discount_factor_per_state_func": discount_factor_per_state_func, } return model_funcs, model_config_processed diff --git a/src/dcegm/pre_processing/model_functions/upper_evelope_wrapper.py b/src/dcegm/pre_processing/model_functions/upper_evelope_wrapper.py index 1833d1d2..c4bdc694 100644 --- a/src/dcegm/pre_processing/model_functions/upper_evelope_wrapper.py +++ b/src/dcegm/pre_processing/model_functions/upper_evelope_wrapper.py @@ -20,9 +20,10 @@ def compute_upper_envelope( state_choice_dict, utility_function, params, - discount_factor, + read_discount_factor, ): state_choice_vars = {**state_choice_dict, **continuous_state_dict} + discount_factor = read_discount_factor(params=params, **state_choice_vars) value_kwargs = { "expected_value_zero_assets": expected_value_zero_assets, diff --git a/src/dcegm/pre_processing/setup_model.py b/src/dcegm/pre_processing/setup_model.py index b8c54547..41dbd8d5 100644 --- a/src/dcegm/pre_processing/setup_model.py +++ b/src/dcegm/pre_processing/setup_model.py @@ -84,6 +84,14 @@ def create_model_dict( ) specs_read_funcs, specs_params_info = extract_model_specs_info(model_specs) + if model_funcs["discount_factor_per_state_func"] is not None: + specs_read_funcs["discount_factor"] = model_funcs[ + "discount_factor_per_state_func" + ] + specs_params_info["discount_factor_in_params"] = False + specs_params_info["discount_factor_is_per_state"] = True + else: + specs_params_info["discount_factor_is_per_state"] = False model_funcs["read_funcs"] = specs_read_funcs model_config_processed["params_check_info"] = { @@ -220,6 +228,14 @@ def load_model_dict( ) specs_read_funcs, specs_params_info = extract_model_specs_info(model_specs) + if model["model_funcs"]["discount_factor_per_state_func"] is not None: + specs_read_funcs["discount_factor"] = model["model_funcs"][ + "discount_factor_per_state_func" + ] + specs_params_info["discount_factor_in_params"] = False + specs_params_info["discount_factor_is_per_state"] = True + else: + specs_params_info["discount_factor_is_per_state"] = False model["model_funcs"]["read_funcs"] = specs_read_funcs model["model_config"]["params_check_info"] = { diff --git a/src/dcegm/simulation/simulate.py b/src/dcegm/simulation/simulate.py index c3b199bf..11b792f8 100644 --- a/src/dcegm/simulation/simulate.py +++ b/src/dcegm/simulation/simulate.py @@ -171,8 +171,10 @@ def simulate_single_period( choice_range = model_structure_sol["choice_range"] - discount_factor = read_funcs["discount_factor"](params) - # Interpolate policy and value function for all agents. + # Interpolate policy and value function for all agents. `discount_factor` + # may be state-choice dependent, so we pass the (unevaluated) read + # function through and let it be resolved per-agent, using each agent's + # own state, deep inside the interpolation vmap. policy, values_pre_taste_shock = interpolate_policy_and_value_for_all_agents( discrete_states_beginning_of_period=discrete_states_beginning_of_period, continuous_state_beginning_of_period=continuous_state_beginning_of_period, @@ -193,7 +195,7 @@ def simulate_single_period( ], upper_envelope_method=model_config["upper_envelope"]["method"], has_additional_continuous_state=has_additional_continuous_state, - discount_factor=discount_factor, + read_discount_factor=read_funcs["discount_factor"], ) # Draw taste shocks and calculate final value. diff --git a/src/dcegm/solve_single_period.py b/src/dcegm/solve_single_period.py index 8eab9bda..d5376ec2 100644 --- a/src/dcegm/solve_single_period.py +++ b/src/dcegm/solve_single_period.py @@ -158,10 +158,12 @@ def solve_for_interpolated_values( params=params, ) - discount_factor = model_funcs["read_funcs"]["discount_factor"](params) - # Run upper envelope over all state-choice combinations to remove suboptimal - # candidates + # candidates. `discount_factor` may be state-choice dependent, so we pass + # the (unevaluated) read function through and call it inside + # `compute_upper_envelope_for_state_choice`, where it already has access + # to a single state-choice's own values -- exactly like `compute_utility` + # and `params`, which are also broadcast (not mapped) into that vmap. ( endog_grid_state_choice, policy_state_choice, @@ -175,7 +177,7 @@ def solve_for_interpolated_values( state_choice_mat=state_choice_mat, compute_utility=model_funcs["compute_utility"], params=params, - discount_factor=discount_factor, + read_discount_factor=model_funcs["read_funcs"]["discount_factor"], compute_upper_envelope_for_state_choice=model_funcs["compute_upper_envelope"], ) out_dict = { @@ -203,12 +205,15 @@ def run_upper_envelope( state_choice_mat, compute_utility, params, - discount_factor, + read_discount_factor, compute_upper_envelope_for_state_choice, ): """Run upper envelope to remove suboptimal candidates. - Vectorized over all state-choice combinations. + Vectorized over all state-choice combinations. `read_discount_factor` is broadcast + (not mapped) like `compute_utility` and `params`; it is called inside + `compute_upper_envelope_for_state_choice` with that call's own state-choice values, + which is where a state-choice-dependent discount factor is actually evaluated. """ return vmap( @@ -246,5 +251,5 @@ def run_upper_envelope( state_choice_mat, compute_utility, params, - discount_factor, + read_discount_factor, ) diff --git a/tests/test_discount_factor_per_state.py b/tests/test_discount_factor_per_state.py new file mode 100644 index 00000000..e02585b8 --- /dev/null +++ b/tests/test_discount_factor_per_state.py @@ -0,0 +1,129 @@ +"""Test that a state-dependent discount factor matches looping over scalar solves. + +We add a `type` deterministic state to the simple dcegm-paper retirement model that +affects *only* the discount factor (nothing else -- not utility, not the budget +constraint, not the choice set). We then compare two ways of solving it: + +(i) one joint solve, with `discount_factor_per_state` reading `beta_by_type[type]` from +`params`, and (ii) looping over each type value and solving the (type-less) base model +with the corresponding scalar `discount_factor`. + +Since `type` has no effect other than through the discount factor, and it never +transitions, the two approaches should be exactly equivalent: solving jointly with a +per-type discount factor cannot differ from solving each type separately with the +matching scalar. We check this by comparing interpolated policy and value functions on a +wealth grid, for every period/lagged_choice/type combination. + +""" + +import jax.numpy as jnp +import numpy as np +import pytest +from numpy.testing import assert_array_almost_equal as aaae + +import dcegm +import dcegm.toy_models as toy_models + +BETA_BY_TYPE = jnp.array([0.90, 0.98]) + + +def discount_factor_per_type(type, params): + return params["beta_by_type"][type] + + +def next_period_deterministic_state(period, choice, type): + return {"period": period + 1, "lagged_choice": choice, "type": type} + + +@pytest.fixture() +def base_ingredients(): + model_funcs = toy_models.load_example_model_functions("dcegm_paper") + params, model_specs, model_config = ( + toy_models.load_example_params_model_specs_and_config( + "dcegm_paper_retirement_with_shocks" + ) + ) + # A handful of periods and a coarse wealth grid keep this test fast; the + # equivalence being tested does not depend on their size. + model_config["n_periods"] = 6 + return model_funcs, params, model_specs, model_config + + +def test_discount_factor_per_state_matches_scalar_loop(base_ingredients): + model_funcs, params_base, model_specs, model_config = base_ingredients + + # --- (i) one joint solve, type as a state, discount factor read per state --- + model_config_joint = { + **model_config, + "deterministic_states": {"type": np.arange(2, dtype=int)}, + } + state_space_functions_joint = { + **model_funcs["state_space_functions"], + "next_period_deterministic_state": next_period_deterministic_state, + } + params_joint = {**params_base, "beta_by_type": BETA_BY_TYPE} + del params_joint["discount_factor"] + + model_joint = dcegm.setup_model( + model_config=model_config_joint, + model_specs=model_specs, + utility_functions=model_funcs["utility_functions"], + utility_functions_final_period=model_funcs["utility_functions_final_period"], + budget_constraint=model_funcs["budget_constraint"], + state_space_functions=state_space_functions_joint, + shock_functions={"discount_factor_per_state": discount_factor_per_type}, + ) + model_joint_solved = model_joint.solve(params_joint) + + wealth_grid = jnp.linspace(1.0, 40.0, 50) + + for type_value in (0, 1): + # --- (ii) loop: plain (type-less) model, scalar discount factor --- + params_loop = { + **params_base, + "discount_factor": float(BETA_BY_TYPE[type_value]), + } + model_loop = dcegm.setup_model( + model_config=model_config, + model_specs=model_specs, + **model_funcs, + ) + model_loop_solved = model_loop.solve(params_loop) + + for period in range(model_config["n_periods"] - 1): + for lagged_choice in (0, 1): + for choice in (0, 1): + if lagged_choice == 1 and choice == 0: + # retirement is absorbing; this state-choice does not exist + continue + + states_joint = { + "period": jnp.full_like(wealth_grid, period, dtype=int), + "lagged_choice": jnp.full_like( + wealth_grid, lagged_choice, dtype=int + ), + "type": jnp.full_like(wealth_grid, type_value, dtype=int), + "assets_begin_of_period": wealth_grid, + } + states_loop = { + "period": jnp.full_like(wealth_grid, period, dtype=int), + "lagged_choice": jnp.full_like( + wealth_grid, lagged_choice, dtype=int + ), + "assets_begin_of_period": wealth_grid, + } + choices = jnp.full_like(wealth_grid, choice, dtype=int) + + policy_joint, value_joint = ( + model_joint_solved.policy_and_value_for_states_and_choices( + states=states_joint, choices=choices + ) + ) + policy_loop, value_loop = ( + model_loop_solved.policy_and_value_for_states_and_choices( + states=states_loop, choices=choices + ) + ) + + aaae(policy_joint, policy_loop, decimal=6) + aaae(value_joint, value_loop, decimal=6) diff --git a/tests/test_interpnd_regular.py b/tests/test_interpnd_regular.py index d95c7f95..3a92e4d9 100644 --- a/tests/test_interpnd_regular.py +++ b/tests/test_interpnd_regular.py @@ -95,7 +95,7 @@ def _run_interpnd(policy_grid_child_states, value_grid_child_states, inputs): }, compute_utility=_compute_utility, params={"u_scale": 2.0}, - discount_factor=0.95, + read_discount_factor=lambda params, **kwargs: 0.95, ) @@ -178,7 +178,7 @@ def _run_interpnd_policy_value( }, compute_utility=_compute_utility, params={"u_scale": 2.0}, - discount_factor=0.95, + read_discount_factor=lambda params, **kwargs: 0.95, ) @@ -202,7 +202,7 @@ def _run_interpnd_value_only(value_grid_child_states, inputs): }, compute_utility=_compute_utility, params={"u_scale": 2.0}, - discount_factor=0.95, + read_discount_factor=lambda params, **kwargs: 0.95, ) diff --git a/tests/test_interpolation.py b/tests/test_interpolation.py index 90ad52c6..a496ce0d 100644 --- a/tests/test_interpolation.py +++ b/tests/test_interpolation.py @@ -266,7 +266,7 @@ def test_interp2d_against_custom(test_cases, test_id): compute_utility=compute_utility, state_choice_vec={"choice": 0}, params=PARAMS, - discount_factor=PARAMS["discount_factor"], + read_discount_factor=lambda params, **kwargs: PARAMS["discount_factor"], ) ) diff --git a/tests/test_utility_second_continuous.py b/tests/test_utility_second_continuous.py index 0a0013c4..24ee32d6 100644 --- a/tests/test_utility_second_continuous.py +++ b/tests/test_utility_second_continuous.py @@ -373,7 +373,9 @@ def test_replication_discrete_versus_continuous_experience( compute_utility=model_cont.model_funcs["compute_utility"], state_choice_vec=state_choice_cont_dict, params=PARAMS, - discount_factor=PARAMS["discount_factor"], + read_discount_factor=lambda params, **kwargs: PARAMS[ + "discount_factor" + ], ) ) @@ -385,7 +387,7 @@ def test_replication_discrete_versus_continuous_experience( compute_utility=model_disc.model_funcs["compute_utility"], state_choice_vec=state_choice_disc_dict, params=PARAMS, - discount_factor=PARAMS["discount_factor"], + read_discount_factor=lambda params, **kwargs: PARAMS["discount_factor"], ) aaae(value_cont_interp, value_disc_interp, decimal=3) From 6a341dbd19870f1f3bc123b1ab1ddff62a46895c Mon Sep 17 00:00:00 2001 From: MaxBlesch Date: Sat, 29 Aug 2026 18:14:24 +0200 Subject: [PATCH 2/2] Buggy replication --- .../replications/iskhakov_keane_2021.ipynb | 1334 +++++++++++------ docs/source/replications/params.yaml | 107 ++ 2 files changed, 1022 insertions(+), 419 deletions(-) create mode 100644 docs/source/replications/params.yaml diff --git a/docs/source/replications/iskhakov_keane_2021.ipynb b/docs/source/replications/iskhakov_keane_2021.ipynb index f7b8a61e..a48cb66e 100644 --- a/docs/source/replications/iskhakov_keane_2021.ipynb +++ b/docs/source/replications/iskhakov_keane_2021.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "6abaf595", + "id": "a53d6dec", "metadata": {}, "source": [ "# Replicating Iskhakov & Keane (2021) with `dcegm`\n", @@ -15,44 +15,49 @@ "experience state was built with this paper in mind (see\n", "[Limitations](../background/limitations.rst)).\n", "\n", - "**Scope.** This is a *calibrated structural replication*, not a re-estimation:\n", + "**We replicate the model, not the estimation.** Throughout this notebook:\n", "\n", "- We plug in the paper's **published point estimates** (Tables 5-7 of the\n", - " supplementary material) rather than re-running the method-of-simulated-moments\n", - " estimation on HILDA, which is restricted-access microdata we don't have.\n", - "- We fix the **post-2010 Age Pension regime** throughout, rather than tracking\n", - " the calendar-time policy changes the paper's estimation sample (2001-2016)\n", - " passed through. This makes the model a clean stationary life cycle for one\n", - " cohort, consistent with how the paper itself fixes a policy regime for its\n", - " own counterfactual simulations (Section 9).\n", - "- We truncate the horizon at the **compulsory retirement age of 85** instead\n", - " of 100, and treat the terminal state (age 85, or an earlier death) as\n", - " bequeathing all remaining wealth. dcegm's terminal-period solver assumes\n", - " consumption equals full wealth, so it cannot reproduce the paper's genuine\n", - " consumption/bequest trade-off in the true final period (eq. 21-22); this is\n", - " a minor difference for the mechanism we're illustrating.\n", - "\n", - "The goal is to reproduce the paper's *mechanism* (kinked policy functions\n", - "from combining a discrete hours choice with a continuous savings choice,\n", - "under taxes/means-tested pensions/superannuation/mortality risk) and its\n", - "*qualitative* life-cycle and policy-experiment implications — not to\n", - "match its estimated moments point for point.\n" + " supplementary material) directly into the model. We do **not** re-run the\n", + " paper's method-of-simulated-moments estimation, which requires the\n", + " restricted-access HILDA microdata we don't have.\n", + "- Every number that appears in a `dcegm` object here — every $\\beta$, $\\eta$,\n", + " tax bracket, pension parameter — is copied from the paper's own tables.\n", + " Nothing in this notebook is fit to data.\n", + "- Consequently, don't expect the simulated *levels* (aggregate wealth,\n", + " average hours) to reproduce the paper's Figures 5-9 point for point — those\n", + " are targets of an estimation we are not running. What we *do* expect to\n", + " reproduce is the model's **mechanism**: the kinked policy functions DC-EGM\n", + " is built to solve, the qualitative shape of life-cycle profiles, the\n", + " direction of the paper's policy experiment, and — new in this version — a\n", + " genuine **quantitative** check against a structural object the paper\n", + " reports (Section 5).\n", + "- We fix the **post-2010 Age Pension regime** throughout, rather than\n", + " tracking the calendar-time policy changes the paper's estimation sample\n", + " (2001-2016) passed through, and we truncate the horizon at the\n", + " **compulsory retirement age of 85** instead of 100 (see Section 4 for what\n", + " this changes). Both are simplifications for tractability, not attempts to\n", + " match the paper's fit.\n", + "\n", + "All calibration values live in [`params.yaml`](params.yaml) next to this\n", + "notebook, transcribed directly from the paper's tables — see Section 1.\n" ] }, { "cell_type": "code", "execution_count": 1, - "id": "722da91f", + "id": "84235d81", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:27.892141Z", - "iopub.status.busy": "2026-08-29T11:55:27.891853Z", - "iopub.status.idle": "2026-08-29T11:55:37.669917Z", - "shell.execute_reply": "2026-08-29T11:55:37.669128Z" + "iopub.execute_input": "2026-08-29T15:06:24.641941Z", + "iopub.status.busy": "2026-08-29T15:06:24.641727Z", + "iopub.status.idle": "2026-08-29T15:06:26.380936Z", + "shell.execute_reply": "2026-08-29T15:06:26.380387Z" } }, "outputs": [], "source": [ + "import yaml\n", "import jax\n", "import jax.numpy as jnp\n", "import numpy as np\n", @@ -61,12 +66,13 @@ "\n", "import dcegm\n", "\n", - "jax.config.update(\"jax_enable_x64\", True)" + "jax.config.update(\"jax_enable_x64\", True)\n", + "plt.rcParams[\"figure.dpi\"] = 55 # keep this notebook's committed size small" ] }, { "cell_type": "markdown", - "id": "9cae8a81", + "id": "899d6893", "metadata": {}, "source": [ "## 1. Calibration\n", @@ -74,148 +80,99 @@ "Hours are discrete, $H = \\{0, 1000, 2000, 2250, 2500, 3000\\}$ (eq. 1). All\n", "monetary values are in \\$1000 AUD, matching the paper.\n", "\n", - "The dictionaries below transcribe Tables 5 (preferences), 6 (human capital)\n", - "and 7 (misc.) of the supplementary material, plus the tax function (eq. 27\n", - "of the main paper) and the pension and survival functions (eqs. 2-3 of the\n", - "supplement). Discount factor, human-capital constants and the high-type\n", - "wage premium differ by education, so `build_params`/`build_model_specs`\n", - "assemble one calibration per education group.\n" + "`params.yaml` transcribes Tables 5 (preferences), 6 (human capital) and 7\n", + "(misc.) of the supplementary material, plus the tax function (eq. 27 of the\n", + "main paper) and the pension and survival functions (eqs. 2-3 of the\n", + "supplement) — every number in it is a value **published in the paper**, not\n", + "something we chose or fit. `build_params`/`build_model_specs` below just\n", + "reshape that file into the flat dictionaries `dcegm` expects; education\n", + "groups are indexed 0=dropout, 1=highschool, 2=college throughout.\n" ] }, { "cell_type": "code", "execution_count": 2, - "id": "cddcf41b", + "id": "7307227b", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:37.672492Z", - "iopub.status.busy": "2026-08-29T11:55:37.672263Z", - "iopub.status.idle": "2026-08-29T11:55:37.688219Z", - "shell.execute_reply": "2026-08-29T11:55:37.687778Z" + "iopub.execute_input": "2026-08-29T15:06:26.382371Z", + "iopub.status.busy": "2026-08-29T15:06:26.382256Z", + "iopub.status.idle": "2026-08-29T15:06:26.392163Z", + "shell.execute_reply": "2026-08-29T15:06:26.391652Z" } }, "outputs": [], "source": [ - "# Hours levels H = {0, 1000, 2000, 2250, 2500, 3000}, choice index 0..5\n", - "HOURS_BY_CHOICE = jnp.array([0.0, 1000.0, 2000.0, 2250.0, 2500.0, 3000.0])\n", - "\n", - "EDUCATION_GROUPS = [\"dropout\", \"highschool\", \"college\"]\n", - "T0_BY_EDUCATION = {\"dropout\": 19, \"highschool\": 19, \"college\": 23}\n", - "T_RETIRE = 85 # compulsory retirement age (last period agents may work)\n", - "\n", - "# --- Table 5: preference parameters ---\n", - "PREFERENCE_PARAMS = {\n", - " \"zeta\": 0.79488, # CRRA coefficient in consumption\n", - " \"gamma\": jnp.array(\n", - " [0.0, 1.4139, 2.0088, 2.9213, 2.8639, 3.8775]\n", - " ), # disutility by hours level (gamma_0=0)\n", - " \"kappa_1\": 0.50321, # low-type disutility correction\n", - " \"kappa_2\": 0.00008, # quadratic age term (older workers)\n", - " \"kappa_3\": 0.05083, # linear age term (younger workers)\n", - " \"xi\": 0.48834, # CRRA coefficient of bequest\n", - " \"b_scale\": 0.68659, # bequest scale\n", - " \"beta\": {\"dropout\": 0.96806, \"highschool\": 0.96732, \"college\": 0.96963},\n", - " \"taste_shock_scale\": 0.29950, # lambda\n", - "}\n", + "with open(\"params.yaml\") as f:\n", + " CAL = yaml.safe_load(f)\n", "\n", - "# --- Table 6: human capital production function, eq. (4) ---\n", - "HUMAN_CAPITAL_PARAMS = {\n", - " \"eta0_edu\": {\"dropout\": 2.45647, \"highschool\": 2.56761, \"college\": 2.78766},\n", - " \"eta0_high_type\": 0.39311,\n", - " \"eta1_edu\": {\"dropout\": 0.01974, \"highschool\": 0.02164, \"college\": 0.03041},\n", - " \"eta2_edu\": {\"dropout\": 0.00000, \"highschool\": -0.00002, \"college\": -0.00017},\n", - " \"eta3\": 0.02676,\n", - " \"eta4\": -0.00076,\n", - "}\n", + "EDUCATION_GROUPS = CAL[\"education_groups\"]\n", + "COLLEGE_INDEX = EDUCATION_GROUPS.index(\"college\")\n", + "HOURS_BY_CHOICE = jnp.array(CAL[\"hours_by_choice\"])\n", + "T0 = CAL[\"t0\"]\n", + "T_RETIRE = CAL[\"t_retire\"]\n", + "# One dummy period beyond T_RETIRE -- see Section 3 for why.\n", + "N_PERIODS = T_RETIRE - T0 + 2\n", + "LAST_WORKING_PERIOD = T_RETIRE - T0\n", + "COLLEGE_START_PERIOD = CAL[\"college_start_age\"] - T0\n", "\n", - "# --- Table 7: misc structural parameters ---\n", - "MISC_PARAMS = {\n", - " \"sigma0\": 0.24485, # wage shock std: constant\n", - " \"sigma1\": 0.00421, # wage shock std: age slope\n", - " \"tr\": 5.51308, # parental transfer ($1000/year, up to age 23)\n", - " \"rho_super\": {\"dropout\": 6.47838, \"highschool\": 5.43473, \"college\": 6.30347},\n", - " \"high_type_share\": {\"dropout\": 0.69306, \"highschool\": 0.80130, \"college\": 0.90089},\n", - "}\n", "\n", - "# --- Eq. (27): income tax. NB the printed additive constant for the top\n", - "# bracket (rate1*thld1) creates a small downward jump in tax liability right\n", - "# at the second threshold; we use the continuity-preserving constant\n", - "# rate1*(thld2-thld1) instead, as is standard for bracket-style tax rules. ---\n", - "TAX_PARAMS = {\"thld1\": 17.39184, \"thld2\": 73.17661, \"rate1\": 0.29907, \"rate2\": 0.37930}\n", - "\n", - "# --- Supplementary eq. (3): pension function. We fix the post-2010 regime\n", - "# constant throughout (see scope discussion above). ---\n", - "PENSION_PARAMS = {\n", - " \"benefit_max\": 10.75973 + 1.84692,\n", - " \"income_taper\": 0.27794,\n", - " \"asset_taper\": 0.00499,\n", - " \"asset_threshold\": 117.08260,\n", - " \"pension_age\": 65,\n", - "}\n", - "\n", - "# --- Supplementary eq. (2): survival function ---\n", - "SURVIVAL_PARAMS = {\"age_threshold\": 40, \"a\": 0.0006569, \"b\": 0.1078507}\n", - "\n", - "# --- Table 1 bottom panel: fixed/calibrated ---\n", - "FIXED_PARAMS = {\n", - " \"credit_constraint\": 20.0, # a0, in $1000\n", - " \"interest_rate\": 0.04,\n", - " \"consumption_floor\": 0.05, # numerical safety floor, not in the paper\n", - " \"superannuation_age\": 65,\n", - "}\n", + "def _edu_array(d):\n", + " # Turn a {education_name: value} mapping from the yaml into an array\n", + " # ordered to match EDUCATION_GROUPS, so it can be indexed by the\n", + " # `education` state directly (jnp.array(...)[education]).\n", + " return jnp.array([d[e] for e in EDUCATION_GROUPS])\n", "\n", "\n", - "def build_params(education: str) -> dict:\n", + "def build_params():\n", + " pref, hc, misc = CAL[\"preferences\"], CAL[\"human_capital\"], CAL[\"misc\"]\n", " p = {\n", - " \"discount_factor\": PREFERENCE_PARAMS[\"beta\"][education],\n", - " \"taste_shock_scale\": PREFERENCE_PARAMS[\"taste_shock_scale\"],\n", - " \"zeta\": PREFERENCE_PARAMS[\"zeta\"],\n", - " \"gamma\": PREFERENCE_PARAMS[\"gamma\"],\n", - " \"kappa_1\": PREFERENCE_PARAMS[\"kappa_1\"],\n", - " \"kappa_2\": PREFERENCE_PARAMS[\"kappa_2\"],\n", - " \"kappa_3\": PREFERENCE_PARAMS[\"kappa_3\"],\n", - " \"xi\": PREFERENCE_PARAMS[\"xi\"],\n", - " \"b_scale\": PREFERENCE_PARAMS[\"b_scale\"],\n", - " \"eta0_edu\": HUMAN_CAPITAL_PARAMS[\"eta0_edu\"][education],\n", - " \"eta0_high_type\": HUMAN_CAPITAL_PARAMS[\"eta0_high_type\"],\n", - " \"eta1\": HUMAN_CAPITAL_PARAMS[\"eta1_edu\"][education],\n", - " \"eta2\": HUMAN_CAPITAL_PARAMS[\"eta2_edu\"][education],\n", - " \"eta3\": HUMAN_CAPITAL_PARAMS[\"eta3\"],\n", - " \"eta4\": HUMAN_CAPITAL_PARAMS[\"eta4\"],\n", - " \"sigma0\": MISC_PARAMS[\"sigma0\"],\n", - " \"sigma1\": MISC_PARAMS[\"sigma1\"],\n", - " \"tr\": MISC_PARAMS[\"tr\"],\n", - " \"rho_super\": MISC_PARAMS[\"rho_super\"][education],\n", + " \"taste_shock_scale\": pref[\"taste_shock_scale\"],\n", + " \"zeta\": pref[\"zeta\"],\n", + " \"gamma\": jnp.array(pref[\"gamma\"]),\n", + " \"kappa_1\": pref[\"kappa_1\"],\n", + " \"kappa_2\": pref[\"kappa_2\"],\n", + " \"kappa_3\": pref[\"kappa_3\"],\n", + " \"xi\": pref[\"xi\"],\n", + " \"b_scale\": pref[\"b_scale\"],\n", + " \"beta_by_education\": _edu_array(pref[\"beta_by_education\"]),\n", + " \"eta0_edu\": _edu_array(hc[\"eta0_by_education\"]),\n", + " \"eta0_high_type\": hc[\"eta0_high_type\"],\n", + " \"eta1_edu\": _edu_array(hc[\"eta1_by_education\"]),\n", + " \"eta2_edu\": _edu_array(hc[\"eta2_by_education\"]),\n", + " \"eta3\": hc[\"eta3\"],\n", + " \"eta4\": hc[\"eta4\"],\n", + " \"sigma0\": misc[\"sigma0\"],\n", + " \"sigma1\": misc[\"sigma1\"],\n", + " \"tr\": misc[\"tr\"],\n", + " \"rho_super_edu\": _edu_array(misc[\"rho_super_by_education\"]),\n", " }\n", - " p.update(TAX_PARAMS)\n", - " p.update(PENSION_PARAMS)\n", - " p.update(SURVIVAL_PARAMS)\n", - " p.update(FIXED_PARAMS)\n", - "\n", - " # The income shock quadrature is standard-normal; we scale it by the\n", - " # paper's age-varying sigma_t inside the budget constraint itself.\n", + " p.update(CAL[\"tax\"])\n", + " p.update(CAL[\"pension\"])\n", + " p.update(CAL[\"survival\"])\n", + " p.update(CAL[\"fixed\"])\n", " p[\"income_shock_mean\"] = 0.0\n", " p[\"income_shock_std\"] = 1.0\n", - "\n", - " # Policy-experiment toggle (Section 9): 0.0 switches off the Age Pension.\n", - " p[\"pension_scale\"] = 1.0\n", + " p[\"pension_scale\"] = 1.0 # policy-experiment toggle, Section 6\n", + " p[\"wage_scale\"] = 1.0 # elasticity-experiment toggle, Section 7\n", " return p\n", "\n", "\n", - "def build_model_specs(education: str) -> dict:\n", - " t0 = T0_BY_EDUCATION[education]\n", + "def build_model_specs():\n", " return {\n", - " \"education\": education,\n", - " \"t0\": t0,\n", - " \"n_periods\": T_RETIRE - t0 + 1,\n", + " \"t0\": T0,\n", + " \"n_periods\": N_PERIODS,\n", + " \"last_working_period\": LAST_WORKING_PERIOD,\n", " \"hours_by_choice\": HOURS_BY_CHOICE,\n", " \"n_choices\": len(HOURS_BY_CHOICE),\n", + " \"college_index\": COLLEGE_INDEX,\n", + " \"college_start_period\": COLLEGE_START_PERIOD,\n", " }" ] }, { "cell_type": "markdown", - "id": "8432bc1d", + "id": "3c2c3aca", "metadata": {}, "source": [ "## 2. Preferences and the budget constraint\n", @@ -227,40 +184,97 @@ "$$u(c_t) = \\frac{c_t^{1-\\zeta}-1}{1-\\zeta}, \\qquad\n", "v_t(h_t) = \\mathbb{1}\\{h_t>0\\}\\,\\kappa_{\\text{type}}\\,\\kappa_{\\text{age}}(t)\\,\\gamma(h_t).$$\n", "\n", - "**Bequest (eq. 11).** Because dcegm's terminal-period solver assumes\n", - "consumption equals the full wealth at that state (see scope note above), we\n", - "implement the bequest function directly as the *terminal-period* utility,\n", - "applied to the full terminal wealth $b = M$:\n", + "**Bequest (eq. 11-12).** dcegm's terminal-period solver assumes consumption\n", + "equals the full wealth at that state, so we implement the bequest function\n", + "directly as the *terminal-period* utility, applied to the full terminal\n", + "wealth $b = M$:\n", "\n", "$$B(b) = b_{scale}\\frac{(b+a_0)^{1-\\xi}-a_0^{1-\\xi}}{1-\\xi}.$$\n", "\n", + "Eq. (12) of the paper leaves this term **undiscounted**\n", + "($(1-\\delta_t)B(\\cdot)$, no $\\beta$), but dcegm automatically discounts\n", + "*every* value returned by the terminal-period solver by one more $\\beta$\n", + "when the calling period aggregates it. We cancel this by dividing the\n", + "bequest utility (and its marginal utility) by education's $\\beta$\n", + "unconditionally at the dummy terminal period, matching eq. (12) for a death\n", + "at any age, and treating a natural end-of-horizon the same way (the dummy\n", + "period has no economic content of its own either way).\n", + "\n", + "$M$ here is also now the paper's exact $b_t = M_t - c_t$ (eq. 11): the\n", + "budget constraint below returns the *raw* end-of-previous-period assets,\n", + "with no interest, wages, pension or superannuation, for **any** state at\n", + "the dummy period — reached by death at any age (routed there by\n", + "`sparsity_condition`'s proxy, Section 3) or by surviving naturally to 86 —\n", + "rather than the ordinary next-period wealth.\n", + "\n", + "*Numerical caveat.* This period-conditional budget constraint is more\n", + "fragile than the rest of the model: a small share of simulated wealth\n", + "trajectories land in regions where interpolation across this discontinuity\n", + "is unstable and produce implausible outliers, the same failure mode we\n", + "first saw in the Section 6 policy experiment. We did not fully root-cause\n", + "this — it did not resolve across several different ways of structuring the\n", + "branch, which suggests something in how dcegm's terminal-period solver\n", + "handles a discontinuous incoming-wealth mapping, worth a dedicated\n", + "dcegm-level investigation rather than a notebook-level fix. Every profile\n", + "below is reported as a **median** (or, in Section 7, at representative\n", + "non-extreme states) specifically because it is robust to this.\n", + "\n", "**Budget constraint (eqs. 2, 4-6, 27).** dcegm calls the budget constraint\n", "with *this* (child) state's own fields — its own `period`, `lagged_choice`\n", "(the choice made last period, which earned this period's income) and\n", - "`experience` (already updated for this period, see the state-space section\n", - "below). Human capital, and thus the wage, is evaluated at the state's own\n", + "`experience` (already updated for this period, see Section 3). Human\n", + "capital, and thus the wage, is evaluated at the state's own\n", "`(period, experience)`, following the DC-EGM algorithm's steps 2(a)-(b) in\n", "the paper (compute $E_{t+1}$, *then* $K_{t+1}$ from it) rather than the\n", "closed-form subscript in eq. (4). Tax, the means-tested Age Pension, the\n", "one-off superannuation lump sum at 65, and the parental transfer up to age\n", - "23 are all applied to the resulting income stream.\n" + "23 are all applied to the resulting income stream. `params[\"wage_scale\"]`\n", + "multiplies the wage level uniformly; it is 1.0 everywhere except the\n", + "Section 7 elasticity experiment.\n" ] }, { "cell_type": "code", "execution_count": 3, - "id": "ef695322", + "id": "f695f023", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:37.690007Z", - "iopub.status.busy": "2026-08-29T11:55:37.689893Z", - "iopub.status.idle": "2026-08-29T11:55:37.693476Z", - "shell.execute_reply": "2026-08-29T11:55:37.692988Z" + "iopub.execute_input": "2026-08-29T15:06:26.393306Z", + "iopub.status.busy": "2026-08-29T15:06:26.393242Z", + "iopub.status.idle": "2026-08-29T15:06:26.396251Z", + "shell.execute_reply": "2026-08-29T15:06:26.395930Z" } }, "outputs": [], "source": [ - "def utility(consumption, choice, period, high_type, params, model_specs):\n", + "def bequest_utility(wealth, education, params):\n", + " # Eq. (11): value of the bequest itself, b_scale*((b+a0)^(1-xi)-a0^(1-xi))/(1-xi).\n", + " # dcegm discounts every terminal-period value by one more factor of beta\n", + " # when the calling (earlier) period aggregates it, but eq. (12) leaves\n", + " # the bequest term (1-delta_t)*B(.) undiscounted. The dummy period\n", + " # (Section 3) has no economic content of its own -- everyone who\n", + " # reaches it, whether by dying at any age (via sparsity_condition's\n", + " # proxy) or by surviving naturally to age 86, is just settling the\n", + " # estate with whatever is left, so we don't distinguish by `survival`\n", + " # here: dividing by beta unconditionally cancels dcegm's extra\n", + " # discounting for both cases alike.\n", + " a0 = params[\"credit_constraint\"]\n", + " xi = params[\"xi\"]\n", + " beta = params[\"beta_by_education\"][education]\n", + " bequest_value = ((wealth + a0) ** (1 - xi) - a0 ** (1 - xi)) / (1 - xi)\n", + " return params[\"b_scale\"] * bequest_value / beta\n", + "\n", + "\n", + "def bequest_marginal_utility(wealth, education, params):\n", + " a0 = params[\"credit_constraint\"]\n", + " xi = params[\"xi\"]\n", + " beta = params[\"beta_by_education\"][education]\n", + " return params[\"b_scale\"] * (wealth + a0) ** (-xi) / beta\n", + "\n", + "\n", + "def utility(\n", + " consumption, choice, period, high_type, survival, education, params, model_specs\n", + "):\n", " zeta = params[\"zeta\"]\n", " consumption_utility = (consumption ** (1 - zeta) - 1) / (1 - zeta)\n", "\n", @@ -273,12 +287,26 @@ " + params[\"kappa_3\"] * (age - 25.0) * (age < 25)\n", " )\n", " disutility = works * kappa_type * kappa_age * params[\"gamma\"][choice]\n", - "\n", - " return consumption_utility - disutility\n", + " utility_alive = consumption_utility - disutility\n", + "\n", + " # Defensive: sparsity_condition's proxy should mean this state is never\n", + " # actually reached with survival==0 (that always routes to the dummy\n", + " # terminal period instead, using bequest_utility above), but we check\n", + " # here too rather than assume `consumption` is meaningful in that case.\n", + " utility_dead = bequest_utility(\n", + " wealth=consumption, education=education, params=params\n", + " )\n", + " return jnp.where(survival == 0, utility_dead, utility_alive)\n", "\n", "\n", - "def marginal_utility(consumption, choice, period, high_type, params, model_specs):\n", - " return consumption ** (-params[\"zeta\"])\n", + "def marginal_utility(\n", + " consumption, choice, period, high_type, survival, education, params, model_specs\n", + "):\n", + " marginal_utility_alive = consumption ** (-params[\"zeta\"])\n", + " marginal_utility_dead = bequest_marginal_utility(\n", + " wealth=consumption, education=education, params=params\n", + " )\n", + " return jnp.where(survival == 0, marginal_utility_dead, marginal_utility_alive)\n", "\n", "\n", "def inverse_marginal_utility(\n", @@ -287,19 +315,6 @@ " return marginal_utility ** (-1.0 / params[\"zeta\"])\n", "\n", "\n", - "def bequest_utility(wealth, params):\n", - " # Eq. (11), applied to the full terminal wealth (see scope note).\n", - " a0 = params[\"credit_constraint\"]\n", - " xi = params[\"xi\"]\n", - " return params[\"b_scale\"] * ((wealth + a0) ** (1 - xi) - a0 ** (1 - xi)) / (1 - xi)\n", - "\n", - "\n", - "def bequest_marginal_utility(wealth, params):\n", - " a0 = params[\"credit_constraint\"]\n", - " xi = params[\"xi\"]\n", - " return params[\"b_scale\"] * (wealth + a0) ** (-xi)\n", - "\n", - "\n", "def create_utility_function_dict():\n", " return {\n", " \"utility\": utility,\n", @@ -315,13 +330,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "4aef324e", + "id": "0538a32d", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:37.694904Z", - "iopub.status.busy": "2026-08-29T11:55:37.694819Z", - "iopub.status.idle": "2026-08-29T11:55:37.698333Z", - "shell.execute_reply": "2026-08-29T11:55:37.697922Z" + "iopub.execute_input": "2026-08-29T15:06:26.397358Z", + "iopub.status.busy": "2026-08-29T15:06:26.397293Z", + "iopub.status.idle": "2026-08-29T15:06:26.400446Z", + "shell.execute_reply": "2026-08-29T15:06:26.400100Z" } }, "outputs": [], @@ -331,6 +346,8 @@ " lagged_choice,\n", " experience,\n", " high_type,\n", + " education,\n", + " survival,\n", " asset_end_of_previous_period,\n", " income_shock_previous_period,\n", " params,\n", @@ -343,18 +360,23 @@ " # --- human capital & wage, eq. (2) & (4) ---\n", " cum_exp_years = period * experience\n", " log_hc = (\n", - " params[\"eta0_edu\"]\n", + " params[\"eta0_edu\"][education]\n", " + params[\"eta0_high_type\"] * high_type\n", - " + params[\"eta1\"] * cum_exp_years\n", - " + params[\"eta2\"] * cum_exp_years**2\n", + " + params[\"eta1_edu\"][education] * cum_exp_years\n", + " + params[\"eta2_edu\"][education] * cum_exp_years**2\n", " + params[\"eta3\"] * period\n", " + params[\"eta4\"] * period**2\n", " )\n", " sigma_age = params[\"sigma0\"] + params[\"sigma1\"] * age\n", - " wage_per_hour = jnp.exp(log_hc + sigma_age * income_shock_previous_period)\n", + " wage_per_hour = params[\"wage_scale\"] * jnp.exp(\n", + " log_hc + sigma_age * income_shock_previous_period\n", + " )\n", " labor_income = hours_prev * wage_per_hour / 1000.0 # dollars -> $1000s\n", "\n", " # --- income tax, eq. (27) ---\n", + " # NB: we use the continuity-preserving constant rate1*(thld2-thld1); the\n", + " # printed equation's constant (rate1*thld1) creates a small downward\n", + " # jump in tax liability at the second threshold, see notebook.\n", " tax = jnp.where(\n", " labor_income < params[\"thld1\"],\n", " 0.0,\n", @@ -381,78 +403,122 @@ " pension = pension * params[\"pension_scale\"]\n", "\n", " # --- superannuation lump sum, eq. (6), paid once at age 65 ---\n", - " human_capital_level = jnp.exp(log_hc)\n", + " human_capital_level = params[\"wage_scale\"] * jnp.exp(log_hc)\n", " super_payment = jnp.where(\n", " age == params[\"superannuation_age\"],\n", - " params[\"rho_super\"] * human_capital_level,\n", + " params[\"rho_super_edu\"][education] * human_capital_level,\n", " 0.0,\n", " )\n", "\n", " # --- parental transfer, ages t0 to 23 ---\n", " transfer = jnp.where(age <= 23, params[\"tr\"], 0.0)\n", "\n", - " wealth_begin_of_period = (\n", + " wealth_begin_of_period_normal = (\n", " asset_end_of_previous_period * (1 + params[\"interest_rate\"])\n", " + after_tax_labor_income\n", " + pension\n", " + super_payment\n", " + transfer\n", " )\n", - " return jnp.maximum(wealth_begin_of_period, params[\"consumption_floor\"])" + " wealth_begin_of_period_normal = jnp.maximum(\n", + " wealth_begin_of_period_normal, params[\"consumption_floor\"]\n", + " )\n", + "\n", + " # Eq. (11): the bequest is b_t = M_t - c_t -- raw unconsumed savings,\n", + " # no next-period interest or income. sparsity_condition's proxy already\n", + " # redirects every death, at any age, to the canonical dummy period\n", + " # (Section 3), so checking `period` alone should be sufficient -- but we\n", + " # check `survival == 0` too, redundantly, so this state's own fields are\n", + " # sufficient to identify it as a bequest state even if some (period,\n", + " # survival) combination were ever reachable outside that proxy. Not\n", + " # floored at consumption_floor (that floor is meant for positive\n", + " # consumption): the assets grid's own lower bound is exactly -a0, and\n", + " # at wealth == -a0 the bequest marginal utility (wealth+a0)^(-xi)\n", + " # divides by zero, so we use a tiny margin above -a0 instead.\n", + " wealth_begin_of_period_bequest = jnp.maximum(\n", + " asset_end_of_previous_period, -params[\"credit_constraint\"] + 1e-6\n", + " )\n", + "\n", + " is_bequest_period = (period >= model_specs[\"n_periods\"] - 1) | (survival == 0)\n", + " return jnp.where(\n", + " is_bequest_period, wealth_begin_of_period_bequest, wealth_begin_of_period_normal\n", + " )" ] }, { "cell_type": "markdown", - "id": "7acb4e1e", + "id": "1e8623ba", "metadata": {}, "source": [ - "## 3. State space and timing\n", + "## 3. State space, timing, and one solve for everyone\n", "\n", "- **Experience** $E_t \\in [0,1]$ is a *continuous* state (eq. 3), the\n", - " recursive average of hours worked so far — the same pattern as dcegm's\n", - " [`cons_ret_model_with_cont_exp`](../guides/two_occupation_model.ipynb) toy\n", - " model. `next_period_continuous_state` is evaluated at this (child) state's\n", - " own `period`, using the exogenous last-period experience grid value and\n", - " this state's own `lagged_choice` (= hours worked last period).\n", - "- **Unobserved type** (\"high\"/\"low\", Table 7) is a time-invariant\n", - " `deterministic_state`: it never transitions, it just carries through.\n", - "- **Mortality and the bequest motive.** We follow dcegm's standard survival\n", - " pattern (see `tests/sparse_death`): `survival` is a stochastic state with\n", - " age-varying probability $\\delta_t$ (eq. 28); any realized death is routed\n", - " by `sparsity_condition` to a single canonical terminal state, which is\n", - " then solved with the bequest function from Section 2. One consequence:\n", - " dcegm discounts *all* continuation values (including this one) by $\\beta$,\n", - " whereas the paper's eq. (12) leaves the $(1-\\delta_t)B(\\cdot)$ term\n", - " undiscounted. This is a standard, validated dcegm building block, not a\n", - " bit-for-bit reproduction of the paper's timing convention — the economics\n", - " of mortality risk reducing the value of future consumption while\n", - " preserving a bequest motive is preserved.\n", - "- **Compulsory retirement.** Only $h=0$ is feasible in the last (age-85)\n", - " period.\n" + " recursive average of hours worked so far.\n", + "- **Education** (3 groups) and **unobserved type** (\"high\"/\"low\", Table 7)\n", + " are time-invariant `deterministic_states`. College students are\n", + " choice-restricted to $h=0$ (in school) until age 23 via\n", + " `state_specific_choice_set`.\n", + "- **Discount factor.** Education groups have different $\\beta$ (Table 5:\n", + " 0.968/0.967/0.970). Rather than solving three separate models with a\n", + " pooled/approximate $\\beta$, we use `dcegm`'s `discount_factor_per_state`\n", + " hook (`shock_functions={\"discount_factor_per_state\": ...}`) to read the\n", + " *exact* $\\beta$ for each state's own `education` value, inside a single\n", + " `setup_model`/`solve()` call spanning all three education groups and both\n", + " types at once. This is a genuinely exact replication of the paper's\n", + " education-specific discount factors, not an approximation.\n", + "- **Mortality and the bequest motive.** `survival` is a stochastic state\n", + " with age-varying probability $\\delta_t$ (eq. 28); any realized death is\n", + " routed by `sparsity_condition` to a single canonical terminal state, then\n", + " solved with the bequest function from Section 2 (dcegm's standard survival\n", + " pattern, see `tests/sparse_death`) — see Section 2 for how we cancel\n", + " dcegm's automatic discounting on that branch to match eq. (12) exactly,\n", + " and for the one part of the bequest we could not fix.\n", + "- **Compulsory retirement, and a dummy terminal period.** Only $h=0$ is\n", + " feasible from age 85 onward. We give the model **one extra period beyond\n", + " age 85** (`N_PERIODS = T_RETIRE - T0 + 2`) purely so dcegm's terminal-period\n", + " solver — which hardcodes consumption equal to full wealth, and which we\n", + " override with the bequest function — lands on that *dummy* age-86 period\n", + " instead of on age 85 itself. Age 85 then becomes an ordinary EGM-solved\n", + " period: agents choose $c_{85}$ via the normal Euler equation, trading off\n", + " $u(c_{85})$ against $\\beta \\cdot B(M_{86})$, which is exactly eq. (21-22)'s\n", + " consumption/bequest trade-off — rather than the 100%-bequest corner\n", + " solution a literal terminal age 85 would force. This costs nothing beyond\n", + " one extra (trivial, single-choice) period to solve.\n" ] }, { "cell_type": "code", "execution_count": 5, - "id": "ca3d2e18", + "id": "2e0eab28", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:37.699739Z", - "iopub.status.busy": "2026-08-29T11:55:37.699637Z", - "iopub.status.idle": "2026-08-29T11:55:37.703067Z", - "shell.execute_reply": "2026-08-29T11:55:37.702669Z" + "iopub.execute_input": "2026-08-29T15:06:26.401485Z", + "iopub.status.busy": "2026-08-29T15:06:26.401422Z", + "iopub.status.idle": "2026-08-29T15:06:26.404361Z", + "shell.execute_reply": "2026-08-29T15:06:26.404006Z" } }, "outputs": [], "source": [ - "def state_specific_choice_set(period, model_specs):\n", - " if period >= model_specs[\"n_periods\"] - 1:\n", + "def state_specific_choice_set(period, education, model_specs):\n", + " # Compulsory retirement at T_RETIRE, one period before dcegm's own\n", + " # (dummy) terminal period -- see the discussion above.\n", + " if period >= model_specs[\"last_working_period\"]:\n", + " return [0]\n", + " if (education == model_specs[\"college_index\"]) and (\n", + " period < model_specs[\"college_start_period\"]\n", + " ):\n", " return [0]\n", " return list(range(model_specs[\"n_choices\"]))\n", "\n", "\n", - "def next_period_deterministic_state(period, choice, high_type):\n", - " return {\"period\": period + 1, \"lagged_choice\": choice, \"high_type\": high_type}\n", + "def next_period_deterministic_state(period, choice, high_type, education):\n", + " return {\n", + " \"period\": period + 1,\n", + " \"lagged_choice\": choice,\n", + " \"high_type\": high_type,\n", + " \"education\": education,\n", + " }\n", "\n", "\n", "def next_period_continuous_state(period, lagged_choice, experience, model_specs):\n", @@ -468,13 +534,25 @@ " }\n", "\n", "\n", - "def sparsity_condition(period, lagged_choice, high_type, survival, model_specs):\n", + "def sparsity_condition(\n", + " period, lagged_choice, high_type, education, survival, model_specs\n", + "):\n", + " # College students cannot have worked before their career starts, so any\n", + " # state with a nonzero lagged_choice while still \"in school\" is unreachable.\n", + " if (\n", + " (education == model_specs[\"college_index\"])\n", + " and (period <= model_specs[\"college_start_period\"])\n", + " and (lagged_choice != 0)\n", + " ):\n", + " return False\n", + "\n", " last_period = model_specs[\"n_periods\"] - 1\n", " period_out = last_period if survival == 0 else period\n", " return {\n", " \"period\": period_out,\n", " \"lagged_choice\": lagged_choice,\n", " \"high_type\": high_type,\n", + " \"education\": education,\n", " \"survival\": survival,\n", " }\n", "\n", @@ -498,39 +576,25 @@ " - params[\"a\"] * (jnp.exp(params[\"b\"] * (age - params[\"age_threshold\"])) - 1.0),\n", " )\n", " delta = jnp.clip(delta, 0.0, 1.0)\n", - " return jnp.array([1.0 - delta, delta]) # [P(survival=0), P(survival=1)]" - ] - }, - { - "cell_type": "markdown", - "id": "ff8ca9b5", - "metadata": {}, - "source": [ - "## 4. Solve one education group and look at the policy functions\n", - "\n", - "Education groups differ in discount factor and human-capital constants\n", - "(both fixed, not state-dependent), so — as in the paper's own computational\n", - "approach — we solve one `dcegm` model per education group rather than\n", - "adding education as a state dimension. Within each solve, the unobserved\n", - "type is a `deterministic_state`.\n", - "\n", - "We use a two-segment asset grid: dense and linear near the credit\n", - "constraint (down to $-a_0$), then log-spaced out to a very large upper\n", - "bound, since lifetime wealth for high earners can compound to several\n", - "million dollars by the 80s under this (undiscounted-by-the-pension-safety-net)\n", - "calibration.\n" + " return jnp.array([1.0 - delta, delta]) # [P(survival=0), P(survival=1)]\n", + "\n", + "\n", + "def discount_factor_per_state(education, params):\n", + " # Exact education-specific beta (Table 5), read per state -- see the\n", + " # dcegm feature note above.\n", + " return params[\"beta_by_education\"][education]" ] }, { "cell_type": "code", "execution_count": 6, - "id": "4747b3f9", + "id": "b0fd64e6", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:37.704252Z", - "iopub.status.busy": "2026-08-29T11:55:37.704172Z", - "iopub.status.idle": "2026-08-29T11:55:38.919194Z", - "shell.execute_reply": "2026-08-29T11:55:38.918614Z" + "iopub.execute_input": "2026-08-29T15:06:26.405389Z", + "iopub.status.busy": "2026-08-29T15:06:26.405332Z", + "iopub.status.idle": "2026-08-29T15:06:34.845859Z", + "shell.execute_reply": "2026-08-29T15:06:34.845293Z" } }, "outputs": [ @@ -545,10 +609,53 @@ "State, state-choice and child state mapping created.\n", "\n", "Start creating batches for the model.\n", - "The batch size of the backwards induction is 72\n", + "The batch size of the backwards induction is 216\n", + "The batch size of the backwards induction is 211\n", + "The batch size of the backwards induction is 206\n", + "The batch size of the backwards induction is 201\n", + "The batch size of the backwards induction is 196\n", + "The batch size of the backwards induction is 192\n", + "The batch size of the backwards induction is 188\n", + "The batch size of the backwards induction is 184\n", + "The batch size of the backwards induction is 180\n", + "The batch size of the backwards induction is 176\n", + "The batch size of the backwards induction is 172\n", + "The batch size of the backwards induction is 168\n", + "The batch size of the backwards induction is 164\n", + "The batch size of the backwards induction is 160\n", + "The batch size of the backwards induction is 156\n", + "The batch size of the backwards induction is 152\n", + "The batch size of the backwards induction is 148\n", + "The batch size of the backwards induction is 145\n", + "The batch size of the backwards induction is 142\n", + "The batch size of the backwards induction is 139\n", + "The batch size of the backwards induction is 136\n", + "The batch size of the backwards induction is 133\n", + "The batch size of the backwards induction is 130\n", + "The batch size of the backwards induction is 127\n", + "The batch size of the backwards induction is 124\n", + "The batch size of the backwards induction is 121\n", "Model setup complete.\n", "\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/maxblesch/Uni/dcegm/dcegm/src/dcegm/pre_processing/model_structure/state_choice_space.py:298: UserWarning: \n", + "\n", + "\n", + "\n", + " Some states are not child states of any state-choice combination or stochastic transition. Please revisit the sparsity condition. \n", + " \n", + "An example of a state that is not a child state is: \n", + " \n", + "{'period': np.uint8(67), 'lagged_choice': np.uint8(1), 'high_type': np.uint8(0), 'education': np.uint8(0), 'survival': np.uint8(1)} \n", + " \n", + "\n", + " warnings.warn(\n" + ] } ], "source": [ @@ -561,55 +668,70 @@ "EXPERIENCE_GRID = jnp.linspace(0.0, 1.0, 8)\n", "N_QUAD_POINTS = 5\n", "\n", + "model_specs = build_model_specs()\n", + "model_config = {\n", + " \"n_periods\": model_specs[\"n_periods\"],\n", + " \"choices\": np.arange(model_specs[\"n_choices\"], dtype=int),\n", + " \"deterministic_states\": {\n", + " \"high_type\": np.arange(2, dtype=int),\n", + " \"education\": np.arange(3, dtype=int),\n", + " },\n", + " \"continuous_states\": {\n", + " \"assets_end_of_period\": ASSETS_GRID,\n", + " \"experience\": EXPERIENCE_GRID,\n", + " },\n", + " \"stochastic_states\": {\"survival\": [0, 1]},\n", + " \"n_quad_points\": N_QUAD_POINTS,\n", + "}\n", "\n", - "def build_model(education):\n", - " model_specs = build_model_specs(education)\n", - " model_config = {\n", - " \"n_periods\": model_specs[\"n_periods\"],\n", - " \"choices\": np.arange(model_specs[\"n_choices\"], dtype=int),\n", - " \"deterministic_states\": {\"high_type\": np.arange(2, dtype=int)},\n", - " \"continuous_states\": {\n", - " \"assets_end_of_period\": ASSETS_GRID,\n", - " \"experience\": EXPERIENCE_GRID,\n", - " },\n", - " \"stochastic_states\": {\"survival\": [0, 1]},\n", - " \"n_quad_points\": N_QUAD_POINTS,\n", - " }\n", - " model = dcegm.setup_model(\n", - " model_config=model_config,\n", - " model_specs=model_specs,\n", - " utility_functions=create_utility_function_dict(),\n", - " utility_functions_final_period=create_final_period_utility_function_dict(),\n", - " state_space_functions=create_state_space_function_dict(),\n", - " budget_constraint=budget_constraint,\n", - " stochastic_states_transitions={\"survival\": prob_survival},\n", - " )\n", - " return model, model_specs\n", - "\n", + "model = dcegm.setup_model(\n", + " model_config=model_config,\n", + " model_specs=model_specs,\n", + " utility_functions=create_utility_function_dict(),\n", + " utility_functions_final_period=create_final_period_utility_function_dict(),\n", + " state_space_functions=create_state_space_function_dict(),\n", + " budget_constraint=budget_constraint,\n", + " stochastic_states_transitions={\"survival\": prob_survival},\n", + " shock_functions={\"discount_factor_per_state\": discount_factor_per_state},\n", + ")\n", "\n", - "model_hs, model_specs_hs = build_model(\"highschool\")\n", - "params_hs = build_params(\"highschool\")\n", - "model_hs_solved = model_hs.solve(params_hs)" + "params_baseline = build_params()\n", + "model_solved = model.solve(params_baseline)" + ] + }, + { + "cell_type": "markdown", + "id": "ae919b76", + "metadata": {}, + "source": [ + "## 4. DC-EGM in action: kinked policy and value functions\n", + "\n", + "Section 4 of the paper describes exactly why DC-EGM is needed here: combining\n", + "a discrete hours choice with a continuous savings choice creates kinks in the\n", + "value function and discontinuities in the policy function, which first-order\n", + "conditions alone cannot characterize. The plot below reproduces that\n", + "signature directly from our solved model, for a mid-career, high-type\n", + "worker.\n" ] }, { "cell_type": "code", "execution_count": 7, - "id": "29cf9f2a", + "id": "34ba4cd5", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:38.921355Z", - "iopub.status.busy": "2026-08-29T11:55:38.921224Z", - "iopub.status.idle": "2026-08-29T11:55:41.283489Z", - "shell.execute_reply": "2026-08-29T11:55:41.282932Z" + "iopub.execute_input": "2026-08-29T15:06:34.847201Z", + "iopub.status.busy": "2026-08-29T15:06:34.847123Z", + "iopub.status.idle": "2026-08-29T15:06:35.965793Z", + "shell.execute_reply": "2026-08-29T15:06:35.965485Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -617,209 +739,583 @@ } ], "source": [ - "# Choice-specific consumption policy and value functions at age ~39\n", - "# (period 20), for a mid-experience, high-type worker. This is exactly the\n", - "# kind of picture Section 4 of the paper describes: combining a discrete\n", - "# choice with a continuous one creates kinks in the value function and\n", - "# discontinuities in the policy function, which is what DC-EGM's upper\n", - "# envelope step is built to resolve.\n", "period_to_plot = 20\n", - "wealth_grid = jnp.linspace(0.1, 150.0, 400)\n", + "wealth_grid = jnp.linspace(0.1, 150.0, 300)\n", "\n", - "fig, axes = plt.subplots(1, 2, figsize=(11, 4.2))\n", - "for choice in range(model_specs_hs[\"n_choices\"]):\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.6))\n", + "for choice in range(model_specs[\"n_choices\"]):\n", " states = {\n", " \"period\": jnp.full_like(wealth_grid, period_to_plot, dtype=int),\n", " \"lagged_choice\": jnp.zeros_like(wealth_grid, dtype=int),\n", " \"high_type\": jnp.ones_like(wealth_grid, dtype=int),\n", + " \"education\": jnp.ones_like(wealth_grid, dtype=int), # highschool\n", " \"survival\": jnp.ones_like(wealth_grid, dtype=int),\n", " \"experience\": jnp.full_like(wealth_grid, 0.5),\n", " \"assets_begin_of_period\": wealth_grid,\n", " }\n", " choices = jnp.full_like(wealth_grid, choice, dtype=int)\n", - " policy, value = model_hs_solved.policy_and_value_for_states_and_choices(\n", + " policy, value = model_solved.policy_and_value_for_states_and_choices(\n", " states=states, choices=choices\n", " )\n", - " hours = int(model_specs_hs[\"hours_by_choice\"][choice])\n", - " axes[0].plot(wealth_grid, policy, label=f\"h={hours}\")\n", - " axes[1].plot(wealth_grid, value, label=f\"h={hours}\")\n", + " hours = int(model_specs[\"hours_by_choice\"][choice])\n", + " axes[0].plot(wealth_grid, policy, label=f\"h={hours}\", lw=1.3)\n", + " axes[1].plot(wealth_grid, value, label=f\"h={hours}\", lw=1.3)\n", "\n", - "axes[0].set_xlabel(\"Beginning-of-period wealth $M_t$ ($1000)\")\n", + "axes[0].set_xlabel(\"Wealth $M_t$ ($1000)\")\n", "axes[0].set_ylabel(\"Consumption policy $c_t$\")\n", - "axes[0].set_title(\"Choice-specific consumption policy\")\n", - "axes[1].set_xlabel(\"Beginning-of-period wealth $M_t$ ($1000)\")\n", - "axes[1].set_ylabel(\"Choice-specific value $W_t$\")\n", - "axes[1].set_title(\"Choice-specific value function\")\n", - "axes[0].legend(fontsize=8)\n", + "axes[0].set_title(\"Consumption policy\")\n", + "axes[1].set_xlabel(\"Wealth $M_t$ ($1000)\")\n", + "axes[1].set_ylabel(\"Value $W_t$\")\n", + "axes[1].set_title(\"Value function\")\n", + "axes[0].legend(fontsize=7)\n", "fig.tight_layout()" ] }, { "cell_type": "markdown", - "id": "003eae80", + "id": "61472c48", "metadata": {}, "source": [ - "## 5. Simulate all three education groups\n", - "\n", - "We solve and simulate dropouts, high-school and college graduates\n", - "separately, drawing the unobserved type for each simulated agent from the\n", - "paper's estimated type shares (Table 7), and compare simulated life-cycle\n", - "profiles against the qualitative shapes in the paper's Figures 5-8: rising\n", - "then plateauing participation, a hump/monotonic rise in wealth, and a clear\n", - "jump in wealth at 65 from the superannuation lump sum. We are calibrating,\n", - "not re-estimating, so we should not expect to match levels — the paper's\n", - "own Figure 8 shows wealth around \\$1M (college), \\$500k (high school) and\n", - "\\$400k (dropout) at age 70, using moments fit to HILDA.\n" + "## 5. Simulating the population\n", + "\n", + "We simulate all education groups and both types in one call, drawing the\n", + "unobserved type for each agent from the paper's estimated type shares\n", + "(Table 7). We are calibrating, not re-estimating, so we compare shapes\n", + "against the paper's Figures 5-8, not levels — the paper's own Figure 8 shows\n", + "wealth around \\$1M (college), \\$500k (high school) and \\$400k (dropout) at\n", + "age 70, using moments fit to HILDA that we do not target here.\n" ] }, { "cell_type": "code", "execution_count": 8, - "id": "f20a32ee", + "id": "50fc6f82", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T15:06:35.967131Z", + "iopub.status.busy": "2026-08-29T15:06:35.967058Z", + "iopub.status.idle": "2026-08-29T15:06:37.566941Z", + "shell.execute_reply": "2026-08-29T15:06:37.566441Z" + } + }, + "outputs": [], + "source": [ + "N_AGENTS = 6000\n", + "rng = np.random.default_rng(0)\n", + "education_draw = rng.integers(0, 3, N_AGENTS)\n", + "high_type_shares = np.array(\n", + " [CAL[\"misc\"][\"high_type_share_by_education\"][e] for e in EDUCATION_GROUPS]\n", + ")\n", + "high_type_draw = rng.binomial(1, high_type_shares[education_draw])\n", + "\n", + "states_initial = {\n", + " \"period\": jnp.zeros(N_AGENTS, dtype=int),\n", + " \"lagged_choice\": jnp.zeros(N_AGENTS, dtype=int),\n", + " \"high_type\": jnp.array(high_type_draw, dtype=int),\n", + " \"education\": jnp.array(education_draw, dtype=int),\n", + " \"survival\": jnp.ones(N_AGENTS, dtype=int),\n", + " \"experience\": jnp.zeros(N_AGENTS),\n", + " \"assets_begin_of_period\": jnp.ones(N_AGENTS) * 2.0,\n", + "}\n", + "sim_baseline = model_solved.simulate(states_initial=states_initial, seed=1)\n", + "sim_baseline = sim_baseline.reset_index()\n", + "sim_baseline[\"age\"] = model_specs[\"t0\"] + sim_baseline[\"period\"]\n", + "sim_baseline[\"hours\"] = np.array(model_specs[\"hours_by_choice\"])[\n", + " sim_baseline[\"choice\"].to_numpy()\n", + "]\n", + "sim_baseline[\"education_label\"] = np.array(EDUCATION_GROUPS)[\n", + " sim_baseline[\"education\"].to_numpy()\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bd244336", "metadata": { "execution": { - "iopub.execute_input": "2026-08-29T11:55:41.285382Z", - "iopub.status.busy": "2026-08-29T11:55:41.285258Z", - "iopub.status.idle": "2026-08-29T11:55:49.888371Z", - "shell.execute_reply": "2026-08-29T11:55:49.887769Z" + "iopub.execute_input": "2026-08-29T15:06:37.568289Z", + "iopub.status.busy": "2026-08-29T15:06:37.568215Z", + "iopub.status.idle": "2026-08-29T15:06:37.729136Z", + "shell.execute_reply": "2026-08-29T15:06:37.728611Z" } }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting state space creation\n", - "State space created.\n", - "\n", - "Starting state-choice space creation and child state mapping.\n", - "State, state-choice and child state mapping created.\n", - "\n", - "Start creating batches for the model.\n", - "The batch size of the backwards induction is 72\n", - "Model setup complete.\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting state space creation\n", - "State space created.\n", - "\n", - "Starting state-choice space creation and child state mapping.\n", - "State, state-choice and child state mapping created.\n", - "\n", - "Start creating batches for the model.\n", - "The batch size of the backwards induction is 72\n", - "Model setup complete.\n", - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Starting state space creation\n", - "State space created.\n", - "\n", - "Starting state-choice space creation and child state mapping.\n", - "State, state-choice and child state mapping created.\n", - "\n", - "Start creating batches for the model.\n", - "The batch size of the backwards induction is 72\n", - "Model setup complete.\n", - "\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "N_AGENTS = 2000\n", - "all_sims = []\n", - "\n", - "for education in EDUCATION_GROUPS:\n", - " model, model_specs = build_model(education)\n", - " params = build_params(education)\n", - " model_solved = model.solve(params)\n", - "\n", - " high_type_share = MISC_PARAMS[\"high_type_share\"][education]\n", - " states_initial = {\n", - " \"period\": jnp.zeros(N_AGENTS, dtype=int),\n", - " \"lagged_choice\": jnp.zeros(N_AGENTS, dtype=int),\n", - " \"high_type\": jnp.array(\n", - " np.random.default_rng(0).binomial(1, high_type_share, N_AGENTS), dtype=int\n", - " ),\n", - " \"survival\": jnp.ones(N_AGENTS, dtype=int),\n", - " \"experience\": jnp.zeros(N_AGENTS),\n", - " \"assets_begin_of_period\": jnp.ones(N_AGENTS) * 2.0,\n", - " }\n", - " df = model_solved.simulate(states_initial=states_initial, seed=1)\n", - "\n", - " df[\"age\"] = model_specs[\"t0\"] + df.index.get_level_values(\"period\")\n", - " df[\"hours\"] = np.array(model_specs[\"hours_by_choice\"])[df[\"choice\"].to_numpy()]\n", - " df[\"education\"] = education\n", - " all_sims.append(df.reset_index())\n", + "fig, axes = plt.subplots(1, 3, figsize=(12, 3.6))\n", + "colors = {\"dropout\": \"tab:green\", \"highschool\": \"tab:red\", \"college\": \"tab:blue\"}\n", + "\n", + "for edu, g in sim_baseline.groupby(\"education_label\"):\n", + " prof = g.groupby(\"age\").agg(\n", + " frac_working=(\"hours\", lambda s: (s > 0).mean()),\n", + " mean_hours=(\"hours\", \"mean\"),\n", + " median_wealth=(\"assets_begin_of_period\", \"median\"),\n", + " )\n", + " axes[0].plot(prof.index, prof[\"frac_working\"], label=edu, color=colors[edu])\n", + " axes[1].plot(prof.index, prof[\"mean_hours\"], label=edu, color=colors[edu])\n", + " axes[2].plot(\n", + " prof.index[:-1], prof[\"median_wealth\"][:-1], label=edu, color=colors[edu]\n", + " )\n", "\n", - "sim_all = pd.concat(all_sims, ignore_index=True)" + "axes[0].set_title(\"Labor force participation\")\n", + "axes[0].set_xlabel(\"Age\")\n", + "axes[1].set_title(\"Mean annual hours\")\n", + "axes[1].set_xlabel(\"Age\")\n", + "axes[2].set_title(\"Median wealth ($1000)\")\n", + "axes[2].set_xlabel(\"Age\")\n", + "for ax in axes:\n", + " ax.legend(fontsize=7)\n", + "fig.tight_layout()" ] }, { "cell_type": "markdown", - "id": "2c16b8b0", + "id": "ff3d9e2c", "metadata": {}, "source": [ "## 6. Policy experiment: eliminating the Age Pension\n", "\n", "Section 9 of the paper studies what happens if the Age Pension is removed\n", - "entirely. We replicate the qualitative direction of that experiment for the\n", - "high-school group using the `pension_scale` toggle we built into the\n", - "budget constraint: without the means-tested safety net, agents have a\n", - "stronger incentive to self-insure through private saving (and, to a lesser\n", - "extent, by working more) near and after 65.\n", - "\n", - "*Note:* we report **median** (not mean) wealth. A small share of simulated\n", - "paths under the no-pension counterfactual land in the sparsely-gridded tail\n", - "of the assets grid, where linear interpolation is numerically unstable and\n", - "produces implausible outliers; the median is robust to this and the\n", - "qualitative comparison is unaffected. A denser/wider grid in that region\n", - "would remove the artifact, at the cost of a slower solve.\n" + "entirely. We replicate the qualitative direction of that experiment using\n", + "the `pension_scale` toggle built into the budget constraint: without the\n", + "means-tested safety net, agents have a stronger incentive to self-insure\n", + "through private saving near and after 65.\n", + "\n", + "*Note:* we report **median** wealth. A small share of simulated paths under\n", + "the no-pension counterfactual land in the sparsely-gridded tail of the\n", + "assets grid, where linear interpolation is numerically unstable and\n", + "produces implausible outliers; the median is robust to this.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e5846efd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T15:06:37.730441Z", + "iopub.status.busy": "2026-08-29T15:06:37.730347Z", + "iopub.status.idle": "2026-08-29T15:06:45.015585Z", + "shell.execute_reply": "2026-08-29T15:06:45.015147Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "params_no_pension = build_params()\n", + "params_no_pension[\"pension_scale\"] = 0.0\n", + "model_no_pension = model.solve(params_no_pension)\n", + "sim_no_pension = model_no_pension.simulate(states_initial=states_initial, seed=1)\n", + "sim_no_pension = sim_no_pension.reset_index()\n", + "sim_no_pension[\"age\"] = model_specs[\"t0\"] + sim_no_pension[\"period\"]\n", + "sim_no_pension[\"hours\"] = np.array(model_specs[\"hours_by_choice\"])[\n", + " sim_no_pension[\"choice\"].to_numpy()\n", + "]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(9.5, 3.6))\n", + "for label, df in [(\"baseline\", sim_baseline), (\"no age pension\", sim_no_pension)]:\n", + " prof = df.groupby(\"age\").agg(\n", + " frac_working=(\"hours\", lambda s: (s > 0).mean()),\n", + " median_wealth=(\"assets_begin_of_period\", \"median\"),\n", + " )\n", + " axes[0].plot(prof.index, prof[\"frac_working\"], label=label)\n", + " axes[1].plot(prof.index[:-1], prof[\"median_wealth\"][:-1], label=label)\n", + "\n", + "axes[0].set_xlim(55, 85)\n", + "axes[0].set_title(\"Labor force participation\")\n", + "axes[0].set_xlabel(\"Age\")\n", + "axes[0].legend(fontsize=8)\n", + "axes[1].set_xlim(55, 85)\n", + "axes[1].set_title(\"Median wealth ($1000)\")\n", + "axes[1].set_xlabel(\"Age\")\n", + "axes[1].legend(fontsize=8)\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "886c45db", + "metadata": {}, + "source": [ + "## 7. A quantitative check: the labor supply elasticity to a permanent wage change\n", + "\n", + "Everything so far compares *shapes*. Here we compare a **number** the paper\n", + "itself reports as a structural implication of its estimated model — not a\n", + "data-fit target, but a property of the solved policy functions, which makes\n", + "it exactly the kind of object we can check independently: if our\n", + "implementation is faithful, evaluating the same experiment on our solved\n", + "model should give a broadly similar answer.\n", + "\n", + "The paper reports (Section 1) that, from an **unanticipated, permanent**\n", + "wage change, \"Marshallian elasticities are very small prior to age 45, but\n", + "grow to about 0.80 at age 60, and 1.75 at age 65.\" We compute the analogous\n", + "object: solve the model twice — once at the baseline wage, once with every\n", + "wage permanently 1% higher (`params[\"wage_scale\"] = 1.01`, an unanticipated\n", + "shift since the agent solves as if it were always true) — and compare the\n", + "**expected hours** $E[h] = \\sum_k P(h_t = h^{(k)})\\,h^{(k)}$ implied by the\n", + "solved choice-specific value functions and the paper's own logit formula\n", + "(eq. 17), $P(h^{(k)}) \\propto \\exp(W(h^{(k)})/\\lambda)$, at a representative\n", + "state for each age and education group (median simulated assets and\n", + "experience from the baseline population in Section 5).\n", + "\n", + "**Why this won't match exactly.** Holding assets and experience fixed at one\n", + "representative point isolates the *intensive margin* — how much someone\n", + "already near the middle of the distribution adjusts their hours. Evaluated\n", + "across the full simulated cross-section instead, the comparison becomes\n", + "numerically delicate: DC-EGM policy functions are genuinely kinked, so two\n", + "separately-solved models can place a kink at slightly different wealth\n", + "levels, and a handful of simulated wealth points landing near one of those\n", + "kinks can swing a population average by an order of magnitude — an artifact\n", + "of point evaluation near a kink, not a real behavioral response. The paper's\n", + "large, sharply rising elasticities at 60-65 are most plausibly driven\n", + "substantially by the *extensive margin* — a wage rise tipping people who are\n", + "near the margin of retiring into staying employed, given Age Pension\n", + "eligibility at 65 — which a single representative (non-marginal) state\n", + "cannot capture by construction. So we expect our numbers to be smaller and\n", + "flatter across age than the paper's, and they are; what we're checking is\n", + "that the sign and rough order of magnitude are sane, not that the point\n", + "estimates match.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "76fd14aa", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-29T15:06:45.016921Z", + "iopub.status.busy": "2026-08-29T15:06:45.016832Z", + "iopub.status.idle": "2026-08-29T15:06:52.947500Z", + "shell.execute_reply": "2026-08-29T15:06:52.947163Z" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
educationageE[hours] baseE[hours] +1% wageelasticitypaper (all groups, approx.)
0dropout302279.3782280.2440.038~0
1dropout452312.5992316.5330.170~0
2dropout602269.0812272.9580.171~0.80
3dropout652150.6352158.0600.345~1.75
4highschool302260.1742263.0140.126~0
5highschool452320.4922325.1210.199~0
6highschool602268.9742272.9140.174~0.80
7highschool652232.9762238.8800.264~1.75
8college302323.3832326.4760.133~0
9college452357.6532362.2770.196~0
10college602304.8582309.5890.205~0.80
11college652307.8992312.9990.221~1.75
\n", + "
" + ], + "text/plain": [ + " education age E[hours] base E[hours] +1% wage elasticity \\\n", + "0 dropout 30 2279.378 2280.244 0.038 \n", + "1 dropout 45 2312.599 2316.533 0.170 \n", + "2 dropout 60 2269.081 2272.958 0.171 \n", + "3 dropout 65 2150.635 2158.060 0.345 \n", + "4 highschool 30 2260.174 2263.014 0.126 \n", + "5 highschool 45 2320.492 2325.121 0.199 \n", + "6 highschool 60 2268.974 2272.914 0.174 \n", + "7 highschool 65 2232.976 2238.880 0.264 \n", + "8 college 30 2323.383 2326.476 0.133 \n", + "9 college 45 2357.653 2362.277 0.196 \n", + "10 college 60 2304.858 2309.589 0.205 \n", + "11 college 65 2307.899 2312.999 0.221 \n", + "\n", + " paper (all groups, approx.) \n", + "0 ~0 \n", + "1 ~0 \n", + "2 ~0.80 \n", + "3 ~1.75 \n", + "4 ~0 \n", + "5 ~0 \n", + "6 ~0.80 \n", + "7 ~1.75 \n", + "8 ~0 \n", + "9 ~0 \n", + "10 ~0.80 \n", + "11 ~1.75 " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "params_wage_shock = build_params()\n", + "params_wage_shock[\"wage_scale\"] = 1.01\n", + "model_wage_shock = model.solve(params_wage_shock)\n", + "\n", + "\n", + "def expected_hours(\n", + " model_solved, params, period, education, high_type, experience, assets\n", + "):\n", + " # E[hours] via the logit CCP formula (eq. 17) applied to the solved\n", + " # choice-specific value functions at one state.\n", + " n_choices = model_specs[\"n_choices\"]\n", + " states = {\n", + " \"period\": jnp.full((n_choices,), period, dtype=int),\n", + " \"lagged_choice\": jnp.zeros((n_choices,), dtype=int),\n", + " \"high_type\": jnp.full((n_choices,), high_type, dtype=int),\n", + " \"education\": jnp.full((n_choices,), education, dtype=int),\n", + " \"survival\": jnp.ones((n_choices,), dtype=int),\n", + " \"experience\": jnp.full((n_choices,), experience),\n", + " \"assets_begin_of_period\": jnp.full((n_choices,), assets),\n", + " }\n", + " choices = jnp.arange(n_choices)\n", + " _, values = model_solved.policy_and_value_for_states_and_choices(\n", + " states=states, choices=choices\n", + " )\n", + " ccp = jax.nn.softmax(values / params[\"taste_shock_scale\"])\n", + " return float(jnp.sum(ccp * HOURS_BY_CHOICE))\n", + "\n", + "\n", + "rows = []\n", + "for edu in EDUCATION_GROUPS:\n", + " edu_idx = EDUCATION_GROUPS.index(edu)\n", + " for age in [30, 45, 60, 65]:\n", + " period = age - model_specs[\"t0\"]\n", + " sub = sim_baseline[\n", + " (sim_baseline[\"education_label\"] == edu) & (sim_baseline[\"age\"] == age)\n", + " ]\n", + " if len(sub) == 0:\n", + " continue\n", + " rep_assets = float(sub[\"assets_begin_of_period\"].median())\n", + " rep_experience = float(sub[\"experience\"].median())\n", + " rep_type = int(sub[\"high_type\"].mode().iloc[0])\n", + "\n", + " h_base = expected_hours(\n", + " model_solved,\n", + " params_baseline,\n", + " period,\n", + " edu_idx,\n", + " rep_type,\n", + " rep_experience,\n", + " rep_assets,\n", + " )\n", + " h_shock = expected_hours(\n", + " model_wage_shock,\n", + " params_wage_shock,\n", + " period,\n", + " edu_idx,\n", + " rep_type,\n", + " rep_experience,\n", + " rep_assets,\n", + " )\n", + " elasticity = (\n", + " (h_shock - h_base) / h_base / (params_wage_shock[\"wage_scale\"] - 1.0)\n", + " )\n", + " rows.append(\n", + " {\n", + " \"education\": edu,\n", + " \"age\": age,\n", + " \"E[hours] base\": h_base,\n", + " \"E[hours] +1% wage\": h_shock,\n", + " \"elasticity\": elasticity,\n", + " }\n", + " )\n", + "\n", + "elasticity_table = pd.DataFrame(rows)\n", + "paper_marshallian = {30: \"~0\", 45: \"~0\", 60: \"~0.80\", 65: \"~1.75\"}\n", + "elasticity_table[\"paper (all groups, approx.)\"] = elasticity_table[\"age\"].map(\n", + " paper_marshallian\n", + ")\n", + "elasticity_table.round(3)" ] }, { "cell_type": "markdown", - "id": "f6615f18", + "id": "e7bcdcc2", "metadata": {}, "source": [ - "## 7. Where this differs from the paper, and how to extend it\n", + "## 8. Where this differs from the paper, and how to extend it\n", "\n", - "This notebook favors a fast, readable first pass over an exact\n", - "reproduction. The most consequential simplifications, all noted where they\n", - "occur above, are:\n", + "This notebook favors a fast, readable pass over an exact reproduction. Once\n", + "more: **we replicate the model, not the estimation** — everything below is a\n", + "simplification of the *mechanism*, not a data-fitting choice. The most\n", + "consequential ones, all noted where they occur above, are:\n", "\n", "1. **Calibrated, not estimated.** We use the paper's published point\n", " estimates directly; no MSM estimation against HILDA is performed.\n", "2. **Stationary policy regime.** The Age Pension and tax rules are held at\n", " their post-2010 values for the whole simulated cohort.\n", - "3. **Terminal bequest.** Both natural termination at 85 and death before it\n", - " are valued by bequeathing 100% of terminal wealth, since dcegm's\n", - " terminal-period solver assumes consumption equals full wealth. The\n", - " paper's own terminal period (eq. 21-22) allows a genuine consumption/\n", - " bequest trade-off even at the maximum age.\n", - "4. **Discounted bequest.** Because we implement mortality risk via dcegm's\n", - " standard stochastic-survival pattern, the bequest term is discounted by\n", - " $\\beta$ once, unlike the undiscounted $(1-\\delta_t)B(\\cdot)$ term in\n", - " eq. (12) of the paper.\n", - "5. **Modest grids.** `ASSETS_GRID`/`EXPERIENCE_GRID` above are sized to keep\n", + "3. **Bequest numerical stability.** The bequest is now evaluated on eq. (11)'s\n", + " exact $b_t = M_t - c_t$ (Section 2), but the discontinuous,\n", + " period-conditional budget constraint this requires is numerically\n", + " fragile: a small share of simulated trajectories land in unstable\n", + " interpolation regions and produce implausible outliers. We report\n", + " medians (and representative-state evaluations in Section 7)\n", + " specifically to be robust to this; see Section 2 for what we tried.\n", + "4. **Modest grids.** `ASSETS_GRID`/`EXPERIENCE_GRID` above are sized to keep\n", " this notebook fast; a finer grid (particularly in the far tail of\n", - " assets) would remove the numerical artifact noted in Section 6 and\n", - " likely tighten the life-cycle profiles in Section 5.\n", - "\n", - "None of these change the qualitative mechanism: a discrete hours choice\n", - "combined with continuous savings under a means-tested pension produces\n", - "exactly the kind of kinked, non-concave choice-specific value functions\n", - "that DC-EGM was built to solve (Section 4), and removing the pension safety\n", - "net raises private saving, as the paper's own policy experiment finds.\n" + " assets) would tighten the life-cycle profiles in Section 5 and the\n", + " elasticity estimates in Section 7.\n", + "5. **Elasticity, not Frisch.** Section 7 computes a Marshallian-type\n", + " (permanent, unanticipated) elasticity at a single representative state\n", + " per age/education; it is not a rigorous replication of the paper's\n", + " Frisch elasticity (a temporary-shock, marginal-utility-of-wealth-held-\n", + " fixed object), which would require a different experimental design.\n", + "\n", + "What *isn't* a simplification any more: the discount factor is the paper's\n", + "exact education-specific $\\beta$ (Section 3, via `discount_factor_per_state`),\n", + "the bequest term is exactly undiscounted and evaluated on raw savings as\n", + "eq. (11)-(12) require (Section 2, modulo the numerical caveat above), age 85\n", + "now faces a genuine consumption/bequest trade-off rather than a\n", + "100%-bequest corner solution (Section 3's dummy terminal period), and every\n", + "parameter value in `params.yaml` is copied verbatim from the paper's own\n", + "tables. None of the above changes the qualitative mechanism: a discrete\n", + "hours choice combined with continuous savings under a means-tested pension\n", + "produces exactly the kind of kinked, non-concave choice-specific value\n", + "functions DC-EGM was built to solve (Section 4), and removing the pension\n", + "safety net raises private saving, as the paper's own policy experiment\n", + "finds (Section 6).\n" ] } ], diff --git a/docs/source/replications/params.yaml b/docs/source/replications/params.yaml new file mode 100644 index 00000000..2ded6bd2 --- /dev/null +++ b/docs/source/replications/params.yaml @@ -0,0 +1,107 @@ +--- +# Calibration for the Iskhakov & Keane (2021) replication notebook. +# +# All monetary values are in $1000 AUD, matching the paper. Values are the +# paper's own published point estimates (not re-estimated here): +# - Table 5 (preference parameters), Table 6 (human capital), Table 7 (misc) +# of the supplementary material. +# - Eq. (27) tax function, main paper page 20. +# - Eq. (2)/(3) survival + pension function, supplementary material page 15-16 +# (we use the post-2010 pension regime constant throughout; see notebook). +# - Table 1 (main paper) bottom panel for fixed/calibrated constants. +# +# Education groups are indexed 0=dropout, 1=highschool, 2=college throughout +# the notebook, matching the key order below. +education_groups: + - dropout + - highschool + - college +hours_by_choice: + - 0.0 + - 1000.0 + - 2000.0 + - 2250.0 + - 2500.0 + - 3000.0 +t0: 19 # model period 0 = age 19 for everyone; college students are +# choice-restricted to h=0 (in school) until age 23, see notebook. +t_retire: 85 # compulsory retirement age (last period agents may work) +college_start_age: 23 +# --- Table 5: preference parameters --- +preferences: + zeta: 0.79488 # CRRA coefficient in consumption + gamma: # disutility by hours level (gamma_0=0, unused) + - 0.0 + - 1.4139 + - 2.0088 + - 2.9213 + - 2.8639 + - 3.8775 + kappa_1: 0.50321 # low-type disutility correction + kappa_2: 0.00008 # quadratic age term (older workers) + kappa_3: 0.05083 # linear age term (younger workers) + xi: 0.48834 # CRRA coefficient of bequest + b_scale: 0.68659 # bequest scale + taste_shock_scale: 0.29950 # lambda + beta_by_education: + dropout: 0.96806 + highschool: 0.96732 + college: 0.96963 +# --- Table 6: human capital production function, eq. (4) --- +human_capital: + eta0_high_type: 0.39311 + eta3: 0.02676 + eta4: -0.00076 + eta0_by_education: + dropout: 2.45647 + highschool: 2.56761 + college: 2.78766 + eta1_by_education: + dropout: 0.01974 + highschool: 0.02164 + college: 0.03041 + eta2_by_education: + dropout: 0.00000 + highschool: -0.00002 + college: -0.00017 +# --- Table 7: misc structural parameters --- +misc: + sigma0: 0.24485 # wage shock std: constant + sigma1: 0.00421 # wage shock std: age slope + tr: 5.51308 # parental transfer ($1000/year, up to age 23) + rho_super_by_education: + dropout: 6.47838 + highschool: 5.43473 + college: 6.30347 + high_type_share_by_education: # only used to draw simulated agents' types + dropout: 0.69306 + highschool: 0.80130 + college: 0.90089 +# --- Eq. (27): income tax. NB the printed additive constant for the top +# bracket (rate1*thld1) creates a small downward jump in tax liability right +# at the second threshold; we use the continuity-preserving constant +# rate1*(thld2-thld1) instead, as is standard for bracket-style tax rules. --- +tax: + thld1: 17.39184 + thld2: 73.17661 + rate1: 0.29907 + rate2: 0.37930 +# --- Supplementary eq. (3): pension function. We fix the post-2010 regime +# constant throughout (see notebook scope discussion). --- +pension: + benefit_max: 12.60665 # 10.75973 + 1.84692 + income_taper: 0.27794 + asset_taper: 0.00499 + asset_threshold: 117.08260 + pension_age: 65 +# --- Supplementary eq. (2): survival function --- +survival: + age_threshold: 40 + a: 0.0006569 + b: 0.1078507 +# --- Table 1 bottom panel: fixed/calibrated --- +fixed: + credit_constraint: 20.0 # a0, in $1000 + interest_rate: 0.04 + consumption_floor: 0.05 # numerical safety floor, not in the paper + superannuation_age: 65