From bbbb0fcc20a62ddc3f3d40cb9c769bbe67192b15 Mon Sep 17 00:00:00 2001 From: Apoorva Lal Date: Sat, 28 Jun 2025 23:48:46 -0700 Subject: [PATCH 1/2] "package into module" --- .gitignore | 29 ++ readme.md => README.md | 0 jax_gmm.ipynb | 338 ------------- jax_linear.ipynb | 335 ------------- jax_lm_optim.ipynb | 128 ----- jaxonometrics/__init__.py | 19 + jaxonometrics/base.py | 28 ++ jaxonometrics/causal.py | 46 ++ jaxonometrics/gmm/__init__.py | 10 + jaxonometrics/gmm/base.py | 73 +++ jaxonometrics/gmm/linear_iv.py | 49 ++ jaxonometrics/gmm/twostep.py | 61 +++ jaxonometrics/legacy/__init__.py | 0 jaxonometrics/legacy/jax_gmm.py | 152 ++++++ jaxonometrics/legacy/jax_linear.py | 98 ++++ jaxonometrics/legacy/jax_lm_optim.py | 63 +++ jaxonometrics/legacy/optax_adam_lin.py | 73 +++ jaxonometrics/legacy/sgd_gmm.py | 273 +++++++++++ jaxonometrics/legacy/stacked_moments.py | 121 +++++ jaxonometrics/linear.py | 37 ++ nb/linmod.ipynb | 405 ++++++++++++++++ optax_adam_lin.ipynb | 149 ------ pyproject.toml | 33 ++ requirements.txt | 8 - sgd_gmm.ipynb | 617 ------------------------ stacked_moments.ipynb | 232 --------- tests/test_gmm.py | 39 ++ tests/test_linear.py | 24 + 28 files changed, 1633 insertions(+), 1807 deletions(-) create mode 100644 .gitignore rename readme.md => README.md (100%) delete mode 100644 jax_gmm.ipynb delete mode 100644 jax_linear.ipynb delete mode 100644 jax_lm_optim.ipynb create mode 100644 jaxonometrics/__init__.py create mode 100644 jaxonometrics/base.py create mode 100644 jaxonometrics/causal.py create mode 100644 jaxonometrics/gmm/__init__.py create mode 100644 jaxonometrics/gmm/base.py create mode 100644 jaxonometrics/gmm/linear_iv.py create mode 100644 jaxonometrics/gmm/twostep.py create mode 100644 jaxonometrics/legacy/__init__.py create mode 100644 jaxonometrics/legacy/jax_gmm.py create mode 100644 jaxonometrics/legacy/jax_linear.py create mode 100644 jaxonometrics/legacy/jax_lm_optim.py create mode 100644 jaxonometrics/legacy/optax_adam_lin.py create mode 100644 jaxonometrics/legacy/sgd_gmm.py create mode 100644 jaxonometrics/legacy/stacked_moments.py create mode 100644 jaxonometrics/linear.py create mode 100644 nb/linmod.ipynb delete mode 100644 optax_adam_lin.ipynb create mode 100644 pyproject.toml delete mode 100644 requirements.txt delete mode 100644 sgd_gmm.ipynb delete mode 100644 stacked_moments.ipynb create mode 100644 tests/test_gmm.py create mode 100644 tests/test_linear.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..99b7cf8 --- /dev/null +++ b/.gitignore @@ -0,0 +1,29 @@ +*/__pycache__/* +*.csv +*.dta +*.xlsx +*.ipynb_checkpoints +.vscode/* +*.log +*.bbl +*.bcf +*.fls +*.bcf +*.run.xml +**/*_cache/* +*.shp +*.shx +*.qpj +*.dbf +*.RData +*.Rds +*.tab +*.swp +*.spq +*.pqt +*.geojson +*.gpkg +*.aux +*.blg +*.out +*.synctex.gz diff --git a/readme.md b/README.md similarity index 100% rename from readme.md rename to README.md diff --git a/jax_gmm.ipynb b/jax_gmm.ipynb deleted file mode 100644 index 393dded..0000000 --- a/jax_gmm.ipynb +++ /dev/null @@ -1,338 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "\n", - "import jax\n", - "import jax.numpy as jnp\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# GMM done easy\n", - "\n", - "moment eqn fn gets a $n \\times k$ matrix of residuals (implied by the moment condition) and minimizes the implied objective function.\n", - "Uses implicit gradient (and therefore performs better than `scipy.optimize.minimize`)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from jaxopt import LevenbergMarquardt\n", - "from tqdm import tqdm\n", - "from joblib import Parallel, delayed\n", - "\n", - "jax.config.update(\"jax_enable_x64\", True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# IV dataset\n", - "np.random.seed(42)\n", - "def dgp(b = np.array([1, 2]), N = 1_000, K = 3):\n", - " # Instruments\n", - " Z = np.random.normal(0, 1, (N, K))\n", - " # Covariates\n", - " pi = np.random.uniform(1, 2, K)\n", - " w = Z @ pi + np.random.normal(0, 1, N) # endogenous treatment\n", - " X = np.c_[np.ones(N), w]\n", - " # Outcome\n", - " y = X @ b + np.random.normal(0, 1, N)\n", - " return {\"y\": y, \"X\": X, \"Z\": Z}\n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([0.97738733, 2.00528897], dtype=float64)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "@jax.jit\n", - "def moment_cond(b, dat):\n", - " y, X, Z = jnp.array(dat['y']), jnp.array(dat['X']), jnp.array(dat['Z'])\n", - " resid = y - X @ b\n", - " return jnp.array(Z * resid[:, None])\n", - "\n", - "def solve_gmm(dat):\n", - " x_init = jnp.zeros(dat['X'].shape[1])\n", - " gn = LevenbergMarquardt(moment_cond)\n", - " return gn.run(x_init, dat = dat).params\n", - "\n", - "solve_gmm(dgp())\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/1000 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "f, ax = plt.subplots(1, 2, figsize=(12, 4))\n", - "# Plot histogram of the 'intercept' column\n", - "ax[0].hist(np.array(res[:, 0]), color=\"red\", alpha=0.5)\n", - "ax[0].axvline(x=1, color=\"black\", linestyle=\"--\", label=\"True Value\")\n", - "\n", - "# Plot histogram of the 'slope' column\n", - "ax[1].hist(np.array(res[:, 1]), color=\"red\", alpha=0.5)\n", - "ax[1].axvline(x=2, color=\"black\", linestyle=\"--\", label=\"True Value\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## balancing weights\n", - "\n", - "solve dual of ERM problem for exact balance. For details, see [Wang and Zubizarreta](http://jrzubizarreta.com/minimal.pdf)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "from jaxopt import LBFGS\n", - "import empirical_calibration as ec\n", - "import matplotlib.pyplot as plt\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "@jax.jit\n", - "def eb_moment(b, X0, X1):\n", - " return jnp.log(jnp.exp(-1 * X0 @ b).sum()) + X1 @ b\n", - "\n", - "\n", - "def ebwt(X0, X1):\n", - " init_par = jnp.repeat(1.0, X0.shape[1])\n", - " solver = LBFGS(fun=eb_moment, maxiter=100)\n", - " res = solver.run(init_par, X0=X0, X1=X1)\n", - " wt = np.exp(-1 * X0 @ res.params)\n", - " wt /= wt.sum()\n", - " return wt" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(6.418394, dtype=float32)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sim = ec.data.kang_schafer.Simulation(size=1000)\n", - "w, y, X = sim.treatment, sim.outcome, np.c_[np.repeat(1, 1000), sim.covariates]\n", - "X0, X1 = X[w == 0, :], X[w == 1, :].mean(0)\n", - "b_start = np.random.rand(X.shape[1])\n", - "eb_moment(b_start, X0, X1)\n", - "# wt = ebwt(X0, X1)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(-19.865469141404446, 0.10502565330460811)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# kang shafer 2007 dgp\n", - "def onesim():\n", - " sim = ec.data.kang_schafer.Simulation(size=1000)\n", - " w, y, X = sim.treatment, sim.outcome, np.c_[np.repeat(1, 1000), sim.covariates]\n", - " X0, X1 = X[w == 0, :], X[w == 1, :].mean(0)\n", - " wt = ebwt(X0, X1)\n", - " naive = y[w == 1].mean() - y[w == 0].mean()\n", - " wtd = y[w == 1].mean() - np.average(y[w == 0], weights=wt)\n", - " return naive, wtd\n", - "\n", - "onesim()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - " 0%| | 0/1000 [00:00" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "simres = pd.DataFrame(res, columns=[\"naive\", \"wtd\"])\n", - "\n", - "sns.histplot(simres[\"naive\"], color=\"red\", alpha=0.5, kde=True, label=\"naive\")\n", - "sns.histplot(simres[\"wtd\"], color=\"blue\", alpha=0.5, kde=True, label=\"wtd\")\n", - "plt.xlabel(\"bias\")\n", - "plt.legend()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "metrics", - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/jax_linear.ipynb b/jax_linear.ipynb deleted file mode 100644 index 9f804b7..0000000 --- a/jax_linear.ipynb +++ /dev/null @@ -1,335 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "be6bda27", - "metadata": {}, - "source": [ - "# Minimum Norm Interpolant" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "ee58a952-6a96-494f-8067-0ea6036c2572", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:10:24.908831Z", - "iopub.status.busy": "2024-08-07T20:10:24.908521Z", - "iopub.status.idle": "2024-08-07T20:10:25.960003Z", - "shell.execute_reply": "2024-08-07T20:10:25.959395Z", - "shell.execute_reply.started": "2024-08-07T20:10:24.908808Z" - } - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import jax.numpy as jnp\n", - "import lineax as lx\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from sklearn.linear_model import LinearRegression\n", - "from statsmodels.api import OLS\n" - ] - }, - { - "cell_type": "markdown", - "id": "b600e803-0dc3-466f-a46c-8b1fa329d97d", - "metadata": {}, - "source": [ - "$n>p$ dgp, OLS solution not unique" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "8b778f4c-7ea7-4823-97d1-98a3d118e9fd", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:10:27.002244Z", - "iopub.status.busy": "2024-08-07T20:10:27.001851Z", - "iopub.status.idle": "2024-08-07T20:10:30.681932Z", - "shell.execute_reply": "2024-08-07T20:10:30.681240Z", - "shell.execute_reply.started": "2024-08-07T20:10:27.002225Z" - }, - "tags": [] - }, - "outputs": [], - "source": [ - "def sparse_dgp(n = 10_000, p = 20_000, eta = 0.1):\n", - " X = np.c_[np.repeat(1, n),\n", - " np.random.normal(size = n*p).reshape((n, p))\n", - " ]\n", - " # initialize coef vector\n", - " β, nzcount = np.repeat(0.0, p + 1), int(eta * p)\n", - " # choose nzcount number of non-zero coef\n", - " nzid = np.random.choice(p, nzcount, replace=False)\n", - " # set them to random values\n", - " β[nzid] = np.random.randn(nzcount)\n", - " # build in heteroskedasticity\n", - " e = np.random.normal(0, 0.5 + (0.1 * X[:, 1]>0), n)\n", - " # generate y\n", - " y = X @ β + e\n", - " return y, X\n", - "\n", - "y, X = sparse_dgp()\n" - ] - }, - { - "cell_type": "markdown", - "id": "bc4600f1-21c9-4d56-a838-238a449e6622", - "metadata": {}, - "source": [ - "### statsmodels" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "f55c4df2", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:10:50.994546Z", - "iopub.status.busy": "2024-08-07T20:10:50.994120Z", - "iopub.status.idle": "2024-08-07T20:12:57.233971Z", - "shell.execute_reply": "2024-08-07T20:12:57.233090Z", - "shell.execute_reply.started": "2024-08-07T20:10:50.994526Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 1h 24min 14s, sys: 34min 40s, total: 1h 58min 55s\n", - "Wall time: 2min 6s\n" - ] - } - ], - "source": [ - "%%time\n", - "smols = OLS(y, X).fit()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "ab2705b3", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:12:57.235703Z", - "iopub.status.busy": "2024-08-07T20:12:57.235326Z", - "iopub.status.idle": "2024-08-07T20:12:57.240783Z", - "shell.execute_reply": "2024-08-07T20:12:57.240344Z", - "shell.execute_reply.started": "2024-08-07T20:12:57.235682Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "32.06474491647644" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.linalg.norm(smols.params)" - ] - }, - { - "cell_type": "markdown", - "id": "4e49c36b-af05-4e09-896f-6895f6207d66", - "metadata": {}, - "source": [ - "Statsmodels is very slow with such problems." - ] - }, - { - "cell_type": "markdown", - "id": "7d19a866-7360-4fa2-8eb8-3f2f6a538e58", - "metadata": {}, - "source": [ - "### scikit" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "82c630be", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:13:16.255033Z", - "iopub.status.busy": "2024-08-07T20:13:16.254911Z", - "iopub.status.idle": "2024-08-07T20:14:07.937802Z", - "shell.execute_reply": "2024-08-07T20:14:07.937238Z", - "shell.execute_reply.started": "2024-08-07T20:13:16.255020Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 35min 26s, sys: 13min 45s, total: 49min 11s\n", - "Wall time: 51.5 s\n" - ] - }, - { - "data": { - "text/plain": [ - "1.794120407794253e-12" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "m = LinearRegression()\n", - "m.fit(X, y)\n", - "(y - m.predict(X)).max()\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "47998a93", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:14:07.939157Z", - "iopub.status.busy": "2024-08-07T20:14:07.938685Z", - "iopub.status.idle": "2024-08-07T20:14:07.942731Z", - "shell.execute_reply": "2024-08-07T20:14:07.942369Z", - "shell.execute_reply.started": "2024-08-07T20:14:07.939133Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "32.063915612235505" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.linalg.norm(m.coef_)\n" - ] - }, - { - "cell_type": "markdown", - "id": "2d8a87e2-ea14-4cb8-b9fa-7d261c741251", - "metadata": {}, - "source": [ - "### lineax\n", - "\n", - "Very fast least squares solver (including for minimum norm interpolation problems). \n" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "3207d070-779f-4107-9763-d0cda1a311e2", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:12:57.241449Z", - "iopub.status.busy": "2024-08-07T20:12:57.241317Z", - "iopub.status.idle": "2024-08-07T20:13:16.249450Z", - "shell.execute_reply": "2024-08-07T20:13:16.248802Z", - "shell.execute_reply.started": "2024-08-07T20:12:57.241436Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "CPU times: user 10min 31s, sys: 3min 35s, total: 14min 6s\n", - "Wall time: 18.9 s\n" - ] - }, - { - "data": { - "text/plain": [ - "Array(0.00014114, dtype=float32)" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "%%time\n", - "sol = lx.linear_solve( # solve # Ax = b\n", - " operator = lx.MatrixLinearOperator(jnp.array(X)), # A\n", - " vector = jnp.array(y), # b\n", - " solver=lx.AutoLinearSolver(well_posed=None), \n", - " )\n", - "\n", - "betahat = sol.value\n", - "# does it interpolate\n", - "(y - X @ betahat).max()" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "24e09278-3a2c-4bec-b0db-9547278d51cc", - "metadata": { - "execution": { - "iopub.execute_input": "2024-08-07T20:13:16.250977Z", - "iopub.status.busy": "2024-08-07T20:13:16.250825Z", - "iopub.status.idle": "2024-08-07T20:13:16.254344Z", - "shell.execute_reply": "2024-08-07T20:13:16.253966Z", - "shell.execute_reply.started": "2024-08-07T20:13:16.250962Z" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "32.064747" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.linalg.norm(betahat)\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3.10 (recommended)", - "language": "python", - "name": "python310" - }, - "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.10.14" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/jax_lm_optim.ipynb b/jax_lm_optim.ipynb deleted file mode 100644 index b4aa80d..0000000 --- a/jax_lm_optim.ipynb +++ /dev/null @@ -1,128 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import jax\n", - "import jax.numpy as jnp\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.model_selection import train_test_split\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([75.06147516, 28.20345726, 17.74395438]),\n", - " Array([[ 1. , 0.17136829, 0.19686124, 0.73846656],\n", - " [ 1. , -1.4247482 , -0.2257763 , 0.0675282 ]], dtype=float32),\n", - " array([ 31.51864074, -112.11315545]))" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# create dataset\n", - "X, y, β = make_regression(n_features=3, coef=True, random_state=42)\n", - "X, X_test, y, y_test = train_test_split(X, y)\n", - "X, X_test = jnp.c_[jnp.ones(X.shape[0]), X], jnp.c_[jnp.ones(X_test.shape[0]), X_test]\n", - "β, X[:2, :], y[:2]" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# param dict\n", - "params = {\n", - " \"b\": jnp.zeros(X.shape[1]),\n", - "}\n", - "\n", - "\n", - "# forward pass: Xbeta\n", - "def forward(params, X):\n", - " return jnp.dot(X, params[\"b\"])\n", - "\n", - "\n", - "@jax.jit\n", - "def loss_fn(params, X, y):\n", - " err = forward(params, X) - y\n", - " return jnp.mean(jnp.square(err)) # mse\n", - "\n", - "\n", - "grad_fn = jax.grad(loss_fn)\n", - "\n", - "\n", - "def update(params, grads, lr=0.05):\n", - " return jax.tree.map(lambda p, g: p - lr * g, params, grads)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# the main training loop\n", - "for _ in range(50):\n", - " loss = loss_fn(params, X_test, y_test)\n", - " grads = grad_fn(params, X, y)\n", - " params = update(params, grads)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(array([75.06147516, 28.20345726, 17.74395438]),\n", - " Array([74.25435 , 26.689371, 16.658165], dtype=float32))" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "β, params['b'][1:]" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "metrics", - "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.10.14" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/jaxonometrics/__init__.py b/jaxonometrics/__init__.py new file mode 100644 index 0000000..b001477 --- /dev/null +++ b/jaxonometrics/__init__.py @@ -0,0 +1,19 @@ +""" +jaxonometrics: a Python package for econometric analysis in JAX. +""" + +__version__ = "0.0.1" + +from .base import BaseEstimator +from .causal import EntropyBalancing +from .gmm import GMM, LinearIVGMM, TwoStepGMM +from .linear import LinearRegression + +__all__ = [ + "BaseEstimator", + "EntropyBalancing", + "GMM", + "LinearIVGMM", + "TwoStepGMM", + "LinearRegression", +] diff --git a/jaxonometrics/base.py b/jaxonometrics/base.py new file mode 100644 index 0000000..2a07486 --- /dev/null +++ b/jaxonometrics/base.py @@ -0,0 +1,28 @@ +from abc import ABC, abstractmethod +from typing import Any, Dict, Optional + +import jax.numpy as jnp + + +class BaseEstimator(ABC): + """Base class for all estimators in jaxonometrics.""" + + def __init__(self): + self.params: Optional[Dict[str, jnp.ndarray]] = None + + @abstractmethod + def fit(self, *args, **kwargs) -> "BaseEstimator": + """Fit the model to the data.""" + raise NotImplementedError + + def summary(self) -> None: + """Print a summary of the model results.""" + if self.params is None: + print("Model has not been fitted yet.") + return + + print(f"{self.__class__.__name__} Results") + print("=" * 30) + for param_name, param_value in self.params.items(): + print(f"{param_name}: {param_value}") + print("=" * 30) diff --git a/jaxonometrics/causal.py b/jaxonometrics/causal.py new file mode 100644 index 0000000..e03c9d7 --- /dev/null +++ b/jaxonometrics/causal.py @@ -0,0 +1,46 @@ +from typing import Dict, Optional + +import jax.numpy as jnp +from jaxopt import LBFGS + +from .base import BaseEstimator + + +class EntropyBalancing(BaseEstimator): + """ + Entropy Balancing for causal inference. + + This class implements the entropy balancing method for estimating causal + effects by reweighting the control group to match the covariate moments + of the treated group. + """ + + def __init__(self): + super().__init__() + + @staticmethod + def _eb_moment(b: jnp.ndarray, X0: jnp.ndarray, X1: jnp.ndarray) -> jnp.ndarray: + """The moment condition for entropy balancing.""" + return jnp.log(jnp.exp(-1 * X0 @ b).sum()) + X1 @ b + + def fit( + self, X0: jnp.ndarray, X1: jnp.ndarray, maxiter: int = 100 + ) -> "EntropyBalancing": + """ + Compute the entropy balancing weights. + + Args: + X0: The covariate matrix for the control group. + X1: The mean of the covariate matrix for the treated group. + maxiter: The maximum number of iterations for the optimizer. + + Returns: + The fitted estimator with the computed weights. + """ + init_par = jnp.repeat(1.0, X0.shape[1]) + solver = LBFGS(fun=self._eb_moment, maxiter=maxiter) + res = solver.run(init_par, X0=X0, X1=X1) + wt = jnp.exp(-1 * X0 @ res.params) + wt /= wt.sum() + self.params = {"weights": wt} + return self diff --git a/jaxonometrics/gmm/__init__.py b/jaxonometrics/gmm/__init__.py new file mode 100644 index 0000000..9b77556 --- /dev/null +++ b/jaxonometrics/gmm/__init__.py @@ -0,0 +1,10 @@ +""" +The gmm submodule provides a flexible framework for Generalized Method of +Moments (GMM) estimation. +""" + +from .base import GMM +from .linear_iv import LinearIVGMM +from .twostep import TwoStepGMM + +__all__ = ["GMM", "LinearIVGMM", "TwoStepGMM"] diff --git a/jaxonometrics/gmm/base.py b/jaxonometrics/gmm/base.py new file mode 100644 index 0000000..ddd7443 --- /dev/null +++ b/jaxonometrics/gmm/base.py @@ -0,0 +1,73 @@ +from typing import Callable, Dict, Optional + +import jax +import jax.numpy as jnp +from jaxopt import LevenbergMarquardt, OptaxSolver +import optax + +from ..base import BaseEstimator + + +class GMM(BaseEstimator): + """ + A general-purpose GMM estimator. + + This class provides a flexible interface for fitting GMM models. It can be + configured with different solvers and is not tied to any specific model. + """ + + def __init__(self, moment_fn: Callable, solver: str = "lm", **solver_kwargs): + """ + Initialize the GMM estimator. + + Args: + moment_fn: A function that computes the moment conditions. + It should have the signature `moment_fn(params, data)`. + solver: The solver to use. Can be "lm" for Levenberg-Marquardt + or "sgd" for stochastic gradient descent. + **solver_kwargs: Additional keyword arguments to pass to the solver. + """ + super().__init__() + self.moment_fn = moment_fn + self.solver_name = solver + self.solver_kwargs = solver_kwargs + + def fit( + self, + data: Dict, + init_params: Optional[jnp.ndarray] = None, + ) -> "GMM": + """ + Fit the GMM model. + + Args: + data: A dictionary containing the data. + init_params: Initial values for the parameters. + + Returns: + The fitted estimator. + """ + if self.solver_name == "lm": + solver = LevenbergMarquardt(self.moment_fn, **self.solver_kwargs) + sol = solver.run(init_params, data=data) + self.params = sol.params + elif self.solver_name == "sgd": + if "optimizer" not in self.solver_kwargs: + self.solver_kwargs["optimizer"] = optax.adam(1e-2) + solver = OptaxSolver(fun=self.moment_fn, **self.solver_kwargs) + state = solver.init_state(init_params) + + @jax.jit + def update_step(params, opt_state, data): + grads, opt_state = solver.update(params=params, state=opt_state, data=data) + params = optax.apply_updates(params, grads) + return params, opt_state + + for _ in range(self.solver_kwargs.get("maxiter", 1000)): + init_params, state = update_step(init_params, state, data) + + self.params = init_params + else: + raise ValueError(f"Unknown solver: {self.solver_name}") + + return self diff --git a/jaxonometrics/gmm/linear_iv.py b/jaxonometrics/gmm/linear_iv.py new file mode 100644 index 0000000..8a7ea98 --- /dev/null +++ b/jaxonometrics/gmm/linear_iv.py @@ -0,0 +1,49 @@ +from typing import Dict, Optional + +import jax.numpy as jnp + +from .base import GMM + + +def iv_moment_fn(params: jnp.ndarray, data: Dict) -> jnp.ndarray: + """Moment condition for linear IV.""" + y, X, Z = data["y"], data["X"], data["Z"] + residuals = y - X @ params + return Z * residuals[:, None] + + +class LinearIVGMM(GMM): + """ + GMM estimator for linear instrumental variable models. + + This is a convenience class that is pre-configured for linear IV. + """ + + def __init__(self, **kwargs): + """ + Initialize the LinearIVGMM estimator. + + Args: + **kwargs: Additional keyword arguments to pass to the GMM solver. + """ + super().__init__(moment_fn=iv_moment_fn, **kwargs) + + def fit( + self, X: jnp.ndarray, y: jnp.ndarray, Z: jnp.ndarray, **kwargs + ) -> "LinearIVGMM": + """ + Fit the linear IV model. + + Args: + X: The matrix of endogenous variables. + y: The vector of outcomes. + Z: The matrix of instruments. + **kwargs: Additional keyword arguments to pass to the solver. + + Returns: + The fitted estimator. + """ + data = {"X": X, "y": y, "Z": Z} + init_params = jnp.zeros(X.shape[1]) + super().fit(data, init_params, **kwargs) + return self diff --git a/jaxonometrics/gmm/twostep.py b/jaxonometrics/gmm/twostep.py new file mode 100644 index 0000000..7cc25a3 --- /dev/null +++ b/jaxonometrics/gmm/twostep.py @@ -0,0 +1,61 @@ +from typing import Callable, Dict, Tuple + +import jax.numpy as jnp +from jax.tree_util import tree_leaves +from jaxopt import LevenbergMarquardt + +from ..base import BaseEstimator + + +class TwoStepGMM(BaseEstimator): + """ + Two-step GMM estimator for models with nuisance parameters. + + This class is designed for situations where the model has two sets of + parameters: the parameters of interest (theta) and nuisance parameters + (eta). The estimation is done in two steps: first, the nuisance parameters + are estimated, and then the parameters of interest are estimated, taking + the nuisance parameters as given. + + This is useful for models like AIPW, where the regression and propensity + score models are estimated first (nuisance parameters), and then the + causal effect is estimated using the influence function. + """ + + def __init__(self, moment_fn: Callable): + """ + Initialize the TwoStepGMM estimator. + + Args: + moment_fn: A function that computes the moment conditions. + It should have the signature `moment_fn(params, data)`, where + `params` is a tuple `(theta, eta)`. + """ + super().__init__() + self.moment_fn = moment_fn + + def fit( + self, + data: Dict, + init_theta: Dict, + init_eta: Dict, + ) -> "TwoStepGMM": + """ + Fit the two-step GMM model. + + Args: + data: A dictionary containing the data. + init_theta: Initial values for the parameters of interest. + init_eta: Initial values for the nuisance parameters. + + Returns: + The fitted estimator. + """ + params_init = (init_theta, init_eta) + solver = LevenbergMarquardt(self.moment_fn) + sol = solver.run(params_init, data=data) + self.params = { + "theta": sol.params[0], + "eta": sol.params[1], + } + return self diff --git a/jaxonometrics/legacy/__init__.py b/jaxonometrics/legacy/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/jaxonometrics/legacy/jax_gmm.py b/jaxonometrics/legacy/jax_gmm.py new file mode 100644 index 0000000..7f5cbfd --- /dev/null +++ b/jaxonometrics/legacy/jax_gmm.py @@ -0,0 +1,152 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.17.2 +# kernelspec: +# display_name: metrics +# language: python +# name: python3 +# --- + +# %% +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt +import seaborn as sns + +import jax +import jax.numpy as jnp + + +# %% [markdown] +# # GMM done easy +# +# moment eqn fn gets a $n \times k$ matrix of residuals (implied by the moment condition) and minimizes the implied objective function. +# Uses implicit gradient (and therefore performs better than `scipy.optimize.minimize`). + +# %% +from jaxopt import LevenbergMarquardt +from tqdm import tqdm +from joblib import Parallel, delayed + +jax.config.update("jax_enable_x64", True) + + +# %% +# IV dataset +np.random.seed(42) +def dgp(b = np.array([1, 2]), N = 1_000, K = 3): + # Instruments + Z = np.random.normal(0, 1, (N, K)) + # Covariates + pi = np.random.uniform(1, 2, K) + w = Z @ pi + np.random.normal(0, 1, N) # endogenous treatment + X = np.c_[np.ones(N), w] + # Outcome + y = X @ b + np.random.normal(0, 1, N) + return {"y": y, "X": X, "Z": Z} + + + +# %% +@jax.jit +def moment_cond(b, dat): + y, X, Z = jnp.array(dat['y']), jnp.array(dat['X']), jnp.array(dat['Z']) + resid = y - X @ b + return jnp.array(Z * resid[:, None]) + +def solve_gmm(dat): + x_init = jnp.zeros(dat['X'].shape[1]) + gn = LevenbergMarquardt(moment_cond) + return gn.run(x_init, dat = dat).params + +solve_gmm(dgp()) + + +# %% +# %%time +def gmmsim(): + df = dgp() + return solve_gmm(df) + +res = Parallel(n_jobs = -1)(delayed(gmmsim)() for _ in tqdm(range(1000))) +res = np.array(res) + + +# %% +f, ax = plt.subplots(1, 2, figsize=(12, 4)) +# Plot histogram of the 'intercept' column +ax[0].hist(np.array(res[:, 0]), color="red", alpha=0.5) +ax[0].axvline(x=1, color="black", linestyle="--", label="True Value") + +# Plot histogram of the 'slope' column +ax[1].hist(np.array(res[:, 1]), color="red", alpha=0.5) +ax[1].axvline(x=2, color="black", linestyle="--", label="True Value") + +plt.show() + +# %% [markdown] +# ## balancing weights +# +# solve dual of ERM problem for exact balance. For details, see [Wang and Zubizarreta](http://jrzubizarreta.com/minimal.pdf) + +# %% +from jaxopt import LBFGS +import empirical_calibration as ec +import matplotlib.pyplot as plt + + +# %% +@jax.jit +def eb_moment(b, X0, X1): + return jnp.log(jnp.exp(-1 * X0 @ b).sum()) + X1 @ b + + +def ebwt(X0, X1): + init_par = jnp.repeat(1.0, X0.shape[1]) + solver = LBFGS(fun=eb_moment, maxiter=100) + res = solver.run(init_par, X0=X0, X1=X1) + wt = np.exp(-1 * X0 @ res.params) + wt /= wt.sum() + return wt + + +# %% +sim = ec.data.kang_schafer.Simulation(size=1000) +w, y, X = sim.treatment, sim.outcome, np.c_[np.repeat(1, 1000), sim.covariates] +X0, X1 = X[w == 0, :], X[w == 1, :].mean(0) +b_start = np.random.rand(X.shape[1]) +eb_moment(b_start, X0, X1) +# wt = ebwt(X0, X1) + + +# %% +# kang shafer 2007 dgp +def onesim(): + sim = ec.data.kang_schafer.Simulation(size=1000) + w, y, X = sim.treatment, sim.outcome, np.c_[np.repeat(1, 1000), sim.covariates] + X0, X1 = X[w == 0, :], X[w == 1, :].mean(0) + wt = ebwt(X0, X1) + naive = y[w == 1].mean() - y[w == 0].mean() + wtd = y[w == 1].mean() - np.average(y[w == 0], weights=wt) + return naive, wtd + +onesim() + + +# %% +# %%time +res = Parallel(n_jobs=-1)(delayed(onesim)() for _ in tqdm(range(1_000))) + + +# %% +simres = pd.DataFrame(res, columns=["naive", "wtd"]) + +sns.histplot(simres["naive"], color="red", alpha=0.5, kde=True, label="naive") +sns.histplot(simres["wtd"], color="blue", alpha=0.5, kde=True, label="wtd") +plt.xlabel("bias") +plt.legend() diff --git a/jaxonometrics/legacy/jax_linear.py b/jaxonometrics/legacy/jax_linear.py new file mode 100644 index 0000000..3bea780 --- /dev/null +++ b/jaxonometrics/legacy/jax_linear.py @@ -0,0 +1,98 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.17.2 +# kernelspec: +# display_name: Python 3.10 (recommended) +# language: python +# name: python310 +# --- + +# %% [markdown] +# # Minimum Norm Interpolant + +# %% +import numpy as np +import jax.numpy as jnp +import lineax as lx +import matplotlib.pyplot as plt + +from sklearn.linear_model import LinearRegression +from statsmodels.api import OLS + + +# %% [markdown] +# $n>p$ dgp, OLS solution not unique + +# %% +def sparse_dgp(n = 10_000, p = 20_000, eta = 0.1): + X = np.c_[np.repeat(1, n), + np.random.normal(size = n*p).reshape((n, p)) + ] + # initialize coef vector + β, nzcount = np.repeat(0.0, p + 1), int(eta * p) + # choose nzcount number of non-zero coef + nzid = np.random.choice(p, nzcount, replace=False) + # set them to random values + β[nzid] = np.random.randn(nzcount) + # build in heteroskedasticity + e = np.random.normal(0, 0.5 + (0.1 * X[:, 1]>0), n) + # generate y + y = X @ β + e + return y, X + +y, X = sparse_dgp() + + +# %% [markdown] +# ### statsmodels + +# %% +# %%time +smols = OLS(y, X).fit() + +# %% +np.linalg.norm(smols.params) + +# %% [markdown] +# Statsmodels is very slow with such problems. + +# %% [markdown] +# ### scikit + +# %% +# %%time +m = LinearRegression() +m.fit(X, y) +(y - m.predict(X)).max() + + +# %% +np.linalg.norm(m.coef_) + + +# %% [markdown] +# ### lineax +# +# Very fast least squares solver (including for minimum norm interpolation problems). +# + +# %% +# %%time +sol = lx.linear_solve( # solve # Ax = b + operator = lx.MatrixLinearOperator(jnp.array(X)), # A + vector = jnp.array(y), # b + solver=lx.AutoLinearSolver(well_posed=None), + ) + +betahat = sol.value +# does it interpolate +(y - X @ betahat).max() + +# %% +np.linalg.norm(betahat) + diff --git a/jaxonometrics/legacy/jax_lm_optim.py b/jaxonometrics/legacy/jax_lm_optim.py new file mode 100644 index 0000000..4a0395d --- /dev/null +++ b/jaxonometrics/legacy/jax_lm_optim.py @@ -0,0 +1,63 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.17.2 +# kernelspec: +# display_name: metrics +# language: python +# name: python3 +# --- + +# %% +import jax +import jax.numpy as jnp +from sklearn.datasets import make_regression +from sklearn.model_selection import train_test_split + + +# %% +# create dataset +X, y, β = make_regression(n_features=3, coef=True, random_state=42) +X, X_test, y, y_test = train_test_split(X, y) +X, X_test = jnp.c_[jnp.ones(X.shape[0]), X], jnp.c_[jnp.ones(X_test.shape[0]), X_test] +β, X[:2, :], y[:2] + +# %% +# param dict +params = { + "b": jnp.zeros(X.shape[1]), +} + + +# forward pass: Xbeta +def forward(params, X): + return jnp.dot(X, params["b"]) + + +@jax.jit +def loss_fn(params, X, y): + err = forward(params, X) - y + return jnp.mean(jnp.square(err)) # mse + + +grad_fn = jax.grad(loss_fn) + + +def update(params, grads, lr=0.05): + return jax.tree.map(lambda p, g: p - lr * g, params, grads) + + +# %% +# the main training loop +for _ in range(50): + loss = loss_fn(params, X_test, y_test) + grads = grad_fn(params, X, y) + params = update(params, grads) + + +# %% +β, params['b'][1:] diff --git a/jaxonometrics/legacy/optax_adam_lin.py b/jaxonometrics/legacy/optax_adam_lin.py new file mode 100644 index 0000000..a422c42 --- /dev/null +++ b/jaxonometrics/legacy/optax_adam_lin.py @@ -0,0 +1,73 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.17.2 +# kernelspec: +# display_name: py311 +# language: python +# name: python3 +# --- + +# %% +import numpy as np +import jax.numpy as jnp +import jax +import optax +import functools + +jax.config.update("jax_enable_x64", True) +key = jax.random.PRNGKey(42) + + +# %% +n, p = 1000, 10 + +print(β := jax.random.uniform(key, (p,))) +X = jax.random.normal(key, (n, p)) +y = X @ β + jax.random.normal(key, (n,)) + + +# %% [markdown] +# ## single-layer neural network with linear activation function (OLS) + +# %% +@functools.partial(jax.vmap, in_axes=(None, 0)) +def network(params, x): + return jnp.dot(params, x) + + +def compute_loss(params, x, y): + y_pred = network(params, x) + loss = jnp.mean(optax.l2_loss(y_pred, y)) + return loss + + +# %% [markdown] +# Optimisation + +# %% +optimizer = optax.adam(1e-2) + +# Initialize parameters of the model + optimizer. +params = jnp.repeat(0.0, p) +opt_state = optimizer.init(params) +# A simple update loop. +for _ in range(1000): + grads = jax.grad(compute_loss)(params, X, y) + updates, opt_state = optimizer.update(grads, opt_state) + params = optax.apply_updates(params, updates) + +# %% +print(np.c_[ + β, # truth + params, # opt estimate + np.linalg.lstsq(X, y, rcond=None)[0] # closed form + ]) + + +# %% [markdown] +# Works well. diff --git a/jaxonometrics/legacy/sgd_gmm.py b/jaxonometrics/legacy/sgd_gmm.py new file mode 100644 index 0000000..9d3d202 --- /dev/null +++ b/jaxonometrics/legacy/sgd_gmm.py @@ -0,0 +1,273 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.17.2 +# kernelspec: +# display_name: py311 +# language: python +# name: python3 +# --- + +# %% +import numpy as np +import jax.numpy as jnp +import optax +from jax import grad, jit, random, vmap +from typing import Callable, Tuple +import jax.numpy as jnp +from jax import random +from scipy.linalg import toeplitz + +# %% +print(jnp.ones(3).devices()) +# {CudaDevice(id=0)} + +# %% [markdown] +# ## SGD for GMM +# +# +# given data $y, x$, instruments $z$, and weights $w$ at the unit level, loss is +# +# $$ +# L(\theta) = \sum_{m=1}^{d_z} \left ( +# \sum_i w_i z_{i, m} (y_i - h(x_i;\theta)) +# \right)^2 +# $$ +# +# refactor as +# +# $$ +# L(\theta) = \sum_i^n \sum_j^n +# \left( +# w_i w_j (y_i - h(x_i;\theta)) (y_j - h(x_j;\theta)) +# \sum_{m=1}^{d_z} z_{i,m} z_{j.m} +# \right) = \sum_i^n \sum_j^n \ell_{i, j}(\theta) +# $$ +# +# Sampling $i,j$ pairs takes a stochastic step in $\nabla(\ell_{i, j}(\theta))$, which is unbiased for $\nabla L(\theta)$. + +# %% [markdown] +# 1. can we use minibatches to construct a confidence interval around $\theta$ as we're learning $\theta$? Minibatches ~ Subsampling. +# +# 2. Can we pick weights $w_i$ to speed up convergence? Note that this is not equal to the optimal weights in the GMM problem $g(d; \theta)' W g(d; \theta)$ where the optimal choice of weight $W$ is the inverse of the outer product of scores $1/n \sum_i g_i g_i'$. This weight matrix is $k \times k$ and chooses weights for moment conditions, not observations. + +# %% [markdown] +# ### linear IV +# low-dim problem. + +# %% +class SGDIV: + def __init__( + self, + optimizer = optax.adam(0.01), + verbose: bool = False, + ): + self.verbose = verbose + self.opt = optimizer + self.theta = None + self.theta_history = None + + def compute_weights(self, Z, method='diagonal'): + if method == 'projection': + W = Z @ jnp.linalg.inv(Z.T @ Z) @ Z.T + elif method == 'diagonal': + W = jnp.diag(jnp.sum(Z**2, axis=1)) + elif method == 'identity': + W = jnp.eye(Z.shape[0]) + else: + raise ValueError("Method must be 'projection', 'diagonal', or 'identity'") + return W + + def fit( + self, + Y: jnp.ndarray, + X: jnp.ndarray, + Z: jnp.ndarray, + weight_method: str = 'diagonal', + max_iterations: int = 1000, + batch_size: int = 1000, + seed: int = 0, + ): + self.Y, self.X, self.Z = Y, X, Z + key = random.PRNGKey(seed) + self.n, self.d_X = X.shape + params = jnp.zeros(self.d_X) + opt_state = self.opt.init(params) + + W = self.compute_weights(Z, method=weight_method) + + self.theta_history = jnp.zeros((max_iterations, self.d_X)) + + for iteration in range(max_iterations): + key, subkey = random.split(key) + batch_indices = random.choice( + subkey, self.n, shape=(batch_size,), replace=False + ) + batch_gradient = self.compute_gradient( + params, + self.Y[batch_indices], + self.X[batch_indices], + self.Z[batch_indices], + W[batch_indices][:, batch_indices], + ) + updates, opt_state = self.opt.update(batch_gradient, opt_state) + params = optax.apply_updates(params, updates) + + self.theta_history = self.theta_history.at[iteration].set(params) + + if iteration % 100 == 0 and self.verbose: + current_loss = self.loss_fn(params, Y, X, Z, W) + print(f"Iteration {iteration}, Loss: {current_loss}, Theta: {params}") + + self.theta = params + return self.theta + + @staticmethod + @jit + def loss_fn( + theta: jnp.ndarray, Y: jnp.ndarray, X: jnp.ndarray, Z: jnp.ndarray, weights: jnp.ndarray + ): + residuals = Y - jnp.dot(X, theta) + weighted_residuals = weights @ residuals + loss = jnp.sum((Z.T @ weighted_residuals) ** 2) + return loss + + @staticmethod + @jit + def compute_gradient(theta, Y, X, Z, weights): + return grad(SGDIV.loss_fn)(theta, Y, X, Z, weights) + + +# %% [markdown] +# ### DGP +# +# Add outliers that generate bias in closed-form estimators. + +# %% +def simulate_dgp( + n=10_000, + d_X=5, + d_Z=5, + rho=0.7, + true_theta=jnp.array([1.0, 1.2, 0.8, 1.5, -0.6]), + instrument_strength=1.0, + seed=42, + outlier_fraction=0.1, + outlier_multiplier=10, +): + key = random.PRNGKey(seed) + # Create a Toeplitz correlation matrix for Z + corr_vector = jnp.array([rho**i for i in range(d_Z)]) + corr_matrix = jnp.array(toeplitz(corr_vector)) + # Generate Z (instruments) with the Toeplitz correlation structure + key, subkey = random.split(key) + Z_uncorrelated = random.normal(subkey, (n, d_Z)) + Z = Z_uncorrelated @ jnp.linalg.cholesky(corr_matrix).T + # Generate confounder U + key, subkey = random.split(key) + U = random.normal(subkey, (n,)) + # Generate instrument strength coefficients + key, subkey = random.split(key) + instrument_coefs = random.normal(subkey, (d_Z, d_X)) * jnp.sqrt(instrument_strength) + # Generate X with Z affecting X (relevance) and instrument strength + key, subkey = random.split(key) + X = random.normal(subkey, (n, d_X)) + Z @ instrument_coefs + 0.5 * U[:, None] + # Generate Y with true effect and confounding + key, subkey = random.split(key) + Y = jnp.dot(X, true_theta) + 2 * U + random.normal(subkey, (n,)) + + # Inject outliers + num_outliers = int(n * outlier_fraction) + outlier_indices = random.choice(key, n, (num_outliers,), replace=False) + X = X.at[outlier_indices].multiply(outlier_multiplier) + Y = Y.at[outlier_indices].multiply(outlier_multiplier) + + return X, Y, Z, U, true_theta, instrument_coefs + + +X, Y, Z, U, true_theta, instrument_coefs = simulate_dgp( + d_X=4, + d_Z=4, + true_theta=jnp.array([1.0, 1.0, 1.0, 1.0]), + instrument_strength=5.0, + rho=0.01, +) + +# %% +# OLS - biased +theta_ols = jnp.linalg.inv(X.T @ X) @ X.T @ Y +print(f"OLS solution: {theta_ols}") +P_Z = Z @ jnp.linalg.inv(Z.T @ Z) @ Z.T +theta_2sls = jnp.linalg.inv(X.T @ P_Z @ X) @ X.T @ P_Z @ Y +print(f"True Theta: {true_theta}") +print(f"2SLS Theta: {theta_2sls}") + +# %% [markdown] +# Fit IV via SGD. + +# %% +model = SGDIV(optimizer=optax.adam(0.01)) +theta_sgd = model.fit(Y, X, Z, max_iterations=20_000, batch_size=2_000) +print(f"SGD Theta: {theta_sgd}") + +# %% +print( + np.linalg.norm(true_theta - theta_ols, 2), + np.linalg.norm(true_theta - theta_2sls, 2), + np.linalg.norm(true_theta - theta_sgd, 2), +) + +# %% [markdown] +# SGD estimate has lower bias than 2SLS. + +# %% [markdown] +# ### convergence rates for different weighting schemes + +# %% +import matplotlib.pyplot as plt + + +# %% +def iv_convergence(opt=optax.adam(0.01), title="ADAM", + max_iterations = 10_000, b=1000, + weight_methods = ['identity', 'diagonal', 'projection'], + ): + results = {} + for method in weight_methods: + model = SGDIV(opt) + model.fit(Y, X, Z, weight_method=method, max_iterations=max_iterations, batch_size=b) + results[method] = model.theta_history + fig, axes = plt.subplots(2, 3, figsize=(15, 10), sharex=True) + axes = axes.flatten() + for i in range(model.d_X): + for method in weight_methods: + axes[i].plot(results[method][:, i], label=method, alpha = 0.5) + axes[i].axhline(y=true_theta[i], color='r', linestyle='--', label='True value') + axes[i].axhline(y=theta_2sls[i], color='b', linestyle='--', label='2SLS') + axes[i].legend() + axes[i].set_title(f'$\\theta_{i}$') + fig.delaxes(axes[4]);fig.delaxes(axes[5]) + fig.text(0.5, 0.04, 'Iteration', ha='center', va='center') + plt.suptitle(f'Convergence of Theta Estimates for Different Weighting Methods\n {title}') + plt.tight_layout() + plt.show() + + +# %% +iv_convergence() + +# %% +iv_convergence(optax.adam(0.1), "adam - LR 0.1") + +# %% +iv_convergence(optax.adam(0.05), "adam - LR 0.05") + +# %% +iv_convergence(optax.nadam(0.1), "nadam - LR 0.1") + +# %% +iv_convergence(optax.nadam(0.05), "nadam - LR 0.05") diff --git a/jaxonometrics/legacy/stacked_moments.py b/jaxonometrics/legacy/stacked_moments.py new file mode 100644 index 0000000..6385c6b --- /dev/null +++ b/jaxonometrics/legacy/stacked_moments.py @@ -0,0 +1,121 @@ +# --- +# jupyter: +# jupytext: +# text_representation: +# extension: .py +# format_name: percent +# format_version: '1.3' +# jupytext_version: 1.17.2 +# kernelspec: +# display_name: metrics +# language: python +# name: python3 +# --- + +# %% +import numpy as np +import statsmodels.api as sm + +# %% +import torch +from torchmin import minimize as torchmin + +# %% +import jax.numpy as jnp +import jax + +from jax.scipy.optimize import minimize as jaxmin + + +# %% +def dgp(n=500, k=3, reg=False, torchout = False): + X = np.random.normal(0, 1, n * k).reshape(n, k) + Y0 = X[:, 0] + X[:, 0] ** 2 + np.random.uniform(-0.5, 0.5, n) + Y1 = X[:, 1] + X[:, 1] ** 2 + np.random.uniform(-1, 1, n) + Z = np.random.binomial(1, 0.6, n) + Y = Y0 * (1 - Z) + Y1 * Z + if torchout: + return torch.tensor(np.c_[Y, Z, X]) + return np.c_[Y, Z, X] + +def linreg(data): + Y, Z, X = data[:, 0], data[:, 1], data[:, 2:] + XX = sm.add_constant(np.c_[Z, X, Z[:, None] * X.mean(axis = 0)]) + model = sm.OLS(Y, XX).fit() + return model.params + +linreg(dgp()) + + +# %% [markdown] +# $$ +# Y_i = \alpha + \tau W_i + X_i'\beta + W_i \tilde{X}_i'\gamma + \epsilon_i +# $$ +# +# where $\tilde{X}_i = X_i - \bar{X}$ is a centered version of $X_i$. The goal is to estimate $\tau$. + +# %% [markdown] +# ## Torch + +# %% +def moment_cond_cent(theta, data): + Z, Y, X = data[:, 1], data[:, 0], data[:, 2:] + n, p = X.shape + mu, beta = theta[:p], theta[p:] + Xcent = X - mu + ones = torch.ones(n, 1, device=data.device) + Xtilde = torch.cat([ones, Z.view(-1, 1), X, Z.view(-1, 1) * Xcent], dim=1) + resid = (Y - torch.matmul(Xtilde, beta)).view(-1, 1) + m = Xtilde * resid + return torch.cat([m, Xcent], dim=1) + + +# %% +data = dgp(n = 1_000, k = 2, torchout=True) +print(np.round(linreg(data.numpy()), 3)) +# m-estimation +k = data.shape[1] +theta_init = torch.tensor(np.random.rand((k-1)*2 +(k-2))) + +def loss(theta): + m = moment_cond_cent(theta, data) + return torch.sum(m.mean(axis=0) ** 2) + +params = torchmin(loss, x0 = theta_init, method="l-bfgs") +params.x[2:].numpy().round(3) + + +# %% [markdown] +# ## JAX + +# %% +def moment_cond_jax(theta, data): + Z, Y, X = jnp.array(data[:, 1]), jnp.array(data[:, 0]), jnp.array(data[:, 2:]) + n, p = X.shape + mu, beta = theta[:p], theta[p:] + Xcent = X - mu + Xtilde = jnp.c_[np.ones(n), Z, X, Z[:, None] * Xcent] + resid = (Y - Xtilde @ beta)[:, None] + m = Xtilde * resid + return jnp.c_[m, Xcent] + + +# %% +def gmm_objective(theta, data): + moments = moment_cond_jax(theta, data) + return np.sum(moments.mean(axis=0) ** 2) + +@jax.jit +def optimize_gmm(theta_init, data): + return jaxmin(lambda theta: gmm_objective(theta, data), theta_init, method="BFGS") + + + +# %% +data = dgp(n = 1_000, k = 2, torchout=False) +print(np.round(linreg(data), 3)) + +k = data.shape[1] +theta_init = np.random.rand((k-1)*2 +(k-2)) + +print(np.round(optimize_gmm(theta_init, data).x[2:], 3)) diff --git a/jaxonometrics/linear.py b/jaxonometrics/linear.py new file mode 100644 index 0000000..81f8f6b --- /dev/null +++ b/jaxonometrics/linear.py @@ -0,0 +1,37 @@ +from typing import Dict, Optional + +import jax.numpy as jnp +import lineax as lx + +from .base import BaseEstimator + + +class LinearRegression(BaseEstimator): + """ + Linear regression model using lineax for efficient solving. + + This class provides a simple interface for fitting a linear regression + model, especially useful for high-dimensional problems where n > p. + """ + + def __init__(self): + super().__init__() + + def fit(self, X: jnp.ndarray, y: jnp.ndarray) -> "LinearRegression": + """ + Fit the linear model. + + Args: + X: The design matrix of shape (n_samples, n_features). + y: The target vector of shape (n_samples,). + + Returns: + The fitted estimator. + """ + sol = lx.linear_solve( + operator=lx.MatrixLinearOperator(X), + vector=y, + solver=lx.AutoLinearSolver(well_posed=None), + ) + self.params = {"beta": sol.value} + return self diff --git a/nb/linmod.ipynb b/nb/linmod.ipynb new file mode 100644 index 0000000..fd2868c --- /dev/null +++ b/nb/linmod.ipynb @@ -0,0 +1,405 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b1dfc7b8", + "metadata": { + "papermill": { + "duration": 0.027127, + "end_time": "2025-06-29T05:16:03.517500", + "exception": false, + "start_time": "2025-06-29T05:16:03.490373", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# Linear Model Comparison: statsmodels, pyfixest, and jaxonometrics\n", + "\n", + "This notebook compares the performance of three different libraries for linear regression: `statsmodels`, `pyfixest`, and `jaxonometrics`. We will use a high-dimensional sparse DGP to highlight the differences in performance." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "f5bf6ed4", + "metadata": { + "execution": { + "iopub.execute_input": "2025-06-29T05:16:03.559707Z", + "iopub.status.busy": "2025-06-29T05:16:03.558644Z", + "iopub.status.idle": "2025-06-29T05:16:06.920801Z", + "shell.execute_reply": "2025-06-29T05:16:06.920027Z" + }, + "papermill": { + "duration": 3.375505, + "end_time": "2025-06-29T05:16:06.922260", + "exception": false, + "start_time": "2025-06-29T05:16:03.546755", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import jax.numpy as jnp\n", + "import statsmodels.api as sm\n", + "from pyfixest.estimation import feols\n", + "from jaxonometrics.linear import LinearRegression\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "id": "4a577c9a", + "metadata": { + "papermill": { + "duration": 0.007598, + "end_time": "2025-06-29T05:16:06.932171", + "exception": false, + "start_time": "2025-06-29T05:16:06.924573", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## DGP" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fc4d98ef", + "metadata": { + "execution": { + "iopub.execute_input": "2025-06-29T05:16:06.939018Z", + "iopub.status.busy": "2025-06-29T05:16:06.937726Z", + "iopub.status.idle": "2025-06-29T05:16:06.943867Z", + "shell.execute_reply": "2025-06-29T05:16:06.943037Z" + }, + "papermill": { + "duration": 0.010632, + "end_time": "2025-06-29T05:16:06.945045", + "exception": false, + "start_time": "2025-06-29T05:16:06.934413", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def sparse_dgp(n=10_000, p=20_000, eta=0.1):\n", + " X = np.c_[np.ones(n), np.random.normal(size=n * p).reshape((n, p))]\n", + " β, nzcount = np.repeat(0.0, p + 1), int(eta * p)\n", + " nzid = np.random.choice(p, nzcount, replace=False)\n", + " β[nzid] = np.random.randn(nzcount)\n", + " e = np.random.normal(0, 0.5 + (0.1 * X[:, 1] > 0), n)\n", + " y = X @ β + e\n", + " return y, X" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "d15c379b", + "metadata": { + "execution": { + "iopub.execute_input": "2025-06-29T05:16:06.950194Z", + "iopub.status.busy": "2025-06-29T05:16:06.949949Z", + "iopub.status.idle": "2025-06-29T05:16:06.956035Z", + "shell.execute_reply": "2025-06-29T05:16:06.955279Z" + }, + "papermill": { + "duration": 0.010128, + "end_time": "2025-06-29T05:16:06.957289", + "exception": false, + "start_time": "2025-06-29T05:16:06.947161", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def onerep(X, y):\n", + " # df\n", + " df = pd.DataFrame(X, columns=[f\"x{i}\" for i in range(X.shape[1])])\n", + " df[\"y\"] = y\n", + " # statsmodels\n", + " start1 = time.time()\n", + " sm_model = sm.OLS(y, X).fit()\n", + " sm_time = time.time() - start1\n", + " # pyfixest\n", + " start2 = time.time()\n", + " fixest_model = feols(\n", + " f\"y ~ -1 + {'+'.join([f'x{i}' for i in range(X.shape[1])])}\", data=df\n", + " )\n", + " fixest_time = time.time() - start2\n", + " # jax\n", + " start3 = time.time()\n", + " jax_model = LinearRegression()\n", + " jax_model.fit(jnp.array(X), jnp.array(y))\n", + " jax_time = time.time() - start3\n", + " return {\n", + " \"sm_time\": sm_time,\n", + " \"fixest_time\": fixest_time,\n", + " \"jax_time\": jax_time,\n", + " \"sm_params\": sm_model.params,\n", + " \"fixest_params\": fixest_model.coef().values,\n", + " \"jax_params\": np.array(jax_model.params[\"beta\"]),\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "97b2b62d", + "metadata": { + "papermill": { + "duration": 0.001963, + "end_time": "2025-06-29T05:16:06.961390", + "exception": false, + "start_time": "2025-06-29T05:16:06.959427", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Low-Dim" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "36049be0", + "metadata": { + "execution": { + "iopub.execute_input": "2025-06-29T05:16:06.966426Z", + "iopub.status.busy": "2025-06-29T05:16:06.966160Z", + "iopub.status.idle": "2025-06-29T05:16:08.459381Z", + "shell.execute_reply": "2025-06-29T05:16:08.458611Z" + }, + "papermill": { + "duration": 1.497523, + "end_time": "2025-06-29T05:16:08.460886", + "exception": false, + "start_time": "2025-06-29T05:16:06.963363", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/alal/Desktop/code/econometrics/jaxonometrics/.venv/lib/python3.13/site-packages/pyfixest/estimation/feols_.py:2628: UserWarning: \n", + " 1 variables dropped due to multicollinearity.\n", + " The following variables are dropped: ['x0'].\n", + " \n", + " warnings.warn(\n", + "INFO:2025-06-28 22:16:08,080:jax._src.xla_bridge:752: Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " sm time: 0.0117s, fixest time: 1.0715s, jax time: 0.3841s\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([-0.00219642, 0.01010658, 0.01650456, 0.00361118, 0.01222154]),\n", + " array([-0.00219642, 0.01010658, 0.01650456, 0.00361118, 0.01222154]),\n", + " array([-0.00219641, 0.01010658, 0.01650455, 0.00361117, 0.01222158],\n", + " dtype=float32))" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y, X = sparse_dgp(n = 10_000, p=20)\n", + "res = onerep(X, y)\n", + "print(f\" sm time: {res['sm_time']:.4f}s, fixest time: {res['fixest_time']:.4f}s, jax time: {res['jax_time']:.4f}s\")\n", + "res[\"sm_params\"][:5], res[\"fixest_params\"][:5], res[\"jax_params\"][:5]" + ] + }, + { + "cell_type": "markdown", + "id": "5709e8df", + "metadata": { + "papermill": { + "duration": 0.003407, + "end_time": "2025-06-29T05:16:08.468271", + "exception": false, + "start_time": "2025-06-29T05:16:08.464864", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### High-Dim" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "691d5fa0", + "metadata": { + "execution": { + "iopub.execute_input": "2025-06-29T05:16:08.477032Z", + "iopub.status.busy": "2025-06-29T05:16:08.476302Z", + "iopub.status.idle": "2025-06-29T05:16:40.660938Z", + "shell.execute_reply": "2025-06-29T05:16:40.660279Z" + }, + "papermill": { + "duration": 32.190832, + "end_time": "2025-06-29T05:16:40.662450", + "exception": false, + "start_time": "2025-06-29T05:16:08.471618", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/alal/Desktop/code/econometrics/jaxonometrics/.venv/lib/python3.13/site-packages/pyfixest/estimation/feols_.py:2628: UserWarning: \n", + " 1 variables dropped due to multicollinearity.\n", + " The following variables are dropped: ['x0'].\n", + " \n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " sm time: 14.8658s, fixest time: 14.2712s, jax time: 2.2547s\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([ 0.00146385, -0.00174201, -0.01347367, -0.01551777, -0.02014805]),\n", + " array([ 0.00146385, -0.00174201, -0.01347367, -0.01551777, -0.02014805]),\n", + " array([ 0.00146354, -0.00174188, -0.01347361, -0.01551812, -0.02014804],\n", + " dtype=float32))" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y, X = sparse_dgp(n = 10_000, p=2_000)\n", + "res = onerep(X, y)\n", + "print(f\" sm time: {res['sm_time']:.4f}s, fixest time: {res['fixest_time']:.4f}s, jax time: {res['jax_time']:.4f}s\")\n", + "res[\"sm_params\"][:5], res[\"fixest_params\"][:5], res[\"jax_params\"][:5]" + ] + }, + { + "cell_type": "markdown", + "id": "cbc3f763", + "metadata": { + "papermill": { + "duration": 0.003149, + "end_time": "2025-06-29T05:16:40.670767", + "exception": false, + "start_time": "2025-06-29T05:16:40.667618", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### Ultra-High-Dim / Ill-Posed" + ] + }, + { + "cell_type": "markdown", + "id": "174ac0ff", + "metadata": { + "papermill": { + "duration": 0.002596, + "end_time": "2025-06-29T05:16:40.676041", + "exception": false, + "start_time": "2025-06-29T05:16:40.673445", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "The minimum-norm interpolator is easy to calculate with lineax because it automatically adapts the solver." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b924e5d3", + "metadata": { + "papermill": { + "duration": null, + "end_time": null, + "exception": false, + "start_time": "2025-06-29T05:16:40.678520", + "status": "running" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "y, X = sparse_dgp(n = 10_000, p=20_000)\n", + "res = onerep(X, y)\n", + "print(res[\"sm_time\"], res[\"fixest_time\"], res[\"jax_time\"])\n", + "res[\"sm_params\"][:5], res[\"fixest_params\"][:5], res[\"jax_params\"][:5]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.3" + }, + "papermill": { + "default_parameters": {}, + "duration": null, + "end_time": null, + "environment_variables": {}, + "exception": null, + "input_path": "linear_model_comparison.ipynb", + "output_path": "linmod.ipynb", + "parameters": {}, + "start_time": "2025-06-29T05:16:02.288218", + "version": "2.6.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/optax_adam_lin.ipynb b/optax_adam_lin.ipynb deleted file mode 100644 index 8f97fb5..0000000 --- a/optax_adam_lin.ipynb +++ /dev/null @@ -1,149 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import jax.numpy as jnp\n", - "import jax\n", - "import optax\n", - "import functools\n", - "\n", - "jax.config.update(\"jax_enable_x64\", True)\n", - "key = jax.random.PRNGKey(42)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[0.24195682 0.57397975 0.43901027 0.20791509 0.37068355 0.97989601\n", - " 0.97685815 0.36242998 0.32092 0.54494161]\n" - ] - } - ], - "source": [ - "n, p = 1000, 10\n", - "\n", - "print(β := jax.random.uniform(key, (p,)))\n", - "X = jax.random.normal(key, (n, p))\n", - "y = X @ β + jax.random.normal(key, (n,))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## single-layer neural network with linear activation function (OLS)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "@functools.partial(jax.vmap, in_axes=(None, 0))\n", - "def network(params, x):\n", - " return jnp.dot(params, x)\n", - "\n", - "\n", - "def compute_loss(params, x, y):\n", - " y_pred = network(params, x)\n", - " loss = jnp.mean(optax.l2_loss(y_pred, y))\n", - " return loss" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Optimisation" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "optimizer = optax.adam(1e-2)\n", - "\n", - "# Initialize parameters of the model + optimizer.\n", - "params = jnp.repeat(0.0, p)\n", - "opt_state = optimizer.init(params)\n", - "# A simple update loop.\n", - "for _ in range(1000):\n", - " grads = jax.grad(compute_loss)(params, X, y)\n", - " updates, opt_state = optimizer.update(grads, opt_state)\n", - " params = optax.apply_updates(params, updates)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[0.24195682 0.26143229 0.26143229]\n", - " [0.57397975 0.55450794 0.55450794]\n", - " [0.43901027 0.44335113 0.44335113]\n", - " [0.20791509 0.18611259 0.18611259]\n", - " [0.37068355 0.39626627 0.39626627]\n", - " [0.97989601 1.01610712 1.01610712]\n", - " [0.97685815 0.98650555 0.98650555]\n", - " [0.36242998 0.37793706 0.37793706]\n", - " [0.32092 0.2965661 0.2965661 ]\n", - " [0.54494161 0.54387632 0.54387632]]\n" - ] - } - ], - "source": [ - "print(np.c_[\n", - " β, # truth\n", - " params, # opt estimate\n", - " np.linalg.lstsq(X, y, rcond=None)[0] # closed form\n", - " ])\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Works well." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "py311", - "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.10.14" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..316e9c1 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,33 @@ +[build-system] +requires = ["hatchling"] +build-backend = "hatchling.build" + +[project] +name = "jaxonometrics" +version = "0.0.1" +dependencies = [ + "numpy", + "jax", + "jaxlib", + "jaxopt", + "lineax", + "optax", + "formulaic", + "narwhals", +] +requires-python = ">=3.8" +authors = [ + {name = "Apoorva Lal", email = "lal.apoorva@gmail.com"}, +] +description = "Econometrics in JAX." +readme = "README.md" +license = "MIT" +keywords = ["econometrics", "jax", "machine learning"] +classifiers = [ + "Development Status :: 4 - Beta", + "Programming Language :: Python" +] + +[project.urls] +Repository = "https://github.com/py-econometrics/jaxonometrics" + diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index c932f4c..0000000 --- a/requirements.txt +++ /dev/null @@ -1,8 +0,0 @@ -jax -jaxopt -lineax -optax - -numpy -matplotlib -seaborn diff --git a/sgd_gmm.ipynb b/sgd_gmm.ipynb deleted file mode 100644 index e24dd01..0000000 --- a/sgd_gmm.ipynb +++ /dev/null @@ -1,617 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "be23a977-cab8-41ce-867c-e0b697197a89", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:45:21.337367Z", - "iopub.status.busy": "2024-10-23T22:45:21.337175Z", - "iopub.status.idle": "2024-10-23T22:45:21.969246Z", - "shell.execute_reply": "2024-10-23T22:45:21.968744Z", - "shell.execute_reply.started": "2024-10-23T22:45:21.337351Z" - } - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import jax.numpy as jnp\n", - "import optax\n", - "from jax import grad, jit, random, vmap\n", - "from typing import Callable, Tuple\n", - "import jax.numpy as jnp\n", - "from jax import random\n", - "from scipy.linalg import toeplitz" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d9771ac5-7c0b-4b20-9d13-c50edfba660d", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:54:19.872105Z", - "iopub.status.busy": "2024-10-23T22:54:19.871806Z", - "iopub.status.idle": "2024-10-23T22:54:19.875282Z", - "shell.execute_reply": "2024-10-23T22:54:19.874828Z", - "shell.execute_reply.started": "2024-10-23T22:54:19.872088Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "{CpuDevice(id=0)}\n" - ] - } - ], - "source": [ - "print(jnp.ones(3).devices())\n", - "# {CudaDevice(id=0)}" - ] - }, - { - "cell_type": "markdown", - "id": "d1ae6c71-6b82-45ef-8ada-8c2603ef2f4d", - "metadata": {}, - "source": [ - "## SGD for GMM\n", - "\n", - "\n", - "given data $y, x$, instruments $z$, and weights $w$ at the unit level, loss is \n", - "\n", - "$$\n", - "L(\\theta) = \\sum_{m=1}^{d_z} \\left (\n", - " \\sum_i w_i z_{i, m} (y_i - h(x_i;\\theta))\n", - "\\right)^2\n", - "$$\n", - "\n", - "refactor as \n", - "\n", - "$$\n", - "L(\\theta) = \\sum_i^n \\sum_j^n\n", - "\\left(\n", - " w_i w_j (y_i - h(x_i;\\theta)) (y_j - h(x_j;\\theta)) \n", - " \\sum_{m=1}^{d_z} z_{i,m} z_{j.m}\n", - "\\right) = \\sum_i^n \\sum_j^n \\ell_{i, j}(\\theta)\n", - "$$\n", - "\n", - "Sampling $i,j$ pairs takes a stochastic step in $\\nabla(\\ell_{i, j}(\\theta))$, which is unbiased for $\\nabla L(\\theta)$." - ] - }, - { - "attachments": {}, - "cell_type": "markdown", - "id": "8f663727-1e1a-4385-96cc-c3a0f8ada95c", - "metadata": {}, - "source": [ - "1. can we use minibatches to construct a confidence interval around $\\theta$ as we're learning $\\theta$? Minibatches ~ Subsampling.\n", - "\n", - "2. Can we pick weights $w_i$ to speed up convergence? Note that this is not equal to the optimal weights in the GMM problem $g(d; \\theta)' W g(d; \\theta)$ where the optimal choice of weight $W$ is the inverse of the outer product of scores $1/n \\sum_i g_i g_i'$. This weight matrix is $k \\times k$ and chooses weights for moment conditions, not observations." - ] - }, - { - "cell_type": "markdown", - "id": "6b95e425-c1cf-4cdd-93e2-2e0979b2af3b", - "metadata": {}, - "source": [ - "### linear IV \n", - "low-dim problem." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "d28db9dc-fa08-44ea-8572-af49fd2346c0", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:45:21.970385Z", - "iopub.status.busy": "2024-10-23T22:45:21.970048Z", - "iopub.status.idle": "2024-10-23T22:45:21.978567Z", - "shell.execute_reply": "2024-10-23T22:45:21.978198Z", - "shell.execute_reply.started": "2024-10-23T22:45:21.970368Z" - } - }, - "outputs": [], - "source": [ - "class SGDIV:\n", - " def __init__(\n", - " self,\n", - " optimizer = optax.adam(0.01),\n", - " verbose: bool = False,\n", - " ):\n", - " self.verbose = verbose\n", - " self.opt = optimizer\n", - " self.theta = None\n", - " self.theta_history = None\n", - "\n", - " def compute_weights(self, Z, method='diagonal'):\n", - " if method == 'projection':\n", - " W = Z @ jnp.linalg.inv(Z.T @ Z) @ Z.T\n", - " elif method == 'diagonal':\n", - " W = jnp.diag(jnp.sum(Z**2, axis=1))\n", - " elif method == 'identity':\n", - " W = jnp.eye(Z.shape[0])\n", - " else:\n", - " raise ValueError(\"Method must be 'projection', 'diagonal', or 'identity'\")\n", - " return W\n", - "\n", - " def fit(\n", - " self,\n", - " Y: jnp.ndarray,\n", - " X: jnp.ndarray,\n", - " Z: jnp.ndarray,\n", - " weight_method: str = 'diagonal',\n", - " max_iterations: int = 1000,\n", - " batch_size: int = 1000,\n", - " seed: int = 0,\n", - " ):\n", - " self.Y, self.X, self.Z = Y, X, Z\n", - " key = random.PRNGKey(seed)\n", - " self.n, self.d_X = X.shape\n", - " params = jnp.zeros(self.d_X)\n", - " opt_state = self.opt.init(params)\n", - "\n", - " W = self.compute_weights(Z, method=weight_method)\n", - "\n", - " self.theta_history = jnp.zeros((max_iterations, self.d_X))\n", - "\n", - " for iteration in range(max_iterations):\n", - " key, subkey = random.split(key)\n", - " batch_indices = random.choice(\n", - " subkey, self.n, shape=(batch_size,), replace=False\n", - " )\n", - " batch_gradient = self.compute_gradient(\n", - " params,\n", - " self.Y[batch_indices],\n", - " self.X[batch_indices],\n", - " self.Z[batch_indices],\n", - " W[batch_indices][:, batch_indices],\n", - " )\n", - " updates, opt_state = self.opt.update(batch_gradient, opt_state)\n", - " params = optax.apply_updates(params, updates)\n", - "\n", - " self.theta_history = self.theta_history.at[iteration].set(params)\n", - "\n", - " if iteration % 100 == 0 and self.verbose:\n", - " current_loss = self.loss_fn(params, Y, X, Z, W)\n", - " print(f\"Iteration {iteration}, Loss: {current_loss}, Theta: {params}\")\n", - "\n", - " self.theta = params\n", - " return self.theta\n", - "\n", - " @staticmethod\n", - " @jit\n", - " def loss_fn(\n", - " theta: jnp.ndarray, Y: jnp.ndarray, X: jnp.ndarray, Z: jnp.ndarray, weights: jnp.ndarray\n", - " ):\n", - " residuals = Y - jnp.dot(X, theta)\n", - " weighted_residuals = weights @ residuals\n", - " loss = jnp.sum((Z.T @ weighted_residuals) ** 2)\n", - " return loss\n", - "\n", - " @staticmethod\n", - " @jit\n", - " def compute_gradient(theta, Y, X, Z, weights):\n", - " return grad(SGDIV.loss_fn)(theta, Y, X, Z, weights)" - ] - }, - { - "cell_type": "markdown", - "id": "de275735-dc6a-45b5-a3ce-84573f7ecc39", - "metadata": {}, - "source": [ - "### DGP\n", - "\n", - "Add outliers that generate bias in closed-form estimators." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "360bbd18-8fd8-458e-95f6-93b2a2f07a83", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:45:21.979467Z", - "iopub.status.busy": "2024-10-23T22:45:21.979158Z", - "iopub.status.idle": "2024-10-23T22:45:26.467371Z", - "shell.execute_reply": "2024-10-23T22:45:26.466822Z", - "shell.execute_reply.started": "2024-10-23T22:45:21.979453Z" - } - }, - "outputs": [], - "source": [ - "def simulate_dgp(\n", - " n=10_000,\n", - " d_X=5,\n", - " d_Z=5,\n", - " rho=0.7,\n", - " true_theta=jnp.array([1.0, 1.2, 0.8, 1.5, -0.6]),\n", - " instrument_strength=1.0,\n", - " seed=42,\n", - " outlier_fraction=0.1,\n", - " outlier_multiplier=10,\n", - "):\n", - " key = random.PRNGKey(seed)\n", - " # Create a Toeplitz correlation matrix for Z\n", - " corr_vector = jnp.array([rho**i for i in range(d_Z)])\n", - " corr_matrix = jnp.array(toeplitz(corr_vector))\n", - " # Generate Z (instruments) with the Toeplitz correlation structure\n", - " key, subkey = random.split(key)\n", - " Z_uncorrelated = random.normal(subkey, (n, d_Z))\n", - " Z = Z_uncorrelated @ jnp.linalg.cholesky(corr_matrix).T\n", - " # Generate confounder U\n", - " key, subkey = random.split(key)\n", - " U = random.normal(subkey, (n,))\n", - " # Generate instrument strength coefficients\n", - " key, subkey = random.split(key)\n", - " instrument_coefs = random.normal(subkey, (d_Z, d_X)) * jnp.sqrt(instrument_strength)\n", - " # Generate X with Z affecting X (relevance) and instrument strength\n", - " key, subkey = random.split(key)\n", - " X = random.normal(subkey, (n, d_X)) + Z @ instrument_coefs + 0.5 * U[:, None]\n", - " # Generate Y with true effect and confounding\n", - " key, subkey = random.split(key)\n", - " Y = jnp.dot(X, true_theta) + 2 * U + random.normal(subkey, (n,))\n", - "\n", - " # Inject outliers\n", - " num_outliers = int(n * outlier_fraction)\n", - " outlier_indices = random.choice(key, n, (num_outliers,), replace=False)\n", - " X = X.at[outlier_indices].multiply(outlier_multiplier)\n", - " Y = Y.at[outlier_indices].multiply(outlier_multiplier)\n", - "\n", - " return X, Y, Z, U, true_theta, instrument_coefs\n", - "\n", - "\n", - "X, Y, Z, U, true_theta, instrument_coefs = simulate_dgp(\n", - " d_X=4,\n", - " d_Z=4,\n", - " true_theta=jnp.array([1.0, 1.0, 1.0, 1.0]),\n", - " instrument_strength=5.0,\n", - " rho=0.01,\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "825d706c-f81c-4a12-a2df-134ba2c8d83d", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:45:26.468257Z", - "iopub.status.busy": "2024-10-23T22:45:26.468087Z", - "iopub.status.idle": "2024-10-23T22:45:27.198491Z", - "shell.execute_reply": "2024-10-23T22:45:27.197982Z", - "shell.execute_reply.started": "2024-10-23T22:45:26.468241Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "OLS solution: [1.0916696 1.7088315 1.1842754 1.2159433]\n", - "True Theta: [1. 1. 1. 1.]\n", - "2SLS Theta: [1.034256 0.8864698 0.96329564 0.95859706]\n" - ] - } - ], - "source": [ - "# OLS - biased\n", - "theta_ols = jnp.linalg.inv(X.T @ X) @ X.T @ Y\n", - "print(f\"OLS solution: {theta_ols}\")\n", - "P_Z = Z @ jnp.linalg.inv(Z.T @ Z) @ Z.T\n", - "theta_2sls = jnp.linalg.inv(X.T @ P_Z @ X) @ X.T @ P_Z @ Y\n", - "print(f\"True Theta: {true_theta}\")\n", - "print(f\"2SLS Theta: {theta_2sls}\")" - ] - }, - { - "cell_type": "markdown", - "id": "e6f14faf-cd56-46ac-bc41-699135cbc584", - "metadata": {}, - "source": [ - "Fit IV via SGD." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "210fbf75-2399-42f6-8ea0-8bd86f93448c", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:45:27.199373Z", - "iopub.status.busy": "2024-10-23T22:45:27.199157Z", - "iopub.status.idle": "2024-10-23T22:47:48.656332Z", - "shell.execute_reply": "2024-10-23T22:47:48.655646Z", - "shell.execute_reply.started": "2024-10-23T22:45:27.199356Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SGD Theta: [0.9843811 1.0139568 0.99863344 1.0102218 ]\n" - ] - } - ], - "source": [ - "model = SGDIV(optimizer=optax.adam(0.01))\n", - "theta_sgd = model.fit(Y, X, Z, max_iterations=20_000, batch_size=2_000)\n", - "print(f\"SGD Theta: {theta_sgd}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "ffdac0b4-0b37-4eed-a33b-33796f6243f1", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:47:48.658469Z", - "iopub.status.busy": "2024-10-23T22:47:48.658214Z", - "iopub.status.idle": "2024-10-23T22:47:48.774005Z", - "shell.execute_reply": "2024-10-23T22:47:48.773494Z", - "shell.execute_reply.started": "2024-10-23T22:47:48.658452Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.76904774 0.13085869 0.02334729\n" - ] - } - ], - "source": [ - "print(\n", - " np.linalg.norm(true_theta - theta_ols, 2),\n", - " np.linalg.norm(true_theta - theta_2sls, 2),\n", - " np.linalg.norm(true_theta - theta_sgd, 2),\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "44a8535f-bfd8-4b01-b2b2-08157b1ab8e0", - "metadata": {}, - "source": [ - "SGD estimate has lower bias than 2SLS." - ] - }, - { - "cell_type": "markdown", - "id": "a339fb11-1d07-4eff-80d4-f1dc73d814b8", - "metadata": {}, - "source": [ - "### convergence rates for different weighting schemes" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "307037d8-1cf7-423e-aa2d-436e3da8126f", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T22:47:48.774870Z", - "iopub.status.busy": "2024-10-23T22:47:48.774640Z", - "iopub.status.idle": "2024-10-23T22:47:48.996523Z", - "shell.execute_reply": "2024-10-23T22:47:48.996008Z", - "shell.execute_reply.started": "2024-10-23T22:47:48.774854Z" - } - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "804c02ed-567d-43f2-8ae4-abadc3a8cbe7", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T23:06:26.838928Z", - "iopub.status.busy": "2024-10-23T23:06:26.838624Z", - "iopub.status.idle": "2024-10-23T23:06:26.844370Z", - "shell.execute_reply": "2024-10-23T23:06:26.843875Z", - "shell.execute_reply.started": "2024-10-23T23:06:26.838910Z" - } - }, - "outputs": [], - "source": [ - "def iv_convergence(opt=optax.adam(0.01), title=\"ADAM\",\n", - " max_iterations = 10_000, b=1000,\n", - " weight_methods = ['identity', 'diagonal', 'projection'],\n", - " ):\n", - " results = {}\n", - " for method in weight_methods:\n", - " model = SGDIV(opt)\n", - " model.fit(Y, X, Z, weight_method=method, max_iterations=max_iterations, batch_size=b)\n", - " results[method] = model.theta_history\n", - " fig, axes = plt.subplots(2, 3, figsize=(15, 10), sharex=True)\n", - " axes = axes.flatten()\n", - " for i in range(model.d_X):\n", - " for method in weight_methods:\n", - " axes[i].plot(results[method][:, i], label=method, alpha = 0.5)\n", - " axes[i].axhline(y=true_theta[i], color='r', linestyle='--', label='True value')\n", - " axes[i].axhline(y=theta_2sls[i], color='b', linestyle='--', label='2SLS')\n", - " axes[i].legend()\n", - " axes[i].set_title(f'$\\\\theta_{i}$')\n", - " fig.delaxes(axes[4]);fig.delaxes(axes[5])\n", - " fig.text(0.5, 0.04, 'Iteration', ha='center', va='center')\n", - " plt.suptitle(f'Convergence of Theta Estimates for Different Weighting Methods\\n {title}')\n", - " plt.tight_layout()\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "030a2721-5bd3-41be-b185-27eb53df3c4a", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T23:06:27.077184Z", - "iopub.status.busy": "2024-10-23T23:06:27.076682Z", - "iopub.status.idle": "2024-10-23T23:09:57.528126Z", - "shell.execute_reply": "2024-10-23T23:09:57.527477Z", - "shell.execute_reply.started": "2024-10-23T23:06:27.077166Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "iv_convergence()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "b0c44519-e078-41e1-8139-95ebaec51cc1", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T23:09:57.529575Z", - "iopub.status.busy": "2024-10-23T23:09:57.529342Z", - "iopub.status.idle": "2024-10-23T23:13:33.044718Z", - "shell.execute_reply": "2024-10-23T23:13:33.044116Z", - "shell.execute_reply.started": "2024-10-23T23:09:57.529559Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "iv_convergence(optax.adam(0.1), \"adam - LR 0.1\")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "c3e34947-d4c7-48d5-a0e7-0729b3b38639", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T23:13:33.045809Z", - "iopub.status.busy": "2024-10-23T23:13:33.045561Z", - "iopub.status.idle": "2024-10-23T23:17:04.707107Z", - "shell.execute_reply": "2024-10-23T23:17:04.706406Z", - "shell.execute_reply.started": "2024-10-23T23:13:33.045792Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "iv_convergence(optax.adam(0.05), \"adam - LR 0.05\")" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "1efbc895-09c2-43d8-99bc-26138fe5ff55", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T23:17:04.708378Z", - "iopub.status.busy": "2024-10-23T23:17:04.708170Z", - "iopub.status.idle": "2024-10-23T23:20:51.771308Z", - "shell.execute_reply": "2024-10-23T23:20:51.770691Z", - "shell.execute_reply.started": "2024-10-23T23:17:04.708364Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "iv_convergence(optax.nadam(0.1), \"nadam - LR 0.1\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "0022843c-0151-4ac4-98f1-641c9241723e", - "metadata": { - "execution": { - "iopub.execute_input": "2024-10-23T23:20:51.772410Z", - "iopub.status.busy": "2024-10-23T23:20:51.772174Z", - "iopub.status.idle": "2024-10-23T23:24:40.002910Z", - "shell.execute_reply": "2024-10-23T23:24:40.002345Z", - "shell.execute_reply.started": "2024-10-23T23:20:51.772394Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "iv_convergence(optax.nadam(0.05), \"nadam - LR 0.05\")" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "py311", - "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.11.7" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/stacked_moments.ipynb b/stacked_moments.ipynb deleted file mode 100644 index f66f02d..0000000 --- a/stacked_moments.ipynb +++ /dev/null @@ -1,232 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import statsmodels.api as sm" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "from torchmin import minimize as torchmin" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import jax.numpy as jnp\n", - "import jax\n", - "\n", - "from jax.scipy.optimize import minimize as jaxmin" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0.84995148, 0.34576802, 0.35638789, 0.89451017, -0.15926814,\n", - " -0.00526948, 0.01192015, 0.02078758])" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "def dgp(n=500, k=3, reg=False, torchout = False):\n", - " X = np.random.normal(0, 1, n * k).reshape(n, k)\n", - " Y0 = X[:, 0] + X[:, 0] ** 2 + np.random.uniform(-0.5, 0.5, n)\n", - " Y1 = X[:, 1] + X[:, 1] ** 2 + np.random.uniform(-1, 1, n)\n", - " Z = np.random.binomial(1, 0.6, n)\n", - " Y = Y0 * (1 - Z) + Y1 * Z\n", - " if torchout:\n", - " return torch.tensor(np.c_[Y, Z, X])\n", - " return np.c_[Y, Z, X]\n", - "\n", - "def linreg(data):\n", - " Y, Z, X = data[:, 0], data[:, 1], data[:, 2:]\n", - " XX = sm.add_constant(np.c_[Z, X, Z[:, None] * X.mean(axis = 0)])\n", - " model = sm.OLS(Y, XX).fit()\n", - " return model.params\n", - "\n", - "linreg(dgp())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "$$\n", - "Y_i = \\alpha + \\tau W_i + X_i'\\beta + W_i \\tilde{X}_i'\\gamma + \\epsilon_i\n", - "$$\n", - "\n", - "where $\\tilde{X}_i = X_i - \\bar{X}$ is a centered version of $X_i$. The goal is to estimate $\\tau$." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Torch" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "def moment_cond_cent(theta, data):\n", - " Z, Y, X = data[:, 1], data[:, 0], data[:, 2:]\n", - " n, p = X.shape\n", - " mu, beta = theta[:p], theta[p:]\n", - " Xcent = X - mu\n", - " ones = torch.ones(n, 1, device=data.device)\n", - " Xtilde = torch.cat([ones, Z.view(-1, 1), X, Z.view(-1, 1) * Xcent], dim=1)\n", - " resid = (Y - torch.matmul(Xtilde, beta)).view(-1, 1)\n", - " m = Xtilde * resid\n", - " return torch.cat([m, Xcent], dim=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 1.004 0.105 0.291 0.403 -0. -0.006]\n" - ] - }, - { - "data": { - "text/plain": [ - "array([ 0.976, 0.106, 0.717, -0.082, -0.666, 0.753])" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data = dgp(n = 1_000, k = 2, torchout=True)\n", - "print(np.round(linreg(data.numpy()), 3))\n", - "# m-estimation\n", - "k = data.shape[1]\n", - "theta_init = torch.tensor(np.random.rand((k-1)*2 +(k-2)))\n", - "\n", - "def loss(theta):\n", - " m = moment_cond_cent(theta, data)\n", - " return torch.sum(m.mean(axis=0) ** 2)\n", - "\n", - "params = torchmin(loss, x0 = theta_init, method=\"l-bfgs\")\n", - "params.x[2:].numpy().round(3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## JAX" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def moment_cond_jax(theta, data):\n", - " Z, Y, X = jnp.array(data[:, 1]), jnp.array(data[:, 0]), jnp.array(data[:, 2:])\n", - " n, p = X.shape\n", - " mu, beta = theta[:p], theta[p:]\n", - " Xcent = X - mu\n", - " Xtilde = jnp.c_[np.ones(n), Z, X, Z[:, None] * Xcent]\n", - " resid = (Y - Xtilde @ beta)[:, None]\n", - " m = Xtilde * resid\n", - " return jnp.c_[m, Xcent]" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "def gmm_objective(theta, data):\n", - " moments = moment_cond_jax(theta, data)\n", - " return np.sum(moments.mean(axis=0) ** 2)\n", - "\n", - "@jax.jit\n", - "def optimize_gmm(theta_init, data):\n", - " return jaxmin(lambda theta: gmm_objective(theta, data), theta_init, method=\"BFGS\")\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[ 0.952 0.13 0.468 0.584 0.002 -0.005]\n", - "[ 0.90300006 0.13900001 0.94600004 0.003 -0.79800004 0.9710001 ]\n" - ] - } - ], - "source": [ - "data = dgp(n = 1_000, k = 2, torchout=False)\n", - "print(np.round(linreg(data), 3))\n", - "\n", - "k = data.shape[1]\n", - "theta_init = np.random.rand((k-1)*2 +(k-2))\n", - "\n", - "print(np.round(optimize_gmm(theta_init, data).x[2:], 3))" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "metrics", - "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.11.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/tests/test_gmm.py b/tests/test_gmm.py new file mode 100644 index 0000000..2269409 --- /dev/null +++ b/tests/test_gmm.py @@ -0,0 +1,39 @@ +import jax.numpy as jnp +import numpy as np + +from jaxonometrics.gmm import GMM, LinearIVGMM + + +def dgp(b=np.array([1, 2]), N=1_000, K=3): + """A simple data generating process for IV.""" + np.random.seed(42) + Z = np.random.normal(0, 1, (N, K)) + pi = np.random.uniform(1, 2, K) + w = Z @ pi + np.random.normal(0, 1, N) + X = np.c_[np.ones(N), w] + y = X @ b + np.random.normal(0, 1, N) + return {"y": y, "X": X, "Z": Z} + + +def iv_moment_fn(params, data): + """The moment condition for IV.""" + y, X, Z = data["y"], data["X"], data["Z"] + resid = y - X @ params + return Z * resid[:, None] + + +def test_gmm(): + """Test the general-purpose GMM estimator.""" + data = dgp() + gmm = GMM(moment_fn=iv_moment_fn) + init_params = jnp.zeros(data["X"].shape[1]) + gmm.fit(data, init_params) + assert np.allclose(gmm.params, np.array([1, 2]), atol=1e-1) + + +def test_linear_iv_gmm(): + """Test the LinearIVGMM estimator.""" + data = dgp() + iv_gmm = LinearIVGMM() + iv_gmm.fit(data["X"], data["y"], data["Z"]) + assert np.allclose(iv_gmm.params, np.array([1, 2]), atol=1e-1) diff --git a/tests/test_linear.py b/tests/test_linear.py new file mode 100644 index 0000000..70d3c63 --- /dev/null +++ b/tests/test_linear.py @@ -0,0 +1,24 @@ +import jax.numpy as jnp +import numpy as np +from sklearn.linear_model import LinearRegression as SklearnLinearRegression + +from jaxonometrics.linear import LinearRegression + + +def test_linear_regression(): + """Test the LinearRegression estimator against scikit-learn.""" + X = np.random.rand(100, 10) + y = X @ np.random.rand(10) + np.random.rand(100) + + # scikit-learn + sklearn_model = SklearnLinearRegression() + sklearn_model.fit(X, y) + sklearn_coef = sklearn_model.coef_ + + # jaxonometrics + X_with_intercept = jnp.c_[jnp.ones(X.shape[0]), X] + jax_model = LinearRegression() + jax_model.fit(X_with_intercept, jnp.array(y)) + jax_coef = jax_model.params["beta"][1:] + + assert np.allclose(sklearn_coef, jax_coef, atol=1e-6) From 6f568c59d0793b26f91489aa6cad630e274d961b Mon Sep 17 00:00:00 2001 From: alal Date: Sun, 29 Jun 2025 11:46:29 -0700 Subject: [PATCH 2/2] add standard errors implementation, clean up notebook --- .gitignore | 2 +- jaxonometrics/linear.py | 77 +++++- nb/linmod.ipynb | 523 +++++++++++++++++++++++++--------------- 3 files changed, 391 insertions(+), 211 deletions(-) diff --git a/.gitignore b/.gitignore index 99b7cf8..cd831ff 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,4 @@ -*/__pycache__/* +*/**/__pycache__/* *.csv *.dta *.xlsx diff --git a/jaxonometrics/linear.py b/jaxonometrics/linear.py index 81f8f6b..85b6722 100644 --- a/jaxonometrics/linear.py +++ b/jaxonometrics/linear.py @@ -1,5 +1,7 @@ from typing import Dict, Optional +import numpy as np + import jax.numpy as jnp import lineax as lx @@ -11,27 +13,84 @@ class LinearRegression(BaseEstimator): Linear regression model using lineax for efficient solving. This class provides a simple interface for fitting a linear regression - model, especially useful for high-dimensional problems where n > p. + model, especially useful for high-dimensional problems where p > n. """ - def __init__(self): + def __init__(self, solver="lineax"): + """Initialize the LinearRegression model. + + Args: + solver (str, optional): Solver. Defaults to "lineax", can also be "jax" or "numpy". + """ super().__init__() + self.solver: str = solver - def fit(self, X: jnp.ndarray, y: jnp.ndarray) -> "LinearRegression": + def fit( + self, + X: jnp.ndarray, + y: jnp.ndarray, + se: str = None, + ) -> "LinearRegression": """ Fit the linear model. Args: X: The design matrix of shape (n_samples, n_features). y: The target vector of shape (n_samples,). + se: Whether to compute standard errors. "HC1" for robust standard errors, "classical" for classical SEs. Returns: The fitted estimator. """ - sol = lx.linear_solve( - operator=lx.MatrixLinearOperator(X), - vector=y, - solver=lx.AutoLinearSolver(well_posed=None), - ) - self.params = {"beta": sol.value} + + if self.solver == "lineax": + sol = lx.linear_solve( + operator=lx.MatrixLinearOperator(X), + vector=y, + solver=lx.AutoLinearSolver(well_posed=None), + # per lineax docs, passing well_posed None is remarkably general: + # If the operator is non-square, then use lineax.QR. (Most likely case) + # If the operator is diagonal, then use lineax.Diagonal. + # If the operator is tridiagonal, then use lineax.Tridiagonal. + # If the operator is triangular, then use lineax.Triangular. + # If the matrix is positive or negative (semi-)definite, then use lineax.Cholesky. + ) + self.params = {"coef": sol.value} + + elif self.solver == "jax": + sol = jnp.linalg.lstsq(X, y) + self.params = {"coef": sol[0]} + elif self.solver == "numpy": # for completeness + X, y = np.array(X), np.array(y) + sol = np.linalg.lstsq(X, y, rcond=None) + self.params = {"coef": jnp.array(sol[0])} + + if se: + self._vcov( + y=y, + X=X, + se=se, + ) # set standard errors in params return self + + def predict(self, X: jnp.ndarray) -> jnp.ndarray: + if not isinstance(X, jnp.ndarray): + X = jnp.array(X) + return jnp.dot(X, self.params["coef"]) + + def _vcov( + self, + y: jnp.ndarray, + X: jnp.ndarray, + se: str = "HC1", + ) -> None: + n, k = X.shape + ε = y - X @ self.params["coef"] + if se == "HC1": + M = jnp.einsum("ij,i,ik->jk", X, ε**2, X) # yer a wizard harry + XtX = jnp.linalg.inv(X.T @ X) + Σ = XtX @ M @ XtX + self.params["se"] = jnp.sqrt((n / (n - k)) * jnp.diag(Σ)) + elif se == "classical": + XtX_inv = jnp.linalg.inv(X.T @ X) + self.params["se"] = jnp.sqrt(jnp.diag(XtX_inv) * jnp.var(ε, ddof=k)) diff --git a/nb/linmod.ipynb b/nb/linmod.ipynb index fd2868c..33ee301 100644 --- a/nb/linmod.ipynb +++ b/nb/linmod.ipynb @@ -41,13 +41,68 @@ }, "outputs": [], "source": [ + "import warnings\n", + "\n", "import numpy as np\n", "import pandas as pd\n", + "\n", + "import jax\n", + "\n", "import jax.numpy as jnp\n", "import statsmodels.api as sm\n", "from pyfixest.estimation import feols\n", - "from jaxonometrics.linear import LinearRegression\n", - "import time" + "from jaxonometrics.linear import LinearRegression" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9f571389", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:2025-06-29 11:43:45,267:jax._src.xla_bridge:752: Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n", + "INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n" + ] + }, + { + "data": { + "text/plain": [ + "[CpuDevice(id=0)]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "jax.devices()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "70b47c6b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "CpuDevice(id=0)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = jnp.array([1, 2, 3])\n", + "a.device" ] }, { @@ -69,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "id": "fc4d98ef", "metadata": { "execution": { @@ -89,283 +144,349 @@ }, "outputs": [], "source": [ - "def sparse_dgp(n=10_000, p=20_000, eta=0.1):\n", + "def sparse_dgp(n=10_000, p=20_000, eta=0.2):\n", " X = np.c_[np.ones(n), np.random.normal(size=n * p).reshape((n, p))]\n", " β, nzcount = np.repeat(0.0, p + 1), int(eta * p)\n", + " # eta% coefs are non-zero\n", " nzid = np.random.choice(p, nzcount, replace=False)\n", - " β[nzid] = np.random.randn(nzcount)\n", - " e = np.random.normal(0, 0.5 + (0.1 * X[:, 1] > 0), n)\n", + " β[nzid] = np.random.uniform(-2, 3, nzcount)\n", + " # heteroskedasticity\n", + " e = np.random.normal(0, 0.5 + (0.2 * X[:, 1] > 0), n)\n", " y = X @ β + e\n", - " return y, X" + " return y, X, β\n", + "\n", + "\n", + "y, X, beta = sparse_dgp(n = 10_000, p=20)\n", + "Xj, yj = jnp.array(X), jnp.array(y)" + ] + }, + { + "cell_type": "markdown", + "id": "13c08e84", + "metadata": {}, + "source": [ + "## Low-Dim" ] }, { "cell_type": "code", - "execution_count": 3, - "id": "d15c379b", - "metadata": { - "execution": { - "iopub.execute_input": "2025-06-29T05:16:06.950194Z", - "iopub.status.busy": "2025-06-29T05:16:06.949949Z", - "iopub.status.idle": "2025-06-29T05:16:06.956035Z", - "shell.execute_reply": "2025-06-29T05:16:06.955279Z" - }, - "papermill": { - "duration": 0.010128, - "end_time": "2025-06-29T05:16:06.957289", - "exception": false, - "start_time": "2025-06-29T05:16:06.947161", - "status": "completed" - }, - "tags": [] - }, + "execution_count": 5, + "id": "628ad440", + "metadata": {}, "outputs": [], "source": [ - "def onerep(X, y):\n", - " # df\n", - " df = pd.DataFrame(X, columns=[f\"x{i}\" for i in range(X.shape[1])])\n", - " df[\"y\"] = y\n", - " # statsmodels\n", - " start1 = time.time()\n", - " sm_model = sm.OLS(y, X).fit()\n", - " sm_time = time.time() - start1\n", - " # pyfixest\n", - " start2 = time.time()\n", - " fixest_model = feols(\n", - " f\"y ~ -1 + {'+'.join([f'x{i}' for i in range(X.shape[1])])}\", data=df\n", - " )\n", - " fixest_time = time.time() - start2\n", - " # jax\n", - " start3 = time.time()\n", - " jax_model = LinearRegression()\n", - " jax_model.fit(jnp.array(X), jnp.array(y))\n", - " jax_time = time.time() - start3\n", - " return {\n", - " \"sm_time\": sm_time,\n", - " \"fixest_time\": fixest_time,\n", - " \"jax_time\": jax_time,\n", - " \"sm_params\": sm_model.params,\n", - " \"fixest_params\": fixest_model.coef().values,\n", - " \"jax_params\": np.array(jax_model.params[\"beta\"]),\n", - " }" + "n, p = 10_000, 20" ] }, { "cell_type": "markdown", - "id": "97b2b62d", - "metadata": { - "papermill": { - "duration": 0.001963, - "end_time": "2025-06-29T05:16:06.961390", - "exception": false, - "start_time": "2025-06-29T05:16:06.959427", - "status": "completed" - }, - "tags": [] - }, + "id": "088ebaa1", + "metadata": {}, "source": [ - "### Low-Dim" + "### statsmodels" ] }, { "cell_type": "code", - "execution_count": 4, - "id": "36049be0", - "metadata": { - "execution": { - "iopub.execute_input": "2025-06-29T05:16:06.966426Z", - "iopub.status.busy": "2025-06-29T05:16:06.966160Z", - "iopub.status.idle": "2025-06-29T05:16:08.459381Z", - "shell.execute_reply": "2025-06-29T05:16:08.458611Z" - }, - "papermill": { - "duration": 1.497523, - "end_time": "2025-06-29T05:16:08.460886", - "exception": false, - "start_time": "2025-06-29T05:16:06.963363", - "status": "completed" - }, - "tags": [] - }, + "execution_count": 6, + "id": "78af31e3", + "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/alal/Desktop/code/econometrics/jaxonometrics/.venv/lib/python3.13/site-packages/pyfixest/estimation/feols_.py:2628: UserWarning: \n", - " 1 variables dropped due to multicollinearity.\n", - " The following variables are dropped: ['x0'].\n", - " \n", - " warnings.warn(\n", - "INFO:2025-06-28 22:16:08,080:jax._src.xla_bridge:752: Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n" + "16.8 ms ± 2.89 ms per loop (mean ± std. dev. of 5 runs, 100 loops each)\n" ] - }, + } + ], + "source": [ + "%%timeit -n 100 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "m = sm.OLS(y, X).fit()" + ] + }, + { + "cell_type": "markdown", + "id": "33611be5", + "metadata": {}, + "source": [ + "### pyfixest" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e9a1a4ea", + "metadata": {}, + "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "INFO:jax._src.xla_bridge:Unable to initialize backend 'tpu': INTERNAL: Failed to open libtpu.so: libtpu.so: cannot open shared object file: No such file or directory\n" + "108 ms ± 1.25 ms per loop (mean ± std. dev. of 5 runs, 100 loops each)\n" ] - }, + } + ], + "source": [ + "%%timeit -n 100 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "df = pd.DataFrame(X, columns=[f\"x{i}\" for i in range(X.shape[1])])\n", + "df[\"y\"] = y\n", + "with warnings.catch_warnings():\n", + " warnings.simplefilter('ignore')\n", + " fixest_model = feols(\n", + " f\"y ~ -1 + {'+'.join([f'x{i}' for i in range(X.shape[1])])}\", data=df\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "93aeb41d", + "metadata": {}, + "source": [ + "### jaxonometrics" + ] + }, + { + "cell_type": "markdown", + "id": "5e06ff3f", + "metadata": {}, + "source": [ + "#### lineax backend " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "25b0053d", + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " sm time: 0.0117s, fixest time: 1.0715s, jax time: 0.3841s\n" + "9.2 ms ± 1.24 ms per loop (mean ± std. dev. of 5 runs, 100 loops each)\n" ] - }, + } + ], + "source": [ + "%%timeit -n 100 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "Xj, yj = jnp.array(X), jnp.array(y)\n", + "LinearRegression(solver=\"lineax\").fit(Xj, yj, se=\"HC1\")" + ] + }, + { + "cell_type": "markdown", + "id": "da9edf23", + "metadata": {}, + "source": [ + "#### jax linalg solve backend" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "051697e3", + "metadata": {}, + "outputs": [ { - "data": { - "text/plain": [ - "(array([-0.00219642, 0.01010658, 0.01650456, 0.00361118, 0.01222154]),\n", - " array([-0.00219642, 0.01010658, 0.01650456, 0.00361118, 0.01222154]),\n", - " array([-0.00219641, 0.01010658, 0.01650455, 0.00361117, 0.01222158],\n", - " dtype=float32))" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "12.3 ms ± 1.57 ms per loop (mean ± std. dev. of 5 runs, 100 loops each)\n" + ] } ], "source": [ - "y, X = sparse_dgp(n = 10_000, p=20)\n", - "res = onerep(X, y)\n", - "print(f\" sm time: {res['sm_time']:.4f}s, fixest time: {res['fixest_time']:.4f}s, jax time: {res['jax_time']:.4f}s\")\n", - "res[\"sm_params\"][:5], res[\"fixest_params\"][:5], res[\"jax_params\"][:5]" + "%%timeit -n 100 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "Xj, yj = jnp.array(X), jnp.array(y)\n", + "LinearRegression(solver = \"jax\").fit(Xj, yj, se=\"HC1\")" ] }, { "cell_type": "markdown", - "id": "5709e8df", - "metadata": { - "papermill": { - "duration": 0.003407, - "end_time": "2025-06-29T05:16:08.468271", - "exception": false, - "start_time": "2025-06-29T05:16:08.464864", - "status": "completed" - }, - "tags": [] - }, + "id": "058963a9", + "metadata": {}, "source": [ - "### High-Dim" + "#### numpy backend" ] }, { "cell_type": "code", - "execution_count": 5, - "id": "691d5fa0", + "execution_count": 10, + "id": "adf665e3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9.37 ms ± 1.38 ms per loop (mean ± std. dev. of 5 runs, 100 loops each)\n" + ] + } + ], + "source": [ + "%%timeit -n 100 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "LinearRegression(solver = \"numpy\").fit(X, y, se=\"HC1\")" + ] + }, + { + "cell_type": "markdown", + "id": "97b2b62d", "metadata": { - "execution": { - "iopub.execute_input": "2025-06-29T05:16:08.477032Z", - "iopub.status.busy": "2025-06-29T05:16:08.476302Z", - "iopub.status.idle": "2025-06-29T05:16:40.660938Z", - "shell.execute_reply": "2025-06-29T05:16:40.660279Z" - }, "papermill": { - "duration": 32.190832, - "end_time": "2025-06-29T05:16:40.662450", + "duration": 0.001963, + "end_time": "2025-06-29T05:16:06.961390", "exception": false, - "start_time": "2025-06-29T05:16:08.471618", + "start_time": "2025-06-29T05:16:06.959427", "status": "completed" }, "tags": [] }, + "source": [ + "## High-Dim" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "9fb59368", + "metadata": {}, + "outputs": [], + "source": [ + "n, p = 10_000, 1_000" + ] + }, + { + "cell_type": "markdown", + "id": "4406b067", + "metadata": {}, + "source": [ + "### pyfixest" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "04aef32f", + "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/alal/Desktop/code/econometrics/jaxonometrics/.venv/lib/python3.13/site-packages/pyfixest/estimation/feols_.py:2628: UserWarning: \n", - " 1 variables dropped due to multicollinearity.\n", - " The following variables are dropped: ['x0'].\n", - " \n", - " warnings.warn(\n" + "1.25 s ± 28.9 ms per loop (mean ± std. dev. of 5 runs, 10 loops each)\n" ] - }, + } + ], + "source": [ + "%%timeit -n 10 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "df = pd.DataFrame(X, columns=[f\"x{i}\" for i in range(X.shape[1])])\n", + "df[\"y\"] = y\n", + "with warnings.catch_warnings():\n", + " warnings.simplefilter('ignore')\n", + " fixest_model = feols(\n", + " f\"y ~ -1 + {'+'.join([f'x{i}' for i in range(X.shape[1])])}\", data=df\n", + " )\n" + ] + }, + { + "cell_type": "markdown", + "id": "2845de80", + "metadata": {}, + "source": [ + "### jaxonometrics" + ] + }, + { + "cell_type": "markdown", + "id": "24d57db0", + "metadata": {}, + "source": [ + "#### lineax backend " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3cbc0deb", + "metadata": {}, + "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " sm time: 14.8658s, fixest time: 14.2712s, jax time: 2.2547s\n" + "1.35 s ± 149 ms per loop (mean ± std. dev. of 5 runs, 10 loops each)\n" ] - }, - { - "data": { - "text/plain": [ - "(array([ 0.00146385, -0.00174201, -0.01347367, -0.01551777, -0.02014805]),\n", - " array([ 0.00146385, -0.00174201, -0.01347367, -0.01551777, -0.02014805]),\n", - " array([ 0.00146354, -0.00174188, -0.01347361, -0.01551812, -0.02014804],\n", - " dtype=float32))" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "y, X = sparse_dgp(n = 10_000, p=2_000)\n", - "res = onerep(X, y)\n", - "print(f\" sm time: {res['sm_time']:.4f}s, fixest time: {res['fixest_time']:.4f}s, jax time: {res['jax_time']:.4f}s\")\n", - "res[\"sm_params\"][:5], res[\"fixest_params\"][:5], res[\"jax_params\"][:5]" + "%%timeit -n 10 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "Xj, yj = jnp.array(X), jnp.array(y)\n", + "LinearRegression(solver=\"lineax\").fit(Xj, yj, se=\"HC1\")" ] }, { "cell_type": "markdown", - "id": "cbc3f763", - "metadata": { - "papermill": { - "duration": 0.003149, - "end_time": "2025-06-29T05:16:40.670767", - "exception": false, - "start_time": "2025-06-29T05:16:40.667618", - "status": "completed" - }, - "tags": [] - }, + "id": "524ab25a", + "metadata": {}, + "source": [ + "#### jax-numpy linalg solve backend" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "c797ea48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.55 s ± 105 ms per loop (mean ± std. dev. of 5 runs, 10 loops each)\n" + ] + } + ], "source": [ - "### Ultra-High-Dim / Ill-Posed" + "%%timeit -n 10 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "Xj, yj = jnp.array(X), jnp.array(y)\n", + "LinearRegression(solver = \"jax\").fit(Xj, yj, se=\"HC1\")" ] }, { "cell_type": "markdown", - "id": "174ac0ff", - "metadata": { - "papermill": { - "duration": 0.002596, - "end_time": "2025-06-29T05:16:40.676041", - "exception": false, - "start_time": "2025-06-29T05:16:40.673445", - "status": "completed" - }, - "tags": [] - }, + "id": "b00a356d", + "metadata": {}, "source": [ - "The minimum-norm interpolator is easy to calculate with lineax because it automatically adapts the solver." + "### statsmodels" ] }, { "cell_type": "code", - "execution_count": null, - "id": "b924e5d3", - "metadata": { - "papermill": { - "duration": null, - "end_time": null, - "exception": false, - "start_time": "2025-06-29T05:16:40.678520", - "status": "running" - }, - "tags": [] - }, - "outputs": [], + "execution_count": 15, + "id": "3547ca24", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.14 s ± 101 ms per loop (mean ± std. dev. of 5 runs, 10 loops each)\n" + ] + } + ], "source": [ - "y, X = sparse_dgp(n = 10_000, p=20_000)\n", - "res = onerep(X, y)\n", - "print(res[\"sm_time\"], res[\"fixest_time\"], res[\"jax_time\"])\n", - "res[\"sm_params\"][:5], res[\"fixest_params\"][:5], res[\"jax_params\"][:5]" + "%%timeit -n 10 -r 5\n", + "y, X, beta = sparse_dgp(n, p)\n", + "m = sm.OLS(y, X).fit()" ] } ], @@ -385,7 +506,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.13.3" + "version": "3.12.6" }, "papermill": { "default_parameters": {}, @@ -402,4 +523,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +}