Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Returnanalyse

Zur Einschätzung der Entwicklung von Portfolien oder Aktienkursen betrachtet man nicht die Aktienkurse selbst, sondern deren Renditen bzw. Returns. Hierzu gibt es verschiedene Definitionen, die teilweise nicht einheitlich verwendet werden. Daher wollen wir Beginn die verschiedenen Renditedefinitionen nochmals aufgreifen. Zunächst betrachten wir nur einzelne Werte, egal ob Aktien oder andere Finanzprodukte und bezeichnen den Kurs zum Zeitpunkt tt mit StS_t und uns interessiert die Wertentwicklung der Aktie vom Anfangszeitpunkt aa nach tt.

Rendite vs. Log-Returns

👉 Renditen beschreiben den prozentualer Wertzuwachs von aa nach tt:

Ra,t=St−SaSa=StSa−1R_{a,t} = \frac{S_{t} - S_{a}}{S_a}= \frac{S_t}{S_a}-1

und werden auch als diskrete oder arithmetische Returns bezeichnet. In der Finanzmathematik arbeitet man hingegen häufig mit den Log-Returns:

ra,t=log⁡(StSa)=log⁡(St)−log⁡(Sa),r_{a,t} = \log{\left( \frac{S_t}{S_a} \right)} = \log {\left(S_t \right)} - \log {\left(S_a \right)},

die teilweise auch als stetige oder geometrische Returns bezeichnet werden Wir werden gleich an einem realen Beispiel sehen, dass sich beide Renditebegriffe nur minimal unterscheiden, wobei mit

Ra,t=era,t−1⇔ra,t=log⁡(Ra,t+1)R_{a,t}=e^{r_{a,t}}-1 \Leftrightarrow r_{a,t} = \log{\left( R_{a,t}+1\right)}

beide einfach ineinander umgerechnet werden können.

Das folgende Beispiel zeigt die Berechnung der täglichen Returns:

Versuche Yahoo Finance für ALV.DE:

[*********************100%***********************]  1 of 1 completed
Ticker          ALV.DE                                            
Price             Open        High         Low       Close  Volume
Date                                                              
2024-01-02  211.337772  214.600500  211.163762  213.121399  778095
2024-01-03  214.470002  215.122548  210.380719  211.033264  686416
2024-01-04  211.511789  213.599930  211.468283  213.599930  545050
2024-01-05  212.338357  213.164912  210.511224  212.207840  634842
2024-01-08  212.164337  213.121395  210.641730  212.773376  437610
Ticker          ALV.DE                                            
Price             Open        High         Low       Close  Volume
Date                                                              
2026-10-02  413.100006  416.200012  409.899994  416.200012  476998
2026-10-05  416.799988  419.899994  415.700012  419.200012  329234
2026-10-06  420.700012  423.700012  419.899994  420.700012  246662
2026-10-07  418.600006  419.299988  415.100006  417.299988  413822
2026-10-09  418.299988  418.399994  417.200012  418.000000   16256

Price       Date       Close
0     2024-01-02  213.121399
1     2024-01-03  211.033264
2     2024-01-04  213.599930
3     2024-01-05  212.207840
4     2024-01-08  212.773376

Verschiedene Methoden zur Berechnung beider Renditen:

Price       Date       Close   Rendite  LogReturn  Rendite2  LogReturn2  \
0     2024-01-02  213.121399       NaN        NaN       NaN         NaN   
1     2024-01-03  211.033264 -0.009798  -0.009846 -0.009798   -0.009846   
2     2024-01-04  213.599930  0.012162   0.012089  0.012162    0.012089   
3     2024-01-05  212.207840 -0.006517  -0.006539 -0.006517   -0.006539   
4     2024-01-08  212.773376  0.002665   0.002661  0.002665    0.002661   

Price  LogReturn3  
0             NaN  
1       -0.009846  
2        0.012089  
3       -0.006539  
4        0.002661  

Offensichtlich sind die Spalten Rendite und Rendite2 sowie die drei verschieden berechneten Log-Returns gleich. Mittels plot() können wir den zeitlichen Verlauf darstellen. Da die Schlusskurse und die Renditen völlig verschiedene Wertebereiche haben, ist ein simpler Plot aller Zeitreihen nicht sinnvoll, so dass wir zuvor noch die Schluss-Kurse entfernen. Probieren Sie zum Vergleich einfach mal den folgenden Befehl:

<Axes: >
<Figure size 640x480 with 1 Axes>
Price        Rendite  LogReturn  Rendite2  LogReturn2  LogReturn3
Date                                                             
2024-01-03 -0.009798  -0.009846 -0.009798   -0.009846   -0.009846
2024-01-04  0.012162   0.012089  0.012162    0.012089    0.012089
2024-01-05 -0.006517  -0.006539 -0.006517   -0.006539   -0.006539
2024-01-08  0.002665   0.002661  0.002665    0.002661    0.002661
2024-01-09 -0.004089  -0.004098 -0.004089   -0.004098   -0.004098
<Axes: xlabel='Date'>
<Figure size 640x480 with 1 Axes>

Hinweis: die Pandas Methode pct_change() kann auch auf den kompletten DataFrame angewendet werden, solange das Datum als Index gesetzt ist. Dann werden die prozentualen Veränderungen auch für die Open, High und Low-Kurse berechnet. Ist das Datum allerdings als Spalte gesetzt, so führt der Aufruf zu einer Fehlermeldung, da die Funktion pct_change() nicht auf das Dates-Format angewendet werden kann. Außerdem werden die normalen Kurse überschrieben -- möchte man beispielsweise die Closing-Kurse im DataFrame erhalten, sollte wie oben in df2 einfach eine neue Variable / Spalte erzeugt werden. Hinweis: Für die Berechnung der Renditen mittels der Pandas Funktion pct_change() ist es notwendig entweder eine konkrete Variable (Spalte) das DataFrames anzugeben, so wie das oben realisiert wurde. Ruft man mehrere Ticker gleichzeitig ab und möchte dann beispielsweise die Renditen auch gleichzeitig für alle Kurse berechnen, kann man andernfalls die Funktion pct_change() auch auf den gesamten DateFrame anwenden. Dann sollte man allerdings darauf achten, dass das Datum als Index gesetzt[1] ist. Natürlich ist es auch möglich, die Funktion nur auf eine Teilmenge aller Spalten bzw. Variablen anzuwenden.

Loading...

Obiger Graph der verschieden berechneten Renditen zeigt, dass auch zwischen der klassichen Rendite als prozentuale Veränderung und den Log-Returns keine großartigen Unterschiede mit bloßen Auge erkennbar sind, denn für sehr kleine Zeitabstände (hier 1 Tag) ist der Quotient StSt−1≈1\frac{S_t}{S_{t-1}} \approx 1 und somit die Unterschiede zwischen Log-Returns und Renditen nur marginal, was sich mit der Taylorapproximation 1. Ordnung der Funktion f(x)=log⁡(x)≈x−1f(x) = \log(x) \approx x-1 für xx nahe 1 erklären lässt. Berücksichtigt man höhere Ordnungen der Taylorapproximation f(x)=log⁡(x)=x−1−12(x−1)2+13(x−1)3−14(x−1)4±…f(x) = \log(x) = x-1 - \frac 12 (x-1)^2 + \frac13 (x-1)^3 - \frac 14 (x-1)^4 \pm \ldots wird deutlich, warum sich aber insbesondere für x≠1x\neq 1 beide Return-Begriffe unterscheiden.

<Figure size 700x500 with 1 Axes>

Es ist deutlich zu erkennen, dass für x nahe 1 kaum ein Unterschied zwischen beiden Funktionen zu erkennen ist. Zusammenfassend: Log-Returns und arithmetische Renditen unterscheiden sich für Tageskurse wegen x=StSt−1≈1x= \frac{S_t}{S_{t-1}} \approx 1

rt−1,t=log⁡(StSt−1)≈StSt−1−1=Rt−1,tr_{t-1,t} = \log{\left( \frac{S_t}{S_{t-1}} \right)} \approx \frac{S_t}{S_{t-1}} - 1 = R_{t-1,t}

nur minimal, da die Kursänderungen von Tag zu Tag nicht wesentlich sind. Beide Rendite-Begriffe haben aus finanzmathematischer Sicht Vor- und Nachteile, die wir später nochmals kurz aufgreifen werden. Aus praktischer Sicht macht es hingegen kaum einen Unterschied, ob wir Renditen oder Log-Returns analysieren. Betrachtet man beispielsweise das Histogramm der täglichen Returns ist optisch kein wesentlicher Unterschied zwischen Log-Returns und Renditen erkennbar. Für Tagesrenditen bzw. -Returns schreibt man häufig RtR_t bzw. rtr_t, d. h. lässt den ersten Zeitindex des Anfangsstadiums einfach weg. Außerdem zeigt die Graphik, dass die rote Kurve, welche den prozentualen Zuwächsen und somit Renditen entspricht, immer oberhalb der blaue Kurve verläuft, welche die Log-Returns beschreibt.

Wertzuwachs über die Zeit: kumulierte Returns vs. Renditen

Die Log-Returns des Zuwachses von der Anfangsinvestition bis zum Zeitpunkt tt ist wegen

r0,t=log⁡(St)−log⁡(S0)=log⁡(St)−log⁡(St−1)+log⁡(St−1)±…+log⁡(S1)−log⁡(S0)=rt−1,t+…+r0,1\begin{align*} r_{0,t} &= \log(S_t) - \log(S_0) = \log(S_t) - \log(S_{t-1}) + \log(S_{t-1}) \pm \ldots + \log(S_1)-\log(S_0)\\ &=r_{t-1,t} + \ldots + r_{0,1} \end{align*}

gerade die Summe der täglichen Log-Returns. Somit folgt dann für die Renditen eine Produkt-Struktur

R0,t+1=StS0=er0,t=e∑k=1trk−1,k=∏k=1terk−1,k=∏k=1t(Rk−1,k+1)\begin{align*} R_{0,t}+1 = \frac{S_t}{S_0}=e^{r_0,t}=e^{\sum\limits_{k=1}^t r_{k-1,k}} = \prod\limits_{k=1}^t e^{r_{k-1,k}} = \prod\limits_{k=1}^t \left(R_{k-1,k} +1 \right) \end{align*}

also ähnlich wie beim (geometrischen) Verzinsen mit Zinseszinseffekten.

Zusammenfassend werden wir die kumulierten Tages-Returns von 0 bis zum Zeitpunkt t zur Annualisierung verwenden

r0,t=∑k=1trk−1,kr_{0,t} = \sum\limits_{k=1}^t r_{k-1,k}

bzw.

R0,t=∏k=1t(Rk−1,k+1)−1=er0,t−1R_{0,t} = \prod\limits_{k=1}^t \left(R_{k-1,k} +1 \right) - 1 = e^{r_{0,t}} - 1

Die Funktionen cumsum() und cumprod() berechnen für jede Spalte die kumulierten Summen bzw. Produkte, d. h. in der ersten Zeile wird die nur das erste Element und in der zweiten Zeile die ersten beiden Werte usw. in die Summe bzw. das Produkt berücksichtigt. Somit kann die Entwicklung über die Zeit beginnend vom Startwert für beide Returnarten einach berechnet werden.

Price        Rendite  LogReturn  Rendite2  LogReturn2  LogReturn3  \
Date                                                                
2026-10-02  0.010194   0.010143  0.010194    0.010143    0.010143   
2026-10-05  0.007208   0.007182  0.007208    0.007182    0.007182   
2026-10-06  0.003578   0.003572  0.003578    0.003572    0.003572   
2026-10-07 -0.008082  -0.008115 -0.008082   -0.008115   -0.008115   
2026-10-09  0.001677   0.001676  0.001677    0.001676    0.001676   

Price       LogReturns_kum  Rendite_kum  
Date                                     
2026-10-02        0.669304     0.952878  
2026-10-05        0.676486     0.966954  
2026-10-06        0.680058     0.973992  
2026-10-07        0.671943     0.958039  
2026-10-09        0.673619     0.961323  
<Figure size 640x480 with 1 Axes>

Es ist deutlich zu erkennen, dass für die frühen Zeitpunkte tt sich die Log-Returns und Renditen von 0 (also Jahresanfang 2024) bis tt kaum unterscheiden. Mit steigender Zeit tt laufen die beiden Renditekurven allerdings auseinander, da sich für größere Zeitabstände eben beide Returndefinitionen unterscheiden. Wie erwartet liegen die (kumulierten) Renditen immer oberhalb der Log-Returns

Annualisierte Returns

Aus Gleichung (8) folgt

R0,t=∏k=1t(Rk−1,k+1)−1=ygeot−1R_{0,t} = \prod\limits_{k=1}^t \left(R_{k-1,k} +1 \right) - 1 = y_\text{geo}^t - 1

d. h. die kumulierte Rendite von 0 nach t lässt sich basierend auf der modifizierten Stichprobe der Tages-Renditen yk=Rk−1,k+1y_k = R_{k-1,k}+1 mit Hilfe des geometrischen Mittels für n=tn=t

ygeo=∏k=1nykn=(∏k=1nyk)1n=exp⁡(1n∑k=1nlog⁡yk)=exp⁡(log⁡y‾)y_\text{geo} = \sqrt[n]{\prod\limits_{k=1}^n y_k} = \left(\prod\limits_{k=1}^n y_k \right)^\frac 1n = \exp{\left( \frac 1n \sum\limits_{k=1}^n \log{y_k} \right)} = \exp{ \left(\overline{\log{y}}\right)}

aller Tagesrenditen bis zum Zeitpunkt t ausdrücken. Ebenso können wir für die Log-Returns für die Stichprobe der Tages-Returns xk=rk−1,kx_k = r_{k-1,k} mittels des arithmetischen Mittels xˉ=1n∑k=1nxk\bar{x}=\frac 1n \sum\limits_{k=1}^n x_k wegen Formel (7) schreiben als

r0,t=∑k=1trk−1,k=txˉr_{0,t} = \sum\limits_{k=1}^t r_{k-1,k} = t \bar{x}

Außerdem gilt folgender Zusammenhang zwischen geometrischen Mittel der Renditen und arithmetischen Mittel der Log-Returns für beliebige Stichprobengröße nn

(R+1)geo=ygeo=(∏k=1nyk)1n=exp⁡(1n∑k=1nlog⁡yk)=exp⁡(1n∑k=1nlog⁡(Rk−1,k+1))=exp⁡(1n∑k=1nrk−1,k)=exp⁡(1n∑k=1nxk)=exp⁡(x‾)=exp⁡(r‾)\begin{align*} (R+1)_\text{geo} &= y_\text{geo} = \left(\prod\limits_{k=1}^n y_k \right)^\frac 1n = \exp{\left( \frac 1n \sum\limits_{k=1}^n \log{y_k} \right)} = \exp{\left( \frac 1n \sum\limits_{k=1}^n \log{ \left( R_{k-1,k} + 1\right)} \right)} \\ &= \exp{\left( \frac 1n \sum\limits_{k=1}^n r_{k-1,k} \right)} = \exp{\left( \frac 1n \sum\limits_{k=1}^n x_k \right)} = \exp{\left( \overline x \right)} = \exp{\left( \overline r \right)} \end{align*}

Somit wird aus allen vorhanden Tages-Returns das jeweilige arithmetische und geometrische Mittel geschätzt und dann annualisiert man diese Werte entsprechend obiger Formeln, wobei man typischerweise unterstellt, dass ein Handelsjahr 252 Handelstage hat

rannualized=rˉdaily⋅252r_\text{annualized} = \bar{r}_\text{daily} \cdot 252

sowie

Rannualized=(1+R)geo,daily252−1=exp⁡(rannualized)−1=exp⁡(rˉdaily⋅252)−1\begin{align*}%eq-rendite-annualized R_\text{annualized} &= (1 + R)_\text{geo,daily}^{252} - 1 = \exp{(r_\text{annualized})} - 1\\ & = \exp{\left( \bar{r}_\text{daily} \cdot 252 \right)} - 1 % \approx \bar{r}_\text{daily} \cdot 252 \approx \bar{R}_\text{daily} \cdot 252 \end{align*}

Insbesondere für statistische Analysen werden häufig die Maßzahlen für jährliche Renditen angegeben, um eine bessere Vergleichbarkeit zwischen verschiedenen Anlageprodukten und Anlagezeiträumen durch die entsprechende Skalierung zu erreichen.

In Abschnitt Portfolioanalyse: erwarteter Portfolio-Return und Portfolio-Varianz benötigen wir die Erwartungswerte, Varianzen sowie Kovarianzen zwischen den einzelnen Aktienrenditen, um die erwartete Portfoliorendite und -Varianz zu berechnen. Für die Log-Returns ist dies aufgrund der Linearität des Erwartungswertes sehr einfach. Aus diesem Grund arbeitet man in der Finanzmathematik auch häufig lieber mit den Log-Returns als den Renditen. Unterstellt man, dass die Tages-Returns der jj-ten Aktie rj,(k−1,k)r_{j,(k-1,k)} unabhängig und identisch verteilte Zufallsvariablen (iid) mit Erj,(k−1,k)=μi\mathbb{E} r_{j,(k-1,k)} = \mu_i und Var⁡rj,(k−1,k)=σj2\operatorname{Var} r_{j,(k-1,k)}=\sigma^2_j sind, folgt für die erwarteten Jahres-Log-Returns sowie deren Varianzen bzw. Volatilitäten / Standardabweichungen

Erj,annualized=252μj=252⋅Erj,daily\mathbb{E} r_{j, \text {annualized}} = 252 \mu_j = 252 \cdot \mathbb{E} r_{j,\text{daily}}
Var⁡(rj,annualized)=252σj2=252⋅Var⁡(rj,daily)\operatorname{Var}(r_{j,\text {annualized}}) = 252 \sigma^2_j = 252 \cdot \operatorname{Var}(r_{j,\text {daily}})
SD⁡(rj,annualized)=252σj\operatorname{SD}(r_{j,\text {annualized}}) = \sqrt{252} \sigma_j

Zur Annualisierung der Kovarianz der täglichen Log-Returns führen wir folgende Bezeichnung ein: XkX_k sei der zufällige Tages-Return der ii-ten Aktie von Tag (k−1)(k-1)-ten Tag zum kk-ten Tag und für die jj-te Aktie sei YlY_l der Tages-Return vom (l−1)(l-1)-ten Tag zum ll-ten Tag, d. h.

Xk:=ri,(k−1,k):=log⁡(Si,kSi,k−1)=log⁡Si,k−log⁡Si,k−1Yl:=rj,(l−1,l):=log⁡(Sj,lSj,l−1)=log⁡Sj,l−log⁡Sj,l−1\begin{align*} X_k &:= r_{i,(k-1,k)} := \log {\left( \frac{S_{i,k}}{S_{i,k-1}} \right)} = \log S_{i,k} - \log S_{i,k-1}\\ Y_l &:= r_{j,(l-1,l)} := \log {\left( \frac{S_{j,l}}{S_{j,l-1}} \right)} = \log S_{j,l} - \log S_{j,l-1}\\ \end{align*}

Mit (7) folgt daher für die Jahres-Returns (für t=252t=252)

ri,(0,t)=log⁡(Si,tSi,0)=∑k=1tXkrj,(0,t)=log⁡(Sj,tSj,0)=∑l=1tYl\begin{align*} r_{i,(0,t)} &= \log {\left( \frac{S_{i,t}}{S_{i,0}} \right)} = \sum\limits_{k=1}^t X_k\\ r_{j,(0,t)} &= \log {\left( \frac{S_{j,t}}{S_{j,0}} \right)} = \sum\limits_{l=1}^t Y_l\\ \end{align*}

Unterstellen wir zusätzlich zur Standardannahme (tägliche Returns einer Aktie sind identisch und unabhängig verteilt, d.h. X1,…,XtX_1, \ldots, X_t iid sowie Y1,…,YtY_1, \ldots, Y_t iid), dass ausschließlich die Tages-Returns zweier verschiedener Aktien am selben Tag korrelieren, also genauer

Cov⁡(Xk,Yl)=Cov⁡(ri,(k−1,k),rj,(l−1,l))={0, falls k≠lσij, falls k=l\operatorname{Cov}(X_k,Y_l) = \operatorname{Cov}(r_{i,(k-1,k)},r_{j,(l-1,l)}) = \begin{cases} 0, & \text{ falls } k \neq l\\ \sigma_{ij}, & \text{ falls } k = l \end{cases}

erhalten wir für die Kovarianz der Jahres-Returns zwischen der ii-ten und jj-ten Aktie wegen

Cov⁡(ri,(0,t),rj,(0,t))=Cov⁡(∑k=1tXk,∑l=1tYl)=∑k=1t∑l=1tCov⁡(Xk,Yl)=∑k=1tCov⁡(ri,(k−1,k),rj,(k−1,k))=tσij,\begin{align*} \operatorname{Cov}(r_{i,(0,t)} ,r_{j,(0,t)} ) &= \operatorname{Cov} \left(\sum\limits_{k=1}^t X_k, \sum\limits_{l=1}^t Y_l\right) = \sum\limits_{k=1}^t \sum\limits_{l=1}^t \operatorname{Cov}(X_k,Y_l)\\ &= \sum\limits_{k=1}^t \operatorname{Cov}(r_{i,(k-1,k)},r_{j,(k-1,k)}) = t \sigma_{ij}, \end{align*}

dass die Kovarianzen der Returns von 0 bis t einfach mit der Zeit skalieren

Cov⁡(ri,(0,t),rj,(0,t))=tσij\operatorname{Cov}(r_{i,(0,t)} ,r_{j,(0,t)} ) = t \sigma_{ij}

und somit die annualisierte Kovarianzmatrix aller Returns unter der Annahme dass ein Jahr 252 Handelstage besitzt

Σannualized=252⋅Σdaily,\Sigma_\text {annualized} = 252 \cdot \Sigma_\text{daily},

wobei Σdaily\Sigma_\text{daily} die Kovarianzmatrix der Tages-Returns bezeichnet.

Die Annualisierung für die prozentualen Zuwächse ist wegen der Nichtlinearität in (9) bzw. (7) komplizierter, aber unter den obigen Annahmen der Unabhängigkeit der Tages-Renditen verschiedener Tage faktorisiert der Erwartungswert des Produktes. Analog zu den Log-Returns führen wir für die zufälligen Renditen folgende Bezeichnungen ein

X~k:=Ri,(k−1,k)+1=Si,kSi,k−1Y~l:=Rj,(l−1,l)+1=Sj,lSj,l−1,\begin{align*} \tilde{X}_k &:= R_{i,(k-1,k)} + 1 = \frac{S_{i,k}}{S_{i,k-1}} \\ \tilde{Y}_l &:= R_{j,(l-1,l)} +1 = \frac{S_{j,l}}{S_{j,l-1}}, \end{align*}

wobei analog zu den Log-Returns ERi,(k−1,k)=μ~i\mathbb{E} R_{i,(k-1,k)} = \tilde{\mu}_i und Var⁡Ri,(k−1,k)=σ~i2\operatorname{Var} R_{i,(k-1,k)} = \tilde{\sigma}^2_i sowie

Cov⁡(X~k,Y~l)=Cov⁡(Ri,(k−1,k)+1,Rj,(l−1,l)+1)=Cov⁡(Ri,(k−1,k),Rj,(l−1,l))={0, falls k≠lσ~ij, falls k=l\operatorname{Cov}(\tilde{X}_k,\tilde{Y}_l) = \operatorname{Cov}(R_{i,(k-1,k)}+1,R_{j,(l-1,l)}+1) = \operatorname{Cov}(R_{i,(k-1,k)},R_{j,(l-1,l)}) = \begin{cases} 0, & \text{ falls } k \neq l\\ \tilde{\sigma}_{ij}, & \text{ falls } k = l \end{cases}

Aus Formel (8) bzw. (9) folgt dann für die erwartete Jahres-Rendite

ERi,(0,t)=E(∏k=1t(Ri,(k−1,k)+1)−1)=∏k=1t(ERi,(k−1,k)+1)−1=(∏k=1t(EX~k)−1)=∏k=1t(μ~i+1)−1=(μ~i+1)t−1\begin{align*} \mathbb{E} R_{i,(0,t)} &= \mathbb{E} \left( \prod\limits_{k=1}^t \left(R_{i,(k-1,k)} +1 \right) - 1 \right)\\ &= \prod\limits_{k=1}^t \left( \mathbb{E}R_{i,(k-1,k)} +1 \right) -1 \\ &= \left( \prod\limits_{k=1}^t \left(\mathbb{E} \tilde{X}_k \right) - 1 \right) = \prod\limits_{k=1}^t \left( \tilde{\mu}_i + 1 \right) -1 = (\tilde{\mu}_i+1)^t - 1\\ \end{align*}

zusammengefasst also

ERi,(0,t)=∏k=1t(μ~i+1)−1=(μ~i+1)t−1\mathbb{E} R_{i,(0,t)} = \prod\limits_{k=1}^t \left( \tilde{\mu}_i + 1 \right) -1 = (\tilde{\mu}_i+1)^t - 1

und die Varianz skaliert wegen

Var⁡(Ri,(0,t))=Var⁡(∏k=1tX~k−1)=Var⁡(∏k=1tX~k)=E(∏k=1tX~k)2−(E(∏k=1tXk~))2=E(∏k=1tX~k2)−∏k=1t(EX~k)2=(μ~i2+σ~i2+2μ~i+1)t−(μ~i+1)2t\begin{align*} \operatorname{Var}(R_{i,(0,t)}) &= \operatorname{Var}\left( \prod\limits_{k=1}^t \tilde{X}_k -1 \right) = \operatorname{Var}\left( \prod\limits_{k=1}^t \tilde{X}_k \right)\\ &= \mathbb{E}\left( \prod\limits_{k=1}^t \tilde{X}_k \right)^2 - \left(\mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X_k} \right) \right)^2 \\ &=\mathbb{E}\left( \prod\limits_{k=1}^t \tilde{X}_k^2 \right) - \prod\limits_{k=1}^t \left( \mathbb{E} \tilde{X}_k \right)^2\\ &= \left( \tilde{\mu}_i^2 + \tilde{\sigma}^2_i + 2 \tilde{\mu}_i + 1 \right)^t - (\tilde{\mu}_i+1)^{2t} \end{align*}

aus den Tageswerten

Var⁡(Ri,(0,t))=(μ~i2+σ~i2+2μ~i+1)t−(μ~i+1)2t\operatorname{Var}(R_{i,(0,t)}) = \left( \tilde{\mu}_i^2 + \tilde{\sigma}^2_i + 2 \tilde{\mu}_i + 1 \right)^t - (\tilde{\mu}_i+1)^{2t}

Insbesondere die Skalierung der Varianz für die annualisierten Renditen ist demnach also deutlich komplexer und insbesondere auch nichtlinear in der Zeit tt. Für die Kovarianzen der Jahres-Renditen zwischen der ii-ten und jj-ten Aktie ergibt sich bei analogen Annahmen zu den Log-Returns

Cov⁡(Ri,(0,t),Rj,(0,t))=(σ~ij+μi~μj~+μ~i+μj~+1)t−(μ~i+1)t(μ~j+1)t\operatorname{Cov}(R_{i,(0,t)} ,R_{j,(0,t)} ) = \left( \tilde{\sigma}_{ij} + \tilde{\mu_i}\tilde{\mu_j} + \tilde{\mu}_i + \tilde{\mu_j} + 1\right)^t - (\tilde{\mu}_i+1)^t (\tilde{\mu}_j+1)^t

denn

Cov⁡(Ri,(0,t),Rj,(0,t))=Cov⁡(Ri,(0,t)+1,Rj,(0,t)+1)=Cov⁡(∏k=1tX~k,∏l=1tY~l)=E(∏k=1tX~k−E(∏k=1tX~k))(∏l=1tY~l−E(∏l=1tY~l))=E(∏k=1tX~k−∏k=1tEX~k)(∏l=1tY~l−∏l=1tEY~l)=E(∏k=1tX~k−(μi~+1)t)(∏l=1tY~l−(μ~j+1)t)=E(∏k=1tX~k∏l=1tY~l)−(μ~j+1)tE(∏k=1tX~k)−(μ~i+1)tE(∏l=1tY~l)+(μ~i+1)t(μ~j+1)t=E(∏k=1tX~kY~k)−(μ~i+1)t(μ~j+1)t=∏k=1tE(X~kY~k)−(μ~i+1)t(μ~j+1)t=(σ~ij+μi~μj~+μ~i+μj~+1)t−(μ~i+1)t(μ~j+1)t\begin{align*} \operatorname{Cov}(R_{i,(0,t)} ,R_{j,(0,t)} ) &= \operatorname{Cov}(R_{i,(0,t)} +1,R_{j,(0,t)} +1 )\\ &= \operatorname{Cov} \left(\prod\limits_{k=1}^t \tilde{X}_k, \prod\limits_{l=1}^t \tilde{Y}_l\right)\\ &= \mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X}_k - \mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X}_k \right)\right) \left( \prod\limits_{l=1}^t \tilde{Y}_l - \mathbb{E} \left( \prod\limits_{l=1}^t \tilde{Y}_l \right)\right)\\ &= \mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X}_k - \prod\limits_{k=1}^t \mathbb{E}\tilde{X}_k \right) \left( \prod\limits_{l=1}^t \tilde{Y}_l - \prod\limits_{l=1}^t \mathbb{E}\tilde{Y}_l \right)\\ &= \mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X}_k - (\tilde{\mu_i}+1)^t \right) \left( \prod\limits_{l=1}^t \tilde{Y}_l - (\tilde{\mu}_j+1)^t\right)\\ &= \mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X}_k \prod\limits_{l=1}^t \tilde{Y}_l \right) - (\tilde{\mu}_j+1)^t \mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X}_k \right)\\ & \quad - (\tilde{\mu}_i+1)^t \mathbb{E} \left( \prod\limits_{l=1}^t \tilde{Y}_l \right) + (\tilde{\mu}_i+1)^t (\tilde{\mu}_j+1)^t\\ &= \mathbb{E} \left( \prod\limits_{k=1}^t \tilde{X}_k \tilde{Y}_k \right) - (\tilde{\mu}_i+1)^t (\tilde{\mu}_j+1)^t \\ &= \prod\limits_{k=1}^t \mathbb{E} \left( \tilde{X}_k \tilde{Y}_k \right) - (\tilde{\mu}_i+1)^t (\tilde{\mu}_j+1)^t \\ &= \left( \tilde{\sigma}_{ij} + \tilde{\mu_i}\tilde{\mu_j} + \tilde{\mu}_i + \tilde{\mu_j} + 1\right)^t - (\tilde{\mu}_i+1)^t (\tilde{\mu}_j+1)^t \end{align*}

wobei die letzte Gleichung aus

σ~ij=Cov⁡(Ri,(k−1,k),Rj,(k−1,k))=Cov⁡(Ri,(k−1,k)+1,Rj,(k−1,k)+1)=Cov⁡(X~,Y~)=E(X~Y~)−EX~⋅EY~=E(X~Y~)−(μ~i+1)(μ~j+1)\begin{align*} \tilde{\sigma}_{ij} &= \operatorname{Cov}(R_{i,(k-1,k)}, R_{j,(k-1,k)}) = \operatorname{Cov}(R_{i,(k-1,k)}+1, R_{j,(k-1,k)}+1)\\ &=\operatorname{Cov}(\tilde{X}, \tilde{Y})= \mathbb{E} \left(\tilde X \tilde Y \right) - \mathbb{E} \tilde{X} \cdot \mathbb{E} \tilde{Y} = \mathbb{E} \left(\tilde X \tilde Y \right) - (\tilde{\mu}_i +1)(\tilde{\mu}_j +1) \end{align*}

folgt. Prinzipiell können wir also aus mit Formel (15) von den täglichen Erwartungswertvektor bzw. Kovarianzmatrix der Renditen übergehen zu den annualisierten Werten, allerdings nicht so einfach wie für die Log-Returns.

Statistische Analyse der Returns

Wie oben gesehen sind die Unterschiede zwischen täglichen Log-Returns und Renditen nicht wesentlich. So sehen die Histogrammen, die die Verteilung der täglichen Wertzuwächse wiedergeben sehr ähnlich aus, wie die folgenden beiden Graphiken zeigen. Der folgende Code erzeugt nicht nur ein klassisches Histogramm, sondern fügt noch den Standard-Kerndichteschätzer[2], was man einfach als empirische Dichtefunktion interpretieren kann, sondern auch noch zum Vergleich die angepasste Normalverteilungsdichte[3].

<Figure size 640x480 with 1 Axes>
<Figure size 640x480 with 1 Axes>

Der Kerndichteschätzer zeigt eine typische glockenförmige Verteilung. Allerdings zeigt der Vergleich zwischen Kerndichteschätzer und Normalverteilungsdichte eine recht deutlichte Abweichung zur Normalverteilung. In den Rändern der empirischen Verteilung liegen deutlich mehr Werte als bei der Normalverteilung üblich. Insbesondere die linke Seite, die starke Verluste repräsentiert, ist stärker ausgeprägt und dies spricht für eine leptokurtsiche Verteilung. Mit Hilfe der 3. und 4. Momente werden wir dies auch mit Hilfe statistischer Maßzahlen in höhere Momente: Schiefe und Kurtosis ausdrücken.

mittlere Tages-Rendite: 0.001023 Tages-LogReturns: 0.000958
Standardabweichung Tages-Rendite: 0.011313 Tages-LogReturns: 0.011347

Oben haben wir bereits mittleren Tages-Returns und die Standardabweichungen berechnet. Allerdings kann man dies auch gleich spaltenweise für den gesamten DataFrame. Zu beachten gilt hier natürlich, ob die Maßzahl tatsächlich auch sinnvoll für jede Variable / Spalte ist. Die Mittelung der durchschnittlich kumilierten Returns ist beipspielsweise nicht sinnvoll, da für jede Zeile verschiedene Zeitpunkte betrachtet werden und somit keine stationäre Zeitreihe mehr vorliegt. Daher sollten die letzten beiden Spalten bei der Interpretation ausgelassen (oder noch besser ausgeblendet) werden, wie wir im Folgenden noch demonstrieren.

Price Rendite 0.001023 LogReturn 0.000958 Rendite2 0.001023 LogReturn2 0.000958 LogReturn3 0.000958 LogReturns_kum 0.370179 Rendite_kum 0.479533 dtype: float64
Price Rendite 0.011321 LogReturn 0.011355 Rendite2 0.011321 LogReturn2 0.011355 LogReturn3 0.011355 LogReturns_kum 0.209145 Rendite_kum 0.304314 dtype: float64

Die describe() Funktion liefert eine Übersicht der wichtigsten Statistik-Maßzahlen

Loading...

Mittels apply() können auch einzelne oder mehrere Funktionen auf die Spalten (axis = 0) bzw. Zeilen (axis=1) angewendet werden

Loading...

Natürlich können auch eigene Funktionen angewendet werden. Der folgende Code zeigt beispielhaft die selbstständige Berechnung der ersten beiden empirischen Momente:

Loading...

Die Berechnung der statistischen Kennzahlen für die kumulierten Returns (letzten beiden Spalten) macht wie oben bereits erwähnt keinen Sinn, daher schließen wir sie einfach aus der Auswertung aus.

Loading...

Alternativ kann man natürlich einfach die Variablen angeben, die man auswerten möchte: hier bietet sich neben der Funktion drop() auch die Pandas Funktion filter() an, bei der man beispielsweise mittels sogenannter Regular Expressions (siehe auch Regex Cheat Sheet) sehr vielfältige Bedingungen formulieren kann, siehe Pandas Docu. Im folgenden Code wollen wir alle Variablen die mit ‘Log’ beginnen (^Log) aber am Ende nicht auf ‘_kum’ enden (negative lookahead: (?!.*_kum$)) auswerten:

Loading...

Hinweis: man kann das beliebig individualisieren. In manchen Auswertungen möchte man beispielsweise nur Variablen mit numerischen Werten auswerten, dann ist die Funktion select_dtypes() für die Auswahl bestimmer Datentypen hilfreich.

Ebenso kann die Funktion agg() wie die Funktion apply() angewendet werden:

Loading...

höhere Momente: Schiefe und Kurtosis

Allgemein kann die Verteilung einer Stichprobe mittels der empirischen zentralen bzw. allgemeinen Momente

M~k=1n∑i=1n(xi−xˉ)k bzw. Mk=∑i=1nxik\tilde{M}_k = \frac 1n \sum\limits_{i=1}^n \left( x_i - \bar{x} \right)^k \qquad \text{ bzw. } \qquad M_k = \sum\limits_{i=1}^n x_i^k

beschrieben werden. Während das 1. Moment M1=x‾M_1 = \overline x den Mittelwert der Verteilung beschreibt, wird die Schwankung mittels des 2. Moments beschrieben und entspricht dem unkorrigierten Varianzschätzer

M~2=s~2=1n∑i=1n(xi−x‾)2=1n∑i=1nxi2−x‾2=M2−M12\tilde{M}_2 = \tilde{s}^2 = \frac 1n \sum\limits_{i=1}^n (x_i - \overline x)^2 = \frac 1n \sum\limits_{i=1}^n x_i^2 - \overline{x}^2 = M_2 - M_1^2

Die sogenannte Z-Transformation einer Stichprobe x1,x2,…,xnx_1, x_2, \ldots, x_n ist eine Standardisierung[^4] der Werte zi=xi−M1M2=xi−x‾s~z_i = \frac{x_i - M_1}{\sqrt{M_2}} = \frac{x_i - \overline x}{\tilde s}, so dass diese Stichprobe wegen M1(z)=1n∑i=1nzi=0M_1(z) = \frac1n \sum\limits_{i=1}^n z_i = 0 um die Null schwankt mit Varianz

M~2(z)=1n∑i=1n(zi−z‾)2=1n∑i=1nzi2=1n∑i=1n(xi−x‾s~)2=1n∑i=1n(xi−x‾)2s~2=M~2(x)M~2(x)=1\begin{align*} \tilde{M}_2(z) &= \frac 1n \sum\limits_{i=1}^n (z_i - \overline{z})^2 = \frac 1n \sum\limits_{i=1}^n z_i^2 = \frac 1n \sum\limits_{i=1}^n \left( \frac{x_i - \overline{x} }{\tilde s} \right) ^2\\ &= \frac{\frac 1n \sum\limits_{i=1}^n \left( x_i - \overline x \right)^2}{\tilde s^2} = \frac{\tilde{M}_2(x)}{\tilde{M}_2(x)}= 1 \end{align*}
unbiased var = 0.000129, 2. zentrales Moment = 0.000129, biased var = 0.000129

Mittels dem 3. Moment wird die (empirische) Schiefe einer Verteilung berechnet

g=M~3(x)M~2(x)32=1n∑i=1n(xi−xˉ)3(1n∑i=1n(xi−xˉ)2)3=(1n∑i=1n(xi−xˉ))3s~3=1n∑i=1n(xi−x‾s~)3=M~3(z).\begin{align*} g &= \frac{\tilde{M}_3(x)}{\tilde{M}_2(x)^\frac 32} = \frac{\frac{1}{n}\sum\limits_{i=1}^n \left( x_i - \bar{x} \right)^3}{\sqrt{ \left( \frac{1}{n}\sum\limits_{i=1}^n \left( x_i - \bar{x} \right)^2 \right)^3}} \\ &= \frac{ \left(\frac 1n \sum\limits_{i=1}^n (x_i - \bar{x}) \right)^3}{\tilde s^3} = \frac 1n \sum\limits_{i=1}^n \left( \frac{x_i - \overline x}{\tilde s} \right)^3 = \tilde{M}_3(z). \end{align*}

Für symmetrische Verteilungen verschwindet die Schiefe (xˉ≈xmed≈xmod\bar{x} \approx x_{med} \approx x_{mod}, g≈0g \approx 0), während für linksschiefe (rechtssteil) Verteilungen der Wert negativ wird (xˉ<xmed<xmod\bar{x} < x_{med} < x_{mod}, g<0g<0) und für rechtsschiefe (linkssteil) Verteilungen (xˉ>xmed>xmod\bar{x} > x_{med} > x_{mod}, g>0g>0) sich ein postiver Wert ergibt.

Schiefe: g = -0.727947 basierend auf 3. zentralen Moment = -0.000001

Mittels 4. Moment misst man die Wölbung bzw. Krümmung einer Verteilung

γ=M~4(x)M~22(x)−3=1n∑i=1n(xi−xˉ)4(1n∑i=1n(xi−xˉ)2)2−3=1n∑i=1n(xi−xˉs~)4−3=M~4(z)−3\gamma = \frac{\tilde{M}_4(x)}{\tilde{M}_2^2(x)}-3 = \frac{\frac{1}{n}\sum\limits_{i=1}^n \left( x_i - \bar{x} \right)^4}{\left( \frac{1}{n}\sum\limits_{i=1}^n \left( x_i - \bar{x} \right)^2 \right)^2} - 3 = \frac 1n \sum\limits_{i=1}^n \left( \frac{x_i - \bar{x}}{\tilde s} \right)^4 -3 = \tilde{M}_4(z) -3

wobei die Verschiebung um 3 für die bessere Interpretierbarkeit bzw. dem Vergleich zur Normalverteilung dient, denn diese Kennzahl vergleicht wie stark der zentrale Bereich und folglich auch wie schwach die ‘tails’ im Vergleich zur Normalverteilung besetzt sind. Werte von γ≈0\gamma \approx 0 sind typisch für eine Normalverteilung, während positive Werte für eine spitzere Verteilung (γ>0\gamma > 0) mit mehr Maße in den Tails und negative Werte für eine breitere Verteilung (γ<0\gamma < 0) sprechen.

Kurtosis: gamma = 3.149912 basierend auf 4. zentralen Moment = 0.000000
Loading...

Natürlich gibt es auch enstprechende Pakete, um diese Kennzahlen einfach zu berechnen. Hier nutzen wir das Sub-Package scipy.stats

Schiefe: g = -0.727947, scipy.stats.skew  = -0.727947
3. Moment: m3 = -0.000001, scipy.stats.moment = -0.000001
Kurtosis: k = 3.149912, Scipy.stats.kurtosis  = 3.149912
Skew: Price
Rendite          -0.651416
LogReturn        -0.729505
Rendite2         -0.651416
LogReturn2       -0.729505
LogReturn3       -0.729505
LogReturns_kum   -0.140620
Rendite_kum       0.170247
dtype: float64
Kurtosis: Price
Rendite           2.975565
LogReturn         3.181015
Rendite2          2.975565
LogReturn2        3.181015
LogReturn3        3.181015
LogReturns_kum   -1.041740
Rendite_kum      -0.882880
dtype: float64

Wir haben hier ausschließlich Tages-Returns ausgewertet, allerdings haben wir in Annualisierte Returns gesehen, wie wir diese zu Jahres-Returns skalieren können. Insbesondere Schiefe und Kurtosis sind im Gegensatz zu den zentrierten 3. bzw. 4. Momenten aber skalierungsfrei, da sich die Skalierungsfaktoren bei der Normierung herauskürzen.

Test auf Normalverteilung

ShapiroResult(statistic=np.float64(0.9575765262330819), pvalue=np.float64(2.2716992929276316e-13))
NormaltestResult(statistic=np.float64(108.9075332553957), pvalue=np.float64(2.2440350436969277e-24))

Abhängigkeiten zwischen Aktien-Returns: Kovarianz und Korrelation

Zur statistischen Auswertung zählt natürlich auch die Analyse der Abhängigkeiten zwischen verschiedenen Aktien. Im folgenden Abschnitt Portfolio-Returns werden wir aus verschiedenen Aktien ein Portfolio zusammenstellen und desen Entwicklung näher untersuchen. Bevor wir Portfolio-Returns studieren, untersuchen wir noch die Abhängigkeiten zwischen den einzelnen Aktien-Returns. Der Übersichtlichkeit wählen wir hier 4 Aktien und laden deren Kurse bei YahooFinance herunter:

[                       0%                       ]
[**********************50%                       ]  2 of 4 completed
[**********************75%***********            ]  3 of 4 completed
[*********************100%***********************]  4 of 4 completed
Ticker            AAPL       GOOGL        MSFT        TSLA
Date                                                      
2021-10-11  139.292770  137.604599  282.380615  263.980011
2021-10-12  138.024765  135.162842  281.084991  268.573334
2021-10-13  137.439514  136.285156  284.376801  270.359985
2021-10-14  140.219345  139.820496  290.557404  272.773346
2021-10-15  141.272751  140.035477  291.958679  281.010010

<Axes: xlabel='Date'>
<Figure size 640x480 with 1 Axes>

Teilweise verlaufen alle 4 Kurse sehr ähnlich, teilweise aber auch individuell. Sinnvoll ist daher der Übergang zu den Renditen und die Analyse derer Abhängigkeiten.

Ticker          AAPL     GOOGL      MSFT      TSLA
Date                                              
2021-10-11       NaN       NaN       NaN       NaN
2021-10-12 -0.009103 -0.017745 -0.004588  0.017400
2021-10-13 -0.004240  0.008303  0.011711  0.006652
2021-10-14  0.020226  0.025941  0.021734  0.008926
2021-10-15  0.007513  0.001538  0.004823  0.030196
<Axes: xlabel='Date'>
<Figure size 640x480 with 1 Axes>

Während oben bereits der zeitliche Verlauf unterschiedliche Zusammenhänge verdeutlicht, ist die Darstellung in Scatterplots übersichtlicher:

<Figure size 600x600 with 16 Axes>
<Figure size 1000x1000 with 20 Axes>

Natürlich können auch nur einzelne Paare beispielsweise mittels der Seaborn Funktionen scatterplot() oder relplot() dargestellt werden. Auf den ersten Blick unterscheiden sich die Funktionen nicht, allerdings liefert die zweite Funktionen flexiblere Anpassungsmöglichkeiten[5].

<Axes: xlabel='AAPL', ylabel='TSLA'>
<Figure size 640x480 with 1 Axes>
<seaborn.axisgrid.FacetGrid at 0x7f7f3f429fd0>
<Figure size 500x500 with 1 Axes>

Alle Scatter-Plots zeigen einen mehr oder weniger starken positiven Zusammenhang zwischen den Renditen zweier Aktien. Steigt die Rendite der einen Aktie, dann steigt üblicherweise auch die der anderen Aktie und fällt die eine Rendite, dann auch die andere. Die einfachste statistische Maßzahl zur Erfassung des Zusammenhangs sind die (empirische) Kovarianz und Korrelation[6], die allerdings nur den linearen Zusammenhang erfassen. Die (unverzerrte) empirische Kovarianz zweier Stichproben (x,y)=((x1,y1),…,(xn,yn))(x,y)=((x_1,y_1), \ldots, (x_n,y_n)) wird mittels

sxy=1n−1∑i=1n(xi−x‾)(yi−y‾)=1n−1(∑i=1nxiyi−nx‾y‾)s_{xy} = \frac1{n-1} \sum\limits_{i=1}^n (x_i - \overline x)(y_i - \overline y) = \frac 1{n-1} \left(\sum\limits_{i=1}^n x_i y_i - n \overline x \overline y \right)

berechnet. Die Korrelation entsteht durch Normierung und ist einfacher zu interpretieren

rxy=sxysxs˙y=∑i=1n(xi−x‾)(yi−y‾)∑i=1n(xi−x‾)2⋅∑i=1n(yi−y‾)2=∑i=1nxiyi−nx‾y‾(∑i=1nxi2−nx‾2)(∑i=1nyi2−ny‾2)∈[−1,1]\begin{align*} r_{xy} &= \frac{s_{xy}}{s_x \dot s_y} = \frac{\sum\limits_{i=1}^n (x_i - \overline x)(y_i - \overline y)}{\sqrt{\sum\limits_{i=1}^n (x_i - \overline x)^2 \cdot \sum\limits_{i=1}^n (y_i - \overline y)^2}}\\ &= \frac{\sum\limits_{i=1}^n x_i y_i - n \overline x \overline y}{\sqrt{\left(\sum\limits_{i=1}^n x_i^2 - n \overline x^2\right) \left(\sum\limits_{i=1}^n y_i^2 - n \overline y^2 \right)}} \in [-1,1] \end{align*}

Pandas hat die Berechnung der empirischen Kovarianz- und Korrelation bereits implementiert und fasst alle paarweisen Kombinationen in der Kovarianz- bzw. Korrelationsmatrix zusammen. Auf der Diagonalen der Kovarianzmatrix stehen also die Varianzen.

Ticker      AAPL     GOOGL      MSFT      TSLA
Ticker                                        
AAPL    0.000312  0.000183  0.000165  0.000308
GOOGL   0.000183  0.000411  0.000196  0.000316
MSFT    0.000165  0.000196  0.000315  0.000258
TSLA    0.000308  0.000316  0.000258  0.001427
Ticker      AAPL     GOOGL      MSFT      TSLA
Ticker                                        
AAPL    1.000000  0.512426  0.526632  0.461543
GOOGL   0.512426  1.000000  0.543755  0.412807
MSFT    0.526632  0.543755  1.000000  0.384321
TSLA    0.461543  0.412807  0.384321  1.000000

Zum Abschluss zeichnen wir noch die Regressionsgerade in den Scatterplot ein, um den linearen Zusammenhang zu veranschaulichen. Mit Regressionsmodellen beschäftigen wir und noch ausführlich in Abschnitt Regressionsmodelle

<Axes: xlabel='AAPL', ylabel='MSFT'>
<Figure size 640x480 with 1 Axes>

👉Der Zusammenhang der täglichen Log-Returns ist völlig analog zu analysieren und sollte zu Übungszwecken selbstständig durchgeführt werden.

Achtung: Vorsicht bei der Skalierung der ‘zeitlinearen’ Log-Returns um von Tages-Returns zu Jahres-Returns überzugehen

Wir haben bei der Analyse der Tages-Returns gesehen, dass die Unterscheidung zwischen Log-Returns (zeitstetige Returns) und Renditen (arithmetische Returns, zweitdiskrete Returns) nur unwesentliche Unterschiede aufzeigen, da für Tages-Kurse beide Return-Begriffe zu verschiedenen, aber sehr ähnlichen Werten führen. Beide Definitionen haben entscheidente Vor- aber auch Nachteile. Die Log-Returns werden aufgrund ihrer kumulierenten Summeneigenschaft sowie der damit engen Verbindung mit der Normalverteilung (zentraler Grenzwertsatz) häufig für zeitstetige Modelle oder Modelle mit Normalverteilungsannahmen verwendet. Insbesondere ist der Übergang von täglichen zu jährlichen Returns im Gegensatz zu den Renditen sehr einfach. Wir werden in Abschnitt Portfolio-Returns noch sehen, dass sich die Portfoliorendite von der Anfangsinvestition zum Zeitpunkt 0 bis nach tt einfach als gewichtete Summe der Aktien-Renditen von 0 bis tt berechnen lässt, was für Log-Returns nur näherungsweise gilt. Dennoch haben sich aber wegen der einfachereren Skalierbarkeit auch hier die Log-Returns gegenüber den Renditen durchgesetzt.

Werden allgemein die Aktienkurse zu den Zeitpunkten t0,t1,…,tnt_0, t_1, \ldots, t_n gemessen, so kann man die annualisierten Log-Returns (siehe Vorlesungsskript Portfoliooptimierung Prof. Pichler) definieren als

ξij:=1ti−ti−1log⁡(Sj,tiSj,ti−1)=1ti−ti−1rj,(ti−1,ti)\begin{align*} %annu-log-return \xi_i^j := \frac{1}{t_i - t_{i-1}} \log{\left( \frac{S_{j,t_i}}{S_{j,t_{i-1}}}\right)} = \frac{1}{t_i - t_{i-1}} r_{j,(t_{i-1},t_i)} \end{align*}

Dann muss allerdings auch der Gesamt-Return von t0t_0 nach tnt_n annualisiert werden

ξtotal:=1tn−t0log⁡(StnSt0)=1tn−t0rt0,tn=1tn−t0∑i=1nrti−1,ti\begin{align*} % \xi_{total} &:= \frac{1}{t_n - t_{0}} \log{\left( \frac{S_{t_n}}{S_{t_{0}}}\right)} = \frac{1}{t_n - t_{0}} r_{t_0,t_n}\\ &= \frac{1}{t_n - t_{0}} \sum\limits_{i=1}^n r_{t_{i-1},t_i} \end{align*}

Für äquividistante Tagesdaten wählt man ti=i252t_i = \frac{i}{252}, so dass ti−ti−1=1252t_{i}-t_{i-1} = \frac 1 {252}, für Monatskurse i12\frac{i}{12} erhält man entsprechend ti−ti−1=112t_i - t_{i-1} = \frac 1{12} und für Quartalsdaten ti=i4t_i=\frac{i}{4} entsprechend ti−ti−1=14t_i - t_{i-1} = \frac 1{4}.

mean daily R Ticker
AAPL     0.000869
GOOGL    0.000946
MSFT     0.000648
TSLA     0.000990
dtype: float64: 
 
geometric mean daily R Ticker
AAPL     0.000713
GOOGL    0.000741
MSFT     0.000491
TSLA     0.000280
dtype: float64: 

check: geo mean Rendite = exp(mean daily log)-1 = Ticker
AAPL     0.000713
GOOGL    0.000741
MSFT     0.000491
TSLA     0.000280
dtype: float64 

Daily log-returns Ticker
AAPL     0.000713
GOOGL    0.000741
MSFT     0.000491
TSLA     0.000280
dtype: float64: 

mu year (Log-Returns r) Ticker
AAPL     0.179719
GOOGL    0.186768
MSFT     0.123804
TSLA     0.070603
dtype: float64: 
 
mu_tilde year (Renditen R) Ticker
AAPL     0.244617
GOOGL    0.269101
MSFT     0.177283
TSLA     0.283333
dtype: float64: 
 
Approximation1 : mu_tilde_year = mu_tilde * trading days Ticker
AAPL     0.218923
GOOGL    0.238422
MSFT     0.163262
TSLA     0.249584
dtype: float64
 
Approximation2: exp(mu_year) -1  Ticker
AAPL     0.196881
GOOGL    0.205347
MSFT     0.131794
TSLA     0.073155
dtype: float64: 

Ticker          AAPL     GOOGL      MSFT      TSLA
Date                                              
2021-10-11       NaN       NaN       NaN       NaN
2021-10-12 -0.009145 -0.017904 -0.004599  0.017251
2021-10-13 -0.004249  0.008269  0.011643  0.006630
2021-10-14  0.020024  0.025610  0.021501  0.008887
2021-10-15  0.007484  0.001536  0.004811  0.029749
Ticker          AAPL     GOOGL      MSFT      TSLA
Date                                              
2026-10-02  0.010151  0.015431  0.009182  0.045489
2026-10-05 -0.002400  0.008609  0.014673  0.021727
2026-10-06  0.002220  0.003486  0.007814  0.005136
2026-10-07  0.009071  0.008078  0.000869 -0.007568
2026-10-08  0.011077 -0.006325 -0.013589 -0.007465
Tage insgesamt: 1823, Jahre: 4.994520547945205
Ticker          AAPL     GOOGL      MSFT       TSLA
Date                                               
2021-10-11       NaN       NaN       NaN        NaN
2021-10-12 -3.337872 -6.534982 -1.678553   6.296475
2021-10-13 -1.550959  3.018236  4.249708   2.420078
2021-10-14  7.308769  9.347649  7.847879   3.243706
2021-10-15  2.731834  0.560775  1.756060  10.858412
Ticker          AAPL     GOOGL      MSFT       TSLA
Date                                               
2026-10-02  3.704940  5.632475  3.351309  16.603398
2026-10-05 -0.292034  1.047444  1.785275   2.643483
2026-10-06  0.810468  1.272484  2.852223   1.874468
2026-10-07  3.310788  2.948547  0.317089  -2.762207
2026-10-08  4.043078 -2.308704 -4.959851  -2.724868
Ticker
AAPL     0.271068
GOOGL    0.201802
MSFT     0.170217
TSLA    -0.075175
dtype: float64
Annualized covarince R (percentege changes)
Ticker      AAPL     GOOGL      MSFT      TSLA
Ticker                                        
AAPL    0.126507  0.074582  0.062165  0.128635
GOOGL   0.074582  0.175175  0.075347  0.134677
MSFT    0.062165  0.075347  0.114360  0.101174
TSLA    0.128635  0.134677  0.101174  0.710268
Approx1: Annualized covarince R (percentege changes): Sigma pprox Sigma_tilde
Ticker      AAPL     GOOGL      MSFT      TSLA
Ticker                                        
AAPL    0.078194  0.045949  0.041329  0.077192
GOOGL   0.045949  0.103146  0.049183  0.079374
MSFT    0.041329  0.049183  0.078696  0.064653
TSLA    0.077192  0.079374  0.064653  0.357946
Approx2: Annualized covarince R (percentege changes): yearly cov = daily cov * 252
Ticker      AAPL     GOOGL      MSFT      TSLA
Ticker                                        
AAPL    0.078651  0.046225  0.041617  0.077612
GOOGL   0.046225  0.103461  0.049283  0.079616
MSFT    0.041617  0.049283  0.079398  0.064933
TSLA    0.077612  0.079616  0.064933  0.359525
Annualized covariance r (log retunrs)
Ticker      AAPL     GOOGL      MSFT      TSLA
Ticker                                        
AAPL    0.078194  0.045949  0.041329  0.077192
GOOGL   0.045949  0.103146  0.049183  0.079374
MSFT    0.041329  0.049183  0.078696  0.064653
TSLA    0.077192  0.079374  0.064653  0.357946
Ticker
AAPL     0.179719
GOOGL    0.186768
MSFT     0.123804
TSLA     0.070603
dtype: float64
Ticker
AAPL     0.179719
GOOGL    0.186768
MSFT     0.123804
TSLA     0.070603
dtype: float64
Ticker       AAPL      GOOGL       MSFT       TSLA
Ticker                                            
AAPL    19.704869  11.579229  10.414851  19.452449
GOOGL   11.579229  25.992810  12.394210  20.002222
MSFT    10.414851  12.394210  19.831430  16.292549
TSLA    19.452449  20.002222  16.292549  90.202402
Ticker      AAPL     GOOGL      MSFT      TSLA
Ticker                                        
AAPL    0.078194  0.045949  0.041329  0.077192
GOOGL   0.045949  0.103146  0.049183  0.079374
MSFT    0.041329  0.049183  0.078696  0.064653
TSLA    0.077192  0.079374  0.064653  0.357946

Portfolio-Returns

Aus den obigen 4 Aktien stellen wir jetzt ein Portfolio zusammen und investieren 1000$ zu 10% in 1. Aktie (AAPL), 30% in 2. Aktie (MSFT), 40% in 3. Aktie (GOOGL) und die verbleibenden 20% in 4.Aktie (TSLA) und schichten das Portfolio im Folgenden nicht mehr um. Die Gewichtung ist hier übrigens absolut willkürlich gewählt und kann beliebig geändert werden. Uns interessiert die Wertentwicklung des Portfolios und daher betrachten wir die Portfolio-Returns bzw. Renditen.

Achtung wenn der Vektor mit den Aktientickern wie in diesem Beispiel nicht alphabetisch sortiert ist, kann es beim Zugriff auf die Kurs-Daten der Aktien und Returns Probleme mit der Reihenfolge geben, da die Download-Funktion von yfinance diese automatisch sortiert und somit nicht mehr der ursprünglichen Reihenfolge entspricht. Beim Berechnen der Portfoliowerte und -Returns ist die Reihenfolge allerdings wesentlich. Greift man den DataFrame direkt auf dem Array der Ticker ab, erzwingt man die ursprüngliche Reihenfolge.

['AAPL', 'MSFT', 'GOOGL', 'TSLA']
Ticker            AAPL       GOOGL        MSFT        TSLA
Date                                                      
2021-10-11  139.292770  137.604599  282.380615  263.980011
2021-10-12  138.024765  135.162842  281.084991  268.573334
2021-10-13  137.439514  136.285156  284.376801  270.359985
2021-10-14  140.219345  139.820496  290.557404  272.773346
2021-10-15  141.272751  140.035477  291.958679  281.010010
Ticker            AAPL        MSFT       GOOGL        TSLA
Date                                                      
2021-10-11  139.292770  282.380615  137.604599  263.980011
2021-10-12  138.024765  281.084991  135.162842  268.573334
2021-10-13  137.439514  284.376801  136.285156  270.359985
2021-10-14  140.219345  290.557404  139.820496  272.773346
2021-10-15  141.272751  291.958679  140.035477  281.010010
Kalendertage = 1823, Handelstage = 1254, Jahre (Handelstage) = 4.976190476190476, Jahre (Kalendertage) =4.994520547945205

Wir nutzen dann später die Tages-Daten zur Schätzung der Kovarianz-Matrix und des Erwartungswertvektors der Returns, die wir zur Berechnung der erwarteten Portfolio-Returns sowie -Varianz benötigen.

Wird in t=0t=0 das Portfolio aus jeweils aja_j Stocks zum Preis Sj,0S_{j,0} zusammengesetzt (j=1,…,Jj=1, \ldots,J), gilt für den jeweiligen Portfolioanteil der jj-ten Aktie

wj=ajSj,0P0⇔aj=wjP0Sj,0w_j = \frac{a_j S_{j,0}}{P_0} \qquad \Leftrightarrow \qquad a_j = \frac{w_j P_0}{S_{j,0}}

mit ∑j=1Jwj=1\sum\limits_{j=1}^J w_j = 1, wobei P0=a1S1,0+…+aJSJ,0=aTS0=S0TaP_0 = a_1 S_{1,0} + \ldots + a_J S_{J,0} = a^T S_0 = S_0^T a den investierte Gesamtbetrag beschreibt. Letztere Gleichung gilt für die Vektoren der Anzahl gekaufter Aktien aT=(a1,…,aJ)a^T = (a_1, \ldots, a_J) und den Vektor der Startkurse S0T=(S1,0,…,SJ,0)S_0^T=(S_{1,0}, \ldots, S_{J,0}) zur Investitionszeit in t=0t=0.

['AAPL', 'MSFT', 'GOOGL', 'TSLA']
Summe der Portfoliogewichte = 1.000000
Ticker            AAPL        MSFT       GOOGL        TSLA
Date                                                      
2021-10-11  139.292770  282.380615  137.604599  263.980011
2021-10-12  138.024765  281.084991  135.162842  268.573334
2021-10-13  137.439514  284.376801  136.285156  270.359985
2021-10-14  140.219345  290.557404  139.820496  272.773346
2021-10-15  141.272751  291.958679  140.035477  281.010010
Ticker            AAPL       GOOGL        MSFT        TSLA
Date                                                      
2021-10-11  139.292770  137.604599  282.380615  263.980011
2021-10-12  138.024765  135.162842  281.084991  268.573334
2021-10-13  137.439514  136.285156  284.376801  270.359985
2021-10-14  140.219345  139.820496  290.557404  272.773346
2021-10-15  141.272751  140.035477  291.958679  281.010010
Type: <class 'pandas.DataFrame'>
kaufen in t=0 Stückzahl Ticker
AAPL     0.717912
MSFT     1.062396
GOOGL    2.906880
TSLA     0.757633
Name: 2021-10-11 00:00:00, dtype: float64 

 zum Preis Ticker
AAPL     139.292770
MSFT     282.380615
GOOGL    137.604599
TSLA     263.980011
Name: 2021-10-11 00:00:00, dtype: float64 

 für insgesamt  1000.0 Dollar
np.float64(1000.0)

Damit können wir jetzt natürlich auch den Wert des Portfolios zu jedem späteren Zeitpunkt berechnen. Wird das Portfolio bis zum Zeitpunkt t>0t>0 nicht umgeschichtet, haben die Aktienkurse den Wert StT=(S1,t,…,SJ,t)S_t^T = (S_{1,t}, \ldots, S_{J,t}) und somit das Portfolio den Wert

Pt=∑j=1najSj,t=aTSt=StTa.P_t = \sum\limits_{j=1}^n a_j S_{j,t} = a^T S_t = S_t^T a.

Es bietet sich hierfür an die von Pandas bereitgestellten Matrix-Vektor-Operationen zu verwenden, denn die letzte Summe entspricht einfach dem Skalarprodukt zweier Vektoren[7] und die Berechnung der Spalte aller Portfoliowerte über die Zeit entspricht entsprechend einer Matrix-Vektor-Multiplikation, die in Pandas mittels der dot() Funktion bereitgestellt wird (Doku Pandas). Wichtig ist allerdings, dass im DataFrame die Spalten in der gleichen Reihenfolge stehen, wie in den Vektoren - wir haben den DataFrame portfolio extra auf die Ticker-Reihenfolge angepasst, alternativ kann auch immer automatsichen mittels portfolio[tickers] explizit auf die Spalten der Aktien in der enstprechenden Reihenfolge zugegriffen werden.

Ticker
AAPL     0.717912
MSFT     1.062396
GOOGL    2.906880
TSLA     0.757633
Name: 2021-10-11 00:00:00, dtype: float64
[0.71791235 1.06239587 2.90687959 0.75763312]
Ticker            AAPL        MSFT       GOOGL        TSLA    Portfolio
Date                                                                   
2021-10-11  139.292770  282.380615  137.604599  263.980011  1000.000000
2021-10-12  138.024765  281.084991  135.162842  268.573334   994.095377
2021-10-13  137.439514  284.376801  136.285156  270.359985  1001.788482
2021-10-14  140.219345  290.557404  139.820496  272.773346  1022.455652
2021-10-15  141.272751  291.958679  140.035477  281.010010  1031.565908
<Axes: xlabel='Date'>
<Figure size 640x480 with 1 Axes>

Berechnung der Portfolio-Rendite

Für die Portfolio-Rendite, also den prozentualen Zuwachs bis zum Zeitpunkt tt des Portfolios gilt wegen

RtP=PtP0−1=∑j=1JajSj,tP0−1=∑j=1najSj,0P0Sj,tSj,0−1=∑j=1nwj(Sj,tSj,0−1)=∑j=1nwjRj,t=RtT⋅w=wT⋅Rt,\begin{align*} %eq-weigthed-ret R^P_t &= \frac{P_t}{P_0}-1 = \sum\limits_{j=1}^J a_j \frac{S_{j,t}}{P_0} - 1 = \sum\limits_{j=1}^n a_j \frac{S_{j,0}}{P_0} \frac{S_{j,t}}{S_{j,0}} - 1 \\ &= \sum\limits_{j=1}^n w_j \left(\frac{S_{j,t}}{S_{j,0}} - 1 \right) = \sum\limits_{j=1}^n w_j R_{j,t} = R_t^T \cdot w = w^T \cdot R_t, \end{align*}

d. h. die Portfolio-Rendite ergibt sich als die gewichtete Summe der Aktien-Renditen Rj,t=Sj,tSj,0−1R_{j,t}=\frac{S_{j,t}}{S_{j,0}} - 1 und kann bequem mittels Vektoren Rt=(R1,t,…,RJ,t)TR_t = (R_{1,t}, \ldots, R_{J,t})^T und Gewichtsvektor w=(w1,…,wJ)Tw = (w_1, \ldots, w_J)^T auch wieder als Matrix-Vektor Produkt geschrieben werden. Für die Log-Returns gilt diese Beziehung zumindest näherungsweise, wie wir hier für unser Beispiel-Portfolio illustrieren.

Ticker            AAPL        MSFT       GOOGL        TSLA    Portfolio
Date                                                                   
2021-10-11  139.292770  282.380615  137.604599  263.980011  1000.000000
2021-10-12  138.024765  281.084991  135.162842  268.573334   994.095377
2021-10-13  137.439514  284.376801  136.285156  270.359985  1001.788482
2021-10-14  140.219345  290.557404  139.820496  272.773346  1022.455652
2021-10-15  141.272751  291.958679  140.035477  281.010010  1031.565908
Ticker          AAPL      MSFT     GOOGL      TSLA  Portfolio  Days_Diff
Date                                                                    
2021-10-11       NaN       NaN       NaN       NaN        NaN        NaN
2021-10-12 -0.009103 -0.004588 -0.017745  0.017400  -0.005905        1.0
2021-10-13 -0.004240  0.011711  0.008303  0.006652   0.007739        1.0
2021-10-14  0.020226  0.021734  0.025941  0.008926   0.020630        1.0
2021-10-15  0.007513  0.004823  0.001538  0.030196   0.008910        1.0
<Figure size 640x480 with 1 Axes>

Die Eigenschaft RtP=wTRtR_t^P = w^T R_t gilt allerdings nur für die Renditen von 0 bis t und nicht für die täglichen, wie die folgende Rechnung zeigt:

Ticker          AAPL      MSFT     GOOGL      TSLA  Portfolio  Days_Diff  \
Date                                                                       
2021-10-11       NaN       NaN       NaN       NaN        NaN        NaN   
2021-10-12 -0.009103 -0.004588 -0.017745  0.017400  -0.005905        1.0   
2021-10-13 -0.004240  0.011711  0.008303  0.006652   0.007739        1.0   
2021-10-14  0.020226  0.021734  0.025941  0.008926   0.020630        1.0   
2021-10-15  0.007513  0.004823  0.001538  0.030196   0.008910        1.0   

Ticker      dot_version  
Date                     
2021-10-11          NaN  
2021-10-12    -0.005905  
2021-10-13     0.007741  
2021-10-14     0.020704  
2021-10-15     0.008852  
Ticker      Portfolio  dot_version         check
Date                                            
2021-10-11        NaN          NaN           NaN
2021-10-12  -0.005905    -0.005905  1.040834e-17
2021-10-13   0.001788     0.001788 -4.423545e-17
2021-10-14   0.022456     0.022456 -4.510281e-17
2021-10-15   0.031566     0.031566 -1.526557e-16
<Figure size 640x480 with 1 Axes>
kumulierte Renditen: 2-Norm Fehler = 5.306068291708575e-14 (gerundet:   0.000000)

Wir sehen dass die beiden Spalten ‘Portfolio’, bei dem die Zuwachsraten von 0 bis t direkt aus den Portfoliowerten, und die Spalte ‘dot_version’, bei dem die kumulierten Portfolio-Renditen als gewichtete Summe wie in Formel eq-weigthed-ret berechnet wurden bis auf minimale numerische Fehler (Spalte ‘check’ mit Norm nahe Null) tatsächlich übereinstimmen.

<Axes: xlabel='Date'>
<Figure size 640x480 with 1 Axes>

Ein Plot der kumulierten Returns aller einzelnen Aktien sowie des Portfolios zeigt die Diversifikationseffekte recht deutlich, denn die Volatilität der Tesla-Aktie, in die 20% investiert wurde, wird deutlich ausgeglättet, obwohl alle Renditen einen positiven Zusammenhang aufweisen.

<Axes: xlabel='Date'>
<Figure size 640x480 with 1 Axes>

Die Berechnung der Log-Returns des Portfolios läuft analog (aus Bequemlichkeit rechnen wir hier einfach die Renditen in Log-Returns nach Formel Rendite vs. Log-Returns um, allerdings kann man wie oben gezeigt auch direkt die Log-Returns mittels diff() Operator ausrechnen

<Figure size 640x480 with 1 Axes>
Ticker          AAPL      MSFT     GOOGL      TSLA  Portfolio  Days_Diff
Date                                                                    
2021-10-11       NaN       NaN       NaN       NaN        NaN        NaN
2021-10-12 -0.009145 -0.004599 -0.017904  0.017251  -0.005922        1.0
2021-10-13 -0.004249  0.011643  0.008269  0.006630   0.007709        1.0
2021-10-14  0.020024  0.021501  0.025610  0.008887   0.020420        1.0
2021-10-15  0.007484  0.004811  0.001536  0.029749   0.008871        1.0
Ticker          AAPL      MSFT     GOOGL      TSLA  Portfolio
Date                                                         
2021-10-11       NaN       NaN       NaN       NaN        NaN
2021-10-12 -0.009145 -0.004599 -0.017904  0.017251  -0.005922
2021-10-13 -0.004249  0.011643  0.008269  0.006630   0.007709
2021-10-14  0.020024  0.021501  0.025610  0.008887   0.020420
2021-10-15  0.007484  0.004811  0.001536  0.029749   0.008871

Übergang von täglichen Returns zu kumulierten Returns:

Ticker      Portfolio  dot_version     check
Date                                        
2021-10-11        NaN          NaN       NaN
2021-10-12  -0.005922    -0.006006  0.000083
2021-10-13   0.001787     0.001696  0.000091
2021-10-14   0.022207     0.022170  0.000037
2021-10-15   0.031078     0.030926  0.000152
<Figure size 640x480 with 1 Axes>
kumulierte Log-Returns: 2-Norm Fehler = 0.6785805111416536 (gerundet:   0.678581)
<Axes: xlabel='Date'>
<Figure size 640x480 with 1 Axes>

Wir sehen also, dass für die kumulierten Log-Returns des Portfolios zumindest näherungsweise rtP≈wT⋅rtr_t^P \approx w^T \cdot r_t gilt. Die Graphiken zeigen, dass der Fehler überschaubar ist.

Zufalls-Modell

Wir haben im vorherigen Abschnitt gesehen, dass für die Portfolio-Rendite RtP=wtRtR^P_t = w^t R_t gilt und für die Log-Returns diese Beziehung in sehr guter Näherung gilt. Aus diesem Grund wird der zufällige Portfolio-Return häufig mittels

RtP=wTRtR^P_t = w^T R_t

unabhängig von der tatsächlich verwendeten Return-Definition angesetzt, wobei der Vektor der Aktien-Returns bis zum Zeitpunkt t als Zufallsvariable modelliert wird. Die Porfolio-Theorie beschäftigt sich mit einer geeigneten Wahl des Gewichtsvektors unter verschiedenen Risiko-Kriterien. Im klassichen Markowitz Modell geht man davon aus, dass die zufällige Rendite RtT=(R1,t,…,RJ,t)∼NJ(μt,Σt)R_t^T = (R_{1,t},\ldots, R_{J,t}) \sim \mathcal{N}_J(\mu_t, \Sigma_t) aller Aktien einer multivariaten Normalverteilung genügt und daher durch die ersten beiden Momente μt=ERt\mu_t = \mathbb{E}R_t und Σt=cov⁡(Rt)\Sigma_t = \operatorname{cov}(R_t) vollständig das Zufallsverhalten charakterisieren. Für beliebig verteilte Zufallsvektoren reichen die ersten beiden Momente der Verteilung nicht. Wir haben oben gesehen, dass Log-Returns (zeitstetige Modelle) und die prozentualen Renditen (zeitdiskrete Modelle, arithmetische Returns) sich zwar leicht unterscheiden und aus mathematischer Sicht jeweils Vor- und Nachteile mitbringen. Während die Log-Returns aufgrund ihrer Additivität eher mit der Normalverteilungsannahme[8] einhergehen, folgen die Renditen dann wegen Formel Rendite vs. Log-Returns einer Log-Normalverteilung.

Ein weiterer Vorteil der Log-Returns gegenüber den Renditen ist die einfachere Skalierbarkeit der ersten beiden Momente Σ\Sigma und μ\mu, so dass diese aus den vorhandenen Tages-Returns geschätzt werden können und dann wie in Abschnitt Annualisierte Returns beschrieben, einfach auf den Anlagezeitraum von 0 bis t skaliert werden können. Daher werden häufig die Log-Returns in der Finanzmathematik und insbesondere in der Portfolio-Theorie verwendet. Häufig unterstellt man für effiziente Finanzmärkte die Unkorreliertheit der Tages-Returns zwischen verschiedenen Handelstagen, wie wir das auch für die Skalierung der annualizierten Momente ausgenutzt haben, so dass alle relevanten und verfügbaren Informationen über die Aktiengesellschaften tatsächlich schon in den aktuellen Kursen eingepreist sind.

Portfolioanalyse: erwarteter Portfolio-Return und Portfolio-Varianz

Wegen Formel (46) können wir die erwartete Rendite ERtP=μtTw\mathbb{E} R^P_t = \mu_t ^T w sowie die Portfolio-Varianz einfach mittels der ersten beiden Momente des Zufalls-Vektors RtT=(R1,t,…,RJ,t)R_t^T = (R_{1,t}, \ldots, R_{J,t}) der Aktien-Returns μt=ERt\mu_t = \mathbb{E} R_t sowie Σt=(⁡Rt)=E(Rt−ERt)(Rt−ERt)T\Sigma_t = \operatorname(R_t) = \mathbb{E} \left( R_t - \mathbb{E} R_t \right) \left(R_t - \mathbb{E} R_t \right)^T ableiten

ERtP=E(RtT⋅w)=(ERtT)⋅w=μtT⋅wVar⁡(RtP)=E((RtT⋅w−E(RtT⋅w))T(RtT⋅w−E(RtT⋅w)))=wT{E(Rt−ERt)(Rt−ERt)T}w=wTΣtw\begin{align*} \mathbb{E} R_t^P &= \mathbb{E} \left( R_t^T \cdot w \right) = \left( \mathbb{E} R_t^T \right) \cdot w = \mu_t^T \cdot w \\ \operatorname{Var} (R_t^P) &= \mathbb{E} \left( \left( R_t^T \cdot w - \mathbb{E}(R_t^T \cdot w) \right)^T \left( R_t^T \cdot w - \mathbb{E}(R_t^T \cdot w) \right) \right)\\ &= w^T \left\lbrace \mathbb{E} \left( R_t - \mathbb{E} R_t \right) \left(R_t - \mathbb{E} R_t \right)^T \right\rbrace w\\ &= w^T \Sigma_t w \end{align*}

Üblicherweise werden, wie in Annualisierte Returns beschrieben, aus den Tages-Log-Returns mit Hilfe des arithmetsichen Mittels die erwarteten Tages-Returns bzw. Renditen geschätzt sowie deren Kovarianzmatrix berechnet und anschließend durch Skalierung annualisiert und verwendet den Zusammenhang zwischen arithmetischen und geometrischen Mittel zur Annualisierung der Renditen. Da wir streng genommen diese Annualisierung nur für die Log-Returns einfach berechnen können, kann man aber danach wieder zu den Renditen mittels Formel Rendite vs. Log-Returns übergehen. In der Praxis wird das nicht immer so konsequent unterschieden, aber wir haben ja gesehen, dass die Unterschiede zwischen Log-Returns und Renditen für kleinere Zeiträume nicht so deutlich sind, die folgenden Rechnungen zeigen dennoch die Probleme bei der Approximation auf. Aus diesem Grund wird tatsächlich bevorzugt mit den Log-Returns in der Portfolio-Theorie gearbeitet.

Ticker
AAPL     0.179719
MSFT     0.123804
GOOGL    0.186768
TSLA     0.070603
dtype: float64
mean daily R Ticker
AAPL     0.000869
MSFT     0.000648
GOOGL    0.000946
TSLA     0.000990
dtype: float64: 
 
geometric mean daily R Ticker
AAPL     0.000713
MSFT     0.000491
GOOGL    0.000741
TSLA     0.000280
dtype: float64: 

check: geo mean Rendite = exp(mean daily log)-1 = Ticker
AAPL     0.000713
MSFT     0.000491
GOOGL    0.000741
TSLA     0.000280
dtype: float64 

Daily log-returns Ticker
AAPL     0.000713
MSFT     0.000491
GOOGL    0.000741
TSLA     0.000280
dtype: float64: 

Wir sehen Abweichungen zwischen den geometrischen und arithmetischen Mittelwerten der täglichen Renditen bzw. Log-Returns. Außerdem sehen wir den den nichtlineare Zusammenhang zwischen mittleren Log-Returns und geometrischen Mittel der Renditen. Nun werden diese Mittel annualisiert.

mu year (Log-Returns r) Ticker
AAPL     0.179719
MSFT     0.123804
GOOGL    0.186768
TSLA     0.070603
dtype: float64: 
 
mu_tilde year (Renditen R) Ticker
AAPL     0.244617
MSFT     0.177283
GOOGL    0.269101
TSLA     0.283333
dtype: float64: 
 
Approximation1 für Renditen: mu_tilde_year = mu_tilde * trading days_per_year Ticker
AAPL     0.218923
MSFT     0.163262
GOOGL    0.238422
TSLA     0.249584
dtype: float64
 
Approximation2 für Renditen: exp(mu_year) -1  Ticker
AAPL     0.196881
MSFT     0.131794
GOOGL    0.205347
TSLA     0.073155
dtype: float64: 

Die Auswirkungen auf die erwartete jährliche Portfoliorendite je nach Berechnungsart:

erwartete annualisierte Portfoliorendite: 
  0.241954 (mu_tilde_year -- Rendite correct) 
  0.143941 (mu_year -- Log-Returns) 
  0.216157 (Approx1 Rendite) 
  0.155996 (Approx2 Rendite) 

Die 1. Approximation liefert bessere Ergebnisse für die Renditen, allerdings ist dieser Ansatz bei der Approximation der Kovarianz zu grob.

Kovarianz- und Korrelationsmatzrix für Log-Returns

Tages vs. Jahres-Kovarianz für Log-Returns
Ticker      AAPL      MSFT     GOOGL      TSLA
Ticker                                        
AAPL    0.000310  0.000164  0.000182  0.000306
MSFT    0.000164  0.000312  0.000195  0.000257
GOOGL   0.000182  0.000195  0.000409  0.000315
TSLA    0.000306  0.000257  0.000315  0.001420
Ticker      AAPL      MSFT     GOOGL      TSLA
Ticker                                        
AAPL    0.078194  0.041329  0.045949  0.077192
MSFT    0.041329  0.078696  0.049183  0.064653
GOOGL   0.045949  0.049183  0.103146  0.079374
TSLA    0.077192  0.064653  0.079374  0.357946

Kovarianz- und Korrelationsmatzrix für Renditen

Tages vs. Jahres-Kovarianz für R
Ticker      AAPL      MSFT     GOOGL      TSLA
Ticker                                        
AAPL    0.000312  0.000165  0.000183  0.000308
MSFT    0.000165  0.000315  0.000196  0.000258
GOOGL   0.000183  0.000196  0.000411  0.000316
TSLA    0.000308  0.000258  0.000316  0.001427
Ticker      AAPL      MSFT     GOOGL      TSLA
Ticker                                        
AAPL    0.126507  0.066992  0.069207  0.128635
MSFT    0.066992  0.132811  0.075347  0.109031
GOOGL   0.069207  0.075347  0.150839  0.124972
TSLA    0.128635  0.109031  0.124972  0.710268
Approx1 für R: Sigma pprox Sigma_tilde
Ticker      AAPL      MSFT     GOOGL      TSLA
Ticker                                        
AAPL    0.078651  0.041617  0.046225  0.077612
MSFT    0.041617  0.079398  0.049283  0.064933
GOOGL   0.046225  0.049283  0.103461  0.079616
TSLA    0.077612  0.064933  0.079616  0.359525
Approx2 für R: cov(R) = cov(e^r - 1) = cov(e^r) approx e^r cov(r) (e^r)^T (Delta-Methode für R_t = exp(r_t) - 1)
               0         1         2         3
Ticker                                        
AAPL    0.112015  0.052940  0.066758  0.088899
MSFT    0.059204  0.100806  0.071457  0.074458
GOOGL   0.065823  0.063002  0.149857  0.091412
TSLA    0.110580  0.082818  0.115319  0.412233

Die deutlich bessere 2. Approximation basiert auf der Delta-Methode.

Portvoliovarianz berechnet:

Für die Log-Returns

0.08019135761419721
0.08019135761419721

Für die Renditen

0.13162722468717047
0.08052506529875084
0.10542641082539309
annualisierte Varianz der Portfolio-Rendite: 
  0.131627 (korrekt) 
  0.080525 (Approx1) 
  0.105426 (Approx2) 

Footnotes
  1. Die Indexierung des Datums kann einfach mittels Aufruf der Funktion dataframe.set_index('Date') gesetzt werden.

  2. Standardmäßig basiert der Kerndichteschätzer auf glockenförmig überlagerten Gaussfunktionen, es können allerdings auch andere Kernels zur Schätzung verwendet werden, hier soll darauf allerdings nicht weiter eingegangen werden. Beispielsweise liefert das Statsmodels-Package verschiedene andere Kernels.

  3. Die Parameter der Normalverteilung werden mittels der Funktion fit() vpm Normalverteilungs-Sub-Package geschätzt, können aber natürlich auch einfach mittels aritmetischen Mittel und empirischer Standardabweichung aus dem Numpy-Package geschätzt werden.

  4. Die Funktion relplot() erzeugt sogenannte ‘relational plots’ und kann neben Scatter-Plots auch Line-Plots erzeugen und kann im Gegensatz zu scatterplot() mehrere Sub-Plots in einer Graphik darstellen. Für Details und Beispiele verweisen wir hier auf die Seaborn-Doku.

  5. Die Kovarianz zweier Zufallsvariablen XX und YY ist definiert als cov⁡(X,Y)=E(X−E)(Y−EY)=E(XY)−EX⋅EY\operatorname{cov}(X,Y) = \mathbb{E}(X-\mathbb{E})(Y-\mathbb{E}Y)=\mathbb{E}(XY)-\mathbb{E}X \cdot \mathbb{E}Y und die Korrelation nach Pearson cor⁡(X,Y)=cov⁡(X,Y)Var⁡(X)⋅VarY⁡∈[−1,1]\operatorname{cor}(X,Y) = \frac{\operatorname{cov}(X,Y)}{\sqrt{\operatorname{Var}(X) \cdot \operatorname{Var{Y}}}} \in [-1,1] skaliert die Werte für eine bessere Interpretierbarkeit. Aus Unabhängigkeit folgt wegen EXY=EX⋅EY\mathbb{E} XY = \mathbb{E} X \cdot \mathbb{E} Y gerade cov⁡(X,Y)=0\operatorname{cov}(X,Y)=0 und somit Unkorreliertheit, die Rückrichtung gilt allerdings im Allgemeinen nicht, beispielsweise sind X∼N(0,1)X \sim \mathcal{N}(0,1) und Y=X2Y=X^2 offensichtlich abhängig (quadratischer Zusammenhang), aber unkorrelierte Zufallsvariablen da cov⁡(X,Y)=E(XY)−EX⋅EY=E(X3)=0\operatorname{cov}(X,Y)= \mathbb{E}(XY)-\mathbb{E}X \cdot \mathbb{E}Y = \mathbb{E}(X^3) = 0 gilt.

  6. Das Skalarprodukt zwischen dem Vektor St=(S1,t,…,SJ,t)TS_t = (S_{1,t}, \ldots, S_{J,t})^T der Aktienkurs zum Zeitpunkt tt und dem Vektor der Stückzahlen a=(a1,…,aJ)Ta = (a_1, \ldots, a_J)^T wird wie folgt berechnet.

    <St,a>=StT⋅a=∑j=1JSj,taj=Pt<S_t,a> = S_t^T \cdot a = \sum\limits_{j=1}^J S_{j,t} a_j = P_t

    Fassen wir nun alle Kurse der 4 Aktien (Spalten) über die Zeit als Matrix ST={Sj,t}j=1,…,J,t=0,1,…,nS^T = \left\lbrace S_{j,t} \right\rbrace_{j=1,\ldots,J, t=0,1, \ldots, n} auf, dann ist STa=(P0,P1,…)TS^T a = (P_0, P_1, \ldots)^T gerade der Vektor aller Portfoliowerte.

  7. Für die Log-Returns von 0 bis zum Zeitpunkt t gilt rt=log⁡(StS0)=∑i=1tri−1,ir_{t} = \log{\left(\frac{S_t}{S_0}\right)} = \sum\limits_{i=1}^t r_{i-1,i}, d. h. wenn wir die täglichen Log-Returns als iid (identisch und unabhängig verteilt) annehmen, so folgt aus dem zentralen Grenzwertsatz automatisch die Normalverteilung der Summe rtr_{t}. Obige Auswertung hat gezeigt, dass die täglichen Returns zwar von einer Normalverteilung abweichen, aber dennoch einen glockenförmige Verteilung besitzen.