Ein Bild sagt mehr als tausend Worte: auf die Performance kommt es an.

Heute beschäftigen wir uns mit einem technischen Thema – einer historischen Portfolioanalyse/Portfolioerstellung mit dem Programm RStudio. Wer sich näher mit Aktienanalysen beschäftigt, der wird jetzt wahrscheinlich Freudentänze machen. Für die Analyse müssen wir einiges vorbereiten, um überhaupt damit anfangen zu können. Keine Angst, wir gehen das Schritt für Schritt durch. Zum Schluss findet ihr den gesamten Code, den ihr direkt verwenden könnt. Der Beitrag zusammengefasst:

  • Wir installieren das Programm RStudio, um unsere Analysen durchzuführen
  • Wir installieren die notwendigen Pakete
  • Wir holen uns die Aktienkurse
  • Wir speichern diese in einem eigenen Datensatz und berechnen den Ertrag
  • Wir kalkulieren das gleiche für ein Portfolio
  • Wir stellen unsere Berechnungen grafisch dar
  • Wir berechnen die Korrelation der Kurse
  • Wir stellen die Performance übersichtlich dar

Wir holen uns die mächtige Software RStudio

Wir müssen uns erstmal das Programm besorgen. Ihr findet RStudio unter dieser URL: https://www.rstudio.com/ Dort könnt ihr euch erstmal umsehen und euch über die Software informieren. Kurz zusammengefasst handelt es sich dabei um ein extrem umfangreiches open-source Programm für die statistische Programmiersprache R. Noch einfacher: Es ist eine Statistiksoftware, ähnlich wie SPSS,  nur meiner Meinung nach aufgrund der “Community-Software-Updates” wesentlich spannender. Man bastelt sich quasi ein Programm, dass auf die eigenen Bedürfnisse oder Fragestellungen zugeschnitten ist. Ihr werdet noch sehen, was damit gemeint ist.

Um das Programm überhaupt zum laufen zu bringen, müsst ihr euch zuerst über das R-project die Sprache selbst herunterladen. Dann installiert ihr die Desktop-Oberfläche RStudio. Die einzelnen Schritte im Detail:

  1. Über R-Project R downloaden
  2. RStudio installieren

Wenn ihr das geschafft habt, müsstet ihr jetzt RStudio (und nicht R!) aufrufen können. Die Oberfläche müsste so aussehen:

Die Software Rstudio

Arbeiten mit RStudio

In der Mitte seht ihr eine einfache Console, mit der ihr schnell Arbeiten könnt. Probiert am besten einfache Berechnungen aus. Gebt dazu einfach 3+4, oder 45*1221 ein und drückt “Enter”. Für unsere Zwecke ist das aber zu wenig. Klickt jetzt auf “File” -> “New File” -> “R Script”. Jetzt sollte ein neues Fenster über eurer Console aufpoppen. Ein Script hat den Vorteil, dass es eure Befehle “speichert”. In der Console wird euer Befehl sofort ausgeführt und kann bei bedarf mit der Pfeil nach oben Taste wieder aufgerufen werden. Oder ihr gebt ihn neu ein. Bei einem Script schreibt ihr eure Befehle wie in einer Word-Datei. Ihr könnt sie noch einmal bearbeiten, etwas hinzufügen und erweitern. Das heißt, wir können uns eine individuelle Datei mit nacheinander, oder individuell ausführbaren Befehlen erstellen.

rstudio script

Installation der Pakete & Finanzdaten abrufen mit fidlr

Gehen wir gleich aufs Ganze und steigen in das Hauptthema ein. Zu Beginn müssen wir uns die richtigen “Pakete” in das Programm laden. Stellt euch das so vor, wie eine App für euer Smartphone. Ihr wollt eine Budget-App? Ihr ladet sie vom Store herunter und habt jetzt eine neue Funktion – den Zugang zu einer App. Genau so verhält es sich mit den Paketen und Add-Ons. Ihr habt das Standardprogramm und könnt es erweitern.

Zuerst müssen wir uns die “devtools” installieren, um auf individuelle Pakete von Autoren aus der weiten Welt zugreifen zu können. Das funktioniert so:

install.packages(“devtools”)

Habt ihr diesen Befehl eingegeben? Dann drückt auf das “Run” Symbol rechts oben im Hauptfenster. Jetzt sollte das Paket installiert werden. Ist es fertig installiert? Super! Die nächsten Befehle sind ähnlich. Wir laden uns ein Add-In in das Programm, um Aktienkurse abrufen zu können und installieren “PerformanceAnalytics”, ein Paket, speziell für ökonometrische Analysen. Dann erwecken wir das Paket zum Leben und erweitern damit unser Programm. Der Code:

install_github(“thertrader/fidlr”)
install.packages(“PerformanceAnalytics”)

library(PerformanceAnalytics)

Jetzt können wir in der zweiten Leiste unser geladenes “Add-In” namens “fidlr” aufrufen.

fidlr addin

Es erscheint ein Fenster, indem wir die Quelle angeben können, den Zeitraum und das Symbol unserer Aktie. In unserem Beispiel rufe ich das Tool zwei mal auf und importiere Apple und Nvidia. Zeitraum: 1. Dez. 2017- 16. Januar 2018. Ja, für eine langfristige Analyse nicht ideal, aber als Beispiel reicht das. Nachdem wir auf “Run” geklickt haben, werden die Daten als Objekt bzw. Variable in das Programm geladen. Ihr müsstet im Fenster rechts oben jetzt zwei Variablen sehen. Wenn dir darauf klickt, könnt ihr die Datensätze abrufen.

fidlr daten laden

Neuer Datensatz für die weitere Bearbeitung

Wir wollen nun die Endkurse der jeweiligen Aktien in einem neuen Datensatz zusammenführen. Das machen wir mit diesem Befehl:

prices <- data.frame(AAPL$AAPL.Close, NVDA$NVDA.Close)
prices

Wir erstellen einen Datensatz mit “data.frame”, ausgehend von den Endkursen und speichern diesen Datensatz in der Variable “prices”. In der Klammer steht, welche Daten wir in dem neuen Datensatz haben wollen. Wir greifen mit AAPL auf unsere Variable zu und sagen dem Programm mit $AAPL.Close, dass wir die Schlusskurse haben wollen. Wenn wir jetzt “prices” eingeben, sollte der neue Datensatz angezeigt werden (nicht vergessen, ihr müsst immer auf “run” klicken; oder am besten den neuen Codeteil markieren und auf “run” klicken oder STRG-Enter drücken). Jetzt haben wir die Aktienkurse.

Return berechnen und grafisch darstellen

Was aber ist der Ertrag? Wir kalkulieren ihn mit der Funktion “Return.calculate” und speichern ihn in “return_prices”.

returns_prices <- Return.calculate(prices)

Mit “returns_prices”, können wir uns wieder unsere neuen Daten ansehen.

Jetzt erstellen wir unseren Portfolio-Ertrag. Zuerst definieren wir die Gewichtung der beiden Aktien:

weights <- c(0.5, 0.5)

Anschließend erstellen wir mit den Daten unsere Gesamtertrag mit “Return.portfolio”. Dazu geben wir mit “R =” an, was wir analysieren wollen und anschließend definieren wir die Gewichtung. Mit “plot” lassen wir uns die Berechnung anzeigen:

full_an <- Return.portfolio(R = returns_prices, weights = weights)
plot(full_an)

Sehen wir uns das Ganze noch einmal mit einer anderen Gewichtung an (Apple 0.9):

weights1 <- c(0.9, 0.1)
full_an1 <- Return.portfolio(R = returns_prices, weights = weights1)

Anschließend können wir die Daten vergleichen, indem wir sie gemeinsam anzeigen:

par(mfrow = c(2, 1))
plot.zoo(full_an)
plot.zoo(full_an1)

portfolio vergleich

Die durchschnittliche Entwicklung wäre für 1: 0.27 und für 2: 0.15. Portfolio 1 schneidet also im Durchschnitt besser ab.

Zusätzlich können wir die monatlichen Erträge berechnen und anzeigen lassen:

portfolio_month <- to.monthly(returns)
plot.zoo(portfolio_month$returns.Close)

Oftmals werden auch Korrelationen für Aktienkurse berechnet. Das kann sinnvoll sein, um die Abhängigkeiten abschätzen zu können. Wir können das mit diesem Befehl machen:

cor(prices)

Eine Korrelation bewegt sich immer zwischen -1 und 1. Ist der Wert nahe bei eins? Dann liegt eine hohe Korrelation vor. Das heißt, der Kursverlauf bewegt sich in einem ähnlichen Ausmaß. In diesem Zeitraum berechnen wir eine Korrelationskoeffizienten von 0.6247277. Das heißt, wir haben eine positive, mittlere Korrelation. Wir könnten uns beispielsweise bei einem größeren Portfolio die Korrelation berechnen und so diversifizieren.

Mit “charts.PerformanceSummary(full_an)” können wir uns außerdem eine Übersicht – Ertrag kumuliert, -“- Tag und kumulierter Verlust – erstellen.

portfolio performance mit charts.PerformanceSummary

Schluss

Es gibt noch tausende andere Möglichkeiten, wie beispielsweise die Einstellung von einem monatlichen oder jährlichen Rebalancing. Diese Analyse ermöglicht, vorab die jeweiligen Aktien unter die Lupe zu nehmen, oder eine gesamte Strategie, basierend auf historischen Daten zu erstellen. Die hier vorgestellte Vorgehensweise basiert auf meiner Erfahrung mit RStudio. Die Berechnungen der Erträge sind u.a. in dem Kurs “Introduction to Portfolio Analysis” vorgestellt worden. Wir könnten natürlich noch allen Diagrammen einen Titel usw. geben, für diesen Beitrag habe ich aber auf weitere Codeschnippsel verzichtet. Wie ihr wisst, gehöre ich nicht zu den Menschen, die der technischen Analyse nahe stehen. Ich finde es interessant, mit historischen Daten zu arbeiten, und die Szenarien durchzuspielen. Zum Aufbau eines Portfolios kann diese Vorgehensweise durchaus interessant sein.

€: Übrigens: Der 16.01 kann in dem Datensatz noch weggelassen werden, da sind anscheinend noch keine Daten vorhanden. Außerdem könnten wir die erste Zeile löschen, da wir dafür keinen Ertrag berechnen können.

Hat euch der Beitrag gefallen? Teilen ist gerne erwünscht 😉

Den gesamten Code der Datei findet ihr hier:

####### Installation und Laden der Pakete ######
install.packages(“devtools”)
library(devtools)
install_github(“thertrader/fidlr”)
install.packages(“PerformanceAnalytics”)
library(PerformanceAnalytics)

####### Daten zusammenführen und ausgeben ######
prices <- data.frame(AAPL$AAPL.Close, NVDA$NVDA.Close)
prices

####### Erträge kalkulieren ######
returns_prices <- Return.calculate(prices)

####### Gewichtung defnieren und Portfolio berechnen ######
weights <- c(0.5, 0.5)
full_an <- Return.portfolio(R = returns_prices, weights = weights)
plot(bf_bh)

####### Gewichtung defnieren und Portfolio berechnen ######
weights1 <- c(0.9, 0.1)
full_an1 <- Return.portfolio(R = returns_prices, weights = weights1)

####### Ausgabe der Portfolioentwicklung ######
par(mfrow = c(2, 1))
plot.zoo(full_an)
plot.zoo(full_an1)

####### Umrechnung monatliche Erträge ######
portfolio_month <- to.monthly(returns)
plot.zoo(portfolio_month$returns.Close)

####### Korrelation ######
cor(prices)

####### Übersicht ######

charts.PerformanceSummary(full_an)

 

 

Hat euch der Beitrag gefallen? Ich würde mich über einen “Share” freuen 🙂