Wie können zufällige positiv-semidefinite Korrelationsmatrizen effizient generiert werden?

Ich möchte in der Lage sein, Korrelationsmatrizen mit positivem Semidefinit (PSD) effizient zu erzeugen. Meine Methode verlangsamt sich dramatisch, wenn ich die zu generierenden Matrizen vergrößere.

1. Können Sie effiziente Lösungen vorschlagen? Wenn Sie Beispiele in Matlab kennen, wäre ich Ihnen sehr dankbar.
2. Wie würden Sie beim Generieren einer PSD-Korrelationsmatrix die Parameter auswählen, um die zu generierenden Matrizen zu beschreiben? Eine durchschnittliche Korrelation, Standardabweichung von Korrelationen, Eigenwerte?

Sie können es rückwärts machen: Jede Matrix (die Menge aller symmetrischen PSD-Matrizen) kann als zerlegt werden p × $C \in \mathbb{R}_{++}^p$$p \times p$

$C=O^{T}DO$ wobei eine orthonormale Matrix ist$O$

Um , generieren Sie zuerst eine Zufallsbasis (wobei Zufallsvektoren sind, typischerweise in ). Verwenden Sie von dort den Gram-Schmidt-Orthogonalisierungsprozess, um( v 1 , . . . , V p ) v i ( - 1 , 1 ) ( u 1 , . . . . , U p ) = $O$$(v_1,...,v_p)$$v_i$$(-1,1)$$(u_1,....,u_p)=O$

$R$ verfügt über eine Reihe von Paketen, mit denen die GS-Orthogonalisierung auf zufälliger Basis effizient durchgeführt werden kann, auch für große Dimensionen, z. B. das "ferne" Paket. Obwohl Sie den GS-Algorithmus im Wiki finden, ist es wahrscheinlich besser, das Rad nicht neu zu erfinden und sich für eine Matlab-Implementierung zu entscheiden (es gibt sicherlich eine, ich kann keine empfehlen).

Schließlich ist eine Diagonalmatrix, deren Elemente alle positiv sind (dies ist wiederum leicht zu erzeugen: Zufallszahlen erzeugen , quadrieren, sortieren und in die Diagonale einer Identität durch Matrix platzieren).p p $D$$p$$p$$p$

Ein Artikel zur Generierung zufälliger Korrelationsmatrizen auf der Basis von Reben und einer Methode mit erweiterten Zwiebeln von Lewandowski, Kurowicka und Joe (LKJ), 2009, bietet eine einheitliche Behandlung und Darstellung der beiden effizienten Methoden zur Generierung zufälliger Korrelationsmatrizen. Beide Methoden ermöglichen die Erzeugung von Matrizen aus einer gleichmäßigen Verteilung in einem bestimmten, nachstehend definierten Sinne, sind einfach zu implementieren, schnell und haben den zusätzlichen Vorteil, dass sie amüsante Namen haben.

Eine reelle symmetrische Matrix mit der Größe mit Einsen auf der Diagonale hat eindeutige Elemente außerhalb der Diagonale und kann daher als Punkt in parametrisiert werden. . Jeder Punkt in diesem Raum entspricht einer symmetrischen Matrix, aber nicht alle von ihnen sind positiv-definit (wie Korrelationsmatrizen sein müssen). Korrelationsmatrizen bilden daher eine Teilmenge von (eigentlich eine zusammenhängende konvexe Teilmenge), und beide Methoden können Punkte aus einer gleichmäßigen Verteilung über diese Teilmenge erzeugen.d ( d - 1 ) / 2 R d ( d - 1 ) / 2 R d ( d - 1 ) /$d \times d$$d(d-1)/2$$\mathbb R^{d(d-1)/2}$$\mathbb R^{d(d-1)/2}$

Ich werde meine eigene MATLAB-Implementierung jeder Methode bereitstellen und sie mit veranschaulichen .$d=100$

Zwiebelmethode

Die Zwiebelmethode stammt aus einer anderen Veröffentlichung (Lit. 3 in LKJ) und hat ihren Namen der Tatsache zu verdanken, dass die Korrelationsmatrizen beginnend mit Matrix und spaltenweise und zeilenweise wachsen. Die resultierende Verteilung ist gleichmäßig. Ich verstehe die Mathematik hinter der Methode nicht wirklich (und bevorzuge sowieso die zweite Methode), aber hier ist das Ergebnis:$1\times 1$

Hier und unter dem Titel jedes Unterplots werden der kleinste und der größte Eigenwert sowie die Determinante (Produkt aller Eigenwerte) angezeigt. Hier ist der Code:

%// ONION METHOD to generate random correlation matrices distributed randomly
function S = onion(d)
    S = 1;
    for k = 2:d
        y = betarnd((k-1)/2, (d-k)/2); %// sampling from beta distribution
        r = sqrt(y);
        theta = randn(k-1,1);
        theta = theta/norm(theta);
        w = r*theta;
        [U,E] = eig(S);
        R = U*E.^(1/2)*U';             %// R is a square root of S
        q = R*w;
        S = [S q; q' 1];               %// increasing the matrix size
    end
end

Erweiterte Zwiebelmethode

LKJ modifizieren diese Methode geringfügig, um Korrelationsmatrizen aus einer Verteilung abtasten zu können, die proportional zu [ d e $\mathbf C$$[\mathrm{det}\:\mathbf C]^{\eta-1}$$\eta$$\eta=1$$\eta={1, 10, 100, 1000, 10\:000, 100\:000}$

$\eta=0$$\eta=1$

%// EXTENDED ONION METHOD to generate random correlation matrices
%// distributed ~ det(S)^eta [or maybe det(S)^(eta-1), not sure]
function S = extendedOnion(d, eta)
    beta = eta + (d-2)/2;
    u = betarnd(beta, beta);
    r12 = 2*u - 1;
    S = [1 r12; r12 1];  

    for k = 3:d
        beta = beta - 1/2;
        y = betarnd((k-1)/2, beta);
        r = sqrt(y);
        theta = randn(k-1,1);
        theta = theta/norm(theta);
        w = r*theta;
        [U,E] = eig(S);
        R = U*E.^(1/2)*U';
        q = R*w;
        S = [S q; q' 1];
    end
end

Rebe-Methode

$d(d-1)/2$$[-1, 1]$$\eta$$[\mathrm{det}\:\mathbf C]^{\eta-1}$

%// VINE METHOD to generate random correlation matrices
%// distributed ~ det(S)^eta [or maybe det(S)^(eta-1), not sure]
function S = vine(d, eta)
    beta = eta + (d-1)/2;   
    P = zeros(d);           %// storing partial correlations
    S = eye(d);

    for k = 1:d-1
        beta = beta - 1/2;
        for i = k+1:d
            P(k,i) = betarnd(beta,beta); %// sampling from beta
            P(k,i) = (P(k,i)-0.5)*2;     %// linearly shifting to [-1, 1]
            p = P(k,i);
            for l = (k-1):-1:1 %// converting partial correlation to raw correlation
                p = p * sqrt((1-P(l,i)^2)*(1-P(l,k)^2)) + P(l,i)*P(l,k);
            end
            S(k,i) = p;
            S(i,k) = p;
        end
    end
end

Weinbaumethode mit manueller Probenahme von Teilkorrelationen

$\pm 1$$[0,1]$$[-1, 1]$$\alpha=\beta={50, 20, 10, 5, 2, 1}$. Je kleiner die Parameter der Beta-Verteilung sind, desto stärker ist sie in Randnähe konzentriert.

Beachten Sie, dass in diesem Fall die Verteilung nicht garantiert permutationsinvariant ist, sodass ich Zeilen und Spalten nach der Generierung zusätzlich zufällig permutiere.

%// VINE METHOD to generate random correlation matrices
%// with all partial correlations distributed ~ beta(betaparam,betaparam)
%// rescaled to [-1, 1]
function S = vineBeta(d, betaparam)
    P = zeros(d);           %// storing partial correlations
    S = eye(d);

    for k = 1:d-1
        for i = k+1:d
            P(k,i) = betarnd(betaparam,betaparam); %// sampling from beta
            P(k,i) = (P(k,i)-0.5)*2;     %// linearly shifting to [-1, 1]
            p = P(k,i);
            for l = (k-1):-1:1 %// converting partial correlation to raw correlation
                p = p * sqrt((1-P(l,i)^2)*(1-P(l,k)^2)) + P(l,i)*P(l,k);
            end
            S(k,i) = p;
            S(i,k) = p;
        end
    end

    %// permuting the variables to make the distribution permutation-invariant
    permutation = randperm(d);
    S = S(permutation, permutation);
end

So sehen die Histogramme der nicht diagonalen Elemente für die obigen Matrizen aus (Varianz der Verteilung steigt monoton an):

Update: unter Verwendung von Zufallsfaktoren

$k<d$$\mathbf W$$k \times d$$\mathbf W \mathbf W^\top$$\mathbf D$$\mathbf B = \mathbf W \mathbf W^\top + \mathbf D$$\mathbf C = \mathbf E^{-1/2}\mathbf B \mathbf E^{-1/2}$$\mathbf E$$\mathbf B$$k={100, 50, 20, 10, 5, 1}$

Und der Code:

%// FACTOR method
function S = factor(d,k)
    W = randn(d,k);
    S = W*W' + diag(rand(1,d));
    S = diag(1./sqrt(diag(S))) * S * diag(1./sqrt(diag(S)));
end

Hier ist der Umhüllungscode, der zum Generieren der Zahlen verwendet wird:

d = 100; %// size of the correlation matrix

figure('Position', [100 100 1100 600])
for repetition = 1:6
    S = onion(d);

    %// etas = [1 10 100 1000 1e+4 1e+5];
    %// S = extendedOnion(d, etas(repetition));

    %// S = vine(d, etas(repetition));

    %// betaparams = [50 20 10 5 2 1];
    %// S = vineBeta(d, betaparams(repetition));

    subplot(2,3,repetition)

    %// use this to plot colormaps of S
    imagesc(S, [-1 1])
    axis square
    title(['Eigs: ' num2str(min(eig(S)),2) '...' num2str(max(eig(S)),2) ', det=' num2str(det(S),2)])

    %// use this to plot histograms of the off-diagonal elements
    %// offd = S(logical(ones(size(S))-eye(size(S))));
    %// hist(offd)
    %// xlim([-1 1])
end

$A$$A^TA$$y^T (A^TA) y \ge 0$$y$$y^T (A^TA) y = (Ay)^T Ay = ||Ay||$Das ist nicht negativ. Versuchen Sie es in Matlab einfach

A = randn(m,n);   %here n is the desired size of the final matrix, and m > n
X = A' * A;

Je nach Anwendung erhalten Sie möglicherweise nicht die gewünschte Verteilung der Eigenwerte. Kwaks Antwort ist in dieser Hinsicht viel besser. Die Eigenwerte Xdieses Code-Snippets sollten der Marchenko-Pastur-Verteilung folgen.

Um die Korrelationsmatrizen von Aktien zu simulieren, möchten Sie vielleicht einen etwas anderen Ansatz:

k = 7;      % # of latent dimensions;
n = 100;    % # of stocks;
A = 0.01 * randn(k,n);  % 'hedgeable risk'
D = diag(0.001 * randn(n,1));   % 'idiosyncratic risk'
X = A'*A + D;
ascii_hist(eig(X));    % this is my own function, you do a hist(eig(X));
-Inf <= x <  -0.001 : **************** (17)
-0.001 <= x <   0.001 : ************************************************** (53)
 0.001 <= x <   0.002 : ******************** (21)
 0.002 <= x <   0.004 : ** (2)
 0.004 <= x <   0.005 :  (0)
 0.005 <= x <   0.007 : * (1)
 0.007 <= x <   0.008 : * (1)
 0.008 <= x <   0.009 : *** (3)
 0.009 <= x <   0.011 : * (1)
 0.011 <= x <     Inf : * (1)

$\mathbf{D}$$\mathbf{A}=\mathbf{Q}\mathbf{D}\mathbf{Q}^T$$\mathbf{Q}$

Sie haben keine Verteilung für die Matrizen angegeben. Zwei gebräuchliche sind die Wishart- und die inverse Wishart-Verteilung. Die Bartlett-Zerlegung ergibt eine Cholesky-Faktorisierung einer zufälligen Wishart-Matrix (die auch effizient gelöst werden kann, um eine zufällige inverse Wishart-Matrix zu erhalten).

Tatsächlich ist der Cholesky-Raum eine bequeme Möglichkeit, andere Arten von zufälligen PSD-Matrizen zu generieren, da Sie nur sicherstellen müssen, dass die Diagonale nicht negativ ist.

$U^TSU$

Wenn Sie mehr Kontrolle über Ihre generierte symmetrische PSD-Matrix haben möchten, z. B. einen synthetischen Validierungsdatensatz generieren möchten, stehen Ihnen eine Reihe von Parametern zur Verfügung. Eine symmetrische PSD-Matrix entspricht einer Hyperellipse im N-dimensionalen Raum mit allen damit verbundenen Freiheitsgraden:

1. Drehungen.
2. Längen der Achsen.

Für eine zweidimensionale Matrix (dh eine 2D-Ellipse) haben Sie also 1 Drehung + 2 Achsen = 3 Parameter.

$\Sigma=ODO^T$$\Sigma$$O$$D$

$\Sigma$

figure;
mu = [0,0];
for i=1:16
    subplot(4,4,i)
    theta = (i/16)*2*pi;   % theta = rand*2*pi;
    U=[cos(theta), -sin(theta); sin(theta) cos(theta)];
    % The diagonal's elements control the lengths of the axes
    D = [10, 0; 0, 1]; % D = diag(rand(2,1));    
    sigma = U*D*U';
    data = mvnrnd(mu,sigma,1000);
    plot(data(:,1),data(:,2),'+'); axis([-6 6 -6 6]); hold on;
end

$U$

Ein billiger und fröhlicher Ansatz, den ich zum Testen verwendet habe, besteht darin, m N (0,1) n-Vektoren V [k] zu generieren und dann P = d * I + Summe {V [k] * V [k] '} zu verwenden. als nxn psd matrix. Mit m <n ist dies für d = 0 singulär und für kleines d hat es eine hohe Bedingungszahl.