diff --git a/Machine Learning for Economics and Finance/Problem Set 1/Problem_Set_1.ipynb b/Machine Learning for Economics and Finance/Problem Set 1/Problem_Set_1.ipynb index 0bd4c65..1e2bf6d 100644 --- a/Machine Learning for Economics and Finance/Problem Set 1/Problem_Set_1.ipynb +++ b/Machine Learning for Economics and Finance/Problem Set 1/Problem_Set_1.ipynb @@ -1,88 +1,126 @@ { "cells": [ { - "cell_type": "markdown", - "id": "5b78890f-9175-49cf-be30-04d1557b9fd0", + "cell_type": "raw", + "id": "77f76980-cc4f-4837-867f-218c92a7deae", "metadata": {}, "source": [ - "

Maschinelles Lernen für Wirtschaft und Finanzen

Universität Hamburg

\n", - "

Aufgabenserie 1

" + "\\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{\\today}\\\\\n", + "\\end{center}" ] }, { - "cell_type": "markdown", - "id": "66280676-a99a-4e20-98a7-c727bacc0dcd", - "metadata": { - "tags": [] - }, - "source": [ - "## Inhaltsverzeichnis:\n", - "* [Vorab](#Vorab)\n", - "* [Aufbau](#Aufbau)\n", - "* [Aufgabe 1](#Aufgabe-1)\n", - "* [Aufgabe 2](#Aufgabe-2)\n", - "* [Aufgabe 3](#Aufgabe-3)\n", - "* [Anhang](#Anhang)\n", - "* [Literatur](#Literatur)" - ] - }, - { - "cell_type": "markdown", - "id": "040dc2a4-910e-4cf5-9d1e-62fe7d0a8efd", + "cell_type": "raw", + "id": "2c3a2d4e-1e5a-4fe3-88be-abd9b9152def", "metadata": {}, "source": [ - "### Vorab \n", - "- Ziel dieses Tutorials ist es, einige der wichtigsten Konzepte zu üben, die in den ersten Wochen des ML Kurses behandelt werden." + "\\setcounter{secnumdepth}{0}" ] }, { "cell_type": "markdown", "id": "baac6966-d67a-4a66-acec-8ef6411c4f66", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "### Aufbau \n", + "## Setup\n", "\n", - "**Die Hauptaufgabe dieses Problemsets besteht darin, die Rendite des US-Aktienmarktes vorherzusagen.** Dazu verwenden wir den Datensatz ```stockmarketdata.RDS``` von Welch und Goyal (2007), der auf *OpenOlat* verfügbar ist. Der Datensatz enthält vierteljährliche Renditen des US-Aktienmarktes ($ret$) sowie mehrere andere Variablen, die von Finanzforschern vorgeschlagen wurden, um Aktienrenditen vorherzusagen. Eine Liste aller Variablen zusammen mit einer Beschreibung finden Sie im Anhang. Für das erste Quartal 1999 (*date = 19991*) enthält er beispielsweise Variablen wie die Rendite des Aktienmarktes ($ret_{t}$), das Dividenden-zu-Preis-Verhältnis ($DP_{t}$), den Kreditspread ($CS_{t}$) und so weiter. Da das Ziel darin besteht, Renditen im folgenden Quartal vorherzusagen, interessieren uns Modelle der Form\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", - "$ret_{t+1} = f (DP_{t}, CS_{t}, ...) + ϵ_{t+1}$\n", + "\\begin{equation*} \n", + " ret_{t+1} = f (DP_{t}, CS_{t}, ...) + ϵ_{t+1}\n", + "\\end{equation*} \n", "\n", - "Angenommen, Sie sind ein Vermögensverwalter und es ist Ende 1994, dh Sie haben alle Daten vor 1995 zur Verfügung, um Ihr Modell zu trainieren und zu validieren. Ihr Ziel ist es, ein Modell zu entwickeln, das nicht nur in der Stichprobe funktioniert, sondern auch zukünftige Renditen vorhersagen kann (nach 1995)." + "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": "markdown", - "id": "87902d82-5336-456b-bec8-403530c75f00", - "metadata": { - "tags": [] - }, + "cell_type": "raw", + "id": "156ee566-f0eb-4206-a443-34a63bc6dbd8", + "metadata": {}, "source": [ - "## Aufgabe 1: Vorbereitung und Analyse der Daten \n", - "\n", - "1. Zuerst müssen wir die Daten so ausrichten, dass eine Zeile, die die Merkmale für das Datum t enthält, die Rendite für das Datum $t + 1$ enthält (anstelle der Rendite für das Datum t, wie es derzeit der Fall ist). Dadurch wird sichergestellt, dass wir tatsächlich die Renditen für das nächste Quartal vorhersagen. Hierfür müssen wir die Zeitreihe der Rendite um einen Zeitraum nach vorne verschieben. (Hinweis: Verwenden Sie die Funktion ```shift()```, um eine neue Variable zum Dataframe hinzuzufügen, die die Rendite um einen Zeitraum verschiebt. Entfernen Sie anschließend die alte Zeitreihe der Rendite aus dem Dataframe.)\n", - " \n", - "2. Entfernen Sie alle Zeilen, die fehlende Werte im Datensatz enthalten. Google bietet viele verschiedene Möglichkeiten, wie Sie dies tun können. Wenn Sie Schwierigkeiten mit dieser Übung haben, tun Sie Folgendes: Verwenden Sie die kombination der Funktionen ```.isna().sum()``` auf das DataFrame, um die Summe aller Zeilen zu bestimmen, die fehlende Werte enthalten. Finden Sie die fehlenden Werte für diese Variablen durch Augeninspektion. Beginnen und beenden Sie die Stichprobe so, dass diese Zeilen mit fehlenden Werten nicht enthalten sind. Verwenden Sie anschließend erneut die Funktion ```.isna().sum()```, um sicherzustellen, dass Sie alle fehlenden Werte entfernt haben.\n", - "\n", - "3. Teilen Sie die Stichprobe in zwei Teile auf. Daten vor 1995 für das Training und die Validierung und Daten nach und einschließlich 1995 für das Out-of-Sample-Testen.\n", - "\n", - "4. Berechnen Sie die durchschnittliche vierteljährliche Rendite und ihre Standardabweichung in den Trainings- und Testdaten. Gibt es etwas, das erwähnenswert ist?\n", - "\n", - "5. Berechnen Sie die Korrelationsmatrix für die Trainingsdaten (einschließlich sowohl der Ergebnisse als auch der Merkmale). Gibt es etwas, das erwähnenswert ist?" + "\\newpage" ] }, { "cell_type": "markdown", "id": "c53eedac-cd76-4649-aebc-dc0c0d26c63e", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "### Vorbereitung: \n", - " - Einlesen und Grundanpassungen der ```stockmarketdata.rds``` Daten" + "## Preliminaries\n", + "\n", + " - Laden notwendiger Pakete und Einlesen der `stockmarketdata.rds` Datei" ] }, { "cell_type": "code", "execution_count": 1, "id": "44ad3d11-abe5-4366-91dc-ac319197b93c", - "metadata": {}, + "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": 2, + "id": "fafaf60e-c76e-45ae-aeed-8c8404bfb4b9", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { @@ -184,26 +222,28 @@ "4 19301.0 0.165884 -3.252345 0.010554 0.145496 NaN 0.0040 0.004662" ] }, - "execution_count": 1, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import warnings # Paket zum Unterdrücken von \"warnings\"\n", - "import pyreadr # Paket zum einlesen von RDS Datein - https://github.com/ofajardo/pyreadr\n", - "\n", + "# Setup of the data set\n", "df = pyreadr.read_r('stockmarketdata.rds')\n", - "df = df[None] # Extrahieren des verfügbaren Pandas-DataFrame Objekts.\n", + "df = df[None] # Extrahieren des verfügbaren pandas DataFrame Objekts.\n", "\n", - "df.head() # Zeige die ersten 5 Zeilen des DataFrames an." + "df.head() # Showing the first five rows of the DataFrame." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "6d3ccd77-5c88-4a7a-9225-efd36768d36d", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -314,22 +354,35 @@ "364 0.079049 " ] }, - "execution_count": 2, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import pandas as pd\n", - "\n", - "# Definierung einer Funktion, um die numerische Darstellung in das Format 'JJJJ-QX' zu erreichen.\n", + "# Definition of a custom function for reading and reformatting the \"date\" year-quarter time data.\n", "def convert_to_quarterly_date(numeric_date):\n", - " year = int(numeric_date) // 10 # Ziehen der Information des Jahres\n", - " quarter = int(numeric_date) % 10 # Ziehen der Information des Quartals\n", - " quarter_str = f'Q{quarter}' # Umwandling der \"float\" Quartal Daten zu \"string\" Format\n", - " return f'{year}-Q{quarter}' # Rückgabe der überschriebenen Schreibweise\n", + " \"\"\"\n", + " Converts a numeric date representing year and quarter into a quarterly date string in the format 'YYYY-Q'.\n", "\n", - "# Anwendung der Fuktion auf die Variable \"date\".\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()" @@ -337,17 +390,58 @@ }, { "cell_type": "markdown", - "id": "f36b947b-7ab0-46f5-82d6-e8df53ae591f", - "metadata": {}, + "id": "84ad3eb5-0717-4848-b531-268affb4bed4", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "### Aufgabe 1.1:\n", - " - Anpassung der Rendite Zeitdaten" + "### Exploration und Visualisierung des Datensatzes (extra) " ] }, { "cell_type": "code", - "execution_count": 3, - "id": "f3725bbe-1708-4559-b7b9-fa975a09083f", + "execution_count": 4, + "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": 5, + "id": "6ca834d5-7d59-4f87-a6f0-0325a0ed0295", "metadata": { "tags": [] }, @@ -373,168 +467,116 @@ " \n", " \n", " \n", - " date\n", - " DP\n", - " CS\n", - " ntis\n", - " cay\n", - " TS\n", - " svar\n", - " ret_next\n", + " count\n", + " mean\n", + " std\n", + " min\n", + " 25%\n", + " 50%\n", + " 75%\n", + " max\n", " \n", " \n", " \n", " \n", - " 360\n", - " 2019-Q1\n", - " -3.943400\n", - " 0.010258\n", - " -0.023230\n", - " -0.039336\n", - " 0.0017\n", - " 0.004651\n", - " 0.042688\n", + " ret\n", + " 365.0\n", + " 0.027951\n", + " 0.112073\n", + " -0.388075\n", + " -0.021158\n", + " 0.035569\n", + " 0.083677\n", + " 0.893713\n", " \n", " \n", - " 361\n", - " 2019-Q2\n", - " -3.960033\n", - " 0.010006\n", - " -0.012562\n", - " -0.033844\n", - " -0.0010\n", - " 0.003271\n", - " 0.017042\n", + " DP\n", + " 365.0\n", + " -3.391056\n", + " 0.470778\n", + " -4.493159\n", + " -3.797300\n", + " -3.373817\n", + " -3.042370\n", + " -1.903915\n", " \n", " \n", - " 362\n", - " 2019-Q3\n", - " -3.951689\n", - " 0.008505\n", - " -0.010862\n", - " -0.029529\n", - " -0.0019\n", - " 0.005517\n", - " 0.090143\n", + " CS\n", + " 365.0\n", + " 0.010621\n", + " 0.006545\n", + " 0.003243\n", + " 0.006502\n", + " 0.008524\n", + " 0.012306\n", + " 0.051673\n", " \n", " \n", - " 363\n", - " 2019-Q4\n", - " -4.015896\n", - " 0.008410\n", - " -0.007222\n", - " -0.033609\n", - " 0.0032\n", - " 0.002319\n", - " -0.193794\n", + " ntis\n", + " 365.0\n", + " 0.015432\n", + " 0.025043\n", + " -0.051831\n", + " 0.005041\n", + " 0.016489\n", + " 0.026695\n", + " 0.163522\n", " \n", " \n", - " 364\n", - " 2020-Q1\n", - " -3.769992\n", - " 0.012252\n", - " -0.007731\n", + " cay\n", + " 273.0\n", + " 0.001998\n", + " 0.022772\n", " -0.050141\n", - " 0.0058\n", - " 0.079049\n", - " NaN\n", + " -0.017083\n", + " 0.007632\n", + " 0.018796\n", + " 0.042897\n", + " \n", + " \n", + " TS\n", + " 365.0\n", + " 0.017220\n", + " 0.012820\n", + " -0.035000\n", + " 0.009000\n", + " 0.017500\n", + " 0.026100\n", + " 0.045300\n", + " \n", + " \n", + " svar\n", + " 365.0\n", + " 0.008814\n", + " 0.015153\n", + " 0.000370\n", + " 0.002430\n", + " 0.003984\n", + " 0.007887\n", + " 0.114436\n", " \n", " \n", "\n", "" ], "text/plain": [ - " date DP CS ntis cay TS svar \\\n", - "360 2019-Q1 -3.943400 0.010258 -0.023230 -0.039336 0.0017 0.004651 \n", - "361 2019-Q2 -3.960033 0.010006 -0.012562 -0.033844 -0.0010 0.003271 \n", - "362 2019-Q3 -3.951689 0.008505 -0.010862 -0.029529 -0.0019 0.005517 \n", - "363 2019-Q4 -4.015896 0.008410 -0.007222 -0.033609 0.0032 0.002319 \n", - "364 2020-Q1 -3.769992 0.012252 -0.007731 -0.050141 0.0058 0.079049 \n", + " 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", - " ret_next \n", - "360 0.042688 \n", - "361 0.017042 \n", - "362 0.090143 \n", - "363 -0.193794 \n", - "364 NaN " - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Verschiebung der Spalte Rendite um einen Zeitraum t+1.\n", - "df['ret_next'] = df['ret'].shift(-1)\n", - "\n", - "# Entfernen der Spalte \"ret\" aus dem DataFrame.\n", - "df.drop('ret', axis=1, inplace=True)\n", - "\n", - "df.tail()" - ] - }, - { - "cell_type": "markdown", - "id": "73330b81-0e43-43ac-911f-4086a9f9788f", - "metadata": {}, - "source": [ - "### Aufgabe 1.2:\n", - " - Anpassung fehlender Datenwerte im DataFrame" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "5c083b5f-f0d4-4fe5-8824-604a073c1215", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "date 0\n", - "DP 0\n", - "CS 0\n", - "ntis 0\n", - "cay 92\n", - "TS 0\n", - "svar 0\n", - "ret_next 1\n", - "dtype: int64" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Aufzählung aller NaN's (je Variable) des DataFrame.\n", - "df.isna().sum()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "2c0b17c8-a060-4687-8047-83abcf22ae46", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "data": { - "text/plain": [ - "date 0\n", - "DP 0\n", - "CS 0\n", - "ntis 0\n", - "cay 0\n", - "TS 0\n", - "svar 0\n", - "ret_next 0\n", - "dtype: int64" + " 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": 5, @@ -543,10 +585,279 @@ } ], "source": [ - "import numpy as np\n", + "df.describe().T # Descriptive Statistics of the Data" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b84929c4-7915-4f63-88b7-9200cec362c9", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[, ,\n", + " ],\n", + " [,\n", + " , ],\n", + " [, , ]],\n", + " dtype=object)" + ] + }, + "execution_count": 6, + "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), grid=False) # 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": 7, + "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": 7, + "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": 8, + "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": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isna().sum() # Enumeration of all NaNs (per variable)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = df.dropna() # Discarding all rows where variables have a NaN cell.\n", "\n", - "# Verwerfen aller Zeilen, bei denen Variablen eine NaN Zelle besitzen.\n", - "df = df.dropna()\n", "df.isna().sum()" ] }, @@ -554,18 +865,22 @@ "cell_type": "markdown", "id": "80e4160e-374a-43e1-a159-45077703658e", "metadata": { - "tags": [] + "tags": [], + "user_expressions": [] }, "source": [ - "### Aufgabe 1.3:\n", - " - Aufteilung des Datensatzes in zwei Teile. Training Datensatz mit Daten vor 1995 und Validierung Datensatz mit den Daten nach 1995 als Out-of-Sample Datensatz." + "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": 6, + "execution_count": 10, "id": "b27a4ab6-fb98-4d05-ad9e-340731f68d68", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -573,38 +888,44 @@ "name": "stdout", "output_type": "stream", "text": [ - "train_data besitzt 172 Beobachtung.\n", - "test_data besitzt 100 Beobachtung.\n" + "train_data contains 172 observations.\n", + "test_data contains 100 observations.\n" ] } ], "source": [ - "# Erstellen von Variablen mit der Information \"1994-Q4\" und der Position, welche als Schnittpunkt dienen.\n", - "split_date = '1994-Q4'\n", - "split_ind = df.index[df['date'] == split_date][0]\n", + "# 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", - "# Aufteilung der Daten zu \"train_data\" und \"test_data\".\n", - "train_data = df.loc[:split_ind] # für in-sample tests\n", - "test_data = df.loc[split_ind + 1:] # für out-of-sample tests\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 besitzt {len(train_data)} Beobachtung.\")\n", - "print(f\"test_data besitzt {len(test_data)} Beobachtung.\")" + "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": {}, + "metadata": { + "tags": [], + "user_expressions": [] + }, "source": [ - "### Aufgabe 1.4:\n", - " - Berechnung der durchschnittlichen vierteljährlichen Rendite und ihre Standardabweichung in den Trainings- und Testdaten." + "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": 7, + "execution_count": 11, "id": "a6833298-ab95-4596-85cd-5c4d9666037c", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -612,46 +933,51 @@ "name": "stdout", "output_type": "stream", "text": [ - "Trainingsdaten:\n", - "Durchschnittliche Rendite: 0.0306\n", - "Standardabweichung der Rendite: 0.0763\n", + "Train data:\n", + "Average quarterly return: 0.0306\n", + "Standard deviation of quarterly return: 0.0763\n", "\n", - "Testdaten:\n", - "Durchschnittliche Rendite: 0.0252\n", - "Standardabweichung der Rendite: 0.0823\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_next'].mean() # durchschnittliche vierteljährlichen Rendite (train_data)\n", - "train_std_ret = train_data['ret_next'].std() # Standardabweichung der vierteljährlichen Rendite (train_data)\n", + "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_next'].mean() # durchschnittliche vierteljährlichen Rendite (test_data)\n", - "test_std_ret = test_data['ret_next'].std() # Standardabweichung der vierteljährlichen Rendite (test_data)\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", - "# Ausgabe der Ergebnisse\n", - "print(\"Trainingsdaten:\")\n", - "print(f\"Durchschnittliche Rendite: {train_mean_ret:.4f}\")\n", - "print(f\"Standardabweichung der Rendite: {train_std_ret:.4f}\")\n", - "print(\"\\nTestdaten:\")\n", - "print(f\"Durchschnittliche Rendite: {test_mean_ret:.4f}\")\n", - "print(f\"Standardabweichung der Rendite: {test_std_ret:.4f}\")" + "# 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": {}, + "metadata": { + "user_expressions": [] + }, "source": [ - "### Aufgabe 1.5:\n", - " - Berechnung der Korrelationsmatrix für die Trainingsdaten (einschließlich sowohl der Ergebnisse als auch der Merkmale)." + "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": 8, + "execution_count": 12, "id": "1b390010-0b60-4bb0-873f-786c93fc34e5", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -659,59 +985,69 @@ "name": "stdout", "output_type": "stream", "text": [ - "Korrelationsmatrix für Trainingsdaten:\n", - " DP CS ntis cay TS svar ret_next\n", - "DP 1.00 0.38 -0.12 -0.21 -0.14 0.11 0.23\n", - "CS 0.38 1.00 -0.31 -0.02 0.21 0.22 0.18\n", - "ntis -0.12 -0.31 1.00 -0.40 -0.07 -0.12 -0.19\n", - "cay -0.21 -0.02 -0.40 1.00 0.46 0.04 0.17\n", - "TS -0.14 0.21 -0.07 0.46 1.00 0.08 0.16\n", - "svar 0.11 0.22 -0.12 0.04 0.08 1.00 0.13\n", - "ret_next 0.23 0.18 -0.19 0.17 0.16 0.13 1.00\n" + "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": [ - "# Berechnung der Korrelationsmatrix für die Trainingsdaten\n", - "train_cor_matrix = train_data.loc[:, train_data.columns != 'date'].corr(method='pearson') # \"date\" Spalte ausgelassen (Nur numerische Spalten)\n", + "# Calculation of the correlation matrix for the training data\n", "\n", - "# Ausgabe der Korrelationsmatrix. Werte auf zwei Nachkommastellen aufgerundet.\n", - "print(\"Korrelationsmatrix für Trainingsdaten:\")\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": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - " - **Zusatz**: Grafische Abbildung der Korrelationsmatrix" + "### Graphical representation of the correlation matrix (extra)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, "id": "e2727ae0-ab97-4ae4-b7cb-8b3e957ccda5", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "import seaborn as sns \n", - "import matplotlib.pyplot as plt \n", - "\n", - "fig, ax = plt.subplots(figsize=(10,8))\n", + "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", @@ -719,49 +1055,95 @@ " square=True,\n", " vmin=-1,\n", " vmax=1, \n", - " xticklabels='auto',\n", - " yticklabels='auto', \n", + " xticklabels='auto', # automatic X-variables\n", + " yticklabels='auto', # automatic X-variables\n", " fmt='0.2f',\n", " cmap=\"coolwarm\")\n", - "s.set_title('Korrelationsmatrix der trainingsdaten Variablen')\n", - "s.set(xlabel='Variablen', ylabel='Variablen')\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": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "## Aufgabe 2: Vorhersage von Renditen \n", + "## Question 2: Predicting returns\n", "\n", - "Nachdem die Daten bereinigt wurden, sind Sie bereit, das erste Modell zur Vorhersage von Renditen zu erstellen.\n", + "After having cleaned the data, you are ready to build the first model to predict returns\n", "\n", - "1. Verwenden Sie die Trainingsdaten, um ein lineares Modell unter Verwendung aller Variablen (stellen Sie sicher, dass Sie die Datumsvariable ausschließen) anzupassen. Welche Merkmale sind nützlich für die Vorhersage von Renditen?\n", - "\n", - "2. Berechnen Sie das R² in der Stichprobe sowie den mittleren quadratischen Fehler. Glauben Sie, dass vierteljährliche Renditen leicht vorhergesagt werden können?\n", - "\n", - "3. Verwenden Sie eine 5-fache Kreuzvalidierung, um eine Schätzung für den mittleren quadratischen Fehler außerhalb der Stichprobe zu erhalten. Vergleichen Sie diese Schätzung mit dem mittleren quadratischen Fehler in der Stichprobe aus \"Aufgabe 2.2\".\n", - "\n", - "4. Basierend auf Ihren Ergebnissen aus \"Aufgabe 2.1\" wählen Sie nur eine Teilmenge der Merkmale aus, um Ihr Modell zu verbessern. Welche Merkmale wählen Sie aus und warum? Berechnen Sie das R² in der Stichprobe sowie den mittleren quadratischen Fehler für dieses Modell und verwenden Sie eine 5-fache Kreuzvalidierung, um eine Schätzung für den mittleren quadratischen Fehler außerhalb der Stichprobe zu erhalten. Vergleichen Sie Ihre Ergebnisse mit dem Modell unter Verwendung aller Merkmale.\n", - "\n", - "5. Angenommen, Sie verwenden die beiden Modelle, die Sie erstellt haben, um vierteljährliche Renditen in den nächsten 25 Jahren vorherzusagen. Berechnen Sie die mittleren quadratischen Fehler außerhalb der Stichprobe für die Testdaten. Vergleichen Sie diese Fehler mit den Schätzungen für die außerhalb der Stichprobe erhaltenen Fehler aus der k-fachen Kreuzvalidierung. Interpretieren Sie." + "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": "db75b418-3630-4afe-a80f-b1f2893ba0c6", - "metadata": {}, + "id": "5460537b-6fde-422f-854a-d36e9cc36375", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "### Aufgabe 2.1:\n", - " - MLR unter Verwendung aller Variablen des Trainingdatensatzes" + "### 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": 10, - "id": "1d09cd12-bbe1-41a8-8b09-15588090f243", + "execution_count": 14, + "id": "593160b7-045b-4754-aed8-2119e37c0b93", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -771,7 +1153,7 @@ "\n", "\n", "\n", - " \n", + " \n", "\n", "\n", " \n", @@ -780,10 +1162,10 @@ " \n", "\n", "\n", - " \n", + " \n", "\n", "\n", - " \n", + " \n", "\n", "\n", " \n", @@ -803,7 +1185,7 @@ " \n", "\n", "\n", - " \n", + " \n", "\n", "\n", " \n", @@ -843,11 +1225,11 @@ "\\begin{center}\n", "\\begin{tabular}{lclc}\n", "\\toprule\n", - "\\textbf{Dep. Variable:} & ret\\_next & \\textbf{ R-squared: } & 0.129 \\\\\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:} & Sun, 14 Apr 2024 & \\textbf{ Prob (F-statistic):} & 0.000793 \\\\\n", - "\\textbf{Time:} & 20:47:06 & \\textbf{ Log-Likelihood: } & 210.80 \\\\\n", + "\\textbf{Date:} & Sat, 19 Oct 2024 & \\textbf{ Prob (F-statistic):} & 0.000793 \\\\\n", + "\\textbf{Time:} & 13:24:32 & \\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", @@ -857,7 +1239,7 @@ "\\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{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", @@ -886,11 +1268,11 @@ "\"\"\"\n", " OLS Regression Results \n", "==============================================================================\n", - "Dep. Variable: ret_next R-squared: 0.129\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: Sun, 14 Apr 2024 Prob (F-statistic): 0.000793\n", - "Time: 20:47:06 Log-Likelihood: 210.80\n", + "Date: Sat, 19 Oct 2024 Prob (F-statistic): 0.000793\n", + "Time: 13:24:32 Log-Likelihood: 210.80\n", "No. Observations: 172 AIC: -407.6\n", "Df Residuals: 165 BIC: -385.6\n", "Df Model: 6 \n", @@ -898,7 +1280,7 @@ "==============================================================================\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", + "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", @@ -919,56 +1301,1633 @@ "\"\"\"" ] }, - "execution_count": 10, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import statsmodels.api as sm\n", - "# Alle nutzen außer - entfernen der \"Unabhängige Variablen\" und der \"qualitativen variablen /bzw. level Variablen\" - hier aber die \"date\" Variable!\n", + "# 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", - "# Möglichkeit 1 - doch ohne weitere Anpassung problematisch:\n", - "#X = train_data.drop(columns=['date','ret_next'])\n", - "# DOCH dann fehlt aber der Intercept in der summary !!\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", - "# Möglichkeit 2:\n", - "#X = pd.DataFrame({'intercept': np.ones(train_data.shape[0]), \n", - "# 'DP': train_data['DP'],\n", - "# 'CS': train_data['CS'],\n", - "# 'ntis': train_data['ntis'],\n", - "# 'cay': train_data['cay'],\n", - "# 'TS': train_data['TS'],\n", - "# 'svar': train_data['svar']\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", - "# Möglichkeit 3: finale Lösung - Füllung der Exogenen Variable\n", - "# Erstellen der Modell-Matrix:\n", - "X = train_data.drop(columns=['date','ret_next']) # Entfernen der endogenen und qualitativen Variablen\n", - "X.insert(0, 'intercept', np.ones(train_data.shape[0]))\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": 15, + "id": "2c357768-0756-4523-a44d-0ccb87cb9c2a", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
OLS Regression Results
Dep. Variable: ret_next R-squared: 0.129Dep. Variable: ret R-squared: 0.129
Model: OLS Adj. R-squared: 0.097Method: Least Squares F-statistic: 4.063
Date: Sun, 14 Apr 2024 Prob (F-statistic): 0.000793Date: Sat, 19 Oct 2024 Prob (F-statistic): 0.000793
Time: 20:47:06 Log-Likelihood: 210.80Time: 13:24:32 Log-Likelihood: 210.80
No. Observations: 172 AIC: -407.6 coef std err t P>|t| [0.025 0.975]
intercept 0.2968 0.097 3.063 0.003 0.106 0.488Intercept 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
\n", + "\n", + "\n", + " \n", + "\n", + "\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: Sat, 19 Oct 2024 Prob (F-statistic): 0.000793
Time: 13:24:32 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:} & Sat, 19 Oct 2024 & \\textbf{ Prob (F-statistic):} & 0.000793 \\\\\n", + "\\textbf{Time:} & 13:24:32 & \\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: Sat, 19 Oct 2024 Prob (F-statistic): 0.000793\n", + "Time: 13:24:32 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": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Creating the model matrix:\n", "\n", - "y = train_data['ret_next'] # Setzen der Endogene Variable\n", - "model = sm.OLS(y, X) # OLS Modell füllen.\n", - "fit_lm = model.fit() # Fit des univariaten linearen Regressionsmodells.\n", - "fit_lm.summary() # Ausgabe der Modellstatistik" + "# 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": 16, + "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": 16, + "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": 17, + "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": 17, + "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": 18, + "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": 19, + "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": 20, + "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.00809389916608189\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": 21, + "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": 22, + "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": 23, + "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": 24, + "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": 24, + "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": 25, + "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": 26, + "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": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "X_train_preprocessed.std(axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "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": [] + "tags": [], + "user_expressions": [] }, "source": [ - "### Aufgabe 2.2:\n", - " - $R^{2}$-Wert des Trainingdatatensatzes." + "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": 11, + "execution_count": 28, "id": "69ae4d7d-16a9-436a-9cfc-1b087a563db8", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -976,71 +2935,44 @@ "name": "stdout", "output_type": "stream", "text": [ - "Das train_data R^2 beträgt: 0.1287\n" + "In-sample (all) R^2: 0.1321\n", + "In-sample (all) MSE: 0.00441\n" ] } ], "source": [ - "print(f\"Das train_data R^2 beträgt: {fit_lm.rsquared:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "id": "d72a3a95-c163-4cbc-8bbb-0dd02b2c8902", - "metadata": {}, - "source": [ - " - Bestimmung des in-sample MSE Wertes." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "3c0eb59d-dc8a-4d44-bef2-1b2177a7166f", - "metadata": { - "tags": [] - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "in-sample (MSE): 0.0050\n" - ] - } - ], - "source": [ - "#from sklearn.metrics import mean_squared_error # kann benutzt werden\n", - "#Oder wie hier, selbst definiert werden:\n", + "y_pred_train = model_all.predict(X_train) # In-sample predictions.\n", "\n", - "##### Computing the MSE for the Auto Data: #####\n", - "# Compute predicted values y_head for training data\n", - "y_head = fit_lm.predict(X)\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", - "# Function to compute the mean squared error (MSE)\n", - "def MSE(y, y_head):\n", - " return np.mean((y - y_head)**2)\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", - "# Compute the mean squared error in the training data\n", - "MSE_train_data = MSE(train_data['ret_next'], y_head)\n", - "print(f\"in-sample (MSE): {MSE_train_data:.4f}\")" + "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": [] + "tags": [], + "user_expressions": [] }, "source": [ - "### Aufgabe 2.3:\n", - " - Vergleich des out-of-sample MSE's mit dem 5-fach Kreuzvalidierung MSE's:" + "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": 13, - "id": "aebbb2ff-9ddb-4e03-9d25-c9cc6e632d6e", + "execution_count": 29, + "id": "642f6798-71ac-479e-bd0f-be0f7ab2ce49", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -1048,56 +2980,48 @@ "name": "stdout", "output_type": "stream", "text": [ - "Out-of-sample MSE: 0.0086\n", - "Cross-validated MSE: 0.0081\n" + "In-sample (all) cv.MSE: 0.00521\n" ] } ], "source": [ - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.metrics import mean_squared_error\n", - "import numpy as np\n", - "\n", - "# Separate features and target variables\n", - "X_train = train_data.drop(columns=['ret_next','date'])\n", - "y_train = train_data['ret_next']\n", - "X_test = test_data.drop(columns=['ret_next','date'])\n", - "y_test = test_data['ret_next']\n", - "\n", - "# Train the model on the training data\n", - "model = LinearRegression()\n", - "model.fit(X_train, y_train)\n", - "\n", - "# Predict on the test data\n", - "y_pred_test = model.predict(X_test)\n", - "\n", - "# Calculate the mean squared error (MSE) on the test data\n", - "mse_test = mean_squared_error(y_test, y_pred_test)\n", - "print(f\"Out-of-sample MSE: {mse_test:.4f}\")\n", - "\n", - "# Perform 5-fold cross-validation and calculate the mean of MSEs\n", - "mse_cv = -cross_val_score(model, X_train, y_train, scoring='neg_mean_squared_error', cv=5).mean()\n", - "print(f\"Cross-validated MSE: {mse_cv:.4f}\")" + "# 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": [] + "tags": [], + "user_expressions": [] }, "source": [ - "### Aufgabe 2.4:\n", - " - Bestimmung des out-of-sample MSE's und mittel 5-fache Kreuzvalidierung den Cross-validation MSE\n", - " - Auswertung der Modellgüte mittels verschiedener variablen Kombinationen." + "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": 14, + "execution_count": 30, "id": "c1761dc0-3714-457d-89e4-d19d00214aaf", "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, "tags": [] }, "outputs": [ @@ -1105,51 +3029,193 @@ "name": "stdout", "output_type": "stream", "text": [ - "In-sample R^2 mit der Variable (DP): 0.0541\n", - "In-sample MSE mit der Variable (DP): 0.0055\n", - "Out-of-sample MSE bei 5-fold cross-validation mit der Variable (DP): 0.0056\n" + "In-sample (DP) R^2: 0.0541\n", + "In-sample (DP) MSE: 0.0055\n", + "In-sample (DP) cv.MSE: 0.00521\n" ] } ], "source": [ - "import pandas as pd\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.metrics import mean_squared_error, r2_score\n", + "# Setting up a new regression model.\n", + "# Pre-selecting the exogenous variable.\n", + "selected_features1 = ['DP']\n", "\n", - "# Select subset of features\n", - "selected_features = ['DP']\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", - "# Separate features and target variables for selected features\n", - "X_train_selected = train_data[selected_features]\n", - "X_test_selected = test_data[selected_features]\n", - "y_train = train_data['ret_next']\n", - "y_test = test_data['ret_next']\n", + "# Training the regression model.\n", + "model_DP = LinearRegression()\n", + "model_DP.fit(X_train_DP_selected, y_train_DP)\n", "\n", - "# Train the model on the training data using selected features\n", - "model_selected = LinearRegression()\n", - "model_selected.fit(X_train_selected, y_train)\n", + "# In-sample predictions.\n", + "y_pred_train_DP_selected = model_DP.predict(X_train_DP_selected)\n", "\n", - "# Predict on the training data\n", - "y_pred_train_selected = model_selected.predict(X_train_selected)\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", - "# Compute in-sample R^2\n", - "r2_in_sample_selected = r2_score(y_train, y_pred_train_selected)\n", - "print(f\"In-sample R^2 mit der Variable (DP): {r2_in_sample_selected:.4f}\")\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", - "# Compute mean squared error (MSE) for the training data\n", - "mse_train_selected = mean_squared_error(y_train, y_pred_train_selected)\n", - "print(f\"In-sample MSE mit der Variable (DP): {mse_train_selected:.4f}\")\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,\n", + " y_train,\n", + " scoring='neg_mean_squared_error',\n", + " cv=KFold(n_splits=5, shuffle=True, random_state=1)).mean()\n", "\n", - "# Perform 5-fold cross-validation and compute out-of-sample MSE for the selected features\n", - "mse_cv_selected = -cross_val_score(model_selected, X_train_selected, y_train, scoring='neg_mean_squared_error', cv=5).mean()\n", - "print(f\"Out-of-sample MSE bei 5-fold cross-validation mit der Variable (DP): {mse_cv_selected:.4f}\")" + "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": 15, + "execution_count": 31, "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.00521\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,\n", + " y_train,\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_DP_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": 32, + "id": "4f75d9ee-5a4a-4c8b-8a43-61846329db6f", + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [ + "hide_code" + ] + }, + "outputs": [], + "source": [ + "y_pred_TRAIN = ridge_model.predict(X_train)\n", + "y_pred_TEST = ridge_model.predict(X_test)\n", + "\n", + "#y_pred_test_all_selected = model_all.predict(X_train) # Out-of-sample Schätzungen\n", + "mse_test_all_selected = mean_squared_error(y_train, y_pred_TRAIN) # Out-of-sample MSE bestimmen\n", + "#print(f\"Out-of-sample (alle) MSE: {mse_train_DP_selected:.5f}\")\n", + "\n", + "##y_pred_test_DP_selected = model_DP.predict(X_train) # Out-of-sample Schätzungen\n", + "#mse_test_DP_selected = mean_squared_error(y_train, y_pred_train_DP_selected) # Out-of-sample MSE bestimmen\n", + "#print(f\"Out-of-sample (DP) MSE: {mse_train_DP_selected:.5f}\")\n", + "\n", + "##y_pred_test_DPcay_selected = model_DPcay.predict(X_train) # Out-of-sample Schätzungen\n", + "#mse_test_DPcay_selected = mean_squared_error(y_train, y_pred_train_DPcay_selected) # Out-of-sample MSE bestimmen\n", + "#print(f\"Out-of-sample (DPcay) MSE: {mse_train_DPcay_selected:.5f}\")\n", + "\n", + "\n", + "## Perform 5-fold cross-validation and calculate the out-of-sample 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", + "#print(f\"\\nOut-of-sample (alle) cv.MSE: {test_all_cv_mse:.9f}\")\n", + "\n", + "\n", + "## Perform 5-fold cross-validation and calculate the out-of-sample MSE\n", + "test_DP_cv_mse = -cross_val_score(model_DP, \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", + "#print(f\"Out-of-sample (DP) cv.MSE: {test_DP_cv_mse:.9f}\")\n", + "\n", + "\n", + "## Perform 5-fold cross-validation and calculate the out-of-sample MSE\n", + "test_DPcay_cv_mse = -cross_val_score(model_DPcay, \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", + "#print(f\"Out-of-sample (DP+cay) cv.MSE: {test_DPcay_cv_mse:.9f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "1830488d-ddb6-4dd0-beda-aeb0d0647f59", "metadata": { "tags": [] }, @@ -1158,77 +3224,58 @@ "name": "stdout", "output_type": "stream", "text": [ - "In-sample R^2 mit den Variablen (DP+cay): 0.1040\n", - "In-sample MSE mit den Variablen (DP+cay): 0.0052\n", - "Out-of-sample MSE bei 5-fold cross-validation mit den Variablen (DP+cay): 0.0053\n" + " Model In-sample MSE In-sample cv.MSE Out-of-sample cv.MSE\n", + "0 DP 0 0.005213 0.008361\n", + "1 DP+cay 0 0.005213 0.008361\n", + "2 All predictors 0 0.005213 0.008361\n" ] } ], "source": [ - "import pandas as pd\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import cross_val_score\n", - "from sklearn.metrics import mean_squared_error, r2_score\n", + "# Define the data\n", + "model_data_table = {\n", + "\"Model\": ['DP', 'DP+cay', 'All predictors'],\n", + "\"In-sample MSE\": ['0', '0', '0'],\n", + "\"In-sample cv.MSE\": [train_DP_cv_mse, train_DP_cv_mse, train_all_cv_mse],\n", + "\"Out-of-sample cv.MSE\": [test_DP_cv_mse, test_DPcay_cv_mse, test_all_cv_mse]\n", + "}\n", + "# Create a DataFrame\n", + "mdt = pd.DataFrame(model_data_table)\n", "\n", - "# Select subset of features\n", - "selected_features = ['DP', 'cay']\n", - "\n", - "# Separate features and target variables for selected features\n", - "X_train_selected = train_data[selected_features]\n", - "X_test_selected = test_data[selected_features]\n", - "y_train = train_data['ret_next']\n", - "y_test = test_data['ret_next']\n", - "\n", - "# Train the model on the training data using selected features\n", - "model_selected = LinearRegression()\n", - "model_selected.fit(X_train_selected, y_train)\n", - "\n", - "# Predict on the training data\n", - "y_pred_train_selected = model_selected.predict(X_train_selected)\n", - "\n", - "# Compute in-sample R^2\n", - "r2_in_sample_selected = r2_score(y_train, y_pred_train_selected)\n", - "print(f\"In-sample R^2 mit den Variablen (DP+cay): {r2_in_sample_selected:.4f}\")\n", - "\n", - "# Compute mean squared error (MSE) for the training data\n", - "mse_train_selected = mean_squared_error(y_train, y_pred_train_selected)\n", - "print(f\"In-sample MSE mit den Variablen (DP+cay): {mse_train_selected:.4f}\")\n", - "\n", - "# Perform 5-fold cross-validation and compute out-of-sample MSE for the selected features\n", - "mse_cv_selected = -cross_val_score(model_selected, X_train_selected, y_train, scoring='neg_mean_squared_error', cv=5).mean()\n", - "print(f\"Out-of-sample MSE bei 5-fold cross-validation mit den Variablen (DP+cay): {mse_cv_selected:.4f}\")" + "# Display the DataFrame\n", + "print(mdt)" + ] + }, + { + "cell_type": "raw", + "id": "ee76d361-883a-4e74-9352-df110c6f093b", + "metadata": {}, + "source": [ + "\\newpage" ] }, { "cell_type": "markdown", "id": "df4f7f10-2779-43ab-a7b0-3bd1b3f15b0c", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "## Aufgabe 3: Vorhersage der Richtung des Aktienmarktes \n", + "## Question 3: Predicting the direction of the stock market\n", "\n", - "Statt Renditen quantitativ vorherzusagen, nehmen Sie nun an, dass Sie die Richtung des Aktienmarktes vorhersagen möchten, d. h. ob die Aktien steigen oder fallen. Basierend auf diesen Vorhersagen möchten Sie entweder in Aktien investieren oder nicht.\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. Erstellen Sie eine neue Variable sowohl in den Trainings- als auch in den Testdaten, die 1 ist, wenn die Rendite größer als Null ist, und 0 sonst.\n", - "\n", - "2. Berechnen Sie den Anteil positiver Aktienrenditen sowohl in den Trainings- als auch in den Testdaten.\n", - "\n", - "3. Passen Sie eine logistische Regression an die Trainingsdaten an, um die Richtung des Aktienmarktes vorherzusagen (stellen Sie sicher, dass Sie die Datumsvariable und die alte quantitative Renditevariable ausschließen). Welche Merkmale sind nützliche Prädiktoren? Berechnen Sie die In-Sample-Genauigkeit und die Fehlerquote. Glauben Sie, dass Sie ein gutes Modell zur Vorhersage der Richtung des Aktienmarktes erstellt haben?\n", - "\n", - "4. Angenommen, Sie verwenden das von Ihnen erstellte Modell, um die Richtung des Aktienmarktes in den nächsten 25 Jahren vorherzusagen. Berechnen Sie die außerhalb der Stichprobe liegende Genauigkeit und Fehlerquote für die Testdaten. Vergleichen Sie diese Ergebnisse mit den In-Sample-Statistiken. Glauben Sie, dass Ihr Modell gut außerhalb der Stichprobe funktioniert? Interpretieren Sie die Ergebnisse. " - ] - }, - { - "cell_type": "markdown", - "id": "309698e2-9577-43ac-84c8-12edad93f8aa", - "metadata": {}, - "source": [ - "### Aufgabe 3.1:\n", - " - Erstelle eine neue Variable, die 1 ist, wenn die Rendite größer als Null ist, und 0 sonst." + "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": 16, + "execution_count": 34, "id": "b28e213d-9ca8-4e33-a15f-feae07d73a18", "metadata": { "tags": [] @@ -1256,129 +3303,114 @@ " \n", " \n", " date\n", + " ret\n", " DP\n", " CS\n", " ntis\n", " cay\n", " TS\n", " svar\n", - " ret_next\n", - " return_positive\n", " \n", " \n", " \n", " \n", " 92\n", " 1952-Q1\n", + " 1\n", " -2.842696\n", " 0.005328\n", " 0.032094\n", " -0.010595\n", " 0.0104\n", " 0.002102\n", - " 0.038275\n", - " 1\n", " \n", " \n", " 93\n", " 1952-Q2\n", + " 0\n", " -2.845711\n", " 0.005425\n", " 0.027731\n", " 0.000055\n", " 0.0089\n", " 0.001660\n", - " -0.004980\n", - " 0\n", " \n", " \n", " 94\n", " 1952-Q3\n", + " 1\n", " -2.828741\n", " 0.005521\n", " 0.031038\n", " -0.000695\n", " 0.0106\n", " 0.001076\n", - " 0.102295\n", - " 1\n", " \n", " \n", " 95\n", " 1952-Q4\n", + " 0\n", " -2.936193\n", " 0.005231\n", " 0.026535\n", " -0.015950\n", " 0.0070\n", " 0.001753\n", - " -0.035683\n", - " 0\n", " \n", " \n", " 96\n", " 1953-Q1\n", + " 0\n", " -2.886819\n", " 0.004354\n", " 0.024013\n", " -0.019021\n", " 0.0093\n", " 0.001574\n", - " -0.032102\n", - " 0\n", " \n", " \n", "\n", "" ], "text/plain": [ - " date DP CS ntis cay TS svar \\\n", - "92 1952-Q1 -2.842696 0.005328 0.032094 -0.010595 0.0104 0.002102 \n", - "93 1952-Q2 -2.845711 0.005425 0.027731 0.000055 0.0089 0.001660 \n", - "94 1952-Q3 -2.828741 0.005521 0.031038 -0.000695 0.0106 0.001076 \n", - "95 1952-Q4 -2.936193 0.005231 0.026535 -0.015950 0.0070 0.001753 \n", - "96 1953-Q1 -2.886819 0.004354 0.024013 -0.019021 0.0093 0.001574 \n", - "\n", - " ret_next return_positive \n", - "92 0.038275 1 \n", - "93 -0.004980 0 \n", - "94 0.102295 1 \n", - "95 -0.035683 0 \n", - "96 -0.032102 0 " + " 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": 16, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "warnings.filterwarnings('ignore') # to hide the warning message - it's fixed here.\n", - "# Erstelle eine neue Variable, die 1 ist, wenn die Rendite größer als Null ist, und 0 sonst\n", + "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", - "# raises a Warning message: A value is trying to be set on a copy of a slice from a DataFrame.\n", - "#train_data['return_positive'] = train_data['ret_next'].apply(lambda x: 1 if x > 0 else 0)\n", - "#test_data['return_positive'] = test_data['ret_next'].apply(lambda x: 1 if x > 0 else 0)\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", - "# .iloc solution to fix the warning:\n", - "train_data.loc[:, 'return_positive'] = train_data['ret_next'].apply(lambda x: 1 if x > 0 else 0)\n", - "test_data.loc[:, 'return_positive'] = test_data['ret_next'].apply(lambda x: 1 if x > 0 else 0)\n", - "\n", - "train_data.head()" + "train_data_class.head()" ] }, { "cell_type": "markdown", "id": "e2c9d767-2c2a-4937-85f4-823ff387e11f", - "metadata": {}, + "metadata": { + "user_expressions": [] + }, "source": [ - "### Aufgabe 3.2: \n", - " - Anteil der positiven Aktienrenditen in den Trainingsdaten & Testdaten" + "2. Compute the proportion of positive stock returns in both, the training and test data." ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 35, "id": "340c54c5-8db6-4fce-ab35-8a782ad501c7", "metadata": { "tags": [] @@ -1388,34 +3420,35 @@ "name": "stdout", "output_type": "stream", "text": [ - "Anteil der positiven Aktienrenditen in den Trainingsdaten: 0.69\n", - "Anteil der positiven Aktienrenditen in den Testdaten: 0.73\n" + "In-sample proportion of positive stock returns: 0.686\n", + "Out-of-Sample proportion of positive stock returns: 0.730\n" ] } ], "source": [ - "# Berechne den Anteil der positiven Aktienrenditen in den Trainingsdaten\n", - "positive_proportion_train = train_data['return_positive'].mean()\n", - "print(f\"Anteil der positiven Aktienrenditen in den Trainingsdaten: {positive_proportion_train:.2f}\")\n", + "# 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", - "# Berechne den Anteil der positiven Aktienrenditen in den Testdaten\n", - "positive_proportion_test = test_data['return_positive'].mean()\n", - "print(f\"Anteil der positiven Aktienrenditen in den Testdaten: {positive_proportion_test:.2f}\")" + "# 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": {}, + "metadata": { + "user_expressions": [] + }, "source": [ - "### Aufgabe 3.3:\n", - " - Logistische Regression über die Trainingsdaten, um die Richtung des Aktienmarktes vorherzusagen." + "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": 18, - "id": "d9b63103-441a-4ecc-b75f-d03d8c948221", + "execution_count": 36, + "id": "b72adcc7-0cd5-4d9d-8c65-1bad74c6dfcb", "metadata": { "tags": [] }, @@ -1424,52 +3457,50 @@ "name": "stdout", "output_type": "stream", "text": [ - "In-sample accuracy: 0.69\n", - "In-sample error rate: 0.31\n", - "Useful predictors: Index(['DP', 'CS', 'ntis', 'cay', 'TS', 'svar'], dtype='object')\n" + "Train data:\n", + "In-sample accuracy: 0.6860\n", + "In-sample error rate: 0.3140\n" ] } ], "source": [ - "from sklearn.linear_model import LogisticRegression\n", - "from sklearn.metrics import accuracy_score, confusion_matrix\n", + "# Aufsetzen eines neuen Regressionsmodells\n", "\n", - "# Separate features and target variables\n", - "X_train = train_data.drop(columns=['return_positive', 'date', 'ret_next'])\n", - "y_train = train_data['return_positive']\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", - "# Train the logistic regression model\n", + "# Regressionsmodell trainieren\n", "model = LogisticRegression()\n", - "model.fit(X_train, y_train)\n", + "model.fit(X_train_class, y_train_class)\n", "\n", - "# Predict on the training data\n", - "y_pred_train = model.predict(X_train)\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", - "# Compute in-sample accuracy and error rate\n", - "accuracy = accuracy_score(y_train, y_pred_train)\n", - "error_rate = 1 - accuracy\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(f\"In-sample accuracy: {accuracy:.2f}\")\n", - "print(f\"In-sample error rate: {error_rate:.2f}\")\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", - "# Compute useful predictors\n", - "coefficients = model.coef_[0]\n", - "useful_predictors = X_train.columns[coefficients != 0]\n", - "print(\"Useful predictors:\", useful_predictors) # Variablen die nicht-null Koeffizienten sind, sind nützlich." + "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": {}, + "metadata": { + "user_expressions": [] + }, "source": [ - "### Aufgabe 3.4:\n", - "- Äquivalent hierzu werden nun die Testdaten genutzt um Out-of-sample accuracy und error rate zu bestimmen und anschließend zu vergleichen mit den Ergebnissen aus Aufgabe 3.3." + "4. 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": 19, + "execution_count": 37, "id": "055822b9-d17f-47be-ada6-f3fa45f4554d", "metadata": { "tags": [] @@ -1479,67 +3510,86 @@ "name": "stdout", "output_type": "stream", "text": [ - "Out-of-sample accuracy: 0.73\n", - "Out-of-sample error rate: 0.27\n", - "\n", - "Comparison with in-sample statistics:\n", - "In-sample accuracy: 0.69\n", - "In-sample error rate: 0.31\n" + "Validation data:\n", + "Out-of-sample accuracy: 0.7300\n", + "Out-of-sample error rate: 0.2700\n" ] } ], "source": [ - "# Separate features and target variables for test data\n", - "X_test = test_data.drop(columns=['return_positive', 'date', 'ret_next'])\n", - "y_test = test_data['return_positive']\n", + "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", - "# Predict on the test data\n", - "y_pred_test = model.predict(X_test)\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", - "# Compute out-of-sample accuracy and error rate\n", - "accuracy_test = accuracy_score(y_test, y_pred_test)\n", - "error_rate_test = 1 - accuracy_test\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(f\"Out-of-sample accuracy: {accuracy_test:.2f}\")\n", - "print(f\"Out-of-sample error rate: {error_rate_test:.2f}\")\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", - "# Compare with in-sample statistics\n", - "print(\"\\nComparison with in-sample statistics:\")\n", - "print(f\"In-sample accuracy: {accuracy:.2f}\")\n", - "print(f\"In-sample error rate: {error_rate:.2f}\")" + "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": {}, + "source": [ + "\\newpage" ] }, { "cell_type": "markdown", "id": "81cbfae3-7385-40a2-8d0d-d7db7ae9a9f5", - "metadata": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "## Anhang \n", - "Der Datensatz enthält die folgenden Variablen:\n", - " - **ret**: Die vierteljährliche Rendite des US-Aktienmarktes (eine Zahl von 0,01 entspricht einer Rendite von 1% pro Quartal)\n", - " date: Das Datum im Format JJJJQ (19941 bedeutet das erste Quartal 1994)\n", - " - **DP**: Das Dividenden-zu-Preis-Verhältnis des Aktienmarktes (eine Bewertungsmessung, ob die Preise im Verhältnis zu den gezahlten Dividenden hoch oder niedrig sind)\n", - " - **CS**: Der Kreditspread definiert als die Differenz der Renditen zwischen hoch bewerteten Unternehmensanleihen (sichere Anlagen) und niedrig bewerteten Unternehmensanleihen (Unternehmen, die möglicherweise bankrott gehen). CS misst die zusätzliche Rendite, die Investoren für Investitionen in riskante Unternehmen im Vergleich zu etablierten Unternehmen mit geringeren Risiken verlangen.\n", - " - **ntis**: Ein Maß für die Aktivität bei der Ausgabe von Unternehmensanleihen (IPOs, Rückkäufe von Aktien,...)\n", - " - **cay**: Ein Maß für das Verhältnis von Vermögen zu Verbrauch (wie viel wird im Verhältnis zum Gesamtvermögen verbraucht)\n", - " - **TS**: Der Term Spread ist die Differenz zwischen der langfristigen Rendite von Staatsanleihen und kurzfristigen Renditen.\n", - " - **svar**: Ein Maß für die Varianz des Aktienmarktes\n", - "Für eine vollständige Beschreibung der Daten siehe Welch und Goyal (2007). Google ist auch sehr hilfreich, wenn Sie mehr über die Variablen erfahren möchten.\n" + "## 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": {}, + "metadata": { + "editable": true, + "slideshow": { + "slide_type": "" + }, + "tags": [], + "user_expressions": [] + }, "source": [ - "## Literatur \n", + "## 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.\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", @@ -1555,8 +3605,13 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" - } + "version": "3.12.7" + }, + "title": " ", + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false }, "nbformat": 4, "nbformat_minor": 5