{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Macro 2: Problem Sheet 1\n",
"\n",
"### Exercise 1\n",
"\n",
"> **Remark 1.** This notebook is structured as follows. First I define all necessary functions in a sort of abstract fashion. Then at the very end I call all functions to produce numerical results and plots."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from pathlib import Path\n",
"from functools import partial\n",
"from itertools import product\n",
"\n",
"import numpy as np\n",
"import pandas as pd\n",
"import seaborn as sns\n",
"import matplotlib.pyplot as plt\n",
"\n",
"from statsmodels.formula.api import ols\n",
"from joblib import Parallel\n",
"from joblib import delayed\n",
"\n",
"sns.set_style(\"whitegrid\")"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"DATA_PATH = Path(\"data/CNEF_PSID\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Functions\n",
"\n",
"##### Data Cleaning"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"def compose(f, g):\n",
" \"\"\"Composition of two functins.\n",
" \n",
" h(x) := f(g(x)) for all x\n",
" \n",
" \"\"\"\n",
" h = lambda x: f(g(x))\n",
" return h"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"def get_yearly_variables(year):\n",
" \"\"\"Returns list and dict of relevant columns given year.\n",
" \n",
" Convert variables names to year specific names. For example instead\n",
" of 'x11102' writes 'x1110285' for the year '85. Additionally add\n",
" variable name for individual id.\n",
" \n",
" For details on variable names and more information seek the\n",
" codebook: https://www.cnefdata.org/documentation/codebooks\n",
" \n",
" \n",
" Args:\n",
" year (int): Year. (Write 85 for 1985.)\n",
" \n",
" Returns:\n",
" as_list (list): List of variable names.\n",
" as_dict (dict): Dict of variable name translation to human\n",
" readable form.\n",
" \n",
" \"\"\"\n",
" variables = {\n",
" \"x11102\": \"household\",\n",
" \"i11113\": \"income\",\n",
" \"d11105\": \"relationship_to_head\",\n",
" \"d11101\": \"age\",\n",
" \"d11109\": \"education\",\n",
" \"e11101\": \"hours\",\n",
" }\n",
" as_dict = {f\"{key}{year}\": value for key, value in variables.items()}\n",
" as_dict = dict(as_dict, **{\"x11101ll\": \"individual\"})\n",
" as_list = [f\"{key}{year}\" for key in variables.keys()]\n",
" as_list.append(\"x11101ll\")\n",
" return as_dict, as_list"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"def load_data_given_year(year):\n",
" \"\"\"Load data and assign new columns given year.\n",
" \n",
" This already does some steps described in part 2 of exercise 1.\n",
" \n",
" Args:\n",
" year (int): Year. (Write 85 for 1985.)\n",
" \n",
" Returns:\n",
" df (pd.DataFrame): Data frame with columss\n",
" \n",
" \"\"\"\n",
" cols_mapper, cols = get_yearly_variables(year)\n",
"\n",
" df = pd.read_stata(DATA_PATH / f\"pequiv{year}.dta\", columns=cols)\n",
"\n",
" df = df.rename(columns=cols_mapper)\n",
" df = df.set_index([\"household\", \"individual\"])\n",
" df = df.dropna(how=\"all\")\n",
" df = df.assign(\n",
" **{\n",
" \"year\": year,\n",
" \"relationship_to_head\": df.relationship_to_head.str.split(\" \").apply(\n",
" lambda s: s[0]\n",
" ),\n",
" }\n",
" )\n",
" df = df.convert_dtypes()\n",
" return df"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"def clean_data(df):\n",
" \"\"\"Clean data frame.\n",
" \n",
" This does most steps described in part 2 of exercise 1.\n",
" \n",
" Args:\n",
" df (pd.DataFrame): Frame produced by :func:`load_data_given_year`.\n",
" \n",
" Returns:\n",
" df (pd.DataFrame): Cleaned data frame.\n",
" \n",
" \"\"\"\n",
" TEN_PERCENT_OF_ANNUAL_FULLTIME_HOURS = 312 # (30 h/w * 52 / 10) * 2 (households)\n",
"\n",
" df = df.query(\"relationship_to_head in ['head', 'partner']\")\n",
" df = df.assign(\n",
" **{\n",
" \"is_single\": df.relationship_to_head.groupby(\"household\").transform(\n",
" lambda x: set(x) != {\"head\", \"partner\"}\n",
" )\n",
" }\n",
" )\n",
" df = df.query(\"is_single == False\")\n",
"\n",
" total = df.groupby(by=\"household\")[[\"hours\"]].sum()\n",
"\n",
" df = df.query(\"relationship_to_head == 'head'\")\n",
" df = df.reset_index(level=\"individual\")\n",
" df = df.assign(**{\"hours\": total.hours})\n",
" df = df.set_index(\"individual\")\n",
"\n",
" df = df.query(\"25 <= age < 56\")\n",
" df = df.query(\"hours >= @TEN_PERCENT_OF_ANNUAL_FULLTIME_HOURS\")\n",
" df = df.query(\"income > 0\")\n",
"\n",
" df = df.assign(**{\"income\": np.log(df.income)})\n",
"\n",
" df = df.drop([\"relationship_to_head\", \"is_single\", \"hours\"], axis=1)\n",
" df = df.set_index(\"age\", append=True)\n",
" df.index = df.index.set_names([\"household\", \"age\"])\n",
" df = df.dropna(how=\"any\")\n",
" return df"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"def load_and_clean_data(n_jobs=1, load_from_disc=False):\n",
" \"\"\"Load, clean and merge data for years 1980 to 1997.\n",
" \n",
" Since loading and cleaning the data is time consuming there is\n",
" a check if clean data is already available, otherwise use multiple cores.\n",
" \n",
" Args:\n",
" n_jobs (int): Number of cores to use for parallelized data cleaning.\n",
" load_from_disc (bool): Should the dataset be loaded from disc if available.\n",
" Default False.\n",
" \n",
" Returns:\n",
" df (pd.DataFrame): Cleaned and merged data frame with index ['household', 'year']\n",
" and columns 'income', 'age', 'education' and 'work'. Column 'income' is float\n",
" while all other columns are category.\n",
" \n",
" \"\"\"\n",
" clean_data_path = DATA_PATH.parent / \"clean_data.csv\"\n",
" if load_from_disc and clean_data_path.exists():\n",
" df = pd.read_csv(clean_data_path)\n",
" else:\n",
" _load_and_clean = compose(clean_data, load_data_given_year)\n",
" dfs = Parallel(n_jobs, prefer=\"processes\")(\n",
" delayed(_load_and_clean)(year) for year in range(80, 98)\n",
" )\n",
" df = pd.concat(dfs).sort_index().reset_index()\n",
"\n",
" df = df.astype(\n",
" {\n",
" \"age\": int,\n",
" \"household\": int,\n",
" \"income\": float,\n",
" \"education\": \"category\",\n",
" \"year\": int,\n",
" }\n",
" )\n",
" df = df.drop_duplicates(subset=[\"household\", \"age\"], keep=\"first\")\n",
" return df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Dummy Regression"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def fit_dummy_regression(df):\n",
" \"\"\"Fit dummy regression on data in df.\n",
" \n",
" In the formula object C() tells statsmodels to use the variable as\n",
" categorical variable.\n",
" \n",
" \"\"\"\n",
" df = df.copy().astype({\"age\": \"category\", \"year\": \"category\"})\n",
" model = ols(\"income ~ C(year) + C(age) + C(education)\", data=df)\n",
" model = model.fit()\n",
" return model"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"##### Estimation approaches"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"def estimate_quantities_approach_4(df):\n",
" \"\"\"Estimate quantities using approach in part 4.\n",
" \n",
" The correction for year and birthyear here is not *correct*.\n",
" \n",
" Args:\n",
" df (pd.DataFrame): Cleaned data with residuals.\n",
" \n",
" Returns:\n",
" quantities (pd.DataFrame): Estimates of rho, sigma_eps^2 and sigma_mu_tau^2.\n",
" var (pd.DataFrame): Sample variances.\n",
"\n",
" \"\"\"\n",
"\n",
" def _estimate(var):\n",
" _rho = (var.loc[55] - var.loc[40]) / (var.loc[40] - var.loc[25])\n",
" rho = _rho ** (1 / 30)\n",
" gamma = rho ** 2 * (1 - rho ** 30) / (1 - rho ** 2)\n",
"\n",
" sigma_eps = (var.loc[40] - var.loc[25]) / gamma\n",
" sigma_mu_tau = var.loc[25] - sigma_eps\n",
" return rho, sigma_eps, sigma_mu_tau\n",
"\n",
" df = df[[\"age\", \"residuals\", \"year\"]]\n",
"\n",
" # create cross-sectional variances\n",
" # notation: csvar = cross-sectional variance\n",
" data = df.groupby([\"age\", \"year\"])[[\"residuals\"]].var()\n",
" data = data.reset_index()\n",
" data = data.rename({\"residuals\": \"csvar\"}, axis=1)\n",
" data = data.assign(**{\"birthyear\": data.year - data.age})\n",
"\n",
" for correction in [\"year\", \"birthyear\"]:\n",
" model = ols(\n",
" f\"csvar ~ C({correction})\", data=data.astype({f\"{correction}\": \"category\"})\n",
" )\n",
" data[f\"csvar-{correction}\"] = data[\"csvar\"] - model.fit().resid * 0.65\n",
"\n",
" var = data[[\"age\", \"csvar\", \"csvar-year\", \"csvar-birthyear\"]]\n",
" var = var.rename({\n",
" \"csvar\": \"baseline\",\n",
" \"csvar-year\": \"year\",\n",
" \"csvar-birthyear\": \"birthyear\",\n",
" }, axis=1\n",
" )\n",
" var = var.groupby(\"age\")[[\"baseline\", \"year\", \"birthyear\"]].mean()\n",
"\n",
" index = [\"rho\", \"sigma_epsilon\", \"sigma_mu_tau\"]\n",
" columns = [\"baseline\", \"year\", \"birthyear\"]\n",
" quantities = pd.DataFrame(columns=columns, index=index)\n",
"\n",
" quantities.loc[:, \"baseline\"] = _estimate(var[\"baseline\"])\n",
" quantities.loc[:, \"year\"] = _estimate(var[\"year\"])\n",
" quantities.loc[:, \"birthyear\"] = _estimate(var[\"birthyear\"])\n",
"\n",
" quantities = quantities.reset_index().rename({\"index\": \"symbol\"}, axis=1)\n",
"\n",
" return quantities, var"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def predict_residual_variance(quantities, age):\n",
" \"\"\"Predict residual variance.\n",
" \n",
" Predicts residual variance given `age` using estimates from part 4.\n",
" \n",
" Args:\n",
" part4 (pd.DataFrame): Output from :func:`estimate_quantities_part4`.\n",
" Has columns [symbol, baseline, year, birthyear].\n",
" age (int or int-array-like): age for which to predict the residual\n",
" variance\n",
" \n",
" Returns:\n",
" prediction (pd.DataFrame): Variance estimate with rows corresponding to\n",
" `age` and columns corresponding to the columns of `part4`.\n",
" \n",
" \"\"\"\n",
" def _estimate(h, col):\n",
" \"\"\"Variance of residual predicted by model.\"\"\"\n",
" h = h - 24\n",
" rho = part4.loc[0, col]\n",
" sigma_e = part4.loc[1, col]\n",
" sigma_mu_tau = part4.loc[2, col]\n",
" out = sigma_e * (1 - rho ** (2 * h)) / (1 - rho ** 2) + sigma_mu_tau\n",
" return out\n",
"\n",
" cols = quantities.columns.drop(\"symbol\")\n",
" prediction = pd.DataFrame(columns=cols, index=age)\n",
" for h, col in product(age, cols):\n",
" prediction.loc[h, col] = _estimate(h, col)\n",
"\n",
" return prediction"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"def plot_part4(quantities, var):\n",
" \"\"\"Plot results from part 4.\"\"\"\n",
" var = var.add_prefix(\"true-\")\n",
" \n",
" predicted = predict_residual_variance(quantities, var.index.values)\n",
" predicted = predicted.add_prefix(\"pred-\")\n",
" \n",
" df = pd.concat((var, predicted), axis=1)\n",
" df = df.assign(**{\"age\": var.index})\n",
" df = df.melt(id_vars=\"age\", var_name=\"type\", value_name=\"value\")\n",
" df = df.convert_dtypes()\n",
" df[[\"data\", \"type\"]] = df[\"type\"].str.split('-', 1, expand=True)\n",
" \n",
" fig, ax = plt.subplots(1)\n",
" fig.set_size_inches(13, 7)\n",
" \n",
" palette = {\n",
" \"baseline\": \"tab:orange\",\n",
" \"year\": \"tab:blue\",\n",
" \"birthyear\": \"tab:green\",\n",
" }\n",
"\n",
" p = sns.lineplot(\n",
" x=\"age\", y=\"value\", hue=\"type\", style=\"data\", data=df, ax=ax, linewidth=2, legend=\"brief\",\n",
" palette=palette, style_order=[\"pred\", \"true\"]\n",
" )\n",
"\n",
" ax.set(ylabel=\"Cross-sectional variance\", xlabel=\"Age\")\n",
" ax.set_frame_on(False)\n",
" ax.xaxis.label.set_size(13)\n",
" ax.yaxis.label.set_size(13)\n",
" return None"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"def estimate_quantities_approach_5(df, var):\n",
" \"\"\"Estimate quantities using approach in part 5.\n",
" \n",
" Args:\n",
" df (pd.DataFrame): Cleaned data with residuals.\n",
" var (pd.DataFrame): Variance output from :func:`estimate_quantities_approach_4`.\n",
" \n",
" Returns:\n",
" quantities (pd.DataFrame): Estimated values.\n",
" \n",
" \"\"\"\n",
" forty_year_old_households = df.query(\"age == 40\")[\"household\"]\n",
" df = df.query(\"household in @forty_year_old_households\")\n",
"\n",
" # compute (sample) covariances\n",
" combinations = [(40, 39), (40, 38), (40, 37)]\n",
" cov = pd.DataFrame(index=pd.MultiIndex.from_tuples(combinations))\n",
" for comb in combinations:\n",
"\n",
" _df = df[[\"household\", \"age\", \"residuals\"]].query(\"age in @comb\")\n",
" idx = _df.groupby(\"household\")[\"age\"].transform(\n",
" lambda x: set(x) == set(comb) and len(x) == 2 # check that both 40 and (e.g.) 37 in data\n",
" )\n",
" _df = _df.loc[idx, :].set_index([\"household\", \"age\"])\n",
"\n",
" _cov = _df.unstack(level=\"age\").cov().values[0, 1]\n",
" cov.loc[comb, \"cov\"] = _cov\n",
"\n",
" # compute quantities\n",
" rho = (\n",
" (cov.loc[(40, 37),] - cov.loc[(40, 38)])\n",
" / (cov.loc[(40, 38),] - cov.loc[(40, 39)])\n",
" )[0]\n",
"\n",
" sigma_eps = (\n",
" (cov.loc[(40, 37),] - cov.loc[(40, 37),])[0]\n",
" * (1 - rho ** 2)\n",
" / (rho * (rho - 1) * (rho ** 29 + 1))\n",
" )\n",
" sigma_mu = cov.loc[(40, 39),][0] - sigma_eps * rho * (1 - rho ** 30) / (\n",
" 1 - rho ** 2\n",
" )\n",
" sigma_tau = var.loc[25, \"baseline\"] - sigma_mu - sigma_eps\n",
"\n",
" quantities = (\n",
" pd.DataFrame(\n",
" [rho, sigma_eps, sigma_mu, sigma_tau],\n",
" columns=[\"part5\"],\n",
" index=[\"rho\", \"sigma_epsilon\", \"sigma_mu\", \"sigma_tau\",],\n",
" )\n",
" .reset_index()\n",
" .rename({\"index\": \"symbol\"}, axis=1)\n",
" )\n",
" return quantities"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"def estimate_rho_approach_iv(df, n_jobs=1, fixed_effects=True):\n",
" \"\"\"Estimate rho using an instrumental variable approach.\n",
" \n",
" Regression equation:\n",
" \n",
" (1) x_{ih}* = rho x_{i, h-1}* + error\n",
" \n",
" Equation (1) has an endogeneity problem, hence we will construct\n",
" a valid instrument z_{i, h-1} for x_{i, h-1}* and estimate rho\n",
" using 2SLS.\n",
" \n",
" (!) A minimum requirement for this to work is that for *some* number\n",
" of observations x_{ih}* AND x_{i, h-1}* is observed.\n",
" \n",
" Args:\n",
" df (pd.DataFrame): Cleaned data with residuals.\n",
" n_jobs (int): Number of cores to use for parallelized data cleaning.\n",
" fixed_effects (bool): Use fixed effects correction.\n",
" \n",
" Returns:\n",
" \n",
" \"\"\"\n",
" # create instruments\n",
" def _create_instrument_or_return_nan(household, age, df):\n",
" try:\n",
" instrument = (\n",
" df.loc[(household, age - 1), \"residuals\"]\n",
" - df.loc[(household, age - 2), \"residuals\"]\n",
" )\n",
" except KeyError:\n",
" instrument = np.nan\n",
"\n",
" try:\n",
" lagged_residual = df.loc[(household, age - 1), \"residuals\"]\n",
" except KeyError:\n",
" lagged_residual = np.nan\n",
"\n",
" return instrument, lagged_residual\n",
"\n",
" df = df.set_index([\"household\", \"age\"])\n",
"\n",
" to_parallelize = partial(_create_instrument_or_return_nan, **{\"df\": df})\n",
" results = Parallel(n_jobs, prefer=\"processes\")(\n",
" delayed(to_parallelize)(household, age) for household, age in df.index\n",
" )\n",
" results = pd.DataFrame(\n",
" results, columns=[\"instrument\", \"lagged_residuals\"], index=df.index\n",
" )\n",
"\n",
" df = pd.concat((df, results), axis=1)\n",
" df = df.dropna(how=\"any\")\n",
"\n",
" # prepare data sets\n",
" df = df.reset_index()\n",
" df = df.astype({\"household\": \"category\"})\n",
"\n",
" if fixed_effects:\n",
" fixed_effect_dummies = pd.get_dummies(df[\"household\"], prefix=\"hh\")\n",
" X = pd.concat((df[[\"lagged_residuals\"]], fixed_effect_dummies), axis=1).values\n",
" Z = pd.concat((df[[\"instrument\"]], fixed_effect_dummies), axis=1).values\n",
" else:\n",
" X = df[[\"lagged_residuals\"]].assign(**{\"intercept\": 1}).values\n",
" Z = df[[\"instrument\"]].assign(**{\"intercept\": 1}).values\n",
" \n",
" y = df[[\"residuals\"]].values\n",
"\n",
" # iv regression\n",
" beta = np.linalg.inv(Z.T @ X) @ Z.T @ y # this can be optimized i know\n",
"\n",
" quantity = (\n",
" pd.Series(beta[0], index=[\"rho\"], name=\"part6\")\n",
" .to_frame()\n",
" .reset_index()\n",
" .rename({\"index\": \"symbol\"}, axis=1)\n",
" )\n",
" return quantity"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def combine_parts(part4, part5, part6):\n",
" \"\"\"Combine results from part4 to part6 in one data frame.\"\"\"\n",
" df = part4.merge(part5, on=\"symbol\", how=\"outer\", suffixes=(\"_part4\", \"_part5\"))\n",
" df = df.merge(part6, on=\"symbol\", how=\"outer\", suffixes=(\"_part4\", \"_part5\"))\n",
" df = df.convert_dtypes()\n",
" return df"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Actual Computation"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"df = load_and_clean_data(n_jobs=4, load_from_disc=False)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Fit Model and use Residuals"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [],
"source": [
"model = fit_dummy_regression(df)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"df = df.assign(**{\"residuals\": model.resid})"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Part 4 - Variances"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"part4, var = estimate_quantities_approach_4(df)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" symbol | \n",
" baseline | \n",
" year | \n",
" birthyear | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" rho | \n",
" 1.036401 | \n",
" 1.036401 | \n",
" 1.135712 | \n",
"
\n",
" \n",
" | 1 | \n",
" sigma_epsilon | \n",
" 0.000747 | \n",
" 0.000261 | \n",
" 0.000004 | \n",
"
\n",
" \n",
" | 2 | \n",
" sigma_mu_tau | \n",
" 0.185923 | \n",
" 0.222065 | \n",
" 0.221479 | \n",
"
\n",
" \n",
"
\n",
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"plot_part4(part4, var)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Part 5 - Covariances"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [],
"source": [
"part5 = estimate_quantities_approach_5(df, var)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" symbol | \n",
" part5 | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" rho | \n",
" 16.749681 | \n",
"
\n",
" \n",
" | 1 | \n",
" sigma_epsilon | \n",
" -0.000000 | \n",
"
\n",
" \n",
" | 2 | \n",
" sigma_mu | \n",
" 0.160546 | \n",
"
\n",
" \n",
" | 3 | \n",
" sigma_tau | \n",
" 0.026124 | \n",
"
\n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" symbol | \n",
" part6 | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" rho | \n",
" 0.240243 | \n",
"
\n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" | \n",
" symbol | \n",
" baseline | \n",
" year | \n",
" birthyear | \n",
" part5 | \n",
" part6 | \n",
"
\n",
" \n",
" \n",
" \n",
" | 0 | \n",
" rho | \n",
" 1.036401 | \n",
" 1.036401 | \n",
" 1.135712 | \n",
" 16.749681 | \n",
" 0.240243 | \n",
"
\n",
" \n",
" | 1 | \n",
" sigma_epsilon | \n",
" 0.000747 | \n",
" 0.000261 | \n",
" 0.000004 | \n",
" -0.0 | \n",
" <NA> | \n",
"
\n",
" \n",
" | 2 | \n",
" sigma_mu_tau | \n",
" 0.185923 | \n",
" 0.222065 | \n",
" 0.221479 | \n",
" <NA> | \n",
" <NA> | \n",
"
\n",
" \n",
" | 3 | \n",
" sigma_mu | \n",
" <NA> | \n",
" <NA> | \n",
" <NA> | \n",
" 0.160546 | \n",
" <NA> | \n",
"
\n",
" \n",
" | 4 | \n",
" sigma_tau | \n",
" <NA> | \n",
" <NA> | \n",
" <NA> | \n",
" 0.026124 | \n",
" <NA> | \n",
"
\n",
" \n",
"
\n",
"