From 679c309ea470f0366677706848ce5434aeb65713 Mon Sep 17 00:00:00 2001 From: alanlujan91 Date: Tue, 5 Nov 2024 09:27:16 -0500 Subject: [PATCH] ch 10 --- ...gression Analysis with Time Series Data.md | 222 ++++++++ markdown/Ch2. The Simple Regression Model.md | 1 + markdown/Ch6. MRA - Further Issues.md | 3 + ...ssion Analysis with Time Series Data.ipynb | 491 ++++++++++++++++++ .../Ch2. The Simple Regression Model.ipynb | 4 +- notebooks/Ch6. MRA - Further Issues.ipynb | 4 +- ...gression Analysis with Time Series Data.py | 212 ++++++++ scripts/Ch2. The Simple Regression Model.py | 1 + scripts/Ch6. MRA - Further Issues.py | 3 + 9 files changed, 939 insertions(+), 2 deletions(-) create mode 100644 markdown/Ch10. Basic Regression Analysis with Time Series Data.md create mode 100644 notebooks/Ch10. Basic Regression Analysis with Time Series Data.ipynb create mode 100644 scripts/Ch10. Basic Regression Analysis with Time Series Data.py diff --git a/markdown/Ch10. Basic Regression Analysis with Time Series Data.md b/markdown/Ch10. Basic Regression Analysis with Time Series Data.md new file mode 100644 index 0000000..4b7c9dc --- /dev/null +++ b/markdown/Ch10. Basic Regression Analysis with Time Series Data.md @@ -0,0 +1,222 @@ +--- +jupyter: + jupytext: + formats: notebooks//ipynb,markdown//md,scripts//py + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.4 + kernelspec: + display_name: merino + language: python + name: python3 +--- + +# 10. Basic Regression Analysis with Time Series Data + +```python +%pip install matplotlib numpy pandas statsmodels wooldridge -q +``` + +```python +import matplotlib.pyplot as plt +import numpy as np # noqa +import pandas as pd +import statsmodels.formula.api as smf +import wooldridge as wool +``` + +## 10.1 Static Time Series Models + +$$ y_t = \beta_0 + \beta_1 z_{1t} + \beta_2 z_{2t} + \cdots + \beta_k z_{kt} + u_t $$ + +### Example 10.2 Effects of Inflation and Deficits on Interest Rates + +```python +intdef = wool.dataWoo("intdef") + +# linear regression of static model (Q function avoids conflicts with keywords): +reg = smf.ols(formula='i3 ~ Q("inf") + Q("def")', data=intdef) +results = reg.fit() + +# print regression table: +table = pd.DataFrame( + { + "b": round(results.params, 4), + "se": round(results.bse, 4), + "t": round(results.tvalues, 4), + "pval": round(results.pvalues, 4), + }, +) +print(f"table: \n{table}\n") +``` + +## 10.2 Time Series Data Types in Python + +### 10.2.1 Equispaced Time Series in Python + +```python +barium = wool.dataWoo("barium") +T = len(barium) + +# monthly time series starting Feb. 1978: +barium.index = pd.date_range(start="1978-02", periods=T, freq="ME") +print(f'barium["chnimp"].head(): \n{barium["chnimp"].head()}\n') +``` + +```python +# plot chnimp (default: index on the x-axis): +plt.plot("chnimp", data=barium, color="black", linestyle="-") +plt.ylabel("chnimp") +plt.xlabel("time") +``` + +## 10.3 Other Time Series Models + +### 10.3.1 Finite Distributed Lag Models + +$$ y_t = \alpha_0 + \delta_0 z_t + \delta_1 z_{t-1} + \cdots + \delta_k z_{t-k} + u_t $$ + +### Example 10.4 Effects of Personal Exemption on Fertility Rates + +```python +fertil3 = wool.dataWoo("fertil3") +T = len(fertil3) + +# define yearly time series beginning in 1913: +fertil3.index = pd.date_range(start="1913", periods=T, freq="YE").year + +# add all lags of 'pe' up to order 2: +fertil3["pe_lag1"] = fertil3["pe"].shift(1) +fertil3["pe_lag2"] = fertil3["pe"].shift(2) + +# linear regression of model with lags: +reg = smf.ols(formula="gfr ~ pe + pe_lag1 + pe_lag2 + ww2 + pill", data=fertil3) +results = reg.fit() + +# print regression table: +table = pd.DataFrame( + { + "b": round(results.params, 4), + "se": round(results.bse, 4), + "t": round(results.tvalues, 4), + "pval": round(results.pvalues, 4), + }, +) +print(f"table: \n{table}\n") +``` + +### Eample 10.4 (continued) + +```python +fertil3 = wool.dataWoo("fertil3") +T = len(fertil3) + +# define yearly time series beginning in 1913: +fertil3.index = pd.date_range(start="1913", periods=T, freq="YE").year + +# add all lags of 'pe' up to order 2: +fertil3["pe_lag1"] = fertil3["pe"].shift(1) +fertil3["pe_lag2"] = fertil3["pe"].shift(2) + +# linear regression of model with lags: +reg = smf.ols(formula="gfr ~ pe + pe_lag1 + pe_lag2 + ww2 + pill", data=fertil3) +results = reg.fit() + +# F test (H0: all pe coefficients are=0): +hypotheses1 = ["pe = 0", "pe_lag1 = 0", "pe_lag2 = 0"] +ftest1 = results.f_test(hypotheses1) +fstat1 = ftest1.statistic +fpval1 = ftest1.pvalue + +print(f"fstat1: {fstat1}\n") +print(f"fpval1: {fpval1}\n") +``` + +```python +# calculating the LRP: +b = results.params +b_pe_tot = b["pe"] + b["pe_lag1"] + b["pe_lag2"] +print(f"b_pe_tot: {b_pe_tot}\n") +``` + +```python +# F test (H0: LRP=0): +hypotheses2 = ["pe + pe_lag1 + pe_lag2 = 0"] +ftest2 = results.f_test(hypotheses2) +fstat2 = ftest2.statistic +fpval2 = ftest2.pvalue + +print(f"fstat2: {fstat2}\n") +print(f"fpval2: {fpval2}\n") +``` + +### 10.3.2 Trends + +### Example 10.7 Housing Investment and Prices + +```python +hseinv = wool.dataWoo("hseinv") + +# linear regression without time trend: +reg_wot = smf.ols(formula="np.log(invpc) ~ np.log(price)", data=hseinv) +results_wot = reg_wot.fit() + +# print regression table: +table_wot = pd.DataFrame( + { + "b": round(results_wot.params, 4), + "se": round(results_wot.bse, 4), + "t": round(results_wot.tvalues, 4), + "pval": round(results_wot.pvalues, 4), + }, +) +print(f"table_wot: \n{table_wot}\n") +``` + +```python +# linear regression with time trend (data set includes a time variable t): +reg_wt = smf.ols(formula="np.log(invpc) ~ np.log(price) + t", data=hseinv) +results_wt = reg_wt.fit() + +# print regression table: +table_wt = pd.DataFrame( + { + "b": round(results_wt.params, 4), + "se": round(results_wt.bse, 4), + "t": round(results_wt.tvalues, 4), + "pval": round(results_wt.pvalues, 4), + }, +) +print(f"table_wt: \n{table_wt}\n") +``` + +### 10.3.3 Seasonality + +### Example 10.11 Effects of Antidumping Filings + +```python +barium = wool.dataWoo("barium") + +# linear regression with seasonal effects: +reg = smf.ols( + formula="np.log(chnimp) ~ np.log(chempi) + np.log(gas) +" + "np.log(rtwex) + befile6 + affile6 + afdec6 +" + "feb + mar + apr + may + jun + jul +" + "aug + sep + oct + nov + dec", + data=barium, +) +results = reg.fit() + +# print regression table: +table = pd.DataFrame( + { + "b": round(results.params, 4), + "se": round(results.bse, 4), + "t": round(results.tvalues, 4), + "pval": round(results.pvalues, 4), + }, +) +print(f"table: \n{table}\n") +``` diff --git a/markdown/Ch2. The Simple Regression Model.md b/markdown/Ch2. The Simple Regression Model.md index 75e94a4..8ffa373 100644 --- a/markdown/Ch2. The Simple Regression Model.md +++ b/markdown/Ch2. The Simple Regression Model.md @@ -75,6 +75,7 @@ b = results.params print(f"b: \n{b}") ``` + ```python def plot_regression(x, y, data, results, title): # scatter plot and fitted values: diff --git a/markdown/Ch6. MRA - Further Issues.md b/markdown/Ch6. MRA - Further Issues.md index 783a0df..e59d9dd 100644 --- a/markdown/Ch6. MRA - Further Issues.md +++ b/markdown/Ch6. MRA - Further Issues.md @@ -73,6 +73,9 @@ $$z_y = \frac{y - \bar{y}}{\text{sd}(y)} \qquad \text{and} \qquad z_{x_1} = \fr $$\text{price\_sc} = \beta_0 + \beta_1 \cdot \text{nox\_sc} + \beta_2 \cdot \text{crime\_sc} + \beta_3 \cdot \text{rooms\_sc} + \beta_4 \cdot \text{dist\_sc} + \beta_5 \cdot \text{stratio\_sc} + u$$ + + + ```python # define a function for the standardization: def scale(x): diff --git a/notebooks/Ch10. Basic Regression Analysis with Time Series Data.ipynb b/notebooks/Ch10. Basic Regression Analysis with Time Series Data.ipynb new file mode 100644 index 0000000..84d9e58 --- /dev/null +++ b/notebooks/Ch10. Basic Regression Analysis with Time Series Data.ipynb @@ -0,0 +1,491 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "11b25d13", + "metadata": {}, + "source": [ + "# 10. Basic Regression Analysis with Time Series Data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ad5c1922", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "%pip install matplotlib numpy pandas statsmodels wooldridge -q" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ba368558", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np # noqa\n", + "import pandas as pd\n", + "import statsmodels.formula.api as smf\n", + "import wooldridge as wool" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10.1 Static Time Series Models\n", + "\n", + "$$ y_t = \\beta_0 + \\beta_1 z_{1t} + \\beta_2 z_{2t} + \\cdots + \\beta_k z_{kt} + u_t $$\n", + "\n", + "### Example 10.2 Effects of Inflation and Deficits on Interest Rates" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "table: \n", + " b se t pval\n", + "Intercept 1.7333 0.4320 4.0125 0.0002\n", + "Q(\"inf\") 0.6059 0.0821 7.3765 0.0000\n", + "Q(\"def\") 0.5131 0.1184 4.3338 0.0001\n", + "\n" + ] + } + ], + "source": [ + "intdef = wool.dataWoo(\"intdef\")\n", + "\n", + "# linear regression of static model (Q function avoids conflicts with keywords):\n", + "reg = smf.ols(formula='i3 ~ Q(\"inf\") + Q(\"def\")', data=intdef)\n", + "results = reg.fit()\n", + "\n", + "# print regression table:\n", + "table = pd.DataFrame(\n", + " {\n", + " \"b\": round(results.params, 4),\n", + " \"se\": round(results.bse, 4),\n", + " \"t\": round(results.tvalues, 4),\n", + " \"pval\": round(results.pvalues, 4),\n", + " },\n", + ")\n", + "print(f\"table: \\n{table}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10.2 Time Series Data Types in Python\n", + "\n", + "### 10.2.1 Equispaced Time Series in Python" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "barium[\"chnimp\"].head(): \n", + "1978-02-28 220.462006\n", + "1978-03-31 94.797997\n", + "1978-04-30 219.357498\n", + "1978-05-31 317.421509\n", + "1978-06-30 114.639000\n", + "Freq: ME, Name: chnimp, dtype: float64\n", + "\n" + ] + } + ], + "source": [ + "barium = wool.dataWoo(\"barium\")\n", + "T = len(barium)\n", + "\n", + "# monthly time series starting Feb. 1978:\n", + "barium.index = pd.date_range(start=\"1978-02\", periods=T, freq=\"ME\")\n", + "print(f'barium[\"chnimp\"].head(): \\n{barium[\"chnimp\"].head()}\\n')" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0, 'time')" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot chnimp (default: index on the x-axis):\n", + "plt.plot(\"chnimp\", data=barium, color=\"black\", linestyle=\"-\")\n", + "plt.ylabel(\"chnimp\")\n", + "plt.xlabel(\"time\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 10.3 Other Time Series Models\n", + "\n", + "### 10.3.1 Finite Distributed Lag Models\n", + "\n", + "$$ y_t = \\alpha_0 + \\delta_0 z_t + \\delta_1 z_{t-1} + \\cdots + \\delta_k z_{t-k} + u_t $$\n", + "\n", + "### Example 10.4 Effects of Personal Exemption on Fertility Rates" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "table: \n", + " b se t pval\n", + "Intercept 95.8705 3.2820 29.2114 0.0000\n", + "pe 0.0727 0.1255 0.5789 0.5647\n", + "pe_lag1 -0.0058 0.1557 -0.0371 0.9705\n", + "pe_lag2 0.0338 0.1263 0.2679 0.7896\n", + "ww2 -22.1265 10.7320 -2.0617 0.0433\n", + "pill -31.3050 3.9816 -7.8625 0.0000\n", + "\n" + ] + } + ], + "source": [ + "fertil3 = wool.dataWoo(\"fertil3\")\n", + "T = len(fertil3)\n", + "\n", + "# define yearly time series beginning in 1913:\n", + "fertil3.index = pd.date_range(start=\"1913\", periods=T, freq=\"YE\").year\n", + "\n", + "# add all lags of 'pe' up to order 2:\n", + "fertil3[\"pe_lag1\"] = fertil3[\"pe\"].shift(1)\n", + "fertil3[\"pe_lag2\"] = fertil3[\"pe\"].shift(2)\n", + "\n", + "# linear regression of model with lags:\n", + "reg = smf.ols(formula=\"gfr ~ pe + pe_lag1 + pe_lag2 + ww2 + pill\", data=fertil3)\n", + "results = reg.fit()\n", + "\n", + "# print regression table:\n", + "table = pd.DataFrame(\n", + " {\n", + " \"b\": round(results.params, 4),\n", + " \"se\": round(results.bse, 4),\n", + " \"t\": round(results.tvalues, 4),\n", + " \"pval\": round(results.pvalues, 4),\n", + " },\n", + ")\n", + "print(f\"table: \\n{table}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Eample 10.4 (continued)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fstat1: 3.9729640469785323\n", + "\n", + "fpval1: 0.011652005303126576\n", + "\n" + ] + } + ], + "source": [ + "fertil3 = wool.dataWoo(\"fertil3\")\n", + "T = len(fertil3)\n", + "\n", + "# define yearly time series beginning in 1913:\n", + "fertil3.index = pd.date_range(start=\"1913\", periods=T, freq=\"YE\").year\n", + "\n", + "# add all lags of 'pe' up to order 2:\n", + "fertil3[\"pe_lag1\"] = fertil3[\"pe\"].shift(1)\n", + "fertil3[\"pe_lag2\"] = fertil3[\"pe\"].shift(2)\n", + "\n", + "# linear regression of model with lags:\n", + "reg = smf.ols(formula=\"gfr ~ pe + pe_lag1 + pe_lag2 + ww2 + pill\", data=fertil3)\n", + "results = reg.fit()\n", + "\n", + "# F test (H0: all pe coefficients are=0):\n", + "hypotheses1 = [\"pe = 0\", \"pe_lag1 = 0\", \"pe_lag2 = 0\"]\n", + "ftest1 = results.f_test(hypotheses1)\n", + "fstat1 = ftest1.statistic\n", + "fpval1 = ftest1.pvalue\n", + "\n", + "print(f\"fstat1: {fstat1}\\n\")\n", + "print(f\"fpval1: {fpval1}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "b_pe_tot: 0.10071909027975486\n", + "\n" + ] + } + ], + "source": [ + "# calculating the LRP:\n", + "b = results.params\n", + "b_pe_tot = b[\"pe\"] + b[\"pe_lag1\"] + b[\"pe_lag2\"]\n", + "print(f\"b_pe_tot: {b_pe_tot}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fstat2: 11.421238467853499\n", + "\n", + "fpval2: 0.0012408438602971525\n", + "\n" + ] + } + ], + "source": [ + "# F test (H0: LRP=0):\n", + "hypotheses2 = [\"pe + pe_lag1 + pe_lag2 = 0\"]\n", + "ftest2 = results.f_test(hypotheses2)\n", + "fstat2 = ftest2.statistic\n", + "fpval2 = ftest2.pvalue\n", + "\n", + "print(f\"fstat2: {fstat2}\\n\")\n", + "print(f\"fpval2: {fpval2}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 10.3.2 Trends\n", + "\n", + "### Example 10.7 Housing Investment and Prices" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "table_wot: \n", + " b se t pval\n", + "Intercept -0.5502 0.0430 -12.7882 0.0000\n", + "np.log(price) 1.2409 0.3824 3.2450 0.0024\n", + "\n" + ] + } + ], + "source": [ + "hseinv = wool.dataWoo(\"hseinv\")\n", + "\n", + "# linear regression without time trend:\n", + "reg_wot = smf.ols(formula=\"np.log(invpc) ~ np.log(price)\", data=hseinv)\n", + "results_wot = reg_wot.fit()\n", + "\n", + "# print regression table:\n", + "table_wot = pd.DataFrame(\n", + " {\n", + " \"b\": round(results_wot.params, 4),\n", + " \"se\": round(results_wot.bse, 4),\n", + " \"t\": round(results_wot.tvalues, 4),\n", + " \"pval\": round(results_wot.pvalues, 4),\n", + " },\n", + ")\n", + "print(f\"table_wot: \\n{table_wot}\\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "table_wt: \n", + " b se t pval\n", + "Intercept -0.9131 0.1356 -6.7328 0.0000\n", + "np.log(price) -0.3810 0.6788 -0.5612 0.5779\n", + "t 0.0098 0.0035 2.7984 0.0079\n", + "\n" + ] + } + ], + "source": [ + "# linear regression with time trend (data set includes a time variable t):\n", + "reg_wt = smf.ols(formula=\"np.log(invpc) ~ np.log(price) + t\", data=hseinv)\n", + "results_wt = reg_wt.fit()\n", + "\n", + "# print regression table:\n", + "table_wt = pd.DataFrame(\n", + " {\n", + " \"b\": round(results_wt.params, 4),\n", + " \"se\": round(results_wt.bse, 4),\n", + " \"t\": round(results_wt.tvalues, 4),\n", + " \"pval\": round(results_wt.pvalues, 4),\n", + " },\n", + ")\n", + "print(f\"table_wt: \\n{table_wt}\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 10.3.3 Seasonality\n", + "\n", + "### Example 10.11 Effects of Antidumping Filings" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "table: \n", + " b se t pval\n", + "Intercept 16.7792 32.4286 0.5174 0.6059\n", + "np.log(chempi) 3.2651 0.4929 6.6238 0.0000\n", + "np.log(gas) -1.2781 1.3890 -0.9202 0.3594\n", + "np.log(rtwex) 0.6630 0.4713 1.4068 0.1622\n", + "befile6 0.1397 0.2668 0.5236 0.6016\n", + "affile6 0.0126 0.2787 0.0453 0.9639\n", + "afdec6 -0.5213 0.3019 -1.7264 0.0870\n", + "feb -0.4177 0.3044 -1.3720 0.1728\n", + "mar 0.0591 0.2647 0.2231 0.8239\n", + "apr -0.4515 0.2684 -1.6822 0.0953\n", + "may 0.0333 0.2692 0.1237 0.9018\n", + "jun -0.2063 0.2693 -0.7663 0.4451\n", + "jul 0.0038 0.2788 0.0138 0.9890\n", + "aug -0.1571 0.2780 -0.5650 0.5732\n", + "sep -0.1342 0.2677 -0.5012 0.6172\n", + "oct 0.0517 0.2669 0.1937 0.8467\n", + "nov -0.2463 0.2628 -0.9370 0.3508\n", + "dec 0.1328 0.2714 0.4894 0.6255\n", + "\n" + ] + } + ], + "source": [ + "barium = wool.dataWoo(\"barium\")\n", + "\n", + "# linear regression with seasonal effects:\n", + "reg = smf.ols(\n", + " formula=\"np.log(chnimp) ~ np.log(chempi) + np.log(gas) +\"\n", + " \"np.log(rtwex) + befile6 + affile6 + afdec6 +\"\n", + " \"feb + mar + apr + may + jun + jul +\"\n", + " \"aug + sep + oct + nov + dec\",\n", + " data=barium,\n", + ")\n", + "results = reg.fit()\n", + "\n", + "# print regression table:\n", + "table = pd.DataFrame(\n", + " {\n", + " \"b\": round(results.params, 4),\n", + " \"se\": round(results.bse, 4),\n", + " \"t\": round(results.tvalues, 4),\n", + " \"pval\": round(results.pvalues, 4),\n", + " },\n", + ")\n", + "print(f\"table: \\n{table}\\n\")" + ] + } + ], + "metadata": { + "jupytext": { + "formats": "notebooks//ipynb,markdown//md,scripts//py" + }, + "kernelspec": { + "display_name": "merino", + "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.12.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Ch2. The Simple Regression Model.ipynb b/notebooks/Ch2. The Simple Regression Model.ipynb index 94e19fc..535e54a 100644 --- a/notebooks/Ch2. The Simple Regression Model.ipynb +++ b/notebooks/Ch2. The Simple Regression Model.ipynb @@ -103,7 +103,9 @@ { "cell_type": "code", "execution_count": 4, - "metadata": {}, + "metadata": { + "lines_to_next_cell": 2 + }, "outputs": [ { "name": "stdout", diff --git a/notebooks/Ch6. MRA - Further Issues.ipynb b/notebooks/Ch6. MRA - Further Issues.ipynb index 9a4832c..909e053 100644 --- a/notebooks/Ch6. MRA - Further Issues.ipynb +++ b/notebooks/Ch6. MRA - Further Issues.ipynb @@ -109,7 +109,9 @@ "\n", "### Example 6.1: Effects of Pollution on Housing Prices\n", "\n", - "$$\\text{price\\_sc} = \\beta_0 + \\beta_1 \\cdot \\text{nox\\_sc} + \\beta_2 \\cdot \\text{crime\\_sc} + \\beta_3 \\cdot \\text{rooms\\_sc} + \\beta_4 \\cdot \\text{dist\\_sc} + \\beta_5 \\cdot \\text{stratio\\_sc} + u$$" + "$$\\text{price\\_sc} = \\beta_0 + \\beta_1 \\cdot \\text{nox\\_sc} + \\beta_2 \\cdot \\text{crime\\_sc} + \\beta_3 \\cdot \\text{rooms\\_sc} + \\beta_4 \\cdot \\text{dist\\_sc} + \\beta_5 \\cdot \\text{stratio\\_sc} + u$$\n", + "\n", + "\n" ] }, { diff --git a/scripts/Ch10. Basic Regression Analysis with Time Series Data.py b/scripts/Ch10. Basic Regression Analysis with Time Series Data.py new file mode 100644 index 0000000..ad9e34d --- /dev/null +++ b/scripts/Ch10. Basic Regression Analysis with Time Series Data.py @@ -0,0 +1,212 @@ +# --- +# jupyter: +# jupytext: +# formats: notebooks//ipynb,markdown//md,scripts//py +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.16.4 +# kernelspec: +# display_name: merino +# language: python +# name: python3 +# --- + +# # 10. Basic Regression Analysis with Time Series Data + +# %pip install matplotlib numpy pandas statsmodels wooldridge -q + +import matplotlib.pyplot as plt +import numpy as np # noqa +import pandas as pd +import statsmodels.formula.api as smf +import wooldridge as wool + +# ## 10.1 Static Time Series Models +# +# $$ y_t = \beta_0 + \beta_1 z_{1t} + \beta_2 z_{2t} + \cdots + \beta_k z_{kt} + u_t $$ +# +# ### Example 10.2 Effects of Inflation and Deficits on Interest Rates + +# + +intdef = wool.dataWoo("intdef") + +# linear regression of static model (Q function avoids conflicts with keywords): +reg = smf.ols(formula='i3 ~ Q("inf") + Q("def")', data=intdef) +results = reg.fit() + +# print regression table: +table = pd.DataFrame( + { + "b": round(results.params, 4), + "se": round(results.bse, 4), + "t": round(results.tvalues, 4), + "pval": round(results.pvalues, 4), + }, +) +print(f"table: \n{table}\n") +# - + +# ## 10.2 Time Series Data Types in Python +# +# ### 10.2.1 Equispaced Time Series in Python + +# + +barium = wool.dataWoo("barium") +T = len(barium) + +# monthly time series starting Feb. 1978: +barium.index = pd.date_range(start="1978-02", periods=T, freq="ME") +print(f'barium["chnimp"].head(): \n{barium["chnimp"].head()}\n') +# - + +# plot chnimp (default: index on the x-axis): +plt.plot("chnimp", data=barium, color="black", linestyle="-") +plt.ylabel("chnimp") +plt.xlabel("time") + +# ## 10.3 Other Time Series Models +# +# ### 10.3.1 Finite Distributed Lag Models +# +# $$ y_t = \alpha_0 + \delta_0 z_t + \delta_1 z_{t-1} + \cdots + \delta_k z_{t-k} + u_t $$ +# +# ### Example 10.4 Effects of Personal Exemption on Fertility Rates + +# + +fertil3 = wool.dataWoo("fertil3") +T = len(fertil3) + +# define yearly time series beginning in 1913: +fertil3.index = pd.date_range(start="1913", periods=T, freq="YE").year + +# add all lags of 'pe' up to order 2: +fertil3["pe_lag1"] = fertil3["pe"].shift(1) +fertil3["pe_lag2"] = fertil3["pe"].shift(2) + +# linear regression of model with lags: +reg = smf.ols(formula="gfr ~ pe + pe_lag1 + pe_lag2 + ww2 + pill", data=fertil3) +results = reg.fit() + +# print regression table: +table = pd.DataFrame( + { + "b": round(results.params, 4), + "se": round(results.bse, 4), + "t": round(results.tvalues, 4), + "pval": round(results.pvalues, 4), + }, +) +print(f"table: \n{table}\n") +# - + +# ### Eample 10.4 (continued) + +# + +fertil3 = wool.dataWoo("fertil3") +T = len(fertil3) + +# define yearly time series beginning in 1913: +fertil3.index = pd.date_range(start="1913", periods=T, freq="YE").year + +# add all lags of 'pe' up to order 2: +fertil3["pe_lag1"] = fertil3["pe"].shift(1) +fertil3["pe_lag2"] = fertil3["pe"].shift(2) + +# linear regression of model with lags: +reg = smf.ols(formula="gfr ~ pe + pe_lag1 + pe_lag2 + ww2 + pill", data=fertil3) +results = reg.fit() + +# F test (H0: all pe coefficients are=0): +hypotheses1 = ["pe = 0", "pe_lag1 = 0", "pe_lag2 = 0"] +ftest1 = results.f_test(hypotheses1) +fstat1 = ftest1.statistic +fpval1 = ftest1.pvalue + +print(f"fstat1: {fstat1}\n") +print(f"fpval1: {fpval1}\n") +# - + +# calculating the LRP: +b = results.params +b_pe_tot = b["pe"] + b["pe_lag1"] + b["pe_lag2"] +print(f"b_pe_tot: {b_pe_tot}\n") + +# + +# F test (H0: LRP=0): +hypotheses2 = ["pe + pe_lag1 + pe_lag2 = 0"] +ftest2 = results.f_test(hypotheses2) +fstat2 = ftest2.statistic +fpval2 = ftest2.pvalue + +print(f"fstat2: {fstat2}\n") +print(f"fpval2: {fpval2}\n") +# - + +# ### 10.3.2 Trends +# +# ### Example 10.7 Housing Investment and Prices + +# + +hseinv = wool.dataWoo("hseinv") + +# linear regression without time trend: +reg_wot = smf.ols(formula="np.log(invpc) ~ np.log(price)", data=hseinv) +results_wot = reg_wot.fit() + +# print regression table: +table_wot = pd.DataFrame( + { + "b": round(results_wot.params, 4), + "se": round(results_wot.bse, 4), + "t": round(results_wot.tvalues, 4), + "pval": round(results_wot.pvalues, 4), + }, +) +print(f"table_wot: \n{table_wot}\n") + +# + +# linear regression with time trend (data set includes a time variable t): +reg_wt = smf.ols(formula="np.log(invpc) ~ np.log(price) + t", data=hseinv) +results_wt = reg_wt.fit() + +# print regression table: +table_wt = pd.DataFrame( + { + "b": round(results_wt.params, 4), + "se": round(results_wt.bse, 4), + "t": round(results_wt.tvalues, 4), + "pval": round(results_wt.pvalues, 4), + }, +) +print(f"table_wt: \n{table_wt}\n") +# - + +# ### 10.3.3 Seasonality +# +# ### Example 10.11 Effects of Antidumping Filings + +# + +barium = wool.dataWoo("barium") + +# linear regression with seasonal effects: +reg = smf.ols( + formula="np.log(chnimp) ~ np.log(chempi) + np.log(gas) +" + "np.log(rtwex) + befile6 + affile6 + afdec6 +" + "feb + mar + apr + may + jun + jul +" + "aug + sep + oct + nov + dec", + data=barium, +) +results = reg.fit() + +# print regression table: +table = pd.DataFrame( + { + "b": round(results.params, 4), + "se": round(results.bse, 4), + "t": round(results.tvalues, 4), + "pval": round(results.pvalues, 4), + }, +) +print(f"table: \n{table}\n") diff --git a/scripts/Ch2. The Simple Regression Model.py b/scripts/Ch2. The Simple Regression Model.py index c348f10..a9a7d2e 100644 --- a/scripts/Ch2. The Simple Regression Model.py +++ b/scripts/Ch2. The Simple Regression Model.py @@ -75,6 +75,7 @@ # - + def plot_regression(x, y, data, results, title): # scatter plot and fitted values: plt.plot(x, y, data=data, color="grey", marker="o", linestyle="") diff --git a/scripts/Ch6. MRA - Further Issues.py b/scripts/Ch6. MRA - Further Issues.py index bc19c3b..8852a21 100644 --- a/scripts/Ch6. MRA - Further Issues.py +++ b/scripts/Ch6. MRA - Further Issues.py @@ -70,6 +70,9 @@ # ### Example 6.1: Effects of Pollution on Housing Prices # # $$\text{price\_sc} = \beta_0 + \beta_1 \cdot \text{nox\_sc} + \beta_2 \cdot \text{crime\_sc} + \beta_3 \cdot \text{rooms\_sc} + \beta_4 \cdot \text{dist\_sc} + \beta_5 \cdot \text{stratio\_sc} + u$$ +# +# +# # + # define a function for the standardization: