Réduire au minimum la variance « intuitivement »

Question

Nous avons un problème se pose la gestion d'actifs. Je pense (et espoir), il soulève des questions assez intéressantes pour ce forum pour l'examiner. Nous avons fait des recherches approfondies assez de la littérature et de trouver des choses qui parlent autour de cette question, mais rien ayant trait directement à la question.

Historique

Nous avons des données de séries chronologiques pour les actifs, à partir de laquelle on calcule une matrice de corrélation. Pour 5 actifs à l'aide de Mathematica, il pourrait ressembler à ceci:

m = Correlation[data]

{{1.0, 0.635562, 0.698852, 0.404792, -0.32746}, {0.635562, 1.0, 0.410075, 0.314375, -0.0636438}, {0.698852, 0.410075, 1.0, 0.374416, -0.260137}, {0.404792, 0.314375, 0.374416, 1.0, 0.293135}, {-0.32746, -0.0636438, -0.260137, 0.293135, 1.0}}

m //TableForm

1.000000, 0.635562, 0.698852, 0.404792, -0.32746

0.635562, 1.000000, 0.410075, 0.314375, -0.0636438

0.698852, 0.410075, 1.000000, 0.374416, -0.260137

0.404792, 0.314375, 0.374416, 1.000000, 0.293135

-0.32746, -0.0636438, -0.260137, 0.293135, 1.000000

Dans une gestion d'actifs veut diversification. Si deux ou plusieurs actifs dans un corrélat de portefeuille trop fortement concentrés plutôt que de diversifier le risque.

Ce que nous voulons

Nous voulons une approche ou une méthode pour construire un portefeuille d'actifs qui minimise le risque de « concentration » du portefeuille tout en tenant toujours une position dans tous les instruments

Je vais illustrer le risque de concentration avec quelques exemples ci-dessous, mais d'abord ...

Pourquoi est-ce un problème intéressant ou une question?

Un couple de choses font une question intéressante et stimulante:

Bien que lié à « frontière efficace », nous avons aucune hypothèse sur le rendement futur des instruments individuels à utiliser.

variance Minimisation donne une réponse, mais pas satisfaire intuitivement ou même utile.

analyse en composantes principales semble un moyen naturel de regarder, mais ne semble pas non plus de nous donner ce dont nous avons besoin.

Nous avons cherché à utiliser la maximisation d'entropie, mais alors que l'un de nos gars familiers avec l'entropie discrète pensé qu'il semblait prometteur, quand nous avons essayé de penser à cela en termes d'entropie continue, il a prouvé une impasse. Le code suivant donne une idée de ce que nous avons examiné (pas certain qu'il fonctionne en fait):

(* This function computes the distribution of returns, given a \
distribution of price movements.*)

returnDistribution[P_, n_] := Module[ {xv, wv},
  wv = Array[w, n];
  xv = Array[x, n];
  varsInPlane = 
   Append[Delete[xv, n], (r - Total[Delete[wv*xv, n]])/wv[[n]]];
  Integrate[PDF[P, varsInPlane], 
   Map[Function[{#, -Infinity, Infinity}], Delete[xv, n]]
   ]
  ]

dist = MultinormalDistribution[
   ConstantArray[0, 3], {{1, 0.9, 0}, {0.9, 1, 0}, {0, 0, 1}}];
rd = returnDistribution[dist, 3]

(* The problem we want to solve is this *)
wv = Array[w, n];
Maximize[{rd*Log[rd, 2], 
  Total[wv] == 1 && And @@ Thread[wv >= 0]}, wv]

Attilio Meucci a un document "Gérer la diversification" et un code de MatLab qui semblait prometteur,

http://www.symmys.com/AttilioMeucci/Research/PublFinance/ PublFinance.html

mais après avoir regardé un de mes collègues commenté comme:

Il semble faire à peu près la même chose que je voulais faire (avant jeter l'idée), sauf qu'il est tricher un peu. Au lieu de réellement le calcul de l'entropie en continu, il est simplement traiter chaque directeur composant comme une valeur discrète. Mais Au fond, son papier est raffiné version des calculs que j'ai fait avec plusieurs coinflips corrélées. Ce vous oblige à obtenir l'entropie d'autres les variables, plutôt que de supplémentaire chiffres de la variable courante.

Pour faire ce qu'il fait à un non-normale la distribution pourrait être plus délicat, bien que Je suppose que l'on pourrait utiliser modèles génératifs pour les situations de la forme « standard normale de 95% la distribution, 5% quelque chose de vraiment mauvais ».

Des exemples de risque de concentration

Quelques exemples simples pour illustrer le risque de concentration

Il est plus facile de comprendre ce que nous voulons réaliser si nous regardons un portefeuille de 3 actifs dans une expérience de pensée. Supposons que 2 des instruments ont des corrélations de 1 (100%) et le troisième à 0, la matrice de corrélation ressemblerait à ceci:

1, 1, 0

1, 1, 0

0, 0, 1

De notre point de vue dans ce cas, il serait judicieux de mettre 25% dans chacune des 2 actions corrélées et 50% dans celui décorrélé.

25%, 25%, 50%

Cela compense le risque de concentration dans les instruments corrélés, tout en reconnaissant que le sont en fait 100% des actifs corrélés instruments encore différents dont la corrélation à l'avenir peut changer.

On pourrait faire valoir que les deux actifs qui présentent une corrélation de 100% se déplacent même, puis un large éventail d'attributions possibles pourrait également servir nos fins par exemple:

50%, 0%, 50%

0%, 50%, 50%

10%, 40%, 50%

... ou de telles variations sur le thème.

Mais, comme nous ne savons pas comment leur corrélation future va évoluer, nous pensons que le meilleur reste la solution et la plus intuitive à:

25%, 25%, 50%

Un autre exemple

Dans un portefeuille de 5 actifs avec 4 ayant une corrélation de 100% et 1 ayant 0% de corrélation la matrice de corrélation ressemblerait à ce qui suit:

1, 1, 1, 1, 0

1, 1, 1, 1, 0

1, 1, 1, 1, 0

1, 1, 1, 1, 0

0, 0, 0, 0, 1

et l'allocation du portefeuille que nous voulons aurait les proportions suivantes:

12,5%, 12,5%, 12,5%, 12,5%, 50%

Bien sûr, les vrais nous présente du monde avec une plus grande complication.

Les choses que nous avons essayé

la variance Minimisation (prometteuse mais ne fonctionne pas)

Quelqu'un a suggéré de minimiser la variance pour ce faire, mais comme on peut le voir ne produit pas une solution intuitive:

Une partie du code Mathematica illustrant ce qui suit:

For 3 assets:

m3 = {{1, 1, 0}, {1, 1, 0 }, { 0, 0 , 1}};

Array[x, Length@m3];

Minimize[{p.m3.p, Tr@p == 1 && And @@ Thread[p >= 0]}, p]

{1/2, {x[1] -> 1/4, x[2] -> 1/4, x[3] -> 1/2}}

Cela semble bon. Il nous donne:

25%, 25%, 50%

...

Pour 5 actifs:

m5 = {{1, 1, 1, 1, 0}, {1 , 1, 1, 1, 0 }, {1 , 1, 1, 1, 0 }, {1 , 1,1, 1, 0 }, { 0, 0 , 0, 0, 1}};

p = Array[x, Length@m5];

Minimize[{p.m5.p, Tr@p == 1 && And @@ Thread[p >= 0]}, p]

{1/2, {x[1] -> 1/16, x[2] -> 1/4, x[3] -> 1/8, x[4] -> 1/16, x[5] ->1/2}}

Pas si bien que cela nous donne:

6.25%, 25%, 12.50%, 6.25%, 50%

Ainsi, la variance réduisant au minimum ne fonctionne pas même pour ce simple (si artificielle) cas et encore moins quelque chose de plus réaliste.

Une solution prometteuse

Un contributeur à notre discussion a proposé une approche prometteuse - au moins pour les cas qui n'ont pas de corrélations négatives. Peut-être que cela conduirait à quelqu'un de proposer une solution plus complète.

Encore une fois avec le code Mathematica:

m = {{1, 1, 0}, {1, 1, 0}, {0, 0, 1}};

Tr /@ PseudoInverse[m]/Tr[ Tr /@ PseudoInverse[m]]

{1/4, 1/4, 1/2}  

Exactement ce que nous voulons. Note: Pour ceux qui ne connaissent pas le code Mathematica les fonctions: « Tr » trouve la trace d'une matrice et « / @ » mappe une fonction à une liste ou d'une matrice. Le reste est sans doute logique.

Un autre exemple pour quatre actifs:

m = {{1, 1, 1, 0}, {1, 1, 1, 0}, {1, 1, 1, 0}, {0, 0, 0, 1}};

Tr /@ PseudoInverse[m]/Tr[ Tr /@ PseudoInverse[m]]

{1/6, 1/6, 1/6, 1/2}

Encore une fois, exactement ce que nous voulons.

Cela fonctionne mieux que la variance réduisant au minimum, mais dans un exemple du monde plus réel (le premier décrit dans le post) nous obtenons quelque chose qui ne fonctionne pas:

m = {{1.0, 0.635562, 0.698852, 0.404792, -0.32746}, {0.635562, 1.0, 0.410075, 0.314375, -0.0636438}, {0.698852, 0.410075, 1.0, 0.374416, -0.260137}, {0.404792, 0.314375, 0.374416, 1.0, 0.293135}, {-0.32746, -0.0636438, -0.260137, 0.293135, 1.0}}

Tr /@ PseudoInverse[m]/Tr[ Tr /@ PseudoInverse[m]]

{0.267806, 0.0898877, 0.22403, -0.0541658, 0.472441}

Dans ce cas, nous avons une allocation négative (-0,0541658) pour le 4ème atout, quelque chose qui n'a pas de sens pour ce que nous voulons atteindre.

Conclusion

Donc, nous avons besoin d'une sorte de fonction MinimizeVarianceIntuitively. J'espère que tout cela décrit ce que nous voulons obtenir assez clairement. Toutes les suggestions ou idées pour attaquer ce problème de manière complètement différente ou pour étendre l'une des choses que nous avons essayé déjà très apprécié.

Les gens qui regardent cette désinvolture alway suggèrent que CAPM (Capital Asset Pricing Model) fait cela. Ce ne est pas. Considérez que les corrélations décrites ci-dessus se rapportent à des actifs non actifs chaque actif au « marché », il n'a pas de « bêta » avec laquelle travailler. En outre, le problème décrit ne fait aucune hypothèse de non retour ou l'utilisation d'un taux sans risque ou une distribution normale des prix. Je peux voir comment CAPM peut sembler une façon de le faire, mais je ne vois pas comment il applique.

Merci,

Arun Garapata

Answer 1

Je vais proposer une approche simple et peu erronée. Pour chaque actif additionne ses covariances. Ensuite, prendre son pourcentage en raison inverse du rapport entre cette somme et la somme totale de covariances.

Dans le code, en utilisant votre exemple original, nous ferions comme suit.

cormat = {{1.0, 0.635562, 0.698852, 
0.404792, -0.32746}, {0.635562, 1.0, 0.410075, 
0.314375, -0.0636438}, {0.698852, 0.410075, 1.0, 
0.374416, -0.260137}, {0.404792, 0.314375, 0.374416, 1.0, 
0.293135}, {-0.32746, -0.0636438, -0.260137, 0.293135, 1.0}};

n = Length[cormat];
xvars = Array[x, n];
corrs = Map[Total, cormat];
cortot = Total[Total[cormat]];

unnormalized = 
  xvars /. First[Solve[xvars == cortot/corrs, xvars]]

Out [26] = {4,129760099114916, 4,337254104111004, 4,479986290069387, \ 4,173066277624756, 15,51647047130198}

normalized = unnormalized/Total[unnormalized]

Out [27] = {,1265379371734397, ,1328956583819156, ,1372690447157368, \ ,1278648603757522, ,4754324993531559}

Je soupçonne que ces valeurs comprennent un résultat raisonnable pour cet exemple.

Il y a deux défauts. La première est que cela ne tient pas compte de la force relative des actifs. Je ne pense pas que ce soit un problème parce que je pense que vous avez déjà pondérées pour cela, à savoir un dollar d'actif 1 vaut un dollar d'actif 2 est une valeur ...

- modifier -

Ce dernier ne peut pas être tout à fait raison. Vous auriez besoin de tenir compte à la fois pour les prix des actifs, et les rendements estimatifs de même. Je ne sais pas comment vous voulez gérer cela dans le code i montré. Peut-être covariances poids légèrement de sorte que « meilleur » des actifs (en termes de rendement par rapport aux prix) donnent de meilleurs chiffres de covariance?

- modifier final -

Un problème plus important est que cela ne joue pas bien quand il y a de grandes corrélations négatives. Comment gérer cela dépend de ce qui est exatly le comportement que vous voulez. Par exemple, si une paire d'actifs sont corrélés négativement, les trouvez-vous préférable à zéro corrélation? Si non, alors une solution facile serait de transformer le négatif en une fraction de corrélation positive (ou les rendre zéro, si la corrélation négative est considérée comme ni meilleur ni pire que les actifs non corrélés).

Si, comme je le soupçonne, une paire avec corrélation négative rend les ensemble relativement plus souhaitable d'avoir des positions (vous rend plus résistant à la récession), nous devons régler le code ci-dessus afin de ne pas souffler les valeurs lorsque la corrélation totaux ont atteint ou dépasse -1. Une heuristique raisonnable, je pense, serait de laisser les négatifs d'affilée seulement si leur somme est dans la gamme (-0.5,0), sinon les Normaliser résumer à -0,5.

Il est évident que tout cela est heuristique, et des paramètres peut être réglé, par exemple pourrait utiliser relation puissance inverse au lieu de simplement inverse. Pourrait traiter les négatifs d'une autre manière que ce que je propose. Pourrait ajouter une lecture des feuilles de thé ...

Note Je suis hors de mon champ ici, donc toute utilisation abusive de la terminologie est involontaire. Peut-être aussi de ma profondeur.

Daniel Lichtblau Wolfram Research

Answer 2

Dans vos exemples de tests extrêmes vous, il y a un nombre infini de solutions; Mma choisit un d'entre eux. Si vous le souhaitez choisir une solution qui rend les poids (non identifiés) équivalent à peu près à l'autre, alors vous devriez lui dire que vous vous souciez de cet aspect: Par exemple, vous pouvez ajouter une pénalité pour écarter de l'égalité. Essayez ceci:

lambda = .00001;
NMinimize[{p.m5.p - 
   lambda*PDF[DirichletDistribution[Table[2, {5}]], Most[p]], 
  Tr@p == 1 && And @@ Thread[p >= 0]}, p]

Je l'ai utilisé la distribution Dirichlet avec une moyenne de 1/5. Les paramètres de réglage comprennent à la fois lambda et le paramètre « 2 » dans la distribution de Dirichlet (qui contrôle la concentration autour de la moyenne). Vous aurez à cheval autour de ces paramètres de réglage en fonction du problème réel. Pour exemple moins extrême, vous pouvez essayer

lambda = .0001;
NMinimize[{p.m.p - 
   lambda*PDF[DirichletDistribution[Table[2, {5}]], Most[p]], 
  Tr@p == 1 && And @@ Thread[p >= 0]}, p]

- Mark