Como gerar eficientemente matrizes de correlação aleatória positiva-semidefinida?

Gostaria de poder gerar com eficiência matrizes de correlação semidefinido positivo (PSD). Meu método diminui drasticamente à medida que aumenta o tamanho das matrizes a serem geradas.

1. Você poderia sugerir soluções eficientes? Se você conhece algum exemplo no Matlab, ficaria muito grato.
2. Ao gerar uma matriz de correlação do PSD, como você selecionaria os parâmetros para descrever as matrizes a serem geradas? Uma correlação média, desvio padrão de correlações, autovalores?

Você pode fazer isso ao contrário: toda matriz (o conjunto de todas as matrizes simétricas p × p PSD) pode ser decomposta como$C \in \mathbb{R}_{++}^p$$p \times p$

que O é uma matriz ortonormal$C=O^{T}DO$$O$

Para obter , geram primeiro uma base aleatória ( v 1 , . . . , V p ) (onde v i são vectores aleatórios, tipicamente em ( - 1 , 1 ) ). De lá, use o processo ortogonalização Gram-Schmidt para obter ( u 1 , . . . . , U p ) = $O$$(v_1,...,v_p)$$v_i$$(-1,1)$$(u_1,....,u_p)=O$

possui vários pacotes que podem realizar a ortogonalização GS de uma base aleatória de forma eficiente, ou seja, mesmo para grandes dimensões, por exemplo, o pacote 'distante'. Embora você encontre o algoritmo GS no wiki, provavelmente é melhor não reinventar a roda e fazer uma implementação do matlab (certamente existe uma, eu simplesmente não posso recomendar nenhuma).$R$

Finalmente, é um matrizes diagonais cujos elementos são todos positivos (isto é, de novo, fácil de gerar: gerar p números aleatórios, quadrado-los, classificá-los e colocá-los até a diagonal de uma identidade p por p matriz).$D$$p$$p$$p$

Um artigo Gerando matrizes de correlação aleatória com base em videiras e método de cebola estendida por Lewandowski, Kurowicka e Joe (LKJ), 2009, fornece um tratamento unificado e exposição dos dois métodos eficientes de gerar matrizes de correlação aleatória. Ambos os métodos permitem gerar matrizes a partir de uma distribuição uniforme em um certo sentido preciso definido abaixo, são simples de implementar, rápidos e têm uma vantagem adicional de ter nomes divertidos.

Uma matriz simétrica real do tamanho com aqueles na diagonal tem d ( d - 1 ) / 2 elementos fora da diagonal exclusivos e assim pode ser parametrizada como um ponto em R d ( d - 1 ) / 2 . Cada ponto neste espaço corresponde a uma matriz simétrica, mas nem todos são positivos-definidos (como as matrizes de correlação precisam ser). Matrizes de correlação, portanto, formam um subconjunto de R d ( d - 1 ) /$d \times d$$d(d-1)/2$$\mathbb R^{d(d-1)/2}$$\mathbb R^{d(d-1)/2}$ (na verdade, um subconjunto convexo conectado) e os dois métodos podem gerar pontos a partir de uma distribuição uniforme nesse subconjunto.

Fornecerei minha própria implementação MATLAB de cada método e ilustrarei com .$d=100$

Método de cebola

O método cebola vem de outro papel (ref # 3 em LKJ) e possui o seu nome ao facto das matrizes de correlação são gerados a partir de matriz e o seu cultivo em coluna por coluna e linha por linha. A distribuição resultante é uniforme. Eu realmente não entendo a matemática por trás do método (e prefiro o segundo método de qualquer maneira), mas aqui está o resultado:$1\times 1$

Aqui e abaixo, o título de cada subparcela mostra os autovalores menores e maiores e o determinante (produto de todos os autovalores). Aqui está o código:

%// 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

Método estendido de cebola

LKJ modifica este método levemente, para poder amostrar as matrizes de correlação de uma distribuição proporcional a [ d e $\mathbf C$ . Quanto maior o η , maior será o determinante, o que significa que as matrizes de correlação geradas se aproximam cada vez mais da matriz de identidade. O valor η = 1 corresponde à distribuição uniforme. Na figura abaixo, as matrizes são geradas com η = 1 , 10 , 100 , 1000 , $[\mathrm{det}\:\mathbf C]^{\eta-1}$$\eta$$\eta=1$ .$\eta={1, 10, 100, 1000, 10\:000, 100\:000}$

Por alguma razão, para obter o determinante da mesma ordem de grandeza que no método da cebola com baunilha, preciso colocar e não η = 1 (conforme reivindicado por LKJ). Não tenho certeza de onde está o erro.$\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

Método de videira

O método Vine foi originalmente sugerido por Joe (J em LKJ) e aprimorado por LKJ. Eu gosto mais, porque é conceitualmente mais fácil e mais fácil de modificar. A idéia é gerar correlações parciais (elas são independentes e podem ter valores de [ - 1 , 1 $d(d-1)/2$$[-1, 1]$sem restrições) e depois os converta em correlações brutas por meio de uma fórmula recursiva. É conveniente organizar o cálculo em uma determinada ordem, e este gráfico é conhecido como "videira". É importante ressaltar que, se forem amostradas correlações parciais de distribuições beta específicas (diferentes para células diferentes na matriz), a matriz resultante será distribuída uniformemente. Aqui, novamente, LKJ introduz um parâmetro adicional para amostrar a partir de uma distribuição proporcional a [ d e $\eta$ . O resultado é idêntico à cebola estendida:$[\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

Método Vine com amostragem manual de correlações parciais

$\pm 1$$[0,1]$$[-1, 1]$$\alpha=\beta={50, 20, 10, 5, 2, 1}$. Quanto menores os parâmetros da distribuição beta, mais ela se concentra nas bordas.

Observe que, neste caso, a distribuição não é garantida como invariante de permutação, portanto, adicionalmente permito aleatoriamente linhas e colunas após a geração.

%// 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

Aqui está como os histogramas dos elementos fora da diagonal procuram as matrizes acima (a variação da distribuição aumenta monotonicamente):

Atualização: usando fatores aleatórios

$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}$

E o código:

%// 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

Aqui está o código de quebra automática usado para gerar as figuras:

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||$o que não é negativo. Então, no Matlab, tente

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

Dependendo do aplicativo, isso pode não fornecer a distribuição dos valores próprios que você deseja; A resposta de Kwak é muito melhor nesse sentido. Os valores próprios Xproduzidos por esse trecho de código devem seguir a distribuição Marchenko-Pastur.

Para simular as matrizes de correlação de ações, por exemplo, convém uma abordagem ligeiramente diferente:

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)

Como variação da resposta do kwak: gere uma matriz diagonal $\mathbf{D}$ com autovalores não negativos aleatórios de uma distribuição de sua escolha e, em seguida, execute uma transformação de similaridade $\mathbf{A}=\mathbf{Q}\mathbf{D}\mathbf{Q}^T$ com $\mathbf{Q}$uma matriz ortogonal pseudo-aleatória distribuída por Haar .

Você não especificou uma distribuição para as matrizes. Dois comuns são as distribuições Wishart e inversa Wishart. A decomposição de Bartlett fornece uma fatoração de Cholesky de uma matriz Wishart aleatória (que também pode ser resolvida com eficiência para obter uma matriz Wishart inversa aleatória).

De fato, o espaço de Cholesky é uma maneira conveniente de gerar outros tipos de matrizes aleatórias de PSD, pois você só precisa garantir que a diagonal não seja negativa.

O método mais simples é o descrito acima, que é uma simulação de um conjunto de dados aleatório e o cálculo do Gramian . Uma palavra de cautela: A matriz resultante não será uniformemente aleatória, pois sua decomposição, por exemplo,$U^TSU$terá rotações não distribuídas de acordo com a medida de Haar. Se você quiser ter matrizes PSD "distribuídas uniformemente", poderá usar qualquer uma das abordagens descritas aqui .

Se você deseja ter mais controle sobre sua matriz PSD simétrica gerada, por exemplo, gerar um conjunto de dados de validação sintético, você tem vários parâmetros disponíveis. Uma matriz PSD simétrica corresponde a uma hiperelipse no espaço N-dimensional, com todos os graus de liberdade relacionados:

1. Rotações.
2. Comprimentos de eixos.

Portanto, para uma matriz bidimensional (isto é, elipse 2d), você terá 1 rotação + 2 eixos = 3 parâmetros.

Se as rotações lembram matrizes ortogonais, é um trem correto, pois a construção é novamente $\Sigma=ODO^T$com $\Sigma$ sendo a matriz Sym.PSD produzida, $O$ a matriz de rotação (ortogonal) e $D$a matriz diagonal, cujos elementos diagonais controlarão o comprimento dos eixos da elipse.

O código Matlab a seguir plota 16 conjuntos de dados distribuídos gaussianos bidimensionais com base em $\Sigma$, com um ângulo crescente. O código para geração aleatória de parâmetros está nos comentários.

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

Para mais dimensões, a matriz Diagonal é direta (como acima), e a $U$ deve derivar da multiplicação das matrizes de rotação.

Uma abordagem barata e alegre que usei para testar é gerar m N (0,1) n-vetores V [k] e usar P = d * I + Soma {V [k] * V [k] '} como uma matriz nxn psd. Com m <n, isso será singular para d = 0 e, para d pequeno, terá um número de condição alto.