diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data.ipynb b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data.ipynb new file mode 100755 index 0000000..d1335d4 --- /dev/null +++ b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data.ipynb @@ -0,0 +1,681 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "6cbef61b-0897-42bf-b456-c0a409b87c41", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{01\\_Auto\\_data}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "13be77f3-44f0-4983-b4cb-bd3e4b5dba8b", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "d10dc1b2-182b-4fc1-bfb0-bb0d5295643b", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "**Get and Set working directory**:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f1cf1749-9e5b-434a-8f45-5d63db20ee2a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/01_SupLearn_Regression\n" + ] + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4c658a6a-1c6a-4350-9c4f-6afdd4dbaa7c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationyearoriginname
018.08307.0130350412.0701chevrolet chevelle malibu
115.08350.0165369311.5701buick skylark 320
218.08318.0150343611.0701plymouth satellite
316.08304.0150343312.0701amc rebel sst
417.08302.0140344910.5701ford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin name \n", + "0 1 chevrolet chevelle malibu \n", + "1 1 buick skylark 320 \n", + "2 1 plymouth satellite \n", + "3 1 amc rebel sst \n", + "4 1 ford torino " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from ISLP import load_data # Package which contains the data\n", + "Auto = load_data('Auto') # Loading the data\n", + "Auto.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "d37dfd0a-c477-412f-a2df-8a180d402980", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "n = int(len(Auto)) # Number of observations in the dataset\n", + "nT = int(n/2) # training sample size\n", + "nV = int(n/2) # validation sample size\n", + "\n", + "#nT = int(0.7 * n) # or any other value for training sample size\n", + "#nV = int(0.3 * n) # validation " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "d1a5c04e-4b81-431d-b5a2-897c15a489e3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# set seed\n", + "np.random.seed(2)\n", + "\n", + "# Define training and test sets\n", + "train_sample = np.random.choice(n, nT, replace=False) # indices for training data\n", + "train_data = Auto.iloc[train_sample] # training dataset\n", + "test_data = Auto.drop(train_sample) # test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f84b8183-9122-488c-8318-437775bafc6c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import statsmodels.formula.api as smf\n", + "\n", + "# fit model on training data and calculate training MSE\n", + "fit_lm = smf.ols(formula='mpg ~ horsepower', data = train_data).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "983b58f5-50e1-4b2e-a092-f0c7bbd99ca3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 40.3338 1.023 39.416 0.000 38.316 42.352\n", + "horsepower -0.1596 0.009 -17.788 0.000 -0.177 -0.142\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "print(fit_lm.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "19f13816-ad3c-460f-8378-3a7195477200", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "# Predictions for training data\n", + "y_head_train = fit_lm.predict(sm.add_constant(train_data))\n", + "\n", + "# OR Alternatively\n", + "#y_head_train = fit_lm.predict(train_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "68a714f4-3a75-4f80-b623-41ef94e32336", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Squared Error: 24.623\n" + ] + } + ], + "source": [ + "# Function to compute the mean squared error (MSE)\n", + "# Takes realized values y and corresponding predictions y_head\n", + "# as inputs and returns MSE as output\n", + "def MSE(y, y_head):\n", + " return((y - y_head)**2).mean()\n", + "\n", + "# Compute the mean squared error\n", + "MSE_train = MSE(train_data['mpg'], y_head_train)\n", + "print(f\"Mean Squared Error: {MSE_train:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "833cddff-8502-434f-8ac5-772980f7e975", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Predictions for test data\n", + "y_head_test = fit_lm.predict(sm.add_constant(test_data))" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "75364f58-9706-4e0f-8a63-19154d5906c0", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Squared Error: 23.362\n" + ] + } + ], + "source": [ + "# MSE in the test data\n", + "MSE_test = MSE(test_data['mpg'], y_head_test)\n", + "print(f\"Mean Squared Error: {MSE_test:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "13abd0fa-7cc4-4fa3-9e21-2692c112d45a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===========================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "-------------------------------------------------------------------------------------------\n", + "Intercept 2.267e-12 1.17e-13 19.397 0.000 2.04e-12 2.5e-12\n", + "poly(horsepower, 10)[0] -1.047e-09 5.4e-11 -19.397 0.000 -1.15e-09 -9.4e-10\n", + "poly(horsepower, 10)[1] 5.523e-09 2.85e-10 19.398 0.000 4.96e-09 6.08e-09\n", + "poly(horsepower, 10)[2] 3.23e-07 1.67e-08 19.398 0.000 2.9e-07 3.56e-07\n", + "poly(horsepower, 10)[3] 8.839e-06 4.56e-07 19.399 0.000 7.94e-06 9.74e-06\n", + "poly(horsepower, 10)[4] -2.061e-07 1.21e-08 -17.074 0.000 -2.3e-07 -1.82e-07\n", + "poly(horsepower, 10)[5] 1.789e-09 1.16e-10 15.420 0.000 1.56e-09 2.02e-09\n", + "poly(horsepower, 10)[6] -6.836e-12 4.82e-13 -14.175 0.000 -7.79e-12 -5.88e-12\n", + "poly(horsepower, 10)[7] 9.682e-15 7.34e-16 13.197 0.000 8.23e-15 1.11e-14\n", + "poly(horsepower, 10)[8] -8.958e-20 2.41e-19 -0.372 0.711 -5.65e-19 3.86e-19\n", + "poly(horsepower, 10)[9] 2.196e-20 1.28e-19 0.172 0.864 -2.3e-19 2.74e-19\n", + "===========================================================================================\n" + ] + } + ], + "source": [ + "def poly(x, degree):\n", + " return np.vander(x, degree + 1, increasing=True)[:, 1:]\n", + "\n", + "fit_lm2 = smf.ols(formula='mpg ~ poly(horsepower, 10)', data = train_data).fit()\n", + "print(fit_lm2.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "dbdedc62-0489-4d69-b767-88012ae07fe1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Squared Error: 73.668\n" + ] + } + ], + "source": [ + "# Predictions for test data\n", + "y_head_test2 = fit_lm2.predict(sm.add_constant(test_data))\n", + "\n", + "# MSE in the test data\n", + "MSE_test2 = MSE(test_data['mpg'], y_head_test2)\n", + "print(f\"Mean Squared Error: {MSE_test2:.3f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "551285b4-ef00-4be0-8000-ceac1ca7742e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "46\n", + "230\n" + ] + } + ], + "source": [ + "# Find the minimum value of the 'horsepower' column\n", + "hp_min = Auto['horsepower'].min()\n", + "print(hp_min)\n", + "\n", + "# Find the maximum value of the 'horsepower' column\n", + "hp_max = Auto['horsepower'].max()\n", + "print(hp_max)" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "294183df-ab11-4578-b7da-c4756c3819f1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " horsepower mpg_pred\n", + "0 46.000000 2.133755\n", + "1 47.858586 2.561017\n", + "2 49.717172 3.043722\n", + "3 51.575758 3.584271\n", + "4 53.434343 4.184536\n", + ".. ... ...\n", + "95 222.565657 7.456441\n", + "96 224.424242 19.414182\n", + "97 226.282828 36.696028\n", + "98 228.141414 60.525143\n", + "99 230.000000 92.310918\n", + "\n", + "[100 rows x 2 columns]\n" + ] + } + ], + "source": [ + "from sklearn.preprocessing import PolynomialFeatures\n", + "import statsmodels.api as sm\n", + "\n", + "# Create a grid of horsepower values\n", + "hp_grid = np.linspace(hp_min, hp_max, 100)\n", + "\n", + "# Create a DataFrame for the grid\n", + "hp_grid_df = pd.DataFrame(hp_grid, columns=['horsepower'])\n", + "\n", + "# Create polynomial features up to degree 10 for the grid\n", + "poly = PolynomialFeatures(degree=10)\n", + "hp_poly_grid = poly.fit_transform(hp_grid_df)\n", + "\n", + "# Fit the polynomial regression model using statsmodels\n", + "train_data = Auto.iloc[train_sample] # Use the train_sample index to get training data\n", + "X_train_poly = poly.fit_transform(train_data[['horsepower']])\n", + "y_train = train_data['mpg']\n", + "fit2 = sm.OLS(y_train, X_train_poly).fit()\n", + "\n", + "# Predict using the fitted model on the grid\n", + "hp_grid_df['mpg_pred'] = fit2.predict(hp_poly_grid)\n", + "\n", + "print(hp_grid_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "6b7da3bd-a75d-4ba9-8afb-61f9e13dc053", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAJOCAYAAACqS2TfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAD5JElEQVR4nOzdeXhT1dYG8PecDG06UjrQMhRQuIATKsNlEkQQldERFLCgiAgOFcUBrwPOoCKiFxARkQoiKHMRRURUQISiePVTQBGZS1ugLR0znP39cUiatJnaJk3Svr/n4WlJTk72yU6hK2vttSUhhAARERERERER+Zwc6AEQERERERER1VcMuomIiIiIiIj8hEE3ERERERERkZ8w6CYiIiIiIiLyEwbdRERERERERH7CoJuIiIiIiIjITxh0ExEREREREfkJg24iIiIiIiIiP2HQTUREREREROQnDLqJiIiIiIiI/IRBNxER+cy0adMgSRIkSfJ47D///GM79sMPP/T/4IjqkPW9LUkSOnTo4PH43bt3Ozxm7NixVY758MMPHY6x/tHr9UhOTsaAAQPw/vvvw2QyeXy+Xbt24ZFHHkGXLl2QnJwMvV6P6OhoXHDBBbjxxhvx1ltv4ejRozW5dCIiqoRBNxEREZEf7du3Dz/88IPbYz744INqnTMhIQFNmjRBkyZNoNfrcerUKXz11VcYP348evTogbNnzzp9XHZ2Nm644Qb8+9//xqxZs5CVlYWcnBxERERACIFDhw5h7dq1mDx5Mlq3bo20tDRYLJZqjY2IiBwx6CYiIiLyk1atWgEAFi1a5PKYsrIyfPLJJ5AkCampqV6dd/fu3cjOzkZ2djaKiorw999/Y+TIkQCArKws3HvvvVUec/DgQVx55ZX44osvoNPpcO+992Lbtm0oKytDfn4+ioqKUFRUhK+++gr3338/DAYDPvroI68y50RE5BqDbiIiIiI/SUtLgyRJWL58OUpKSpwes2rVKuTn56NPnz5o3bp1jZ6ndevWWLJkCa666ioAwMqVK5GdnW27v6ysDMOGDcPJkyfRqFEjbNmyBfPnz0fPnj2h1+ttx0VGRqJ///7473//i3/++cc2fiIiqjkG3UREFNRWrVqFwYMH28pomzRpgsGDB2P16tUuHzN27FjbulghBN5//3306tUL8fHxVdaQHzt2DJMnT8bFF1+MyMhIhIWFoWnTpujUqRMmT56M3bt3u3yerVu34o477kBqairCw8MRGxuLrl274rXXXkNxcbFXY3v33XfRtWtXxMbGIiYmBr169cLSpUs9vi5bt27FbbfdhmbNmiEsLAwJCQno168fFi1a5LQc+IEHHoAkSbj11lur3GcymRAVFQVJkpCYmAghRJVjrrvuOkiShGeffdbpeH7++WfcfffduPDCCxEREYGoqCh07NgRTz/9NPLy8pw+xtoD4OqrrwagBooDBgxAUlISZFnGtGnTPL4Ob775JiRJQpMmTWA2m10eJ4RAy5YtIUkSXnrpJYf79u3bh3vvvRf/+te/EBERAYPBgBYtWqBbt2546qmnsG/fPo/jcKV169bo06cPCgsLsXLlSqfHWEvL77rrrho/D6CuIx89ejQA9XqzsrJs973//vv4v//7PwDA/Pnz0atXL4/ni4+Px+LFixEWFlarcRERNXiCiIjIR5577jkBQHjz38uhQ4dsxy5atKjK/eXl5WLEiBG2Y2RZFnFxcUKWZdttd9xxhzAajVUeO2bMGAFApKWliVtvvbXK463Pt3fvXhEXF2c7n0ajEXFxcUKSJNttY8aMqXJ+k8kk7rnnHtsxAERUVJTQaDS2v7dr1078888/Lsc2ZswY2/VZx2b/vHfddZdQFMXpazd58mTbcZIkiUaNGjk89zXXXCMKCwsdHrNy5UoBQMTHx1c577Zt2xyu5ZdffnG432g0isjISAFAbNmypcp4nn32WYexR0RECL1eb/t7SkqK+Omnn6o8zvp+6dOnj3jkkUds1xMXFyc0Go147rnnnF6/vezsbNu1Z2Zmujxu69attvMfOnTIdvumTZtEWFiYbaw6nU40atTI4fXwZhyV2b+3Fy9eLACIvn37Vjnu8OHDQpIkER0dLYqLi0WfPn1cvu8WLVpkO6/9NdjbsGGD7ZilS5fabm/fvr0AIDp06FDtayEiotphppuIiILSU089heXLl0OSJDzzzDM4ffo0zpw5g7y8PDz11FMAgGXLluGZZ55xeY5Vq1ZhzZo1eOONN3D27FmcOXMGBQUFuO666wAAjz76KM6ePYsrr7wSP/zwA0wmE86cOYOysjIcOHAAb7zxBi6++OIq550yZQref/99NGnSBHPnzsXp06dx7tw5lJaW4ptvvsEVV1yB/fv34+abb4aiKE7HtmbNGqxYsQIvvviibWynTp3CAw88AEBdA/zOO+9Uedx///tfzJo1CwBw77334sSJEzh79iwKCgowa9YsaLVabNmyBePHj3d43NVXXw1JknD69Gn88ssvDvd98803AICYmBgAwJYtWxzu//HHH1FcXIywsDB0797d4b633noLL7zwAqKiovDqq6/i5MmTKC4uRklJCbKysnDNNdfg5MmTGDp0KIqKipy+Fnv27MGbb76Jxx9/HKdOncKZM2dQXFzsVea3SZMmGDBgAADgo48+cnmc9b6rrrrKts4aACZNmoTy8nIMGDAAv/76K4xGI86ePYvS0lL8+uuvmDZtGlq2bOlxHO7ceuutiImJwdatW3Ho0CGH+xYtWgQhBEaMGIGIiIhaPQ+g7gpg1bhxYwDAiRMnbNn6IUOG1Po5iIiomgId9RMRUf1hn+lu0qSJ2z8JCQkuM93Hjh0TWq1WABBTp051+lzWzKhOpxMnTpxwuM+aTQYg3n77bZfjNRgMAoDYsWOH19f466+/CkmSREREhPjf//7n9JjCwkLRvHlzAUCsXr3a5dieeeYZp48fPXq0ACAaN24sSktLbbeXlJSIxo0b27L8zrz99tu28+/evdvhvssvv1wAEDNnznS4vW/fvgKAePbZZwUAMWTIEIf7n3/+eQFAXH311Q635+bmioiICCFJkti8ebPT8ZhMJtGpUycBQMyaNcvhPvv3yyOPPOL08d5YtmyZACDCw8NFfn5+lftLS0tFbGysACDef/992+2nTp2yPX/l91BtVX5vWysjnn32WdsxiqKI1q1bCwBi+/btQghRq0y3yWQSHTt2tFVP5OXlCSGE+Oqrr2yP+/jjj316nURE5Bkz3URE5BenTp1y+8fVOl9AXdtrNpsRHh6OJ5980ukxTz/9NMLCwmAymfDZZ585PSYuLg4TJkxw+TyNGjUCAJw8edLr61q4cCGEEBg0aBAuvfRSp8dER0fjxhtvBAB8+eWXTo8xGAyYMmWK0/us66bPnDmDr776ynb7V199hTNnzgCAy/XOkyZNQkpKCgC1EsBe3759AThmssvLy/HDDz8gMjISjzzyCPR6Pb777juHdeHWTLj18VZLly5FSUkJOnfujH79+jkdj1arxR133AHA9WshyzKeeOIJp/d5Y9iwYYiJiUFZWZnT98K6detQUFCA8PBwhzXt0dHRkGX1V6HqvAdq4u677wYALF682LZm/ptvvsGhQ4fQrl079OjRo8bnLioqws6dOzFw4EBbFcOYMWMQHx8PADh9+rTtWGv225nLLrsMycnJVf688cYbNR4bERGxkRoREfmJEMLtn8pltvasDaC6dOliK3muLC4uDp07d3Y4vrIuXbo4dGaubPDgwQDUAOXRRx/Ft99+67LDtNW2bdsAABs3bnQaoFj/WLeIOnz4sNPzdO7c2eW1tW3bFs2bN69ybdbvW7RogX/9619OH6vRaHDNNddUeSwA2+3fffedrenYjh07UFZWhl69eiE2Nhb//ve/UVBQgD179gBQu15b95iuHHRbX4vffvvN7WvxwgsvuH0t2rRpg6SkJKf3ecNgMNiCaWcl5tbbhg0bhtjYWIfHWT8suP766/Hss8/ixx9/hNForPFYXOnevTvat2+Pw4cP4+uvvwZQuwZqrVu3hiRJkCQJ0dHR6N69u+0Dmv79+ztdmuBJTk6O0w/IXC0LICIi7zDoJiKioJOTkwMAaNasmdvjrIGp9fjKPAVyr732Gvr27YuioiK8+eabuPrqqxETE4POnTvjueeew/Hjx6s85sSJEwDU7KK7TL61e7mrIN7TtVnvt7+22r4uvXv3hkajwblz52wBuTWLbQ3IrV+t2fAdO3agvLwcERER+Pe//+1wPutrUVpa6va1KCwsBOD6tahNwG2VlpYGQP1AwT64z83NxRdffOFwjL33338fHTt2RG5uLl588UV069YN0dHR6NWrF15//XVbZYEvWIPrRYsWobCwEKtWrYJGo3E6Lk8SEhLQpEkTNGnSBM2bN8dll12G0aNHY82aNdi0aRMiIyNtx1oz3gDcXk92drbDB2O1XctOREQqBt1ERBS0vN0f2NVxGo3G7eOs+xV///33ePzxx9GzZ09otVrs2bMHL7zwAtq2bVulRNtadj19+nSP2XwhBLZu3Vqra6vNYysfFxMTgyuvvBJARVBt/eoq6LZ+rbyfM1DxWtx3331evRb2Tb7seZonb/Tu3RstW7aEEAJLliyx3f7JJ5/AbDY7NFyzl5qaip9++glffPEFHnroIXTq1AmKomD79u14/PHH0aZNmyqN5WrqzjvvhEajwerVq/Huu++itLQU119/vW05QHXs3r0b2dnZyM7OxtGjR/HLL7/go48+wrBhw6rM+0UXXWT7fu/evbW9DCIiqiYG3UREFHSsmc+jR4+6Pe7YsWMAgMTExFo9X69evTBjxgxs27YN+fn5WLt2LS699FKUlpbi7rvvxqlTp2zHJicnAwB+/fXXWj2ndeyuWLPs9llgX7wu9kF1cXExdu3ahUaNGtmC8W7dusFgMGD79u0wGo22gLNyaTngu9fCF+z3qLYvMbd+f8cdd0Cr1Tp9rCzLuO666zB79mxkZWXhzJkzWLp0KVJTU3H27FmMHDnSJyXnKSkpuP7661FaWmrrul/bvbm90bRpU7Rv3x4AsH79er8/HxEROWLQTUREQcd+rXZBQYHTY/Lz8x3WfvtKeHg4hg4dilWrVgFQ1zRb1y4DasYXADZs2FCrta5ZWVk4d+6c0/v++usvW+BsfS3svz927BgOHDjg9LEWi8VWMu7sdbEGzzt27MDXX38Nk8mEPn362BqK6fV69OzZEyUlJdi8eTN2797t8Dh71tdi586dLtdr1yVrmfb+/fuxe/du21f7+7wRHR2NkSNHYuHChQDUpoC++mDB2lDNaDQiISGhzrbwuv/++wEAf/zxB1asWFEnz0lERCoG3UREFHRuueUWaLValJWVYcaMGU6PeeWVV1BeXg6dTodbbrml2s9hNptd7qENqE22rOzLn8ePHw9JkpCfn4/HHnvM7XOYTCaXgXlpaSlmzpzp9L6XXnoJgNpp+tprr7Xdfu2119rW57rqXj5//nzbWmtr13B7V111FXQ6HUpLS/HKK68AqMh+W1kD7BdeeAFmsxlRUVEOwb/VnXfeCYPBAIvFgvvvv9+h43lliqIgPz/f5f2+8K9//cu27jwjI8OW5b7kkktwxRVXVDneU/ba1XugNoYMGYLHH38cjz76KN566y23jf586Z577rHtOT9hwgRs3769Tp6XiIgYdBMRURBq1qwZ0tPTAahrp5977jlbwJafn49nnnkGr7/+OgDgkUceqdGa2GPHjqFt27Z46aWX8PPPP9u6eQPA//73P1upcmRkJHr37m277/LLL8fDDz8MAHj33Xdx2223Ye/evbZtoCwWC3755Re8+OKLuPDCC12uoY2NjcWLL76IV1991ZbxzsvLQ3p6OhYvXgwAeOaZZxAeHm57jMFgsAXby5Ytw3333WcrfS8pKcE777xjG9uIESPQqVOnKs8bERGBrl27AgB+/PFHAFWDbuvfrfdfddVVTkuzk5OTMX36dABq5v/aa6/F9u3bbcG3EAL79u3Dm2++iUsuuQSZmZlOXwtfuvPOOwGoa7mta7utt1W2Y8cOXHbZZZg1axb++OMP24cwQgjs2LEDEydOBKA2pnO1PVx16XQ6zJgxA2+88QZGjRrlk3N6Izw8HGvXrkVKSgry8/PRt29fW/Bt/+FDeXk5du3ahfT0dNuHN0REVEt+3geciIgakOeee04AEN7893Lo0CHbsYsWLapyf3l5uRg+fLjtGFmWRVxcnJBl2XbbHXfcIYxGY5XHjhkzRgAQY8aM8er5AQiNRiMaN24s9Hq97Ta9Xi8+/fTTKo81m83i4Ycfdnh8eHi4iI+PF1qt1uH2bdu2uRzbiBEjbM8dFxcnJEmyPS4tLU1YLBanY588ebLtOEmSRFxcnMPz9u3bVxQWFrq89meeecZ2bFJSUpX7TSaTiI6Oth3z2muvuTyXEEK89tprQqPROLxu8fHxQqfTObwWS5YscXic9f3Sp08ft+evjry8PIc5lGVZHDt2zOmx33zzjcP4dDpdlTmMiYkR3333XbXH4e697U6fPn1cvncXLVpkO++hQ4eqPSYhhDh58qS4/vrrHa5bkiTRqFGjKj9fGo1GjB07Vhw/frxGz0VERCpmuomIKCjp9XosX74cK1euxA033ID4+HicO3cO8fHxuOGGG7Bq1Sp8/PHH0Ol0NTp/s2bNsG7dOkyePBndunVDSkoKioqKoNVqcdFFF+H+++/Hb7/9Ztv/2Z5Go8GsWbPw008/4d5770W7du2g0WhQUFCAuLg49OzZE9OmTcPevXtt656dWbZsGebNm4crrrgCZrMZkZGR6N69OzIyMrB48WLbOuvK3nzzTWzZsgW33HILmjRpgqKiIkRHR6Nv37744IMP8NVXXyE6Otrl89qvz3a2Vlur1eKqq65ye4y9xx57DPv27cPkyZNx2WWXITw8HPn5+YiKikKXLl3w+OOPY8eOHRg5cqTb8/hCfHw8Bg4caPt7v379XG6x1qVLF6xYsQITJ05Ep06dkJCQgIKCAoSHh+Pyyy/H448/jj/++MPhtQh1ycnJ2LhxI3bu3ImHH37Ydt1FRUUwmUxITU3F0KFD8cYbb+DIkSNYtGgRmjZtGuhhExGFNEmI8/VwRERE5Hdjx47F4sWLMWbMGHz44YeBHg4RERH5GTPdRERERERERH7CoJuIiIiIiIjITxh0ExEREREREfkJg24iIiIiIiIiP2EjNSIiIiIiIiI/YaabiIiIiIiIyE8YdBMRERERERH5CYNuIiIiIiIiIj/RBnoAoers2bMwm82BHoZfJSYmIjc3N9DDoBri/IU2zl/o4tyFNs5f6OLchTbOX2hrqPOn1WoRFxfn+bg6GEu9ZDabYTKZAj0Mv5EkCYB6ney1F3o4f6GN8xe6OHehjfMXujh3oY3zF9o4f56xvJyIiIiIiIjITxh0ExEREREREfkJg24iIiIiIiIiP2HQTUREREREROQnDLqJiIiIiIiI/IRBNxEREREREZGfMOgmIiIiIiIi8hMG3URERERERER+wqCbiIiIiIiIyE8YdBMRERERERH5CYNuIiIiIiIiIj9h0E1ERERERETkJwy6iYiIiIiIiPyEQTcRERERERGRnzDoJiIiIiIiIvITBt1EREREREREfsKgm4iIiIiIiMhPtIEeABEREREREZGVnJMDzYkTUKKjoaSkQEREBHpItcJMNxEREREREQWN8M8/R+KgQWjSuzfCN2wI9HBqjUE3ERERERERBQ25sND2vYiJCeBIfINBNxEREREREQUN6dw52/dKdHQAR+IbDLqJiIiIiIgoaNhnuhVmuomIiIiIiIh8x6G8nJluIiIiIiIiIt9heTkRERERERGRnzDTTUREREREROQn1ky3YjAAOl2AR1N7DLqJiIiIiIgoaFgz3fVhuzCAQTcREREREREFEVumux6UlgMMuomIiIiIiChYWCyQi4sB1I/13ACDbiIiIiIiIgoSDp3LY2MDOBLfYdBNREREREREQUG2C7qZ6SYiIiIiIiLyIcluuzCFjdSIiIiIiIiIfIeZbiIiIiIiIiI/cch0M+gmIiIiIiIi8h2HTDfLy4mIiIiIiIh8x6F7OTPdRERERERERL4j25WXM9NNRERERERE5EPMdBMRERERERH5icwtw4iIiIiIiIj8w6G8nJluIiIiIiIiIt9heTkRERERERGRnzDTTUREREREROQn1ky3YjAAOl2AR+MbDLqJiIiIiIgoKFgz3fVluzCAQTcREREREREFCVumu56UlgMMuomIiIiIiCgYWCyQi4sB1J/13ACDbiIiIiIiIgoCDp3LWV5ORERERERE5DuyXdDNNd1EREREREREPiTZbRfGTDcRERERERGRDzlkurmmm4iIiIiIiMh3HDLdDLqJiIiIiIiIfIdruomIiIiIiIj8xKF7OTPdRERERERERL4j25WXM9NNRERERERE5EPMdBMRERERERH5icwtw4iIiIiIiIj8w6G8nJluIiIiIiIiIt9heTkRERERERGRnzDTTUREREREROQn1ky3YjAAOl2AR+M7DLqJiIiIiIgo4KyZ7vq0XRjAoJuIiIiIiIiCgC3TXY9KywEG3URERERERBRoFgvk4mIA9Ws9N8Cgm4iIiIiIiALMoXM5y8uJiIiIiIiIfEe2C7qZ6SYiIiIiIiLyIcluuzAlNjaAI/E9baAH4K2CggKsXbsWe/fuRU5ODoQQaNy4MS655BIMGzYMycnJTh934MABrFmzBvv370dZWRmSkpLQs2dPDB06FHq9vo6vgoiIiIiIiCqrz5nukAi6T5w4geeeew4FBQXQaDRo0qQJNBoNsrOz8fXXX2Pbtm2YOnUqLrroIofHff/995gzZw4URUHjxo2RkJCAI0eOYMWKFdizZw+mTZuGsLCwAF0VERERERERAZUy3Qy6697ChQtRUFCAdu3a4eGHH0Z8fDwA4Ny5c5g3bx6ysrIwd+5cvPPOO5AkCQCQk5ODd999F4qiYPTo0RgyZAgkSUJubi5efvllHDx4EEuWLMG4ceMCeWlEREREREQNnkOmm43U6lZ5eTl+++03AMD48eNtATcAREdHY9KkSZAkCTk5OTh+/LjtvnXr1sFkMqFjx44YOnSoLRhPTEzExIkTAQCbN29Gfn5+3V0MERERERERVeHQvbyeZbqDPug2m80QQgAAkpKSqtwfFRWFqKgoAICiKAAAIQR2794NAOjbt2+Vx7Rr1w7NmjWDxWJBVlaWv4ZOREREREREXpDtysuZ6a5jkZGRtuz2gQMHqtx/4sQJnDt3DpGRkbZmanl5eTh79iwAoH379k7P265dOwDAn3/+6Y9hExERERERkZeY6Q6w22+/HQAwb9487Ny5E+fOnUNJSQn27t2L119/HZIkYdSoUbZu5CdPngQA6HQ6xMXFOT2nNWuenZ1dB1dARERERERErthnupV6lukOiUZqffr0QXh4OFauXIk333zT4b6WLVti6tSpuPzyy223FRcXAwAiIiJsa7krs5akFxUVuX1uk8kEk8lk+7skSTAYDLbv6yvrtdXna6zPOH+hjfMXujh3oY3zF7o4d6GN8xfafDV/9kE3YmLq1fshJIJuIQROnTqFc+fOQZZlJCUlQavVIjs7G0eOHMHmzZvRpk0bWyBtDZK1WteXZ73PaDS6fe7Vq1fjs88+s/29devWmDFjBhITE2t7WSHB1f7nFBo4f6GN8xe6OHehjfMXujh3oY3zF9pqPX92cVlS27aAXQPtUBcSQfeCBQuwefNmtGvXDs8//7ytNLygoADz5s3Drl27cOrUKcyYMQOyLEOn0wFQm7C5Yr3PWpLuyk033YTBgwfb/m79xCU3N9ft+UOdJElITk5Gdna2rZEdhQ7OX2jj/IUuzl1o4/yFLs5daOP8hTZfzV98bi6skdnJ4mKHIDxYabVar5KxQR90//PPP/j666+h0WiQnp6OhIQE232xsbF46KGH8OCDD+Lw4cPYsWMHevXqhcjISABASUkJhBBOSxOsZeXW7LgrOp3OFsRX1hD+URBCNIjrrK84f6GN8xe6OHehjfMXujh3oY3zF9pqO3/WRmqKwQCh1QL16L0Q9I3U9u/fDyEEmjZt6hBwW0VERKBNmzYAgL///hsAkJKSAkAtM7d2Ma8sJycHAMtYiIiIiIiIAs26pru+bRcGhEDQXVpa6vWx1vXZCQkJaNSoEQBg3759To/dv38/AKBt27a1GyARERERERHVii3TXc+2CwNCIOi2Zq1PnDiBvLy8KveXlJTgr7/+AgA0bdoUgLquoGvXrgCAb775pspj9u/fj+PHj0Oj0aBz587+GjoRERERERF5YrFAPr8DlWDQXfc6duyI6OhoWCwWzJ4921YWDqiN1N5++22cO3cOOp0O3bp1s903dOhQaLVa/PLLL1i3bp1tfUFubi7mzZsHAOjXr58tI05ERERERER1z5rlBurfHt1ACDRSCw8PxwMPPIA33ngD+/fvx0MPPYQmTZpAo9EgOzsbZrMZGo0G48ePR+PGjW2PS0pKwoQJEzB37lwsWbIEn3/+OWJjY3HkyBFYLBZccMEFGD16dACvjIiIiIiIiGS7oLs+ZrqDPugGgCuuuAKvv/46MjMz8dtvvyEvLw9CCMTFxaFDhw4YOHAgLrjggiqP69OnD5KTk7F69WocOHAAx44dQ5MmTdCzZ08MGzbM43ZhRERERERE5F/S+SZqADPdAdW0aVPce++91X5cu3bt8OSTT/phRERERERERFRbDpnuehh0B/2abiIiIiIiIqq/HDLd9bC8nEE3ERERERERBQwz3URERERERER+4tC9nJluIiIiIiIiIt+R7crLmekmIiIiIiIi8iFmuomIiIiIiIj8RK7nW4Yx6CYiIiIiIqKAcSgvZ6abiIiIiIiIyHdYXk5ERERERETkJ8x0ExEREREREfmJNdOtGAyAThfg0fgeg24iIiIiIiIKGGumuz5uFwYw6CYiIiIiIqIAsmW662FpOcCgm4iIiIiIiALFYoFcXAygfq7nBhh0ExERERERUYA4dC5neTkRERERERGR78h2QTcz3UREREREREQ+JNltF8ZMNxEREREREZEPMdNNRERERERE5CfMdBMRERERERH5iUOmm0E3ERERERERke84dC9neTkRERERERGR78h25eXMdBMRERERERH5EDPdRERERERERH4is5EaERERERERkX84lJcz001ERERERETkOywvJyIiIiIiIvITZrqJiIiIiIiI/MSa6VYMBkCnC/Bo/INBNxEREREREQWENdNdX7cLAxh0ExERERERUYDYMt31tLQcYNBNREREREREgWCxQC4uBlB/13MDDLqJiIiIiIgoABw6l7O8nIiIiIiIiMh3ZLugm5luIiIiIiIiIh+S7LYLY6abiIiIiIiIyIeY6SYiIiIiIiLyE2a6iYiIiIiIiPzEIdPNoJuIiIiIiIjIdxy6l7O8nIiIiIiIiMh3ZLvycma6iYiIiIiIiHyImW4iIiIiIiIiP5HZSI2IiIiIiIjIPxzKy5npJiIiIiIiIvIdlpcTERERERER+Qkz3URERERERER+Ys10KwYDoNMFeDT+w6CbiIiIiIiI6pw1012ftwsDGHQTERERERFRANgy3fW4tBxg0E1ERERERER1zWKBXFwMoH6v5wYYdBMREREREVEdc+hczvJyIiIiIiIiIt+R7YJuZrqJiIiIiIiIfEiy2y6MmW4iIiIiIiIiH2Kmm4iIiIiIiMhPHDLdDLqJiIiIiIiIfMch0x0bG8CR+B+DbiIiIiIiIqpTDt3LmekmIiIiIiIi8h3ZrrxcsJEaERERERERke8w001ERERERETkJzK3DCMiIiIiIiLyD4fycma6iYiIiIiIiHyH5eVEREREREREfsJMNxEREREREZGfWDPdisEA6HQBHo1/MegmIiIiIiKiOmXNdNf37cIABt1ERERERERUx2yZ7npeWg4w6CYiIiIiIqK6ZLFALi4GUP/XcwMMuomIiIiIiKgOOXQuZ3k5ERERERERke/IdkE3M91EREREREREPiTZbRfGTDcRERERERGRDzHTTUREREREROQnDpluBt1EREREREREvuOQ6WZ5OREREREREZHvNLTu5dpAD6A6FEXBli1b8P333+PYsWMoKytDbGwsWrVqhb59+6JLly5VHnPgwAGsWbMG+/fvR1lZGZKSktCzZ08MHToUer0+AFdBRERERETUcMl25eUNIdMdMkF3UVERXn31Vfz555+QJAkpKSlITEzE2bNnkZWVBY1GUyXo/v777zFnzhwoioLGjRsjISEBR44cwYoVK7Bnzx5MmzYNYWFhAboiIiIiIiKihsch090A1nSHRNCtKApee+01/Pnnn+jatSvuuusuxMfH2+4/ffo0Tp065fCYnJwcvPvuu1AUBaNHj8aQIUMgSRJyc3Px8ssv4+DBg1iyZAnGjRtX15dDRERERETUYMncMiz4bN68Gfv27cPFF1+MRx55xCHgBoD4+HhcdNFFDretW7cOJpMJHTt2xNChQyFJEgAgMTEREydOtJ03Pz+/Tq6BiIiIiIiIKpWXN4BMd0gE3Rs3bgQAjBgxArLsechCCOzevRsA0Ldv3yr3t2vXDs2aNYPFYkFWVpZvB0tEREREREQusbw8yJw8eRLHjx9HVFQU2rVrh927d+OHH35Afn4+YmJicOmll6J3797Q6XS2x+Tl5eHs2bMAgPbt2zs9b7t27XD8+HH8+eef6N+/f51cCxERERERUUMnFxTYvm8Ime6gD7r//vtvAECzZs3wzjvvYNu2bQ7379ixA5mZmXjqqaeQmJgIQA3UAUCn0yEuLs7peZOSkgAA2dnZ/ho6ERERERERVSKfOQMAUGJjAbvkaX0V9EG3NWP9119/Yf/+/bjmmmtwyy23oFGjRti3bx/ee+89HD9+HDNnzsQrr7wCWZZRXFwMAIiIiLCt5a4sKioKgNoV3R2TyQSTyWT7uyRJMBgMtu/rK+u11edrrM84f6GN8xe6OHehjfMXujh3oY3zF9pqMn/y+RhPady4Qcx70Afd5eXlAACLxYIOHTrgvvvus9136aWX4tFHH8UTTzyBv//+Gz/99BM6d+5sC5K1WteXZ73PaDS6ff7Vq1fjs88+s/29devWmDFjhi2rXt8lJycHeghUC5y/0Mb5C12cu9DG+QtdnLvQxvkLbV7Pn8kEnC8v1zZpgpSUFD+OKjgEfdBtv1b7hhtuqHJ/q1atcPHFF+O3337D3r170blzZ9tjzGazy/Na79Pr9W6f/6abbsLgwYNtf7d+EpObm+v2/KFOkiQkJycjOzsbQohAD4eqifMX2jh/oYtzF9o4f6GLcxfaOH+hrbrzJ+fmosn578uionD2/NLgUKTVar1KxgZ90G0tAwfUdd3ONGvWDL/99htyc3MBAJGRkQCAkpISCCGclixYy8rtz++MTqdzCPztNYR/FIQQDeI66yvOX2jj/IUuzl1o4/yFLs5daOP8hTZv5086fdr2vdK4cYOY86DfMqxp06a2710Fv9bbFUUBAFuJgslksq0JrywnJwcAy1iIiIiIiIjqirWJGqAG3Q1B0AfdrVq1sgXVp06dcnqM9fbG5yctISEBjRo1AgDs27fP6WP2798PAGjbtq0vh0tEREREREQuMOgOQuHh4bjiiisAAN9++22V+/Pz8/HLL78AAC655BIA6rqCrl27AgC++eabKo/Zv38/jh8/Do1Gg86dO/tr6ERERERERGTHPui2xMcHcCR1J+iDbgC49dZbIcsytm/fjq1bt9puLy4uxpw5c2A0GtGkSRN0797ddt/QoUOh1Wrxyy+/YN26dba1Arm5uZg3bx4AoF+/fraMOBEREREREflXQ8x0B30jNUAtMb/77ruxcOFCzJ07FytWrEBsbCyOHTuG8vJyREdH49FHH3XYIiwpKQkTJkzA3LlzsWTJEnz++eeIjY3FkSNHYLFYcMEFF2D06NEBvCoiIiIiIqKGRbZvpBYXF8CR1J2QCLoBYMCAAWjRogXWrVuHAwcO4PDhw4iLi8OVV16Jm266ybae216fPn2QnJyM1atX48CBAzh27BiaNGmCnj17YtiwYR63CyMiIiIiIiLfke0aXTPTHYQ6dOiADh06VOsx7dq1w5NPPumnEREREREREZG3GmJ5eUis6SYiIiIiIqLQZw26hSxDxMYGeDR1g0E3ERERERER1Qlr0K3ExQFywwhHG8ZVEhERERERUcDZgu4GUloOMOgmIiIiIiKiulBaCrmkBACDbiIiIiIiIiKfaoidywEG3URERERERFQHGmLncoBBNxEREREREdUBBt1EREREREREfsLyciIiIiIiIiI/YaabiIiIiIiIyE80p0/bvmfQTURERERERORDzHQTERERERER+QmDbiIiIiIiIiI/YdBNRERERERE5CfWoFvo9RCRkQEeTd1h0E1ERERERER+Z90yTGncGJCkAI+m7jDoJiIiIiIiIv8SwpbpVuLiAjyYusWgm4iIiIiIiPxKKi6GZDQCaFjruQEG3URERERERORnDbWJGsCgm4iIiIiIiPzMIeiOjw/gSOoeg24iIiIiIiLyK2a6iYiIiIiIiPzEPui2MOgmIiIiIiIi8h1muomIiIiIiIj8RD592vY9twwjIiIiIiIi8iH57Fnb98x0ExEREREREfkQy8uJiIiIiIiI/MQh6GZ5OREREREREZHvWINuJSICMBgCPJq6xaCbiIiIiIiI/MoWdDew0nKAQTcRERERERH5k6LYGqkx6CYiIiIiIiLyIamgAJKiAACU+PgAj6buMegmIiIiIiIiv2nITdQABt1ERERERETkRw15uzCAQTcRERERERH5kXU9N8Cgm4iIiIiIiMinmOkmIiIiIiIi8hPN6dO27xl0ExEREREREfkQM91EREREREREfsKgm4iIiIiIiMhPGHQTERERERER+YlD0N2oUeAGEiAMuomIiIiIiMhvrEG3EhsL6HQBHk3dY9BNREREREREfmPdp1uJiwvwSAKDQTcRERERERH5h8kEuaAAAKDExwd4MIHBoJuIiIiIiIj8Qs7Pt33fEJuoAQy6iYiIiIiIyE8aeudyANAGegBEwUynM6C8PBKyLENRFISFFcNkKg30sIiIiIiIQgKDbma6iZzSaDSQ5SRkZMSiRw89mjfXokcPPTIyYiHLSdBoNIEeIhERERFR0GPQXcNM9z///IMTJ04gLi4OHTp0cLjv+eefd/m4G264AV27dq3JUxLVKSHiMWiQFj/9VHHb0aPAlCkyli2TsX59PICcgI2PiIiIiCgUyKdP2763MOj2jslkwowZM5Cfn49nn322yv2///67y8dmZ2fjyiuvhFbLqnYKXjqdARkZskPAbW/PHmDZMhlpaeEwGsvqdnBERERERCGEme4aBN1ZWVk4c+YMunfvXiXLbdW0aVPcfPPNDrft3LkTWVlZyMrKQrdu3Wo2WqI6UF4eidmz3a+8mD1bxvDhUZBlBt1ERERERK44BN0NdJ/uGgXdADBw4ECXx8TExOCqq65yuK1ly5bIysrC7t27GXRTUJNlGUePuj/m6FFAo5EhRN2MiYiIiIgoFMlnz9q+b6iZ7mo3Uvv7778RERGBtm3bVutxqampiI6Oxt9//13dpySqU4qioEUL98e0aAFYLErdDIiIiIiIKESxvLwGQfeZM2eQkJAASZKc3q/Val2u2Y6Li8NZu086iIJRWFgx0tPdB9Tp6QrCw4vqaERERERERKHJGnQLjQYiNjbAowmMGjVS0+l0Lu9funSp6yfTamEymar7lER1ymQqxahR0Vi2TMaePVXv79QJGDlSYRM1IiIiIiIPrEG3EhcHyA1zx+pqX3V0dDTy8/Nr9GT5+fmIjIys0WOJ6pIkncb69WbMnKkgNRWQJCA1FZg5U0FmphmSVLH1gU5ngKIkAEiCoiRApzMEbuBEREREREHEFnQ30NJyoAZBd9OmTXH69Gnk5uZW63E5OTk4c+YMmjVrVt2nJB9jkOiZxWKBEDlIS8vH9u1GHD9uxvbtRqSl5UNRcmCxWKDRaCDLScjIiEWPHno0b65Fjx56ZGTEQpaToNFoAn0ZRERERESBU1oKuaQEAIPuaunYsSMAIDMzs1qPW79+vcPjqe4xSKw+o7EMspwHIXIgy3kOJeVCxGPQIC2mTFG7nQuhdjWfMkXG4MFaKEp8AEdORERERBRY7FyuqnbQ3b9/f4SHh+PLL7/E1q1bvXrMN998g02bNiE8PBz9+/ev7lOSj/gySGzo2XKdzoClS2X89JPz+/fsAZYtk6HXh9ftwIiIiIiIggT36FZVO+iOiorC3XffDSEE5s2bh9deew179+5FaWmpw3GlpaX4+eefMWPGDLz77rsAgLvuugtRUVG+GTlVi6+CRGbLVeXlkZg92/2Pz+zZMsrK+H4nIiIiooaJ24Wpqt29HAD69OmD8vJyLF68GHv27MGePXsgSRIiIyMRFhaG8vJyFBcXQwgBQA3U0tLScPXVV/ty7FQN1iBRrwduvhkYPRpISADy8oAlS4CVK9UgcfjwKMiy667c1my5ffBuzZYvWyZj/fp4ADn+v6AAk2W1WsCdo0cBjUbG+R8DIiIiIqIGheXlqhr3bB8wYABmzJiBnj17Qq/XQwiBoqIinD59GkVFRRBCQK/Xo2fPnpg+fTquv/56X46bqkmWZUgS8P33QPv2wMSJQPfu6tf27YFt29QO3RqN67cES6orKIqCFi3cH9OiBWCxuN/vm4iIiIiovtKcrtjxpyEH3TXKdFs1b94cDz30ECwWCw4fPowzZ86gtLQUBoMBjRs3RsuWLRtMuXGwUxQFq1cD48ejSpZ62jRg/Xo1222xKC63z/O2pNpTtrw+CAsrRnq6uj7elfR0BeHhRTAa63BgRERERERBguXlqloF3VYajQYXXHABLrjgAl+cjvwgMtKITZt0+Oknyen9e/YAmzcLTJhgxPmu/lWwpLqCyVSKUaOisWyZjD17qt7fqRMwcqTi0O2ciIiIiKghYdCtqnHQnZeXh127duHkyZMAgOTkZHTt2hWJiYk+Gxz5TnGxHnPnOg+4rebOlTBqlN5lpttaUu0u8LaWVLs6R30iSaexfn08li2TMXu2+oFEixZqhnvkSAWSdNrzSYiIiIiI6ikG3aoaBd2bN2/GokWLYDabHW5funQp0tLSuH47CGk0Gi+z1BqXWWqWVDuyWCwAcpCWFo7hw6Og0ciwWKzXzww3ERERETVsDLpV1c5HHjhwAO+//z7MZjMaNWqEK6+8EldccQUaNWoEi8WCDz/8EPv27fPHWKkWzGbJq8ZfZrPrbLhaUq2gUyfn9zfUkmqjsQyynAchciDLeQ3u+omIiIiInLEG3SIsDCIyMsCjCZxqZ7o///xzCCHQq1cvTJgwAXq9HgBgNBrx7rvvYvv27fj888/Rvn17nw+Wai48XGDcOLVpmivjxgEGg3CbpWZJNRERERERecO6ZZgSF6duldRAVTvo3r9/P/R6PcaPH28LuAFAr9fj3nvvxe7du3HgwAGfDpJqr7zcgiFDNFi/Hi4bfw0eDJSVWdyux2ZJNREREREReSSELdPdkEvLgRqUlxcWFqJp06YID6+6F3N4eDhSUlJQWFjok8GR74SFFSMrS8GcOcDzzwOpqeqHTamp6t/nzgX27FGDZ2+wpDq06HQGKEoCgCQoSgJ0OkOgh0RERERE9ZhUXAzpfAltQw+6q53pNpvNTgNuq/Dw8PPZUAomJlMphg6Nxo03ymjVCpgzB0hMBHJzgSVLgM8/B9asaXjrses7jUYDRWmMjAx1OcCxY0Dz5kB6uhajRkVDkk7z55WIiIiIfI5N1Co0gI2dyEqSTmP1ajO6dlVw//1A9+7A/fcDXbsqWLPGzPXY9ZCiNMagQWrH+aNHASHULvVTpsgYPFgLRYkP9BCJiIiIqB5i0F2hRluG5eXl4bPPPnN5HwCX9wPArbfeWpOndfDJJ59g1apVAIARI0bglltucXrcgQMHsGbNGuzfvx9lZWVISkpCz549MXToUIc16Q0B12NXn05nQHl5JGRZhqIoCAsrhslUGuhhecVsBpYulfHTT87v37MHWLZMRlpaOOefiIiIiHyKQXeFGgfdn376qdtj3N1f26D72LFjWLduncfjvv/+e8yZMweKoqBx48ZISEjAkSNHsGLFCuzZswfTpk1DWFhYrcYSitT12GUQApBlNIg9tatL3a88PqTLsk+fBmbPdl/MMnu2jOHDoyDLDLqJiIiIyHfk0xVVtBYG3dXToUMHSAFs9y6EwIIFC6DRaNC+fXv89ttvTo/LycnBu+++C0VRMHr0aAwZMgSSJCE3Nxcvv/wyDh48iCVLlmDcuHF1fAUUCoSIx6BBWocssbUse9kyGevXxwPICdj4vCFJ6pjdOXoU0GhkCFE3YyIiIiKihoGZ7grVDrqnudvouQ5s2bIFf/zxB0aNGoVjx465PG7dunUwmUzo2LEjhg4dars9MTEREydOxDPPPIPNmzfjlltuQaNGjepg5BQqdDoDMjJCvyxbCHUPdXeBd4sWgMWiuN0mjoiIiIiouhyC7ri4AI4k8ELqV+3CwkIsXboUzZs3x6BBg1weJ4TA7t27AQB9+/atcn+7du3QrFkzWCwWZGVl+W28FJrKyyO9KssuK4uqoxHVTHw8kJ6uuD0mPd37beKIiIiIiLwlnz1r+76hZ7pDKuj+8MMPUVRUhHvuuQdareskfV5eHs6en+T27ds7PaZdu3YAgD///NP3A6WQJsuy12XZwUyrBUaNUtCpk/P7O3UCRo7kNnFERERE5HssL69Q7fLyESNG1OoJJUnCJ598Uu3H/frrr9i2bRuuuuoqXHTRRW6PPXnyJABAp9MhzkUpQ1JSEgAgOzu72mOh+k1RlDopy66LzuiyfAbr1zfGsmVqQ7ijR9Wxp6crGDlS4TZxREREROQXDLor1Kh7eW2IGnRsMhqNWLBgASIiInDnnXd6PL64uBgAEBER4bLpW1SUWhpcVOS+tNZkMsFkMtn+LkkSDAaD7fv6ynptwXCNOl04ysoi7bY4K4bJ5L/sbHh4MdLT1b2tXVHLsothMlX/9dFoNFCUxi47o8vymVp3RrfOm6IoAHLPbxNX9TUUIjjmmBwF088fVQ/nLrRx/kIX5y60cf5Cm6v5swbdSmQkpPPxU0NV46C7adOm6N27N/79738jPDzcl2OqYtWqVcjOzsbdd9/tVdMza5DsrgTdep/Rw35Zq1evdthzvHXr1pgxYwYSExO9GHnoS05ODujz5+YCGRnAW2/BFpw+/LAed94J+GMKzGZ1q62RI4ErrwTeew9YuRKw+9wFnToBaWkyEhJq1hAiNxcYNAguO6Nv3JiElJRaXsh5ruevYe1RH6oC/fNHNce5C22cv9DFuQttnL/QVmX+8vMBAHJiIlJ89cttiKp20D1mzBh8//33+Pvvv/HJJ59g1apV6Nq1K3r37o1LL70Uso/bIFv35G7dujUGDBjg1WN0Oh0AwGw2uzzGep9e7z74uOmmmzB48GDb362f4OTm5ro9f6iTJAnJycnIzs6uUXWCb8aQ6HTbrkcfBT7+GMjMNEOIXJ88lzX7vHSpY/Z50iSBxx6TcPPNajdwa1m2opzByZPVz0brdOHIyIjFTz85/znZswf46CMFaWkFtcrmB8P8Uc1x/kIX5y60cf5CF+cutHH+QpvT+VMUJJ8+DQmAMTYWp88v/61vtFqtV8nYagfdAwcOxMCBA3HixAl899132LZtm+1PbGwsevXqhV69euGCCy6o0cArW7hwISwWC8aPH+91QB8ZGQkAKCkpgRDCaamKtazcWmbuik6nswXxlTWEfxSEEAG5Tm+27fr4YxlpaWE+aQSmKI2dBvhTp0r47DNg504Bs9mE8PAiGI1lUNw3BXeprMy7zujDh0dClmu/vjtQ80e+wfkLXZy70Mb5C12cu9DG+Qtt9vMn5edDOv8Ls9K4cYOf11qVl99+++24/fbbsW/fPnz77bfYuXMnNmzYgA0bNqBZs2bo3bs3evXqhYSEhBoP8NChQ5AkCTNmzKhyX0lJCQBg7dq1+OKLL5CQkIBXX33VVr5gMplw9uxZNHaycD8nJwcAy1iClbfbdg0fHgVZrl3Q7V2AL5CWVlTrAL86ndEb+L9NRERERBSiuEe3I5/Ugrdv3x4TJkzAggULMHnyZHTq1AmnTp3CsmXL8MADD2DhwoW1Or+iKCgoKKjyx7p2u6ysDAUFBSgsLAQAJCQk2NZ+79u3z+k59+/fDwBo27ZtrcZG/lHdbbt0OgMUJQFAEhQlATqd52YN1seYTI1w2WUybr8dcFHU4HZfboMhBhZLMoAUWCzJMBhiXD6ntTO6O9bO6A1JTeaPiIiIiIITO5c78mn3cq1Wi27duqFbt274448/8N///hd5eXm2Lbxq4sMPP3R535w5c/Dtt99ixIgRuOWWW2y3S5KErl27YtOmTfjmm2/Qo0cPh8ft378fx48fh0ajQefOnWs8NvKf6mzbpdUmuewELkmnq3QC12g0ECK+ymPGjQO2bQNuuw04csTxuZxln3U6HSyWBMyfD8ydK50/j4RJkyIxdmwkNJo8h873ABAW5m1n9CJ46PFXL7iaC3fzR0RERETBTT571vY9g24fZbqt8vPzsWHDBjzxxBOYNm0a8vLyEB4ejvbt2/vyabwydOhQaLVa/PLLL1i3bp1tHUFubi7mzZsHAOjXr59X3dCp7qnBqftsb3q6AoNBg0GD1CD26FG12Zm1E/jgwVooSrzteGs2VYgkp4+ZNg2YNAlYsaJqxttZ9tliScCgQRKmTpUczjN1qoTBgyVYLFWXVZhMpRg1SkGnTs6vqVMnYORIxSfr1EOBEPFezx8RERERhQbN6dO27xl0+yDTbTQasWvXLnz33Xf49ddfoSgKZFlGx44d0bt3b3Tt2tVjh3B/SEpKwoQJEzB37lwsWbIEn3/+OWJjY3HkyBFYLBZccMEFGD16dJ2Pi7yjBqfRWLZMxp49Ve/v1AkYNUogI0NyuxZ72TIZY8dGwGiMQkaGjEOHZCQmwu1jvvwSuPlmYPnyitsrZ58NhhjMn+/+PIsXAxMmxKCkpBA6nQHl5ZGQZRlms8AXX1iwZImEWbPUYLNFi4rO6JJ02vlJ6xlv1tIvWyYjLS28wXwIQURERFQfsLzcUY2CbiEEfv31V3z33XfYvXs3ysrUX4hbtWqF3r17o2fPnkGRQe7Tpw+Sk5OxevVqHDhwAMeOHUOTJk3Qs2dPDBs2LCAfBpD3JOk01q+Px7Jlaulx5eBUURTMmuV+DufNkzFyZCwGDVKD88xMYOJE98+7cCEwZ05F0K1mnyWUlUUhLEyCyVSKoqIIzJ1btSu+vblzJYwcGXF+m7DK5dMKRo8WGDHCCECGxaLYOqM3FHXZLI+IiIiI6g6DbkfVDro/+ugjbNu2DfnnNzuPj4/Hddddh969e6N58+a+Hp9b999/P+6//363x7Rr1w5PPvlkHY2IfEldy5uDtLRwDB8eBY2mcnCa5LHZWufOwNKlFRnphAT368QB9f7ERKBNG+D11wU6dpRw/LiEM2f0KCvTokuXaEiS5NV5tFoJf/yhRVYWkJ3tWD69bBmwfr2AEDmQZTSINdz2gqWTu30VgqIoCAsrhslU++3aiIiIiBoqh6A7nssFqx10Z2ZmAlC3DLvqqqtw0UUXQZIkFBcX2zqCe9KuXbvqPi01YEZjGWS5DELAITj1ptna3XcD48ZVZKTz8uBVg7bmzQW+/lrCRx9JeOgh2DVbk9GihYyEBOHVeQoLJYwZ47xJW0Mvn65OszzZp90nVGziRkREROQfzHQ7qvGa7hMnTmC5/aJXL0mShE8++aSmT0tk400n8FatBI4erQi6lyxRA+Bp01yfNz1dTavedJPjmm1rs7X164GNG4FJkwSmTnVdYj5pknqc/eNWrACuugqwNjVvyOXTge7kbm3iVnmO1SoEGevXxwPI8f0TExEREdVzDkF3ECw7DrRqB90JCVU7MhMFgjfN1gwGx8z2ypVqxnn9erhp0AYsWOC+QdvChRLGjhX47DP357Ev6nDWpK0uyqeDlTfz569O7mziRkREROQ/1qBbadQI0Pp0l+qQVO1XYM6cOf4YB5FL7tbcVjRb02D2bMmu2ZrAyJEW6HTFSE+PtmVTTSa1xHvFCjUAXrgQThq0afDee+7HNG+eWrq+dq2aPZ87t+I8kyapAffw4UBJiePjrE3aVq9Wg++77waE0EBREmq8lrjy6xMZaURxsR45OYDFEh90a5R91cm9Nmux2cSNiIiIyH+s+3QrcXEBHklw8MNKSSLf0Gg0kOUkZGTEokcPPZo316JHDz0yMmIhy0nQaDQAAEkC2rQRWLAA+OEHYMEC9e8AYDaXVdkX+8gRtcT799+BDz8Ejh8X2L7diLS0fChKjq3ZmTtHjwIFBRL+9S8gLAzYtEld971pk/r3du3UsTh7XLNmwPffA+3bq6XuzZtLTq+ruq9Pjx5a5OToMX9+JHr00CM5GTU6ryvWfc6BJChKAnQ6Q7Ue73w+dVi8WMIddwjs3GnE8eNmh7lwtqba2/eFO9Vp4kZERERE1WAyQS4oAMD13FbM9VPQ8mbNrSShyjEqGZ06qcfIctWtx1JSgK5dFXTooGZThbDY1g0LYUGLFlqPDb4OHVIz2ZMnq3+s25G5e9yFFwKNG6tZ7tquJbZ/ffR6NZAfPx746aeKdea+WKPsq4Zj7ufT+07uvliLHegmbkRERET1lZyba/vewqXJAJjppiCl0xmwdKn7NbdZWTKWLtV4XJer0eggRA7S0vKxfbvnbKpef87WTM2Vhx4CPvjA8TZrkzZ3XnnFcQszV2PW68Pdnqfy63PzzWrTttqe1xlrkDtlivqBhf22Z4MHa6EonreB8GY+a3LdNT2P2sRNcXuMtYkbEREREXlPc/Kk7XslJSWAIwkeDLopKHmz5jY8XMbs2RL0euD229VM886d6tfbbwd0OnVdbllZFADr1mN557OpeS4bZKkNviwOJen2OnVS14Xv3u14+8qVwA03wO3juncXePddt5flMGZXKr8+o0er68Vre97KfBXkeruGurrXXdPzqHOsuJ0rfzVxIyIiIqrPNNnZtu8tDLoBMOimIOXNmtuYGHU9t3V99MSJQPfu6tf27dUu5ZJUs3W5aoM2M2bOFEhNVc+Tmgq8/LLaRO3114G0NMfHWJu0zZkDPP88HB43c6ZAZqaARuPdenFPY678+iQk+Oa8lfkqyPXVGmpfrsWumGOl0lwpyMw0u23iRkRERETO2We6LcnJARxJ8GDQTUHJuubWnXPn1C7gEyeq+2Dblz5Pm6Z2EV+5Ul2X64y7xmAWi+V8SfpZbN9uxLFjaqO2//0P6NkTmD/feVbb2qSttBTYvl3g+HELtm8XaNNGoGdPCT/9JHm8Luta4uq8Pnl58Ml5K/NVkOvNfNbkumt6HsB+jr1bdkBEREREnjkE3cx0A2DQTUHKmzW3sbEKNm0SbkufN28WiIpy7MpVne7XQqhNySRJQXKygHS+R5m7rPb06QrS083Q6XIgSQLDhkkYNkzG3397t+7bm7XElV8fX523Ml8Fub5aQ62ex/16+/R0Ua3r9HbZARERERF5JrO8vAoG3RSUvFlzm5IiYe5cyfkB582dK6GoSO9wmzeNwSoH5s2aaTB4sISLL1bL1lNTPW89Jsv6KuuhV64Ehgxxv+7bm7XElV8fb9aTuzuvq6y/r4JlX66hHjbM/XUOHerxFERERETkJ2ykVhWDbgpantbcajRKtUufvWkMtmKFDCDBaWD+zDNq2fqqVeo2XRVbj5khyxWZUp3OgLKyWFx9tezQ2E2S1MctXAisWKHu671zp/p1xQq1I7q3W1TZvz4pKcDw4WrZ+/Tpwus1yp6y/opi9Fmw7Is11OXlkbjzTglz56rr652tt09Lk6rdMI6IiIiIfMMadCuNGkEYDB6Obhi4TzcFLXVNbQ7S0sIxfHgUNBoZFouaVTUay6AoCWjRQlOtvZa9aQz2558yPvrIfdn6t98KHD+uoKzMgshII4qL9ZDleEiSAlnWICNDctjTetw4NUP+8cfA9u3AlVcCBw6oQbL1mAkTgFatgLVrNbjppnCPgayr12fiRAUjR+qh1cowmxVERZWgtLTQ6Tm82fPa2T7nLVqoGe6RIxWvG455mk9vyLKMEyfUQLtNG2DBAiA2FigoAPLz1WNOnFA/aBHuq9CJiIiIyNeEsHUvZ2l5BQbdFPTUNbdlEELNAhvPL9FWS5/VbLQr1tJn62O8aQx2ww3AxInuy9Znz5YwfLgFWq2MDz6IwOzZMnJygB07gPHjUSWInTYNWL9ebfyWm+v8mKefVu+fP19CeXkMJMm7QNT6+siyBpIUjwULtHYBv4z09AiMGhUOSTrt0BxMpzMgI8PzdmBpaTpYLDUPlnU6A8rLIyHLMhRFgRDF59dQO86nNxRFwerVVV8/q06dKprnyXLV5w4LK4bJVOr9ExIRERGR1+QzZyCd/+WOQXcFlpdTyKrJOmFvGoMlJ3u7/ZbOoQT9ppvUwNpdELt3L7Bxo/tjNmwAwsI0zg9ww5u16vaqux1YdRuOVadhnbciI41eNc+Ljjb5/LmJiIiIyD2Z24U5xaCbfMZgiIHFkgwgBRZLMgyGGL8/Z3XXCXvTGEynE1517M7JcQyeR49W12q7Ex6ulpS7s3ChuuWYt3Q6A7TaJCxdqvGYtdbrw223+XLPa2eq+yGAN4qL9V41zzt3LsLnz01ERERE7nG7MOcYdFON2He7FiIRYWEpWLAgEj17ymjeXELPnjLmz4+ELKdAp9P5bRzV3WvZm+x4s2aet9964AHgvfccg7+EBM8Z8pgY77LoWi8Wfthnkn/5RYvZsz2VxMsODcZ8ued1Zd40rKv8IYA3vP2goLTUfTVBTZ67ruh0Blgs8cjJASyWeIf944mIiIiCGTuXO8egm6rFWclw9+46zJsn4eqrJUhSRVZx6lQJgwdLsFgS/D6u6pQ+e8qOG40mL7b1Upt42cvLg8cgtrDQ8zEtWgCKF3GufSbZ22DePmvtq+3AnKlu6bq3vP2g4NCh6n0AEQwq/2wlJ4Ml8eQ1V9v+ERER1SUNy8udYtBN1eKqZNi6ldaKFerWWFZ79gCLFwMREf4vNfeWp+y4VluMrCwFc+YAzz/vuC3V888Dc+cChYUClf8dWbLEc4a8rEzgoYfcH/Pgg0BYmBoMu/pFunIm2Rrw6/Xq9mSZmepWZPbblVXOWvty7+zK/FW67t0HBQIffOD75/Y3f5TjU/3nj94JRERENWXtXA6wvNxecP3WSUHNm5LhL78Ebr7Z8XbrGttg4yo7bjKVYuhQBenpwO+/A3PmAD/8oH79/XfgoYeApCQF6emKQ5A7eTIwdqz7DHmXLsCAAe6PufZawGSyuP1Furw8yiGTvGQJ8MgjwPffA+3bAxMnAt27q1/bt1e3K3v66apZa1/sne2Mv0rXvfugANi92/fP7U/+Ksen+o8f1hARUTDhmm7nGHST17wpGV64UG0oZk9do+y+3NcfalNuKUmnsXq1GV27Ctx/vxrA3n8/0LWrwJo1ZpjNebjzTgW7dqkfMuj16i+7hw6p237NnAmnQaxOV4jfflOwZg0wfbrjMdOnq93PGzcWkCSd21+kNRqtQyZ5/Xrg1lvVIHvaNDg8Zto0tQphyBCpSta6umviveUqI23/IcXmzQKSJFe7DNbTBwU6XSEmTfJP2bw7tXm/+ascn+o3flhDRETBxtq9XDEYIGKCp9I10Bh0k9e8LRlOTHS8rUULwGwW/htYJb4qt5QkoFcvgc2bgcOHgc2b1b/bE0LNfo8bpwbmaWnABx8AgwYBO3eKKkFseXkxrrlGwi23AD//7JhF//lndduxkhIJCxZIbn+Rzs11XBs+ZAiwaJH75mEffwyXv3xXdzswT5xlpFNTHTPx7dpJ6N5dW+158fRBQXl5sd/K5p3xxfvN353kqX7ihzVERBRsrJluJSVF/WWaADDopmrwtmQ4N9fxtkmTBKKjS/w3sEp8UW4pSfHIztZi40YZ/foBLVsC/foBGzfKyM7WQqdLQGGhBuPGOc8sjxoFFBcDOp10fkzqVzUzBezaBSxfrgbL3bqpX5cvB378ESgpqdqkrbL33pPw0EPCljl+/nlg4EDHNdyVzZ4toby87j5xtM9It2kDfPqp80x8Tctg3X1Q4K+yeWd88X7zZyd5qr/4YQ0REQUT6dw5yMXFAFhaXhn/JyavedPEatw4dX2xVadOwJgxQElJoZ9Hp/JFuaVOZ3AbUN9zD2Ayyfj4Y/fZ6E8+kfDPPxqHrKfRGO1xay9F8dyJfMECNav+449q5rh/f3W9uP0a7tRUx8ccPQpIUt01VXLMSJvx/feizspg/VU2X5mvynv92Ume6i9+WENERMGEnctdY9BNXvOmidXgweqaZnWNskBmpoBGk1dnY/RFuaUQ0R4D6rIyCe+/734sCxYATZoA8+YBWVkybrxRC1nWeAyos7M9byuWmqoG564+GHDWSd7brchqw9m6ZqOxDEaj4uU+4nE+3e7I12XzlfmqvNefneSp/uKHNUREFEzkEyds3zPT7YhBN1WLRnMWmZkC06eLSk3ABDZsEEhOVvDPPwLbtimYMKEYinISJpOpzsbni3JLo1HjMaC2nsfT/SdOVGSf334byM/3HFBv3Ag88ID7Y958U8HSpe7XcFfuJD9+PBAW5psMb2We1jXrdN7Ny/HjUkhtd+TL8t66LImn+oEf1hARUTDhdmGuMeimarFY4jBsmISff5YqNQGTMGyYBElSIMRJaDTZdVZSbs8X5Zay7DmgPnHCc/BsXd9un30GJI/7dCcnq43Y3P0ifcUVksfMsbWTvF4PTJ0KpKUJWCyyTzPJVp7XNWtwwQXuz2H/eoXKdke+LO+tXBKfnQ2/lMRT/cIPa4iIKFg4lJc3bRrAkQQfBt3kNev6VXdNwAK9PU11yi1db/HkOZBavhxIT3ffkb3y+vY9e9RmYmPHCrcB9YABwLBh6ocZzz/vfOsxjUbxKsPasiXw229A48ZAr14SmjaVnWaSa7PdlXfrmoFZs6rXDyAUtjvyR3mv0VgGjeY0kpIAjeY0s5TkVl31LyAiIvJEtgu6Fa7pdsCgm7wWCtvTeFNuOXq0ArM5xmUptF4v8OCD7p+nZUt132t3z3P99cCqVY63L1wIlJUB779fNaB+/nlg7lzgttuAgweBq64CSkuBrVuBY8dElV+kPX0wcOGFQHy82s38scecdwwXIr7W2115976QcOWV1X+9Av1+8oTlvRQs/N2/gIiIyBOWl7vGoJu8Firb03gqt1QUuC2FNpk06NdPzeLffru6DdfOnRXbcf3738Add6hbdM2bB7z2muvgufJy9qNHAa1WQZMmZlxxhcCnnwIHDgDffAN06ACMHKkek5oKPP20um/35s0K9PqzDr9Ie5NhnTkTHtd9f/yxBm+95d12V66y4d6/L5Tz8yKq9XoF+v3kCct7iYiIiADN+UZqQqeDEh/cSwTrWnD/NktBJVS2p3FVbnnXXSWwWIBz5zR44QXn+1mrgSiwZYtaCt6xo9oIrXt39WvHjsBnn6nB4aWXAikpakZ5wQLg77/Vr7//DvTqBRw5UnVsLVoAZrMFkgQIIVBQAISHq8H2ypXAW29VrJP//XfgoYeAIUOqZkq9ybBecgnwzjvuX6vZsyX06uX8Pmt5d3h4hNtsuKIIL98X6nW3aSOq9XrV5v1Um7J5b7G8l4iIiKhiTbelSRO1SRLZaAM9AAodanZVzYq6Yl2/ajTW4cBcUMstyyDLGkhSPD74IAKzZ8s4dgxo3lxdQ7xtm5phtQ/43n1XwtatAkOHOm4bdvSo2pDss8+ANWsE5sxRS8ytx9x+u9qlfPly12NKTxcwGDQYMEBje1xqqhrgb94M3H+/+jwtWqjHvvWWxWWmVM2wxmPZMhmzZ8u2x40bp5Zqnz3rXYf1xETX98+eLWP48FgMG1b1tZgyRcayZTK++MKC9HTF4/ui8nV793rV7P2k0WggRDwyMmSHOU9P12LUqGhI0mmfB8PW95sQ6v8zwfAz4KC8HJpjx6A9cgSaI0egycuDVFAA+dw5SOfOQS4shFRYqP69sBBSSYl6IVotIMsQWi2g0Th8rzRqBCUhAZaEBCgJCVDi46EkJsISH6/e3rQpRKNGgb5yIiIi8reyMshnzwJgabkzDLrJa2p2NRrLlsnYs6fq/cG6ftXaWbty0DhtGrB+vbqf9VVXVZQ2d+4MfPKJ+7LsFSuA1q0dj1m5Ug3i16+Hy9fnxhuBHTuq7gGuZoDVzG9sLFBQAJSVuW/UpgaNOUhLC8eIETEoK9NAkiTs2aNmzmfPVoNwd4G3tWO4K0ePquvK3b0WS5ZIGD1aYNky19c9apRARoZU7derpu8nV3Nu/aBg/fp4ADnVPm/Qs1igPXgQut9+g+aff6A9fBiao0ehPXIEcnY2JOH+PeWXISUmwty2Lcxt28LUti3MbdrA3LYtlCZN1Dc+ERERhb7jx23fKgy6q2DQTdDpDCgvj4Qsy1AUBWFhxTCbnQc61uxqVpaM8HAZMTFAYSFQVqagSxcl6Nav6nQGZGS476xt3c/amnG9+25g3Dj3wcDs2RIWLHC8zWRSs+YrVqjnXLgQDtnnYcOA4mIJ4eESoqKAl15S14VHR6tbhFUdo4xOnTwHiEZjGSSpDJGRSbjxRi1atVLL1Nu0Uff7fuIJ19dxzz2OHcMra9ECOHTI/Wsxa5aMESOMWL9eVMm6p6crGDVKwGKRMGuWDL1efa1HjwYSEtQPF5YuVTP9CxbA4XEjR9bs/eTNnC9bJiMtLTzoPiCqFrMZ2r/+gu5//4Pu11/VP//3f5BLSmp8SiHLEDExUKKjISIj1UX+ZjMkiwVQFPV7RQEsFkgmE6SCAo+BvCY3F5rcXITt2OFwuxITA/O//gVj584wdu0KY+fOXP9FREQUqo4ds31rYefyKhh0N2CeSnBdkSTgwAEJs2fD7jESunSpw8F7yZvO2gsXqmuorUF3q1YCR4+6DzSPHlUz0pUdOaJmzW++WT1nx47AL7+oge1LL6nN0UaNAv74A/joIzUbnZjoPpPsbYCo0ZzFmjUJWLwYuP9+CdnZ6vrwTp1cZ5Jvvx24+GLX50xPF/jgA8+vBSCfX9ccjuHDo6DRyLBY1JLyjAwJvXvLkCTg+++BjRvV9fH2Zf633qqum7/oIgGLxXS+pLxmAbG3XfaHD4+CLIdQ0F1aCv3u3Qjbtg1hP/4I7W+/QS7zbvyWxo1hadkSlhYtYE5NhaVFC1hSUqDExFQE2bGxEBER1cs+WyyQz56FnJcHOTcXmtOnbd/LeXnQHj4M7Z9/QpOXV+WhcmEh9FlZ0GdlAe++CwAwXXihGoB36QJj166Q23ZAuTHK4QNBk6nU+/ERERFR3bDLdLO8vCoG3Q2YpxLcjRur8xgJy5Zpg65s19vO2tZ1zZ06AQaDd2XZBQXO7zOZ1ADe2hBtyJCK+xYuBO66S816//ST2hF94kT34/M2QLRY4jBsmITWrdXnTUxU13V/+CGwdi3w3nuOmfcbblCz7Jdd5q68W32cO9ZmZ+o65op1zVptkm0N9+efA6tXA+PHw2WZ//z5gMViOt+l3f1zulOdLvsBqLb2nsUC3c8/Q//ddwjbtg36rCxI5eVuH2Ju0QKmSy+F6bLLYP7Xv2wBtojy07ZrGo26ljshQV2g74J05gx0f/0F7Z9/qn/++gvaAwegtfsPGgB0Bw9Cd/AgIpctAwAURSfjW8sAfFIyFL81uw7jJ8f6bU0+ERER1YJ9pptBdxUMuhsob0pwlywB7rwzHEZjqdePCbayXWvHdW8C6Jkz1ZJmna4Y6enRHhqDCRQXA4DrrOC4cVVLt48eBcxmgZ9+Uh+XkOBdszNPAaJ1bnbtAnbtcmxOptOpmfc1a9Tv//lHHdeBA0CPHgJz5khOy+Gvv14Nhl97TcGwYdVrnlf5vXLgALB3r/uM/ubNAhMmGFGL6mgA3s+59YOCYCLn5iL8iy8QvnUr8MMPSHD1yQ4Ac8uWtgDbeOmlMF16KURcXN0NthpE48ZqBrtrV4fb5dOn1Wz3rl3Q79oF3a+/QrLbNy7qXDZuRQZuRQbKj+vx9ZR+WPT2UNy9+gYgWVf5aYiIiChQWF7uFoPuBsqbEty33gJuuy0Sslzq9WOCrWzXu47rAldcYcGVVxbCaCxDeTkwalSkh4ZxFgAat6Xb11+vlpTba9EC+OuvikA9L8+7rLqnANHd3LjKvG/ZAowZo5ahW8vhExPVxmrWcviUFAnbt6t7lrdqVbEWOy9PPebQIefNziqPp21b4L77XI8fAObOlTBqlL7WgXCoddmXT5yAYeNGhH/+OfQ//uhyjbS5eXOUX3UVyq+6CsaePdXscohT4uNRdt11KLvuOgCAVFoKw29/4Ld39+LcF9vRC9sQjSIAQBiMGIiNGHhkI9AJMF1+OUr790fZoEEw/+tfgbwMIiIism+k1rRpAAcSnCQhgrrAMmjl5ubCZJeRCT1JaNbM/WcukgQcP26GEDm1eEzgyXISBg/WugyOMzPNUBTH8Wo0GihK1e247Bt8ybIMi0VdQz13rlQlS1x5KzIAmDlTYNcuyZaJtm6bNW2a6/HPnKkgLS3fQ/WAOjeVG5VZg+OVKwGzWQ28hw9Xr+OOOyQ0beo8U29/niuvFLBYgN271WUEhw6pa7EnTRIYOxbQaPKc/Cw4vld27lQDd3fs3zvOmvtVXsvr7hhZTsHgwZKbORdQlJMez+MvmiNHEP755zBs2AC9q/R/fDxKe/RAea9eKO/VC5aWLWvV7TsQ11kTipKAHj30OHoU0KMcV2MrhmIdhmIdWuCY08cYL78cJbfdhtJhwwKe7ZckCSkpKTh58iT432vo4fyFLs5daOP8hTZJkpBy443Arl0QkoSThw6p5ZUNgE6nQ6K7/XfPC7LiSqor1hJcd6wZ1to8JhioHdfNmDlTQWqqGrekpqrBbGam2WmHbIvFcr4xWD62bzfi+HEztm83Ii0tH4qSA4vFApPJBEU5iQkTirFtm4LjxwW2bxcoLQV69aoacFvXSO/eXXHbypXq2upOnZyP3dttsxRFQbduaqOy9u3VdeLdu6tf27dXt+bq1g1o1kzYrsNiMTmdz9RUx/M0ayahRw8J//ufhGXLKjLzU6dKGDxYgsVSNcip/F6xZvTdqcjoJyEjIxY9eujRvLkWPXrokZERC1lOgkajgUajcXtMWFgktmwRWLMGePVVOMz5q6+qZfbffCMQHh7h8bl8STpzBpEffICEG25Ak+7dEfvii1UCbtOFF+Lcgw8i94svgJwc5M+fj5LRo2Fp1arGAben18vX11lb9mvyjQjDJlyHBzAHqTiCK7EH0/AcfsIVDo/R792LRv/5D5KvvBJxEyYg7Ouv1U+ZiIiIqG6cLy9XEhMbTMBdHcx011CoZ7rVNbexbktw33wTuPPOs5XWdLt/jHdZ2cDQ68NRVlbRWbs2HbJd8ZQhNxjKMW9eBKZOrQigUlOdbzNmn1X31DRKpzOgoKARRoyougc4oAbvn3wi0KjRWds1O5tPvV4NuCdOdL7+ulMntQzdfl/zmTMF0tLOOryWlc/tbUZ/zBhha77m7LnXrzdDklClmZ/jMQLZ2RLuu0/dS330aMey+X/+Ua+hSROBYcNcv17r17uu2PA6a2yxIOy77xDxyScI37QJkpN6dlOHDigdNAhlAweqZdKS5NNP/GU5ycPrFVyVKfaZbldSU4GdK/5CxJcfw/DZZ9D/+muVYyxJSSi95RaUDB9ep+XnzNaENs5f6OLchTbOX2iTLBaktGoFKAqMHTsi7/PPAz2kOuNtpptBdw2FetANeC67/uILwGRy/MevJqXaDZG7AN9Z6XNkJPDyy+p+3ZGRAmazQFRUCUpLC716PoMhBgsXRuKxx1xnQ994Q2DcuGKUlFScs/J8ehMcP/888PvvFc3aUlOBHTvMkCTHebc/t06nZtsnTXK9Bn7DBgs+/ljCI4+4/lBn3ToFBw5ImDLF9XXOnCnQvLmEESPcX8O4cepxrs9T9QMk6zZ7S5dW3mZPwahRFR+QaA4dQtRnqxD2yXJos49XObfxsstQNmgQSgcOhOWCC6rc76tfPkLxg7KajFn7+++I+PRTGFatcro9WXnPnigaPx7l/frB393z+ItjaOP8hS7OXWjj/IU2zcmTaNK5MwCg9PrrcXbhwgCPqO6wvJw88lR27axPU01KteuCTmeAoiQASIKiJECnMwRkHFbq1ll5ECLn/BZY9oFbHjIzBaZPF0hNBVq2BL77DigtFbjmGrWcu2dPGR98EOF1+W9RUQTeftt9+fHbb0s4dy7C4bbK8zl6tJptd2fhQvU4q6NHAUmqOkbrudetU7BhAxARoXZDt1639b0zfbpAZqaAJFkwa5YMvV4N/jMz1bXgmZnq33U6IDxcxuzZkttjZs+W0KgREBWlNgPcv18t9d+/X/17RIR6DcXF7l+v2bNllJU5brVl3TJvyhS1ikGIim32hg0S0K/8Cgm33IImvXoh8q03HQLukshEFN83GXlbtyJv40YUPfCA04Dbl7xtflj5OgPJZCrFqFFKtZZcmC+6CIXPPYdTWVk4vWgRSgcOhLArbQvbvh3xY8ciqU8fRHz4IaTatsgnIiIiG83Jk7bvFXYud4rdyxswtWQ5B2lp4Rg+3DErazKVA6i6x567xwQiU2bNPGZkVM48aoN2P1+1QuIkJkyIwciREdDpJAwaJNm2EQMc90v3Zu9zjUbyausxrVZy2Hqs6nzqcPSo+2DUfl9zQC2FF8L5kmNJAg4ckDBvHvDxx2qTudatpUqd0iWsXg2sXq2zlbdv3KiWuFvnc9w4NVOu06nndHfM8OFA06bAH38AH30E9O9fcczEiWrwPWIEPHYur7xVm6st8xKQi3vxHib9NBdxP51wuM8MDTZgED7A3fi8eCA67tZh/bNmoI7KuUN1z3L1A5t4ZGXJCA+XERMDFBYCZWUKunRRXH+4p9OhfMAAlA8YAPnMGRhWrULkokXQ/vMPAED7999o9J//IOb111E8ahSKx45lh1UiIqJasg+6uUe3c8x0k9usrC8f4w/uMo+DB2uhKPEBGZc3SkoKER5egKVLhdv9qz/+WAO9vonbDL7FIrxqVGY2O4+srPPpqrla5fPk5lb8ffx4QKeret6KuZHQpYsaJO/dqwbN1gDd+v1PP6nl6pmZamA8bRoc5nPaNLU0PT5ebYTm7pjVq9Xjhg0DnnrK8ZinngJuvFF9rlOnPF+nfVPAylnjS/E/vI9xOIoWeBlPoxkqAu4/0B6P4TU0xzHciLVYh2EwQ2fby16vD3f/5D5ibWjnrjIgGJsfAhUf2IwbpzYFHDdO/bu3lMaNUXzPPcj5/nucXrQI5T162O6T8/MRPWcOmnTvjkb33w/t//2fPy6BiIioQZCzs23fM+h2jkE3hSydzoClS6tmHq3qOsCpCW/Kf99+W8LOnRq3HaejokowaZL7VOWkSQLR0e7LatU9rt0HYOPGqQ3JALXUd8AANei3V3luRo9WewS4665++rSEzEz3H0CsWCHwzz/ujzEaBRYvdn/M0qUCzZu7f72se3lbybKM40ctGIq12IK++B86Yhw+QDjKAQAKJGR3G4YRiVtwEX7HG3gMp1C1xKouy7nDworx9NOK29f96acdrzMY2H9g4/hhmlT9D9NkGeUDBuD0p58i58svUXLbbbbSc8lsRsSaNUgaMABx48dD+/vvfroiIiKi+ktzoiLxwKDbOTZSq6H60EjNnVBoaOFtl+Pt242Q5arNlYKDd3uf//BDxT7XrjpOV2dvanc8NcubO1fd+iwtTd2P/OGHgRUrHF/jynPz44/qV3dd0VesAK6+Gh7nc8EC4LrrXB9z4ADQr5/n82zbJnDTTe5eL7umgEYjwj/7EgVT30Br818OxxYgBgsxDv/FA/g06wKc7yPikjd72fu2e3nK+eULVe+rzvuirtRF8zc5JweRixcjIiMDmjNnHO4rHTQI5yZPhrlDhxqdOxT+7STXOH+hi3MX2jh/oS1u0iQY1q4FAJz6/nu/96wJJmyk1kAZDDGwWJIBpMBiSYbBEBPoIflNddar+pM3TdycHaPTGWCxyNUu53aVwbc2aFuzRmDTJrWMeNMmYM0atVGZRuP6gwf78QmhIDPTgpkzHRuevfyyuq+4Tqc2JPv9d3U/8ltvrZoprTw3sqxmut1ln81m94EyoN4fG+v+mPBw786j1aofXuzapeDAAbXZ2oEDwP79CtasERBCglIcieiMJUjq2RONH7vPIeA+gLZ4AO+gOY7hUbyJQ7gAOp13Zf51Vc6tVhx4Wr4gAlIN4urnpi6avylJSTj32GM4tWsXCl54AZakJNt9hg0bkNS/P+ImTIB2374aPwcREVFDYV9erjDT7RSD7npCp9NBllMwf34kevaU0by52gF7/vxIyHIKdPVwk3rrelV3/BngaDQayHISMjJi0aOHHs2ba6uUgLs+phEKChrhvfdkjBvn/nnsy7mt3AUd+/fDYR3s/v3Vu4abb9ajqEhGmzbA++8Dhw8DH34I/O9/QNu2wJVXAkOGqOuiL7usaidpoOrcmEzqudw5fBhezWdBgftjysq8O4/FIiBJGnz9tYR+/dQu8v36AatWSZCLi7Cq+0zo27dD9NQnoLUrm9od3RcDsQHtsQ9z8ACKEA1AzRo3a6Z4LM+vXLbuT8HYvdybn5s6+zDNYEDxuHE4tWMHCqZNg8Xuk2pDZiYS+/dH3H33Qfvnn7V/LiIionrK2khNiYuDMAR2B6FgxaC7nrBYEjBokISpUx3XQE6dKmHwYAkWi5P9v0KcN+uP/RngeNPEzfUxEm6/XcKQIcDAgXC7PdL11wOrVjne7izosL4HnnjC8T3wxBNV3wPWLKOiJOGPP7TIypKRnW3dcgsYMULCsGESBgxQs9kREcBFFwEpKRWZ7+efV7fecrbtceW50Wg8Z58/+ABIT/e0zlp4DLrz8uDV+vaICKnKz0zR0TMom/o8Ii9uifsPP4EkpaLbWln/QTizYQOa79+E/jOvR4tU2WHLvA0bLDAaLRg1SqrWdlf+FCzVIPY8/dy4qv6wbwa3ezdgNsu+2xrQYEDx+PHI+eEHFDz3nC34loSAYf16JPbrh9gnn4RsX3JCREREgBDQnM90W7hdmEsMuusBgyEGH37ovnR38WIgIqJ+lZrXZD9fX/GuiZsGu3a5P+aLL9S5mTNHDWLty7mff15dP33bbWqm2F7lDL6374HIyFiHLGOzZhLGjKloqnXvvWqXcfvzHDkCXHWVWk4+Zw6wbx+wbJn69y5dgCVLqpa6V56b3FzP2efdu4FRo9x/ADFyJNCqlftjdDpg7Fj3ge+YMWrm3Xqd0SjEc5iGf9AK0/A8Yi1nAQBCkrAcw9ERezH3hnVQunaDEDlIS8vH9u1GHD9uxvbtRowZI/DxxxL+/W89unWTMH9+1f3IA7GXfaCrQSrz5ufm559FlQ9fUlMdm/B16QL07Cm7bCxYU8JgQPG996rB97PPwpKgflAlWSyI/OgjJPXqhai33wZKS33yfERERKFOPnMG0vl9WNlEzTUG3fVAUVEE5s51v5XO3LkSzp2LqKMR1R11P18zZs5U6jTA8a5sV0J4uPtjFi5UM9n9+qlrlb/6Ss36rVsnbGumjxyp+rjKGXxv3gPvvy+htDTCaZbRut3WlClARkbVx5pMajn5kCHAtdcCZ86oW3Pdcgtw6aUyjMa4KuvZ7edm40Z4LKOfNEmBXl/gcj43bLBAUQQeesj9hxQPPQQcPKiOb/p0x2OmT1e3HCsvl/Df/0owoART8DoOoTWm4XnE4Jx6vdBiReRYHNrwB27HcvwPHR3KsDUaPYTQQggNtFodBgzQ4JFH1Nf08GG1tP/nnyV8+CFw/LjA9u1GpKXlQ1Fy6nTf+LqoBvGmp4GVNz83kyfLDh++6PXAp5863ybOX1sDCoMBxRMmIOeHH1D45JNQotR5l4uKEDNjBpJ694Zh5UpACb6t1oiIiOqSbLdHN9dzu8agux7QaCQvG0d5v8dtqLBYLE4zj/4OcLwt2/XU9OvoUaBZM2DLFiA/H+jfH7jgAsBikfDXX1Uz3IDzDL4374HOnYGlS91nwz/9VM0iehpzSkpF5nHcOKB5c6nKulz7uXnySSMmTBAeqxLKykrcZpJfeUXGwIGOmfcfflC/Wj+kGDgQeOcddWxhYWozuaNH1dc4LAxo1w6QzUYMPjoXf6ENXsfjiIfawdoELd7FBLTBX7i9ZBF0l7RzuG51PXJF74RHH5Xw3ntVO4NbP6S45hpg2TKB8PCigOxl789qEG/WZlfmzc/N338DWq0FmZkC06cLjB9ftfrCnj+3BhQRESh68EHkbNuG4jvvhDi/lkJ74gTiHnoICYMHQ79zp8+fl4iIKFQ4bBfG8nKXGHTXAxaLdx2Tzeb6uwWDENL5r45/9xdvy3Y9rT++8EKgcWPHLJ7RCNx0kxpIvvQSvMrge/MeuPtuNfvuzjvvqMd5uq64OO8zj0ZjGWQ5D5KU43VVgvUxQuRAq5VtmeQPPwTuuktt4GbNvHfr5tjYbexYYP16oKQEmDxZDb579AD++AN4dLIFt5YsRvLV7TAX96Mpzjf+gIQM3Il22I+JeBdH0BItWjhWEatl2LLDOvDRoz03iKvrRmWV+asaxJueBpV583Nz4YWA2azBsGESfv5ZwkMPqRUh7vj7NVYSE1EwfTpyN29G2TXX2G7X//ILEm65BXHjxkHj6dMEIiKiekhj17mc5eWuMeiuB6KiSrxqHBUdXVJHI6o7Ncm2+YJ3ZbsCZWXuj3nlFbUzeeUsnnUd9a+/qqXmx49b3GbwY2KMHt8DLVsKr7LzLVu6P2bCBCArq/qZx5pUJVReAzxkiNpUzl15+cqV6nH2jbdWLBfofHwtDsdcisUYC92xf2zPsRI341L8ijHIwCFU7Cs5aZK6hZhVerrA7t2O152Q4N32ZHXZqKwyf1SDeNfToOp7wJufmzffVLB0KbBrl/pBytmzwfMam9u1w5mPPsLpZctgstvH2/DFF0i8+mp1vXd5ud/HQUREFCw0duXllqZNAziS4Magux4oLS3E2LHum0uNGQOUlBTW6bjqQk2ybb7gXdmuBV27uj+mUydg/nxXz6EGHUOHSrBYLJDlPJdlwOfOybjzTvfNwyIiJK+y8zqd+/fS6NHA1KmOQe3OnerX22+3dkB3nXm0z2K7uyag6hrgO+8E3njDfXn5m28C48dXlL/PHbcHpd37Ivm+G9G88A/bucr6XIc72+/GrViJ33Gx0+u0dma3NnGbMkVyuO7ERO+2JzObNTAYAtvIsDqvuyc13YrMm5+bK66QHCoy8vK83QLO+/XV1VmH7kx5797I/fJL5L/xhm2Pb7msDDEzZiCxXz9g8+ZqnY+IiChU2QfdCsvLXWLQXU9oNHm2NZCOjaMEMjMFNJq8QA/R52qabfMVb8p2XR8j8MknAoWFvsniybKMBx9Uy6qdNQ/LzFQDeE9bco0bByxaBHzyicDMmZXfS8B77wGnTwNms2M36e7d1a/WLuiSVL3Mo6sgqPIa4NRU9fWwb+xmX15uMgGnTqnrtqeNO4rW09Kw4VRnXI1vbef4JbIHTq/8BncmfoHXtnR2+Xo9+CDQpIn9fFa97v/8R+34Xpl9YL5pE5CdLWHr1kjIcgp0Op3Xr0uwqs1WZJ5+bjQaxeHcS5Z4bsLnbTM4n1bGaDQoueMO5Hz7LYrGjatY7/3338C116LRxImQ7UruiIiI6iOWl3tHEkLU34W+fpSbmwuTsy5XARYREYNz5yKg1Uowm9WS8ppkuCVJQkpKCk6ePIlgfYsoSgJ69NC7/eU/NRXYvt0IWfbfhw56fTjKyqKg0ciwWBSnTbOcHQMApaWN0LOn+wDGm2tQlATk5Ojx4IPqFmM33KDurV1Sojah+uwz4O23gaZNBQYPlrBnT9VzdOoEZGYKmM0mh/Hl5Kh7eP/5J9C2LdChg9r0bfx45yXm1ux9kyaeX3eNRgMh4rF0qYzZs2UcOwY0b64GUaNGKRBCwb//XTHH+/erzebcvV6PjD+HWw9Ox+Vb3oQBFfPwJ9rgCczAatyEt94CrrtO3S6tdWs1q52YqG5ttmQJ8M8/avY8KUmBwZAPo7EMFksycnNlh+uOjFS3ULvxRthe09RUtSHdxo3qWmTrNY0bBwwbps6B2Xyy8rBtdDoDyssjodfrYTQaERZWDJMpuLao8sXPnqufm8rn1unUD3ImTYKb960ZipLjcdyynIRBg7Qu37fr15shhOfzOKP97Tc0euop6O0GqURF4dxjj6F47FhAq63RealuhcL/feQc5y60cf5CV2KfPtD99RcQGYmTBw6goc2eTqdDYmKix+OY6a5nSkoKodFkQ4iT0Giy62VJuVVtsm2+5E3ZrrNjjMYyhIcX+GRLp+hoBZs2CezYUdE8LDVV/Tp5MrB9O/DVVwKRkeUesvNVx7d1q4LBg9XzDB6sZtO//NL9mu7NmwWiooweXztPywMkSYPJkxW7411nPTUw417Mx/SVbdB9yyu2gPsM4pCOt3Ax/g+rcTMACX/+KSEzU9jWDVfOmP/4o3oN0dEltvmMjTVj0ybhcN1DhqgfaFjXmLdp43p7q2nTgHvuUZvrRURULTWvnIVNTkad9CeoichIzz0EJk1y/x5w9XNTed23yaR+kORsHX91msH5uzLGfMklyFuzBvlvvAHEq8ta5KIixD73HBJvuAG6n3+u0XmJiIiClhAV3cubNVP/gyanGHRTyPK2g3h11nrWNV9t6VRYqPdqr/b8fH21mmo5G1/btsC8ee6va+5cCUVFerfHeBMEffyxhLS0iq3GDh5UA93Kr1cfbMVPuBLzcR90Z9RMpRE6zMQjuBAH8TbSYULFeG64AXj7bc+vl/01FBRoq7zGo0era8ita8y3bAG+/db9BxLLl0swGiOq3Ofv/gS1Xcdsr7hYjxtucN9D4PrrPb8HnHH2nrM2Fvz9d9R47/OarkOvFllG6ciRwP79KBk1ynaz7vffkTB0KGJeeAFSaXBVLRAREdWUdO4c5JLzjZqbNw/sYIIcg27yG1/+ku+Mdx3EvVvrGUi+2NKpunu1V84yCiG5nKvK44uPr946dFfvA2+DoJISCV98YcGsWQo+/xz47ruKrGe3pkfwCUZgK/riMvxqe9wGw63ogD8wBTORj7gq501Orv5aeutrHBUFvPWWWup+xRXqBxC33KJ2VTeZ1G3X3FmwADAaHYN3f2Zh/dHhX5ZlCKFul+asi/zChYCi1LzKxNnPREoK0LWrgg4dzJDl6jeDq4vKGJ3OAIslHjmWeJyZ/gHOfv4lTBerTfokRUHU/PlI7N8f+h07avwcREROlZcDZWXqvqNmM2CxVOyjSuQn9uu5GXS7x6CbfK6utvHyVZY40HyxpVNN92r3Zq4qj69ZM++ey2JRPJ7bmyAoJ0fG4sUS7rhD4D//MeL22wUee7AM7T59Cdvy2mMEVtiO/yOyE/Izv0fWE5/ib1zo8ryyXP2O2BaLwI03qvt9l5Soa8ubN3dsIKfReBfMy5X+5fVnFtYfGXStFli3Duja1XkX+S5dgA0bar6M2R/bnPmzMsbV0oAPfu+P019k4dx//gMRFgYA0P7zDxJuuw2xjz8OqbD+Lv8hIj+xWKD96y+Er12L6FdfReM770STTp3Q9IIL0PTCC9G0dWs0bdkSTVNT0bR5czRt1gwpzZsjpWVLJPbujUaTJyPio4+g/f13NTAnqgX7zuUMut1j0E0+V5fbePkiSxwsarOlU033aq/OXFnHFxaW71WFgcGgcXtui0X2Kgg6eVJ9zKBBGkBICP9yNb46cRFG/PYMNEa1VDdPTsS6oe/D+P0uFF/e02kJulWnTkB0tOdO7pWrJKKiSjBnjsCwYcBTT1Vdrz1pkvp3b64JcHz9/JWF9VcG3WRSs9ySVPEHcPxezehX67RV+HKbM39Wxrj9OboxHEX3T0POpk0o79rV9pjIpUuR1Lcvwri9GBG5IZ07B8OnnyL28ceRMHgwkv/1LyT16YPGkyYh+r//RfiWLY7ZRmfnEAKS2QzdwYOIWLECjZ58EknXXovkDh0QP3w4oqdPR9hXX0HKz6+bi6J6Q7YPups1C9xAQgCDbvKput7Gyx8ZsVBUk73aazpX3lQYjBolkJEhuT33zz8Lr7YwW7JE/b5ozz5oBg9Co7G3IOz4IQCA0Ghw7q6HkP/jARy6Zhx69JLx008CWVnCaeOt558H5s4Fvv1WYPTo6ldJZGS4X6+9ezfw0ENuLwnp6QIREY7rev2VhfVXBt0aXHvaNq5yRj+Q/FUZ4+3PkeaiS3B65Urkv/wylAh1Tb8mOxvxY8ag0YMPQj5zplrPS0T1WFkZwj//HHHjxyO5Y0fEPfwwIpcuhf7nnyGXVf03SomNhbFzZ5R3747ybt1Q3rUrjJ07w9ipE4xXXAHj5ZfD1KEDRKUtK+XiYoRt347od95B/NixSL7iCsQ+9hi0f/5ZV1dKIY6Zbu9xy7AaCtYtw3ylpls3BMs2XvWFdfsoWZahKIrb7aN0Oh0slgQsXqw2ATt6VA3UJk0SGDMGkGUTzOaK85SXR9Z4rjQaDRQlHsuWqVt9WZ8rPV3ByJFVt/py5sILgW3b3G9htmYN8NuuEpQ9/RIG/vEG9Kj4mTvUqi/Gl76NLTmX2LbkuuEGYOpUYOlSgRtvlNCqlfPtwNasEZCkHLfXIEmnbR/a6HQGlJU1Qs+e7tfOX3ih2kzt5ptdb2+1Zg0gywKKYrLNp05nQEZGLKZMcR2lzpypIC0tv5pBYRKaNXNf4y1JwPHj1dsqy7pFnbfbxlXnfexPnt639nPurZr8m6c5dgyxTzyB8K1bbcdYEhKQ//rrKB8woCaXRj7CbYtCV8jPndmMsB07YFi9GuEbN0I+d875Ya1awXTRReqfiy+G+eKLYWna1Luu0WVl0P36K/Q//QT9nj3Q79njMkte1r8/iu67D8Zu3eqkI3XIz18DFfv444hculT9y549OJmS0uDmz9stwxh01xCDblf880t+Q+Np/2p3wUHFXu3q/sdRUcDixcDMmY7nGTlSQtOm7v8j9TRXrvco9+59kJ1thsWCKkHQxInAgAHAnOvXY9qZB9HCctj2uPLkVDxjmInXD90CwHH8nTqp3a137hS49FIJX36pNvWynnfcOOD664FfflFw001qAOtun3X7ebj6ahmdO7u9JEgScOqU2sMmI0PNqld8+AHceSdw//3A2rVV51OIeAwerK31XtT2/PUhmMEQg/nzIzF1quv3z/TpAvfdV4LS0rAavY/9yd2cV18N/80TQi0Zff55yHYlnSUjRqDg+echoqNrOB6qDf7iH7pCde40hw8jcuFCGNauhSav6r/Dlvh4lA4dirKBA2G67DKIqFrssOCEfOKEGoTv3ImIzz6rEuwbO3ZE0YQJKBs0qOaNOrwQqvPX0DW+806Eb9mi/iU7GycVpcHNH4NuP2PQ7Rwz3b4hy0kYNEjrMou4fr37Dy2s85edbXZ5ni1b1JJzf8xVdd8Hen04SksbAZDx55/AyllHcN2GhzBUrLUdb5J0KHvocbwT9RT+83LVLbesXntNzWYvWKBmnCtnuletUjthe3Nd9vOQmal+GODumtq0UbcMu+kmoHVr51n22bPV7a+s/3xY51OjAU6c0GLduqofFAwbBqSkmGE2Vy/oVjPojTBliuvgeOZMgbS0s9UKOr2Z3zZtgO+/Fxg0yPkyA2/exwZDDIqKIqDRSLBYBKKiSlBaGlzNx2r7b56ck4NGjz+O8K++st1mbt4c+W++CWPPnv4YMrnBX/xDV6jNneavvxD93//CsGoVpEofPipRUSi74QaU3nQTynv29Guwa086dw4Ry5YhcsECaK17L59nbt4cxePHo3j0aCDcN0sEHZ47xOaPVInXXgvd779D6HSQyspw8tSpBjd/3gbdQbTijuqD+rKNVyD5al282Qy353nvPXhsvlbTuaru+8BoLENUVAmWZRjxRb/X8FpmB4eA+2tcg0vErzgx8UW8m+E64AaA//5XLTM3mYDly9V9vbt1U78uX67e7k1TssrzsGSJGgC78/rrAkuXCuza5fy5f/wR+PJL9cMAqz17gKwsGR99pHHbDXzJkpr1Qhg2zP1a/6FDq31Krxq/de4MLF3qfg28q/exTqeDLKdg/vxI9Owpo3lzCT17ypg/PxKynAJdpXWJgVTbf/OUpCScWbQIZ998E8r5DJb22DEkDB+OmOeeA7ivN1G9ot2/H40mTUJS376I+PRTW8AtwsJQOnAgzrz3HrL37kX+W2+hvE+fOgu4AUBER6P43nuRs2MHzs6ZA+Mll1SM+9gxxD73HBIHDoT2//6vzsZEwc3aSM2SnBxcjVyCEDPdNcRMt2uynOTzMtmGxBfVApIkQZZT0KWL68ysTgfs3Ance6/r9ce1mavqvg+0O/5A/h0P4V/m3223nUQyHsGb+AS3A5CQlQWvSrx373Z/nDcZ/MrzoNOpDcLS02FbK56QAOTlqQH5oUPAZ58BPXp4rh6YM0cNxK02bVIDel9XHShKAm67TY+33oLLUvuHHwZWrKj+eT29R2tzTbKc4jZDnpkpoCgnq94ZIL76N09z9CgaTZ6MsB9+sN1matMG+bNnw3T55T4cMbnCbFvoCva50/72G6Jnz4bh888dbldiY1F0zz0ovusuiLi4AI3OBSGg37EDUe++W1FCDEDodDj3+OMomjBB3SvTB4J9/siJ0lI0bdMGAGDs0gX6Xbsa5Pwx000BU5+28QoEaxZRrwduv10ta965U/16++1q8OdNplaS3Ac8JpOacc3MFH6ZK2/fB9LZs4h77HEk3dbfFnBbIONtPIj22IdPcAesa7ezs73bkkurrX0Gv3I212RSA9RPPwU6dnTs2N2xo9ograDAu326K//bHBPj3eOqu2WYLMvYuVMtZ3eWQe/VS31vWc+r0xmgKAkAkqAoCdDpDE7PGx2teKySaNlS1OiaDIYYfPih+wz54sVq74Jg4at/8ywtWuD0ihUomDYN4nz5pu6vv5AwdCii33ijYk0CEYUM7f/9HxqPGYOk665zCLgtjRujcOpUnPrxRxQ98kjwBdwAIEkw9uyJMx99hJwvv4TpoovUm00mxLz8MuKHD4fm2LEAD5ICRXPqlO17S0pKAEcSGuquZqWGhBDYv38/du/ejX379uH48eMoLy9HTEwM2rZti+uvvx6X2JW/VHbgwAGsWbMG+/fvR1lZGZKSktCzZ08MHToUer2+Dq+k4VAbI+UgLS0cw4f7qllRw6EoCrp1U9f+btyoBnXWBlTjxqnZ1ocfVrePclfJY90z2l3gIwRgNpuQllbk87ny+D4QApHr1iHqmeegOZ1re1x+2y54rfU8vPFNpyoxxsaNwAMPAE884fp509MVNG8u0KmTxmXm0ZutoazbeFlfP70eeOsttVzbPiA8elTtmP7ZZ+p68QsuAP7+2/V5W7RQ13jbKyz0PFfWLcOqU71lvYZTp1zvp209r1abhIyMyg3PtBg1KrpKw7PCQj0GDJDw2WeuqyR0OqlG11RUFIG5c903+Js7V8LIkRHQaIJjfXfl97per4fRaKzZz5Eso3j8eJRffTUapadD/8svkCwWRM+ahbCtW3H2nXdgad3aL9dBRL4jFRQg+vXXEbl4MSSlYgmKJSkJRffdh5I774SIcL9cKpiYL7kEuZmZiH7jDUTNmwdJCITt3InE/v1R8NJLKL3lljrpck7Bw367MAbdngV9pvu3337Ds88+i/Xr1+Ovv/5CbGwsUlNTUVpail27duGFF17AJ5984vSx33//PZ599llkZWVBp9OhefPmyM7OxooVK/Dcc8+hvLy8jq+mYTEayyDLeRAiB7Kcx4DbS2FhxfjoI4GJE4Fp09SgRQj167RpahfsjAzhMVMbHw+v15r6c66cnVtz+DAajxqF2EmTbAF3oRSD+zEHl5f+gLAenbBtm5ottJecDAwa5H6N8siRCiwWgfffd75P98KF3i07qrxW9+ab1aDfXQZ2+XKBWbO833vcqqxMQXq6cFvdUJP19WFhxXj6aQXbtgGXXOKYnb/kEmD7duDppxUYDBoMGqTFlCmyw/ttyhQZgwdroSjxDufVaCQ88ICa3X/1VcfX+NVX1dsXLYLHfdidXZNG435bNkAdm1YbfL/cGY1l0GhOIykJ0GhO1+rnyNy2LfLWrkXhlCkQ58s39T//jMQBA2BYvlydJCIKPooCw/LlSLrqKkQtWmQLuC0pKch/6SWc2rEDxRMmhFTAbRMWhnP/+Q9Of/opzM2aAQDkc+cQl56OuPvug3T2bIAHSHXJPuhWGHR7FPRBtxACycnJuOeee7Bw4ULMnj0bM2bMwAcffIAbb7wRALBq1SrsqZRuycnJwbvvvgtFUTB69GjMmzcPM2bMwNtvv42mTZvi4MGDWFL5N1+iILF2rfvgbt06z+fQaoFRoxSPAWqdfhhiMiFq7lwkXnMNwr/91nbzp7gV7cUfmItJOHxMY/twYcUKNeC0jnfAADXTPHeuet+mTWpwumkTsG6dWsqr0xXjo49k9OoFxMYCX30FHD6sfo2NVddce9OUzGQqdXj9Ro9WA3Z3/vtfCVde6f5DgeuvVzPi9rd16aLgzjst+PFHoH17x+C4fXtg1y5g9GjXc+WqLNxkKsXQoRLuuw94+mnHD3Ceflo9/5AhEpYscb5+GnDe8ExR1IZ1t9wC7N3rWLa+dy9w663AjTcCo0Z5/oCk8jVZLMKrJQRmcwMIOnU6FE2ejLy1a2Fu1QoAIJeUIO6RR4LuF1xvlyYQ1We6X39FwrBhiHvkEWhOq8tKFIMBhU8+iVPbt6PkrrsAQ+j/bBi7d0fu5s0oueUW222GzEwk9e8P/fbtARwZ1SX7Pd6Z6fYs6IPuNm3aYNasWRgwYACi7PYm1Gq1GDlyJK644goAwNdff+3wuHXr1sFkMqFjx44YOnQopPMlL4mJiZg4cSIAYPPmzci32x+VKBiUl0di9mz3WbzZsyWUlXneq1OWzwTN+nrd3r1IHDgQMS+/DLlMDbQKY5pjKNZiOD7FSTR1OH7PHjVQHj9ezVDPnQvcdpu6rFWSgIMH1axx9+7q1wMH1NfMaDTgs89kfPMNUFQE9O8PtGypfi0tVdcyX3utjNLSRh4DA/u1usnJ3q67Vly85gKffCLw8MNqZ/nK86Ao6nU4q2645x410LW9lucDHI0mCbKcgoyMRujRQ4/mzbXo0UOPjIxYyHISwsIiPXYQ//hj4OBB9/8VzJ4tO7zfoqMFNm2C2y7tX30FREaKar//oqJKPK4XnzRJIDq6xO0xtRVMQaTpiiuQu2kTim+/3XabITMTSddeG/BfcDUaDWQ5CRkZsU7fgxofNVkiCmbS2bOInToVCTfcAL3dP7ilgwYh99tvUfTgg0BYWABH6HsiJgb5b7+NM+++C6VRIwBqEBY/ahTCN2wI7OCoTsgsL6+WkO9enpmZiYyMDDRr1gyzZs0CoGbH77vvPpw9exYPP/wwevToUeVxkydPxvHjx3Hvvfeif//+1X5edi8n/0lCs2bu2y1IEnD8uOs9jivPn14fjrKywKyvl4qLET1jBiI/+ADS+feSkCQU3f0gun7xEv7Ojbbtp23fDXzlSnU/7a++Ap59Vs0OS5KaUR0/3nkgae1sffKkhHvucX3MnDnAyJHApEkKRo1SqqxZrkyvD0d5eRy6d3df+pyaCuzYYYYk5Th9zQE4nQd1P+1YTJniOvidOVPB2LGFMBqjsHSpjHnzZHz8sZqtdr0PtkCvXpLbNeapqcCyZYC7LaErv98UJQU9enh+LbZvF5Dlk9V+/8lyCgYPltx0A/df93KNRgMh4rF0aeX17d69V/z9b2d4ZiYaPfEE5PMfGAtJQtGkSTg3ZYraeKCO2e9lX5k3e7EHG/7fF7oCMndCwLBiBWJefBEau8oTU5s2KHjxRRh7966bcQSYnJ2NRpMnI/y77wAAQpaRP3MmSocP9/oc/NkLPXH33APDxo0AgFO7dqFJly4Ncv4aTPdya+Br3xQtLy8PZ8//49e+fXunj2vXrh0A4M8///TzCImqx9r8yh1rAypvBWp9fdg33yDxmmsQtXChLeA2XXQR8jIzUfTiWyjRROP7752XVG/bpgZ7FkvF/trDhwNff+05c3vkiPtjvvxS3fva1ZrlytTA2IJ77nF/vePHV8Q9zl5zV/OgVjd4zjaXlMTa1l536eJ5jfmyZep1unP0KHB+aZ5Lld9vsuxd1t+6dr667z+NJg+ZmQLTpwuHDPn06QKZmQIajffbm1WXEPHVWt9e18oGD0bOV1+h/PyHyZIQiJ4zBwlDh0Jz8GCdjqXyXvaVuduLnSjUySdPonFamlpKfv53TiUiAgVPP43cr75qMAE3ACjJyTizZAlKRowAAEiKgrjJkxHx4YeBHRj5lXVNt5AkKE2aBHg0wS+kg24hBHbu3AmgIogGgJPn3wQ6nQ5xLrZgSEpKAgBk261HIAoGlRt4OVOTplp1ST5zBo0efBDxo0dDe347ESU8XP1lZONGmC6/HBYLsHo13DaMW7kSCLf7fX3SJOCdd9w/9+zZksclcwsXqpl1wPvAwGKRcP317tcoDxgAmM3Vb/Cl1Wq9CmJLSyuCbG/WmM+eLeHuu90fo37AU92GZ959MAR4/8GQPZPJBEU5iQkTirFtm4LjxwW2bVMwYUIxFOWk36qMQiWIVJo2xenly1Hw9NMQ55se6H/9FYnXX1+nTda8/bDIm6UcRCFDCBhWrkRSv34Oe1eXDBuGnO++Q/HEiQGpOgk4jQb5b7yBIrv/dBr95z+Imjs3gIMif7Ku6VaSkioa8JBLQb9lmDtff/01Dh06BK1Wi4EDB9puLy4uBgBERETY1nJXZl0fXlTkPnAxmUwOv+BJkgTD+d/oXZ27PrBeW32+xmBlNpdh1KhoLFsmu93yymQqdzk/AZs/IRC+ejVinn0WmjNnbDeX9+qFgtdeg6VVK1hHFBkp8OWX7ht4bd6sZo87dVL/npLiXYY1Nlb9ncdV2XrlvbJnz5bPb2vmekcDs1lCerpamv7ll2rAe/SoGlyOG6c2SHv4YWD5cqnanbVNJu+21zp0qOK8CQnevRbn+2+5NH48EBFR8RpX5uz9FhamfgAydarr806apPYLKiur+XuwtPQctNpzANTGgKWl/n1PextEunqv6HRqGX1ODmCxJCA8vAgmk5+qSjQalEyaBGOvXoi7/35oDx60NVkL/+47FMyYAREd7Z/ntg1B9uo9mJMjY+vWWIwaFQ1ZPuO2PN8b6uscabdcodhnrzP/7wtddTF3cl4eYp94AuHnS2oBwNKkCQpefx3l55cqNuh3jkaDcy++CERFIerttwEAMS+/DKmoCEWPP+52SzH+7IUYkwny+X26LcnJnD9viBB18OBBMXLkSHHbbbeJtWvXOtz37bffittuu03cd999Lh//9ddfi9tuu0088MADbp9n+fLl4rbbbrP9efzxx30yfiJPcnKEePNNIVJThZAk9eubbwqRmxvokblw+LAQAwcKoebZ1D+NGgmxcKEQilLl8KNHhWjRwvHwyn9SU4X480/1z8yZQvz9t3eP+eYbIX78UYhp09TjJUn9Om2aenv37kJkZlY8RpKEOHXK/eWdPq0+XqcTYsQIIdavF2LnTvXriBHq7c8/rx4nhBAmkxDZ2ep5s7PVv7uSm6ue2911vf66+jzWv2dmevdaHD4sRKdOzu/v1EmIgweFMJurvt/atFGv7dixqtdw7JgQe/a4P++ePepx1X0tAunUKfevp7v3Sk6O+h61f7/NnKne7ndFRUKMG+c40Nat1TeoH2Vne/ceXL++4n1R29cjoK8zNWyffSZEQoLjG3zkyIp/9MnRK684vlYPPSSExRLoUZGvHDlSMbc33hjo0YSEkGyklpOTg2eeeQZnz55Fr1698OCDDzp8svLDDz9g1qxZiI2NxYIFC5yeY9OmTXj//ffRokULzJw50+Vzucp05+bmwmw2++6igowkSUhOTkZ2dnaDa4gQTGqa0anT+VMURCxejOhXXoF8vsoEAEoHD0bhSy+pZUdOJaFpU/edjdUGXgI6XT4AwGKJxYIFMp55xvVjXntNbZI2dKjrBmPLlqnrodPT1dvUpl9GaDSuu7lbLPE4fVqPceNcZ4QXLgQSEkzQaCSXjbicZfrM5iY4c0Z2e+7Vq4Grr4atKdrtt6tr36dNc/1aqM3XJBw5ImHduqrZ+WHDgJQUAYtFLRGzvt/0ehmKosHSpWqJeuVrEEKDbt0kfPqpWo0wf37FeSdMAK69Vu00v2OHgCxbqvVaBJLFEo8ePfReNIhzfK9IUqLbZmKZmWYIkeuHETsKX7sWsY8/DvmcWh0gtFqce/xxFE+a5N3m9NWk04Vj8WL3DQCf///27ju+qap/4PjnZnXSQheUJShLxAcE5UFQEUFF9lBARHDhwMFPH9fjekRQEVHEAaIiDlQc7LoQEBkyBAQVmQqyaQt0N23G/f1xm9DQNE3SpGna7/v14kVzk3tzcs+9N/nec873TNBmDPj8c+3xK6/YGT0626+W6arYz/LdF76CVXfK6dPEP/UUUQsXOpfZEhLIeeklzH37Bux9aqLo998n/qmnnI8LRowg++WXwc2sBnLuhRfjli0k9e8PQP6tt5L7wgu1tv4MBoNXidTCrnt5VlYWEydO5PTp03Ts2JFx48aV6coQExMDQEFBAaqquu3q4OhWXnoaMneMRiPGcsYp1IaDSlXVWvE5q6vi4kJ0ukJUVfvNXFzs2/rBrj/9vn3UfeQRIjZtci6z1a9P9gsvYO7d21EIt+va7TaaNNFX2KXaZrOgqoWANmTottvqsmhR+Zmtb75Z5ZNPPHdbX7wYevQ4s8wxZrm4uPx9FRGRT3y8kffeKz+AjY9XiYzUcc01epf3P3QInnhCx8mTOsaNS0ans2G324mIyMdiKSQ2tgCbLcbjtkHlvvvgoYe069n8+VqyuaVLyw/Ub7pJ5cMP4bHHFIYM0brGJydDRobW1X7SJC052ejRESWJ3rTjzW5PoW9fpcxnePhhHZ99pmPRIpWGDbWbIi1awLvval36s7PBMQtjw4Za1Z8dJJXeztKlCdUqs7WWT8HgMYg8+1jRMs97Hgf+6ac65z4OpsIBAyju0IF6996LaetWFKuVuBdeIGLNGk5Pnx7wRDfFxYUVDoXp3Vs7zhy07vkx6HSFPr1XVexnozGKoqIY0tPBak1wnp8ivATye8+0ejX1/u//0Jd0owUovO46sidPxp6UVGX5E8JV/q23Yo+Opu7DD6PY7UTPm4dSUMDpN97Qxgy5Ib87w4PuyBHn37YGDZx1JvVXvrBKpJaXl8fEiRM5ceIEbdu25aGHHsLg5qRNLZkrzmKxOLOYny09Xfuh16BBg+AVWIiaymol9s03SbnmGpeAO/+mm0j/8cczAbcHMTHF3Huv5wvzvfeqxMaeudNgMBhJS9OCxwkTcMls7ZjL22aD6dM9v/cbb0BiSRJqx5hlb36oz58PnTtrLXdvvaVNX/bWW9rjSy7RpjX7+eeyAX/TprBmjTYWumtXpcxcxgaDqcJtf/kljBmjOhO5WSxaa7K7feGYB9tutzFtmg6Lxf182hZL2Tm4vUkmtn27yscfq9x9NwwfDtdeq2332mu1x/fcAx99pPLrr2q1T0pWmsVSyE032T0myzv7WPF2HHjpfRxMtqZNyVywgNz770d1jMFfs4bkq68molTSJ4fKzkdeei57d+fjDTdox5mDNpe97z89grmfz55rvEEDZK7x2s5ioc6LL5I4cqQz4LbHx3P6jTc4/e67WsAtvFI4fDinZ8xALfm9HrVkCXETJ4a4VKKyDKXmIrWec04ISxI+wiboNpvNvPjiixw6dIjzzjuPxx57zGWasNKSkpKoW7cuALt27XL7mt27dwPQsmXLoJRXiHDiyw9vwx9/kNSvH3EvvohSpCWTsjZrRuaXX5I9ZQpqfLxX75mfb+LqqxWPAU6vXgp5eWfO87y8aCZNUrj8cvfB6WWXaQnPvEnuZDSeCU4Vpfxu5Q7aj34FRcH5D1z/nj5dISJCh8mkdf9OS4ONG2H1avdZ2h3TUOXlGZkxQ6kgOFYoKFBcApxDh+Cmm+Cii+ysW6dy5IiNdeuKGT06C7s9HVX1LtFV6SDIm+Dmhx90LF7sebqyJUtgxYrqE4yW5ul4Ly+ILO9Y0el838eBLrObF5P7+OOcnDcPW0nrtv7kSRJvvpm4556D4uIygebZN4K8DTRtNhuqms6ttxawdq3KP//ADz9oPR969NCm7yvN1+kOHYK5n6v7NHGiaukPHSJpyBDqvPmmc6pLc/fupK9YQeGQIR6TgQn3zP37c2r2bGfgHfvee0TPnRviUonKMOzb5/zbKrGUV8Ii6LZYLEyZMoW9e/fSpEkTnnzySWcGcXcURaFz584A/Pjjj2We3717N0eOHEGv13PxxRcHrdxCVHc+/fA2m6nz0ksk9+2L6fffAVB1OvLuvpuM5cspLpk32Fs6nY7Bgz23Wg8Z4vojWq/XAmpPwenRo3g5nZXqDE69GVes0+lQFCqcVzw52fU106bBhx8GZj5tvR5UNZ3Ro7NYt66YI0esrFpVzKWXZqHTHUNVT7jMg+3PnO/eBDdXX63dBPBk+nSFG27w5jNV3deQN8e7I4gsvY9L38g4+1jxZx8HuszlKb7sMjKWL8dcklUZIHbWLJIGDUK3PysggaajfO+/H023bgrnnAO9emnDDH78UTufS/N3usNg7edwmSauqlW2B0S4ily6lORrrsFUckCoBgPZTz3FqblzsZf0ohT+KerVi+wXX3Q+jn/ySUzr1oWwRKIyDH/9BWi/A60VTZMigDAIuu12O6+99hp//PEH9evX56mnnqpwHDbAgAEDMBgMbN++nSVLljjHF2RkZDBz5kwAevbs6WwRF6I28raFx7h5M8nXXkud119HKUkgaGnThswlS8h5+mnUiibGdsNut6Oq0LOn1ir2ww+UaSVTVdcf0TabWuEP788/hwce8Pya++8Hk8nm09hPu93OwoXatnftgpkztVb2mTO1xw88oHUvT0x0bdUeNQree8/ztr2dT9uRu7G42IxOl4mqprsE2WfTxihXNAe36hIEeRPcNGjg3XRljRp5fk1lglF/+NKi6ds+9vwZfA00Swc8FksK06cb+O9//QuO7QkJnPrgA7InTDgzp/f27cRdeQktt85zu44vgaa7fXrihHZO5OdrN6O+/lrr+fHvf3s/lONswdjPUP2GB4RaoHpAhBulsJD4Rx8l4e670eXkAFqX2cxFi7R5t4OQiLA2Khg5kryxYwFQrFYS7rwTfaluyiJMqKqzpdvWtClE1q6bkv6q9leRn3/+mV9++QXQWmBeffVVnn766TL/Xn31VZf1UlJSuOuuu1AUhblz53LPPffw2GOP8cADD3D06FHOPfdcRo0aFYqPJES14E0Lz5cfFFJvwnMkDRqEseQCqxqN5PznP2R8+y2Wiy7y+/0jIvJ56ik7K1dqrWK9elGmleypp1x/RMfHWxk3znMQ2bSpyrBhqsdu60OGqBiNvv3wj4kpZsMGlddfd9/S/frrkJGh8vnnruOYvZ9P2/PnGjdOJTHRt+QkJlMUAwficV8MGAAmU7RzmTfBjdFY8c0PR28CT8aNcx2zH0zBatH0Zxx4edwHPAqRkVrwenarsddlVhTy77iDzCVLnC0SEUW5zONG3uUOoskvs4o3gaa7ferIX9CmDYwZo53Td98N7durLFqkYjRmV7gf3Ankfi5Nr/eczBEcPTJqZrB5ttrY1d6waxdJffsS88knzmUFAweS8d13lfqOE+7lPP005quuAkCXlUXimDEojgycIizojh93zlZjPe+8EJcmfFT7KcNWrVrFjBkzKnxdcnIyb731Vpnlu3fvZuHChezZs4eioiKSk5Pp1q0bAwcOLHdMuDcyMjJcphKraRRFITU1lWPHjkkWwjDkTf3Z7Ukep0e6ihXM0Y+lqW2/c1lxhw5kvfIK1jZtAlJOnS61TJZsB20KIBW7/Zhzmc3WgIwMHXfeWX7G7gULICdHaxX+5puy01n17at1065btxidLtPrstrtSaSnmxg7tvypyBYs0FroS9+4T0vTAvOKp6GCQYPK/1yLF4PdrqLXHyv7gnLYbKkMG6bw2mvw/fdls6L37g3/93/w+eeu29XpUujXz1BuWb7/XuX99xUefbT89375ZW28ef/+5X+md96BlBTf6sFfFR3vcGY6MF/Lo9frsdsT+ewzPdOnK859PH68ysiRNhTlpJdDGFI8Tok1f77WiuzIPj9/PqSm+lZmJS+P+P9OIHrBp85lf3I+w/mcP7jwzOsUOHLE6jG7/Nn71GTSAu577in/HDn7nPaFwZDC0aMGD9PfWbFafcuGb7M1oFs3z0MqmjaFtWvt6PXH/Sp3uNAyxHueAk6b8i0r6Jn4/eHz7xZVJfrTT4l/5hkUc8mQnKgosidNonD4cBm7HURKbq52M78k71LR5Zdzau5cUps2ld+dYcC0Zg1JI0YAkHfXXeQ880ytjhuMRqNXU4ZV+6C7upKgW1Rn3tVfCo0alc3+H08WL/MIYznTJ1qNjCTnkUfIHzvW7fya/vDvB14ql16q8MUX5QeRRqMWvH75pdZdPT7+zHRW2dnQrJmWUXn9es8BRdny1mfGDL3HebFffhk2bz4zJzF4O5+2yunTCnfeCZ9+qo1nd3yuceO04HX4cPjqKxVV9SVgSaVRIwWjURsfP2qU65RhCxZoNyeOHHHd7pkgUptf+0wQaWfkSDuRkToyM3WMGFF+QD1vnhaAtW1bfl0NG+Z7PfjP/fFemjeBpjt6vR5VTWTTJh2RkTrn8WY22+nc2e5V0O3N+fDcc7BjB/z8s7YPr7vOv31otyfxSvt5TDw1jtiSVm4zETzINN7mbkDx8gaE6z715lifPFnlrrvyKSjI8bq8cGb//Pe/unKP5cmTfQ8Ijcb6vP22nmeeKf81EyfC3XfbKC4+Uf6LKih7UVEMOp3OZarA6iaYN6aqgi+/W5SCAuIff5zo+fOdyyznn8/pmTMlKVQV0R86RFLfvuhPaskp88eMIeaDD+R3ZxiI/uAD6j75JABZL79MwciRtTpu8Dborvbdy4UQweFu7G4/lrKDC1wC7qIuV5C+fDn5d98dsIAb/BtLabOpqCoes5dnZmpdIi+7TGsJdMxtXlysPe7WrexYcW+YzQqzZ3t+zRtvUGZs9vz5WnDkuVusFmy3aaNNK7ZsmXbDYNky7XHr1nD48Jkx3d6y2bQg11PiudJjxc+s5zmZWG4u3Hyz5yR4o0drjz3VlT/14K9gJjxzdMkdOFDnMn3awIHed8n15nx47z0t2Dx0SAtsx43Tji9fyxwRkU/jJ0bRiS38SgcAIiliJuP4iuupxymvxkefvU9HjaLCc2TGDIXc3GjPL3LDsX98mf7Ou+3auO02z+fnrbeC2VxxT4Wzhdv46KrKxB9qhj17SOrb1yXgzh8zhoy0NAm4q5CtSRNOv/ceakmv05gPP9S+IES155K5vEWLEJYkvIT3lVMI4bfSY3eTyOATRrKUATTiKAA51GH50LfIXTwfW/PmAX9/f37gxcYWMG6c6vGHd36+yvjxnl/jT8Ilg0H1qrzNm7ve4fVmPu2YGAtjx6oUFMCDD2rBd9Om2v8PPggFBdr453r1fOtdExdXVOEY+HHjVOLji9w+V14yMaMRNmzwHFBv2ACtWgW+HvwVrERcgRor7u35UPpm+pYtsHy57+PiHeOj63RqzaWs53Xudz43lAX8aezAmPNWl9ti7Ej0ptfrSUtTGTFCOya8zV9gMPjebTdYAWFMTDGLF6sebyAtWeJf7oFwGx8d7Ez81UHU/Pkk9emDcc8eAOwxMZyaMYPsF14oNxlUbc3kXhWKO3cma8qUMwvGj8e0alXIyiO8Y5Sg2y8SdAtRS1kshdw00sYTzT/jT9oyks+cz33Dddx44Q7avXknxdbgJLry5wdeYWEOt9ziuVWqSxe46SZbwBMu2Ww2r8obFVW2fAcPagFqYSEl82m7thxnZ8Mtt3ies3zMGAVfc83k55+qcH+NGQN5ead82q7FonjVgu54j/Le299M1v4IViKuQGW/9vZ8yMhwXTZjhutc9qV5Mx/5C6+YeKXp6wxiEad1CQA0sBwiYUhPYqdN07pLlDi75bZRIz39+ilccIGW6C0/37vp+nztsQHBCwjz801Mnqx4vIE0eXL5+7g84TgVWbBuTFULJdnJ6z3wALpCrWu/5fzzyfj2W8wDB7pdJdx6KoSrwhtuIPe++7QHNhv17r4bfamgTlQ/zszl9ephT0gIcWnChwTdQtRSuqNHqTemL8/vH0ky2vi8U9Tj/xI/YtfUpcxeloqinAza+/v7A0+vzyQtTWXyZNWlVWryZJW0NBW9PtMZULzyit1ty7I/n8vb8sbE5Lot38SJWgt8RETZlmOdTse4cbB0KSxcqHUr37BB+3/hQi0Z27hx/nXrNBpPkZamsnChetZ2tf1lNPoWcIPWIHT77Z5fc/vt2g2IQNdDZeh0Whdtdy2as2f7NytQoFpgvTm+br9dG79c0bb9mY985tG+mDf8guXSrgAodjtxU6eSOHw4umPaeP/yWm6fflo7PlNToWQ2oHKNGwd16vg+3i/QAaHjhoROZ2TmTC1vQrdu0KoVNGyo/X/ppVoLvj8t6OE4FVmwbkyVFopWY/3+/SQPHOiSnTz/xhvJWLoUm4fMy6qayKBBBjZv1rlMEbl5s45Bg6pfT4VwlvvYY5h79wZAl5NDwrhxZ8aGiWpFyctDX/KdEOxW7prWy0SCbiFqG7ud6LlzSbnqKiJ++MG5uKDPYCzbfuPhbcMZPSYbuz3dq4zL/vL3B57FYsFuP8Zdd+Wzdq2dI0dU1q61c9dd+djtx7BYLBWOSfbnc3lb3sLCvArLdzbHnOV2O+zdqwVXl16q/b9375nGRn+6ddrt2jr79rlu19GQ4HjeF2azSv/+nlux+/WDwkI14PXgL6Mxio8/1tG5s/sWzUsugblzfW95DFQLrDfHV+/eWsKwirbt73zkaqNIMj6fR87DD6OW3IGIWL+elF69iFmxqsKW22++URk3zvNxMWoU5OX53tQdqICw7A0JhXvugQsu0PavY5qzXr20YR27d2uJGX0998J1fHQwblhC6FqNI7/+muTevTHu2AGAPTKS09OmkT11qnZXsBxGYxRLlug8ThGZlla9eiqENZ2OrDfe0DJvAsYdO6gzdWqICyXcMZSaniVYQXdN7WUi2cv9JNnLRXVWXv3p9++n7iOPELF+vXOZLSWF7Oefx9ynT5WXs6Is2d5OtVRVglVeozEKi6Uu/fuXP33akiUqJtNpn1uZfJ2WzRtRUXF89lkMnTop5WYm37JF5cYbfc9SHSzByswcyGmWyju+HPv0hhu0oQqeth2o8pg2bqTevfc6WzQA5sTezz15UyjCfaChTa2lotMpzJ1bNgv/qFHatHdRUdpx7GtWb8f+2bxZyxIfF6dND2g227nkEu/Ov4qmZXvrLW0oiOPr3d9zL9wzgZtMkZjNsej1Omw2rQdBZVq4dboUBg0y0Ly5dhwkJWlJL+fOhf37YeHCys9i4PK9V1RE3KRJxJbK7Gc57zxOv/OOV1NeejNF5KxZUL9+9au/cMmWfzZFUUg9cQK1c2cUiwVVUTj55ZcUX3ppqIsmSolasIB692t5QLKfflpLsktg44aKrtNLl1bVrCfekezlQogzrFZiZs4kpVcvl4C7YPhw0n/8MSQBN1ScJbs6BdwQvPIaDEY++sj9jzvQWhE//hgMBt/GlUZFxfHBB563++GHEB0d59N2rVYLgwbB+PHuW40feEBrHbQGKR+AP4LV8hjILrnujy+VwkJtbPHZAbe7bQeqW3Pxv/9N+g8/UFjS5RPg1rw32Mi/acsOt+scOgRms9Y1210W/lattKn8dDqd360YigJ79iguvTb27PEuMZs346y//16bXq/0so8/BpPJt4zr4T4+urwkiv6o6lZj3eHDJA0Z4hJwFwwaROa333oVcANEROhZutTztfPrryEysvq0uNWI1sEOHch97DEAFFWl7vjxKNnZIS6UKM0lc7mH4Rn+Csd8GN6Slm4/SUu3qApRUXHk5UWj1yvYbCqxsQUUFlbccli6/vQ7dlD34Ycxbd/ufN7apAnZU6ZQdMUVwSy+8JLN1oBu3TwHhVoroh29/njIt2u3J3H//SbeeAM++wzefPNMi+Z998GNN2qB9+uvV59WoGC2PAazx8aZbeuZPl0ptW2VkSNtbrYd4PnIVZXojz4ifsIElCIty30hkTzCy7zFvcCZgLdpU3j3XW26tPK0aAFr1qgee1+U14pR2dYPb4+Bt97SkgKWXrZ2rYpe71uPEJ0uhX79DOXOZZ+WZsVurz6tNaUFsrW0qlqNFUUh9ddfsY8ahe70aQBUk4nsCRMouPlm7cD3UrCuncFUXVsHvT2WnL9bDh8mYdgwZwNBwZAhWtdzUS3UGzuWqG++AeDE2rXO2W0CFTeEYy8haekWIowZjUZ0ulRmzYqhWzcdjRsrdOumY9asGHS6VIxGY8UbMZuJfeklkq+7zhlwq4pC3u23k7FihQTc1YherwRlqqVgbVen0+5CHz8O556rBVrr12v/n3uutnzr1uo1XjUmptir6dP8mRrq7Bbq48cJaI8NRYEWLVSX/dyihfvPEvAs34pCwZgxnP5+BRkN2gEQhZk3uZ8lDCCZMz/ix49Xef99z5u7+GL45BPPLYjuWjEC0frhz7RsjmUGz/cx3ArW+OhgCkZraZW0Glut1HnxRejb1xlwW5s2JXPxYgpGj/Yp4Abvp4g0GKpHo0R1bB30+1jS68maPh17nNYDK3rBAqIWLaqycgvPDH/9BWg3tGwVfdn4IVzzYXhDWrr9JC3dIpgqOw43YuNGEh9/HErmIgWwtGxJ1tSpWC6+OBhFFpUQji3d4Tbe0VHmO++k3JbHd96BlJQAtLYF8Nrpa+tVIMeYlylLUR1W/ftJRmScaXU6Tn3G8CEnO11LWppKt24KpfLslLFsmdYl3NdWjEC0flR1S7dDoMdHB1MwWkuD3WqsO3GCevfe6zJ0qvDaa8l69VXUunV93h6EX2tbdSyvr8fS2dfOqEWLqHfvvQDY4+LIWL4cW6NGVVJ2UQ6rldSWLVGKi7G0bk3GypXOp6SlW1q6hQg7lRmHq+TkEP/YYyQOGeIMuFWjkdwHHyTj++8l4K6m4uK8a4WNj/etFTY2tsCr7dapU+DTdmNiilm2TPV4jC5f7l+rcbDodDoGD9YCKndThs2YoY3lrU53z/1pvQrmtE9KdAHdt7/KwjuWkqFLAaABJ/ie3vzUcTxGWzrjxnluQW/WzLsWxLPrwWAweNnyWH6TtL/Tso0bp5KYqJ1H/kxhE8jx0cEUrNZSx7Rrnhw6pL3OV6affyb52mvPBNwGAzn/+x+nZ8/2O+CG8BuTr9frvTyvqmZcdyCOpcJBgygYPBjQphGrO368NsWHCBn9oUMoJVO5BWM8N4TfueeL6vPrQggBQF5eNDNmeO4KN2OGQm6ua2KfyO++I6VHD2JK/WIs7tiRjO++I/fhh7VMRqJays3Vcc01isdA6eqrFXJyfLtkFxbmcMstnqdwGjMGnzOM5+ebvDpG8/J8S/wWTI5p2S6/3H3yt8su06bW8mdatmDxNylasLo1O7rRX/5iVyybN2O+6kyStZh3Xyfu6h6M6fSbx+MtKgq/ur9bLIpX61ks5R+X/kzLpk1zppCVpYR/kqoKBGtucYvFuzr3qfOgzUbstGkkDh+OPiNDW5SaCqtWkX/XXT53Jz9bVcxZHkhWq3fnh9Vauf3irUAdS9nPP4+1YUNAm74w5p13AlZG4TuXJGpBmi4s3M49X0jQLUQ14+s4XF16OvXuvJOE229Hf1zrmmePjobXX+fk4sVeZ2sVoRPMVli9PpO0NJXJk1WX7U6erJKWpqLX+949KxzHXDnunlss8PnnWvfhLl20/z//XPvBX93unvu7nwOdZf/s1l1VVaC+nlMfvUf2xImoJTf0jDt3kti7Cyv7vsyShRaWLYMNG7Qu5UuWaAF/VFSOX60YkZFaK7Qnt99e/tTLjs+gKLB0qcorr7ieD1Onwrx58H//B1ar4xyBRYvgpptAp6OCuc9TsNkaEBXl20wAleFPq7snjuPNZIIRIyAtTau/tDTtsaPF2tfzOjJSZexYz68ZOxaiorzrkqo7cYLEESOImzoVpaTl09KjJ8e/+ZVj53bDaq0fkHoIpzH5kZGql+dH1QwXDNR3hBofT9b06aglN1HiJk/GsMP97Ak1RaDP60Bu1zGeG1yD7qioOKzW+hw7RkDOv3A693xRfX4RCSEAsNlU7+5YF9uInjuXlCuvJOrrr53Pma+6ioxVq+D++6EGtL7UBsFshbVYLNjtx7jrrnzWrrVz5IjK2rV27rorH7v9mF+5KQKerKsKhOPd88ru58p2a64wEZLBQP5tt5Hx9ddYSm7uKUVFxD33KB3+04v/jTlQZlovq9XsVz2YzSr9+3vutdGvHxQWugYVZ3+G1FQDl12m0KKFyrp1KkeOqHz6KYweDSdPwgcfaNOc/fADdO+ubaN/f63Luaeusu++qzB5so/JLv0UrKmh7HY7XbrAmjXup/Zau1a7UeXreV1UZKNvX89116cPmM0V3wyKWLWK5KuvJuLnnwFQdTpyH32OV3t9x6UD6tOoEb4nHS1HOE1pWVRk8+r88GYfB0IgvyOKu3Yl7557AFAsFm2O6MLqP++4r4J1Xgdyu2e3dJ+d9DdQ5184nXu+kERqfpJEaiJYoqLimDUrhv/+t/xuYO8+uINbfr4Dw8YNzmW2hARyJk6kcOBAFJ1O6i+MBDP5VTCEW3kdgjm1l0Mgr52h3s8+JUIym4l76SVi3n0XpeRz51CH/+M15nAroDjX0elO+lwPUVFxfPZZDJ06KXz/PcyefWaauttv17qFb9micuON+S7DJSr6DF9/rWKzQf/+5SeuXLRIpWtXzz2QSidg8ybZZWUEa2ooozGK7Oy6DB9e/r6YN0+lbt3TPh1vRmMUCxfG0769rty6277dzuDBHo5ji4U6U6dS5803nYtsDRqQNWMe10zq7nfS0ZoiIPs4wOXx9drl8dpZVERy//4YS1q58+64g5wJE4JW/lAI1nkdyO0mDhpExC+/AHBs926UuJaVSvpbU0giNSHClKdxuBGYebfB09z+5kUuAXfB9deT8dNPFA4aVOmxbKLqhVsrbLiV1yHc7p6Hcj/7nAgpMpLCSZP54q7lHOAcAOLI5X1uZxGDSOGEcx293uhzPRQW5jBkCIwf7743yAMPwODBrvkJvPkMn3wCGzd6bsUuKPAuEZjjN5enZJeVFeypoRYv9rwvlizxfZsWSyEDBtg91l3//uUfx/ojR0i6/nqXgNvcsye5a9bz7u4r/Eo6WtNUdh8HozwBvXZFRHD6zTdRI7XjOmb2bIwlU6HWBMFLYhjY7Tpaum0NGhCZ3NDvpL+1lbR0+0laukUwGY1GbLYkPvxQS0h16BAMT17JW7a7SDhZqntPs2ZkvfQSxZdd5rK+1F/4qYpW2EAKt/JWlUCce0ZjFEVFMeh0OhTFjqLo+fRTHdOnK6X2s8rIkbag7Wd/pm1xrJN1KIdpPMjtnJm0O51k7mIWW5sO9nuqF8d1ccMGiIlRiIuDnBzIz1fp0kXLX1D6e9nbz/DuuzB0KEyaBNddp40LLyyEb7+FJ57QxnV7M81Z6anGSk+BVbo+7XY7ERH5WCwVd491t15RUUzQptNx7K8TJ7QcEqNGQVISZGZq3evnz4fUVP+27bheHD6so25dHZGRYDZDVpadJk3Kv15ELFtGvQcfRJeVBYBqMJDz3/+Sf+ed2NSGdOum4/Tp8usuKcn/qcjCjWMfb96sIzJS5zw/zGY7l1xS9ddkX78jvLl2xsycSfykSQAUX3ghmWlp4GHGgnARrHMvkNNv6U6dosGFFwJQdNllpH/6U1CnAgwn0tItRBgrPQ735yXp5F0/hs/SezoDbtVoJHf8eNJXrCgTcIvwdHYr7PHjVOtW2HBrNQ4H7sbeDRliIi9PR4sWWnC4fr32f/PmAHp0uuB8jfuTCMmxTi5x3MFsBrCYE2hTi6WQwUKGMPHgaAw5WZUq2969WhDsGC++d2/lPkPDhrBzp9ai3asXnHOO9n9BAezerY1xHj/e8w2Us6caO3QIIiL8y3juaQymwWCssDOTv0kMtZs8nsd0K0pltq1nxQqFnj21fdyzJ6xYoeDuOFYKC4l/8kkSb73VGXBbmzQhc+FC8u++G3Q69HqFxo09113jxmeSjtYGiqLlTyh9fjjyKVS1YHxH5N9xB5bzzwfA9PvvxHz4YaCLHRLBOvcCmfT07PHcvib9FdLS7Tdp6RZBZ7cT9eWXxE2ciP70aefioksuIfull7C2bl3uqlJ/4U3qL3xVpu7OHntnMmk/wu65x30XvmCOmatMS3fpdZLI4B3uZDCLnMtsyfXJfn4i5r59fSqTTpfq0/hBbz5D27awfLmWZKr8Md1gMKj066ewZYv718yYoSU8dPwsaNEC1qxRPZa3vLGUFY3BnDVL+0Fe3k+QyrR0p6ebGDu2/H0xaxbUr+/7tn2pO+Pvv1P3vvswlvqRX9inD1lTp6LGxzuX2WwN0Ol0DBjgue5Utea3tEHwxgRXFW+vncZffiF50CAA7LGxpK9ahT01tYpKGRzBOvcC2dId/emn1H3kEQCyJk0id/R/paW7hLR0CxHGDDt3kjh0KPUeesgZcNvj4sh66SVOLljgMeAWQoQfd2PvhgzRusmGYsycY4o1T86e2ismpphx41x/LGeSzBAWMIYPyEILmPQZJ0i4807qjR2LLt27ICAqKs7n8YPefIYPPlD58EO1gnHfKvHxqtspbBxT+t1wg2sQ/PLLKp984rm87sZSejMGc/lylSFDyv9M/k59FxNTzLJlnvfF8uUqsbHFPm3X67qLiCH2jTdI6tfPGXCrkZFkPf88p995xyXgBqhb187HH1dcdwkJ1WcWhWAJ9lj/6sRyySXk33QTALq8POKffTa0BQqAYJ17/lzHy+PS0n3eecTGFpS53p9t3DiVOnUKvCtsLSAt3X6Slm4RDEp+PnVefVXLAFyq61XhgAFkT5iAPSXFu+1I/YU1qb/w5W/duWuRSEvTWrlD1ZKg06XQr5+h3NbdtDQrdvuZoNnRWnPnnbhd59oLjzIv4R7q/nQmG5e9bl2yn32Wwuuv95gE0mZr4FerSkWfYeFClW7dKs5Mvnatil5/DJMpErM5Fr3eyK5dCrNmwYIFrgG3LxnPz25h8rZl6oMP4Kqr3H+ms+vFW4FsFSvNm7rr2vAAKxvdTMQva53Lii+8kKw333SZD9h1u6k+1V1NFqy6q0q+XDuV06dJ6d4d/UltvuaTH39MkbsTIkwEs/58vY6XJ2H0aCJXrADg+C+/YG/YEJ0u1WMPIMle7kpauoWoDlSVyK+/JqV7d2LfftsZcFubN+fkZ59xeuZMrwNuIUT4cTf2LinJu6zZwRozpygn3bbuvvKKnbQ0K4py0uX1Op2OwYO1hGITJlCmRfi59xrSYf8iTs+Yiy0hQVsnK4t6//d/JNx8M/ojR8oti7/jByv6DAaDt/tY+9sx97nBkMn556tcdJFKauqZ7U6erJKWpqLX2/0aS+ntGMw2bVSWLLGzbBls2ADLlsGSJe7rxVu+jv80GqOw25OAFOz2JIzGKLfreK47lZv5iG+P/ssZcKs6Hbn330/mkiXlBtzadn2rO39FRcVhszUAUrHZGhAVVf2yMQdy7G6geXuc+EKtV4+cZ55xPo5/8kmUMJ67O5j15+t1vDyGv/4CwB4d7ezOr9dnkpamsnCh6nItWrjQcR2snjd4QkWCbiFCTP/PPySMHk3CnXeiP6bdEVQjIsh5+GHSly+n6IorQlxCIUSw2e12mjRxXZaZSZllZ2vSBKzW4PSG8DURkt1uR1Xh8svdT1t02WWgopDf/wYyVq2iYPBg57qRP/5Ico8eRH/wAbhJsGSzqX7ti4o+g9Xq7T52XVY62eXatXaOHFFZu9bOXXflY7cfw2azebVdm82166e748D9eoFPmOXte4PdpwRx5dVdPU7xOcP5iDHEkQtoydJOzp9P7uOPa0kNPLDZ/Ks7bxmNRnS6VGbNiqFbNx2NGyt066Zj1qwYdLpUjEajfxsOAu+Pm6rrau8pIaCnRILeKhw6lKKuXQEwHDxI7PTpgSh2SASz/gKS0M5sRn/wIKAlUXP0SrLb7YCNv/5yTW6pxee2kueFgwTdQoRKYSGx06aRctVVRK5c6Vxs7tGD9JUryXvwQYgM//FXQoiKuRt7N3eu9gPGk6oYM+do3VXVdHS6zHLn1nV8BosFPv9cmz6rSxft/88/17pgO8YP2hMTyXrzTU7OmYOtQQMAdPn51H3ySZIGDCgzB29lxw+W9xni4y1ebbdePffDyQoKctDrj6Oqx9DrjzvnCfd3LKV366m8+abCww9rLciqqrWCPfywQr9+Buz2RI/rl8eb937oITs6nZ6+fQ08/LDurPfXuX3/snWnMpSv+JO2DONL59LiG0eS8cMPFHfu7FV54+KKvKq7+Pgir7Z3Npstib59Ff77X9f9/N//KvTrp2CzJfm13WAI5NjdQFHVRJ+OE58pClkvvohacnMm9u23MezZE4CSV72qqD9vr+PuGA4cQCkJoEv3PjlTx4G9FtVUEnQLUdVUlcjvvyelRw/ipk5FMWsXPluDBpyaNYtTH3+MrVmz0JZRCFGlLJZCbrrJTqdOZ5bNn6/NPVx6WWmdOsGYMTgDvVBz9xlK69QJRo60u/zYK7rmGtJXrnQmRgIwbdtGUt++xD/+OEpJIsnCwhxuuSXw+yIvL9Or7ebk+NZN0p994e16AwbAq6+6f74yCbO8ee9Ro1TmznWfhby89y9dd6kcZQFD+IobaMAJALL19Tj97hdkTn0ZtU4dr8ubn3/Kq7rLyzvl9TYd/EncF0r+Hm/BUlWJ3WwtWpA3bhwAisVC/OOPa5FfmKlu9Xe2s5OoQe1K3hcoEnQLUYX0+/aRMGoUCbfdhqFkAI+q15M3dizpP/2EuV8/j8mEhBA119lj76xW+L//g3nzVKZOVV3G450ZO1y9xsz5M35QjY8ne8oUMr/6CkvJzAyKqhLz8cekXHEFUfPmgd3uHD84eXJg90VERJbH7UZEZFXZvqh4PZWbb1bKnS4MYPp0HWZzbFDKXFhoZ/p0zz8d3b2/XpfBihHv8HdkW5fp4/aeP4CiX37DOvBKv8prNJ7yWHdGo+8BN0BeXjQzZiiYTDBihJbUcMMG7f8RI8BohBkzFHJzo/3afjAEauxuIBQVxfh1nPgj9777sJY0VERs3EjUF19UepvejEMP9Fj16lR/Zzt7jm6o2jquKSR7uZ8ke7nwhZKXR+z06cS++y5KqeOmqGtXsidNCvgUYFJ/4U3qL3wFou7OZMjWYbNpXQoNBhO5udEYDApWq9aNurq0cLvj7jN41UpjsRAzezZ1Xn0VXX6+c3Fxp05kvfAC1nbtiI6OC+i+0Ov1qGoi2dl6IiMVjEatK7zZrBIfb0NRTno37rEc/u4L9+vF0aiR58xgigJHjlRuTubyy5zi8/vr9++n7iOPELF+vfM1tqQUTk+YjuHGvhQU5vpdTofY2ASysyOcx0R8fJFfLdxnpHLppQpffqlN2zd7Nhw+DI0ba0M+rrsOhg2D9etVVLV6ZWf2+9wLKN+Pk8pcOyN++onEkSMBsNWrR/rq1aglyRp94bgWfPKJjunTdc46Hz/ezk032Z2Bb0WvCcX1Ipjq3n8/0QsWAJC+YgXWNm3wp45rKm+zl0vQ7ScJuoVXVJWoRYuImzQJ/fEz09hYGzYk55lngtayLfUX3qT+wpfUXWDojh0j/rnniFpyZnoxVacj/5ZbyP3Pf1Dr1g3ce+lS6NvX4LabZKdOsHRp9fnRGOqpoXx6f/txYt95hzqvvOIcRgVQcMMNZD/zjF9BkSeBPPdstgZkZOgYO9Z9F/NOnWDWLEhJCc50feHOn+O0svVXd9w4ohcvBiB/xAiyX3nF5214cy1QFMLmehEoSdddh+m331B1Oo7t2wcRESG/FlUnMmWYECFm/O03EocOpd599zkDbtVkIveBB8j46SfM/ftLV3IhhHDDnprK6ZkzyfzsMywlYwgVu53Y99+nfteuxLz9Npgr3/oTbuMSQ50wy9v3j/31B5L69iXu+eedAbe1SRNOfvopWa+9FvCAO9Di4opZtkz1eFwsX64SH19ctQULE6E4TnP+9z/sJTkBYubNw+hu8mgPvLsW6Nm0KXyuFwGhqs7u5bamTSEiAgj9tSgcSdAtRIDpjh+n7oMPktSnDxEbNzqXm6++mvQffyT3scdQo6vPODAhhKiuiq+4gozly8l54gnsUdqYSV12NvETJ2rjvefPh0pMSxNu4xJDnXCpovfv1+4A96waTt0B/TD98QcAqqKQd8cdZKxYQVH37kEpV6Dl5uqYMcPzTfEZMxRycuRntDuhOE7t9euT++ijzsfxEyb4lFTNu2uBQmRk+FwvAkF37Bi6Am1WiNKZy0N9LQpHcrUQIlAKC4l97TVSLr+c6C++QCm52FubN+fkRx9x6oMPJCu5EEL4ymQi7957Sf/pJwqGDUMt6SFkOHKEeg88QHLv3kSsXu3XpnU6ncfukaBNgaPXV5+fS6FOuOTu/ds0zmN9rydZsrcNUUu/cr7Wcv75ZC5eTM6ECagxMUEtVyCF43FR3fhynBqNUdhsiaSng82W6HdSsvzRo7G0bAmAacsWIksNT6mIt3UeH1/xaypzXAQ6QVtluUui5hDqa1G4kauFEJVVMm47pXt34l5+2XlH0B4fT/azz5K+ciVFPXuGuJBCCBHe7I0akTVtGhnLlmG+6irncuOOHSTeeCMJI0diKGld9XqbdjtNmnh+TZMmYLP535oeaDabDVVNZ/ToLNatK+bIESvr1hUzenQWdnt6pZI4+fz+a8ycmvY+fxS3osvyF1CKtDmxbYmJZE2ZQsb332MprymsGgvH46K68eY41ev16HQpfPRRPF27mmjQALp2NfHRR/HodCno9Xrf3tRgIOeZZ5wP455/HgoLvVrV2zrPzq74Nf4cF2fvi8aNDZXbFwFi+Osv599nB91n1/Hx41TptSjcSNAtRCUYt24laeBA6t17L4YjR4CSKcBuvZX0tWvJHzsWTKYQl1IIIWoOa9u2nPr4YzLnzaP4wgudyyN/+onk3r2pO24chj//9Gpb4TwusbjYjE6Xiaqmo9NlVnk3TnXdGlIGXkrd/7sdfbqWwVs1Gsm75x7S166l4KabIESBQmWF83FR3Xg6TlU1kb59DTz8sNbKrKpaS/HDD+vo18+A3Z7o8/sVXXUV5h49AK03TOw773i1nnd1rmI2B+e4CMa+CASjh5Zuh+JiM3r9SVJSQK8/KV3KyyFBtxB+0O/fT7277ya5f39MpZJ1mK+6Sht/OGkS9mqeKEYIIcJZ8eWXk/nNN5x+802sJU1UiqoSvXgxKVdfTcItt1SYTEnGJfrOuGULCTffTPKgQZi2bXMuL7z2WtJ//JGcp55CjYsLXQEDQI6L4AtmEsOcZ55BLbnhE/vmm+hOnKhwHe/q3EbnzoE/LqpzQsfS3csdSS2FfyToFsIHusxM4p56ipQrryRq6VLnckvLlpycO5dTH3+MtVWrEJZQCCFqEZ2OwsGDSf/pJ7L/9z9siWdagyJ/+IHkAQNIvOEGTGvWlJtUScYlese0YQOJI0aQPGAAkStXOpdbzj+fzHnzOP3++9iaNw9hCQOrth0XVT2WOJhJDK2tWlEwahQAuoIC6kyZ4tV63tR5MI6L6pzQ0Zm5PCGh2s86UN3JPN1+knm6axclP5+Yd94hduZMdPn5zuW2pCRyH3xQu7gbDCEsoSupv/Am9Re+pO5CSyksJPqzz4iZORPD0aMuzxVfdBF599+P+eqrQVf2B67JFInZHIvJZKK4uJjIyDxpyVRVTGvXUmf6dCLWr3d5ytq4MXn330/BiBHV4vsvWOee47jQ63XYbPYad1zo9XpUNZFPPtExfbqOw4ehcWOtm/RNN9lRlJNBGpubQqNGno8bRYEjR/yb91p36hQp3bqhy8lBVRQyvvsOa7t2Xq3rTZ0H9rgI7r7wl5KXR2rr1gAUde7MyYULy39tLf7uk3m6hQgEi4XoDz8kpVs34qZOdQbc9uhoch96iPR16yi45ZZq8YNDCCFqOzUqivzbbiN93TpOv/oq1nPPdT5n+vVXEm67jeQePYh5912UU6dc1pVxiaWoKhE//kjSwIEkjRjhEnBbzzmH06+8oo3brmY3nIMh1GPngy1UY4mDnazOnpBA7vjxgDbsJP7ZZ72eQsybOg/kcVFdE/d5SqImfCdBtxDu2O1ELllCylVXUfeJJ9BnZABakrT80aNJX7eO3P/8BzW25szFKIQQNYbJROHw4aSvWsWpmTOxtG3rfMq4bx/xzz5Lg4svpu7992PasMGn+XxrMt2pU8TMmkXylVeSOGqUS84Sy3nncXr6dNJXr6ZwxAgwGkNYUhEIoRxLXBXJ6vJvuw1ryVStEevXE/ndd35vK5iqa+I+w969zr+tMp670iToFqI0VSXy++9JvuYaEu65B8PffzufKuzbl/QffyT7xRexp6SEsJBCCCG8otdjHjCAjGXLOPnRRxRdeqnzKaWoiOgFC0gaOpTkK68k5p13yrR+1wqqimndOuqOG0f9Tp2If+45l4zFltatOTVjBhk//kjh9dfX+Jbt2iSUY4mrJFmdyUTO0087H8ZNmgQl09pVJ9U1cZ+nObqF7yToFgLOdKXr25eE227DuHOn86miLl3IWLqU0++8g03u9AkhRPhRFIp69uTkV1+R/tNP5N15J/a6dZ1PG/ftI37CBOp37Ag33kjkN9+gFBSErrxVQJeRQeyMGaRcdhlJw4YRvXgxSnGx8/miLl049e67ZCxfjnngwLCd/kuUT6fTupR7cugQ6PXBCReqIlmd+dprnTfbDAcOEDNnTqW3GQzVMXGfdC8PLEmk5idJpFZzmH7+mTpTphDxyy8uy4s7dCD3kUco6t5du/qFkdpUfzWR1F/4kroLI2YzUd9+S/Qnn5RJEgagRkZivuIKzL17U9SrF/bE0MyTG0i6o0eJXLGCyB9+IOKnn1CsVpfnbQkJFN5wAwUjR4bdj2w593xntyfRtavJY+DdtCmsW1eMTpcZtHIEO4mh4Y8/SO7dG0VVscfFkb52bbU9n6tT4r7kHj0w7tmDajJxbN8+jzfeavP5520iNekjJGot0y+/UOfll4lYt85luaVtW3IeeYSiq68Ou2BbCCGElyIjKRw8mMLBgzHs20f0J58Q/eWX6E6fBkAxm4latoyoZctQdTqKO3fG3Ls35muvxda0aYgL7yW7HeO2bUQuX07k8uUYd+xw+7Kiyy4jf+RIzL17Q0REFRdShIo2llhLolYex1jiUp0gAk5LYlhESkoqx46dpLg4sEGbtV07CoYPJ2bePHQ5OdR55RWyX3ghoO8RKFqCNjOqqk2yEMz97pHVimH/fu3Pc8+Vni4BIC3dfpKW7jDlYfoTS8uW5P7nP5j79nU7nUw4qbH1V0tI/YUvqbvwphQXk7prF/mffkrk99+jT3c/PY+1cWOKO3XC0rGj9v8FF4DJVMWldcNuR79/P6bffyfip5+IWLkSfab7Fkpb/foU3HADBSNG1Ij5teXc849Ol0K/fgZK5cxz6tQJ0tKs2O3Bn6Yq2PWnO3GClMsvR5efj6rTkbF8OdaS6bBEWfq//6b+5ZcDWk6j0++84/H1tfn8k5ZuIUpTVSJWrKDO9OmYzkrTaW3WjNyHHqJw0CC5kyeEELVZRAT07k1O+/Zkv/ACxq1bifz+e6K+/dbZ6gNgOHwYw+HDsHgxAGpEBJYLL6S4Y0eKO3bE2qYNtsaNUaOigldWiwXDnj0Y//gD444dGH//HeOOHc6pLd0pbt8ec69eFPXqhaVdu7C/wSwqTxtLnMhnn2nzdB86pE1PNX68nZEj7SEZSxwM9vr1ybvvPuJeegnFbifuhRc49eGHoS5WtSVJ1AJPgm5Rs9ntRH77LXWmTy/Trc7avDm5999P4ZAhMvWJEEIIVzodlosvxnLxxeQ+8QSGffuI/O47IlatwrhtGzrzmXGWSlERps2bMW3e7LIJW0ICtsaNtX+NGp35OzERjEZUg0H7X68/89hgAFVFd/Ik+pMn0WVmosvI0B6X/K0/cQLD3r0uic/csUdHU3TFFRT16oX5qquw168flF0lwpfNZgPSGT06kmHDqsdY4mDJGzuWmI8+Qn/sGJHLl2Nav57iUjMaiDMkiVrgSdAtaiaLhaglS4h94w2MpeYZBLC0aUPuAw9g7tdPWraFEEJUTFGwtmxJXsuW5N1/v9bKvHu3Fmhv3Ypp61aXlnAH/alT6E+dgt9+q5JiWhs1wnLhhVjatcNy0UUUdekCkYGfY1nUPNVmLHEwRUWR88gj1HvoIQDinn+ezKVLJX+PG8Y9e5x/S9AdGBJ0ixpFyckh+tNPiX3vPfTHjrk8V9y+PXnjx2O++mrpUieEEMJ/RiPWdu20BE233AKA7tQpjFu3Yvr1V/QHD6I/fFj7d/w4it0e0LdXdTqszZufCbAvuABLu3aoCQkBfR8haprC668n9t13Me7cienXX4lMS8Pcv3+oi1XtmEpm9FGNRiwtW4a4NDWDBN2iRtAdOULs7NlEf/IJurw8l+eKOncmb/z4sJz6SwghRHiwJyRQVDJe2oXFgv748TNB+OHD6LKytOm6Sv4pFgvYbNr/JdN42RMTtX9JSdiSk51/25OTtTnGpaeWEL7T68l54gkSb74ZgLjJkzFfe231SIRYTehOnHD23Cnu0AGCmZuiFpGgW4Q14++/EzNrFlFLlqDYbC7Pma++mry776a4S5cQlU4IIUStZzRia9IEW5MmoS6JEAIo6tGDoq5difj5ZwwHDhD9yScU3HprqItVbZg2bHD+Lb+hA0eCbhF+bDYily8nZvbsMnNsqxERFFx/Pfl33iljUIQQQgghhCtFIeepp0ju0weAOq++SuH116PWqRPiglUPERs3Ov+WoDtwJOgWYUN38iTRn31G9Mcfa1O1lGJLSKDgllvIHzMGe1JSiEoohBBCCCGqO0v79hQMHEj04sXoT50iduZMch99NNTFqhZMJUG3qtNRfPHFIS5NzSFBt6j2jNu2ETNnDlFLl6IUFbk8Z23enLw776TwhhuCOx+qEEIIIYSoMXIfe4yob75BsViIeecd8kePxt6gQaiLFVLKqVMYd+0CwHLhhaixsSEuUc0hQbeonsxmopYuJeaDDzBt2+bylKooFPXoQf6tt1J05ZWSiVwIIYQQQvjEds455I8eTezs2egKC6nz6qtkT5kS6mKFVMSmTc6/i//97xCWpOaRoFtUK4Y//iB63jyiFy5El5Xl8py9bl0Khg8nf/RobM2ahaR8QgghhBCiZsj7v/8j+osv0OXmEv3ZZ+SPHYu1Fk+RVTqJWtGll4awJDWPBN0i5JTsbKIWLiR63jxMv/9e5vnidu3Iv/VWzAMHShdyIYQQQggREPaEBPLuvZe4yZNR7HbqvPACp+fMCXWxQsZUOonaJZeEsCQ1jwTdIjTsdkw//0z0vHlEffstitns+nRkJOa+fckfPRpLp04yv7YQQgghhAi4/DvuIOaDD9AfP07UsmXkb9pEcefOoS5WlVNyczH+8QcAlvPPR61XL8Qlqlkk6BZVyrBnD1ELFhC1aBGGQ4fKPF/cvj0FI0ZQOGgQalxcCEoohBBCCCFqCzUqityHH6buww8DEDdxIplLltS6Bh/T5s0odjsg47mDQYJuEXS6I0eIWrKE6AULMP75Z5nn7XXrUjB0KAUjRmBt2zYEJRRCCCGEELVVwQ03EPPuuxh378a0dSuR33yDuW/fUBerSrmM55b5uQNOgm4RFMrp00R98w1RCxdi2rABRVVdnld1Ooouv5yC4cMx9+4NEREhKqkQQgghhKjVDAZy/vtfEm+5BYC4F1/EfM01YDSGtlxVKKJU0C0t3YEnQbcIGF1mJpHff0/kt98SsXYtisVS5jXFF11E4eDBFPbvjz0lJQSlFEIIIYQQwlVRr14UXXopEevXY9i/n+i5cym49dZQF6tKKIWFGLdvB8B67rnyGz0IJOgWlaI7coSo774j8ttvMW3c6BwLUpr13HMpGDKEwkGDsDVvHoJSCiGEEEII4YGikPP00yT36QNAnVdfpXDo0FqRY8i4dauzsUy6lgeHBN3CN6qKYe9eIn/4gchvvsG0bZvbl1kbNsTcty+FQ4ZgufDCWpeMQgghhBBChBdL+/YUDBpE9KJF6E+dIvatt8j9739DXaygk67lwSdBt6iQUlCAad06IleuJGLlSgyHD7t9nfXccyns0wdznz5Y/vUvCbSFEEIIIURYyX38caK++QaluJjY994jf/Ro7I0ahbpYQVU6iVrxpZeGsCQ1lwTdwi39/v3w5ZfUW7iQiPXrUYqK3L7OcsEFFF53HeY+fbC2aiWBthBCCCGECFu2Jk3Iv/VWYmfNQjGbiZsyhazp00NdrOApLsa0dSsA1saNsdXwGwyhIkG3AECXkYHp55+JWLeOiLVrMfzzDwCRZ71ONZko6tKFoh49MF97LbZzzqn6wgohhBBCCBEkuQ88QPTnn6PLyiJq/nzyxo7F2q5dqIsVFMbt21HMZkC6lgeTBN21lJKVRcSGDZjWrSNi3TqMu3eX+1pbairmnj0x9+xJcbduqDExVVhSIYQQQgghqo5aty65DzxA/HPPoagq8ZMmcfKzz2pkj86IjRudfxdLErWgkaC7ltAdOYJp82bt3y+/YPzjjzJzZzuoJhPFnToRMXAgGZ07Y5Fu40IIIYQQohbJv+UWYj74AMPBg0SsWUPEqlUU9egR6mIFXOnx3JK5PHgk6K6JrFaMO3di+uUXLcDevBnD0aPlvlzV6bC0b09Rt24UdeuG5ZJLIDqa1NRUrMeOQTnBuRBCCCGEEDVSRAQ5jz9OwrhxAMRNmkTGFVeAXh/iggWQ1Yrpl18AsKWkyNS+QSRBd01is5F4000Yt2xBV1BQ7stURcHapo0zyC7u0qXMHITSri2EEEIIIWoz84ABFL/zDqZt2zDu2kXUl19SOGJEqIsVMMY//0SXlweUjOeWnq1BI0F3TaLXo8vMLBNw26OjsVx0EcUXX0zxJZdQ3LEjanx8iAophBBCCCFEGFAUcp5+mqShQwGImzIF84ABqNHRIS5YYEjX8qojQXcNU3zxxSjZ2VgcAfbFF2Np2xYMUtVCCCGEEEL4orhLFwqvuYaoZcvQnzhBzKxZ5D34YKiLFRAu83NL0B1UtSIS27p1K19//TV///03VquVhg0bcuWVV3Lttdei0+lCXbyAyp4wASZPDnUxhBBCCCGEqBFyn3ySyBUrUGw2YmfOpGDUKOzJyaEuVuXY7c7M5fa6dbG2ahXiAtVsNSvidGPRokVMnjyZ33//ndjYWBo0aMCBAweYM2cOU6dOxW63h7qIgRUREeoSCCGEEEIIUWNYW7Sg4KabANDl51PnlVdCXKLKM+zZgy4rC4Cif/8balhDZHVTo/funj17+Oyzz1AUhQceeIA33niDl19+mZdeeon4+Hg2b95MWlpaqIsphBBCCCGEqMZyH3oIe0wMANGffIJhx44Ql6hyXLqW//vfISxJ7VCjg+758+ejqio9e/bksssucy5v1qwZY8aMAWDx4sVYrdZQFVEIIYQQQghRzdmTk8m77z4AFLud+KeeCutpdR1dy0HGc1eFGht0FxQU8PvvvwNw1VVXlXm+S5cuREVFkZuby44wv1MlhBBCCCGECK68u+7C2qwZABGbNhE1f35oC+QvVXW2dNtjY7FccEGIC1Tz1dig+8CBA1itVoxGI83dTPRuMBho0aIFAHv37q3q4gkhhBBCCCHCSUQE2ZMmOR/GTZqEkpMTwgL5R79/P/r0dACKL7lEZjmqAjU26D527BgASUlJ6PV6t69JSUkB4Pjx41VWLiGEEEIIIUR4KurRg8LrrgNAn5FBnalTQ1wi37l0LZfx3FWixt7WyM/PByA2Nrbc18SUJEPIy8sr9zUWiwWLxeJ8rCgKUVFRzr9rKsdnq8mfsSaT+gtvUn/hS+ouvEn9hS+pu/AWbvWXO2ECkT/+iGI2EzNnDoUjRmANoy7aprPGc1d2v4db/YVCjQ26i4uLAa0beXmMRiOAS1B9toULF/LVV185Hzdv3pyXXnqJ5HCfm89LDRo0CHURRCVI/YU3qb/wJXUX3qT+wpfUXXgLm/pLTYWnnoKnnkKx20meMAFWr4ZwCDptNli/Xvs7MpKk664Dkykgmw6b+guBGht0m0oOHk+ZyR3BtiP4dmfw4MH069fP+dhxBycjI6NGZz1XFIUGDRpw/Phx1DDOzFhbSf2FN6m/8CV1F96k/sKX1F14C8v6u+kmkmfPxrB/P6xdS9abb1J4/fWhLlWFIr7/noTDhwEwd+vG6ZMnK73NsKy/ADEYDF41xtbYoNubruPedEE3Go3lBuW14aBSVbVWfM6aSuovvEn9hS+pu/Am9Re+pO7CW1jVn8lE9sSJJI4aBUCdiRMpvPpq1Li4EBfMs5j33nP+nT9mTED3d1jVXxWrsYnUUlNTAcjMzMRms7l9TXpJ1j7pCiGEEEIIIYTwRbglVTPs3EnEunUAWJs3p6hHjxCXqPaosUF3s2bN0Ov1WCwW9u/fX+Z5q9XKvn37AGjZsmVVF08IIYQQQggR5nKefRZ7ZCQAMXPmYNixI8QlKl/MnDnOv/Nvuw10NTYUrHZq7J6Ojo7mX//6FwArV64s8/yGDRsoLCykTp06XBBG2QaFEEIIIYQQ1YOtcWPyHngAAMVuJ/6pp6AadrFWTp0iev58AOyxsRQMGxbiEtUuNTboBi0JmqIorFixgrVr1zqXHzhwgA8//BCAAQMGeMxwLoQQQgghhBDlybv7bqzNmgEQsWkTUSXBbXUS89lnKGYzAAXDh6N6yGklAq9GR5tt2rRh+PDhzJs3j9dff53PP/+cyMhIDh48iKqqdOzYkf79+4e6mEIIIYQQQohwFRFB9qRJzqRqcZMmYb76atT4+BAXrITVSvQHHwCgKgr5t94a2vLUQjW6pRtgyJAhPPbYY7Rr147c3FyOHz9O06ZNueWWW3j00UfRyVgGIYQQQgghRCUU9ehBYe/egJZUre6jj1abbuaR336L4ehRAIp69sTWvHmIS1T71OiWbodOnTrRqVOnUBdDCCGEEEIIUUPlPPccEevXo8vOJiotjaJPP6XgpptCXSxi3n/f+Xfe7beHsCS1lzTzCiGEEEIIIUQl2Ro1IqvUtGHxzzyDYffuEJYIjL//TsSmTQBYWrWi+PLLQ1qe2kqCbiGEEEIIIYQIAHOfPuSPGQOAYjZT7+67UQoLQ1aemNmznX/n33YbKErIylKbSdAthBBCCCGEEAGS/cwzWM4/HwDjnj3E/e9/ISmHLiODqMWLAbDXrUvh9deHpBxCgm4hhBBCCCGECJzISE7PnIk9KgqAmE8+IbIk+K1K0XPnohQXA5A/ciRqSXlE1ZOgWwghhBBCCCECyNqyJdnPP+98XPexx9D/80/VFaC4mJiPPgJA1ekoKOnyLkJDgm4hhBBCCCGECLDCYcMoGDIEAF1uLvXuvRdKWp6DLSotDX16OgDm3r2xNW5cJe8r3JOgWwghhBBCCCECTVHIfvFFrM2aAWD69VfipkypkrcuPU1YvkwTFnISdAshhBBCCCFEEKixsZyeORPVaAQgduZMIn78MajvadyyBdOvvwJgueACiv/976C+n6iYBN1CCCGEEEIIESSWf/2LnCefdD6uO348uuPHg/Z+pacJy7v9dpkmrBqQoFsIIYQQQgghgij/jjsw9+oFgP7kSZKGDMGwb1/A38f0889Eff01ALbERAoHDgz4ewjfSdAthBBCCCGEEMGkKGRNm4a1USMADP/8Q9KAAZjWrQvYW0R+/z2Jo0ahWK0AWsbyyMiAbV/4T4JuIYQQQgghhAgye0ICmYsWYbngAgB02dkkjhxJ1OefV3rbUV98Qb2xY1GKigAw9+xJ7r33Vnq7IjAk6BZCCCGEEEKIKmBv2JDMhQsx9+wJgGK1Uu+hh6gzeTLY7X5tM+bdd6n34IMoNhsABUOGcGr2bGnlrkYk6BZCCCGEEEKIKqLGxHBqzhwtyVmJOm+8oc3jXVjow4ZU6kyZQvyzzzoX5d12G1nTp0NJtnRRPUjQLYQQQgghhBBVSa8n57nnyJ44EVWnhWRRS5aQNGwYuszMite324l/8knqTJ/uXJT70EPkPPcc6CTEq26kRoQQQgghhBAiBPJvu41Tc+Zgj44GwLR1K0n9+xP1xReY1q1D//ffKGe3flss1L3/fmI+/NC5KPu558j9z39kerBqyhDqAgghhBBCCCFEbVXUqxeZCxeSOGYM+uPHMRw8SL0HH3R5jb1uXWypqdhSU9GdPo3p118BUPV6sl59lcLrrw9F0YWXJOgWQgghhBBCiBCytmtHRloaCbfcgumPP8o8r8vKQpeVhXHnTucyNSKCU2+/TdE111RlUYUfJOgWQgghhBBCiBCzp6aSuXQpEatXYzh4EP3Ro+iOHUNf6p9isWivrVOHU++/T3HXriEutfCGBN1CCCGEEEIIUR2YTBT16kWRu+fsdnQnT6I7cQJbw4aoCQlVXTrhJwm6hRBCCCGEEKK60+mwJydjT04OdUmEjyR7uRBCCCGEEEIIESQSdAshhBBCCCGEEEEiQbcQQgghhBBCCBEkEnQLIYQQQgghhBBBIkG3EEIIIYQQQggRJBJ0CyGEEEIIIYQQQSJBtxBCCCGEEEIIESQSdAshhBBCCCGEEEEiQbcQQgghhBBCCBEkEnQLIYQQQgghhBBBIkG3EEIIIYQQQggRJBJ0CyGEEEIIIYQQQSJBtxBCCCGEEEIIESQSdAshhBBCCCGEEEEiQbcQQgghhBBCCBEkEnQLIYQQQgghhBBBIkG3EEIIIYQQQggRJBJ0CyGEEEIIIYQQQWIIdQHClcFQO3ZdbfmcNZXUX3iT+gtfUnfhTeovfEndhTepv/BWG+vP28+sqKqqBrksQgghhBBCCCFErSTdy4VbhYWFPPbYYxQWFoa6KMIPUn/hTeovfEndhTepv/AldRfepP7Cm9RfxSToFm6pqsr+/fuRjhDhSeovvEn9hS+pu/Am9Re+pO7Cm9RfeJP6q5gE3UIIIYQQQgghRJBI0C2EEEIIIYQQQgSJBN3CLaPRyPXXX4/RaAx1UYQfpP7Cm9Rf+JK6C29Sf+FL6i68Sf2FN6m/ikn2ciGEEEIIIYQQIkikpVsIIYQQQgghhAgSCbqFEEIIIYQQQoggkaBbCCGEEEIIIYQIEkOoCyCq1ltvvcVPP/3k8TVz587FZDKVWb5nzx4WLVrE7t27MZvNpKSk0K1bNwYMGOD29SKw0tPTue+++7x67bPPPkvbtm0B+OKLL/jqq688vn7atGk0atSo0mWs7dLT0/ntt9/Yt28ff/31F4cOHcJutzN8+HCGDh3qcV1/z6/Dhw+zYMEC/vjjD/Lz80lISOCSSy5h6NChxMTEBPoj1lj+1N3+/fvZtGkTf/75J4cPH6agoICYmBjOPfdcevXqRefOnd2ut2rVKmbMmOGxPE888QQdOnSo7MeqNfypv8peG+XcCxx/6m/YsGFebXvcuHFceeWVzsdy/gWOqqrs3r2bX375hV27dnHkyBGKioqIi4ujZcuW9O7dm3bt2pW7vnzvhZa/9Sffff6RoLuWSk1NJS4uzu1zOl3ZDhBr1qzhrbfewm63k5CQQFJSEgcPHuSLL75gy5YtPPvss0RERAS72LWayWSidevW5T6flZXFiRMnMBqNNGvWrMzziYmJJCUluV1X6i4wvvnmG7755huf1/P3/Prjjz+YPHkyxcXFxMXF0bhxY44ePUpaWhq//PILEydOpG7dugH4ZDWfr3V3/PhxHnvsMefjlJQUkpOTOXHiBNu2bWPbtm10796de+65x+01FSA+Pp4GDRq4fU5+OPrG33MP/Ls2yrkXWP7Un6fvw/z8fA4fPgxAq1at3L5Gzr/K++OPP5g4cSIAiqLQoEEDIiMjOXbsGJs2bWLTpk0MGTKEESNGlFlXvvdCz5/6k+8+/0nQXUsNHjzY5c6vJ+np6bz99tvY7XZGjRpF//79URSFjIwMnn/+ef766y/mzp3L7bffHtxC13J169Z1Xhzdef311zlx4gQXX3wx0dHRZZ7v0aOH1y0Dwj916tShY8eOtGjRghYtWrBixQo2btzocR1/z6/CwkJee+01iouLue6667j55psxGAzk5uYyZcoUdu/ezdtvv83jjz8ezI9cY/hTd/Xq1aNPnz5cccUV1KtXDwC73c6yZcuYM2cOP/30E+eddx69e/d2u36HDh249957A/5ZaiN/6s/B12ujnHuB50/9efo+nDdvHocPH6ZFixY0bNjQ7Wvk/Ks8VVVp0KAB/fr1o2vXrsTGxgJgtVr54osvWLRoEQsWLKBly5Z06tTJuZ5871UP/taffPf5R8Z0iwotWbIEi8VC+/btGTBgAIqiAJCcnMw999wDwPLly8nKygphKWs3s9nML7/8AsAVV1wR4tLUXkOHDuXxxx/n+uuvp0OHDkRGRla4jr/n1w8//EBOTg6NGjVizJgxGAzaPdQ6deowfvx49Ho9W7du5e+//w7sh6yhfK27hIQEXn/9dQYOHOj80QFaT6HevXvTq1cvAFasWBHUcguNP+eev+TcC7xA1p+qqqxZswaQ78Nga9GiBdOmTeOaa65xBmwABoOBkSNHctFFFwFlr4PyvVc9+FN/8t3nPwm6hUeqqjqDuR49epR5vnXr1jRq1AibzcbmzZuruniixMaNG53jcGrqWJiaqDLnl6MV6MorryzThSspKYkLL7wQgA0bNgSj6LWeyWTyOCyjffv2ABw9erSqiiSqiJx71dvOnTvJyMhAr9fTtWvXUBenRouOjkav15f7vONcOHbsmHOZfO9VH/7Un3z3+U+6l9dSGzZsYNOmTRQWFhIfH0/r1q3p3r17mW7JmZmZnD59GoA2bdq43Vbr1q05cuQIe/fudd7hElXLcVe/a9eu5V5Ad+zYwauvvkpubi6xsbG0aNGC7t27y9inEPL3/LLZbM47+eWNa2zdujXbtm1j3759QSi5qEhxcTGAx2RA//zzD9OnTycrK4uoqCiaN2/O5ZdfXu5YNxEcvlwb5dyr/hzfhx06dCg3dw3I+VcVLBYL4HodlO+98OGu/ioi333lk6C7ltq6davL459//pkvvviC8ePHu7SUOu5uGY1Gl24kpaWkpABacgVR9U6fPs3vv/8OeO5Kt3PnTpfHGzdu5Msvv+SOO+7weny/CCx/z6+MjAxsNhsA9evXd7ueY3npO9Si6qxfvx7wnOzpwIEDHDhwwPl48+bNzJ8/n2HDhjFkyJBgF1GU8OXaKOde9WaxWJytnBV1LZfzL7hUVXXWRenroHzvhYfy6q8i8t1XPgm6a5n69etz44030rFjR1JSUlAUhT179vD555+zd+9eXn75ZZ577jnOO+88QMsACloXFMeYm7M5xoHk5eVVzYcQLtasWYOqqjRs2JAWLVqUeb5evXoMHjyYzp07U79+fUwmE/v372fBggX8+uuvzJw5k9jYWC6++OIQlL528/f8Kv13eZk+Hcsd7yGqzvbt253dJwcMGFDm+ejoaHr37k23bt1o0KAB0dHRHDlyhLS0NFavXs28efOcrxHB48+1Uc696m3Lli3k5+cTHR3tkvipNDn/qsaKFSvYv38/BoOBPn36OJfL9154KK/+PJHvPs8k6K5lrr/++jLL/vWvf9G2bVueeeYZ9u3bxyeffMIzzzwDnOla4khW4Y7jOUeXElG1KkoYc/XVV5dZ1rp1ax5//HFeeeUVNm3axIcffkinTp3K/QIUweHv+eVYz9O6RqOxzHoi+DIzM3n99dcBuOaaa2jbtm2Z13Tu3LnMPKbNmjXjvvvuIzY2lm+++YZ58+bRvXt3oqKiqqTctZE/10Y596q31atXA9ClS5dyu7fK+Rd8f//9N3PmzAFgxIgRLt2G5Xuv+vNUf+WR776KSSI1AWgXsOHDhwPa+DbHHUXHBcxqtZa7ruM5X8Z8iMA4ePAg//zzD4qicPnll/u0rqIojBw5EoATJ07wzz//BKOIwgN/zy/Hep7W9WcslqicvLw8XnjhBXJzc7ngggsYM2aMz9sYNmwYRqORgoIC/vjjjyCUUlTE07VRzr3qKzc3l19//RWA7t27+7UNOf8qLz09nZdeegmLxcJll11G//79XZ6X773qraL6c0e++7wjQbdwatWqFaCN40hPTwfOdNUpKChAVVW36zkC9NLTDYiq4birf/7555OcnOzz+g0bNnTWm4zJr3r+nl+l/y6vG51jeXnd8ERgmc1mXnzxRQ4fPsy5557Lo48+6vIj0VvR0dE0btwYkHMylMq7Nsq5V339/PPP2Gw2kpOTy03QVRE5/yonKyuLiRMncvr0aTp27Mi4cePK9KCT773qy5v6O5t893lPgm7hVDrrtSNZRWpqKqDdPXRkmzybI0Cv6VkHqxu73c66deuAys1F6qh3u90ekHIJ7/l7fiUnJzvr7cSJE27Xcyx3vIcIHovFwpQpU9i7dy+NGzfmiSeeqFTXOEfXScd1WISGu2ujnHvVl2Oo1eWXX16poVJy/vknLy+PiRMncuLECdq2bctDDz3kthu4fO9VT97WX2ny3ecbCbqF0+HDh51/JyYmAtq8h45pU3bt2uV2vd27dwPQsmXL4BZQuNixYwcnT57EaDTSpUsXv7aRk5NDTk4OAAkJCYEsnvCCv+eXXq/n3HPPdXm+vPXcJdcTgWOz2Zg2bRp//PEH9evX56mnnvI4TVFF7Ha7c35Tx3VYVL3yro1y7lVPx48fZ8+ePUDlbkLL+ecfR2vnoUOHOO+883jsscfK7eIt33vVjy/15yDffb6ToFs4LV26FIBGjRo5f2QoiuJMevDjjz+WWWf37t0cOXIEvV4v2a+rmKNr+cUXX1xmfnVvpaWloaoq0dHR8iUVApU5vxzrrVq1qkwvhczMTOc0cv7ekBEVU1WVt956i82bN1OvXj2efvrpSt+8WrlyJfn5+eh0Oi644IIAlVT4ytO1Uc696sfxfdiiRQsaNmzo93bk/PNd6dbOJk2a8OSTT3ps7ZTvverF1/oD+e7zlwTdtchvv/3Gp59+6uy241BQUMD777/v7Ko8dOhQl+cHDBiAwWBg+/btLFmyxDkGJyMjg5kzZwLQs2dP551LEXzFxcVs2rQJ8HxX/9ChQ7z33nscOnSozPoLFixg8eLFAAwcOLDCbkQiOPw9v66++mrq1KnDkSNH+PDDD52JZXJzc5k+fTo2m42LLrrI2TIgAm/OnDmsXbuWOnXq8PTTTzvnlvWkoKCA1157jX379rkst9vtLF++3Jkx9qqrrpLeJ0FUmWujnHvVz9q1a4GKW7nl/Assu93Oa6+95tLa6U1+H/neqx78rT/57vOPopaXxUDUOJs2bWLq1KmA1l2uXr162Gw2Dh8+jNVqRVEUhg4dyrBhw8qs+9NPPzFjxgxUVSUhIYH4+HgOHjyIzWbj3HPP5dlnnyUyMrKqP1KttXbtWl5//XXi4uKYNWuWy3j80g4cOMCjjz4KQFxcHElJSQAcOXKEoqIiQLvA3XXXXTJdWADs2rWLl19+2fnYbDZjsViIiIhw6ar10ksvOesC/D+/fv/9dyZPnozFYnHWr6Nuk5OTef755+VmmJd8rbs9e/bw1FNPAVpXuNL1ebaJEyc6/87Pz+fWW28FtGQ/KSkp6HQ6jh8/7kwCdNFFF/Gf//xHMvD6wNf6q+y1Uc69wPL32gk4z0W9Xs+sWbM8dnGV8y+wHL9FQBtHXd6+r1evHg899JDLMvneCz1/6k+++/wnTVu1yLnnnsuQIUPYs2cPx48f59ChQ86LXZs2bbj22mvLHZfdvXt3GjRowMKFC9mzZw+HDx+mfv36dOvWjYEDB9bYE6S6ciSM6dq1a7kBN2iJR4YPH86ePXs4cuQIR48exWq1Eh8fz0UXXcRVV11Fhw4dqqjUNZ/NZiM3N7fM8qKiIucPeSibtM7f8+vCCy9k8uTJzJ8/nx07dnDw4EESEhLo3LkzQ4YMkRkFfOBr3ZWeM/bkyZOcPHnSq/eJiIhg1KhR7N69m0OHDnH8+HGKi4upU6cOHTt25IorruDSSy+Vm2A+8rX+KnttlHMvsPy9dsKZruUdOnSocEypnH+BVXrqrmPHjnHs2DG3r3M3u4p874WeP/Un333+k5ZuIYQQQgghhBAiSGRMtxBCCCGEEEIIESQSdAshhBBCCCGEEEEiQbcQQgghhBBCCBEkEnQLIYQQQgghhBBBIkG3EEIIIYQQQggRJBJ0CyGEEEIIIYQQQSJBtxBCCCGEEEIIESQSdAshhBBCCCGEEEEiQbcQQgghhBBCCBEkEnQLIYQQQgghhBBBIkG3EEIIIYQQQggRJBJ0CyGEEH649957GTZsGKtWrfL4umeffZZhw4bxxRdfVE3BhBBCCFGtSNAthBBCCCGEEEIEiQTdQgghhBBCCCFEkEjQLYQQQgghhBBCBIkh1AUQQgghaqvdu3ezdOlSdu/eTV5eHvHx8bRr145BgwbRuHHjMq9/9tln+fPPP/nf//5HTEwM8+fPZ9euXeTk5HDPPfdw5ZVXoqoqq1evZuXKlfzzzz8UFRURGxtLQkICF154Iddddx2JiYku21VVlZ9//pmVK1eyf/9+zGYzCQkJdOzYkSFDhlC3bl2X1+/YsYMJEybQtm1bnnrqKRYuXMjatWvJzMwkNjaWSy65hBEjRhAbG+v2c2dmZrJw4UK2bdvG6dOniYqK4rzzzuO6667joosucnltWloaH330EX379mXMmDEuzz3//PNs376dxMREZs6c6fLcqlWrmDFjBt27d+fee+91ee7kyZMsXryY7du3k5mZidFopHnz5lx77bV06dLFr/0uhBBClEeCbiGEECIEli1bxuzZs1FVlfj4eJo1a8bx48dZvXo169ev5z//+Q8dO3Z0u+7OnTtZuHAher2ehg0bEhkZ6Xzu448/Ji0tDYCkpCRSU1PJzc3l0KFD7N+/n1atWrkE3Varlddff50NGzYAUK9ePRITEzl+/DjfffcdGzdu5H//+x8NGzYsUw5VVZk6dSpbt24lNTWVRo0acejQIZYtW8Zvv/3GxIkTiY+Pd1ln7969vPDCC+Tn5xMREUHTpk3Jzs5m27ZtbNu2jaFDhzJ8+HDn69u2bQvAn3/+6bIdu93Onj17AC2IPnHiBPXr13c+73i9Y/3Sy6dMmUJBQQEmk4nU1FTy8/PZsWMHO3bsoF+/fowePdrn/S6EEEKUR4JuIYQQooodOHCAOXPmoKoqo0aNol+/fuh0OiwWCx9++CHLli3j9ddfZ9q0adSrV6/M+l999RVXXXUVY8aMISIiAoDi4mJycnL4+uuviY6O5vHHH6dNmzbOdYqLi/nll19cAlOAL774gg0bNtC8eXPuuecemjVr5nz9Rx99xLJly3jjjTd48cUXy5Rjz549mEwmnnnmGdq1awdordgvvfQS//zzD7Nnz+ahhx5yvr6oqIhp06aRn5/PpZdeyt13301UVBSgtUy//fbbzJ8/n1atWjlbvJs1a0ZUVBQHDhygoKCA6OhoAP7++28KCwtJSEjg1KlT/Pnnny6fbefOnYBr0H3q1CmmTp1KYWEhN954I/369cNoNAJar4Np06aRlpbGBRdcQKdOnbze70IIIYQnMqZbCCGEqIQZM2YwbNiwcv+d3UILsGTJEmw2GxdffDEDBgxAp9O+jo1GI7fffjtNmjShoKCAZcuWuX3PJk2acMcddzgDPwCTycTx48dRVZV27dq5BNyO57t168Y555zjXOYI0qOionj00UedAbfj9bfddhvnnXcef/31lzOILc1ms3HDDTc4A27QWtfvu+8+ADZu3MiJEyeczzm6oMfHx3Pvvfc6A26AK6+8kl69egGwaNEi53KdTkebNm1QVZVdu3Y5lzv264ABA1wegxZcnzhxgsTERJdAPC0tjby8PPr06cPgwYOdATdA69atGTt2LABff/11mc8K5e93IYQQwhMJuoUQQohKSE1NpXXr1uX+Kx1YOvz2228AXHfddWWeUxTFudzxurNdfvnlzkC9tKSkJEDrwp2ZmVlh2bdu3YrFYqF9+/ZlxnmDFvA6Wnzd3TwwGAz07NmzzPJzzjnHGShv377dudzxd8+ePd0Gq3369AG0Vmez2excfv7555cpw86dO1EUhSuuuIKkpCSX5xx/O9Zz2Lhxo/P93enQoQMGg4Hdu3djs9nKPF/efhdCCCE8ke7lQgghRCUMHjzYYyItRxIuh/z8fHJycgDcJksrvfzo0aMenz9bQkICXbp0YcOGDdx///20a9eOtm3bcv7559OyZUv0er3L6w8ePAhoQfrTTz/tdpvZ2dmA1np8tsTERLc3FQAaNWrErl27OHbsmHOZ4+/yyp+amorBYMBqtXLixAlnq7yji7ijtd1ut7Nr1y6aNm1KbGwsbdu2ZfXq1WRmZroE4KW7lpvNZjIyMgCYNWuW2/d3sFgs5ObmlkkgV165hRBCCE8k6BZCCCGqUOkW3LOTjDk4gr3Sry2tdPfms9133300btyYlStXsn37dmfrclxcHAMGDHCOHwcoKCgAtERkJ0+e9Fhud2OX4+Liyn2947MVFhY6lzk+T3mfW1EU4uLiOHXqlMt65557LhEREfz999+YzWaOHz9Ofn4+V1xxBaC1aK9evZo///yTK664wm3Q7fisoLWkV8Td5/W034UQQojySNAthBBCVKHSGa+zs7PdJkrLysoq81pvmUwm53jyI0eOsHPnTrZs2cLWrVuZO3cucGYctGP7Q4YMYcSIET6/l6PF3tNzpVvCHe/naD0/m6qqbtczGAy0atWK33//nd27d3PkyBHgTFBdOsP5v/71L44ePUp8fLxLxvXS+/LTTz/FYJCfQEIIIaqGDEwSQgghqlBMTIyzhfjw4cNuX+NY7m6aLl80atSIXr168dhjj3HHHXcAsGLFCufzju7Sjm7mvjp58mS5rfGOwDg1NdW5zPF3eZ/72LFjWK1WdDpdmSzrjvHZO3fu5M8//0RRFOey1NRU6tWrx44dO5xd0M8ezx0dHe28wVHe+wshhBDBIEG3EEIIUcXat28PwLffflvmOVVVncsdrwuEli1bAnD69Gnnso4dO2IwGPj1119dxl57y2q1snLlyjLLDx486Ex09q9//cu5vEOHDoAW+Lvrvu343K1bty7Tyu9ozd6xYwe7du2icePGLt3bzz//fE6cOMGaNWtcXl/av//9b6D87ORCCCFEMEjQLYQQQlSx/v37o9fr2bx5M0uXLsVutwNaEDtnzhwOHTpEdHQ011xzjU/b/f333/n444/LtOSazWaWLFkCQPPmzZ3LExIS6NOnDzabjeeff54dO3a4rKeqKvv27ePdd991mfrLQa/X88UXX7gkijt58iRvvfUWAJ07d6ZBgwbO57p160ZSUhLZ2dnMmDHDpZV89erVLF++HIBBgwaVea8WLVpgNBrZs2cPOTk5ZVqyHUH2li1bXB6XNnDgQGJjY/npp5/48MMPyc/Pd3k+Ly+PlStXMn/+/DLrCiGEEP6SAU1CCCFEFWvWrBm33nors2fP5uOPP2bJkiUkJSU5E4QZjUYeeOCBMtmzK1JYWMjSpUtZunQpcXFxJCcnY7VaOX78OEVFRURHRzNmzBiXdW688UZOnz7NmjVrmDBhAnXr1iUpKQmLxUJ6erozoZljOq/SWrVqRVRUFM8++yypqalERkZy8OBBbDYb9evX5/bbb3d5fUREBA8++CDPP/88P//8M1u2bKFx48ZkZWU5E7kNGTKEiy66qMx7mUwmWrRo4ew+fnZQ7Xisqip16tShSZMmZbaRmJjIo48+yssvv8zXX3/Nd999R6NGjYiIiCAnJ4f09HRUVaVr167e7nIhhBCiQhJ0CyGEECFwzTXX0LRpU5YuXcru3bs5cOAAcXFxdOzYkcGDB/s1PdX555/Prbfeym+//cahQ4c4fPgwer2eBg0a0L59e/r161cmkNfr9dx///1069aNFStWsHfvXvbv309sbCypqam0atWKLl26uIzNdlAUhYcffpiFCxeyZs0aDh8+TFxcHJdccgnDhg1zm928ZcuWvPzyyyxcuJDt27fzzz//EBERQfv27bnuuuvo2LGjx89XXtDt6G6ek5NDmzZtUBTF7TbatGnDtGnT+Oabb9iyZQsnTpzAbreTkJBAhw4d6NSpE507d65oVwshhBBeU1RVVUNdCCGEEEKEjx07djBhwgTatm3Ls88+G+riCCGEENWajOkWQgghhBBCCCGCRIJuIYQQQgghhBAiSCToFkIIIYQQQgghgkSCbiGEEEIIIYQQIkgkkZoQQgghhBBCCBEk0tIthBBCCCGEEEIEiQTdQgghhBBCCCFEkEjQLYQQQgghhBBCBIkE3UIIIYQQQgghRJBI0C2EEEIIIYQQQgSJBN1CCCGEEEIIIUSQSNAthBBCCCGEEEIEiQTdQgghhBBCCCFEkEjQLYQQQgghhBBCBMn/Azjh+AIMK3tXAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6), tight_layout=True)\n", + "plt.style.use('ggplot')\n", + "\n", + "# Scatter plot of the Auto data\n", + "sns.scatterplot(data=Auto, x='horsepower', y='mpg', color='blue', s=50)\n", + "\n", + "# Line plot of the predicted values\n", + "plt.plot(hp_grid_df['horsepower'], hp_grid_df['mpg_pred'], color='red', linewidth=2)\n", + "\n", + "# Adjust the text size\n", + "plt.xticks(fontsize=16)\n", + "plt.yticks(fontsize=16)\n", + "plt.xlabel('Horsepower', fontsize=16)\n", + "plt.ylabel('MPG', fontsize=16)\n", + "plt.title('Horsepower vs MPG', fontsize=18)\n", + "\n", + "# Show plot\n", + "plt.show()\n", + "\n", + "# Save the plot as EPS file\n", + "#plt.savefig(\"01_auto_poly10.eps\", format='eps')" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "c2196050-965a-498d-b59d-884059d64bfa", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x testmse trainmse\n", + "0 1 23.361903 24.623010\n", + "1 2 20.252691 18.144194\n", + "2 3 20.325609 18.035030\n", + "3 4 20.343887 17.908378\n", + "4 5 20.036431 17.393915\n", + "5 6 19.966946 17.210659\n", + "6 7 20.186598 17.293690\n", + "7 8 20.357129 17.455614\n", + "8 9 20.267491 17.524121\n", + "9 10 20.105590 17.408553\n" + ] + } + ], + "source": [ + "from sklearn.metrics import mean_squared_error\n", + "\n", + "# Lists to store models and MSE values\n", + "models = []\n", + "test_mse = []\n", + "train_mse = []\n", + "\n", + "# Try 10 models\n", + "for i in range(1, 11):\n", + " # Polynomial features\n", + " poly = PolynomialFeatures(degree=i)\n", + " X_train_poly = poly.fit_transform(train_data[['horsepower']])\n", + " X_test_poly = poly.transform(test_data[['horsepower']])\n", + " \n", + " # Linear regression model\n", + " model = LinearRegression()\n", + " model.fit(X_train_poly, train_data['mpg'])\n", + " \n", + " # Store the model\n", + " models.append(model)\n", + " \n", + " # Predict on train and test data\n", + " y_train_pred = model.predict(X_train_poly)\n", + " y_test_pred = model.predict(X_test_poly)\n", + " \n", + " # Calculate MSE\n", + " train_mse.append(mean_squared_error(train_data['mpg'], y_train_pred))\n", + " test_mse.append(mean_squared_error(test_data['mpg'], y_test_pred))\n", + "\n", + "# Create a DataFrame for MSE values\n", + "mse = pd.DataFrame({'x': range(1, 11), 'testmse': test_mse, 'trainmse': train_mse})\n", + "print(mse)" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "2e1588d2-ba82-4cda-8911-a2c1e7b4a97d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The PostScript backend does not support transparency; partially transparent artists will be rendered opaque.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create the plot\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "# Plot Test MSE\n", + "plt.plot(mse['x'], mse['testmse'], color='red', label='Validation MSE')\n", + "plt.scatter(mse['x'], mse['testmse'], color='red')\n", + "\n", + "# Plot Train MSE\n", + "plt.plot(mse['x'], mse['trainmse'], color='blue', label='Train MSE')\n", + "plt.scatter(mse['x'], mse['trainmse'], color='blue')\n", + "\n", + "# Add labels and title\n", + "plt.xlabel('Flexibility (Degree of Polynomial)', fontsize=18)\n", + "plt.ylabel('MSE', fontsize=18)\n", + "plt.legend()\n", + "plt.xticks(fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "\n", + "# Show the plot\n", + "plt.show()\n", + "\n", + "# Save the plot as EPS file\n", + "#plt.savefig(\"01_auto_mse_seed3.eps\", format='eps')" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data.pdf b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data.pdf new file mode 100755 index 0000000..e1512db Binary files /dev/null and b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data.pdf differ diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_1.ipynb b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_1.ipynb new file mode 100755 index 0000000..c4a9900 --- /dev/null +++ b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_1.ipynb @@ -0,0 +1,267 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "03c68072-8fd9-4c26-9f8b-e6f6e24fd583", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{01\\_Auto\\_data\\_1}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "4e117807-3711-444b-838d-775303383d93", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "e0c43ee7-0ede-4d7e-9966-f00493b33f0a", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "**Get and Set working directory**:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "57ab9acc-8d99-4165-8930-db6ae2be39a9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/01_SupLearn_Regression\n" + ] + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4424246b-bee1-4b9e-a5ac-79c20e4b4c26", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationyearoriginname
018.08307.0130350412.0701chevrolet chevelle malibu
115.08350.0165369311.5701buick skylark 320
218.08318.0150343611.0701plymouth satellite
316.08304.0150343312.0701amc rebel sst
417.08302.0140344910.5701ford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin name \n", + "0 1 chevrolet chevelle malibu \n", + "1 1 buick skylark 320 \n", + "2 1 plymouth satellite \n", + "3 1 amc rebel sst \n", + "4 1 ford torino " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from ISLP import load_data # Package which contains the data\n", + "Auto = load_data('Auto') # Loading the data\n", + "Auto.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "141f0257-39a4-4e21-9be0-78dfd645445a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import statsmodels.formula.api as smf\n", + "\n", + "# fit model on training data and calculate training MSE\n", + "fit_lm = smf.ols(formula='mpg ~ horsepower', data = Auto).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4ae9bf59-3b73-4020-b039-885948f6cbbd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 39.9359 0.717 55.660 0.000 38.525 41.347\n", + "horsepower -0.1578 0.006 -24.489 0.000 -0.171 -0.145\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "print(fit_lm.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77170717-6eb1-41fa-a2b6-fdbf5e9193cf", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_1.pdf b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_1.pdf new file mode 100755 index 0000000..cd042fe Binary files /dev/null and b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_1.pdf differ diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2.ipynb b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2.ipynb new file mode 100755 index 0000000..bf1d6ea --- /dev/null +++ b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2.ipynb @@ -0,0 +1,562 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "03c68072-8fd9-4c26-9f8b-e6f6e24fd583", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{01\\_Auto\\_data\\_2}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "4e117807-3711-444b-838d-775303383d93", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "23889938-8996-46c5-8751-fe1c7da1deb0", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Setup for Tasks 2" + ] + }, + { + "cell_type": "markdown", + "id": "962ac167-f15c-4ab4-8abd-a9d1ab26455c", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "The following steps will outline the initial setup of the Auto dataset, including the creation of\n", + "separate training (train data) and test (test data) sets." + ] + }, + { + "cell_type": "markdown", + "id": "e0c43ee7-0ede-4d7e-9966-f00493b33f0a", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Get and Set working directory" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "57ab9acc-8d99-4165-8930-db6ae2be39a9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/01_SupLearn_Regression\n" + ] + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory" + ] + }, + { + "cell_type": "markdown", + "id": "e20de814-7963-4856-8892-b5a913ef10b9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Loading the package and data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4424246b-bee1-4b9e-a5ac-79c20e4b4c26", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationyearoriginname
018.08307.0130350412.0701chevrolet chevelle malibu
115.08350.0165369311.5701buick skylark 320
218.08318.0150343611.0701plymouth satellite
316.08304.0150343312.0701amc rebel sst
417.08302.0140344910.5701ford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin name \n", + "0 1 chevrolet chevelle malibu \n", + "1 1 buick skylark 320 \n", + "2 1 plymouth satellite \n", + "3 1 amc rebel sst \n", + "4 1 ford torino " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from ISLP import load_data # Package which contains the data\n", + "Auto = load_data('Auto') # Loading the data\n", + "Auto.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "fc65f415-1870-4b3f-bbdd-cf89eedec1b9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "n = int(len(Auto)) # Number of observations in the dataset\n", + "nT = int(n/2) # training sample size\n", + "nV = int(n/2) # validation sample size" + ] + }, + { + "cell_type": "markdown", + "id": "fd7b9df2-ad21-4de3-87bc-18b5939439ce", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Define training and test set" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d942dc0e-7286-4c46-ae15-a69cbaeb25b1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "np.random.seed(2) # set seed\n", + "\n", + "# Define training and test sets\n", + "train_sample = np.random.choice(n, nT, replace=False) # indices for training data\n", + "train_data = Auto.iloc[train_sample] # training dataset\n", + "test_data = Auto.drop(train_sample) # test dataset" + ] + }, + { + "cell_type": "markdown", + "id": "b8e653c9-fa9b-4414-a8a6-8d785b3e9913", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "We start with the following univariate linear regression:\n", + "\n", + "\\begin{equation*} \n", + " \\text{mpg} = \\beta_{0} + \\beta_{1} \\text{horsepower} + \\varepsilon\n", + "\\end{equation*} " + ] + }, + { + "cell_type": "markdown", + "id": "5b497789-eb36-412c-b95d-50ab29d0c9f4", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Fit model on training data and calculate training MSE" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "141f0257-39a4-4e21-9be0-78dfd645445a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import statsmodels.formula.api as smf\n", + "\n", + "# fit model on training data and calculate training MSE\n", + "fit_lm = smf.ols(formula='mpg ~ horsepower', data = train_data).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "4ae9bf59-3b73-4020-b039-885948f6cbbd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 39.0131 0.994 39.245 0.000 37.053 40.974\n", + "horsepower -0.1510 0.009 -17.040 0.000 -0.168 -0.134\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "print(fit_lm.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "77170717-6eb1-41fa-a2b6-fdbf5e9193cf", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Predictions for training data\n", + "y_head_train = fit_lm.predict(train_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eecfb895-dc1c-43e9-bcb4-13697cd6a602", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Squared Error: 23.002\n" + ] + } + ], + "source": [ + "# Function to compute the mean squared error (MSE)\n", + "# Takes realized values y and corresponding predictions y_head\n", + "# as inputs and returns MSE as output\n", + "def MSE(y, y_head):\n", + " return((y - y_head)**2).mean()\n", + "\n", + "# Compute the mean squared error\n", + "MSE_train = MSE(train_data['mpg'], y_head_train)\n", + "print(f\"Mean Squared Error: {MSE_train:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1da45d5e-86a2-4cd0-bbc7-1f02fcd17421", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Extra visualisation" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "15c7664a-bf12-485f-96bd-26c4018b0756", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.12/site-packages/sklearn/base.py:493: UserWarning: X does not have valid feature names, but LinearRegression was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.linear_model import LinearRegression\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6), tight_layout=True)\n", + "plt.style.use('ggplot')\n", + "\n", + "# Scatter plot of the Auto data\n", + "sns.scatterplot(x=Auto['horsepower'], y=Auto['mpg'], color='blue', s=50)\n", + "\n", + "X = Auto[['horsepower']] # Make sure X is a 2D array\n", + "y = Auto['mpg']\n", + "lm = LinearRegression().fit(X,y)\n", + "\n", + "# Generate predictions across the range of horsepower values\n", + "x_range = np.linspace(Auto['horsepower'].min(), Auto['horsepower'].max(), 100)\n", + "x_range_reshaped = x_range.reshape(-1, 1) # Reshape x_range to a 2D array\n", + "y_pred = lm.predict(x_range_reshaped)\n", + "\n", + "# Plot the predicted line together with the data\n", + "plt.plot(x_range, y_pred, color='red', label='Fitted line')\n", + "\n", + "# Adjust the text size\n", + "plt.xticks(fontsize=16)\n", + "plt.yticks(fontsize=16)\n", + "plt.xlabel('Horsepower', fontsize=16)\n", + "plt.ylabel('MPG', fontsize=16)\n", + "plt.title('', fontsize=18)\n", + "\n", + "# Show plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "34765acf-c72c-4f4c-9c6c-7259c57c1535", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Task 2" + ] + }, + { + "cell_type": "markdown", + "id": "e9fbd0f6-598b-413f-a584-669b68fad554", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1. Compute the test MSE for the univariate linear model and note the training and test MSE." + ] + }, + { + "cell_type": "markdown", + "id": "d1f3413f-6ece-4238-a398-38debb776882", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "**Hint**:\n", + "First copy line $84$ and generate predictions $\\hat{y}$ for the test data. Then copy line $98$ and change it correspondingly to compute the test MSE." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "94a8fac9-ef1a-4841-b67d-1fe0c053080d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "377b9c15-fdf7-4c6b-8cf3-187cff086e45", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "2. Compute and note the training and test MSE for a quadratic model:\n", + "\n", + "\\begin{equation*} \n", + " \\text{mpg} = \\beta_{0} + \\beta_{1} \\text{horsepower} + \\beta_{2} \\text{horsepower}^{2} + \\varepsilon\n", + "\\end{equation*}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e8cdb96a-1898-4000-b540-7b690557d353", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b2d02d24-b07d-4a91-a65c-1fb83a175819", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "3. Redo Step 2 but add the term horsepower$^{3}$ to the regression. Then add horsepower$^{4}$ and so on. For each model note the training and test MSE. How do the two MSE change with the flexibility of the method?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1d95f27b-33e2-41b4-b674-e7f44a883458", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2.pdf b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2.pdf new file mode 100755 index 0000000..c3fedd1 Binary files /dev/null and b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2.pdf differ diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2_solution.ipynb b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2_solution.ipynb new file mode 100755 index 0000000..2a3084f --- /dev/null +++ b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2_solution.ipynb @@ -0,0 +1,940 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "03c68072-8fd9-4c26-9f8b-e6f6e24fd583", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{01\\_Auto\\_data\\_2\\_solution}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "4e117807-3711-444b-838d-775303383d93", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "23889938-8996-46c5-8751-fe1c7da1deb0", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Setup for Tasks 2" + ] + }, + { + "cell_type": "markdown", + "id": "962ac167-f15c-4ab4-8abd-a9d1ab26455c", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "The following steps will outline the initial setup of the Auto dataset, including the creation of\n", + "separate training (train data) and test (test data) sets." + ] + }, + { + "cell_type": "markdown", + "id": "e0c43ee7-0ede-4d7e-9966-f00493b33f0a", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Get and Set working directory" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "57ab9acc-8d99-4165-8930-db6ae2be39a9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/01_SupLearn_Regression\n" + ] + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory" + ] + }, + { + "cell_type": "markdown", + "id": "e20de814-7963-4856-8892-b5a913ef10b9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Loading the package and data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4424246b-bee1-4b9e-a5ac-79c20e4b4c26", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationyearoriginname
018.08307.0130350412.0701chevrolet chevelle malibu
115.08350.0165369311.5701buick skylark 320
218.08318.0150343611.0701plymouth satellite
316.08304.0150343312.0701amc rebel sst
417.08302.0140344910.5701ford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin name \n", + "0 1 chevrolet chevelle malibu \n", + "1 1 buick skylark 320 \n", + "2 1 plymouth satellite \n", + "3 1 amc rebel sst \n", + "4 1 ford torino " + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from ISLP import load_data # Package which contains the data\n", + "Auto = load_data('Auto') # Loading the data\n", + "Auto.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "fc65f415-1870-4b3f-bbdd-cf89eedec1b9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "n = int(len(Auto)) # Number of observations in the dataset\n", + "nT = int(n/2) # training sample size\n", + "nV = int(n/2) # validation sample size" + ] + }, + { + "cell_type": "markdown", + "id": "fd7b9df2-ad21-4de3-87bc-18b5939439ce", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Define training and test set" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "d942dc0e-7286-4c46-ae15-a69cbaeb25b1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "np.random.seed(2) # set seed\n", + "\n", + "# Define training and test sets\n", + "train_sample = np.random.choice(n, nT, replace=False) # indices for training data\n", + "train_data = Auto.iloc[train_sample] # training dataset\n", + "test_data = Auto.drop(train_sample) # test dataset" + ] + }, + { + "cell_type": "markdown", + "id": "b8e653c9-fa9b-4414-a8a6-8d785b3e9913", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "We start with the following univariate linear regression:\n", + "\n", + "\\begin{equation*} \n", + " \\text{mpg} = \\beta_{0} + \\beta_{1} \\text{horsepower} + \\varepsilon\n", + "\\end{equation*} " + ] + }, + { + "cell_type": "markdown", + "id": "5b497789-eb36-412c-b95d-50ab29d0c9f4", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Fit model on training data and calculate training MSE" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "141f0257-39a4-4e21-9be0-78dfd645445a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import statsmodels.formula.api as smf\n", + "\n", + "# fit model on training data and calculate training MSE\n", + "fit_lm = smf.ols(formula='mpg ~ horsepower', data = train_data).fit()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "4ae9bf59-3b73-4020-b039-885948f6cbbd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 39.0131 0.994 39.245 0.000 37.053 40.974\n", + "horsepower -0.1510 0.009 -17.040 0.000 -0.168 -0.134\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "print(fit_lm.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "77170717-6eb1-41fa-a2b6-fdbf5e9193cf", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Predictions for training data\n", + "y_head_train = fit_lm.predict(train_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "eecfb895-dc1c-43e9-bcb4-13697cd6a602", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean Squared Error: 23.002\n" + ] + } + ], + "source": [ + "# Function to compute the mean squared error (MSE)\n", + "# Takes realized values y and corresponding predictions y_head\n", + "# as inputs and returns MSE as output\n", + "def MSE(y, y_head):\n", + " return((y - y_head)**2).mean()\n", + "\n", + "# Compute the mean squared error\n", + "MSE_train = MSE(train_data['mpg'], y_head_train)\n", + "print(f\"Mean Squared Error: {MSE_train:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1da45d5e-86a2-4cd0-bbc7-1f02fcd17421", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Extra visualisation" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "15c7664a-bf12-485f-96bd-26c4018b0756", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.12/site-packages/sklearn/base.py:493: UserWarning: X does not have valid feature names, but LinearRegression was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.linear_model import LinearRegression\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6), tight_layout=True)\n", + "plt.style.use('ggplot')\n", + "\n", + "# Scatter plot of the Auto data\n", + "sns.scatterplot(x=Auto['horsepower'], y=Auto['mpg'], color='blue', s=50)\n", + "\n", + "X = Auto[['horsepower']] # Make sure X is a 2D array\n", + "y = Auto['mpg']\n", + "lm = LinearRegression().fit(X,y)\n", + "\n", + "# Generate predictions across the range of horsepower values\n", + "x_range = np.linspace(Auto['horsepower'].min(), Auto['horsepower'].max(), 100)\n", + "x_range_reshaped = x_range.reshape(-1, 1) # Reshape x_range to a 2D array\n", + "y_pred = lm.predict(x_range_reshaped)\n", + "\n", + "# Plot the predicted line together with the data\n", + "plt.plot(x_range, y_pred, color='red', label='Fitted line')\n", + "\n", + "# Adjust the text size\n", + "plt.xticks(fontsize=16)\n", + "plt.yticks(fontsize=16)\n", + "plt.xlabel('Horsepower', fontsize=16)\n", + "plt.ylabel('MPG', fontsize=16)\n", + "plt.title('', fontsize=18)\n", + "\n", + "# Show plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "34765acf-c72c-4f4c-9c6c-7259c57c1535", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Task 2" + ] + }, + { + "cell_type": "markdown", + "id": "e9fbd0f6-598b-413f-a584-669b68fad554", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1. Compute the test MSE for the univariate linear model and note the training and test MSE." + ] + }, + { + "cell_type": "markdown", + "id": "d1f3413f-6ece-4238-a398-38debb776882", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "**Hint**:\n", + "First copy line $84$ and generate predictions $\\hat{y}$ for the test data. Then copy line $98$ and change it correspondingly to compute the test MSE." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "94a8fac9-ef1a-4841-b67d-1fe0c053080d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Predictions for test data\n", + "y_head_test = fit_lm.predict(test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "4c054d4c-bd52-483c-a252-a5fa6adaae88", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train MSE: 23.002\n", + "Validation MSE: 25.109\n" + ] + } + ], + "source": [ + "# Compute the \"Mean Squared Error\"\n", + "print(f\"Train MSE: {MSE_train:.3f}\")\n", + "\n", + "MSE_test = MSE(test_data['mpg'], y_head_test)\n", + "print(f\"Validation MSE: {MSE_test:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "377b9c15-fdf7-4c6b-8cf3-187cff086e45", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "2. Compute and note the training and test MSE for a quadratic model:\n", + "\n", + "\\begin{equation*} \n", + " \\text{mpg} = \\beta_{0} + \\beta_{1} \\text{horsepower} + \\beta_{2} \\text{horsepower}^{2} + \\varepsilon\n", + "\\end{equation*}" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "e8cdb96a-1898-4000-b540-7b690557d353", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==========================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------------------\n", + "Intercept 56.0467 2.594 21.610 0.000 50.931 61.162\n", + "poly(horsepower, 2)[0] -0.4566 0.044 -10.278 0.000 -0.544 -0.369\n", + "poly(horsepower, 2)[1] 0.0012 0.000 6.992 0.000 0.001 0.002\n", + "==========================================================================================\n" + ] + } + ], + "source": [ + "# Define polynomial function\n", + "def poly(x, degree):\n", + " return np.vander(x, degree + 1, increasing=True)[:, 1:]\n", + "\n", + "# Quadratic model\n", + "fit_lm2 = smf.ols(formula='mpg ~ poly(horsepower, 2)', data = train_data).fit()\n", + "print(fit_lm2.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "d2e2d83b-47fb-4b33-84a6-047784f75c9b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Predictions for test data\n", + "y_head_train_2 = fit_lm2.predict(train_data)\n", + "# Predictions for test data\n", + "y_head_test_2 = fit_lm2.predict(test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "987a0ad9-fd1c-4d3b-87a8-af11032d171c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train MSE: 18.353\n", + "Validation MSE: 19.723\n" + ] + } + ], + "source": [ + "# Compute the \"Mean Squared Error\"\n", + "MSE_train_2 = MSE(train_data['mpg'], y_head_train_2)\n", + "print(f\"Train MSE: {MSE_train_2:.3f}\")\n", + "\n", + "MSE_test_2 = MSE(test_data['mpg'], y_head_test_2)\n", + "print(f\"Validation MSE: {MSE_test_2:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "b2d02d24-b07d-4a91-a65c-1fb83a175819", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "3. Redo Step $2$ but add the term horsepower$^{3}$ to the regression. Then add horsepower$^{4}$ and so on. For each model note the training and test MSE. How do the two MSE change with the flexibility of the method?" + ] + }, + { + "cell_type": "markdown", + "id": "8d58316f-8d91-4aee-abcc-f832c61f2bc9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "- $\\text{horsepower}^{3}$ model:" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "1d95f27b-33e2-41b4-b674-e7f44a883458", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "==========================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------------------\n", + "Intercept 64.6844 6.696 9.660 0.000 51.477 77.891\n", + "poly(horsepower, 3)[0] -0.6878 0.171 -4.019 0.000 -1.025 -0.350\n", + "poly(horsepower, 3)[1] 0.0031 0.001 2.270 0.024 0.000 0.006\n", + "poly(horsepower, 3)[2] -4.746e-06 3.39e-06 -1.399 0.164 -1.14e-05 1.95e-06\n", + "==========================================================================================\n" + ] + } + ], + "source": [ + "# Quadratic model using poly() function.\n", + "# (yields same predictions as the quadratic model above but\n", + "# the polynomial degree can be easily adjusted)\n", + "fit_lm3 = smf.ols(formula='mpg ~ poly(horsepower, 3)', data = train_data).fit()\n", + "print(fit_lm3.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "0c588ff7-0658-4e46-923b-b9f6dea5dc01", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Predictions for test data\n", + "y_head_train_3 = fit_lm3.predict(train_data)\n", + "# Predictions for test data\n", + "y_head_test_3 = fit_lm3.predict(test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "7f5c8f0e-dbd0-4d51-9b18-f70bbeaf5ddd", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train MSE: 18.168\n", + "Validation MSE: 19.921\n" + ] + } + ], + "source": [ + "# Compute the \"Mean Squared Error\"\n", + "MSE_train_3 = MSE(train_data['mpg'], y_head_train_3)\n", + "print(f\"Train MSE: {MSE_train_3:.3f}\")\n", + "\n", + "MSE_test_3 = MSE(test_data['mpg'], y_head_test_3)\n", + "print(f\"Validation MSE: {MSE_test_3:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "76ad7276-852d-4164-919d-7750c4d359e8", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "- $\\text{horsepower}^{10}$ model:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "eaff5326-7fea-403e-a0f9-fc07679531a4", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===========================================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "-------------------------------------------------------------------------------------------\n", + "Intercept 2.256e-12 1.1e-13 20.570 0.000 2.04e-12 2.47e-12\n", + "poly(horsepower, 10)[0] 3.91e-10 1.9e-11 20.569 0.000 3.53e-10 4.28e-10\n", + "poly(horsepower, 10)[1] 8.099e-09 3.94e-10 20.570 0.000 7.32e-09 8.88e-09\n", + "poly(horsepower, 10)[2] 3.176e-07 1.54e-08 20.570 0.000 2.87e-07 3.48e-07\n", + "poly(horsepower, 10)[3] 8.66e-06 4.21e-07 20.571 0.000 7.83e-06 9.49e-06\n", + "poly(horsepower, 10)[4] -2.016e-07 1.11e-08 -18.115 0.000 -2.24e-07 -1.8e-07\n", + "poly(horsepower, 10)[5] 1.748e-09 1.07e-10 16.372 0.000 1.54e-09 1.96e-09\n", + "poly(horsepower, 10)[6] -6.662e-12 4.42e-13 -15.058 0.000 -7.54e-12 -5.79e-12\n", + "poly(horsepower, 10)[7] 9.413e-15 6.71e-16 14.022 0.000 8.09e-15 1.07e-14\n", + "poly(horsepower, 10)[8] -2.054e-19 1.96e-19 -1.046 0.297 -5.93e-19 1.82e-19\n", + "poly(horsepower, 10)[9] -1.066e-20 1.15e-19 -0.093 0.926 -2.37e-19 2.16e-19\n", + "===========================================================================================\n" + ] + } + ], + "source": [ + "fit_lm10 = smf.ols(formula='mpg ~ poly(horsepower, 10)', data = train_data).fit()\n", + "print(fit_lm10.summary().tables[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "67721d57-3743-47e5-98b6-8aa265f30a54", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Predictions for test data\n", + "y_head_train_10 = fit_lm10.predict(train_data)\n", + "# Predictions for test data\n", + "y_head_test_10 = fit_lm10.predict(test_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "a4a5d8d0-509c-43f3-bcde-ed887d579372", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train MSE: 57.118\n", + "Validation MSE: 79.702\n" + ] + } + ], + "source": [ + "# Compute the \"Mean Squared Error\"\n", + "MSE_train_10 = MSE(train_data['mpg'], y_head_train_10)\n", + "print(f\"Train MSE: {MSE_train_10:.3f}\")\n", + "\n", + "MSE_test_10 = MSE(test_data['mpg'], y_head_test_10)\n", + "print(f\"Validation MSE: {MSE_test_10:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6090a810-949e-4bea-99e1-4f6937ad4a87", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "- Setup for $10$ models with different polynomial degrees:" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "a4c7f519-e573-4492-a4ff-143d9502bdf9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " x testmse trainmse\n", + "0 1 25.108539 23.002395\n", + "1 2 19.722533 18.352971\n", + "2 3 19.921368 18.167881\n", + "3 4 19.823280 18.151318\n", + "4 5 19.115938 17.951430\n", + "5 6 18.891373 17.927435\n", + "6 7 19.129574 17.955439\n", + "7 8 19.341569 17.985236\n", + "8 9 19.322458 17.976080\n", + "9 10 19.132870 17.964630\n" + ] + } + ], + "source": [ + "from sklearn.preprocessing import PolynomialFeatures\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "# Lists to store models and MSE values\n", + "models = []\n", + "test_mse = []\n", + "train_mse = []\n", + "\n", + "# Try 10 models\n", + "for i in range(1, 11):\n", + " # Polynomial features\n", + " poly = PolynomialFeatures(degree=i)\n", + " X_train_poly = poly.fit_transform(train_data[['horsepower']])\n", + " X_test_poly = poly.transform(test_data[['horsepower']])\n", + " \n", + " # Linear regression model\n", + " model = LinearRegression()\n", + " model.fit(X_train_poly, train_data['mpg'])\n", + " \n", + " # Store the model\n", + " models.append(model)\n", + " \n", + " # Predict on train and test data\n", + " y_train_pred = model.predict(X_train_poly)\n", + " y_test_pred = model.predict(X_test_poly)\n", + " \n", + " # Calculate MSE\n", + " train_mse.append(mean_squared_error(train_data['mpg'], y_train_pred))\n", + " test_mse.append(mean_squared_error(test_data['mpg'], y_test_pred))\n", + "\n", + "# Create a DataFrame for MSE values\n", + "mse = pd.DataFrame({'x': range(1, 11), 'testmse': test_mse, 'trainmse': train_mse})\n", + "print(mse)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "901752cf-6c22-40ed-89f2-71f9cc704071", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# Create the plot\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "# Plot Test MSE\n", + "plt.plot(mse['x'], mse['testmse'], color='red', label='Validation MSE')\n", + "plt.scatter(mse['x'], mse['testmse'], color='red')\n", + "\n", + "# Plot Train MSE\n", + "plt.plot(mse['x'], mse['trainmse'], color='blue', label='Train MSE')\n", + "plt.scatter(mse['x'], mse['trainmse'], color='blue')\n", + "\n", + "# Add labels and title\n", + "plt.xlabel('Flexibility (Degree of Polynomial)', fontsize=18)\n", + "plt.ylabel('MSE', fontsize=18)\n", + "plt.legend()\n", + "plt.xticks(fontsize=14)\n", + "plt.yticks(fontsize=14)\n", + "\n", + "# Show the plot\n", + "plt.show()\n", + "\n", + "# Save the plot as EPS file\n", + "#plt.savefig(\"01_auto_mse_seed3.eps\", format='eps')" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2_solution.pdf b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2_solution.pdf new file mode 100755 index 0000000..0d01f84 Binary files /dev/null and b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/01_Auto_data_2_solution.pdf differ diff --git a/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/Plot_Ver2.png b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/Plot_Ver2.png new file mode 100755 index 0000000..2ff2d58 Binary files /dev/null and b/Machine Learning for Economics and Finance/01_Supervised Learning - Regression/Plot_Ver2.png differ diff --git a/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data.ipynb b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data.ipynb new file mode 100755 index 0000000..c8d1914 --- /dev/null +++ b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data.ipynb @@ -0,0 +1,184 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "6cbef61b-0897-42bf-b456-c0a409b87c41", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\\n", + " \\Large{Task 1: Logistic Regressions}\\\\[0.5cm]\n", + " \\Large{\\textbf{02\\_Default\\_data}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "13be77f3-44f0-4983-b4cb-bd3e4b5dba8b", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "72f918a4-cdd4-4b46-a88f-f4b43c3c3a88", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Task 1: Logistic Regressions" + ] + }, + { + "cell_type": "markdown", + "id": "0b3f9fc6-db4f-47b0-9dfa-e41d9f85a5ba", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.1 Randomly split the data into $7000$ observations for training and $3000$ observations for testing and set the seed to $1$ before sampling the data. Call these two datasets *train_data* and *test_data* respectively. (Hint: use the code to split the data from 01 Auto_data_2.R or Auto_data_2.Rmd)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "335aa198-5a94-4c5a-8ad8-67c78bcf71f5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "116c466d-0627-43d6-adbe-a937ac846a28", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.2 Fit a logistic regression of default on *income* using the *train_data*. Analyze the significance of\n", + "the estimated coefficients." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e38a201-7f2d-4999-beab-5739217a9318", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "43c6dade-5a22-476a-b3bf-bfd1b880038d", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.3 Compute the *out-of-sample accuracy* and *error rate* and compare to the *in-sample statistics*. Do\n", + "you think this is a good model to predict default?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44028726-1eff-436f-bc47-04a6786ae3ad", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "c28971ef-8bee-462d-9612-88f1534bfcb5", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.4 Add balance as a predictor and compute the *out-of-sample error rate* and *accuracy*. Do you\n", + "think this is a good model to predict *default*?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a7216df-adf5-4df0-9593-69c1a7649f64", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "f267ef66-1775-42a8-a1e9-45fda849f4d9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.5 Compare the results for Task $1.4$ to a model with only balance as a predictor. Which model\n", + "would you choose?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "28082bd5-8fe1-4160-aec0-1a92aebfa671", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "7ccad70f-5ef5-42c8-8c2e-22e76943d281", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.6 Take the model from Task $1.4$ but now re-estimate the model using different *seeds* to draw your\n", + "*training* and *test data*. Does your *test error rate* change with the seed? What’s going on here?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9ab2f559-83b1-4a66-b1dc-8799b8301d85", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.1" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data.pdf b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data.pdf new file mode 100755 index 0000000..aa531fa Binary files /dev/null and b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data.pdf differ diff --git a/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data_solution.ipynb b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data_solution.ipynb new file mode 100755 index 0000000..edccfe3 --- /dev/null +++ b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data_solution.ipynb @@ -0,0 +1,902 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "6cbef61b-0897-42bf-b456-c0a409b87c41", + "metadata": { + "editable": true, + "raw_mimetype": "", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\\n", + " \\Large{Task 1: Logistic Regressions - solution}\\\\[0.5cm]\n", + " \\Large{\\textbf{02\\_Default\\_data\\_solution}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "13be77f3-44f0-4983-b4cb-bd3e4b5dba8b", + "metadata": { + "editable": true, + "raw_mimetype": "", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "72f918a4-cdd4-4b46-a88f-f4b43c3c3a88", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Task 1: Logistic Regressions" + ] + }, + { + "cell_type": "markdown", + "id": "0b3f9fc6-db4f-47b0-9dfa-e41d9f85a5ba", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.1 Randomly split the data into $7000$ observations for training and $3000$ observations for testing and set the seed to $1$ before sampling the data. Call these two datasets *train_data* and *test_data* respectively. (**Hint**: use the code to split the data from *01_Auto_data.ipynb*)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "335aa198-5a94-4c5a-8ad8-67c78bcf71f5", + "metadata": { + "editable": true, + "scrolled": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "no-execute" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/02-SupLearning_Class\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
defaultstudentbalanceincome
0NoNo729.52649544361.625074
1NoYes817.18040712106.134700
2NoNo1073.54916431767.138947
3NoNo529.25060535704.493935
4NoNo785.65588338463.495879
\n", + "
" + ], + "text/plain": [ + " default student balance income\n", + "0 No No 729.526495 44361.625074\n", + "1 No Yes 817.180407 12106.134700\n", + "2 No No 1073.549164 31767.138947\n", + "3 No No 529.250605 35704.493935\n", + "4 No No 785.655883 38463.495879" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory\n", + "\n", + "# pip install ISLP --break-system-packages\n", + "from ISLP import load_data # Package which contains the data\n", + "default_data = load_data('Default') # Loading the data\n", + "default_data.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f980cc3a-cb5f-475f-ab83-add7af6ac643", + "metadata": { + "editable": true, + "scrolled": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " balance income\n", + "count 10000.000000 10000.000000\n", + "mean 835.374886 33516.981876\n", + "std 483.714985 13336.639563\n", + "min 0.000000 771.967729\n", + "25% 481.731105 21340.462903\n", + "50% 823.636973 34552.644802\n", + "75% 1166.308386 43807.729272\n", + "max 2654.322576 73554.233495\n" + ] + } + ], + "source": [ + "print(default_data.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2f35039e-b8b3-4f9b-b129-38fd6faed429", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# set seed\n", + "np.random.seed(1)\n", + "\n", + "# Number of observations in the dataset\n", + "n = len(default_data)\n", + "\n", + "# Shuffle the dataset using np.random.permutation\n", + "shuffled_indices = np.random.permutation(n)\n", + "\n", + "# Compute training and validation sample sizes\n", + "nT = int(0.7 * n) # Training sample size\n", + "\n", + "# Split the shuffled dataset based on the shuffled indices\n", + "train_data = default_data.iloc[shuffled_indices[:nT]] # First 70% for training\n", + "test_data = default_data.iloc[shuffled_indices[nT:]] # Remaining 30% for validation" + ] + }, + { + "cell_type": "markdown", + "id": "5b484b9d-6786-436b-b34b-a01ecdb0babd", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "Compute the percentage of defaulting (\"Yes\") values in the `default` column of the \"train_data\" and \"test_data\" datasets." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f8f69dcf-c511-4852-8e5f-21aeeae79072", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data percentage of defaulting: 0.03157\n", + "Test data percentage of defaulting: 0.03733\n" + ] + } + ], + "source": [ + "defaulting_train = (train_data['default'] == 'Yes').mean()\n", + "defaulting_test = (test_data['default'] == 'Yes').mean()\n", + "# The \"train_data$default == \"Yes\": creates a logical vector where each element is TRUE \n", + "# if the corresponding element.\n", + "# The outer mean() function than calculates the proportion of TRUE values \n", + "# in the logical vector.\n", + "\n", + "# Output the results\n", + "print(f\"Train data percentage of defaulting: {round(defaulting_train, 5)}\")\n", + "print(f\"Test data percentage of defaulting: {round(defaulting_test, 5)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "116c466d-0627-43d6-adbe-a937ac846a28", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.2 Fit a logistic regression of default on *income* using the *train_data*. Analyze the significance of\n", + "the estimated coefficients." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2e38a201-7f2d-4999-beab-5739217a9318", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: default No. Observations: 7000\n", + "Model: GLM Df Residuals: 6998\n", + "Model Family: Binomial Df Model: 1\n", + "Link Function: Logit Scale: 1.0000\n", + "Method: IRLS Log-Likelihood: -979.69\n", + "Date: Sat, 01 Feb 2025 Deviance: 1959.4\n", + "Time: 14:20:46 Pearson chi2: 7.01e+03\n", + "No. Iterations: 6 Pseudo R-squ. (CS): 0.0004155\n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -3.1353 0.179 -17.492 0.000 -3.487 -2.784\n", + "income -8.81e-06 5.18e-06 -1.700 0.089 -1.9e-05 1.35e-06\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "# Create a copy of the train_data DataFrame\n", + "# preventing to overwrite the original data\n", + "train_data_copy = train_data.copy()\n", + "\n", + "# Ensure the target variable is numeric (binary)\n", + "train_data_copy['default'] = train_data_copy['default'].map({'No': 0, 'Yes': 1})\n", + "\n", + "# Logistic regression model:\n", + "X_train = train_data_copy[['income']]\n", + "X_train = sm.add_constant(X_train) # Adds an intercept term to the model\n", + "y_train = train_data_copy['default']\n", + "\n", + "# Fit the logistic regression model\n", + "glm_fit = sm.GLM(y_train, X_train, family=sm.families.Binomial()).fit()\n", + "\n", + "# Alternative:\n", + "#glm_fit = sm.Logit(y_train, X_train).fit()\n", + "\n", + "print(glm_fit.summary())" + ] + }, + { + "cell_type": "markdown", + "id": "43c6dade-5a22-476a-b3bf-bfd1b880038d", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.3 Compute the *out-of-sample accuracy* and *error rate* and compare to the *in-sample statistics*. Do\n", + "you think this is a good model to predict default?" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "29235f3e-980e-42ee-a998-62f0e148e26a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample accuracy: 0.96843\n", + "In-sample error rate: 0.03157\n" + ] + } + ], + "source": [ + "# Predict probabilities on the training data\n", + "logit_probs_train = glm_fit.predict(X_train)\n", + "\n", + "# Predict default status based on the probability threshold (0.5)\n", + "logit_pred_train = np.where(logit_probs_train > 0.5, 1, 0) # Ternary operator usage: \n", + "# (If \"logit_probs_train\" is greater than \"0.5\" apply \"1\" else \"0\")\n", + "\n", + "#np.unique(logit_pred_train) \n", + "#result: array([0, 1]) at logit_probs_train > 0.03\n", + "\n", + "# Compute accuracy and error rate for the training set\n", + "accuracy_train = np.mean(logit_pred_train == train_data_copy['default'])\n", + "print(f\"In-sample accuracy: {round(accuracy_train, 5)}\")\n", + "\n", + "error_rate_train = np.mean(logit_pred_train != train_data_copy['default'])\n", + "print(f\"In-sample error rate: {round(error_rate_train, 5)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "32ccd1e4-2d84-41e6-8ff7-7ac8b8327482", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Create a copy of the test_data DataFrame\n", + "# preventing to overwrite the original data\n", + "test_data_copy = test_data.copy()\n", + "\n", + "# Ensure the target variable is numeric (binary)\n", + "test_data_copy['default'] = test_data_copy['default'].map({'No': 0, 'Yes': 1})\n", + "\n", + "# Logistic regression model:\n", + "X_test = test_data_copy[['income']]\n", + "X_test = sm.add_constant(X_test) # Adds an intercept term to the model\n", + "y_test = test_data_copy['default']\n", + "\n", + "logit_probs_test = glm_fit.predict(X_test)\n", + "logit_pred_test = [ 0 if x < 0.5 else 1 for x in logit_probs_test]\n", + "\n", + "## EXTRA:\n", + "#from sklearn.metrics import classification_report\n", + "#print(classification_report(y_test, \n", + "# logit_pred_test, \n", + "# digits = 3))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "bf8934b5-d383-4290-93a9-f16a6d87951d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out-of-sample accuracy: 0.96267\n", + "Out-of-sample error rate: 0.03733\n" + ] + } + ], + "source": [ + "# Compute accuracy and error rate for the training set\n", + "accuracy_test = np.mean(logit_pred_test == test_data_copy['default'])\n", + "print(f\"Out-of-sample accuracy: {round(accuracy_test, 5)}\")\n", + "\n", + "error_rate_test = np.mean(logit_pred_test != test_data_copy['default'])\n", + "print(f\"Out-of-sample error rate: {round(error_rate_test, 5)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "c28971ef-8bee-462d-9612-88f1534bfcb5", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.4 Add balance as a predictor and compute the *out-of-sample error rate* and *accuracy*. Do you\n", + "think this is a good model to predict *default*?" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3a7216df-adf5-4df0-9593-69c1a7649f64", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: default No. Observations: 7000\n", + "Model: GLM Df Residuals: 6997\n", + "Model Family: Binomial Df Model: 2\n", + "Link Function: Logit Scale: 1.0000\n", + "Method: IRLS Log-Likelihood: -542.14\n", + "Date: Sat, 01 Feb 2025 Deviance: 1084.3\n", + "Time: 14:20:46 Pearson chi2: 5.42e+03\n", + "No. Iterations: 9 Pseudo R-squ. (CS): 0.1179\n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -11.3514 0.515 -22.060 0.000 -12.360 -10.343\n", + "income 1.847e-05 5.98e-06 3.091 0.002 6.76e-06 3.02e-05\n", + "balance 0.0055 0.000 20.428 0.000 0.005 0.006\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "# Second logistic regression model:\n", + "X_train2 = train_data_copy[['income','balance']]\n", + "X_train2 = sm.add_constant(X_train2) # Adds an intercept term to the model\n", + "X_test2 = test_data_copy[['income','balance']]\n", + "X_test2 = sm.add_constant(X_test2) # Adds an intercept term to the model\n", + "\n", + "# Fit the logistic regression model\n", + "glm_fit2 = sm.GLM(y_train, X_train2, family=sm.families.Binomial()).fit()\n", + "\n", + "# Alternative:\n", + "#glm_fit = sm.Logit(y_train, X_train2).fit()\n", + "\n", + "print(glm_fit2.summary())" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "75e6de1c-5c71-41ea-afd4-1605af956909", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out-of-sample accuracy: 0.97067\n", + "Out-of-sample error rate: 0.02933\n" + ] + } + ], + "source": [ + "logit_probs_test2 = glm_fit2.predict(X_test2)\n", + "logit_pred_test2 = [ 0 if x < 0.5 else 1 for x in logit_probs_test2]\n", + "\n", + "# Compute accuracy and error rate for the training set\n", + "accuracy_test2 = np.mean(logit_pred_test2 == test_data_copy['default'])\n", + "print(f\"Out-of-sample accuracy: {round(accuracy_test2, 5)}\")\n", + "\n", + "error_rate_test2 = np.mean(logit_pred_test2 != test_data_copy['default'])\n", + "print(f\"Out-of-sample error rate: {round(error_rate_test2, 5)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f267ef66-1775-42a8-a1e9-45fda849f4d9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.5 Compare the results for Task $1.4$ to a model with only balance as a predictor. Which model\n", + "would you choose?" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "28082bd5-8fe1-4160-aec0-1a92aebfa671", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: default No. Observations: 7000\n", + "Model: GLM Df Residuals: 6998\n", + "Model Family: Binomial Df Model: 1\n", + "Link Function: Logit Scale: 1.0000\n", + "Method: IRLS Log-Likelihood: -546.92\n", + "Date: Sat, 01 Feb 2025 Deviance: 1093.8\n", + "Time: 14:20:46 Pearson chi2: 5.73e+03\n", + "No. Iterations: 9 Pseudo R-squ. (CS): 0.1167\n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -10.5908 0.435 -24.330 0.000 -11.444 -9.738\n", + "balance 0.0054 0.000 20.441 0.000 0.005 0.006\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "# Third logistic regression model:\n", + "X_train3 = train_data_copy[['balance']]\n", + "X_train3 = sm.add_constant(X_train3) # Adds an intercept term to the model\n", + "X_test3 = test_data_copy[['balance']]\n", + "X_test3 = sm.add_constant(X_test3) # Adds an intercept term to the model\n", + "\n", + "# Fit the logistic regression model\n", + "glm_fit3 = sm.GLM(y_train, X_train3, family=sm.families.Binomial()).fit()\n", + "\n", + "# Alternative:\n", + "#glm_fit = sm.Logit(y_train, X_train3).fit()\n", + "\n", + "print(glm_fit3.summary())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "339a665b-8391-486e-ac32-4c8a30e6cb3e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out-of-sample accuracy: 0.97033\n", + "Out-of-sample error rate: 0.02967\n" + ] + } + ], + "source": [ + "logit_probs_test3 = glm_fit3.predict(X_test3)\n", + "logit_pred_test3 = [ 0 if x < 0.5 else 1 for x in logit_probs_test3]\n", + "\n", + "# Compute accuracy and error rate for the training set\n", + "accuracy_test3 = np.mean(logit_pred_test3 == test_data_copy['default'])\n", + "print(f\"Out-of-sample accuracy: {round(accuracy_test3, 5)}\")\n", + "\n", + "error_rate_test3 = np.mean(logit_pred_test3 != test_data_copy['default'])\n", + "print(f\"Out-of-sample error rate: {round(error_rate_test3, 5)}\")" + ] + }, + { + "cell_type": "markdown", + "id": "495fe989-c027-478d-98b5-0b034b91de4f", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Extra:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ea5f65f1-448b-40b3-9d6b-e10fbb2cc243", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Model In-sample error rate Out-of-sample error rate\n", + "0 income 0.031571 0.037333\n", + "1 income + balance 0.029333\n", + "2 balance 0.029667\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "# Define the data\n", + "data = {\n", + " \"Model\": [\"income\", \"income + balance\", \"balance\"],\n", + " \"In-sample error rate\": [error_rate_train, '', ''],\n", + " \"Out-of-sample error rate\": [error_rate_test, error_rate_test2, error_rate_test3]\n", + "}\n", + "\n", + "# Create a DataFrame\n", + "df = pd.DataFrame(data)\n", + "\n", + "# Display the DataFrame\n", + "print(df)" + ] + }, + { + "cell_type": "markdown", + "id": "7ccad70f-5ef5-42c8-8c2e-22e76943d281", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "1.6 Take the model from Task $1.4$ but now re-estimate the model using different *seeds* to draw your\n", + "*training* and *test data*. Does your *test error rate* change with the seed? What’s going on here?" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "9ab2f559-83b1-4a66-b1dc-8799b8301d85", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out-of-sample error rate: 0.0253333333\n" + ] + } + ], + "source": [ + "# CHANGE SEED HERE:\n", + "np.random.seed(123)\n", + "\n", + "# Number of observations in the dataset\n", + "n = len(default_data)\n", + "\n", + "# Shuffle the dataset using np.random.permutation\n", + "shuffled_indices = np.random.permutation(n)\n", + "\n", + "# Compute training and validation sample sizes\n", + "nT = int(0.7 * n) # Training sample size\n", + "\n", + "# Split the shuffled dataset based on the shuffled indices\n", + "train_data = default_data.iloc[shuffled_indices[:nT]] # First 70% for training\n", + "test_data = default_data.iloc[shuffled_indices[nT:]] # Remaining 30% for validation\n", + "\n", + "train_data_copy = train_data.copy()\n", + "train_data_copy['default'] = train_data_copy['default'].map({'No': 0, 'Yes': 1})\n", + "\n", + "test_data_copy = test_data.copy()\n", + "test_data_copy['default'] = test_data_copy['default'].map({'No': 0, 'Yes': 1})\n", + "\n", + "# Logistic regression model:\n", + "X_train1_6 = train_data_copy[['income','balance']]\n", + "X_train1_6 = sm.add_constant(X_train1_6) # Adds an intercept term to the model\n", + "X_test1_6 = test_data_copy[['income','balance']]\n", + "X_test1_6 = sm.add_constant(X_test1_6) # Adds an intercept term to the model\n", + "y_train1_6 = train_data_copy['default']\n", + "\n", + "# Fit the logistic regression model\n", + "glm_fit1_6 = sm.GLM(y_train1_6, X_train1_6, family=sm.families.Binomial()).fit()\n", + "\n", + "logit_probs_test1_6 = glm_fit1_6.predict(X_test1_6)\n", + "logit_pred_test1_6 = [ 0 if x < 0.5 else 1 for x in logit_probs_test1_6]\n", + "\n", + "error_rate_test1_6 = np.mean(logit_pred_test1_6 != test_data_copy['default'])\n", + "print(f\"Out-of-sample error rate: {round(error_rate_test1_6, 10)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fa19927b-162a-4581-bc2a-00b6d4ac4127", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9732ba48-8e42-4d5d-8801-4965fddf0f29", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "ede0120f-e5e4-4e3c-be86-4926480ebce7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from math import ceil\n", + "import io\n", + "from PIL import Image\n", + "\n", + "# Assuming your DataFrame is named 'paneldata09_SL'\n", + "# If not, replace 'paneldata09_SL' with your actual DataFrame name\n", + "\n", + "# Function to create a single plot\n", + "def create_plot(data, var):\n", + " fig, ax = plt.subplots(figsize=(5, 4))\n", + " if data[var].dtype in ['int64', 'float64']:\n", + " sns.kdeplot(data=data, x=var, ax=ax)\n", + " ax.set_title(f\"Density Plot of {var}\")\n", + " else:\n", + " sns.countplot(data=data, x=var, ax=ax, \n", + " palette={'No': \"#FF6F61\", 'Yes': \"#79C753\"}, hue=var, legend=False)\n", + " ax.set_title(f\"Bar Plot of {var}\")\n", + " \n", + " # Save the plot to a buffer\n", + " buf = io.BytesIO()\n", + " fig.savefig(buf, format='png')\n", + " plt.close(fig)\n", + " buf.seek(0)\n", + " return Image.open(buf)\n", + "\n", + "# Create a plot for each variable\n", + "plots = [create_plot(train_data, var) for var in train_data.columns]\n", + "\n", + "# Calculate grid dimensions\n", + "n = len(plots)\n", + "cols = 3 # You can adjust this to change the number of columns\n", + "rows = ceil(n / cols)\n", + "\n", + "# Create the grid plot\n", + "fig, axes = plt.subplots(rows, cols, figsize=(5*cols, 4*rows))\n", + "fig.suptitle(\"Variable distribution plots\", fontsize=16)\n", + "\n", + "# Add plots to the grid\n", + "for i, plot in enumerate(plots):\n", + " row = i // cols\n", + " col = i % cols\n", + " axes[row, col].imshow(plot)\n", + " axes[row, col].axis('off')\n", + " axes[row, col].set_title(f\"$\\\\mathbf{{{chr(65+i)}}}$: $\\\\quad\\\\quad$ {train_data.columns[i]}\", loc='left')\n", + "\n", + "# Remove any empty subplots\n", + "for i in range(n, rows*cols):\n", + " row = i // cols\n", + " col = i % cols\n", + " fig.delaxes(axes[row, col])\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "ef2f86b8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "######\n", + "# EXTRA (Parquet Format)\n", + "default_data_parquet = load_data('Default')\n", + "default_data_parquet.to_parquet('default_data.parquet', engine='pyarrow')\n", + "\n", + "# Später laden:\n", + "df_parquet = pd.read_parquet('default_data.parquet', engine='pyarrow')\n", + "######" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "vscodekernel", + "language": "python", + "name": "vscodekernel" + }, + "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.1" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data_solution.pdf b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data_solution.pdf new file mode 100755 index 0000000..760043d Binary files /dev/null and b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/02_Default_data_solution.pdf differ diff --git a/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/default_data.parquet b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/default_data.parquet new file mode 100755 index 0000000..5c2a1e7 Binary files /dev/null and b/Machine Learning for Economics and Finance/02_Supervised Learning - Classification/default_data.parquet differ diff --git a/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_CV.ipynb b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_CV.ipynb new file mode 100755 index 0000000..5b33f22 --- /dev/null +++ b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_CV.ipynb @@ -0,0 +1,487 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "6cbef61b-0897-42bf-b456-c0a409b87c41", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{03\\_Auto\\_data\\_CV}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "13be77f3-44f0-4983-b4cb-bd3e4b5dba8b", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "335aa198-5a94-4c5a-8ad8-67c78bcf71f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/03-CrossValidation\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationyearoriginname
018.08307.0130350412.0701chevrolet chevelle malibu
115.08350.0165369311.5701buick skylark 320
218.08318.0150343611.0701plymouth satellite
316.08304.0150343312.0701amc rebel sst
417.08302.0140344910.5701ford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin name \n", + "0 1 chevrolet chevelle malibu \n", + "1 1 buick skylark 320 \n", + "2 1 plymouth satellite \n", + "3 1 amc rebel sst \n", + "4 1 ford torino " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory\n", + "\n", + "from ISLP import load_data # Package which contains the data\n", + "Auto_data = load_data('Auto') # Loading the data\n", + "Auto_data.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e38a201-7f2d-4999-beab-5739217a9318", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 392 entries, 0 to 391\n", + "Data columns (total 9 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 mpg 392 non-null float64\n", + " 1 cylinders 392 non-null int64 \n", + " 2 displacement 392 non-null float64\n", + " 3 horsepower 392 non-null int64 \n", + " 4 weight 392 non-null int64 \n", + " 5 acceleration 392 non-null float64\n", + " 6 year 392 non-null int64 \n", + " 7 origin 392 non-null int64 \n", + " 8 name 392 non-null object \n", + "dtypes: float64(3), int64(5), object(1)\n", + "memory usage: 27.7+ KB\n", + "None\n" + ] + } + ], + "source": [ + "print(Auto_data.info())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7dd29324-cd54-415c-ba83-56c0d9f74159", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mpg cylinders displacement horsepower weight \\\n", + "count 392.000000 392.000000 392.000000 392.000000 392.000000 \n", + "mean 23.445918 5.471939 194.411990 104.469388 2977.584184 \n", + "std 7.805007 1.705783 104.644004 38.491160 849.402560 \n", + "min 9.000000 3.000000 68.000000 46.000000 1613.000000 \n", + "25% 17.000000 4.000000 105.000000 75.000000 2225.250000 \n", + "50% 22.750000 4.000000 151.000000 93.500000 2803.500000 \n", + "75% 29.000000 8.000000 275.750000 126.000000 3614.750000 \n", + "max 46.600000 8.000000 455.000000 230.000000 5140.000000 \n", + "\n", + " acceleration year origin \n", + "count 392.000000 392.000000 392.000000 \n", + "mean 15.541327 75.979592 1.576531 \n", + "std 2.758864 3.683737 0.805518 \n", + "min 8.000000 70.000000 1.000000 \n", + "25% 13.775000 73.000000 1.000000 \n", + "50% 15.500000 76.000000 1.000000 \n", + "75% 17.025000 79.000000 2.000000 \n", + "max 24.800000 82.000000 3.000000 \n" + ] + } + ], + "source": [ + "print(Auto_data.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "aac9e3c5-e19b-4568-b205-e1ce3fc1ca3f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# set seed\n", + "np.random.seed(2)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f9a25057-a631-48dc-883f-643bd09d0999", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: mpg No. Observations: 392\n", + "Model: GLM Df Residuals: 390\n", + "Model Family: Gaussian Df Model: 1\n", + "Link Function: Identity Scale: 24.066\n", + "Method: IRLS Log-Likelihood: -1178.7\n", + "Date: Sat, 19 Oct 2024 Deviance: 9385.9\n", + "Time: 16:50:14 Pearson chi2: 9.39e+03\n", + "No. Iterations: 3 Pseudo R-squ. (CS): 0.7834\n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 39.9359 0.717 55.660 0.000 38.530 41.342\n", + "horsepower -0.1578 0.006 -24.489 0.000 -0.170 -0.145\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "# Logistic regression model:\n", + "X = Auto_data[['horsepower']]\n", + "X = sm.add_constant(X) # Adds an intercept term to the model\n", + "y = Auto_data['mpg']\n", + "\n", + "# Fit the model\n", + "glm_fit = sm.GLM(y, X, family=sm.families.Gaussian()).fit()\n", + "# Further function options can be found at: \n", + "# https://www.statsmodels.org/stable/glm.html \"Families\"\n", + "\n", + "print(glm_fit.summary())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b5c7de71-463d-455b-a596-923cfcddcefb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "const 39.935861\n", + "horsepower -0.157845\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "print(glm_fit.params) # print coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6b8fb99c-d172-4398-92e5-89324c1787f8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import pandas as pd\n", + "from sklearn.model_selection import cross_val_score\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.pipeline import make_pipeline\n", + "\n", + "# Number of folds for cross-validation\n", + "folds = 10\n", + "num_models = 10 # Number of polynomial degrees to fit\n", + "cv_errors = []\n", + "\n", + "# Perform cross-validation for different polynomial degrees (flexibility)\n", + "for degree in range(1, num_models + 1):\n", + " # Create a pipeline to add polynomial features and fit a linear regression model\n", + " model = make_pipeline(PolynomialFeatures(degree), LinearRegression())\n", + " \n", + " # Compute cross-validated MSE (negative mean squared error)\n", + " mse_scores = -cross_val_score(model, X, y, cv=folds, scoring='neg_mean_squared_error')\n", + " \n", + " # Save the average MSE for this model\n", + " cv_errors.append(mse_scores.mean())\n", + "\n", + "# Convert results into a DataFrame for easier plotting\n", + "cv_errors_df = pd.DataFrame({'Degree': np.arange(1, num_models + 1), 'MSE': cv_errors})\n", + "\n", + "\n", + "# Find the best model (minimum MSE)\n", + "best_model_idx = cv_errors_df['MSE'].idxmin()\n", + "best_model_degree = cv_errors_df.loc[best_model_idx, 'Degree']\n", + "best_model_mse = cv_errors_df.loc[best_model_idx, 'MSE']" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d9b3b0b3-8b66-4624-b75e-74f97015c362", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Plot the cross-validation errors\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(cv_errors_df['Degree'], cv_errors_df['MSE'], marker='o', linestyle='-')\n", + "\n", + "# Mark the best model on the plot\n", + "plt.annotate(f'Best Model\\n(Degree {best_model_degree})', \n", + " xy=(best_model_degree, best_model_mse), \n", + " xytext=(best_model_degree + 0.5, best_model_mse + 1), # Adjust position for better readability\n", + " arrowprops=dict(facecolor='black', shrink=0.05), fontsize=10)\n", + "\n", + "plt.xticks(np.arange(1, num_models + 1, step=1))\n", + "plt.xlabel('Flexibility (Degree of Polynomial)')\n", + "plt.ylabel('MSE')\n", + "plt.title('Cross-Validation MSE vs. Polynomial Degree')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "48c8ca26-cdb0-4ec0-8eba-db24aa1fa655", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Degree MSE\n", + "0 1 27.439934\n", + "1 2 21.235840\n", + "2 3 21.336606\n", + "3 4 21.353887\n", + "4 5 20.905641\n", + "5 6 20.780511\n", + "6 7 20.953654\n", + "7 8 21.077388\n", + "8 9 21.037360\n", + "9 10 20.982162\n" + ] + } + ], + "source": [ + "# Output the cross-validation errors for each polynomial degree\n", + "print(cv_errors_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "44cf3905-98d2-44c9-be09-424e22ef5d71", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best model is with degree 6 with a corresponding MSE of 20.781\n" + ] + } + ], + "source": [ + "# Output the MSE values and best model\n", + "print(f\"Best model is with degree {best_model_degree} with a corresponding MSE of {round(best_model_mse, 3)}\")" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_CV.pdf b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_CV.pdf new file mode 100755 index 0000000..fe5dc23 Binary files /dev/null and b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_CV.pdf differ diff --git a/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_val_set.ipynb b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_val_set.ipynb new file mode 100755 index 0000000..eab7f7c --- /dev/null +++ b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_val_set.ipynb @@ -0,0 +1,511 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "6cbef61b-0897-42bf-b456-c0a409b87c41", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{03\\_Auto\\_data\\_val\\_set}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "13be77f3-44f0-4983-b4cb-bd3e4b5dba8b", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "335aa198-5a94-4c5a-8ad8-67c78bcf71f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/03-CrossValidation\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
mpgcylindersdisplacementhorsepowerweightaccelerationyearoriginname
018.08307.0130350412.0701chevrolet chevelle malibu
115.08350.0165369311.5701buick skylark 320
218.08318.0150343611.0701plymouth satellite
316.08304.0150343312.0701amc rebel sst
417.08302.0140344910.5701ford torino
\n", + "
" + ], + "text/plain": [ + " mpg cylinders displacement horsepower weight acceleration year \\\n", + "0 18.0 8 307.0 130 3504 12.0 70 \n", + "1 15.0 8 350.0 165 3693 11.5 70 \n", + "2 18.0 8 318.0 150 3436 11.0 70 \n", + "3 16.0 8 304.0 150 3433 12.0 70 \n", + "4 17.0 8 302.0 140 3449 10.5 70 \n", + "\n", + " origin name \n", + "0 1 chevrolet chevelle malibu \n", + "1 1 buick skylark 320 \n", + "2 1 plymouth satellite \n", + "3 1 amc rebel sst \n", + "4 1 ford torino " + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory\n", + "\n", + "from ISLP import load_data # Package which contains the data\n", + "Auto_data = load_data('Auto') # Loading the data\n", + "Auto_data.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e38a201-7f2d-4999-beab-5739217a9318", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 392 entries, 0 to 391\n", + "Data columns (total 9 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 mpg 392 non-null float64\n", + " 1 cylinders 392 non-null int64 \n", + " 2 displacement 392 non-null float64\n", + " 3 horsepower 392 non-null int64 \n", + " 4 weight 392 non-null int64 \n", + " 5 acceleration 392 non-null float64\n", + " 6 year 392 non-null int64 \n", + " 7 origin 392 non-null int64 \n", + " 8 name 392 non-null object \n", + "dtypes: float64(3), int64(5), object(1)\n", + "memory usage: 27.7+ KB\n", + "None\n" + ] + } + ], + "source": [ + "print(Auto_data.info())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7dd29324-cd54-415c-ba83-56c0d9f74159", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " mpg cylinders displacement horsepower weight \\\n", + "count 392.000000 392.000000 392.000000 392.000000 392.000000 \n", + "mean 23.445918 5.471939 194.411990 104.469388 2977.584184 \n", + "std 7.805007 1.705783 104.644004 38.491160 849.402560 \n", + "min 9.000000 3.000000 68.000000 46.000000 1613.000000 \n", + "25% 17.000000 4.000000 105.000000 75.000000 2225.250000 \n", + "50% 22.750000 4.000000 151.000000 93.500000 2803.500000 \n", + "75% 29.000000 8.000000 275.750000 126.000000 3614.750000 \n", + "max 46.600000 8.000000 455.000000 230.000000 5140.000000 \n", + "\n", + " acceleration year origin \n", + "count 392.000000 392.000000 392.000000 \n", + "mean 15.541327 75.979592 1.576531 \n", + "std 2.758864 3.683737 0.805518 \n", + "min 8.000000 70.000000 1.000000 \n", + "25% 13.775000 73.000000 1.000000 \n", + "50% 15.500000 76.000000 1.000000 \n", + "75% 17.025000 79.000000 2.000000 \n", + "max 24.800000 82.000000 3.000000 \n" + ] + } + ], + "source": [ + "print(Auto_data.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3debf6d8-efda-4414-bcca-dd758dc65512", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "# set seed\n", + "np.random.seed(1)\n", + "\n", + "# Number of observations in the dataset\n", + "n = len(Auto_data)\n", + "\n", + "# Shuffle the dataset using np.random.permutation\n", + "shuffled_indices = np.random.permutation(n)\n", + "\n", + "# Split data into training, validation, and test sets\n", + "n = len(Auto_data)\n", + "n_train = 150 # Training set size\n", + "n_val = 150 # Validation set size\n", + "n_test = n - n_train - n_val # Remaining for the test set\n", + "\n", + "train_data = Auto_data.iloc[:n_train]\n", + "val_data = Auto_data.iloc[n_train:n_train + n_val]\n", + "test_data = Auto_data.iloc[n_train + n_val:]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "13ad6115-3358-41fc-a681-42dfcd4365d3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn.metrics import mean_squared_error\n", + "\n", + "# Define a function to compute MSE\n", + "def compute_mse(y_true, y_pred):\n", + " return mean_squared_error(y_true, y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "bf46cd61-c6e5-4228-88e9-27ded25be029", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "\n", + "# Try models with polynomial degrees from 1 to 10\n", + "num_models = 10\n", + "train_mse = []\n", + "val_mse = []\n", + "lm_list = [] # List to save all models\n", + "\n", + "for i in range(1, num_models + 1):\n", + " # Create polynomial features\n", + " poly = PolynomialFeatures(degree=i)\n", + " \n", + " # Training data: Transform horsepower to polynomial features\n", + " X_train_poly = poly.fit_transform(train_data[['horsepower']])\n", + " y_train = train_data['mpg']\n", + " \n", + " # Validation data: Transform horsepower to polynomial features\n", + " X_val_poly = poly.transform(val_data[['horsepower']])\n", + " y_val = val_data['mpg']\n", + " \n", + " # Train the model on the training set\n", + " model = LinearRegression().fit(X_train_poly, y_train)\n", + " lm_list.append(model) # Save the model\n", + " \n", + " # Make predictions for training and validation sets\n", + " y_train_pred = model.predict(X_train_poly)\n", + " y_val_pred = model.predict(X_val_poly)\n", + " \n", + " # Compute MSE for training and validation sets\n", + " train_mse.append(compute_mse(y_train, y_train_pred))\n", + " val_mse.append(compute_mse(y_val, y_val_pred))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d6505c9c-d1f2-44d2-9dcb-e3d3e820519c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best model is polynomial degree: 6\n" + ] + } + ], + "source": [ + "# Select the best model (with minimum validation MSE)\n", + "best_model_index = np.argmin(val_mse) + 1 # Adding 1 to match polynomial degree\n", + "print(f\"Best model is polynomial degree: {best_model_index}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "86d843f8-0497-46d5-9d3a-68dacf1da17b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Degree 1: Train MSE: 11.02522, Validation MSE: 19.39243\n", + "Degree 2: Train MSE: 8.00342, Validation MSE: 15.12801\n", + "Degree 3: Train MSE: 7.86238, Validation MSE: 15.72968\n", + "Degree 4: Train MSE: 7.73052, Validation MSE: 15.80150\n", + "Degree 5: Train MSE: 7.17526, Validation MSE: 15.35206\n", + "Degree 6: Train MSE: 7.13461, Validation MSE: 15.04239\n", + "Degree 7: Train MSE: 7.20354, Validation MSE: 15.40961\n", + "Degree 8: Train MSE: 7.32205, Validation MSE: 15.68285\n", + "Degree 9: Train MSE: 7.43871, Validation MSE: 15.68433\n", + "Degree 10: Train MSE: 7.46632, Validation MSE: 15.45292\n" + ] + } + ], + "source": [ + "# Output the MSE values for each model\n", + "for degree, train_error, val_error in zip(range(1, num_models + 1), train_mse, val_mse):\n", + " print(f\"Degree {degree}: Train MSE: {train_error:.5f}, Validation MSE: {val_error:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c60a0be3-9c8a-4469-860b-ca04d92e0860", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "# Convert train MSE and validation MSE to a DataFrame\n", + "mse_df = pd.DataFrame({\n", + " 'Degree': np.arange(1, num_models + 1),\n", + " 'Val MSE': val_mse,\n", + " 'Train MSE': train_mse\n", + "})\n", + "\n", + "# Create a subset with only the best model\n", + "mse_best = mse_df[mse_df['Degree'] == best_model_index]\n", + "\n", + "# Plotting Train MSE and Validation MSE\n", + "plt.figure(figsize=(10, 6))\n", + "\n", + "# Plot the training MSE\n", + "plt.plot(mse_df['Degree'], mse_df['Train MSE'], label=\"Train MSE\", color='blue', marker='o')\n", + "plt.plot(mse_df['Degree'], mse_df['Val MSE'], label=\"Val MSE\", color='red', marker='o')\n", + "\n", + "# Mark the best model with a red point and annotate it\n", + "plt.scatter(mse_best['Degree'], mse_best['Val MSE'], color='red', zorder=5)\n", + "plt.text(mse_best['Degree'].values[0] - 0.4, mse_best['Val MSE'].values[0] - 0.6, \n", + " 'Best Model', color='black', fontsize=12)\n", + "\n", + "# Labels and legends\n", + "plt.xlabel('Flexibility (Degree of Polynomial)')\n", + "plt.ylabel('MSE')\n", + "plt.legend()\n", + "plt.xticks(np.arange(1, num_models + 1, step=1))\n", + "plt.title('Train MSE and Val MSE vs. Polynomial Degree')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "b1dad12f-7bde-45e8-822e-f80b13195f2f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train MSE: 7.13461\n", + "Val MSE: 15.04239\n", + "Test MSE: 57.43518\n" + ] + } + ], + "source": [ + "# Fit the best model again using both the training and validation data\n", + "# Combine training and validation sets\n", + "train_val_data = pd.concat([train_data, val_data])\n", + "\n", + "# Polynomial features for the best model\n", + "poly_best = PolynomialFeatures(degree=best_model_index)\n", + "X_train_val_poly = poly_best.fit_transform(train_val_data[['horsepower']])\n", + "y_train_val = train_val_data['mpg']\n", + "\n", + "# Train the best model on the combined training + validation data\n", + "best_model = LinearRegression().fit(X_train_val_poly, y_train_val)\n", + "\n", + "# Compute Test MSE\n", + "X_test_poly = poly_best.transform(test_data[['horsepower']])\n", + "y_test = test_data['mpg']\n", + "y_test_pred = best_model.predict(X_test_poly)\n", + "\n", + "test_mse = mean_squared_error(y_test, y_test_pred)\n", + "\n", + "# Display Training, Validation and Test MSE for the best model\n", + "print(f\"Train MSE: {round(train_mse[best_model_index-1], 5)}\")\n", + "print(f\"Val MSE: {round(val_mse[best_model_index-1], 5)}\")\n", + "print(f\"Test MSE: {round(test_mse, 5)}\")" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_val_set.pdf b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_val_set.pdf new file mode 100755 index 0000000..e8ce2da Binary files /dev/null and b/Machine Learning for Economics and Finance/03_Cross Validation/03_Auto_data_val_set.pdf differ diff --git a/Machine Learning for Economics and Finance/03_Cross Validation/03_Default_data.ipynb b/Machine Learning for Economics and Finance/03_Cross Validation/03_Default_data.ipynb new file mode 100755 index 0000000..17ca930 --- /dev/null +++ b/Machine Learning for Economics and Finance/03_Cross Validation/03_Default_data.ipynb @@ -0,0 +1,465 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "6cbef61b-0897-42bf-b456-c0a409b87c41", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{03\\_Default\\_data}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "13be77f3-44f0-4983-b4cb-bd3e4b5dba8b", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "335aa198-5a94-4c5a-8ad8-67c78bcf71f5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/mnt/ds/home/UHH_MLSJ_2024/Code/Python/03-CrossValidation\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
defaultstudentbalanceincome
0NoNo729.52649544361.625074
1NoYes817.18040712106.134700
2NoNo1073.54916431767.138947
3NoNo529.25060535704.493935
4NoNo785.65588338463.495879
\n", + "
" + ], + "text/plain": [ + " default student balance income\n", + "0 No No 729.526495 44361.625074\n", + "1 No Yes 817.180407 12106.134700\n", + "2 No No 1073.549164 31767.138947\n", + "3 No No 529.250605 35704.493935\n", + "4 No No 785.655883 38463.495879" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os # Package to access system related information \n", + "print(os.getcwd()) # Prints the current working directory\n", + "path = os.getcwd()\n", + "os.chdir(path) # Set the working directory\n", + "\n", + "from ISLP import load_data # Package which contains the data\n", + "default_data = load_data('Default') # Loading the data\n", + "default_data.head() # Showing the first 5 Lines of Data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "2e38a201-7f2d-4999-beab-5739217a9318", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 10000 entries, 0 to 9999\n", + "Data columns (total 4 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 default 10000 non-null object \n", + " 1 student 10000 non-null object \n", + " 2 balance 10000 non-null float64\n", + " 3 income 10000 non-null float64\n", + "dtypes: float64(2), object(2)\n", + "memory usage: 312.6+ KB\n", + "None\n" + ] + } + ], + "source": [ + "print(default_data.info())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7dd29324-cd54-415c-ba83-56c0d9f74159", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " balance income\n", + "count 10000.000000 10000.000000\n", + "mean 835.374886 33516.981876\n", + "std 483.714985 13336.639563\n", + "min 0.000000 771.967729\n", + "25% 481.731105 21340.462903\n", + "50% 823.636973 34552.644802\n", + "75% 1166.308386 43807.729272\n", + "max 2654.322576 73554.233495\n" + ] + } + ], + "source": [ + "print(default_data.describe())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3debf6d8-efda-4414-bcca-dd758dc65512", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "# set seed\n", + "np.random.seed(1)\n", + "\n", + "# Number of observations in the dataset\n", + "n = len(default_data)\n", + "\n", + "# Shuffle the dataset using np.random.permutation\n", + "shuffled_indices = np.random.permutation(n)\n", + "\n", + "# Compute training and validation sample sizes\n", + "nT = int(0.7 * n) # Training sample size\n", + "\n", + "# Split the shuffled dataset based on the shuffled indices\n", + "train_data = default_data.iloc[shuffled_indices[:nT]] # First 70% for training\n", + "test_data = default_data.iloc[shuffled_indices[nT:]] # Remaining 30% for validation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e1b2a560-2a8e-4881-8d51-f3d96c3b05fe", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data percentage of defaulting: 0.03157\n", + "Test data percentage of defaulting: 0.03733\n" + ] + } + ], + "source": [ + "defaulting_train = (train_data['default'] == 'Yes').mean()\n", + "defaulting_test = (test_data['default'] == 'Yes').mean()\n", + "# The \"train_data$default == \"Yes\": creates a logical vector where each element is TRUE \n", + "# if the corresponding element.\n", + "# The outer mean() function than calculates the proportion of TRUE values \n", + "# in the logical vector.\n", + "\n", + "# Output the results\n", + "print(f\"Train data percentage of defaulting: {round(defaulting_train, 5)}\")\n", + "print(f\"Test data percentage of defaulting: {round(defaulting_test, 5)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f9a25057-a631-48dc-883f-643bd09d0999", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Generalized Linear Model Regression Results \n", + "==============================================================================\n", + "Dep. Variable: default No. Observations: 7000\n", + "Model: GLM Df Residuals: 6997\n", + "Model Family: Binomial Df Model: 2\n", + "Link Function: Logit Scale: 1.0000\n", + "Method: IRLS Log-Likelihood: -542.14\n", + "Date: Sat, 19 Oct 2024 Deviance: 1084.3\n", + "Time: 16:53:00 Pearson chi2: 5.42e+03\n", + "No. Iterations: 9 Pseudo R-squ. (CS): 0.1179\n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err z P>|z| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -11.3514 0.515 -22.060 0.000 -12.360 -10.343\n", + "income 1.847e-05 5.98e-06 3.091 0.002 6.76e-06 3.02e-05\n", + "balance 0.0055 0.000 20.428 0.000 0.005 0.006\n", + "==============================================================================\n" + ] + } + ], + "source": [ + "import statsmodels.api as sm\n", + "\n", + "train_data_copy = train_data.copy()\n", + "train_data_copy['default'] = train_data_copy['default'].map({'No': 0, 'Yes': 1})\n", + "\n", + "test_data_copy = test_data.copy()\n", + "test_data_copy['default'] = test_data_copy['default'].map({'No': 0, 'Yes': 1})\n", + "\n", + "# Logistic regression model:\n", + "X_train = train_data_copy[['income','balance']]\n", + "X_train = sm.add_constant(X_train) # Adds an intercept term to the model\n", + "X_test = test_data_copy[['income','balance']]\n", + "X_test = sm.add_constant(X_test) # Adds an intercept term to the model\n", + "y_train = train_data_copy['default']\n", + "\n", + "# Fit the logistic regression model\n", + "glm_fit = sm.GLM(y_train, X_train, family=sm.families.Binomial()).fit()\n", + "print(glm_fit.summary())" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b5c7de71-463d-455b-a596-923cfcddcefb", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "const -11.351394\n", + "income 0.000018\n", + "balance 0.005536\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "print(glm_fit.params) # print coefficients" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6b8fb99c-d172-4398-92e5-89324c1787f8", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-fold Cross-Validation Error Rate: 0.02571\n" + ] + } + ], + "source": [ + "from sklearn.metrics import accuracy_score\n", + "from sklearn.model_selection import KFold\n", + "\n", + "# ---- K-Fold Cross-Validation ----\n", + "folds = 10\n", + "kf = KFold(n_splits=folds, shuffle=True, random_state=12)\n", + "cv_errors = []\n", + "\n", + "for train_index, test_index in kf.split(X_train):\n", + " X_train_fold, X_test_fold = X_train.iloc[train_index], X_train.iloc[test_index]\n", + " y_train_fold, y_test_fold = y_train.iloc[train_index], y_train.iloc[test_index]\n", + " \n", + " # Fit model on this fold\n", + " glm_fold = sm.GLM(y_train_fold, X_train_fold, family=sm.families.Binomial()).fit()\n", + " \n", + " # Compute the out-of-sample error for this fold\n", + " preds_fold = glm_fold.predict(X_test_fold)\n", + " pred_labels_fold = [1 if p > 0.5 else 0 for p in preds_fold]\n", + " fold_error = np.mean(pred_labels_fold != y_test_fold)\n", + " \n", + " cv_errors.append(fold_error)\n", + "\n", + "cv_error_rate = np.mean(cv_errors)\n", + "print(f\"K-fold Cross-Validation Error Rate: {cv_error_rate:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "06091455-d874-4a10-9919-78c8c9ddfbed", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample accuracy: 0.97486\n", + "In-sample error rate: 0.02514\n" + ] + } + ], + "source": [ + "# ---- In-sample predictions ----\n", + "glm_probs_train = glm_fit.predict(X_train)\n", + "glm_pred_train = np.where(glm_probs_train > 0.5, 1, 0) # ternary operator\n", + "\n", + "# Compute in-sample accuracy and error rate\n", + "accuracy_train = accuracy_score(y_train, glm_pred_train)\n", + "error_rate_train = np.mean(glm_pred_train != y_train)\n", + "\n", + "print(f\"In-sample accuracy: {round(accuracy_train, 5)}\")\n", + "print(f\"In-sample error rate: {round(error_rate_train, 5)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "9d115c02-9520-41d5-b04b-e8cbe84b0277", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# ---- Out-of-sample predictions ----\n", + "glm_probs_test = glm_fit.predict(X_test)\n", + "glm_pred_test = np.where(glm_probs_test > 0.5, 1, 0) # ternary operator" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "80aadaaf-e914-4e70-9ea3-411965a8d9d7", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out-of-sample accuracy: 0.97067\n", + "Out-of-sample error rate: 0.02933\n" + ] + } + ], + "source": [ + "# Compute out-of-sample accuracy and error rate\n", + "accuracy_test = accuracy_score(test_data_copy['default'], glm_pred_test)\n", + "error_rate_test = np.mean(glm_pred_test != test_data_copy['default'])\n", + "\n", + "print(f\"Out-of-sample accuracy: {round(accuracy_test, 5)}\")\n", + "print(f\"Out-of-sample error rate: {round(error_rate_test, 5)}\")" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/03_Cross Validation/03_Default_data.pdf b/Machine Learning for Economics and Finance/03_Cross Validation/03_Default_data.pdf new file mode 100755 index 0000000..8167d16 Binary files /dev/null and b/Machine Learning for Economics and Finance/03_Cross Validation/03_Default_data.pdf differ diff --git a/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_ForwardSelection.ipynb b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_ForwardSelection.ipynb new file mode 100755 index 0000000..c7698e3 --- /dev/null +++ b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_ForwardSelection.ipynb @@ -0,0 +1,324 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "71dde0cd-56e2-43e6-892c-a35cb066edf1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "---\n", + "title: Machine Learning for Economics and Finance\n", + "subtitle: In JupyterLab\n", + "subject: Tutorial\n", + "venue: Python Intro\n", + "authors: \n", + " - name: Ole Wilms\n", + " email: ole.wilms@uni-hamburg.de\n", + "keywords: islp\n", + "# date: 2024/09/28\n", + "date: \"`r format(Sys.time(), '%d %B, %Y')`\"\n", + "math:\n", + " '\\dobs': '\\mathbf{d}_\\text{obs}'\n", + " '\\dpred': '\\mathbf{d}_\\text{pred}\\left( #1 \\right)'\n", + " '\\mref': '\\mathbf{m}_\\text{ref}'\n", + "abbreviations:\n", + " MyST: Markedly Stryctured Text\n", + " TLA: Three Letter Acronym\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "87902d82-5336-456b-bec8-403530c75f00", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Example code" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "f1cf1749-9e5b-434a-8f45-5d63db20ee2a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Intercept:\n", + "128.10911474918652\n", + "\n", + "Coefficients:\n", + " Feature Coefficient\n", + "0 AtBat -1.617362\n", + "1 Hits 6.980032\n", + "2 HmRun 1.324768\n", + "3 Runs -2.439937\n", + "4 RBI -0.007608\n", + "5 Walks 6.585051\n", + "6 CAtBat -0.228701\n", + "7 CHits 0.815118\n", + "8 CHmRun 1.538879\n", + "9 CRuns 0.709538\n", + "10 CWalks -0.600017\n", + "11 Errors 0.956309\n", + "12 League_N 79.566554\n", + "13 Division_W -121.244188\n", + "14 NewLeague_N -33.825830\n", + "\n", + "R-squared:\n", + "0.5150869657868427\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.feature_selection import SequentialFeatureSelector\n", + "from ISLP import load_data\n", + "\n", + "###\n", + "# Forward stepwise selection\n", + "###\n", + "# Load Hitters dataset from ISLP\n", + "Hitters = load_data('Hitters')\n", + "\n", + "# Remove missing values\n", + "Hitters = Hitters.dropna()\n", + "\n", + "# Create dummy variables for categorical columns\n", + "Hitters = pd.get_dummies(Hitters, drop_first=True)\n", + "\n", + "# Separate response (target) and predictors\n", + "y = Hitters['Salary']\n", + "X = Hitters.drop(columns=['Salary'])\n", + "\n", + "# Define the linear regression model\n", + "model = LinearRegression()\n", + "\n", + "# Perform forward stepwise selection using SequentialFeatureSelector\n", + "#sfs = SequentialFeatureSelector(model, n_features_to_select=15, direction='forward', cv=5)\n", + "sfs = SequentialFeatureSelector(model, n_features_to_select=15, direction='forward')\n", + "\n", + "# Fit the model to the data\n", + "sfs.fit(X, y)\n", + "\n", + "# Get the selected features\n", + "selected_features = X.columns[sfs.get_support()]\n", + "\n", + "# Fit the model with the selected features\n", + "model.fit(X[selected_features], y)\n", + "\n", + "# Coefficients of the selected features\n", + "coefficients = pd.DataFrame({\n", + " 'Feature': selected_features,\n", + " 'Coefficient': model.coef_\n", + "})\n", + "\n", + "# Printing short summary - intercept, coefficients and $R^{2}$\n", + "print(\"\\nIntercept:\")\n", + "print(model.intercept_)\n", + "\n", + "print(\"\\nCoefficients:\")\n", + "print(coefficients)\n", + "\n", + "print(\"\\nR-squared:\")\n", + "print(model.score(X[selected_features], y))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6b73a83c-3b00-45d7-bfc8-8d04353b3bfb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation Errors for each model size (1 to 15 features):\n", + "[124621.80599921 97585.98973835 108054.65205434 109660.96621422\n", + " 104763.84348023 100783.43834678 104998.65236004 114426.75713735\n", + " 119884.39341126 127572.74609957 116991.35484176 114162.96717981\n", + " 116360.6476317 117289.1176923 115771.82167166]\n", + "\n", + "Min val_err: 97585.9897383486\n" + ] + } + ], + "source": [ + "###\n", + "# Validation errors for FSS\n", + "###\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.metrics import mean_squared_error as MSE\n", + "from mlxtend.feature_selection import SequentialFeatureSelector as SFS\n", + "import statsmodels.api as sm\n", + "\n", + "# Split the data into training and validation sets based on row indices\n", + "train_data = Hitters.iloc[:184] # First 184 rows for training data\n", + "val_data = Hitters.iloc[184:263] # Rows 185 to 263 for validation data\n", + "\n", + "# Define X and y for both training and validation sets\n", + "X_train = train_data.drop(columns=['Salary'])\n", + "y_train = train_data['Salary']\n", + "X_val = val_data.drop(columns=['Salary'])\n", + "y_val = val_data['Salary']\n", + "\n", + "# Ensure that all categorical variables are encoded as numeric\n", + "X_train = pd.get_dummies(X_train, drop_first=True).astype(float)\n", + "X_val = pd.get_dummies(X_val, drop_first=True).astype(float)\n", + "\n", + "# Align columns of validation set to match training set\n", + "X_val = X_val.reindex(columns=X_train.columns, fill_value=0).astype(float)\n", + "\n", + "# Convert validation data to matrix form (for statsmodels)\n", + "val_data = sm.add_constant(X_val)\n", + "\n", + "# Ensure target variable is numeric\n", + "y_train_np = np.asarray(y_train).astype(float)\n", + "y_val_np = np.asarray(y_val).astype(float)\n", + "\n", + "\n", + "# Run forward stepwise selection using sklearn's SequentialFeatureSelector\n", + "model2 = LinearRegression()\n", + "\n", + "sfs2 = SFS(model2, \n", + " k_features=15, \n", + " forward=True, \n", + " floating=False, \n", + " scoring='neg_mean_squared_error', \n", + " cv=0) # No cross-validation\n", + "\n", + "sfs2.fit(X_train, y_train)\n", + "\n", + "# Extract selected features for each number of features (1 to 15)\n", + "#selected_features = list(sfs2.subsets_)\n", + "selected_features = sfs2.subsets_\n", + "\n", + "# Compute validation mean squared errors for each model\n", + "val_err = np.zeros(15)\n", + "for i in range(1, 16):\n", + " # Get the selected feature names for this step\n", + " feature_names = selected_features[i]['feature_names']\n", + " \n", + " # Select the corresponding features from X_train\n", + " X_train_selected = X_train[list(feature_names)]\n", + " \n", + " # Add constant (intercept) term\n", + " X_train_selected = sm.add_constant(X_train_selected).astype(float)\n", + " \n", + " # Ensure the selected features are numeric\n", + " X_train_selected_np = np.asarray(X_train_selected).astype(float)\n", + "\n", + " # Fit OLS model\n", + " model = sm.OLS(y_train_np, X_train_selected_np).fit()\n", + "\n", + " # Predict on validation set\n", + " X_val_selected = val_data[list(feature_names)]\n", + " X_val_selected_np = sm.add_constant(X_val_selected).astype(float) # Ensure numpy array is float\n", + "\n", + " y_pred_val = model.predict(X_val_selected_np)\n", + "\n", + " # Compute MSE for validation set\n", + " val_err[i - 1] = MSE(y_val_np, y_pred_val)\n", + "\n", + "# Print validation errors for each model size\n", + "print(\"Validation Errors for each model size (1 to 15 features):\")\n", + "print(val_err)\n", + "\n", + "print(\"\\nMin val_err: \", min(val_err))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "16f1c19e-7177-4bc2-81f0-9428adf4e90e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "##\n", + "# PLOT results\n", + "##\n", + "import matplotlib.pyplot as plt\n", + "# Assuming 'val_err' contains the validation MSE values\n", + "\n", + "# Find the index of the minimum validation error\n", + "min_index = np.argmin(val_err) + 1 # +1 because index starts from 0, but variables start from 1\n", + "\n", + "# Plot the validation errors\n", + "plt.figure(figsize=(8, 5))\n", + "plt.plot(range(1, 16), val_err, marker='o', linestyle='--', color='black')\n", + "\n", + "# Highlight the minimum MSE with a red vertical line\n", + "plt.axvline(x=min_index, color='red', linestyle='-', linewidth=1.5)\n", + "\n", + "# Label the axes\n", + "plt.xlabel(\"# Variables\", fontsize=12)\n", + "plt.ylabel(\"Validation MSE\", fontsize=12)\n", + "\n", + "# Title for the plot (optional)\n", + "plt.title(\"Validation MSE vs Number of Variables\", fontsize=14)\n", + "\n", + "# Show the plot\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression.ipynb b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression.ipynb new file mode 100755 index 0000000..45e4b27 --- /dev/null +++ b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression.ipynb @@ -0,0 +1,196 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fb0c424f-1667-4fb2-baab-2d88d8abb387", + "metadata": {}, + "source": [ + "# Preliminary setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de6396ca-e17d-4c95-8f96-1f78a09e9ce2", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from ISLP import load_data\n", + "from matplotlib.pyplot import subplots, show\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# Load and preprocess data\n", + "Hitters = load_data('Hitters').dropna()" + ] + }, + { + "cell_type": "markdown", + "id": "87902d82-5336-456b-bec8-403530c75f00", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "# Task" + ] + }, + { + "cell_type": "markdown", + "id": "0ce8adda-23e7-498f-9ff3-26c138903b88", + "metadata": {}, + "source": [ + "1. Use the final model (tuning parameter) obtained from 10-fold CV and fit the model again using the full dataset and display the corresponding coefficients." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac884445-bc95-4659-b656-d9c5f821bf52", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "05635216-4afb-4d0d-982a-a2af35d6bf3a", + "metadata": {}, + "source": [ + "2. Multiply the feature Errors by $1/1000$ and again fit the model from Task 1. Display the coefficients and interpret. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "70bc0da8-6134-4d4d-ad1f-e43ea26fae3c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "b6e19093-51bf-4e68-aba6-01c34905b5e4", + "metadata": {}, + "source": [ + "3. Redo Task 2 BUT without the normalizing (standardize) the data. Refit the same model again and display the coefficients. Interpret. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a38add3-642e-41a8-8b80-c3d01a63e538", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "df85262d-8a38-4bf9-9dfa-0a001e117d33", + "metadata": {}, + "source": [ + "4. Split the dataset into a training set using $80\\%$ of the observations and validation set using all other observations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0a152a8-395e-49e2-973d-252b88cd379c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "e1e3e60e-0d5a-4340-ae29-9153ffdad7c8", + "metadata": {}, + "source": [ + "5. Set up a grid for the tuning parameter $\\lambda$ and fit Lasso regressions for all tuning parameters using the training data. Make sure that you choose the mininmum and maximum values of $\\lambda$ so that it allows you to determine the optimal $\\lambda$ parameter in the next task (you might need to play with the grid size a bit). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5e0cff0-6782-40a3-8d7f-891c19bb5f4d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "21ba53c0-def1-4059-9872-27e6b437b8af", + "metadata": {}, + "source": [ + "6. For each model (tuning parameter), compute the mean squared prediction error in the validation dataset. Plot the validation error as a function of $\\lambda$ and find the best model which minimizes the validation error. Display the estimated coefficients for the best model and check whether some features are not selected in the final regression. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8323ce02-17fe-4f54-820d-030f198a34fe", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "19f07912-bffd-4a19-9a92-aa1a2dc48c75", + "metadata": {}, + "source": [ + "7. Finally compare the best Lasso model obtained from the validation set approach from Task 6 to the best Lasso model obtained by 5-fold cross-validation. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0166113-9d31-4e42-a8df-69f2048b65af", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "8fd306c8-2247-4343-8c30-5dd99393c9d0", + "metadata": {}, + "source": [ + "8. Compare the best model from Task 7 to the best ridge regression obtained from 5-fold cross validation. How do the coefficients of the two models differ?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3c70e9bd-78d9-4a91-a28f-588fca65c616", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression_solved.ipynb b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression_solved.ipynb new file mode 100755 index 0000000..9b3c346 --- /dev/null +++ b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression_solved.ipynb @@ -0,0 +1,550 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4ef176ca-44e5-472f-ba91-dbf3c808423f", + "metadata": {}, + "source": [ + "# Preliminary setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "a8bae312-073e-4e8e-947d-c72022422fb2", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from ISLP import load_data\n", + "from matplotlib.pyplot import subplots, show\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# Load and preprocess data\n", + "Hitters = load_data('Hitters').dropna()" + ] + }, + { + "cell_type": "markdown", + "id": "87902d82-5336-456b-bec8-403530c75f00", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "# Task" + ] + }, + { + "cell_type": "markdown", + "id": "0ce8adda-23e7-498f-9ff3-26c138903b88", + "metadata": {}, + "source": [ + "1. Use the final model (tuning parameter) obtained from 10-fold CV and fit the model again using the full dataset and display the corresponding coefficients." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "ac884445-bc95-4659-b656-d9c5f821bf52", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ -2.02860796 7.58424738 4.03379342 -2.32240494 -0.88451987\n", + " 6.19542148 -3.22976069 -0.17077862 0.10671085 -0.20456668\n", + " 1.49604977 0.81815031 -0.80943149 0.28390582 0.37371839\n", + " -3.20449556 36.02559023 -98.31856376 -1.03497201]\n" + ] + } + ], + "source": [ + "from sklearn.linear_model import RidgeCV, Lasso, LassoCV, Ridge\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.metrics import mean_squared_error\n", + "from sklearn.utils import shuffle\n", + "\n", + "# Construct feature matrix and outcome variable\n", + "X = pd.get_dummies(Hitters.drop(columns='Salary'), drop_first=True)\n", + "y = Hitters['Salary'].values\n", + "\n", + "# Task 1: Ridge regression with CV to find best lambda (alpha)\n", + "alphas = np.exp(np.linspace(0, 8, 50))\n", + "ridge_cv = RidgeCV(alphas=alphas, store_cv_results=True)\n", + "ridge_cv.fit(X, y)\n", + "best_alpha_ridge = ridge_cv.alpha_\n", + "ridge_model = Ridge(alpha=best_alpha_ridge)\n", + "ridge_model.fit(X, y)\n", + "coef_task1 = ridge_model.coef_\n", + "\n", + "print(coef_task1)" + ] + }, + { + "cell_type": "markdown", + "id": "05635216-4afb-4d0d-982a-a2af35d6bf3a", + "metadata": {}, + "source": [ + "2. Multiply the feature Errors by $1/1000$ and again fit the model from Task 1. Display the coefficients and interpret. " + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "70bc0da8-6134-4d4d-ad1f-e43ea26fae3c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficients after rescaling + standardization:\n", + " [-120.75620416 141.98271425 -10.7355903 23.13998844 16.78667849\n", + " 79.16269699 -46.75097671 -13.02193553 93.80996664 57.58064435\n", + " 110.86292201 89.70452309 -86.55162346 74.72391629 27.29818898\n", + " -24.87620768 27.59197633 -61.81228093 -10.31249136]\n" + ] + } + ], + "source": [ + "# Task 2: Scale one variable manually and fit ridge with standardization\n", + "X_scaled = X.copy()\n", + "\n", + "# Rescale 'Errors' by 1/1000\n", + "X_scaled['Errors'] = X_scaled['Errors'].astype(float) / 1000\n", + "\n", + "# Standardize (if required by the task)\n", + "scaler = StandardScaler()\n", + "X_scaled = pd.DataFrame(scaler.fit_transform(X_scaled), columns=X.columns)\n", + "\n", + "# Fit ridge model\n", + "ridge_model2 = Ridge(alpha=best_alpha_ridge)\n", + "ridge_model2.fit(X_scaled, y)\n", + "coef_task2 = ridge_model2.coef_\n", + "print(\"Coefficients after rescaling + standardization:\\n\", coef_task2)" + ] + }, + { + "cell_type": "markdown", + "id": "b6e19093-51bf-4e68-aba6-01c34905b5e4", + "metadata": {}, + "source": [ + "3. Redo Task 2 BUT without the normalizing (standardize) the data. Refit the same model again and display the coefficients. Interpret. " + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "5a38add3-642e-41a8-8b80-c3d01a63e538", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coefficients after rescaling WITHOUT standardization:\n", + " [-2.08316424e+00 7.83574168e+00 4.03538434e+00 -2.46707401e+00\n", + " -1.01184803e+00 6.30012470e+00 -2.72891307e+00 -1.63751994e-01\n", + " 4.96433825e-02 -2.72096047e-01 1.55164973e+00 8.48452938e-01\n", + " -8.20932977e-01 2.79014031e-01 2.72444155e-01 -1.43983852e+00\n", + " 3.27987035e+01 -9.84477207e+01 1.27421956e-01]\n" + ] + } + ], + "source": [ + "# Task 3: Same variable but no standardization\n", + "X_no_std = X.copy()\n", + "\n", + "# Rescale 'Errors' only\n", + "X_no_std['Errors'] = X_no_std['Errors'].astype(float) / 1000\n", + "\n", + "# Do not standardize\n", + "ridge_model3 = Ridge(alpha=best_alpha_ridge)\n", + "ridge_model3.fit(X_no_std, y)\n", + "coef_task3 = ridge_model3.coef_\n", + "print(\"Coefficients after rescaling WITHOUT standardization:\\n\", coef_task3)" + ] + }, + { + "cell_type": "markdown", + "id": "df85262d-8a38-4bf9-9dfa-0a001e117d33", + "metadata": {}, + "source": [ + "4. Split the dataset into a training set using $80\\%$ of the observations and validation set using all other observations." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "b0a152a8-395e-49e2-973d-252b88cd379c", + "metadata": {}, + "outputs": [], + "source": [ + "# Task 4: Shuffle data and split\n", + "Hitters_shuffled = shuffle(Hitters, random_state=2)\n", + "n = len(Hitters_shuffled)\n", + "nTr = int(n * 0.8)\n", + "train_data = Hitters_shuffled[:nTr]\n", + "val_data = Hitters_shuffled[nTr:]\n", + "\n", + "X_train = pd.get_dummies(train_data.drop(columns='Salary'), drop_first=True)\n", + "y_train = train_data['Salary'].values\n", + "X_val = pd.get_dummies(val_data.drop(columns='Salary'), drop_first=True)\n", + "y_val = val_data['Salary'].values" + ] + }, + { + "cell_type": "markdown", + "id": "e1e3e60e-0d5a-4340-ae29-9153ffdad7c8", + "metadata": {}, + "source": [ + "5. Set up a grid for the tuning parameter $\\lambda$ and fit Lasso regressions for all tuning parameters using the training data. Make sure that you choose the mininmum and maximum values of $\\lambda$ so that it allows you to determine the optimal $\\lambda$ parameter in the next task (you might need to play with the grid size a bit). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53b4d5aa-87a2-4cd2-95a0-427d5e29e9c0", + "metadata": {}, + "outputs": [], + "source": [ + "# Task 5: Lasso grid\n", + "grid = np.linspace(0.001, 100, 100)\n", + "val_errors = []\n", + "\n", + "for alpha in grid:\n", + " lasso = Lasso(alpha=alpha, max_iter=10000)\n", + " lasso.fit(X_train, y_train)\n", + " y_pred = lasso.predict(X_val)\n", + " val_errors.append(mean_squared_error(y_val, y_pred))" + ] + }, + { + "cell_type": "markdown", + "id": "21ba53c0-def1-4059-9872-27e6b437b8af", + "metadata": {}, + "source": [ + "6. For each model (tuning parameter), compute the mean squared prediction error in the validation dataset. Plot the validation error as a function of $\\lambda$ and find the best model which minimizes the validation error. Display the estimated coefficients for the best model and check whether some features are not selected in the final regression. " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "b5e0cff0-6782-40a3-8d7f-891c19bb5f4d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Task 6: Lasso grid plot\n", + "plt.plot(grid, val_errors)\n", + "plt.xlabel('Lambda')\n", + "plt.ylabel('Validation MSE')\n", + "plt.title('Lasso Validation Error')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "060f3ffb-5c85-4d26-ab5a-03eff6cc34c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "52415.86383077253\n" + ] + } + ], + "source": [ + "print(min(val_errors))" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "19d25e18-0763-41cb-b65c-2b884a99d523", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best lambda: 100.0 \n", + "\n", + "Lasso results: \n", + " AtBat -2.015511\n", + "Hits 6.056399\n", + "HmRun -0.000000\n", + "Runs -0.000000\n", + "RBI 0.000000\n", + "Walks 5.565911\n", + "Years -0.000000\n", + "CAtBat -0.303844\n", + "CHits 0.521263\n", + "CHmRun -0.000000\n", + "CRuns 1.402914\n", + "CRBI 0.900971\n", + "CWalks -0.753718\n", + "PutOuts 0.292351\n", + "Assists 0.362418\n", + "Errors -0.000000\n", + "League_N 0.000000\n", + "Division_W -0.000000\n", + "NewLeague_N 0.000000\n", + "dtype: float64 \n", + "\n", + "Non-zero Lasso coefficients: \n", + " Hits 6.056399\n", + "Walks 5.565911\n", + "CRuns 1.402914\n", + "CRBI 0.900971\n", + "CHits 0.521263\n", + "Assists 0.362418\n", + "PutOuts 0.292351\n", + "CAtBat -0.303844\n", + "CWalks -0.753718\n", + "AtBat -2.015511\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "# Find best model\n", + "min_index = np.argmin(val_errors)\n", + "best_lambda_lasso_cv = grid[min_index]\n", + "print(\"Best lambda: \",best_lambda_lasso_cv,'\\n')\n", + "\n", + "# Refit model with best lambda\n", + "best_lasso_model = Lasso(alpha=best_lambda_lasso_cv, max_iter=10000).fit(X_train, y_train)\n", + "best_lasso_coefs = pd.Series(best_lasso_model.coef_, index=X_train.columns)\n", + "print(\"Lasso results: \\n\",best_lasso_coefs,'\\n')\n", + "\n", + "# Display non-zero coefficients\n", + "non_zero_coefs = best_lasso_coefs[best_lasso_coefs != 0]\n", + "non_zero_coefs.sort_values(ascending=False)\n", + "print(\"Non-zero Lasso coefficients: \\n\",non_zero_coefs.sort_values(ascending=False))" + ] + }, + { + "cell_type": "markdown", + "id": "a200cb80-d1c1-4ff5-a2fd-bf9742a5e913", + "metadata": {}, + "source": [ + "## Extra code (not same! 10 folds!)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "31de56c7-a6e1-45ef-85a6-16656320feae", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.linear_model import Lasso\n", + "from sklearn.metrics import mean_squared_error\n", + "from sklearn.utils import shuffle\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Create lambda grid\n", + "grid = np.linspace(0.001, 100, 100)\n", + "val_errors_mean = []\n", + "val_errors_std = []\n", + "\n", + "# Repeat train/validation split multiple times\n", + "n_runs = 10\n", + "\n", + "for alpha in grid:\n", + " run_errors = []\n", + " for seed in range(n_runs):\n", + " # Shuffle and split each time\n", + " Hitters_shuffled = shuffle(Hitters, random_state=seed)\n", + " n = len(Hitters_shuffled)\n", + " nTr = int(n * 0.8)\n", + " train_data = Hitters_shuffled[:nTr]\n", + " val_data = Hitters_shuffled[nTr:]\n", + "\n", + " X_train = pd.get_dummies(train_data.drop(columns='Salary'), drop_first=True)\n", + " y_train = train_data['Salary'].values\n", + " X_val = pd.get_dummies(val_data.drop(columns='Salary'), drop_first=True)\n", + " y_val = val_data['Salary'].values\n", + "\n", + " # Align columns (in case some category levels are missing)\n", + " X_val = X_val.reindex(columns=X_train.columns, fill_value=0)\n", + "\n", + " model = Lasso(alpha=alpha, max_iter=10000)\n", + " model.fit(X_train, y_train)\n", + " y_pred = model.predict(X_val)\n", + " run_errors.append(mean_squared_error(y_val, y_pred))\n", + "\n", + " val_errors_mean.append(np.mean(run_errors))\n", + " val_errors_std.append(np.std(run_errors))\n", + "\n", + "# Plot with error bars\n", + "plt.figure(figsize=(7,5))\n", + "plt.errorbar(grid, val_errors_mean, yerr=val_errors_std, fmt='o', ecolor='gray', capsize=3, color='red')\n", + "plt.xlabel('Lambda')\n", + "plt.ylabel('Validation MSE')\n", + "plt.title('Lasso Validation Error with Error Bars')\n", + "plt.grid(True)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "8bfc8cbd-3441-4129-8c56-5c63c057f6ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "117142.78701588386\n" + ] + } + ], + "source": [ + "print(min(val_errors_mean))" + ] + }, + { + "cell_type": "markdown", + "id": "19f07912-bffd-4a19-9a92-aa1a2dc48c75", + "metadata": {}, + "source": [ + "7. Finally compare the best Lasso model obtained from the validation set approach from Task 6 to the best Lasso model obtained by 5-fold cross-validation. " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "e0166113-9d31-4e42-a8df-69f2048b65af", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.66927222 5.71591888 0. -0. 0. 4.64628557\n", + " -0. -0.23063656 0.35464977 0. 1.26847803 0.74243336\n", + " -0.57932076 0.28981039 0.26073614 -0. 0. -0.\n", + " 0. ]\n", + "\n", + "Lasso-MSE: 96459.01482992568 with alpha 113.82860789196029\n" + ] + } + ], + "source": [ + "# Task 7 & 8: LassoCV and RidgeCV\n", + "lasso_cv = LassoCV(cv=5, random_state=1, max_iter=10000, alphas=alphas)\n", + "lasso_cv.fit(X, y)\n", + "y_pred_lasso = lasso_cv.predict(X)\n", + "mse_lasso_cv = mean_squared_error(y, y_pred_lasso)\n", + "best_lambda_lasso = lasso_cv.alpha_\n", + "lasso_cv_coefs = lasso_cv.coef_\n", + "\n", + "print(lasso_cv_coefs)\n", + "\n", + "print('\\nLasso-MSE: ',mse_lasso_cv, 'with alpha', best_lambda_lasso)" + ] + }, + { + "cell_type": "markdown", + "id": "8fd306c8-2247-4343-8c30-5dd99393c9d0", + "metadata": {}, + "source": [ + "8. Compare the best model from Task 7 to the best ridge regression obtained from 5-fold cross validation. How do the coefficients of the two models differ?" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "3c70e9bd-78d9-4a91-a28f-588fca65c616", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-1.92090495 6.39400133 0.35386008 -0.66701689 0.47113815 5.2897077\n", + " -0.31582864 -0.2195458 0.30632354 0.07691325 1.38722192 0.68697756\n", + " -0.67956448 0.29499384 0.35765861 -2.07935974 0.90188371 -2.38262927\n", + " 0.65171112]\n", + "\n", + "Ridge-MSE: 92141.38240788862 with alpha 2980.9579870417283\n" + ] + } + ], + "source": [ + "ridge_cv_5fold = RidgeCV(alphas=alphas, cv=5)\n", + "ridge_cv_5fold.fit(X, y)\n", + "y_pred_ridge = ridge_cv.predict(X)\n", + "mse_ridge_cv = mean_squared_error(y, y_pred_ridge)\n", + "best_lambda_ridge = ridge_cv_5fold.alpha_\n", + "ridge_cv_coefs = ridge_cv_5fold.coef_\n", + "\n", + "print(ridge_cv_coefs)\n", + "\n", + "print('\\nRidge-MSE: ',mse_ridge_cv, 'with alpha', best_lambda_ridge)" + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression_solved.pdf b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression_solved.pdf new file mode 100755 index 0000000..0968a43 Binary files /dev/null and b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/04_RidgeRegression_solved.pdf differ diff --git a/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/Script04_codes_FSS.py b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/Script04_codes_FSS.py new file mode 100755 index 0000000..0de731c --- /dev/null +++ b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/Script04_codes_FSS.py @@ -0,0 +1,164 @@ +import pandas as pd +import numpy as np +from sklearn.linear_model import LinearRegression +from sklearn.feature_selection import SequentialFeatureSelector +from ISLP import load_data + +### +# Forward stepwise selection +### +# Load Hitters dataset from ISLP +Hitters = load_data('Hitters') + +# Remove missing values +Hitters = Hitters.dropna() + +# Create dummy variables for categorical columns +Hitters = pd.get_dummies(Hitters, drop_first=True) + +# Separate response (target) and predictors +y = Hitters['Salary'] +X = Hitters.drop(columns=['Salary']) + +# Define the linear regression model +model = LinearRegression() + +# Perform forward stepwise selection using SequentialFeatureSelector +#sfs = SequentialFeatureSelector(model, n_features_to_select=15, direction='forward', cv=5) +sfs = SequentialFeatureSelector(model, n_features_to_select=15, direction='forward') + +# Fit the model to the data +sfs.fit(X, y) + +# Get the selected features +selected_features = X.columns[sfs.get_support()] + +# Fit the model with the selected features +model.fit(X[selected_features], y) + +# Coefficients of the selected features +coefficients = pd.DataFrame({ + 'Feature': selected_features, + 'Coefficient': model.coef_ +}) + +# Printing short summary - intercept, coefficients and $R^{2}$ +print("\nIntercept:") +print(model.intercept_) + +print("\nCoefficients:") +print(coefficients) + +print("\nR-squared:") +print(model.score(X[selected_features], y)) + + +### +# Validation errors for FSS +### +from sklearn.model_selection import train_test_split +from sklearn.metrics import mean_squared_error as MSE +from mlxtend.feature_selection import SequentialFeatureSelector as SFS +import statsmodels.api as sm + +# Split the data into training and validation sets based on row indices +train_data = Hitters.iloc[:184] # First 184 rows for training data +val_data = Hitters.iloc[184:263] # Rows 185 to 263 for validation data + +# Define X and y for both training and validation sets +X_train = train_data.drop(columns=['Salary']) +y_train = train_data['Salary'] +X_val = val_data.drop(columns=['Salary']) +y_val = val_data['Salary'] + +# Ensure that all categorical variables are encoded as numeric +X_train = pd.get_dummies(X_train, drop_first=True).astype(float) +X_val = pd.get_dummies(X_val, drop_first=True).astype(float) + +# Align columns of validation set to match training set +X_val = X_val.reindex(columns=X_train.columns, fill_value=0).astype(float) + +# Convert validation data to matrix form (for statsmodels) +val_data = sm.add_constant(X_val) + +# Ensure target variable is numeric +y_train_np = np.asarray(y_train).astype(float) +y_val_np = np.asarray(y_val).astype(float) + + +# Run forward stepwise selection using sklearn's SequentialFeatureSelector +model2 = LinearRegression() + +sfs2 = SFS(model2, + k_features=15, + forward=True, + floating=False, + scoring='neg_mean_squared_error', + cv=0) # No cross-validation + +sfs2.fit(X_train, y_train) + +# Extract selected features for each number of features (1 to 15) +#selected_features = list(sfs2.subsets_) +selected_features = sfs2.subsets_ + +# Compute validation mean squared errors for each model +val_err = np.zeros(15) +for i in range(1, 16): + # Get the selected feature names for this step + feature_names = selected_features[i]['feature_names'] + + # Select the corresponding features from X_train + X_train_selected = X_train[list(feature_names)] + + # Add constant (intercept) term + X_train_selected = sm.add_constant(X_train_selected).astype(float) + + # Ensure the selected features are numeric + X_train_selected_np = np.asarray(X_train_selected).astype(float) + + # Fit OLS model + model = sm.OLS(y_train_np, X_train_selected_np).fit() + + # Predict on validation set + X_val_selected = val_data[list(feature_names)] + X_val_selected_np = sm.add_constant(X_val_selected).astype(float) # Ensure numpy array is float + + y_pred_val = model.predict(X_val_selected_np) + + # Compute MSE for validation set + val_err[i - 1] = MSE(y_val_np, y_pred_val) + +# Print validation errors for each model size +print("Validation Errors for each model size (1 to 15 features):") +print(val_err) + +print("\nMin val_err: ", min(val_err)) + + +## +# PLOT results +## +import matplotlib.pyplot as plt +# Assuming 'val_err' contains the validation MSE values + +# Find the index of the minimum validation error +min_index = np.argmin(val_err) + 1 # +1 because index starts from 0, but variables start from 1 + +# Plot the validation errors +plt.figure(figsize=(8, 5)) +plt.plot(range(1, 16), val_err, marker='o', linestyle='--', color='black') + +# Highlight the minimum MSE with a red vertical line +plt.axvline(x=min_index, color='red', linestyle='-', linewidth=1.5) + +# Label the axes +plt.xlabel("# Variables", fontsize=12) +plt.ylabel("Validation MSE", fontsize=12) + +# Title for the plot (optional) +plt.title("Validation MSE vs Number of Variables", fontsize=14) + +# Show the plot +plt.tight_layout() +plt.show() diff --git a/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/Script04_codes_RR_LR_01.04.2025.py b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/Script04_codes_RR_LR_01.04.2025.py new file mode 100755 index 0000000..814d473 --- /dev/null +++ b/Machine Learning for Economics and Finance/04_Subset Selection & Shrinkage/Script04_codes_RR_LR_01.04.2025.py @@ -0,0 +1,50 @@ +import pandas as pd +import numpy as np +from sklearn.linear_model import Ridge, RidgeCV, LassoCV +from sklearn.preprocessing import StandardScaler +from ISLP import load_data + +# === Setup === +# Load and preprocess data +Hitters = load_data('Hitters').dropna() +Hitters = pd.get_dummies(Hitters, drop_first=True) +y = Hitters['Salary'] +X = Hitters.drop(columns=['Salary']) + +# Standardize predictors +scaler = StandardScaler() +X_scaled = scaler.fit_transform(X) + +# === SLIDE 1: Ridge regression with fixed lambda === +ridge_fixed = Ridge(alpha=100) +ridge_fixed.fit(X_scaled, y) +ridge_fixed_coeffs = ridge_fixed.coef_ +ridge_fixed_preds = ridge_fixed.predict(X_scaled[:5]) + +# === SLIDE 2: Ridge regression with cross-validation to find best lambda === +lambdas = 10**np.linspace(10, -2, 100) * 0.5 # Equivalent to R's lambda grid +ridge_cv = RidgeCV(alphas=lambdas, scoring='neg_mean_squared_error', cv=10) +ridge_cv.fit(X_scaled, y) +best_lambda_ridge = ridge_cv.alpha_ +ridge_cv_coeffs = ridge_cv.coef_ +ridge_cv_preds = ridge_cv.predict(X_scaled[:5]) + +# === SLIDE 3: Lasso regression with cross-validation === +lasso_cv = LassoCV(cv=10, max_iter=10000) +lasso_cv.fit(X_scaled, y) +best_lambda_lasso = lasso_cv.alpha_ +lasso_cv_coeffs = lasso_cv.coef_ +lasso_cv_preds = lasso_cv.predict(X_scaled[:5]) + +# === Create summary DataFrame === +summary = pd.DataFrame({ + 'Model': ['Ridge (lambda=100)', 'RidgeCV (best lambda)', 'LassoCV (best lambda)'], + 'Best Lambda': [100, best_lambda_ridge, best_lambda_lasso], + 'Non-zero Coefficients': [ + np.sum(ridge_fixed_coeffs != 0), + np.sum(ridge_cv_coeffs != 0), + np.sum(lasso_cv_coeffs != 0) + ] +}) + +print(summary) diff --git a/Machine Learning for Economics and Finance/05_Tree Based Methods/05 Trees Carseats.py b/Machine Learning for Economics and Finance/05_Tree Based Methods/05 Trees Carseats.py new file mode 100755 index 0000000..0dd48f5 --- /dev/null +++ b/Machine Learning for Economics and Finance/05_Tree Based Methods/05 Trees Carseats.py @@ -0,0 +1,101 @@ +import numpy as np +import pandas as pd +from ISLP import load_data +from sklearn.model_selection import train_test_split +from sklearn.tree import DecisionTreeClassifier, plot_tree +from sklearn.metrics import accuracy_score +from sklearn.ensemble import RandomForestClassifier +from sklearn.model_selection import cross_val_score +import matplotlib.pyplot as plt +import seaborn as sns +# Load and preprocess data +Carseats = load_data('Carseats').dropna() + +# Create qualitative variable "High" vs "Low" Sales +Carseats['High'] = np.where(Carseats['Sales'] <= 8, 'No', 'Yes') +Carseats['High'] = Carseats['High'].astype('category') + +# Drop 'Sales' from predictors +X = Carseats.drop(columns=['Sales', 'High']) +X = pd.get_dummies(X, drop_first=True) # Convert categorical to dummy variables +y = Carseats['High'] + +# Train/test split (200 obs each) +np.random.seed(2) +train_idx = np.random.choice(len(Carseats), size=200, replace=False) +X_train = X.iloc[train_idx] +X_test = X.drop(train_idx) +y_train = y.iloc[train_idx] +y_test = y.drop(train_idx) + +# Fit classification tree +tree_model = DecisionTreeClassifier(criterion='entropy', random_state=2) +tree_model.fit(X_train, y_train) + +# Summary +print(f"Tree depth: {tree_model.get_depth()}, Terminal nodes: {tree_model.get_n_leaves()}") + +# Plot tree +plt.figure(figsize=(16, 8)) +plot_tree(tree_model, filled=True, feature_names=X.columns, class_names=tree_model.classes_, fontsize=8) +plt.title("Classification Tree") +plt.show() + +# Test error rate +y_pred = tree_model.predict(X_test) +error_rate_test = np.mean(y_pred != y_test) +print(f"Test Error (Unpruned Tree): {error_rate_test:.3f}") + +# Cross-validation to find optimal pruning parameter using cost-complexity pruning +path = tree_model.cost_complexity_pruning_path(X_train, y_train) +ccp_alphas = path.ccp_alphas[:-1] # exclude the last (trivial) alpha +cv_errors = [] + +for alpha in ccp_alphas: + clf = DecisionTreeClassifier(random_state=2, ccp_alpha=alpha) + scores = cross_val_score(clf, X_train, y_train, cv=5, scoring='accuracy') + cv_errors.append(1 - scores.mean()) + +# Plot CV errors +plt.figure(figsize=(8, 5)) +plt.plot(ccp_alphas, cv_errors, marker='o') +plt.xlabel("ccp_alpha") +plt.ylabel("Cross-Validated Classification Error") +plt.title("CV Error vs. Tree Complexity") +plt.show() + +# Prune tree with optimal alpha (min CV error) +optimal_alpha = ccp_alphas[np.argmin(cv_errors)] +pruned_tree = DecisionTreeClassifier(random_state=2, ccp_alpha=optimal_alpha) +pruned_tree.fit(X_train, y_train) + +# Plot pruned tree +plt.figure(figsize=(16, 8)) +plot_tree(pruned_tree, filled=True, feature_names=X.columns, class_names=pruned_tree.classes_, fontsize=8) +plt.title("Pruned Classification Tree") +plt.show() + +# Test error of pruned tree +y_pred_pruned = pruned_tree.predict(X_test) +error_rate_pruned = np.mean(y_pred_pruned != y_test) +print(f"Test Error (Pruned Tree): {error_rate_pruned:.3f}") + +# Fit Random Forest +rf_model = RandomForestClassifier(n_estimators=500, max_features=3, oob_score=True, random_state=2) +rf_model.fit(X_train, y_train) + +# OOB Error +oob_error = 1 - rf_model.oob_score_ if rf_model.oob_score else "OOB not enabled" +print(f"OOB Error Rate: {oob_error}") + +# Test error of RF +rf_pred = rf_model.predict(X_test) +error_rate_rf = np.mean(rf_pred != y_test) +print(f"Test Error (Random Forest): {error_rate_rf:.3f}") + +# Feature importance +importances = pd.Series(rf_model.feature_importances_, index=X.columns) +importances.sort_values(ascending=True).plot(kind='barh', figsize=(10, 8), title="Variable Importance") +plt.xlabel("Importance") +plt.tight_layout() +plt.show() diff --git a/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task.ipynb b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task.ipynb new file mode 100755 index 0000000..451d63a --- /dev/null +++ b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task.ipynb @@ -0,0 +1,293 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "67cd5699-6111-4576-9386-0fe46130f060", + "metadata": {}, + "source": [ + "# Preliminary setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ea9c10a-5919-467d-8aca-efa3f2bc05e3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from ISLP import load_data\n", + "from matplotlib.pyplot import subplots, show\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# Load and preprocess data\n", + "Hitters = load_data('Hitters').dropna()" + ] + }, + { + "cell_type": "markdown", + "id": "ce3b15bc-bebb-48cb-b0ab-8754b5004796", + "metadata": {}, + "source": [ + "# Task 1" + ] + }, + { + "cell_type": "markdown", + "id": "a277a01e-5932-4376-9771-ca735b510eab", + "metadata": {}, + "source": [ + "1. Use the Hitters data and remove all rows that contain missing values. Create a new\n", + "variable that is the log of Salary and provide histograms for Salary and Log(Salary).\n", + "Interpret." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bcc5d1a2-c5b8-401d-b854-dd0ff5837704", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "5ce10e96-7257-4e74-b4dd-61eadc98090a", + "metadata": {}, + "source": [ + "2. Split the sample into a training dataset consisting of the first 200 observations and a\n", + "test dataset containing the remaining observations." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e1c39b34-4e4e-42bb-a915-ff7d9edc2bb5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "2cffb0ba-7e62-4cff-b79d-ef5e027a62ec", + "metadata": {}, + "source": [ + "3. Fit a large, unpruned regression tree to predigt Log(Salary). Which features are used\n", + "to construct the tree, which features are the most important and how many terminal\n", + "nodes does the tree have? You might want to plot the tree for this exercise." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "425892e5-ba65-4be4-b103-5d1968973cf5", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "0c19dc38-6d3d-4d83-8e77-eab071883a1e", + "metadata": {}, + "source": [ + "4. Compute the mean squared prediction error for the test data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb73ed7b-6730-4a98-b04e-0d12c0c7125d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "dbae3448-f484-4fe2-afd1-40a741b8ef9e", + "metadata": {}, + "source": [ + "5. Let’s try to improve predictions using k-fold CV. Set the seed to 2 and run 5-fold cross\n", + "validation. Plot the mean squared cross validation error against the tree size and\n", + "report the tree size and the pruning parameter α that minimize the mean squared\n", + "cross validation error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "31280859-0b4f-4b8d-9aeb-4e9c83bd008a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "37322a0e-a542-4b10-88e3-eb88d7b1f2ac", + "metadata": {}, + "source": [ + "6. Use the pruning parameter from the previous task to prune the tree. Plot the tree and\n", + "report the most important variables." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b8bf40b3-8cba-4335-92e2-686ba0a93185", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "67496351-580b-4e9f-9b17-2776f2c55843", + "metadata": {}, + "source": [ + "7. Compute the test mean squared prediction error for pruned tree and compare to the\n", + "results from Task 4." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3104831-7607-4eab-a0a2-861adde2658d", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "30021421-8807-4481-b28d-6ea23cb06b82", + "metadata": {}, + "source": [ + "8. Use random forest to improve the predictions. Fit $500$ trees using $m = \\sqrt(p)$ (round to the nearest integer)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c907edbf-5755-4a5c-bd12-ea80a2358358", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "4b014396-e91b-4f72-9b58-85fa80805eb0", + "metadata": {}, + "source": [ + "9. Do you think it was necessary to fit $500$ trees or would have fewer trees be sufficient? Determine the number of trees that provides the lowest OOB error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "77cb58bd-6d3d-4b0d-ad5e-e18737501cb8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "2cea0e71-cc51-4890-b776-e4f03d7af94d", + "metadata": {}, + "source": [ + "10. Compute the OOB estimate of the out-of-sample error and compare it to best pruned model from CV of Task 5. Interpret the outcomes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6aafe1d3-b54c-4bca-9070-ea62ac27f885", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "992771aa-1fec-44d0-b3f5-e8525bd1ce79", + "metadata": {}, + "source": [ + "11. Which are the most important variables used in the random forest?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85841a9e-4df5-4d14-ae2b-107002042fd8", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "bc5eee45-8c48-41dd-ba38-7f78c4bcd036", + "metadata": {}, + "source": [ + "12. Let’s try to improve the random forest by trying out different values for $m$. Set up a grid for m going from $1$ to $p$. Write a loop that fits a random forest for each $m$. Explain which model you would choose." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0361acc5-041d-46b1-848d-eadea0ce717b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "6f38e2e4-8242-46c6-9c49-69b7ee73be1e", + "metadata": {}, + "source": [ + "13. For the best model, compute the test errors and compare them to the best pruned model from Task 7." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d31d199b-116f-4585-8e4d-e40d4b6ff685", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "d6f1407e-5ad1-4690-bf9e-ecc36c4a50e5", + "metadata": {}, + "source": [ + "14. What is the OOB error obtained from bagging (you can infer the answer from the previous task)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d7ed7a03-8520-4fba-b2ff-500979e92496", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task.pdf b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task.pdf new file mode 100755 index 0000000..f614517 Binary files /dev/null and b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task.pdf differ diff --git a/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task_solved.ipynb b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task_solved.ipynb new file mode 100755 index 0000000..839e3ca --- /dev/null +++ b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task_solved.ipynb @@ -0,0 +1,725 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "67cd5699-6111-4576-9386-0fe46130f060", + "metadata": {}, + "source": [ + "# Preliminary setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0ea9c10a-5919-467d-8aca-efa3f2bc05e3", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "from ISLP import load_data\n", + "from matplotlib.pyplot import subplots, show\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "# Load and preprocess data\n", + "Hitters = load_data('Hitters').dropna()" + ] + }, + { + "cell_type": "markdown", + "id": "ce3b15bc-bebb-48cb-b0ab-8754b5004796", + "metadata": {}, + "source": [ + "# Task 1" + ] + }, + { + "cell_type": "markdown", + "id": "a277a01e-5932-4376-9771-ca735b510eab", + "metadata": {}, + "source": [ + "1. Use the Hitters data and remove all rows that contain missing values. Create a new\n", + "variable that is the log of Salary and provide histograms for Salary and Log(Salary).\n", + "Interpret." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "bcc5d1a2-c5b8-401d-b854-dd0ff5837704", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Task 1: Load and preprocess data\n", + "Hitters = load_data('Hitters').dropna()\n", + "\n", + "# Add log of Salary\n", + "Hitters['LogSalary'] = np.log(Hitters['Salary'])\n", + "\n", + "# Histograms\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 5))\n", + "axs[0].hist(Hitters['Salary'], bins=20, color='skyblue', edgecolor='black')\n", + "axs[0].set_title('Histogram of Salary')\n", + "axs[1].hist(Hitters['LogSalary'], bins=20, color='salmon', edgecolor='black')\n", + "axs[1].set_title('Histogram of Log(Salary)')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5ce10e96-7257-4e74-b4dd-61eadc98090a", + "metadata": {}, + "source": [ + "2. Split the sample into a training dataset consisting of the first 200 observations and a\n", + "test dataset containing the remaining observations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e1c39b34-4e4e-42bb-a915-ff7d9edc2bb5", + "metadata": {}, + "outputs": [], + "source": [ + "# Task 2: Split the dataset\n", + "Hitters_dummies = pd.get_dummies(Hitters.drop(columns=['Salary']), drop_first=True)\n", + "X_train = Hitters_dummies.iloc[:200].drop(columns='LogSalary')\n", + "y_train = Hitters_dummies.iloc[:200]['LogSalary']\n", + "X_test = Hitters_dummies.iloc[200:].drop(columns='LogSalary')\n", + "y_test = Hitters_dummies.iloc[200:]['LogSalary']" + ] + }, + { + "cell_type": "markdown", + "id": "2cffb0ba-7e62-4cff-b79d-ef5e027a62ec", + "metadata": {}, + "source": [ + "3. Fit a large, unpruned regression tree to predigt Log(Salary). Which features are used\n", + "to construct the tree, which features are the most important and how many terminal\n", + "nodes does the tree have? You might want to plot the tree for this exercise." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "425892e5-ba65-4be4-b103-5d1968973cf5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Task 3: Fit a large tree\n", + "\n", + "from sklearn.tree import DecisionTreeRegressor, plot_tree\n", + "tree_model = DecisionTreeRegressor(random_state=1)\n", + "tree_model.fit(X_train, y_train)\n", + "\n", + "# Plot the tree\n", + "plt.figure(figsize=(16, 8))\n", + "plot_tree(tree_model, feature_names=X_train.columns, filled=True, rounded=True, max_depth=3)\n", + "plt.title(\"Large Regression Tree\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "451ea8d5-4ac9-4aaa-86fa-0b4ede003663", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CAtBat 0.614032\n", + "CRuns 0.105176\n", + "Walks 0.082480\n", + "Hits 0.039794\n", + "CRBI 0.030783\n", + "AtBat 0.022928\n", + "CHits 0.019713\n", + "PutOuts 0.018320\n", + "CHmRun 0.017818\n", + "RBI 0.014231\n", + "Assists 0.013396\n", + "Errors 0.005891\n", + "HmRun 0.005503\n", + "NewLeague_N 0.003566\n", + "CWalks 0.003453\n", + "Years 0.002096\n", + "Runs 0.000610\n", + "Division_W 0.000177\n", + "League_N 0.000033\n", + "dtype: float64 183 0.39152675958676264\n" + ] + } + ], + "source": [ + "# Task 3: feature importance\n", + "important_features = pd.Series(tree_model.feature_importances_, index=X_train.columns)\n", + "important_features = important_features[important_features > 0].sort_values(ascending=False)\n", + "print(important_features, n_leaves, mse_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "70fd73f6-dc16-4fd9-80a1-243cf080b685", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "183\n" + ] + } + ], + "source": [ + "# Task 3: number of terminal nodes\n", + "n_leaves = tree_model.get_n_leaves()\n", + "print(n_leaves)" + ] + }, + { + "cell_type": "markdown", + "id": "0c19dc38-6d3d-4d83-8e77-eab071883a1e", + "metadata": {}, + "source": [ + "4. Compute the mean squared prediction error for the test data." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "eb73ed7b-6730-4a98-b04e-0d12c0c7125d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.39152675958676264\n" + ] + } + ], + "source": [ + "# Task 4: Test MSE\n", + "\n", + "from sklearn.metrics import mean_squared_error\n", + "y_pred = tree_model.predict(X_test)\n", + "mse_test = mean_squared_error(y_test, y_pred)\n", + "print(mse_test)" + ] + }, + { + "cell_type": "markdown", + "id": "dbae3448-f484-4fe2-afd1-40a741b8ef9e", + "metadata": {}, + "source": [ + "5. Let’s try to improve predictions using k-fold CV. Set the seed to 2 and run 5-fold cross\n", + "validation. Plot the mean squared cross validation error against the tree size and\n", + "report the tree size and the pruning parameter α that minimize the mean squared\n", + "cross validation error." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "31280859-0b4f-4b8d-9aeb-4e9c83bd008a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Min CV MSE: 0.2644 at alpha = 0.01155\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import cross_val_score\n", + "\n", + "# Task 5: Cross-validation with cost-complexity pruning\n", + "path = tree_model.cost_complexity_pruning_path(X_train, y_train)\n", + "ccp_alphas = path.ccp_alphas[:-1] # skip the maximum alpha\n", + "trees = []\n", + "cv_results = []\n", + "\n", + "for ccp_alpha in ccp_alphas:\n", + " tree = DecisionTreeRegressor(random_state=2, ccp_alpha=ccp_alpha)\n", + " scores = cross_val_score(tree, X_train, y_train, scoring='neg_mean_squared_error', cv=5)\n", + " cv_results.append(-scores.mean())\n", + " tree.fit(X_train, y_train)\n", + " trees.append(tree)\n", + "\n", + "# Ausgabe der besten Ergebnisse\n", + "best_idx = np.argmin(cv_results)\n", + "print(f\"Min CV MSE: {cv_results[best_idx]:.4f} at alpha = {ccp_alphas[best_idx]:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "37322a0e-a542-4b10-88e3-eb88d7b1f2ac", + "metadata": {}, + "source": [ + "6. Use the pruning parameter from the previous task to prune the tree. Plot the tree and\n", + "report the most important variables." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b8bf40b3-8cba-4335-92e2-686ba0a93185", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Task 6: Plot pruned tree\n", + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "plot_tree(optimal_tree, feature_names=X_train.columns, filled=True, fontsize=8)\n", + "plt.title(f\"Pruned Tree with alpha={optimal_alpha:.4f}\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "67496351-580b-4e9f-9b17-2776f2c55843", + "metadata": {}, + "source": [ + "7. Compute the test mean squared prediction error for pruned tree and compare to the\n", + "results from Task 4." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c3104831-7607-4eab-a0a2-861adde2658d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test-MSE (unpruned): 0.3915\n", + "Test-MSE (pruned with α = 0.01155): 0.3079\n" + ] + } + ], + "source": [ + "# Task 7: Compute MSE on test set with pruned tree\n", + "from sklearn.metrics import mean_squared_error\n", + "\n", + "# Pruned MSE\n", + "y_pred_pruned = optimal_tree.predict(X_test)\n", + "mse_pruned = mean_squared_error(y_test, y_pred_pruned)\n", + "\n", + "print(f\"Test-MSE (unpruned): {mse_test:.4f}\")\n", + "print(f\"Test-MSE (pruned with α = {optimal_alpha:.5f}): {mse_pruned:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "f0b3321f-62b3-46c1-a819-a3bb3064924f", + "metadata": {}, + "source": [ + "8. Use random forest to improve the predictions. Fit $500$ trees using $m = \\sqrt(p)$ (round to the nearest integer)." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "83942e1c-32a9-4333-9a59-4490d19feded", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random Forest MSE (500 trees): 0.2122\n" + ] + } + ], + "source": [ + "from sklearn.ensemble import RandomForestRegressor\n", + "\n", + "# Random Forest with m = sqrt(p)\n", + "p = X_train.shape[1]\n", + "m_try = int(np.round(np.sqrt(p)))\n", + "\n", + "rf_model = RandomForestRegressor(n_estimators=500, max_features=m_try, oob_score=True, random_state=1)\n", + "rf_model.fit(X_train, y_train)\n", + "\n", + "# Evaluate\n", + "y_pred = rf_model.predict(X_test)\n", + "mse_rf = mean_squared_error(y_test, y_pred)\n", + "print(f\"Random Forest MSE (500 trees): {mse_rf:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "a081e559-4e29-435d-b7db-552e28060c50", + "metadata": {}, + "source": [ + "9. Do you think it was necessary to fit $500$ trees or would have fewer trees be sufficient? Determine the number of trees that provides the lowest OOB error." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "73057916-bdd3-4c98-92f3-a7810d0b1dea", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.13/site-packages/sklearn/ensemble/_forest.py:612: UserWarning: Some inputs do not have OOB scores. This probably means too few trees were used to compute any reliable OOB estimates.\n", + " warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lowest OOB Error at 490 trees: 0.2531\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Task 9 – Find best number of trees via OOB error\n", + "oob_errors = []\n", + "tree_counts = list(range(10, 501, 10))\n", + "for n in tree_counts:\n", + " model = RandomForestRegressor(n_estimators=n, max_features=m_try, oob_score=True, random_state=1)\n", + " model.fit(X_train, y_train)\n", + " oob_errors.append(1 - model.oob_score_)\n", + "\n", + "best_n = tree_counts[np.argmin(oob_errors)]\n", + "print(f\"Lowest OOB Error at {best_n} trees: {min(oob_errors):.4f}\")\n", + "\n", + "# Plot OOB error\n", + "plt.plot(tree_counts, oob_errors, marker='o')\n", + "plt.axvline(x=best_n, color='red', linestyle='--', label=f'Optimal trees: {best_n}')\n", + "plt.xlabel(\"Number of Trees\")\n", + "plt.ylabel(\"OOB Error\")\n", + "plt.title(\"Out-of-Bag Error vs Number of Trees\")\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2695a6c8-ca39-4181-95c2-a31bdd59dfb0", + "metadata": {}, + "source": [ + "10. Compute the OOB estimate of the out-of-sample error and compare it to best pruned model from CV of Task 5. Interpret the outcomes." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "aa4c0e8d-406a-4f17-8fbf-69e116cddd53", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Min CV MSE: 0.2644\n", + "Lowest OOB Error 0.2531 at 490 Trees\n" + ] + } + ], + "source": [ + "print(f\"Min CV MSE: {cv_results[best_idx]:.4f}\")\n", + "print(f\"Lowest OOB Error {min(oob_errors):.4f} at {best_n} Trees\")" + ] + }, + { + "cell_type": "markdown", + "id": "6356f562-4211-45f5-860d-b761a83d7056", + "metadata": {}, + "source": [ + "11. Which are the most important variables used in the random forest?" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "f6adfc99-cf37-4b7f-abeb-3c7b82f4cef2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Feature Importance\n", + "7 CAtBat 0.173027\n", + "8 CHits 0.147864\n", + "10 CRuns 0.134998\n", + "11 CRBI 0.108832\n", + "12 CWalks 0.097070\n", + "6 Years 0.048685\n", + "9 CHmRun 0.048505\n", + "1 Hits 0.043583\n", + "4 RBI 0.038223\n", + "0 AtBat 0.036723\n" + ] + } + ], + "source": [ + "# Feature Importances\n", + "importances = rf_model.feature_importances_\n", + "feature_names = X_train.columns\n", + "\n", + "# DataFrame overview\n", + "importance_df = pd.DataFrame({\n", + " 'Feature': feature_names,\n", + " 'Importance': importances\n", + "}).sort_values(by='Importance', ascending=False)\n", + "\n", + "print(importance_df.head(10)) # Top 10 Features" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "5654d92d-69c5-451b-94d3-b3c75e5afd81", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Optional / Extra: plot\n", + "import seaborn as sns\n", + "plt.figure(figsize=(10, 6))\n", + "sns.barplot(data=importance_df.head(10), x='Importance', y='Feature', hue='Feature', palette='viridis')\n", + "plt.title(\"Top 10 Wichtigste Variablen im Random Forest\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "cb226b9a-1ea4-46f2-ae46-10b9c42f24aa", + "metadata": {}, + "source": [ + "12. Let’s try to improve the random forest by trying out different values for $m$. Set up a grid for m going from $1$ to $p$. Write a loop that fits a random forest for each $m$. Explain which model you would choose." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "66b21c8f-6fc8-4e1b-bb3e-653d94e29eff", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best mtry based on Test-MSE:\n", + "mtry 3.000000\n", + "Test_MSE 0.207397\n", + "OOB_Error 0.249531\n", + "Name: 2, dtype: float64\n", + "\n", + "Best mtry based on OOB-Error:\n", + "mtry 2.000000\n", + "Test_MSE 0.212309\n", + "OOB_Error 0.248776\n", + "Name: 1, dtype: float64\n" + ] + } + ], + "source": [ + "\n", + "n_features = X_train.shape[1]\n", + "mtry_range = range(1, n_features + 1)\n", + "\n", + "test_mse_grid = []\n", + "oob_error_grid = []\n", + "\n", + "# Grid-search over mtry (max_features)\n", + "for m in mtry_range:\n", + " rf_model = RandomForestRegressor(n_estimators=500,\n", + " max_features=m,\n", + " oob_score=True,\n", + " random_state=1,\n", + " bootstrap=True)\n", + " rf_model.fit(X_train, y_train)\n", + "\n", + " # Test-MSE \n", + " y_pred_test = rf_model.predict(X_test)\n", + " mse_test = mean_squared_error(y_test, y_pred_test)\n", + " test_mse_grid.append(mse_test)\n", + "\n", + " # OOB-error \n", + " oob_error = 1 - rf_model.oob_score_\n", + " oob_error_grid.append(oob_error)\n", + "\n", + "# results as DataFrame \n", + "results_df = pd.DataFrame({\n", + " 'mtry': list(mtry_range),\n", + " 'Test_MSE': test_mse_grid,\n", + " 'OOB_Error': oob_error_grid\n", + "})\n", + "\n", + "# Finding best mtry-values\n", + "best_mtry_test = results_df.loc[results_df['Test_MSE'].idxmin()]\n", + "best_mtry_oob = results_df.loc[results_df['OOB_Error'].idxmin()]\n", + "\n", + "print(\"Best mtry based on Test-MSE:\")\n", + "print(best_mtry_test)\n", + "\n", + "print(\"\\nBest mtry based on OOB-Error:\")\n", + "print(best_mtry_oob)" + ] + }, + { + "cell_type": "markdown", + "id": "0d5022fe-6175-4f6d-87f6-d039738a99e5", + "metadata": {}, + "source": [ + "13. For the best model, compute the test errors and compare them to the best pruned model from Task 7." + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "14c87bcb-4a30-44e4-9a7a-d24e43d230f4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test-MSE for best Pruned Tree: 0.3079\n" + ] + } + ], + "source": [ + "# Optimal alpha-value\n", + "optimal_tree = DecisionTreeRegressor(random_state=1, ccp_alpha=optimal_alpha)\n", + "optimal_tree.fit(X_train, y_train)\n", + "\n", + "# MSE for Pruned Tree\n", + "y_pred_pruned = optimal_tree.predict(X_test)\n", + "mse_pruned = mean_squared_error(y_test, y_pred_pruned)\n", + "print(f\"Test-MSE for best Pruned Tree: {mse_pruned:.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "9dbe4978-fa74-486c-8bb2-8b05b662b9ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Test-MSE best Random Forest Model: 0.2074\n", + "Test-MSE best Pruned Tree Model : 0.3079\n" + ] + } + ], + "source": [ + "# Compare with #12\n", + "print(f\"\\nTest-MSE best Random Forest Model: {best_mtry_test['Test_MSE']:.4f}\")\n", + "print(f\"Test-MSE best Pruned Tree Model : {mse_pruned:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "02c02b24-1440-42f0-a876-423a47bab017", + "metadata": {}, + "source": [ + "14. What is the OOB error obtained from bagging (you can infer the answer from the previous task)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a88354d-416c-4cc1-b581-7bf901786882", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task_solved.pdf b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task_solved.pdf new file mode 100755 index 0000000..08c5413 Binary files /dev/null and b/Machine Learning for Economics and Finance/05_Tree Based Methods/05_Trees_Hitters_Task_solved.pdf differ diff --git a/Machine Learning for Economics and Finance/06_Deep Learning/09-Deep learning-Hitters.py b/Machine Learning for Economics and Finance/06_Deep Learning/09-Deep learning-Hitters.py new file mode 100755 index 0000000..e425a99 --- /dev/null +++ b/Machine Learning for Economics and Finance/06_Deep Learning/09-Deep learning-Hitters.py @@ -0,0 +1,62 @@ +import pandas as pd +import numpy as np +from ISLP import load_data +from sklearn.model_selection import train_test_split +from sklearn.preprocessing import StandardScaler +from tensorflow.keras.models import Sequential +from tensorflow.keras.layers import Dense +#from tensorflow.keras.optimizers import SGD +from tensorflow.keras.optimizers import Adam + +# === Setup === +# Load and preprocess Hitters data +Hitters = load_data('Hitters').dropna() + +# Convert target to binary classification (Salary >= 500 as good income) +print(Hitters[["Salary"]].describe()) +y = np.where(Hitters['Salary'] >= 500, 1, 0) + +# Convert categorical variables into numerical variables (if needed) +Hitters = pd.get_dummies(Hitters.drop(columns=['Salary']), drop_first=True) + +# Extract feature matrix after one-hot encoding +X = Hitters + +# Standardize the features +scaler = StandardScaler() +X_scaled = scaler.fit_transform(X) + + +# Split into training and testing sets +X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42) + + +## Build the Neural Network +model = Sequential([ + Dense(units=64, input_shape=(X_train.shape[1],), activation='relu'), # Input and hidden layer + Dense(units=32, activation='relu'), # Hidden layer + Dense(units=1, activation='sigmoid') # Output layer +]) + +## Compile the Model (Adam optimizer and binary_crossentropy loss) +model.compile(optimizer=Adam(learning_rate=0.001), + loss='binary_crossentropy', + metrics=['accuracy']) + +## Train the Model +history = model.fit(X_train, y_train, epochs=50, batch_size=16, validation_split=0.1, verbose=1) + +## Evaluate the Model +loss, accuracy = model.evaluate(X_test, y_test) +print(f"Test Accuracy: {accuracy:.2f}") + +## Visualize Training Progress +import matplotlib.pyplot as plt + +plt.plot(history.history['accuracy'], label='Train Accuracy') +plt.plot(history.history['val_accuracy'], label='Validation Accuracy') +plt.title('Model Accuracy') +plt.xlabel('Epochs') +plt.ylabel('Accuracy') +plt.legend() +plt.show() diff --git a/Machine Learning for Economics and Finance/06_Deep Learning/Model_Accuracy.png b/Machine Learning for Economics and Finance/06_Deep Learning/Model_Accuracy.png new file mode 100644 index 0000000..a31e8db Binary files /dev/null and b/Machine Learning for Economics and Finance/06_Deep Learning/Model_Accuracy.png differ diff --git a/Machine Learning for Economics and Finance/Problem Set 1/ProblemSet1_solution.ipynb b/Machine Learning for Economics and Finance/Problem Set 1/ProblemSet1_solution.ipynb new file mode 100755 index 0000000..47d20a6 --- /dev/null +++ b/Machine Learning for Economics and Finance/Problem Set 1/ProblemSet1_solution.ipynb @@ -0,0 +1,3688 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "7453d213-ab6c-40e8-9e70-6170eccc7b9d", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{Problem Set 1 - Solution}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "2c3a2d4e-1e5a-4fe3-88be-abd9b9152def", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "040dc2a4-910e-4cf5-9d1e-62fe7d0a8efd", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Important Instructions\n", + "\n", + "- The purpose of this tutorial is for you to practise some of the key concepts we covered in the first weeks\n", + "- In case you struggle with some problems, please post your questions on the Canvas discussion board\n", + "- For this exercise, NO write-up of your answers or submission is required. However, I recommend you already begin developing clean programs that you can use later in the take-home exam\n", + "- We will discuss the solutions for the problem set in the lecture on `DAY MONTH`" + ] + }, + { + "cell_type": "markdown", + "id": "baac6966-d67a-4a66-acec-8ef6411c4f66", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Setup\n", + "\n", + "**The main task of this problem set is to forecast the return of the US stock market.**\n", + "For this we will use the dataset `stockmarketdata.RDS` taken from Welch and Goyal ($2007$) which is available on *OpenOlat*. The dataset contains quarterly returns of the US stock market ($ret$) as well as several other variables that have been proposed by finance researchers to predict stock returns. A list of all variables together with a description can be found in the appendix. For example for quarter $1999Q1$ (date = $19991$) it contains variables like the return of the stock market ($ret_{t}$), the dividend-to-price ratio ($DP_{t}$), the credit spread ($CS_{t}$) and so on. As the goal is to predict returns in the subsequent quarter, we are interested in models of the form\n", + "\n", + "\\begin{equation*} \n", + " ret_{t+1} = f (DP_{t}, CS_{t}, ...) + ϵ_{t+1}\n", + "\\end{equation*} \n", + "\n", + "Suppose you are an asset manager and it is the end of $1994$, that is, you have all the data before\n", + "$1995$ available to train and validate your model. Your goal is to build a model that not only works\n", + "in-sample, but can also predict returns in the future (after $1995$)." + ] + }, + { + "cell_type": "raw", + "id": "156ee566-f0eb-4206-a443-34a63bc6dbd8", + "metadata": {}, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "c53eedac-cd76-4649-aebc-dc0c0d26c63e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Preliminaries\n", + "\n", + " - Laden notwendiger Pakete und Einlesen der `stockmarketdata.rds` Datei" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "44ad3d11-abe5-4366-91dc-ac319197b93c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Loading the necessary packages for this exercise\n", + "import pyreadr # Package for reading RDS files - https://github.com/ofajardo/pyreadr\n", + "import pandas as pd # Package for processing, analyzing, and visualizing data\n", + "import numpy as np # Package for handling vectors, matrices, or generally large multidimensional arrays\n", + "import statsmodels.api as sm # Package for investigating/estimating\n", + "from statsmodels.formula.api import ols\n", + "from sklearn.linear_model import LinearRegression, LogisticRegression # Package for various classifications-, regressions- and Clustering-Algorithms\n", + "from sklearn.model_selection import cross_val_score, KFold\n", + "from sklearn.metrics import r2_score, mean_squared_error, accuracy_score\n", + "\n", + "\n", + "import matplotlib.pyplot as plt # Package for creating data visualizations\n", + "import seaborn as sns # Supplementary package to \"matplotlib\". (Modernizes design & simplere syntax)\n", + "\n", + "# Defaults for the following matplotlib figures:\n", + "plt.rcParams.update({\n", + " 'figure.figsize': (10, 8),\n", + " 'font.family': 'serif',\n", + " 'font.size': 11, \n", + " 'axes.titlesize': 14,\n", + " 'axes.grid': False,\n", + " 'lines.linewidth': 2\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "fafaf60e-c76e-45ae-aeed-8c8404bfb4b9", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateretDPCSntiscayTSsvar
019291.00.050490-3.3676880.0103570.079805NaN-0.00830.007982
119292.00.087235-3.4128510.0111050.116197NaN-0.01130.008405
219293.00.091067-3.4683920.0125170.121390NaN-0.00830.008056
319294.0-0.268418-3.0961840.0121550.163522NaN0.00370.100171
419301.00.165884-3.2523450.0105540.145496NaN0.00400.004662
\n", + "
" + ], + "text/plain": [ + " date ret DP CS ntis cay TS svar\n", + "0 19291.0 0.050490 -3.367688 0.010357 0.079805 NaN -0.0083 0.007982\n", + "1 19292.0 0.087235 -3.412851 0.011105 0.116197 NaN -0.0113 0.008405\n", + "2 19293.0 0.091067 -3.468392 0.012517 0.121390 NaN -0.0083 0.008056\n", + "3 19294.0 -0.268418 -3.096184 0.012155 0.163522 NaN 0.0037 0.100171\n", + "4 19301.0 0.165884 -3.252345 0.010554 0.145496 NaN 0.0040 0.004662" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Setup of the data set\n", + "df = pyreadr.read_r('stockmarketdata.rds')\n", + "df = df[None] # Extrahieren des verfügbaren pandas DataFrame Objekts.\n", + "\n", + "df.head() # Showing the first five rows of the DataFrame." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6d3ccd77-5c88-4a7a-9225-efd36768d36d", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateretDPCSntiscayTSsvar
3602019-Q10.137489-3.9434000.010258-0.023230-0.0393360.00170.004651
3612019-Q20.042688-3.9600330.010006-0.012562-0.033844-0.00100.003271
3622019-Q30.017042-3.9516890.008505-0.010862-0.029529-0.00190.005517
3632019-Q40.090143-4.0158960.008410-0.007222-0.0336090.00320.002319
3642020-Q1-0.193794-3.7699920.012252-0.007731-0.0501410.00580.079049
\n", + "
" + ], + "text/plain": [ + " date ret DP CS ntis cay TS \\\n", + "360 2019-Q1 0.137489 -3.943400 0.010258 -0.023230 -0.039336 0.0017 \n", + "361 2019-Q2 0.042688 -3.960033 0.010006 -0.012562 -0.033844 -0.0010 \n", + "362 2019-Q3 0.017042 -3.951689 0.008505 -0.010862 -0.029529 -0.0019 \n", + "363 2019-Q4 0.090143 -4.015896 0.008410 -0.007222 -0.033609 0.0032 \n", + "364 2020-Q1 -0.193794 -3.769992 0.012252 -0.007731 -0.050141 0.0058 \n", + "\n", + " svar \n", + "360 0.004651 \n", + "361 0.003271 \n", + "362 0.005517 \n", + "363 0.002319 \n", + "364 0.079049 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Definition of a custom function for reading and reformatting the \"date\" year-quarter time data.\n", + "def convert_to_quarterly_date(numeric_date):\n", + " \"\"\"\n", + " Converts a numeric date representing year and quarter into a quarterly date string in the format 'YYYY-Q'.\n", + "\n", + " Parameters:\n", + " numeric_date (int or float): Numeric date representing year and quarter.\n", + " The whole part indicates the year, and the decimal part indicates the quarter (e.g., 20191.0 for the first quarter of 2019).\n", + " \n", + " Returns:\n", + " str: A string representing the quarterly date in the format 'YYYY-Q', where 'YYYY' is the year and 'Q' is the quarter.\n", + " \n", + " Example:\n", + " >>> convert_to_quarterly_date(20191.0)\n", + " '2019-Q1'\n", + " \"\"\"\n", + " year = int(numeric_date) // 10 # Extracting the year information\n", + " quarter = int(numeric_date) % 10 # Extracting the quarter information using the modulo operation\n", + " quarter_str = f'Q{quarter}' # Converting the integer quarter data to string format\n", + " return f'{year}-Q{quarter}' # Returning the desired string\n", + "\n", + "\n", + "# Applying the function to the \"date\" variable.\n", + "df['date'] = df['date'].apply(convert_to_quarterly_date)\n", + "\n", + "df.tail()" + ] + }, + { + "cell_type": "markdown", + "id": "84ad3eb5-0717-4848-b531-268affb4bed4", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Exploration und Visualisierung des Datensatzes (extra) " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9be0a727-8bb6-4c51-992f-de30090b33ba", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 365 entries, 0 to 364\n", + "Data columns (total 8 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 date 365 non-null object \n", + " 1 ret 365 non-null float64\n", + " 2 DP 365 non-null float64\n", + " 3 CS 365 non-null float64\n", + " 4 ntis 365 non-null float64\n", + " 5 cay 273 non-null float64\n", + " 6 TS 365 non-null float64\n", + " 7 svar 365 non-null float64\n", + "dtypes: float64(7), object(1)\n", + "memory usage: 22.9+ KB\n" + ] + } + ], + "source": [ + "df.info() # The last column \"Dtype\" is of particular interest here.\n", + " # The variable \"date\" is of type \"object\", therefore not a numerical variable." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "6ca834d5-7d59-4f87-a6f0-0325a0ed0295", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countmeanstdmin25%50%75%max
ret365.00.0279510.112073-0.388075-0.0211580.0355690.0836770.893713
DP365.0-3.3910560.470778-4.493159-3.797300-3.373817-3.042370-1.903915
CS365.00.0106210.0065450.0032430.0065020.0085240.0123060.051673
ntis365.00.0154320.025043-0.0518310.0050410.0164890.0266950.163522
cay273.00.0019980.022772-0.050141-0.0170830.0076320.0187960.042897
TS365.00.0172200.012820-0.0350000.0090000.0175000.0261000.045300
svar365.00.0088140.0151530.0003700.0024300.0039840.0078870.114436
\n", + "
" + ], + "text/plain": [ + " count mean std min 25% 50% 75% \\\n", + "ret 365.0 0.027951 0.112073 -0.388075 -0.021158 0.035569 0.083677 \n", + "DP 365.0 -3.391056 0.470778 -4.493159 -3.797300 -3.373817 -3.042370 \n", + "CS 365.0 0.010621 0.006545 0.003243 0.006502 0.008524 0.012306 \n", + "ntis 365.0 0.015432 0.025043 -0.051831 0.005041 0.016489 0.026695 \n", + "cay 273.0 0.001998 0.022772 -0.050141 -0.017083 0.007632 0.018796 \n", + "TS 365.0 0.017220 0.012820 -0.035000 0.009000 0.017500 0.026100 \n", + "svar 365.0 0.008814 0.015153 0.000370 0.002430 0.003984 0.007887 \n", + "\n", + " max \n", + "ret 0.893713 \n", + "DP -1.903915 \n", + "CS 0.051673 \n", + "ntis 0.163522 \n", + "cay 0.042897 \n", + "TS 0.045300 \n", + "svar 0.114436 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.describe().T # Descriptive Statistics of the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b84929c4-7915-4f63-88b7-9200cec362c9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[, ,\n", + " ],\n", + " [,\n", + " , ],\n", + " [, , ]],\n", + " dtype=object)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df.hist(figsize=(10,7), edgecolor='black', grid=False) \n", + "# Graphical Overview of the Distributions of Individual Variables in the Data\n", + "# The variable \"date\" is not included as it is not a numerical variable." + ] + }, + { + "cell_type": "raw", + "id": "587b42ca-c325-4d67-918c-2ede5360bf62", + "metadata": {}, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "87902d82-5336-456b-bec8-403530c75f00", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Question 1: Preparing and analyzing the data\n", + "\n", + "1. First we need to align the data such that a row that contains the features for date $t$, contains the return for date $t + 1$ (instead of the return for date $t$ as it does now). This ensures that we are actually predicting **next** quarters returns. For this we need to lead the return time series by one period. (Hint: Use the `shift()` function to add a new variable to the dataframe that is the return led by one period. Afterwards remove the old return time series from the dataframe.)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f3725bbe-1708-4559-b7b9-fa975a09083f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateretDPCSntiscayTSsvar
3602019-Q10.042688-3.9434000.010258-0.023230-0.0393360.00170.004651
3612019-Q20.017042-3.9600330.010006-0.012562-0.033844-0.00100.003271
3622019-Q30.090143-3.9516890.008505-0.010862-0.029529-0.00190.005517
3632019-Q4-0.193794-4.0158960.008410-0.007222-0.0336090.00320.002319
3642020-Q1NaN-3.7699920.012252-0.007731-0.0501410.00580.079049
\n", + "
" + ], + "text/plain": [ + " date ret DP CS ntis cay TS \\\n", + "360 2019-Q1 0.042688 -3.943400 0.010258 -0.023230 -0.039336 0.0017 \n", + "361 2019-Q2 0.017042 -3.960033 0.010006 -0.012562 -0.033844 -0.0010 \n", + "362 2019-Q3 0.090143 -3.951689 0.008505 -0.010862 -0.029529 -0.0019 \n", + "363 2019-Q4 -0.193794 -4.015896 0.008410 -0.007222 -0.033609 0.0032 \n", + "364 2020-Q1 NaN -3.769992 0.012252 -0.007731 -0.050141 0.0058 \n", + "\n", + " svar \n", + "360 0.004651 \n", + "361 0.003271 \n", + "362 0.005517 \n", + "363 0.002319 \n", + "364 0.079049 " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df['ret'] = df['ret'].shift(-1) # Shifting the Return by the Time Period t+1.\n", + "\n", + "df.tail()" + ] + }, + { + "cell_type": "markdown", + "id": "73330b81-0e43-43ac-911f-4086a9f9788f", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "2. Remove all rows that contain missing values from the dataset. Google will provide many different ways on how to do this. If you struggle with this exercise, do the following: Use the `.isna().sum()` function to determine all rows that contain missing values. Find the missing values for these variables by eye inspection. Start and end the sample such that these rows with missing values are not included. Use the `.isna().sum()` again to make sure that you got rid of all missing values (`NaN`'s)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5c083b5f-f0d4-4fe5-8824-604a073c1215", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "date 0\n", + "ret 1\n", + "DP 0\n", + "CS 0\n", + "ntis 0\n", + "cay 92\n", + "TS 0\n", + "svar 0\n", + "dtype: int64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isna().sum() # Enumeration of all NaNs (per variable)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2c0b17c8-a060-4687-8047-83abcf22ae46", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "date 0\n", + "ret 0\n", + "DP 0\n", + "CS 0\n", + "ntis 0\n", + "cay 0\n", + "TS 0\n", + "svar 0\n", + "dtype: int64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = df.dropna() # Discarding all rows where variables have a NaN cell.\n", + "\n", + "df.isna().sum()" + ] + }, + { + "cell_type": "markdown", + "id": "80e4160e-374a-43e1-a159-45077703658e", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "3. Split the sample into two parts. Data before $1995$ for *training* and *validation* and data after and including $1995$ for *out-of-sample* testing." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "b27a4ab6-fb98-4d05-ad9e-340731f68d68", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train_data contains 172 observations.\n", + "test_data contains 100 observations.\n" + ] + } + ], + "source": [ + "# Creating variables with the information \"1994-Q4\" and the position serving as the intersection.\n", + "split_date = '1994-Q4' # Variable with split value\n", + "split_ind = df.index[df['date'] == split_date][0] # Variable with split position\n", + "\n", + "# Division of the data into \"train_data\" and \"test_data\".\n", + "train_data = df.loc[:split_ind] # In-sample dataset (all rows up to the split position)\n", + "test_data = df.loc[split_ind + 1:] # Out-of-sample dataset (all rows after the split position)\n", + "\n", + "print(f\"train_data contains {len(train_data)} observations.\")\n", + "print(f\"test_data contains {len(test_data)} observations.\")" + ] + }, + { + "cell_type": "markdown", + "id": "03d19235-25ee-4c3b-b7bf-97cdf27d41b2", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "4. Compute the mean quarterly return and its standard deviation in the training and test data. Is there anything worth noting?" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a6833298-ab95-4596-85cd-5c4d9666037c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data:\n", + "Average quarterly return: 0.0306\n", + "Standard deviation of quarterly return: 0.0763\n", + "\n", + "Test data:\n", + "Average quarterly return: 0.0252\n", + "Standard deviation of quarterly return: 0.0823\n" + ] + } + ], + "source": [ + "train_mean_ret = train_data['ret'].mean() # Average quarterly return (train_data)\n", + "train_std_ret = train_data['ret'].std() # Standard deviation of quarterly return (train_data)\n", + "\n", + "test_mean_ret = test_data['ret'].mean() # Average quarterly return (test_data)\n", + "test_std_ret = test_data['ret'].std() # Standard deviation of quarterly return (test_data)\n", + "\n", + "# Output of the results\n", + "print(\"Train data:\")\n", + "print(f\"Average quarterly return: {train_mean_ret:.4f}\")\n", + "print(f\"Standard deviation of quarterly return: {train_std_ret:.4f}\")\n", + "print(\"\\nTest data:\")\n", + "print(f\"Average quarterly return: {test_mean_ret:.4f}\")\n", + "print(f\"Standard deviation of quarterly return: {test_std_ret:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "79732a93-d610-4d49-9bf0-a03b3f4edf22", + "metadata": { + "user_expressions": [] + }, + "source": [ + "5. Compute the correlation matrix for the training data (including both the outcomes and the features). Is there anything worth noting?" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1b390010-0b60-4bb0-873f-786c93fc34e5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Correlation matrix (train data):\n", + " ret DP CS ntis cay TS svar\n", + "ret 1.00 0.23 0.18 -0.19 0.17 0.16 0.13\n", + "DP 0.23 1.00 0.38 -0.12 -0.21 -0.14 0.11\n", + "CS 0.18 0.38 1.00 -0.31 -0.02 0.21 0.22\n", + "ntis -0.19 -0.12 -0.31 1.00 -0.40 -0.07 -0.12\n", + "cay 0.17 -0.21 -0.02 -0.40 1.00 0.46 0.04\n", + "TS 0.16 -0.14 0.21 -0.07 0.46 1.00 0.08\n", + "svar 0.13 0.11 0.22 -0.12 0.04 0.08 1.00\n" + ] + } + ], + "source": [ + "# Calculation of the correlation matrix for the training data\n", + "\n", + "# \"date\" column excluded (Only numerical columns)\n", + "train_cor_matrix = train_data.loc[:, train_data.columns != 'date'].corr(method='pearson')\n", + "\n", + "# Output of the correlation matrix. Values rounded to two decimal places.\n", + "print(\"Correlation matrix (train data):\")\n", + "print(round(train_cor_matrix,2))" + ] + }, + { + "cell_type": "markdown", + "id": "dd530aab-33af-4c70-bfce-193e32d49aed", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Graphical representation of the correlation matrix (extra)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e2727ae0-ab97-4ae4-b7cb-8b3e957ccda5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 7))\n", + "s = sns.heatmap(train_data.loc[:, train_data.columns != 'date'].corr(),\n", + " annot=True, \n", + " center=0,\n", + " linewidths=.5, \n", + " square=True,\n", + " vmin=-1,\n", + " vmax=1, \n", + " xticklabels='auto', # automatic X-variables\n", + " yticklabels='auto', # automatic X-variables\n", + " fmt='0.2f',\n", + " cmap=\"coolwarm\")\n", + "s.set_title('Correlation Matrix of the In-Sample Exogenous Variables')\n", + "s.set(xlabel='Variables', ylabel='Variables')\n", + "plt.show()" + ] + }, + { + "cell_type": "raw", + "id": "7ff4dcdb-7e30-4870-b7ae-d52ae5867112", + "metadata": {}, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "e715dd42-7021-466d-a9c1-0c0b4efeee78", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Question 2: Predicting returns\n", + "\n", + "After having cleaned the data, you are ready to build the first model to predict returns\n", + "\n", + "1. Use the training data to fit a linear model using all features (make sure to exclude the date variable). Which features are useful for predicting returns?" + ] + }, + { + "cell_type": "markdown", + "id": "5460537b-6fde-422f-854a-d36e9cc36375", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Regression with all predictors: `ret ~ .`" + ] + }, + { + "cell_type": "markdown", + "id": "75c4236c-352c-4c28-8eaf-6687771426ae", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Solution Approach 1: `ols()` \"formula\" function from `statsmodels.formula`\n", + "\n", + "- Advantage:\n", + " - Formula function, as known from R.\n", + " - **Extract**:\n", + " - `np.log(Variable)` Apply logarithm to Variable\n", + " - `np.sqrt(Variable)` Apply square root to Variable\n", + " - `np.power(Variable, 2)` Variable to the power of $2$\n", + " Example: `np.power(Variable, 3)` Variable to the power of $3$\n", + " - `C(Variable)` The C declares the Variable as a categorical variable\n", + " - `Variable1 * Variable2` Interaction term of two variables (with additional inclusion of individual variables)\n", + " - `Variable1 : Variable2` Interaction term of two variables (without separately including individual variables)\n", + " - Provides a summary statistic directly.\n", + "- Disadvantage:\n", + " - Often not flexible enough for more complex tasks..." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "593160b7-045b-4754-aed8-2119e37c0b93", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
OLS Regression Results
Dep. Variable: ret R-squared: 0.129
Model: OLS Adj. R-squared: 0.097
Method: Least Squares F-statistic: 4.063
Date: Tue, 01 Apr 2025 Prob (F-statistic): 0.000793
Time: 21:31:56 Log-Likelihood: 210.80
No. Observations: 172 AIC: -407.6
Df Residuals: 165 BIC: -385.6
Df Model: 6
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err t P>|t| [0.025 0.975]
Intercept 0.2968 0.097 3.063 0.003 0.106 0.488
DP 0.0839 0.028 3.031 0.003 0.029 0.139
CS 0.4750 1.739 0.273 0.785 -2.958 3.908
ntis -0.3945 0.410 -0.961 0.338 -1.205 0.416
cay 0.4215 0.306 1.379 0.170 -0.182 1.025
TS 0.6310 0.482 1.309 0.192 -0.320 1.583
svar 0.8027 0.828 0.969 0.334 -0.832 2.438
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Omnibus: 26.211 Durbin-Watson: 1.810
Prob(Omnibus): 0.000 Jarque-Bera (JB): 40.178
Skew: -0.823 Prob(JB): 1.89e-09
Kurtosis: 4.701 Cond. No. 1.10e+03


Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The condition number is large, 1.1e+03. This might indicate that there are
strong multicollinearity or other numerical problems." + ], + "text/latex": [ + "\\begin{center}\n", + "\\begin{tabular}{lclc}\n", + "\\toprule\n", + "\\textbf{Dep. Variable:} & ret & \\textbf{ R-squared: } & 0.129 \\\\\n", + "\\textbf{Model:} & OLS & \\textbf{ Adj. R-squared: } & 0.097 \\\\\n", + "\\textbf{Method:} & Least Squares & \\textbf{ F-statistic: } & 4.063 \\\\\n", + "\\textbf{Date:} & Tue, 01 Apr 2025 & \\textbf{ Prob (F-statistic):} & 0.000793 \\\\\n", + "\\textbf{Time:} & 21:31:56 & \\textbf{ Log-Likelihood: } & 210.80 \\\\\n", + "\\textbf{No. Observations:} & 172 & \\textbf{ AIC: } & -407.6 \\\\\n", + "\\textbf{Df Residuals:} & 165 & \\textbf{ BIC: } & -385.6 \\\\\n", + "\\textbf{Df Model:} & 6 & \\textbf{ } & \\\\\n", + "\\textbf{Covariance Type:} & nonrobust & \\textbf{ } & \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\\begin{tabular}{lcccccc}\n", + " & \\textbf{coef} & \\textbf{std err} & \\textbf{t} & \\textbf{P$> |$t$|$} & \\textbf{[0.025} & \\textbf{0.975]} \\\\\n", + "\\midrule\n", + "\\textbf{Intercept} & 0.2968 & 0.097 & 3.063 & 0.003 & 0.106 & 0.488 \\\\\n", + "\\textbf{DP} & 0.0839 & 0.028 & 3.031 & 0.003 & 0.029 & 0.139 \\\\\n", + "\\textbf{CS} & 0.4750 & 1.739 & 0.273 & 0.785 & -2.958 & 3.908 \\\\\n", + "\\textbf{ntis} & -0.3945 & 0.410 & -0.961 & 0.338 & -1.205 & 0.416 \\\\\n", + "\\textbf{cay} & 0.4215 & 0.306 & 1.379 & 0.170 & -0.182 & 1.025 \\\\\n", + "\\textbf{TS} & 0.6310 & 0.482 & 1.309 & 0.192 & -0.320 & 1.583 \\\\\n", + "\\textbf{svar} & 0.8027 & 0.828 & 0.969 & 0.334 & -0.832 & 2.438 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\\begin{tabular}{lclc}\n", + "\\textbf{Omnibus:} & 26.211 & \\textbf{ Durbin-Watson: } & 1.810 \\\\\n", + "\\textbf{Prob(Omnibus):} & 0.000 & \\textbf{ Jarque-Bera (JB): } & 40.178 \\\\\n", + "\\textbf{Skew:} & -0.823 & \\textbf{ Prob(JB): } & 1.89e-09 \\\\\n", + "\\textbf{Kurtosis:} & 4.701 & \\textbf{ Cond. No. } & 1.10e+03 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "%\\caption{OLS Regression Results}\n", + "\\end{center}\n", + "\n", + "Notes: \\newline\n", + " [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. \\newline\n", + " [2] The condition number is large, 1.1e+03. This might indicate that there are \\newline\n", + " strong multicollinearity or other numerical problems." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: ret R-squared: 0.129\n", + "Model: OLS Adj. R-squared: 0.097\n", + "Method: Least Squares F-statistic: 4.063\n", + "Date: Tue, 01 Apr 2025 Prob (F-statistic): 0.000793\n", + "Time: 21:31:56 Log-Likelihood: 210.80\n", + "No. Observations: 172 AIC: -407.6\n", + "Df Residuals: 165 BIC: -385.6\n", + "Df Model: 6 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "Intercept 0.2968 0.097 3.063 0.003 0.106 0.488\n", + "DP 0.0839 0.028 3.031 0.003 0.029 0.139\n", + "CS 0.4750 1.739 0.273 0.785 -2.958 3.908\n", + "ntis -0.3945 0.410 -0.961 0.338 -1.205 0.416\n", + "cay 0.4215 0.306 1.379 0.170 -0.182 1.025\n", + "TS 0.6310 0.482 1.309 0.192 -0.320 1.583\n", + "svar 0.8027 0.828 0.969 0.334 -0.832 2.438\n", + "==============================================================================\n", + "Omnibus: 26.211 Durbin-Watson: 1.810\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 40.178\n", + "Skew: -0.823 Prob(JB): 1.89e-09\n", + "Kurtosis: 4.701 Cond. No. 1.10e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 1.1e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\"\"\"" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Fit in-sample multilinear regression\n", + "Fit_lm = ols('ret ~ DP + CS + ntis + cay + TS + svar', data=train_data).fit()\n", + "Fit_lm.summary() # Outputting the model statistics.\n", + "\n", + "# Option 2:\n", + "## Concatenate all predictor variable names except 'ret'\n", + "#predictors = [col for col in Auto.columns if col != 'ret']\n", + "#formula = 'ret ~ ' + ' + '.join(predictors)\n", + "\n", + "## Fit linear regression using all predictors from Auto data\n", + "#Fit_lm = ols(formula=formula, data=Auto).fit()\n", + "#Fit_lm.summary() # Outputting the model statistics." + ] + }, + { + "cell_type": "markdown", + "id": "9ef0f8dd-b4cb-4f50-a3e8-4672e32d23a0", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Solution Approach 2: `OLS()` without the \"formula\" function from `statsmodels`\n", + "\n", + " - Advantage:\n", + " - Provides a summary statistic directly.\n", + " - Disadvantage:\n", + " - An \"Intercept\" must be added independently to the list of exogenous variables.\n", + " - Often not flexible enough for more complex tasks..." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "2c357768-0756-4523-a44d-0ccb87cb9c2a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
OLS Regression Results
Dep. Variable: ret R-squared: 0.129
Model: OLS Adj. R-squared: 0.097
Method: Least Squares F-statistic: 4.063
Date: Tue, 01 Apr 2025 Prob (F-statistic): 0.000793
Time: 21:31:56 Log-Likelihood: 210.80
No. Observations: 172 AIC: -407.6
Df Residuals: 165 BIC: -385.6
Df Model: 6
Covariance Type: nonrobust
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
coef std err t P>|t| [0.025 0.975]
const 0.2968 0.097 3.063 0.003 0.106 0.488
DP 0.0839 0.028 3.031 0.003 0.029 0.139
CS 0.4750 1.739 0.273 0.785 -2.958 3.908
ntis -0.3945 0.410 -0.961 0.338 -1.205 0.416
cay 0.4215 0.306 1.379 0.170 -0.182 1.025
TS 0.6310 0.482 1.309 0.192 -0.320 1.583
svar 0.8027 0.828 0.969 0.334 -0.832 2.438
\n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "\n", + " \n", + "\n", + "
Omnibus: 26.211 Durbin-Watson: 1.810
Prob(Omnibus): 0.000 Jarque-Bera (JB): 40.178
Skew: -0.823 Prob(JB): 1.89e-09
Kurtosis: 4.701 Cond. No. 1.10e+03


Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
[2] The condition number is large, 1.1e+03. This might indicate that there are
strong multicollinearity or other numerical problems." + ], + "text/latex": [ + "\\begin{center}\n", + "\\begin{tabular}{lclc}\n", + "\\toprule\n", + "\\textbf{Dep. Variable:} & ret & \\textbf{ R-squared: } & 0.129 \\\\\n", + "\\textbf{Model:} & OLS & \\textbf{ Adj. R-squared: } & 0.097 \\\\\n", + "\\textbf{Method:} & Least Squares & \\textbf{ F-statistic: } & 4.063 \\\\\n", + "\\textbf{Date:} & Tue, 01 Apr 2025 & \\textbf{ Prob (F-statistic):} & 0.000793 \\\\\n", + "\\textbf{Time:} & 21:31:56 & \\textbf{ Log-Likelihood: } & 210.80 \\\\\n", + "\\textbf{No. Observations:} & 172 & \\textbf{ AIC: } & -407.6 \\\\\n", + "\\textbf{Df Residuals:} & 165 & \\textbf{ BIC: } & -385.6 \\\\\n", + "\\textbf{Df Model:} & 6 & \\textbf{ } & \\\\\n", + "\\textbf{Covariance Type:} & nonrobust & \\textbf{ } & \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\\begin{tabular}{lcccccc}\n", + " & \\textbf{coef} & \\textbf{std err} & \\textbf{t} & \\textbf{P$> |$t$|$} & \\textbf{[0.025} & \\textbf{0.975]} \\\\\n", + "\\midrule\n", + "\\textbf{const} & 0.2968 & 0.097 & 3.063 & 0.003 & 0.106 & 0.488 \\\\\n", + "\\textbf{DP} & 0.0839 & 0.028 & 3.031 & 0.003 & 0.029 & 0.139 \\\\\n", + "\\textbf{CS} & 0.4750 & 1.739 & 0.273 & 0.785 & -2.958 & 3.908 \\\\\n", + "\\textbf{ntis} & -0.3945 & 0.410 & -0.961 & 0.338 & -1.205 & 0.416 \\\\\n", + "\\textbf{cay} & 0.4215 & 0.306 & 1.379 & 0.170 & -0.182 & 1.025 \\\\\n", + "\\textbf{TS} & 0.6310 & 0.482 & 1.309 & 0.192 & -0.320 & 1.583 \\\\\n", + "\\textbf{svar} & 0.8027 & 0.828 & 0.969 & 0.334 & -0.832 & 2.438 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "\\begin{tabular}{lclc}\n", + "\\textbf{Omnibus:} & 26.211 & \\textbf{ Durbin-Watson: } & 1.810 \\\\\n", + "\\textbf{Prob(Omnibus):} & 0.000 & \\textbf{ Jarque-Bera (JB): } & 40.178 \\\\\n", + "\\textbf{Skew:} & -0.823 & \\textbf{ Prob(JB): } & 1.89e-09 \\\\\n", + "\\textbf{Kurtosis:} & 4.701 & \\textbf{ Cond. No. } & 1.10e+03 \\\\\n", + "\\bottomrule\n", + "\\end{tabular}\n", + "%\\caption{OLS Regression Results}\n", + "\\end{center}\n", + "\n", + "Notes: \\newline\n", + " [1] Standard Errors assume that the covariance matrix of the errors is correctly specified. \\newline\n", + " [2] The condition number is large, 1.1e+03. This might indicate that there are \\newline\n", + " strong multicollinearity or other numerical problems." + ], + "text/plain": [ + "\n", + "\"\"\"\n", + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: ret R-squared: 0.129\n", + "Model: OLS Adj. R-squared: 0.097\n", + "Method: Least Squares F-statistic: 4.063\n", + "Date: Tue, 01 Apr 2025 Prob (F-statistic): 0.000793\n", + "Time: 21:31:56 Log-Likelihood: 210.80\n", + "No. Observations: 172 AIC: -407.6\n", + "Df Residuals: 165 BIC: -385.6\n", + "Df Model: 6 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.2968 0.097 3.063 0.003 0.106 0.488\n", + "DP 0.0839 0.028 3.031 0.003 0.029 0.139\n", + "CS 0.4750 1.739 0.273 0.785 -2.958 3.908\n", + "ntis -0.3945 0.410 -0.961 0.338 -1.205 0.416\n", + "cay 0.4215 0.306 1.379 0.170 -0.182 1.025\n", + "TS 0.6310 0.482 1.309 0.192 -0.320 1.583\n", + "svar 0.8027 0.828 0.969 0.334 -0.832 2.438\n", + "==============================================================================\n", + "Omnibus: 26.211 Durbin-Watson: 1.810\n", + "Prob(Omnibus): 0.000 Jarque-Bera (JB): 40.178\n", + "Skew: -0.823 Prob(JB): 1.89e-09\n", + "Kurtosis: 4.701 Cond. No. 1.10e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 1.1e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\"\"\"" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Creating the model matrix:\n", + "\n", + "# Removing the endogenous and qualitative variables.\n", + "X = train_data.drop(columns=['date', 'ret'])\n", + "X = sm.add_constant(X) \n", + "# Option 2: Inserting an intercept term at the beginning of the matrix.\n", + "#X.insert(0, 'intercept', np.ones(train_data.shape[0]))\n", + "\n", + "y = train_data['ret'] # Setting the endogenous variable.\n", + "\n", + "model = sm.OLS(y, X) # Filling the Ordinary Least Squares (OLS) model.\n", + "fit_lm = model.fit() # Fitting the univariate linear regression model.\n", + "fit_lm.summary() # Outputting the model statistics." + ] + }, + { + "cell_type": "markdown", + "id": "a058bafc-8a68-4a80-820b-9f164ffca056", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Solution Approach 3: `LinearRegression()` without the \"formula\" function from `sklearn.linear_model`\n", + "\n", + " - Advantage:\n", + " - No need to add an \"Intercept\" to the list of exogenous variables.\n", + " - Comprehensive and flexible enough for more complex tasks...\n", + " - Disadvantage:\n", + " - Does **not** provide \"out of the box\" summary statistics.\n", + "\n", + "For solving the following tasks, LinearRegression() is the best choice. Proceeding with Approach 3 from here." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "bbd38561-e89e-4dc6-926b-d333b44e3eb8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
LinearRegression()
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "LinearRegression()" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Establishing y and X based on the training and validation datasets.\n", + "X_train = train_data.drop(columns=['ret','date']) # Exogenous: all variables except ret and date.\n", + "y_train = train_data['ret'] # Endogenous: ret.\n", + "X_test = test_data.drop(columns=['ret','date']) # Exogenous: all variables except ret and date.\n", + "y_test = test_data['ret'] # Endogenous: ret.\n", + "\n", + "# Setting up and training the regression model.\n", + "model_all = LinearRegression()\n", + "model_all.fit(X_train, y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2d4dfb67-cc08-4d9e-9a1d-5128827d6fe4", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Coefficients
svar0.802650
TS0.631040
cay0.421456
ntis-0.394479
CS0.474950
DP0.083873
\n", + "
" + ], + "text/plain": [ + " Coefficients\n", + "svar 0.802650\n", + "TS 0.631040\n", + "cay 0.421456\n", + "ntis -0.394479\n", + "CS 0.474950\n", + "DP 0.083873" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Feature_names = model_all.feature_names_in_\n", + "COefs = pd.DataFrame(\n", + " model_all.coef_, # Coeffocient values\n", + " columns=[\"Coefficients\"], # New Column name\n", + " index=Feature_names, # Predictor name list\n", + ")\n", + "\n", + "COefs.iloc[::-1] # \".iloc[::-1]\" reverses the order of the dataframe" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "2b3de871-d80c-482b-bea5-d5d77badb011", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "COefs.plot.barh(figsize=(10, 4))\n", + "plt.title(\"ret ~ DP + CS + ntis + cay + TS + svar\")\n", + "plt.axvline(x=0, color=\".5\")\n", + "plt.xlabel(\"$\\\\beta$ coefficients\")\n", + "plt.ylabel(\"Predictors\")\n", + "#plt.legend([\"zero\",\"$\\\\beta$\"])\n", + "plt.legend([]) # Remove legend\n", + "plt.subplots_adjust(left=0.3)" + ] + }, + { + "cell_type": "markdown", + "id": "8d9da5e3-293b-47da-89ee-ea4d8762cfe2", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "#### Relevance and Effect Size of Variables for the Model (extra)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "4f5b3610-98e3-4596-a0cf-bf5c7c532200", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.compose import make_column_transformer\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.linear_model import Ridge\n", + "from sklearn.compose import TransformedTargetRegressor" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "517f1333-0502-4278-ac43-dec75f6422d0", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5-fold cross-validated MSE: 0.008093899166081891\n" + ] + } + ], + "source": [ + "# Initialize and train the Ridge regression model\n", + "# Alpha parameter controls regularization strength (1=ridge)\n", + "ridge_model = Ridge(alpha=1e-10, random_state=1)\n", + "ridge_model.fit(X_train, y_train)\n", + "\n", + "# Optionally, you can perform cross-validation to evaluate the model\n", + "mse_cv = -cross_val_score(ridge_model, X_train, y_train, cv=5, scoring='neg_mean_squared_error').mean()\n", + "print(\"5-fold cross-validated MSE:\", mse_cv)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "ba50c4ab-a93d-4406-ada7-8c066b90019e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [], + "source": [ + "X = train_data.drop(columns=['ret','date']) # Exogenous: all variables except ret and date.\n", + "y = train_data['ret'] # Endogenous: ret." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "2139b8ff-3870-4a39-a72b-58f1f8e24bc1", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [], + "source": [ + "# Setting up the train test split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "d889850d-6aa7-48c4-b7bd-6e5bb4ea9cb7", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code", + "remove_input" + ] + }, + "outputs": [], + "source": [ + "train_dataset = X_train.copy()\n", + "train_dataset.insert(0, \"ret\", y_train)" + ] + }, + { + "cell_type": "markdown", + "id": "fad01b44-299d-48ff-9c6d-4136ce1b4001", + "metadata": { + "tags": [ + "hide_code" + ], + "user_expressions": [] + }, + "source": [ + "In the following section, we will interpret the coefficients of the model. While we do so, we should keep in mind that any conclusion we draw is about the model that we build, rather than about the true (real-world) generative process of the data." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "460b38c9-201f-41ac-80f3-8b83200bdc08", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('columntransformer',\n",
+       "                 ColumnTransformer(force_int_remainder_cols=False,\n",
+       "                                   remainder='passthrough',\n",
+       "                                   transformers=[('onehotencoder',\n",
+       "                                                  OneHotEncoder(), [])],\n",
+       "                                   verbose_feature_names_out=False)),\n",
+       "                ('transformedtargetregressor',\n",
+       "                 TransformedTargetRegressor(func=<ufunc 'log1p'>,\n",
+       "                                            inverse_func=<ufunc 'expm1'>,\n",
+       "                                            regressor=Ridge(alpha=1e-10)))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('columntransformer',\n", + " ColumnTransformer(force_int_remainder_cols=False,\n", + " remainder='passthrough',\n", + " transformers=[('onehotencoder',\n", + " OneHotEncoder(), [])],\n", + " verbose_feature_names_out=False)),\n", + " ('transformedtargetregressor',\n", + " TransformedTargetRegressor(func=,\n", + " inverse_func=,\n", + " regressor=Ridge(alpha=1e-10)))])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "categorical_columns = []\n", + "numerical_columns = ['DP', 'CS', 'ntis', 'cay', 'TS', 'svar']\n", + "\n", + "preprocessor = make_column_transformer(\n", + " (OneHotEncoder(), categorical_columns),\n", + " remainder=\"passthrough\",\n", + " verbose_feature_names_out=False, # avoid to prepend the preprocessor names\n", + " force_int_remainder_cols=False # Enable the future behavior for remainder columns\n", + ")\n", + "\n", + "# Create a model pipeline\n", + "model = make_pipeline(\n", + " preprocessor,\n", + " TransformedTargetRegressor(\n", + " regressor=Ridge(alpha=1e-10), # Ridge regression model\n", + " func=np.log1p, # Apply log transformation to target variable\n", + " inverse_func=np.expm1 # Inverse of log transformation for predictions\n", + " )\n", + ")\n", + "\n", + "# Fit the model\n", + "model.fit(X_train, y_train)" + ] + }, + { + "cell_type": "markdown", + "id": "4c9d3cc1-a61c-4165-9377-2014b377369d", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "**Normalization with the Z-Score**\n", + "\n", + "The Z-score (or normalized value) is a standardized value with a mean of 0 and a standard deviation of $1$. It is calculated by subtracting the value from the sample mean and then dividing by the sample standard deviation.\n", + "\n", + "\\begin{equation*} \n", + " z = \\frac{(x\\, -\\, Mean)}{Standard\\, Deviation}\n", + "\\end{equation*} \n", + "\n", + "When applied to numerical values in a vector, it results in a standardized vector." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "d0667ffe-bf1f-4aad-8dd5-a2cb6a5519e2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "feature_names = model[:-1].get_feature_names_out()\n", + "\n", + "X_train_preprocessed = pd.DataFrame(model[:-1].transform(X_train), columns=feature_names, copy=None)\n", + "\n", + "X_train_preprocessed.std(axis=0).plot.barh(figsize=(10, 4))\n", + "plt.title(\"ret ~ DP + CS + ntis + cay + TS + svar\")\n", + "plt.xlabel(\"Normalized $\\\\beta$ coefficients\")\n", + "plt.ylabel(\"Predictors\")\n", + "plt.subplots_adjust(left=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "040113f9-626a-45df-baa4-839ea2e48563", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "DP 0.228184\n", + "CS 0.003674\n", + "ntis 0.017305\n", + "cay 0.023599\n", + "TS 0.014240\n", + "svar 0.007801\n", + "dtype: float64" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_preprocessed.std(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "aa62b411-b18d-4c19-8e4c-76f2bd19c7d7", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "remove_input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure with two subplots arranged horizontally\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(20, 9)) # 1 row, 2 columns\n", + "#fig.suptitle('ret ~ DP + CS + ntis + cay + TS + svar', fontsize=12, fontweight='bold')\n", + "\n", + "# Plot the first horizontal bar plot\n", + "COefs.plot.barh(ax=axes[0], width=0.3)\n", + "#axes[0].set_title(\"Regression Coefficients' Magnitudes\")\n", + "axes[0].axvline(x=0, color=\".5\")\n", + "axes[0].set_xlabel(\"$\\\\beta$-coefficients\", fontsize=14)\n", + "axes[0].set_ylabel(\"Predictors\", fontsize=14)\n", + "axes[0].legend([]) # Remove legend\n", + "\n", + "# Place the beta values next to the horizontal bars\n", + "for i, (v, p) in enumerate(zip(COefs.values[:, 0], COefs.index)):\n", + " if v < 0: # If negative coefficient, place to the left of the bar\n", + " axes[0].text(v, i, f'{v:.2f}', va='center', ha='right', fontsize=11, color='black', weight='normal')\n", + " else:\n", + " axes[0].text(v, i, f'{v:.2f}', va='center', ha='left', fontsize=11, color='black', weight='normal')\n", + "\n", + "# Adjust x-axis limits to provide space for negative coefficient values\n", + "max_abs_coef = abs(COefs.values[:, 0]).max()\n", + "axes[0].set_xlim(-max_abs_coef * 1.2, max_abs_coef * 1.2)\n", + "\n", + "# Plot the second horizontal bar plot\n", + "sorted_featureWeight = (X_train_preprocessed.std(axis=0)).sort_values(ascending=True)\n", + "#sorted_featureWeight.plot.barh(ax=axes[1])\n", + "X_train_preprocessed.std(axis=0).plot.barh(ax=axes[1], width=0.3)\n", + "#axes[1].set_title(\"Normalized Variables: Z-scores\")\n", + "# Standardized betas (beta coefficients) are normalized based on the scales of the predictors.\n", + "axes[1].set_xlabel(\"Standardized $\\\\beta$-coefficients\", fontsize=14)\n", + "axes[1].set_ylabel(\"Predictors\", fontsize=14)\n", + "\n", + "# Place the beta values next to the horizontal bars for the second plot\n", + "for i, (v, p) in enumerate(zip(X_train_preprocessed.std(axis=0), X_train_preprocessed.columns)):\n", + " if v < 0: # If negative coefficient, place to the left of the bar\n", + " axes[1].text(v, i, f'{v:.3f}', va='center', ha='right', fontsize=11, color='black', weight='normal')\n", + " else:\n", + " axes[1].text(v, i, f'{v:.3f}', va='center', ha='left', fontsize=11, color='black', weight='normal')\n", + "\n", + "# Adjust x-axis limits for the second plot\n", + "max_abs_value = abs(X_train_preprocessed.std(axis=0)).max()\n", + "axes[1].set_xlim(0, max_abs_value * 1.2)\n", + "\n", + "# Adjust spacing between subplots\n", + "plt.subplots_adjust(wspace=0.2)\n", + "# Tighten the layout to remove oversized margins\n", + "plt.tight_layout()\n", + "# Save the figure\n", + "#plt.savefig(\"2.4.beta_coef_results.png\")\n", + "\n", + "#![This plot shows that...](2.4.beta_coef_results.png)\n", + "#plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3069027d-f53f-4348-8c0c-0885483dc8d9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "2. Compute the in-sample $R^2$ as well as the mean squared error. Do you think quarterly returns can easily be predicted?" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "69ae4d7d-16a9-436a-9cfc-1b087a563db8", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample (all) R^2: 0.1321\n", + "In-sample (all) MSE: 0.00441\n" + ] + } + ], + "source": [ + "y_pred_train = model_all.predict(X_train) # In-sample predictions.\n", + "\n", + "r2_train = r2_score(y_train, y_pred_train) # Option 1: calling sklearn r2_score function\n", + "print(f\"In-sample (all) R^2: {r2_train:.4f}\")\n", + "\n", + "#model_r2_train = model_all.score(X_train, y_train) # Option 2: calling LinearRegression.score function\n", + "#print(f\"In-sample R^2: {model_r2_train:.4f}\")\n", + "\n", + "mse_train = mean_squared_error(y_train, y_pred_train) # In-sample MSE\n", + "print(f\"In-sample (all) MSE: {mse_train:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "581f7631-9c99-4143-b87e-11b43c243dd0", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "3. Use $5$-fold cross validation to obtain an estimate for the out-of-sample mean squared error. Compare this estimate to the in-sample mean squared error from *Q2.2*." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "642f6798-71ac-479e-bd0f-be0f7ab2ce49", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample (all) cv.MSE: 0.00521\n" + ] + } + ], + "source": [ + "# Perform 5-fold cross-validation and calculate the in-sample MSE\n", + "train_all_cv_mse = -cross_val_score(model_all, X_train, y_train, scoring='neg_mean_squared_error', \n", + " cv=KFold(n_splits=5, shuffle=True, random_state=1)).mean()\n", + "print(f\"In-sample (all) cv.MSE: {train_all_cv_mse:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "18a9a179-4226-4734-8bcf-554671ce85e9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "4. Based on your findings from *Q2.1* select only a subset of the features to improve your model. Which features do you choose and why? Compute the in-sample $R^2$ as well as the mean squared error for this model and use $5$-fold cross validation to obtain an estimate for the out-of-sample mean squared error. Compare your results to the model using all features." + ] + }, + { + "cell_type": "markdown", + "id": "95d24155-d7b1-48ba-9567-2574ebc63fb7", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Regression with DP as predictor: `ret ~ DP`" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "c1761dc0-3714-457d-89e4-d19d00214aaf", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample (DP) R^2: 0.0541\n", + "In-sample (DP) MSE: 0.0055\n", + "In-sample (DP) cv.MSE: 0.00556\n" + ] + } + ], + "source": [ + "# Setting up a new regression model.\n", + "# Pre-selecting the exogenous variable.\n", + "selected_features1 = ['DP']\n", + "\n", + "# Establishing y and X based on the training and validation datasets.\n", + "X_train_DP_selected = train_data[selected_features1]\n", + "X_test_DP_selected = test_data[selected_features1]\n", + "y_train_DP = train_data['ret']\n", + "y_test_DP = test_data['ret']\n", + "\n", + "# Training the regression model.\n", + "model_DP = LinearRegression()\n", + "model_DP.fit(X_train_DP_selected, y_train_DP)\n", + "\n", + "# In-sample predictions.\n", + "y_pred_train_DP_selected = model_DP.predict(X_train_DP_selected)\n", + "\n", + "# Determining the in-sample R^2.\n", + "r2_in_sample_DP_selected = r2_score(y_train_DP, y_pred_train_DP_selected)\n", + "print(f\"In-sample (DP) R^2: {r2_in_sample_DP_selected:.4f}\")\n", + "\n", + "# Determining the in-sample Mean Squared Error (MSE).\n", + "mse_train_DP_selected = mean_squared_error(y_train_DP, y_pred_train_DP_selected)\n", + "print(f\"In-sample (DP) MSE: {mse_train_DP_selected:.4f}\")\n", + "\n", + "# Perform 5-fold cross-validation and calculate the in-sample MSE\n", + "train_DP_cv_mse = -cross_val_score(model_DP,\n", + " X_train_DP_selected,\n", + " y_train_DP,\n", + " scoring='neg_mean_squared_error',\n", + " cv=KFold(n_splits=5, shuffle=True, random_state=1)).mean()\n", + "\n", + "print(f\"In-sample (DP) cv.MSE: {train_DP_cv_mse:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fd8b3ab2-6b1a-4bf8-9db3-e19d4d4a2c01", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "### Regression with DP and cay as predictors: `ret ~ DP + cay`" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "d7512923-949c-4733-be03-24cc6c7ce71c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample (DP+cay) R^2: 0.1040\n", + "In-sample (DP+cay) MSE: 0.0052\n", + "In-sample (DP+cay) cv.MSE: 0.00529\n" + ] + } + ], + "source": [ + "# Setting up a new regression model.\n", + "# Pre-selecting the exogenous variable.\n", + "selected_features2 = ['DP', 'cay']\n", + "\n", + "# Establishing y and X based on the training and validation datasets.\n", + "X_train_DPcay_selected = train_data[selected_features2]\n", + "X_test_DPcay_selected = test_data[selected_features2]\n", + "y_train_DPcay = train_data['ret']\n", + "y_test_DPcay = test_data['ret']\n", + "\n", + "# Training the regression model.\n", + "model_DPcay = LinearRegression()\n", + "model_DPcay.fit(X_train_DPcay_selected, y_train_DPcay)\n", + "\n", + "# In-sample predictions.\n", + "y_pred_train_DPcay_selected = model_DPcay.predict(X_train_DPcay_selected)\n", + "\n", + "# Determining the in-sample R^2.\n", + "r2_in_sample_DPcay_selected = r2_score(y_train_DPcay, y_pred_train_DPcay_selected)\n", + "print(f\"In-sample (DP+cay) R^2: {r2_in_sample_DPcay_selected:.4f}\")\n", + "\n", + "# Determining the in-sample Mean Squared Error (MSE).\n", + "mse_train_DPcay_selected = mean_squared_error(y_train_DPcay, y_pred_train_DPcay_selected)\n", + "print(f\"In-sample (DP+cay) MSE: {mse_train_DPcay_selected:.4f}\")\n", + "\n", + "# Perform 5-fold cross-validation and calculate the in-sample MSE\n", + "train_DPcay_cv_mse = -cross_val_score(model_DPcay,\n", + " X_train_DPcay_selected,\n", + " y_train_DPcay,\n", + " scoring='neg_mean_squared_error',\n", + " cv=KFold(n_splits=5, shuffle=True, random_state=1)).mean()\n", + "\n", + "print(f\"In-sample (DP+cay) cv.MSE: {train_DPcay_cv_mse:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5a7e1a79-340c-4b61-9e74-e06b4f455904", + "metadata": { + "user_expressions": [] + }, + "source": [ + "5. Now suppose you use the two models you have build to predict quarterly returns in the coming $25$ years. Compute the out-of-sample mean squared errors for the test data. Compare these errors to the estimates for the out-of-sample errors obtained from k-fold CV. Interpret." + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "4f75d9ee-5a4a-4c8b-8a43-61846329db6f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [], + "source": [ + "## Perform 5-fold cross-validation - calculate the out-of-sample (all) MSE:\n", + "test_all_cv_mse = -cross_val_score(model_all, \n", + " X_test, \n", + " y_test, \n", + " scoring='neg_mean_squared_error', \n", + " cv=KFold(n_splits=5, shuffle=True, random_state=1)).mean()\n", + "\n", + "\n", + "## Perform 5-fold cross-validation - calculate the out-of-sample (DP) MSE:\n", + "test_DP_cv_mse = -cross_val_score(model_DP, \n", + " X_test_DP_selected, \n", + " y_test_DP, \n", + " scoring='neg_mean_squared_error',\n", + " cv=KFold(n_splits=5, shuffle=True, random_state=1)).mean()\n", + "\n", + "\n", + "## Perform 5-fold cross-validation - calculate the out-of-sample (DP+cay) MSE:\n", + "test_DPcay_cv_mse = -cross_val_score(model_DPcay, \n", + " X_test_DPcay_selected, \n", + " y_test_DPcay, \n", + " scoring='neg_mean_squared_error',\n", + " cv=KFold(n_splits=5, shuffle=True, random_state=1)).mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "1830488d-ddb6-4dd0-beda-aeb0d0647f59", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Model In-sample MSE In-sample cv.MSE Out-of-sample cv.MSE\n", + "0 All predictors 0.004414 0.005213 0.008361\n", + "1 DP 0.005479 0.005560 0.006735\n", + "2 DP+cay 0.005190 0.005294 0.006587\n" + ] + } + ], + "source": [ + "# Define the data\n", + "model_data_table = {\n", + " \"Model\": ['All predictors', 'DP', 'DP+cay'],\n", + " \"In-sample MSE\": [mse_train, mse_train_DP_selected, mse_train_DPcay_selected],\n", + " \"In-sample cv.MSE\": [train_all_cv_mse, train_DP_cv_mse, train_DPcay_cv_mse],\n", + " \"Out-of-sample cv.MSE\": [test_all_cv_mse, test_DP_cv_mse, test_DPcay_cv_mse]\n", + "}\n", + "# Create a DataFrame\n", + "mdt = pd.DataFrame(model_data_table)\n", + "\n", + "# Display the DataFrame\n", + "print(mdt)" + ] + }, + { + "cell_type": "raw", + "id": "ee76d361-883a-4e74-9352-df110c6f093b", + "metadata": { + "editable": true, + "raw_mimetype": "", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "df4f7f10-2779-43ab-a7b0-3bd1b3f15b0c", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Question 3: Predicting the direction of the stock market\n", + "\n", + "Instead of quantitatively predicting returns, assume now that you want to predict the direction of the stock market, that is, whether stocks go up or down. Based on these predictions you want to either invest in stocks or not.\n", + "\n", + "1. Create a new variable in both, the training and test data that is $1$ if the return is larger than zero and $0$ otherwise." + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "b28e213d-9ca8-4e33-a15f-feae07d73a18", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
dateretDPCSntiscayTSsvar
921952-Q11-2.8426960.0053280.032094-0.0105950.01040.002102
931952-Q20-2.8457110.0054250.0277310.0000550.00890.001660
941952-Q31-2.8287410.0055210.031038-0.0006950.01060.001076
951952-Q40-2.9361930.0052310.026535-0.0159500.00700.001753
961953-Q10-2.8868190.0043540.024013-0.0190210.00930.001574
\n", + "
" + ], + "text/plain": [ + " date ret DP CS ntis cay TS svar\n", + "92 1952-Q1 1 -2.842696 0.005328 0.032094 -0.010595 0.0104 0.002102\n", + "93 1952-Q2 0 -2.845711 0.005425 0.027731 0.000055 0.0089 0.001660\n", + "94 1952-Q3 1 -2.828741 0.005521 0.031038 -0.000695 0.0106 0.001076\n", + "95 1952-Q4 0 -2.936193 0.005231 0.026535 -0.015950 0.0070 0.001753\n", + "96 1953-Q1 0 -2.886819 0.004354 0.024013 -0.019021 0.0093 0.001574" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "train_data_class = train_data.copy() # Continuing with the copy of \"train_data\"\n", + "test_data_class = test_data.copy() # Continuing with the copy of \"test_data\"\n", + "\n", + "# Overwriting ret column.\n", + "# ret ist 1, wenn die Rendite größer als Null ist, sont 0.\n", + "train_data_class['ret'] = train_data_class['ret'].apply(lambda x: 1 if x > 0 else 0) # Applying onto In-sample data\n", + "test_data_class['ret'] = test_data_class['ret'].apply(lambda x: 1 if x > 0 else 0) # Applying onto Out-of-sample data\n", + "\n", + "train_data_class.head()" + ] + }, + { + "cell_type": "markdown", + "id": "e2c9d767-2c2a-4937-85f4-823ff387e11f", + "metadata": { + "user_expressions": [] + }, + "source": [ + "2. Compute the proportion of positive stock returns in both, the training and test data." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "340c54c5-8db6-4fce-ab35-8a782ad501c7", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample proportion of positive stock returns: 0.686\n", + "Out-of-Sample proportion of positive stock returns: 0.730\n" + ] + } + ], + "source": [ + "# In-sample proportion of positive stock returns\n", + "positive_proportion_train = train_data_class['ret'].mean()\n", + "print(f\"In-sample proportion of positive stock returns: {positive_proportion_train:.3f}\")\n", + "\n", + "# Out-of-Sample proportion of positive stock returns\n", + "positive_proportion_test = test_data_class['ret'].mean()\n", + "print(f\"Out-of-Sample proportion of positive stock returns: {positive_proportion_test:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "26f00d13-9110-4011-b896-cb1e0e3edd08", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "3. Fit a logistic regression using the training data to predict the direction of the stock market (make sure to exclude the *date* variable and the old quantitative *ret* variable.). Which features are useful predictors? Compute the in-sample accuracy and error rate. Do you think you have build a good model to predict the direction of the stock market?" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "b72adcc7-0cd5-4d9d-8c65-1bad74c6dfcb", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data:\n", + "In-sample accuracy: 0.6860\n", + "In-sample error rate: 0.3140\n" + ] + } + ], + "source": [ + "# Aufsetzen eines neuen Regressionsmodells\n", + "\n", + "X_train_class = train_data_class[['TS', 'svar']] # In-sample X \n", + "y_train_class = train_data_class['ret'] # In-sample y \n", + "\n", + "# Regressionsmodell trainieren\n", + "model = LogisticRegression()\n", + "model.fit(X_train_class, y_train_class)\n", + "\n", + "y_pred_train_class = model.predict(X_train_class) # In-sample Schätzungen\n", + "probs_train_class = model.predict_proba(X_train_class)[:, 1] # Wahrscheinlichkeiten der vorhergesagten In-sample Schätzungen\n", + "\n", + "pred_train_class = np.zeros(len(train_data_class))\n", + "pred_train_class[probs_train_class > 0.5] = 1 # Compute predictions using a threshold of 50%\n", + " # Extra: Ab threshold ~70% flippen \"accuracy\" und \"error rate\" Werte.\n", + "\n", + "print(\"Train data:\")\n", + "accuracy_train_class = accuracy_score(y_train_class, pred_train_class) # In-sample accuracy\n", + "print(f\"In-sample accuracy: {accuracy_train_class:.4f}\")\n", + "\n", + "error_rate_train_class = np.mean(pred_train_class != y_train_class) # In-sample error rate \n", + "print(f\"In-sample error rate: {error_rate_train_class:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "2c1bbcad-b760-41b5-a455-01f063e6036e", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "4. Now suppose you use the model you have build to predict the direction of the stock market in the coming $25$ years. Compute the out-of-sample accuracy and error rate for the test data. Compare these outcomes to the in-sample statistics. Do you think your model work well out- of-sample? Interpret the results." + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "055822b9-d17f-47be-ada6-f3fa45f4554d", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Validation data:\n", + "Out-of-sample accuracy: 0.7300\n", + "Out-of-sample error rate: 0.2700\n" + ] + } + ], + "source": [ + "X_test_class = test_data_class[['TS', 'svar']] # Out-of-sample X\n", + "y_test_class = test_data_class['ret'] # Out-of-sample y \n", + "\n", + "y_pred_test_class = model.predict(X_test_class) # Out-of-sample Schätzungen\n", + "probs_test_class = model.predict_proba(X_test_class)[:, 1] # Wahrscheinlichkeiten der vorhergesagten In-sample Schätzungen\n", + "\n", + "pred_test_class = np.zeros(len(test_data_class))\n", + "pred_test_class[probs_test_class > 0.5] = 1 # Compute predictions using a threshold of 50%\n", + "\n", + "print(\"Validation data:\")\n", + "accuracy_test_class = accuracy_score(y_test_class, pred_test_class) # Out-of-sample accuracy\n", + "print(f\"Out-of-sample accuracy: {accuracy_test_class:.4f}\")\n", + "\n", + "error_rate_test_class = np.mean(pred_test_class != y_test_class) # Out-of-sample error rate\n", + "print(f\"Out-of-sample error rate: {error_rate_test_class:.4f}\")" + ] + }, + { + "cell_type": "raw", + "id": "2419d990-f478-4bda-8dbc-3144fbdfc917", + "metadata": { + "editable": true, + "raw_mimetype": "", + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "81cbfae3-7385-40a2-8d0d-d7db7ae9a9f5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Appendix\n", + "The dataset contains the following variables:\n", + "\n", + " - **ret**: the quarterly return of the US stock market (a number of 0.01 is a $1\\%$ return per quarter)\n", + " - **date**: the date in format $yyyyq$ ($19941$ means the first quarter of $1994$)\n", + " - **DP**: the dividend to price ratio of the stock market (a valuation measure whether prices are high or low relative to the dividends payed)\n", + " - **CS**: the credit spread defined as the difference in yields between high rated corporate bonds (save investments) and low rated corporate bonds (corporations that might go bankrupt). CS measures the additional return investors require to invest in risky firms compared to well established firms with lower risks\n", + " - **ntis**: A measure for corporate issuing activity (IPO’s, stock repurchases,...)\n", + " - **cay**: a measure of the wealth-to-consumption ratio (how much is consumed relative to total wealth)\n", + " - **TS**: the term spread is the difference between the long term yield on government bonds and short term yields.\n", + " - **svar**: a measure for the stock market variance\n", + "\n", + "For a full description of the data, see *Welch und Goyal* ($2007$). Google is also very helpful if you are interested in obtaining more intuition about the variables.\n" + ] + }, + { + "cell_type": "markdown", + "id": "db90f03c-18a4-4e7f-a31c-56f206baf5cc", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## References\n", + "\n", + "Welch, I. and A. Goyal ($2007$, $03$). A Comprehensive Look at The Empirical Performance of Equity\n", + "Premium Prediction. *The Review of Financial Studies 21* ($4$), $1455$ – $1508$." + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.2" + }, + "latex": { + "header": "\\usepackage{etoolbox}\n\\AtBeginEnvironment{Verbatim}{\\fontsize{6}{8}\\selectfont}" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/Problem Set 1/ProblemSet1_solution.pdf b/Machine Learning for Economics and Finance/Problem Set 1/ProblemSet1_solution.pdf new file mode 100755 index 0000000..8f565fe Binary files /dev/null and b/Machine Learning for Economics and Finance/Problem Set 1/ProblemSet1_solution.pdf differ diff --git a/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2.ipynb b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2.ipynb new file mode 100755 index 0000000..b10cb19 --- /dev/null +++ b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2.ipynb @@ -0,0 +1,354 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "77f76980-cc4f-4837-867f-218c92a7deae", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{Problem Set 2}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "2c3a2d4e-1e5a-4fe3-88be-abd9b9152def", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "040dc2a4-910e-4cf5-9d1e-62fe7d0a8efd", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Important Instructions\n", + "\n", + "- In this problem set you are asked to apply the machine learning techniques we covered in the past weeks\n", + "- In case you struggle with some problems, please post your questions on the OpenOlat discussion board.\n", + "- We will discuss the solutions for the problem set on `MONTH DAY`" + ] + }, + { + "cell_type": "markdown", + "id": "baac6966-d67a-4a66-acec-8ef6411c4f66", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Setup\n", + "\n", + "Assume the same setup as in *Problem Set 1* but now you try to improve the return predictions using\n", + "the machine learning approaches we have discussed in class. For this you are asked to use the same\n", + "training and test datasets we constructed in *Problem Set 1*." + ] + }, + { + "cell_type": "raw", + "id": "156ee566-f0eb-4206-a443-34a63bc6dbd8", + "metadata": {}, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "87902d82-5336-456b-bec8-403530c75f00", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Question 1: Shrinkage Methods\n", + "\n", + "1. Fit a ridge regression using the training data. Determine the optimal penalty parameter $\\lambda$ using $5$-fold cross validation (set the seed to $2$ before you run the CV). Provide a plot of the cross-validation MSE as a function of log($\\lambda$) and interpret the outome." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0770500d-74fe-48df-841c-20b9aef42883", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "73330b81-0e43-43ac-911f-4086a9f9788f", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "2. Prepare a slide with a table that reports training MSE and test MSE for different models. Fill in the MSE from the linear model using all features from Problem Set 1. Now compute the training and test MSE for the ridge regression with the optimal penalty parameter $\\lambda$ from *Q1.1*." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f1b13abd-80b1-4805-b108-55d403b7ab5c", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "80e4160e-374a-43e1-a159-45077703658e", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "3. Redo the two tasks above using Lasso instead of Ridge. Again fix the seed to $2$. Provide a plot of the cross-validation MSE as a function of log($\\lambda$) and interpret. Provide a table that shows the coefficient of the Lasso with the optimal penalty parameter $\\lambda$. Compute the training and test MSE of this Lasso model and add it to the table from *Q1.2*." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a214f453-68d3-4b6f-bc36-dbabf5536fc3", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "03d19235-25ee-4c3b-b7bf-97cdf27d41b2", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "4. Now suppose your boss tells you that he only trusts sparse models with few variables. Use the Lasso and choose the tuning parameter $\\lambda$ such that the model only considers $3$ out of the six variables. Report the coefficients and compare them to the coefficients from the optimal model from *Q1.3* and interpret. Compute the training and test MSE of this Lasso model and add it to the table from *Q1.2*. Interpret." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9e53d846-19a3-46d9-b103-f42e75a87c20", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "e715dd42-7021-466d-a9c1-0c0b4efeee78", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Question 2: Tree-Based Methods\n", + "\n", + "1. Fit a large regression tree using the training data. Report the number of terminal nodes as well as the most important variables for splitting the tree." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0207f3f9-c389-4e50-abeb-5316857ab2da", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "3069027d-f53f-4348-8c0c-0885483dc8d9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "2. Compute the training and test MSE of the tree and add it to the table from *Q1.2*." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f65211c4-6864-4749-8b94-eaeea96c9cbf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "581f7631-9c99-4143-b87e-11b43c243dd0", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "3. Again set the seed to $2$ and use $5$-fold cross validation to determine the optimal pruning parameter for the large tree. Provide a plot of the prediction error against the size of the tree. Report the optimal tree size and provide a plot of the pruned tree. Which variables are important for splitting the pruned tree?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9801c9a3-85ba-4b70-82b6-a9bbbfcfaec4", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "18a9a179-4226-4734-8bcf-554671ce85e9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "4. Compute the training and test MSE of the pruned tree and add it to the table from *Q1.2*." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b0272ea3-971d-4881-8308-9b41c38b05bd", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "5a7e1a79-340c-4b61-9e74-e06b4f455904", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "5. Finally, use random forest to improve the predictions. Motivate your choice for the tuning parameters. Report the training and test MSE and add it to the table from *Q1.2*. Which variables are most important in the random forest?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e9731a27-c811-4cf2-a53d-7d49a48e1d5b", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "id": "ccecdd74-9faf-4b7a-bd23-9d3f81dcda60", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "6. Supposed it is the beginning of $2020$ and you have access to both the in-sample and out-of-sample errors for the different methods. Which model do you choose to predict stock markets in the future and why?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "151e7ae9-1f4d-47f9-87d1-9da0b030da50", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "raw", + "id": "2419d990-f478-4bda-8dbc-3144fbdfc917", + "metadata": {}, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "81cbfae3-7385-40a2-8d0d-d7db7ae9a9f5", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Appendix\n", + "The dataset contains the following variables:\n", + "\n", + " - **ret**: the quarterly return of the US stock market (a number of 0.01 is a $1\\%$ return per quarter)\n", + " - **date**: the date in format $yyyyq$ ($19941$ means the first quarter of $1994$)\n", + " - **DP**: the dividend to price ratio of the stock market (a valuation measure whether prices are high or low relative to the dividends payed)\n", + " - **CS**: the credit spread defined as the difference in yields between high rated corporate bonds (save investments) and low rated corporate bonds (corporations that might go bankrupt). CS measures the additional return investors require to invest in risky firms compared to well established firms with lower risks\n", + " - **ntis**: A measure for corporate issuing activity (IPO’s, stock repurchases,...)\n", + " - **cay**: a measure of the wealth-to-consumption ratio (how much is consumed relative to total wealth)\n", + " - **TS**: the term spread is the difference between the long term yield on government bonds and short term yields.\n", + " - **svar**: a measure for the stock market variance\n", + "\n", + "For a full description of the data, see *Welch und Goyal* ($2007$). Google is also very helpful if you are interested in obtaining more intuition about the variables.\n" + ] + }, + { + "cell_type": "markdown", + "id": "db90f03c-18a4-4e7f-a31c-56f206baf5cc", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## References\n", + "\n", + "Welch, I. and A. Goyal ($2007$, $03$). A Comprehensive Look at The Empirical Performance of Equity\n", + "Premium Prediction. *The Review of Financial Studies 21* ($4$), $1455$ – $1508$." + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2.pdf b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2.pdf new file mode 100755 index 0000000..a5d1237 Binary files /dev/null and b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2.pdf differ diff --git a/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2_solution.ipynb b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2_solution.ipynb new file mode 100755 index 0000000..df1e970 --- /dev/null +++ b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2_solution.ipynb @@ -0,0 +1,2092 @@ +{ + "cells": [ + { + "cell_type": "raw", + "id": "77f76980-cc4f-4837-867f-218c92a7deae", + "metadata": {}, + "source": [ + "\\vspace{-4cm}\n", + "\\begin{center}\n", + " \\LARGE{Machine Learning for Economics and Finance}\\\\[0.5cm]\n", + " \\Large{\\textbf{Problem Set 2}}\\\\[1.0cm]\n", + " \\large{Ole Wilms}\\\\[0.5cm]\n", + " \\large{July 29, 2024}\\\\\n", + "\\end{center}" + ] + }, + { + "cell_type": "raw", + "id": "2c3a2d4e-1e5a-4fe3-88be-abd9b9152def", + "metadata": {}, + "source": [ + "\\setcounter{secnumdepth}{0}" + ] + }, + { + "cell_type": "markdown", + "id": "040dc2a4-910e-4cf5-9d1e-62fe7d0a8efd", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Important Instructions\n", + "\n", + "- In this problem set you are asked to apply the machine learning techniques we covered in the past weeks\n", + "- In case you struggle with some problems, please post your questions on the OpenOlat discussion board.\n", + "- We will discuss the solutions for the problem set on `MONTH DAY`" + ] + }, + { + "cell_type": "markdown", + "id": "baac6966-d67a-4a66-acec-8ef6411c4f66", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Setup\n", + "\n", + "Assume the same setup as in *Problem Set 1* but now you try to improve the return predictions using\n", + "the machine learning approaches we have discussed in class. For this you are asked to use the same\n", + "training and test datasets we constructed in *Problem Set 1*." + ] + }, + { + "cell_type": "raw", + "id": "156ee566-f0eb-4206-a443-34a63bc6dbd8", + "metadata": {}, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "e54ba1ec-32c5-4f70-ab80-8b73be676bc4", + "metadata": {}, + "source": [ + "## Preliminaries" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fcdca5da-754d-4c06-b1c7-d8acef1e113d", + "metadata": {}, + "outputs": [], + "source": [ + "# Loading needed packages for this ProblemSet2\n", + "import pyreadr\n", + "import pandas as pd\n", + "import numpy as np\n", + "import statsmodels.api as sm\n", + "from statsmodels.formula.api import ols\n", + "from sklearn.linear_model import LinearRegression, LogisticRegression, Ridge, Lasso, RidgeCV, LassoCV\n", + "from sklearn.model_selection import cross_val_score, KFold, GridSearchCV\n", + "from sklearn.metrics import r2_score, mean_squared_error, accuracy_score\n", + "from matplotlib.pyplot import subplots\n", + "from statsmodels.api import OLS\n", + "import sklearn.model_selection as skm\n", + "import sklearn.linear_model as skl\n", + "from sklearn.preprocessing import StandardScaler\n", + "from functools import partial\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.cross_decomposition import PLSRegression\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn.compose import make_column_transformer\n", + "from sklearn.preprocessing import OneHotEncoder\n", + "from sklearn.compose import TransformedTargetRegressor\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.metrics import PredictionErrorDisplay, median_absolute_error\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from sklearn.model_selection import cross_validate\n", + "\n", + "# Setup options for the following matplotlib plots:\n", + "plt.rcParams.update({\n", + " 'figure.figsize': (8, 6),\n", + " 'font.family': 'serif',\n", + " 'font.size': 12,\n", + " 'axes.titlesize': 14,\n", + " 'axes.grid': False,\n", + " 'lines.linewidth': 2\n", + "})" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "97421b61-9b25-4f76-ac85-9146b81c1b4a", + "metadata": {}, + "outputs": [], + "source": [ + "# Load and prepare data (your existing code)\n", + "df = pyreadr.read_r('~/Desktop/stockmarketdata.rds')\n", + "df = df[None]\n", + "dfRAW = df.copy(deep=True)\n", + "\n", + "# Lead returns (shift by -1)\n", + "df['ret'] = df['ret'].shift(-1)\n", + "\n", + "# Remove missing values\n", + "df = df.dropna()" + ] + }, + { + "cell_type": "markdown", + "id": "a5e301be-db9a-40eb-a6bf-8fa65d96200c", + "metadata": {}, + "source": [ + "Splitting the Dataset into train- and testdata" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "730b7867-6fe1-439a-975e-4f39c1e7cfe0", + "metadata": {}, + "outputs": [], + "source": [ + "# Split data into train and test sample\n", + "df['date'] = df['date'].astype(np.int64)\n", + "split_date = 19944\n", + "split_ind = df.index[df['date'] == split_date][0]\n", + "\n", + "train_data = df.loc[:split_ind]\n", + "train_data = train_data.drop('date', axis=1)\n", + "test_data = df.loc[split_ind + 1:]\n", + "test_data = test_data.drop('date', axis=1)\n", + "\n", + "# Prepare X and y\n", + "X_train = train_data.drop(columns=['ret'])\n", + "y_train = train_data['ret']\n", + "X_test = test_data.drop(columns=['ret'])\n", + "y_test = test_data['ret']" + ] + }, + { + "cell_type": "markdown", + "id": "4c0e2ea6-7101-4452-bada-bbe7c5f431d3", + "metadata": {}, + "source": [ + "### Exploration and visualization of the dataset (additional)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "52383bbe-c44b-48be-856f-75101654a133", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Index: 272 entries, 92 to 363\n", + "Data columns (total 8 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 date 272 non-null int64 \n", + " 1 ret 272 non-null float64\n", + " 2 DP 272 non-null float64\n", + " 3 CS 272 non-null float64\n", + " 4 ntis 272 non-null float64\n", + " 5 cay 272 non-null float64\n", + " 6 TS 272 non-null float64\n", + " 7 svar 272 non-null float64\n", + "dtypes: float64(7), int64(1)\n", + "memory usage: 27.2 KB\n" + ] + } + ], + "source": [ + "df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7a753beb-0dfb-441c-ad2e-695ebc064bfc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
countmeanstdmin25%50%75%max
date272.019857.500000196.64285719521.00000019689.25000019857.50000020025.75000020194.000000
ret272.00.0286080.078468-0.252154-0.0167250.0358210.0769140.228211
DP272.0-3.5530950.404929-4.493159-3.906620-3.498891-3.279654-2.778536
CS272.00.0090020.0038750.0032430.0064650.0080440.0105980.031668
ntis272.00.0118310.019359-0.0518310.0013560.0154150.0259450.048391
cay272.00.0021890.022592-0.047607-0.0169870.0077170.0187970.042897
TS272.00.0167100.013993-0.0350000.0067250.0160000.0273250.045300
svar272.00.0058220.0097210.0003700.0021420.0034760.0059510.114436
\n", + "
" + ], + "text/plain": [ + " count mean std min 25% \\\n", + "date 272.0 19857.500000 196.642857 19521.000000 19689.250000 \n", + "ret 272.0 0.028608 0.078468 -0.252154 -0.016725 \n", + "DP 272.0 -3.553095 0.404929 -4.493159 -3.906620 \n", + "CS 272.0 0.009002 0.003875 0.003243 0.006465 \n", + "ntis 272.0 0.011831 0.019359 -0.051831 0.001356 \n", + "cay 272.0 0.002189 0.022592 -0.047607 -0.016987 \n", + "TS 272.0 0.016710 0.013993 -0.035000 0.006725 \n", + "svar 272.0 0.005822 0.009721 0.000370 0.002142 \n", + "\n", + " 50% 75% max \n", + "date 19857.500000 20025.750000 20194.000000 \n", + "ret 0.035821 0.076914 0.228211 \n", + "DP -3.498891 -3.279654 -2.778536 \n", + "CS 0.008044 0.010598 0.031668 \n", + "ntis 0.015415 0.025945 0.048391 \n", + "cay 0.007717 0.018797 0.042897 \n", + "TS 0.016000 0.027325 0.045300 \n", + "svar 0.003476 0.005951 0.114436 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Descriptive Statistics of the Data\n", + "df.describe().T" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "beb3b6e0-76d7-4584-b260-941de25b45e2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[, ,\n", + " ],\n", + " [,\n", + " , ],\n", + " [, , ]],\n", + " dtype=object)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df.loc[:, df.columns != \"date\"].hist(figsize=(10, 8), edgecolor='black', grid=False)\n", + "# Graphical Overview of the Distributions of Individual Variables in the Data\n", + "# The variable \"date\" is not explicitly excluded here." + ] + }, + { + "cell_type": "markdown", + "id": "f9f1a13d-3c5f-4eed-9892-4c3db49775da", + "metadata": {}, + "source": [ + "Linear Model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6031cc9b-3399-4e2d-a6ca-6f0f3d18a544", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "In-sample MSE: 0.00505\n", + "Out-of-sample MSE: 0.00861\n" + ] + } + ], + "source": [ + "# Train linear model for comparison (your existing code)\n", + "model_all = LinearRegression()\n", + "model_all.fit(X_train, y_train)\n", + "y_pred_train_lm = model_all.predict(X_train)\n", + "mse_train_lm = mean_squared_error(y_train, y_pred_train_lm)\n", + "y_pred_test_lm = model_all.predict(X_test)\n", + "mse_test_lm = mean_squared_error(y_test, y_pred_test_lm)\n", + "\n", + "# print(\"LINEAR MODEL RESULTS:\")\n", + "print(f\"In-sample MSE: {mse_train_lm:.5f}\")\n", + "print(f\"Out-of-sample MSE: {mse_test_lm:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "87902d82-5336-456b-bec8-403530c75f00", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Question 1: Shrinkage Methods" + ] + }, + { + "cell_type": "markdown", + "id": "7c7f6ae5-294d-4221-bfcf-c55d113c6eb2", + "metadata": {}, + "source": [ + "### 1.1 Ridge Regression\n", + "Fit a ridge regression using the training data. Determine the optimal penalty parameter $\\lambda$ using $5$-fold cross validation (set the seed to $2$ before you run the CV). Provide a plot of the cross-validation MSE as a function of log($\\lambda$) and interpret the outome." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0f2cd4e4-bc7a-4a7f-b144-af2696ecdb66", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best lambda (Ridge): 0.040370\n", + "Log of best lambda: -3.2097\n" + ] + } + ], + "source": [ + "# Set up Ridge regression with cross-validation\n", + "np.random.seed(2) # Set seed for reproducibility\n", + "\n", + "# Define lambda grid (alpha in sklearn)\n", + "lambda_grid = np.logspace(-6, 2, 100) # From log(-6) to log(2)\n", + "\n", + "# Perform Ridge regression with 5-fold cross-validation\n", + "# Note: store_cv_results only works with cv=None, so we'll use manual CV for plotting\n", + "ridge_cv = RidgeCV(alphas=lambda_grid, cv=5, scoring='neg_mean_squared_error')\n", + "ridge_cv.fit(X_train, y_train)\n", + "\n", + "# Get best lambda (alpha in sklearn)\n", + "best_lambda_ridge = ridge_cv.alpha_\n", + "print(f\"Best lambda (Ridge): {best_lambda_ridge:.6f}\")\n", + "print(f\"Log of best lambda: {np.log(best_lambda_ridge):.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "17577967-bc41-4e39-924b-341ccbf34a17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing detailed cross-validation for plotting...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.model_selection import cross_validate\n", + "\n", + "# Manual cross-validation to get detailed results for plotting (like R's cv.glmnet)\n", + "print(\"Performing detailed cross-validation for plotting...\")\n", + "\n", + "cv_mse_mean = []\n", + "cv_mse_std = []\n", + "\n", + "for alpha in lambda_grid:\n", + " ridge_temp = Ridge(alpha=alpha)\n", + " cv_results = cross_validate(ridge_temp, X_train, y_train,\n", + " cv=5, scoring='neg_mean_squared_error',\n", + " return_train_score=False)\n", + " cv_scores = -cv_results['test_score'] # Convert to positive MSE\n", + " cv_mse_mean.append(cv_scores.mean())\n", + " cv_mse_std.append(cv_scores.std())\n", + "\n", + "cv_mse_mean = np.array(cv_mse_mean)\n", + "cv_mse_std = np.array(cv_mse_std)\n", + "\n", + "# Index von best_lambda_ridge im Grid finden:\n", + "idx_best = np.where(lambda_grid == best_lambda_ridge)[0][0]\n", + "best_mse = cv_mse_mean[idx_best]\n", + "\n", + "# Index für λ_1SE finden:\n", + "# Bestes MSE + 1SE-Grenze\n", + "threshold = best_mse + cv_mse_std[idx_best]\n", + "\n", + "# Kandidaten-Lambdas finden, die <= threshold sind\n", + "candidates = np.where(cv_mse_mean <= threshold)[0]\n", + "\n", + "# Nimm das größte λ (also den einfachsten / regularisiertesten Kandidaten)\n", + "idx_1se = candidates[-1]\n", + "best_lambda_1se = lambda_grid[idx_1se]\n", + "best_mse_1se = cv_mse_mean[idx_1se]\n", + "\n", + "# --- NEUER CODE FÜR y2-ACHSE: Anzahl Variablen berechnen ---\n", + "n_nonzero = []\n", + "for alpha in lambda_grid:\n", + " ridge_temp = Ridge(alpha=alpha)\n", + " ridge_temp.fit(X_train, y_train)\n", + " # Ridge behält alle Variablen, aber wir können trotzdem die Anzahl Features anzeigen\n", + " n_nonzero.append(X_train.shape[1]) # Für Ridge immer alle Features\n", + " # Alternative: Zeige \"effective\" number of parameters basierend auf Koeffizienten-Größe\n", + " # n_nonzero.append(np.sum(np.abs(ridge_temp.coef_) > np.max(np.abs(ridge_temp.coef_)) * 0.01))\n", + "\n", + "plt.style.use('default')\n", + "# --- GEÄNDERT: fig, ax1 für subplot mit y2-Achse ---\n", + "fig, ax1 = plt.subplots(figsize=(10, 6))\n", + "\n", + "ax1.errorbar(np.log(lambda_grid),\n", + " cv_mse_mean,\n", + " yerr=cv_mse_std,\n", + " capsize=3,\n", + " color=\"red\",\n", + " ecolor=\"grey\",\n", + " elinewidth=1,\n", + " fmt='o',\n", + " markersize=4,\n", + " )\n", + "\n", + "ax1.axvline(np.log(best_lambda_ridge),\n", + " color='black',\n", + " linestyle='--',\n", + " linewidth=1,\n", + " label=(f'Best log(λ) = {np.log(best_lambda_ridge):.3f}\\n'\n", + " f'(Best λ = {best_lambda_ridge:.6f})\\n'\n", + " f'CV-MSE = {best_mse:.5f}'\n", + " )\n", + " )\n", + "\n", + "ax1.axvline(np.log(best_lambda_1se),\n", + " color='darkgrey',\n", + " linestyle='--',\n", + " linewidth=1,\n", + " label=(f'1SE log(λ) = {np.log(best_lambda_1se):.3f}\\n'\n", + " f'(1SE λ = {best_lambda_1se:.6f})\\n'\n", + " f'CV-MSE = {best_mse_1se:.5f}'\n", + " )\n", + " )\n", + "\n", + "ax1.set_xlabel('log(λ)', fontsize=12)\n", + "ax1.set_ylabel('Cross-Validation MSE', fontsize=12)\n", + "# ax1.set_title('Ridge Regression: Cross-Validation MSE vs log(λ)')\n", + "ax1.grid(False)\n", + "\n", + "# --- Legende unter dem Plot, zentriert, nebeneinander ---\n", + "ax1.legend(bbox_to_anchor=(0.5, -0.15),\n", + " loc='upper center',\n", + " ncol=3,\n", + " frameon=True,\n", + " framealpha=0 # 0 = unsichtbar, 1 = voll sichtbar\n", + " )\n", + "\n", + "# --- NEUER CODE: y2-Achse oben für Anzahl Variablen ---\n", + "ax2 = ax1.twiny()\n", + "ax2.set_xlim(ax1.get_xlim())\n", + "\n", + "# Ticks und Labels für die Anzahl der Variablen setzen\n", + "log_lambdas = np.log(lambda_grid)\n", + "# Zeige max 20 Ticks um Überlappung zu vermeiden\n", + "n_ticks = min(20, len(lambda_grid))\n", + "tick_indices = np.linspace(0, len(lambda_grid)-1, n_ticks, dtype=int)\n", + "\n", + "ax2.set_xticks(log_lambdas[tick_indices])\n", + "ax2.set_xticklabels([str(n_nonzero[i]) for i in tick_indices])\n", + "ax2.set_xlabel('Number of Variables', fontsize=12)\n", + "\n", + "# Ticks nach innen richten (wie in R)\n", + "# ax2.tick_params(axis='x', direction='in', pad=-15)\n", + "ax2.tick_params(axis='x', direction='out')#, pad=-15)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "73330b81-0e43-43ac-911f-4086a9f9788f", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 1.2 Ridge Regression MSE\n", + "Prepare a slide with a table that reports training MSE and test MSE for different models. Fill in the MSE from the linear model using all features from Problem Set 1. Now compute the training and test MSE for the ridge regression with the optimal penalty parameter $\\lambda$ from *Q1.1*." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "2946f83f-3fe7-42cf-9c14-fd9952117fbb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ridge Train MSE: 0.00511\n", + "Ridge Test MSE: 0.00878\n", + "\n", + "Ridge Coefficients:\n", + " Variable Ridge_Coefficient\n", + "0 DP 0.086305\n", + "1 CS 0.064603\n", + "2 ntis -0.260392\n", + "3 cay 0.389788\n", + "4 TS 0.327515\n", + "5 svar 0.156850\n" + ] + } + ], + "source": [ + "# Fit Ridge regression with optimal lambda\n", + "ridge_optimal = Ridge(alpha=best_lambda_ridge)\n", + "ridge_optimal.fit(X_train, y_train)\n", + "\n", + "# Calculate training and test MSE\n", + "y_pred_ridge_train = ridge_optimal.predict(X_train)\n", + "mse_ridge_train = mean_squared_error(y_train, y_pred_ridge_train)\n", + "\n", + "y_pred_ridge_test = ridge_optimal.predict(X_test)\n", + "mse_ridge_test = mean_squared_error(y_test, y_pred_ridge_test)\n", + "\n", + "print(f\"Ridge Train MSE: {mse_ridge_train:.5f}\")\n", + "print(f\"Ridge Test MSE: {mse_ridge_test:.5f}\")\n", + "\n", + "# Show coefficients\n", + "ridge_coefs = pd.DataFrame({\n", + " 'Variable': X_train.columns,\n", + " 'Ridge_Coefficient': ridge_optimal.coef_\n", + "})\n", + "print(\"\\nRidge Coefficients:\")\n", + "print(ridge_coefs)" + ] + }, + { + "cell_type": "markdown", + "id": "80e4160e-374a-43e1-a159-45077703658e", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 1.3 Lasso Regression\n", + "Redo the two tasks above using Lasso instead of Ridge. Again fix the seed to $2$. Provide a plot of the cross-validation MSE as a function of log($\\lambda$) and interpret. Provide a table that shows the coefficient of the Lasso with the optimal penalty parameter $\\lambda$. Compute the training and test MSE of this Lasso model and add it to the table from *Q1.2*." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "36942912-0b0d-4caf-af6c-52c4c248cee4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best lambda (Lasso): 0.000152\n", + "Log of best lambda: -8.7917\n" + ] + } + ], + "source": [ + "# Lasso with cross-validation\n", + "lasso_cv = LassoCV(alphas=lambda_grid, cv=5, random_state=2, max_iter=10000)\n", + "lasso_cv.fit(X_train, y_train)\n", + "\n", + "# Get best lambda\n", + "best_lambda_lasso = lasso_cv.alpha_\n", + "print(f\"Best lambda (Lasso): {best_lambda_lasso:.6f}\")\n", + "print(f\"Log of best lambda: {np.log(best_lambda_lasso):.4f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "da2dde5d-2756-41ce-9e6c-239b8d884ee3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Performing detailed cross-validation for Lasso plotting...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Manual cross-validation for plotting (to match R's detailed CV output)\n", + "print(\"Performing detailed cross-validation for Lasso plotting...\")\n", + "cv_mse_lasso = []\n", + "cv_mse_lasso_std = []\n", + "\n", + "for alpha in lambda_grid:\n", + " lasso_temp = Lasso(alpha=alpha, random_state=2, max_iter=10000)\n", + " cv_results = cross_validate(lasso_temp, X_train, y_train, \n", + " cv=5, scoring='neg_mean_squared_error',\n", + " return_train_score=False)\n", + " cv_scores = -cv_results['test_score'] # Convert to positive MSE\n", + " cv_mse_lasso.append(cv_scores.mean())\n", + " cv_mse_lasso_std.append(cv_scores.std())\n", + "\n", + "cv_mse_lasso = np.array(cv_mse_lasso)\n", + "cv_mse_lasso_std = np.array(cv_mse_lasso_std)\n", + "\n", + "# Index von best_lambda_lasso im Grid finden:\n", + "idx_best_lasso = np.where(lambda_grid == best_lambda_lasso)[0][0]\n", + "best_mse_lasso = cv_mse_lasso[idx_best_lasso]\n", + "\n", + "# Index für λ_1SE finden:\n", + "# Bestes MSE + 1SE-Grenze\n", + "threshold_lasso = best_mse_lasso + cv_mse_lasso_std[idx_best_lasso]\n", + "# Kandidaten-Lambdas finden, die <= threshold sind\n", + "candidates_lasso = np.where(cv_mse_lasso <= threshold_lasso)[0]\n", + "# Nimm das größte λ (also den einfachsten / regularisiertesten Kandidaten)\n", + "idx_1se_lasso = candidates_lasso[-1]\n", + "best_lambda_1se_lasso = lambda_grid[idx_1se_lasso]\n", + "best_mse_1se_lasso = cv_mse_lasso[idx_1se_lasso]\n", + "\n", + "# --- NEUER CODE FÜR y2-ACHSE: Anzahl Variablen berechnen ---\n", + "n_nonzero_lasso = []\n", + "for alpha in lambda_grid:\n", + " lasso_temp = Lasso(alpha=alpha, random_state=2, max_iter=10000)\n", + " lasso_temp.fit(X_train, y_train)\n", + " # Für Lasso: Zähle nicht-null Koeffizienten\n", + " n_nonzero_lasso.append(np.sum(np.abs(lasso_temp.coef_) > 1e-10))\n", + "\n", + "plt.style.use('default')\n", + "# --- GEÄNDERT: fig, ax1 für subplot mit y2-Achse ---\n", + "fig, ax1 = plt.subplots(figsize=(10, 6))\n", + "\n", + "ax1.errorbar(np.log(lambda_grid),\n", + " cv_mse_lasso,\n", + " yerr=cv_mse_lasso_std,\n", + " capsize=3,\n", + " color=\"red\", # Marker/Linie Rot\n", + " ecolor=\"grey\", # Error Bars grau\n", + " elinewidth=1, # (optional) Breite der Error Bars\n", + " fmt='o', # (optional) schwarze '-'Linie + 'o'Punkte '-o'\n", + " markersize=4,\n", + " )\n", + "\n", + "ax1.axvline(np.log(best_lambda_lasso),\n", + " color='black',\n", + " linestyle='--', \n", + " linewidth=1,\n", + " label=(f'Best log(λ) = {np.log(best_lambda_lasso):.3f}\\n'\n", + " f'(Best λ = {best_lambda_lasso:.6f})\\n'\n", + " f'CV-MSE = {best_mse_lasso:.5f}'\n", + " )\n", + " )\n", + "\n", + "ax1.axvline(np.log(best_lambda_1se_lasso),\n", + " color='darkgrey',\n", + " linestyle='--',\n", + " linewidth=1,\n", + " label=(f'1SE log(λ) = {np.log(best_lambda_1se_lasso):.3f}\\n'\n", + " f'(1SE λ = {best_lambda_1se_lasso:.6f})\\n'\n", + " f'CV-MSE = {best_mse_1se_lasso:.5f}'\n", + " )\n", + " )\n", + "\n", + "ax1.set_xlabel('log(λ)', fontsize=12)\n", + "ax1.set_ylabel('Cross-Validation MSE', fontsize=12)\n", + "# ax1.set_title('Lasso Regression: Cross-Validation MSE vs log(λ)')\n", + "ax1.grid(False)\n", + "\n", + "# --- Legende unter dem Plot, zentriert, nebeneinander ---\n", + "ax1.legend(bbox_to_anchor=(0.5, -0.15),\n", + " loc='upper center',\n", + " ncol=3,\n", + " frameon=True,\n", + " framealpha=0 # 0 = unsichtbar, 1 = voll sichtbar\n", + " )\n", + "\n", + "# --- NEUER CODE: y2-Achse oben für Anzahl Variablen ---\n", + "ax2 = ax1.twiny()\n", + "ax2.set_xlim(ax1.get_xlim())\n", + "\n", + "# Ticks und Labels für die Anzahl der Variablen setzen\n", + "log_lambdas_lasso = np.log(lambda_grid)\n", + "# Zeige max 20 Ticks um Überlappung zu vermeiden\n", + "n_ticks = min(20, len(lambda_grid))\n", + "tick_indices = np.linspace(0, len(lambda_grid)-1, n_ticks, dtype=int)\n", + "\n", + "ax2.set_xticks(log_lambdas_lasso[tick_indices])\n", + "ax2.set_xticklabels([str(n_nonzero_lasso[i]) for i in tick_indices])\n", + "ax2.set_xlabel('Number of Variables', fontsize=12)\n", + "\n", + "# Ticks nach außen richten (wie in Ridge)\n", + "ax2.tick_params(axis='x', direction='out')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "25e2f604-dd39-4eb7-aeb8-19ed44db30a8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lasso Train MSE: 0.00524\n", + "Lasso Test MSE: 0.00916\n" + ] + } + ], + "source": [ + "# Fit Lasso with optimal lambda\n", + "lasso_optimal = Lasso(alpha=best_lambda_lasso, random_state=2, max_iter=10000)\n", + "lasso_optimal.fit(X_train, y_train)\n", + "\n", + "# Calculate training and test MSE\n", + "y_pred_lasso_train = lasso_optimal.predict(X_train)\n", + "mse_lasso_train = mean_squared_error(y_train, y_pred_lasso_train)\n", + "\n", + "y_pred_lasso_test = lasso_optimal.predict(X_test)\n", + "mse_lasso_test = mean_squared_error(y_test, y_pred_lasso_test)\n", + "\n", + "print(f\"Lasso Train MSE: {mse_lasso_train:.5f}\")\n", + "print(f\"Lasso Test MSE: {mse_lasso_test:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "0cebe3da-b8ce-433b-8db2-94fa70117a2c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lasso Coefficients:\n", + " Variable Lasso_Coefficient\n", + "0 DP 0.085394\n", + "1 CS 0.000000\n", + "2 ntis -0.000000\n", + "3 cay 0.443235\n", + "4 TS 0.000000\n", + "5 svar 0.000000\n", + "\n", + "Number of non-zero coefficients: 2\n" + ] + } + ], + "source": [ + "# Show coefficients\n", + "lasso_coefs = pd.DataFrame({\n", + " 'Variable': X_train.columns,\n", + " 'Lasso_Coefficient': lasso_optimal.coef_\n", + "})\n", + "print(\"Lasso Coefficients:\")\n", + "print(lasso_coefs)\n", + "\n", + "# Count non-zero coefficients\n", + "non_zero_coefs = np.sum(lasso_optimal.coef_ != 0)\n", + "print(f\"\\nNumber of non-zero coefficients: {non_zero_coefs}\")" + ] + }, + { + "cell_type": "markdown", + "id": "03d19235-25ee-4c3b-b7bf-97cdf27d41b2", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 1.4 Sparse Lasso Regression (3 Variables)\n", + "Now suppose your boss tells you that he only trusts sparse models with few variables. Use the Lasso and choose the tuning parameter $\\lambda$ such that the model only considers $3$ out of the six variables. Report the coefficients and compare them to the coefficients from the optimal model from *Q1.3* and interpret. Compute the training and test MSE of this Lasso model and add it to the table from *Q1.2*. Interpret." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "67bf2ffa-71fb-4b68-b2af-1ac0cb1731be", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Lambda for 3 variables: 0.000128\n", + "Sparse Lasso Train MSE: 0.00522\n", + "Sparse Lasso Test MSE: 0.00925\n", + "\n", + "Sparse Lasso Coefficients (3 variables):\n", + " Variable Sparse_Lasso_Coefficient\n", + "0 DP 0.086918\n", + "1 CS 0.000000\n", + "2 ntis -0.000000\n", + "3 cay 0.481694\n", + "4 TS 0.023727\n", + "5 svar 0.000000\n", + "\n", + "Selected variables: ['DP', 'cay', 'TS']\n" + ] + } + ], + "source": [ + "# Find lambda that gives exactly 3 non-zero coefficients\n", + "# We'll search through different lambda values\n", + "lambda_test_range = np.logspace(-4, -1, 1000) # More focused range\n", + "n_features_list = []\n", + "\n", + "for alpha in lambda_test_range:\n", + " lasso_temp = Lasso(alpha=alpha, random_state=2, max_iter=10000)\n", + " lasso_temp.fit(X_train, y_train)\n", + " n_features = np.sum(lasso_temp.coef_ != 0)\n", + " n_features_list.append(n_features)\n", + "\n", + "# Find alpha that gives exactly 3 features\n", + "target_features = 3\n", + "suitable_alphas = [alpha for alpha, n_feat in zip(lambda_test_range, n_features_list) \n", + " if n_feat == target_features]\n", + "\n", + "if suitable_alphas:\n", + " # Use the middle value from suitable alphas\n", + " sparse_lambda = suitable_alphas[len(suitable_alphas)//2]\n", + " print(f\"Lambda for 3 variables: {sparse_lambda:.6f}\")\n", + " \n", + " # Fit sparse Lasso\n", + " lasso_sparse = Lasso(alpha=sparse_lambda, random_state=2, max_iter=10000)\n", + " lasso_sparse.fit(X_train, y_train)\n", + " \n", + " # Calculate MSE\n", + " y_pred_lasso_sparse_train = lasso_sparse.predict(X_train)\n", + " mse_lasso_sparse_train = mean_squared_error(y_train, y_pred_lasso_sparse_train)\n", + " \n", + " y_pred_lasso_sparse_test = lasso_sparse.predict(X_test)\n", + " mse_lasso_sparse_test = mean_squared_error(y_test, y_pred_lasso_sparse_test)\n", + " \n", + " print(f\"Sparse Lasso Train MSE: {mse_lasso_sparse_train:.5f}\")\n", + " print(f\"Sparse Lasso Test MSE: {mse_lasso_sparse_test:.5f}\")\n", + " \n", + " # Show coefficients\n", + " sparse_lasso_coefs = pd.DataFrame({\n", + " 'Variable': X_train.columns,\n", + " 'Sparse_Lasso_Coefficient': lasso_sparse.coef_\n", + " })\n", + " print(\"\\nSparse Lasso Coefficients (3 variables):\")\n", + " print(sparse_lasso_coefs)\n", + " \n", + " # Show which variables are selected\n", + " selected_vars = X_train.columns[lasso_sparse.coef_ != 0].tolist()\n", + " print(f\"\\nSelected variables: {selected_vars}\")\n", + " \n", + "else:\n", + " print(\"Could not find lambda that gives exactly 3 variables\")\n", + " # Use a reasonable approximation\n", + " sparse_lambda = 0.0125 # From R code\n", + " lasso_sparse = Lasso(alpha=sparse_lambda, random_state=2, max_iter=10000)\n", + " lasso_sparse.fit(X_train, y_train)\n", + " \n", + " y_pred_lasso_sparse_train = lasso_sparse.predict(X_train)\n", + " mse_lasso_sparse_train = mean_squared_error(y_train, y_pred_lasso_sparse_train)\n", + " \n", + " y_pred_lasso_sparse_test = lasso_sparse.predict(X_test)\n", + " mse_lasso_sparse_test = mean_squared_error(y_test, y_pred_lasso_sparse_test)\n", + " \n", + " print(f\"Sparse Lasso Train MSE: {mse_lasso_sparse_train:.5f}\")\n", + " print(f\"Sparse Lasso Test MSE: {mse_lasso_sparse_test:.5f}\")\n", + " \n", + " n_selected = np.sum(lasso_sparse.coef_ != 0)\n", + " print(f\"Number of selected variables: {n_selected}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "4b22788c-1bbf-45fb-b753-e0af54c6a35a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Model In-sample MSE Out-of-sample MSE\n", + " Linear Regression 0.00505 0.00861\n", + " Ridge Regression 0.00511 0.00878\n", + " Lasso Regression 0.00524 0.00916\n", + "Sparse Lasso (3 vars) 0.00522 0.00925\n" + ] + } + ], + "source": [ + "# Comprehensive results table\n", + "results_dict = {\n", + " 'Model': ['Linear Regression', 'Ridge Regression', 'Lasso Regression', 'Sparse Lasso (3 vars)'],\n", + " 'In-sample MSE': [mse_train_lm, mse_ridge_train, mse_lasso_train, mse_lasso_sparse_train],\n", + " 'Out-of-sample MSE': [mse_test_lm, mse_ridge_test, mse_lasso_test, mse_lasso_sparse_test]\n", + "}\n", + "\n", + "results_df = pd.DataFrame(results_dict)\n", + "results_df = results_df.round(5)\n", + "\n", + "print(results_df.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "2b173cd6-fcc2-4f19-a499-3fa93b5bdb6f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variable Linear Ridge Lasso_Optimal Lasso_Sparse\n", + " DP 0.083873 0.086305 0.085394 0.086918\n", + " CS 0.474950 0.064603 0.000000 0.000000\n", + " ntis -0.394479 -0.260392 -0.000000 -0.000000\n", + " cay 0.421456 0.389788 0.443235 0.481694\n", + " TS 0.631040 0.327515 0.000000 0.023727\n", + " svar 0.802650 0.156850 0.000000 0.000000\n" + ] + } + ], + "source": [ + "# Compare table of all coefficients\n", + "coef_comparison = pd.DataFrame({\n", + " 'Variable': X_train.columns,\n", + " 'Linear': model_all.coef_,\n", + " 'Ridge': ridge_optimal.coef_,\n", + " 'Lasso_Optimal': lasso_optimal.coef_,\n", + " 'Lasso_Sparse': lasso_sparse.coef_\n", + "}).round(6)\n", + "\n", + "print(coef_comparison.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "13177258-31dc-4ec0-8be6-dfa2fac34993", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# VISUALIZATION: COEFFICIENT PATHS - (EXTRA)\n", + "# Lasso coefficient path\n", + "lasso_path = Lasso(random_state=2, max_iter=10000)\n", + "lambda_path = np.logspace(-4, 0, 100)\n", + "coefs_lasso = []\n", + "\n", + "for alpha in lambda_path:\n", + " lasso_path.set_params(alpha=alpha)\n", + " lasso_path.fit(X_train, y_train)\n", + " coefs_lasso.append(lasso_path.coef_.copy())\n", + "\n", + "coefs_lasso = np.array(coefs_lasso)\n", + "\n", + "plt.figure(figsize=(12, 6))\n", + "\n", + "# Lasso path\n", + "plt.subplot(1, 2, 1)\n", + "for i, feature in enumerate(X_train.columns):\n", + " plt.plot(np.log(lambda_path), coefs_lasso[:, i], label=feature)\n", + "plt.xlabel('log(λ)')\n", + "plt.ylabel('Coefficients')\n", + "plt.title('Lasso Coefficient Paths')\n", + "plt.legend()\n", + "plt.grid(False)\n", + "\n", + "# Ridge path\n", + "ridge_path = Ridge()\n", + "coefs_ridge = []\n", + "\n", + "for alpha in lambda_path:\n", + " ridge_path.set_params(alpha=alpha)\n", + " ridge_path.fit(X_train, y_train)\n", + " coefs_ridge.append(ridge_path.coef_.copy())\n", + "\n", + "coefs_ridge = np.array(coefs_ridge)\n", + "\n", + "plt.subplot(1, 2, 2)\n", + "for i, feature in enumerate(X_train.columns):\n", + " plt.plot(np.log(lambda_path), coefs_ridge[:, i], label=feature)\n", + "plt.xlabel('log(λ)')\n", + "plt.ylabel('Coefficients')\n", + "plt.title('Ridge Coefficient Paths')\n", + "plt.legend()\n", + "plt.grid(False)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e715dd42-7021-466d-a9c1-0c0b4efeee78", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Question 2: Tree-Based Methods" + ] + }, + { + "cell_type": "markdown", + "id": "dfcf8271-d59c-4bb3-80e2-90eae36fb225", + "metadata": {}, + "source": [ + "### 2.1 Large Regression Tree\n", + "Fit a large regression tree using the training data. Report the number of terminal nodes as well as the most important variables for splitting the tree." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "a4cf00ec-7ad0-4f4d-8af5-07060fadf654", + "metadata": {}, + "outputs": [], + "source": [ + "# Loading needed packages for Question 2 tasks\n", + "from sklearn.tree import DecisionTreeRegressor, plot_tree, export_text\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from sklearn.model_selection import cross_val_score, validation_curve\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.metrics import mean_squared_error\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "0207f3f9-c389-4e50-abeb-5316857ab2da", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of nodes: 343\n", + "Number of terminal nodes (leaves): 172\n", + "Maximum depth: 16\n" + ] + } + ], + "source": [ + "# Fit a large regression tree (minimal restrictions to allow deep tree)\n", + "# In sklearn, we need to set parameters to allow a \"large\" tree similar to R's tree()\n", + "large_tree = DecisionTreeRegressor(\n", + " random_state=2,\n", + " min_samples_split=2, # Minimum samples to split (very low to allow deep tree)\n", + " min_samples_leaf=1, # Minimum samples in leaf (very low)\n", + " max_depth=None, # No depth limit initially\n", + " min_impurity_decrease=0 # No minimum impurity decrease required\n", + ")\n", + "\n", + "large_tree.fit(X_train, y_train)\n", + "\n", + "# Get tree information\n", + "n_nodes = large_tree.tree_.node_count\n", + "n_leaves = large_tree.get_n_leaves()\n", + "max_depth = large_tree.get_depth()\n", + "\n", + "print(f\"Number of nodes: {n_nodes}\")\n", + "print(f\"Number of terminal nodes (leaves): {n_leaves}\")\n", + "print(f\"Maximum depth: {max_depth}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "42246727-ebca-4415-b02b-2b07397b8b67", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature Importance (most important variables for splitting):\n", + " Variable Importance\n", + "4 TS 0.233574\n", + "0 DP 0.228339\n", + "5 svar 0.194723\n", + "1 CS 0.186572\n", + "3 cay 0.117219\n", + "2 ntis 0.039573\n", + "\n", + "Most important variable for splitting: TS\n" + ] + } + ], + "source": [ + "# Feature importance (equivalent to R's splitting importance)\n", + "feature_importance = pd.DataFrame({\n", + " 'Variable': X_train.columns,\n", + " 'Importance': large_tree.feature_importances_\n", + "}).sort_values('Importance', ascending=False)\n", + "\n", + "print(\"Feature Importance (most important variables for splitting):\")\n", + "print(feature_importance)\n", + "\n", + "# Most important variable\n", + "most_important_var = feature_importance.iloc[0]['Variable']\n", + "print(f\"\\nMost important variable for splitting: {most_important_var}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "62ec80eb-60d1-439a-b7c0-7aded7d6d15a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the tree (showing only top levels due to size)\n", + "plt.figure(figsize=(20, 12))\n", + "plot_tree(large_tree,\n", + " feature_names=X_train.columns,\n", + " filled=True,\n", + " max_depth=3, # Show only first 3 levels for readability\n", + " fontsize=10)\n", + "plt.title(\"Large Regression Tree (First 3 levels)\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3069027d-f53f-4348-8c0c-0885483dc8d9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 2.2 Train and Test MSE for the Large Tree\n", + "Compute the training and test MSE of the tree and add it to the table from *Q1.2*." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "04c40a06-a7b8-4539-93b1-8645428d37ad", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Large Tree Train MSE: 0.000000\n", + "Large Tree Test MSE: 0.045659\n" + ] + } + ], + "source": [ + "# Calculate training MSE\n", + "y_pred_large_tree_train = large_tree.predict(X_train)\n", + "mse_large_tree_train = mean_squared_error(y_train, y_pred_large_tree_train)\n", + "\n", + "# Calculate test MSE\n", + "y_pred_large_tree_test = large_tree.predict(X_test)\n", + "mse_large_tree_test = mean_squared_error(y_test, y_pred_large_tree_test)\n", + "\n", + "print(f\"Large Tree Train MSE: {mse_large_tree_train:.6f}\")\n", + "print(f\"Large Tree Test MSE: {mse_large_tree_test:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "581f7631-9c99-4143-b87e-11b43c243dd0", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 2.3. Cross-Validation for optimal Tree Pruning\n", + "Again set the seed to $2$ and use $5$-fold cross validation to determine the optimal pruning parameter for the large tree. Provide a plot of the prediction error against the size of the tree. Report the optimal tree size and provide a plot of the pruned tree. Which variables are important for splitting the pruned tree?" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "9801c9a3-85ba-4b70-82b6-a9bbbfcfaec4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Optimal tree size (number of leaves): 3\n", + "Optimal ccp_alpha: 0.000424\n" + ] + } + ], + "source": [ + "# Set seed for reproducibility\n", + "np.random.seed(2)\n", + "\n", + "# In sklearn, pruning is done by varying max_leaf_nodes or ccp_alpha\n", + "# We'll use cost complexity pruning (ccp_alpha) which is more similar to R's approach\n", + "\n", + "# First, get the cost complexity pruning path\n", + "path = large_tree.cost_complexity_pruning_path(X_train, y_train)\n", + "ccp_alphas, impurities = path.ccp_alphas, path.impurities\n", + "\n", + "# Remove the last alpha value (it would result in a tree with only root)\n", + "ccp_alphas = ccp_alphas[:-1]\n", + "\n", + "# Perform cross-validation for different alpha values\n", + "cv_scores = []\n", + "tree_sizes = []\n", + "\n", + "for ccp_alpha in ccp_alphas:\n", + " tree_temp = DecisionTreeRegressor(random_state=2, ccp_alpha=ccp_alpha)\n", + " tree_temp.fit(X_train, y_train)\n", + "\n", + " # Get tree size (number of leaves)\n", + " tree_sizes.append(tree_temp.get_n_leaves())\n", + "\n", + " # 5-fold cross-validation\n", + " scores = cross_val_score(tree_temp, X_train, y_train,\n", + " cv=5, scoring='neg_mean_squared_error')\n", + " cv_scores.append(-scores.mean()) # Convert back to positive MSE\n", + "\n", + "cv_scores = np.array(cv_scores)\n", + "tree_sizes = np.array(tree_sizes)\n", + "\n", + "# Find the optimal tree size (minimum CV error)\n", + "best_idx = np.argmin(cv_scores)\n", + "best_size = tree_sizes[best_idx]\n", + "best_alpha = ccp_alphas[best_idx]\n", + "\n", + "print(f\"Optimal tree size (number of leaves): {best_size}\")\n", + "print(f\"Optimal ccp_alpha: {best_alpha:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "0cdff5b0-b62d-4cba-814c-98c5e2e0e96d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib.ticker import MultipleLocator\n", + "\n", + "# Plot prediction error against tree size\n", + "plt.style.use('default')\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(tree_sizes, cv_scores, '-o', color='black', markersize=3)\n", + "plt.xlim(0, 20)\n", + "# X-Ticks in 2er Schritten (nur ganze Zahlen)\n", + "plt.gca().xaxis.set_major_locator(MultipleLocator(2))\n", + "plt.axvline(x=best_size, color='red', linestyle='--',\n", + " label=f'Optimal size = {best_size}')\n", + "plt.xlabel('Tree Size (Number of Leaves)')\n", + "plt.ylabel('Cross-Validation MSE')\n", + "# plt.title('Prediction Error vs Tree Size')\n", + "plt.legend()\n", + "plt.grid(False)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "46b0bf6c-d0a8-4899-aa37-48371f184581", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pruned tree statistics:\n", + " Number of leaves: 3\n", + " Maximum depth: 2\n" + ] + } + ], + "source": [ + "# Fit the pruned tree with optimal alpha\n", + "pruned_tree = DecisionTreeRegressor(random_state=2, ccp_alpha=best_alpha)\n", + "pruned_tree.fit(X_train, y_train)\n", + "\n", + "print(f\"Pruned tree statistics:\")\n", + "print(f\" Number of leaves: {pruned_tree.get_n_leaves()}\")\n", + "print(f\" Maximum depth: {pruned_tree.get_depth()}\")\n", + "\n", + "# Feature importance for pruned tree\n", + "pruned_importance = pd.DataFrame({\n", + " 'Variable': X_train.columns,\n", + " 'Importance': pruned_tree.feature_importances_\n", + "}).sort_values('Importance', ascending=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "36056171-5deb-4017-bc6b-a725ec969e97", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature Importance for Pruned Tree:\n", + " Variable Importance\n", + "5 svar 0.511469\n", + "4 TS 0.488531\n", + "1 CS 0.000000\n", + "0 DP 0.000000\n", + "3 cay 0.000000\n", + "2 ntis 0.000000\n", + "\n", + "Variables important for splitting the pruned tree: ['svar', 'TS']\n" + ] + } + ], + "source": [ + "print(\"Feature Importance for Pruned Tree:\")\n", + "print(pruned_importance)\n", + "\n", + "# Variables used in splitting (non-zero importance)\n", + "important_vars = pruned_importance[pruned_importance['Importance'] > 0]['Variable'].tolist()\n", + "print(f\"\\nVariables important for splitting the pruned tree: {important_vars}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "3e5e6f15-4ea5-470d-8d8d-9a92bba0b3f8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the pruned tree\n", + "plt.style.use('default')\n", + "plt.figure(figsize=(12, 8))\n", + "plot_tree(pruned_tree,\n", + " feature_names=X_train.columns,\n", + " filled=True,\n", + " fontsize=12)\n", + "# plt.title(\"Pruned Regression Tree\")\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "18a9a179-4226-4734-8bcf-554671ce85e9", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 2.4. Train and Test MSE for Pruned Tree\n", + "Compute the training and test MSE of the pruned tree and add it to the table from *Q1.2*." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "b46158c7-20ed-40ab-a9ed-f7ad577c976e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pruned Tree Train MSE: 0.004898\n", + "Pruned Tree Test MSE: 0.008131\n" + ] + } + ], + "source": [ + "# Calculate training MSE for pruned tree\n", + "y_pred_pruned_tree_train = pruned_tree.predict(X_train)\n", + "mse_pruned_tree_train = mean_squared_error(y_train, y_pred_pruned_tree_train)\n", + "\n", + "# Calculate test MSE for pruned tree\n", + "y_pred_pruned_tree_test = pruned_tree.predict(X_test)\n", + "mse_pruned_tree_test = mean_squared_error(y_test, y_pred_pruned_tree_test)\n", + "\n", + "print(f\"Pruned Tree Train MSE: {mse_pruned_tree_train:.6f}\")\n", + "print(f\"Pruned Tree Test MSE: {mse_pruned_tree_test:.6f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5a7e1a79-340c-4b61-9e74-e06b4f455904", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 2.5. Random Forest\n", + "Finally, use random forest to improve the predictions. Motivate your choice for the tuning parameters. Report the training and test MSE and add it to the table from *Q1.2*. Which variables are most important in the random forest?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "e9731a27-c811-4cf2-a53d-7d49a48e1d5b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random Forest Parameters:\n", + " Number of trees (n_estimators): 100\n", + " Features considered per split (max_features): 2\n", + " Out-of-bag score: -0.009214729335368155\n", + "\n", + "Parameter Justification:\n", + " - n_estimators=100: Sufficient trees for stable predictions without overfitting\n", + " - max_features=2: For regression, typically sqrt(p) or p/3, where p=6\n", + " sqrt(6) = 2, so 2 is reasonable\n" + ] + } + ], + "source": [ + "# Random Forest with tuned parameters\n", + "rf_model = RandomForestRegressor(\n", + " n_estimators=100, # corresponds tontree in R\n", + " max_features=2, # corresponds tomtry in R (number of features to consider at each split)\n", + " random_state=2,\n", + " n_jobs=-1, # Use all available cores\n", + " oob_score=True \n", + ")\n", + "\n", + "rf_model.fit(X_train, y_train)\n", + "\n", + "print(f\"Random Forest Parameters:\")\n", + "print(f\" Number of trees (n_estimators): {rf_model.n_estimators}\")\n", + "print(f\" Features considered per split (max_features): {rf_model.max_features}\")\n", + "print(f\" Out-of-bag score: {rf_model.oob_score_}\")\n", + "\n", + "# Parameter justification\n", + "print(f\"\\nParameter Justification:\")\n", + "print(f\" - n_estimators=100: Sufficient trees for stable predictions without overfitting\")\n", + "print(f\" - max_features=2: For regression, typically sqrt(p) or p/3, where p={len(X_train.columns)}\")\n", + "print(f\" sqrt({len(X_train.columns)}) = {int(np.sqrt(len(X_train.columns)))}, so 2 is reasonable\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "19ed5de3-bb54-45bb-bda4-2ebdaf457338", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/lib/python3.13/site-packages/sklearn/ensemble/_forest.py:611: UserWarning: Some inputs do not have OOB scores. This probably means too few trees were used to compute any reliable OOB estimates.\n", + " warn(\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot OOB error evolution (if OOB scoring is enabled)\n", + "# Note: In \"RandomForestRegressor\", \"oob_score_\" represents OOB-R^2 (Bestimmtheitsmaß), not the OOB-MSE.\n", + "# Note: sklearn doesn't store OOB evolution by default, so we'll create a simple version\n", + "oob_errors = []\n", + "for n_est in range(10, 101, 10):\n", + " rf_temp = RandomForestRegressor(n_estimators=n_est, max_features=2,\n", + " random_state=2, oob_score=True)\n", + " rf_temp.fit(X_train, y_train)\n", + " oob_errors.append(1 - rf_temp.oob_score_) # Convert R^2 to \"error\": (1 - R^2)\n", + "\n", + "best_idx = np.argmin(oob_errors)\n", + "best_size = list(range(10, 101, 10))[best_idx]\n", + "best_oob_error = oob_errors[best_idx]\n", + "\n", + "plt.style.use('default')\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(range(10, 101, 10), oob_errors, '-o', color='black', label=\"OOB Error\")\n", + "plt.axvline(x=best_size, color='red', linestyle='--',\n", + " label=f'Optimal size = {best_size}\\nOOB Error = {best_oob_error:.4f}')\n", + "\n", + "plt.xlabel('Number of Trees')\n", + "plt.ylabel('OOB Error')\n", + "# plt.title('Random Forest: OOB Error vs Number of Trees')\n", + "plt.grid(False)\n", + "plt.legend()\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "256e2c6c-3de3-426e-ac67-b9c5b92372d3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Random Forest Train MSE: 0.000739\n", + "Random Forest Test MSE: 0.012266\n" + ] + } + ], + "source": [ + "# Calculate training and test MSE\n", + "y_pred_rf_train = rf_model.predict(X_train)\n", + "mse_rf_train = mean_squared_error(y_train, y_pred_rf_train)\n", + "\n", + "y_pred_rf_test = rf_model.predict(X_test)\n", + "mse_rf_test = mean_squared_error(y_test, y_pred_rf_test)\n", + "\n", + "print(f\"\\nRandom Forest Train MSE: {mse_rf_train:.6f}\")\n", + "print(f\"Random Forest Test MSE: {mse_rf_test:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "0f6cf5fb-638d-4d3e-a25e-f3dbbdb7ef6f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Feature Importance (Random Forest):\n", + " Variable Importance\n", + "0 DP 0.188921\n", + "3 cay 0.173580\n", + "4 TS 0.169850\n", + "1 CS 0.163270\n", + "5 svar 0.161956\n", + "2 ntis 0.142423\n", + "\n", + "Most important variable in Random Forest: DP\n" + ] + } + ], + "source": [ + "# Feature importance\n", + "rf_importance = pd.DataFrame({\n", + " 'Variable': X_train.columns,\n", + " 'Importance': rf_model.feature_importances_\n", + "}).sort_values('Importance', ascending=False)\n", + "\n", + "print(\"Feature Importance (Random Forest):\")\n", + "print(rf_importance)\n", + "\n", + "# Most important variable\n", + "most_important_rf = rf_importance.iloc[0]['Variable']\n", + "print(f\"\\nMost important variable in Random Forest: {most_important_rf}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "3ae48b8e-d6ba-46dd-af32-ae3c263ebf04", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Variable importance plot\n", + "plt.style.use('default')\n", + "plt.figure(figsize=(10, 6))\n", + "plt.barh(range(len(rf_importance)), rf_importance['Importance'])\n", + "plt.yticks(range(len(rf_importance)), rf_importance['Variable'])\n", + "plt.xlabel('IncNodePurity')\n", + "# plt.title('Random Forest: Variable Importance Plot')\n", + "plt.gca().invert_yaxis() # Highest importance at top\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e9c70281-eccc-4ef8-a9d8-8dfd0d87f739", + "metadata": {}, + "source": [ + "The test set MSE associated with the bagged regression tree is 0.0186..." + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "72db51de-dec8-4303-b869-79ff8ebebe2f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Model In-sample MSE Out-of-sample MSE\n", + " Linear Regression 0.005047 0.008608\n", + " Ridge Regression 0.005111 0.008779\n", + " Lasso Regression 0.005235 0.009159\n", + " Sparse Lasso (3 vars) 0.005218 0.009250\n", + " Large Regression Tree 0.000000 0.045659\n", + "Pruned Regression Tree 0.004898 0.008131\n", + " Random Forest 0.000739 0.012266\n" + ] + } + ], + "source": [ + "# COMPREHENSIVE RESULTS TABLE\n", + "results_dict = {\n", + " 'Model': [\n", + " 'Linear Regression',\n", + " 'Ridge Regression',\n", + " 'Lasso Regression',\n", + " 'Sparse Lasso (3 vars)',\n", + " 'Large Regression Tree',\n", + " 'Pruned Regression Tree',\n", + " 'Random Forest'\n", + " ],\n", + " 'In-sample MSE': [\n", + " mse_train_lm,\n", + " mse_ridge_train,\n", + " mse_lasso_train,\n", + " mse_lasso_sparse_train,\n", + " mse_large_tree_train,\n", + " mse_pruned_tree_train,\n", + " mse_rf_train\n", + " ],\n", + " 'Out-of-sample MSE': [\n", + " mse_test_lm,\n", + " mse_ridge_test,\n", + " mse_lasso_test,\n", + " mse_lasso_sparse_test,\n", + " mse_large_tree_test,\n", + " mse_pruned_tree_test,\n", + " mse_rf_test\n", + " ]\n", + "}\n", + "\n", + "comprehensive_results = pd.DataFrame(results_dict).round(6)\n", + "\n", + "print(comprehensive_results.to_string(index=False))" + ] + }, + { + "cell_type": "markdown", + "id": "ccecdd74-9faf-4b7a-bd23-9d3f81dcda60", + "metadata": { + "tags": [], + "user_expressions": [] + }, + "source": [ + "### 2.6. Model selection analysis\n", + "Supposed it is the beginning of $2020$ and you have access to both the in-sample and out-of-sample errors for the different methods. Which model do you choose to predict stock markets in the future and why?" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "93579364-cb99-4373-9be9-0d7d09324a0c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Overfitting Analysis (Out-of-sample MSE - In-sample MSE):\n", + " Model Overfitting_Gap\n", + "5 Pruned Regression Tree 0.003233\n", + "0 Linear Regression 0.003561\n", + "1 Ridge Regression 0.003668\n", + "2 Lasso Regression 0.003924\n", + "3 Sparse Lasso (3 vars) 0.004032\n", + "6 Random Forest 0.011527\n", + "4 Large Regression Tree 0.045659\n", + "\n", + "Recommended Model for Future Predictions:\n", + " Model: Pruned Regression Tree\n", + " Out-of-sample MSE: 0.008131\n", + "\n", + "Justification:\n", + " - Good balance between complexity and generalization\n", + " - Pruning reduces overfitting compared to large tree\n", + " - Interpretable model structure\n" + ] + } + ], + "source": [ + "# Analysis of overfitting vs generalization\n", + "comprehensive_results['Overfitting_Gap'] = (comprehensive_results['Out-of-sample MSE'] -\n", + " comprehensive_results['In-sample MSE'])\n", + "\n", + "print(\"Overfitting Analysis (Out-of-sample MSE - In-sample MSE):\")\n", + "print(comprehensive_results[['Model', 'Overfitting_Gap']].sort_values('Overfitting_Gap'))\n", + "\n", + "# Find best model based on out-of-sample performance\n", + "best_model_idx = comprehensive_results['Out-of-sample MSE'].idxmin()\n", + "best_model = comprehensive_results.loc[best_model_idx, 'Model']\n", + "best_oos_mse = comprehensive_results.loc[best_model_idx, 'Out-of-sample MSE']\n", + "\n", + "print(f\"\\nRecommended Model for Future Predictions:\")\n", + "print(f\" Model: {best_model}\")\n", + "print(f\" Out-of-sample MSE: {best_oos_mse:.6f}\")\n", + "\n", + "print(f\"\\nJustification:\")\n", + "if best_model == 'Sparse Lasso (3 vars)':\n", + " print(\" - Lowest out-of-sample MSE indicates best generalization\")\n", + " print(\" - Sparse model is interpretable and less prone to overfitting\")\n", + " print(\" - Good balance between bias and variance\")\n", + "elif best_model == 'Pruned Regression Tree':\n", + " print(\" - Good balance between complexity and generalization\")\n", + " print(\" - Pruning reduces overfitting compared to large tree\")\n", + " print(\" - Interpretable model structure\")\n", + "else:\n", + " print(\" - Best out-of-sample performance\")\n", + " print(\" - Shows good generalization to unseen data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "cb947a8e-4a3b-496a-9eed-05605a7678eb", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualization of model performance comparison\n", + "plt.style.use('default')\n", + "plt.figure(figsize=(12, 8))\n", + "\n", + "models = comprehensive_results['Model']\n", + "train_mse = comprehensive_results['In-sample MSE']\n", + "test_mse = comprehensive_results['Out-of-sample MSE']\n", + "\n", + "x = np.arange(len(models))\n", + "width = 0.35\n", + "\n", + "plt.bar(x - width/2, train_mse, width, label='In-sample MSE', alpha=0.8)\n", + "plt.bar(x + width/2, test_mse, width, label='Out-of-sample MSE', alpha=0.8)\n", + "\n", + "plt.xlabel('Model Types')\n", + "plt.ylabel('MSE')\n", + "# plt.title('Model Performance Comparison: In-sample vs Out-of-sample MSE')\n", + "plt.xticks(x, models, rotation=45, ha='right')\n", + "plt.legend()\n", + "plt.grid(False)\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "raw", + "id": "2419d990-f478-4bda-8dbc-3144fbdfc917", + "metadata": {}, + "source": [ + "\\newpage" + ] + }, + { + "cell_type": "markdown", + "id": "81cbfae3-7385-40a2-8d0d-d7db7ae9a9f5", + "metadata": { + "editable": true, + "jp-MarkdownHeadingCollapsed": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## Appendix\n", + "The dataset contains the following variables:\n", + "\n", + " - **ret**: the quarterly return of the US stock market (a number of 0.01 is a $1\\%$ return per quarter)\n", + " - **date**: the date in format $yyyyq$ ($19941$ means the first quarter of $1994$)\n", + " - **DP**: the dividend to price ratio of the stock market (a valuation measure whether prices are high or low relative to the dividends payed)\n", + " - **CS**: the credit spread defined as the difference in yields between high rated corporate bonds (save investments) and low rated corporate bonds (corporations that might go bankrupt). CS measures the additional return investors require to invest in risky firms compared to well established firms with lower risks\n", + " - **ntis**: A measure for corporate issuing activity (IPO’s, stock repurchases,...)\n", + " - **cay**: a measure of the wealth-to-consumption ratio (how much is consumed relative to total wealth)\n", + " - **TS**: the term spread is the difference between the long term yield on government bonds and short term yields.\n", + " - **svar**: a measure for the stock market variance\n", + "\n", + "For a full description of the data, see *Welch und Goyal* ($2007$). Google is also very helpful if you are interested in obtaining more intuition about the variables.\n" + ] + }, + { + "cell_type": "markdown", + "id": "db90f03c-18a4-4e7f-a31c-56f206baf5cc", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, + "source": [ + "## References\n", + "\n", + "Welch, I. and A. Goyal ($2007$, $03$). A Comprehensive Look at The Empirical Performance of Equity\n", + "Premium Prediction. *The Review of Financial Studies 21* ($4$), $1455$ – $1508$." + ] + } + ], + "metadata": { + "date": " ", + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2_solution.pdf b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2_solution.pdf new file mode 100644 index 0000000..e39d2e7 Binary files /dev/null and b/Machine Learning for Economics and Finance/Problem Set 2/ProblemSet2_solution.pdf differ