강한 상관 관계가있는 큰 전체 순위 랜덤 상관 행렬을 생성하는 방법은 무엇입니까?

나는 임의의 상관 행렬을 생성하고자하는 의 크기와 같은 일부 적당히 강한 상관 관계가 존재가 있음 : N × $\mathbf C$$n \times n$

• 크기 의 제곱 실수 대칭 행렬 , 예를 들어 ;n = $n \times n$$n=100$
• 양의 한정된, 즉 모든 고유 값이 실제적이고 양인 경우;
• 풀 랭크;
• 모든 대각선 요소는 ;$1$
• 비 대각선 요소는 에 균등하게 분포 되어야합니다 . 정확한 분포는 중요하지 않지만 적당히 큰 값 (예 : 절대 값 이상)의 약간 큰 양 (예 : )을 원합니다 . 기본적으로 가 대각선 이 아닌 모든 요소 과 대각선 이 아닌지 확인하고 싶습니다 .10 % 0.5 $(-1, 1)$$10\%$$0.5$$\mathbf C$$\approx 0$

간단한 방법이 있습니까?

목적은 이러한 랜덤 행렬을 사용하여 상관 (또는 공분산) 행렬로 작동하는 일부 알고리즘을 벤치마킹하는 것입니다.

작동하지 않는 방법

내가 아는 랜덤 상관 행렬을 생성하는 몇 가지 방법이 있지만 여기서는 효과가 없습니다.

1. 크기, 중심 임의의 를 생성 하고 상관 행렬 표준화하고 형성합니다 . 경우 , 이것은 일반적으로 모든 오프 대각 상관 될 것 인 약 . 경우 , 어떤 상관 관계가 강한 수 있지만 전체 순위되지 않습니다. s × n C = $\mathbf X$$s \times n$s>n0s≪n$\mathbf C=\frac{1}{s-1}\mathbf X^\top \mathbf X$$s>n$$0$$s\ll n$$\mathbf C$

2. 다음 방법 중 하나로 임의의 양의 한정 행렬 를 생성하십시오 .$\mathbf B$

   • 임의의 정사각형 생성 하고 대칭 양수의 명확한 만듭니다.B = A A$\mathbf A$$\mathbf B = \mathbf A \mathbf A^\top$

   • 임의의 제곱 생성 하고 대칭 을 만들고 고유 분해 모든 음의 고유 값을 0으로 설정 : . NB : 이로 인해 순위가 부족한 행렬이 발생합니다.E = A + A ⊤ E = U S U ⊤ B = $\mathbf A$$\mathbf E = \mathbf A + \mathbf A^\top$$\mathbf E = \mathbf U \mathbf S \mathbf U^\top$$\mathbf B = \mathbf U \:\mathrm{max}\{\mathbf S, \mathbf 0\} \:\mathbf U^\top$

   • 난수 생성 직교 (예를 들어 임의의 사각형 생성하여 그 QR 분해를하고, 또는 그램 - 슈미트 절차를 통해) 임의 대각선 모든 긍정적 인 요소와; 형태 .A D B = Q D $\mathbf Q$$\mathbf A$$\mathbf D$$\mathbf B = \mathbf Q \mathbf D \mathbf Q^\top$

   얻은 행렬 는 대각선에 모든 것을 갖도록 쉽게 정규화 될 수 있습니다 : , 여기서 같은 대각선 대각 행렬이다 . 위에 나열된 세 가지 생성 결과 소자 확대 대각선 오프 갖는 .C = D - 1 / 2 B D - 1 / 2$\mathbf B$$\mathbf C = \mathbf D^{-1/2}\mathbf B \mathbf D^{-1/2}$$\mathbf D = \mathrm{diag}\:\mathbf B$$\mathbf B$C$\mathbf B$$\mathbf C$$0$

업데이트 : 이전 스레드

내 질문을 게시 한 후 과거에 거의 두 가지 중복이 발견되었습니다.

• 주어진 표준 편차로 대략 정규 분포 된 비 대각선 항목을 갖는 랜덤 상관 행렬을 생성하는 방법은 무엇입니까?
• 임의의 양의 반음계 상관 행렬을 효율적으로 생성하는 방법은 무엇입니까?

불행히도,이 스레드 중 어느 것도 만족스러운 답변을 포함하지 않았습니다 (지금까지 :)

다른 답변은 다양한 방법으로 내 문제를 해결하기위한 좋은 트릭을 생각해 냈습니다. 그러나 개념적으로 매우 명확하고 조정하기 쉽다는 큰 장점이 있다고 생각되는 원칙적인 접근 방법을 찾았습니다.

이 스레드에서 : 임의의 양의 반음계 상관 행렬을 효율적으로 생성하는 방법은 무엇입니까? -랜덤 상관 행렬을 생성하는 두 가지 효율적인 알고리즘에 대한 코드를 설명하고 제공했습니다. 두 가지 모두 Lewandowski, Kurowicka 및 Joe (2009) 의 논문 에서 발췌 한 것으로 @ssdecontrol이 위의 의견에서 언급 한 것입니다 (감사합니다!).

많은 그림, 설명 및 MATLAB 코드에 대한 내 대답을 참조하십시오 . 소위 "바인 (vine)"방법은 부분 상관의 분포를 갖는 랜덤 상관 행렬을 생성 할 수 있으며, 대각이 아닌 큰 값을 갖는 상관 행렬을 생성하는데 사용될 수있다. 해당 스레드의 예제 그림은 다음과 같습니다.

서브 플롯간에 변경되는 유일한 것은 부분 상관 분포가 주위로 집중되는 정도를 제어하는 ​​하나의 매개 변수입니다 .$\pm 1$

이 매트릭스를 생성하기 위해 코드를 복사하여 여기에 제안 된 다른 방법보다 길지 않음을 보여줍니다. 일부 설명은 링크 된 답변을 참조하십시오. betaparam위 그림 의 값 은 (치수 는 )입니다.${50,20,10,5,2,1}$d$100$

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

업데이트 : 고유 값

@psarka는이 행렬의 고유 값에 대해 묻습니다. 아래 그림에서 위와 같은 6 개의 상관 행렬의 고유 값 스펙트럼을 플로팅합니다. 그것들은 점차 감소합니다. 반대로 @psarka가 제안한 방법은 일반적으로 하나의 큰 고유 값을 갖는 상관 행렬을 생성하지만 나머지는 상당히 균일합니다.

최신 정보. 정말 간단한 방법 : 몇 가지 요소

@ttnphns가 위의 주석과 @GottfriedHelms의 답변에 쓴 것과 유사하게, 나의 목표를 달성하는 매우 간단한 방법 중 하나는 무작위로 여러 ( ) 인자 로딩 ( 크기 의 랜덤 행렬 ) 을 무작위로 생성하는 것입니다 공분산 행렬 (물론 전체 순위가 아님)을 형성하고 여기에 긍정적 인 요소가 있는 임의의 대각선 행렬 를 추가하여 전체 순위. 결과 공분산 행렬은 내 질문에 설명 된 것처럼 상관 행렬이되도록 정규화 될 수 있습니다. 이것은 매우 간단하고 트릭을 수행합니다. 여기에 대한 상관 행렬의 예가 있습니다.$k<n$$\mathbf W$$k \times n$$\mathbf W \mathbf W^\top$$\mathbf D$$\mathbf B = \mathbf W \mathbf W^\top + \mathbf D$$k={100, 50, 20, 10, 5, 1}$ :

유일한 단점은 결과로 얻은 행렬 에 포도 나무 방법으로 위의 멋진 붕괴와는 달리 개의 고유 값이 있고 갑자기 하락한다는 것입니다. 해당 스펙트럼은 다음과 같습니다.$k$

코드는 다음과 같습니다.

d = 100;    %// number of dimensions
k = 5;      %// number of factors

W = randn(d,k);
S = W*W' + diag(rand(1,d));
S = diag(1./sqrt(diag(S))) * S * diag(1./sqrt(diag(S)));

$a$

import numpy as np
from random import choice
import matplotlib.pyplot as plt

n = 100
a = 2

A = np.matrix([np.random.randn(n) + np.random.randn(1)*a for i in range(n)])
A = A*np.transpose(A)
D_half = np.diag(np.diag(A)**(-0.5))
C = D_half*A*D_half

vals = list(np.array(C.ravel())[0])
plt.hist(vals, range=(-1,1))
plt.show()
plt.imshow(C, interpolation=None)
plt.show()

흠, MatMate 언어로 예제를 작성한 후에는 이미 python-answer가 있다는 것을 알았습니다. 파이썬이 널리 사용되기 때문에 바람직 할 수 있습니다. 그러나 여전히 질문이 있기 때문에 Matmate-matrix-language를 사용하는 내 접근 방식을 보여 주었을 것입니다.

방법 1
(MatMate 사용) :

v=12         // 12 variables
f=3          // subset-correlation based on 3 common factors
vg = v / f   // variables per subsets

 // generate hidden factor-matrix
             // randomu(rows,cols ,lowbound, ubound) gives uniform random matrix 
             //    without explicite bounds the default is: randomu(rows,cols,0,100)
L = {   randomu(vg,f)     || randomu(vg,f)/100  || randomu(vg,f)/100 , _
        randomu(vg,f)/100 || randomu(vg,f)      || randomu(vg,f)/100 , _
        randomu(vg,f)/100 || randomu(vg,f)/100  || randomu(vg,f)     }

 // make sure there is itemspecific variance
 // by appending a diagonal-matrix with random positive entries
L = L || mkdiag(randomu(v,1,10,20)) 
  // make covariance and correlation matrix
cov = L *'   // L multiplied  with its transpose
cor = covtocorr(cov)
                   set ccdezweite=3 ccfeldweite=8
                   list cor
cor = 
   1.000,   0.321,   0.919,   0.489,   0.025,   0.019,   0.019,   0.030,   0.025,   0.017,   0.014,   0.014
   0.321,   1.000,   0.540,   0.923,   0.016,   0.015,   0.012,   0.030,   0.033,   0.016,   0.012,   0.015
   0.919,   0.540,   1.000,   0.679,   0.018,   0.014,   0.012,   0.029,   0.028,   0.014,   0.012,   0.012
   0.489,   0.923,   0.679,   1.000,   0.025,   0.022,   0.020,   0.040,   0.031,   0.014,   0.011,   0.014
   0.025,   0.016,   0.018,   0.025,   1.000,   0.815,   0.909,   0.758,   0.038,   0.012,   0.018,   0.014
   0.019,   0.015,   0.014,   0.022,   0.815,   1.000,   0.943,   0.884,   0.035,   0.012,   0.014,   0.012
   0.019,   0.012,   0.012,   0.020,   0.909,   0.943,   1.000,   0.831,   0.036,   0.013,   0.015,   0.010
   0.030,   0.030,   0.029,   0.040,   0.758,   0.884,   0.831,   1.000,   0.041,   0.017,   0.022,   0.020
   0.025,   0.033,   0.028,   0.031,   0.038,   0.035,   0.036,   0.041,   1.000,   0.831,   0.868,   0.780
   0.017,   0.016,   0.014,   0.014,   0.012,   0.012,   0.013,   0.017,   0.831,   1.000,   0.876,   0.848
   0.014,   0.012,   0.012,   0.011,   0.018,   0.014,   0.015,   0.022,   0.868,   0.876,   1.000,   0.904
   0.014,   0.015,   0.012,   0.014,   0.014,   0.012,   0.010,   0.020,   0.780,   0.848,   0.904,   1.000

여기서 문제는 상관 관계가 거의없는 높은 상관 관계를 갖는 서브 매트릭스 블록을 정의한다는 것입니다. 이는 프로그래밍 방식이 아니라 상수 연결 표현식에 의해 결정됩니다. 아마도이 접근법 은 파이썬에서보다 우아하게 모델링 될 수 있습니다.

{L = matrix(8,8);  \\ generate an empty factor-loadings-matrix
for(r=1,8, 
   rv=1.0;    \\ remaining variance for variable is 1.0
   for(c=1,8,
        pv=if(c<8,random(100)/100.0,1.0); \\ define randomly part of remaining variance
        cv= pv * rv;  \\ compute current partial variance
        rv = rv - cv;     \\ compute the now remaining variance
        sg = (-1)^(random(100) % 2) ;  \\ also introduce randomly +- signs
        L[r,c] = sg*sqrt(cv) ;  \\ compute factor loading as signed sqrt of cv
       )
     );}

cor = L * L~

그리고 생성 된 상관 행렬은

     1.000  -0.7111  -0.08648   -0.7806   0.8394  -0.7674   0.6812    0.2765
   -0.7111    1.000   0.06073    0.7485  -0.7550   0.8052  -0.8273   0.05863
  -0.08648  0.06073     1.000    0.5146  -0.1614   0.1459  -0.4760  -0.01800
   -0.7806   0.7485    0.5146     1.000  -0.8274   0.7644  -0.9373  -0.06388
    0.8394  -0.7550   -0.1614   -0.8274    1.000  -0.5823   0.8065   -0.1929
   -0.7674   0.8052    0.1459    0.7644  -0.5823    1.000  -0.7261   -0.4822
    0.6812  -0.8273   -0.4760   -0.9373   0.8065  -0.7261    1.000   -0.1526
    0.2765  0.05863  -0.01800  -0.06388  -0.1929  -0.4822  -0.1526     1.000

아마도 이것은 인자 로딩 행렬에 대한 누적 생성 규칙으로 인해 주요 주성분과 상관 행렬을 생성 할 수 있습니다. 또한 분산의 마지막 부분을 고유 한 요소로 만들어 긍정적 인 명확성을 확보하는 것이 좋습니다. 나는 일반 원칙에 초점을 맞추기 위해 프로그램에 남겨 두었습니다.

100x100 상관 행렬은 다음과 같은 상관 주파수를가집니다 (1-12 자리로 반올림).

    e    f            e: entry(rounded) f: frequency
  -----------------------------------------------------
  -1.000, 108.000
  -0.900, 460.000
  -0.800, 582.000
  -0.700, 604.000
  -0.600, 548.000
  -0.500, 540.000
  -0.400, 506.000
  -0.300, 482.000
  -0.200, 488.000
  -0.100, 464.000
   0.000, 434.000
   0.100, 486.000
   0.200, 454.000
   0.300, 468.000
   0.400, 462.000
   0.500, 618.000
   0.600, 556.000
   0.700, 586.000
   0.800, 536.000
   0.900, 420.000
   1.000, 198.000

[최신 정보]. 흠, 100x100 매트릭스의 상태가 좋지 않습니다. Pari / GP는 200 자리 정밀도로도 polroots (charpoly ()) 함수를 사용하여 고유 값을 올바르게 판별 할 수 없습니다. loadingmatrix L에서 pca-form으로 Jacobi 회전을 수행했으며 대부분 매우 작은 고유 값을 찾아서 10으로 대수로 인쇄했습니다 (대략 소수점 위치). 왼쪽에서 오른쪽으로 읽은 다음 행별로 읽으십시오.

log_10(eigenvalues):
   1.684,   1.444,   1.029,   0.818,   0.455,   0.241,   0.117,  -0.423,  -0.664,  -1.040
  -1.647,  -1.799,  -1.959,  -2.298,  -2.729,  -3.059,  -3.497,  -3.833,  -4.014,  -4.467
  -4.992,  -5.396,  -5.511,  -6.366,  -6.615,  -6.834,  -7.535,  -8.138,  -8.263,  -8.766
  -9.082,  -9.482,  -9.940, -10.167, -10.566, -11.110, -11.434, -11.788, -12.079, -12.722
 -13.122, -13.322, -13.444, -13.933, -14.390, -14.614, -15.070, -15.334, -15.904, -16.278
 -16.396, -16.708, -17.022, -17.746, -18.090, -18.358, -18.617, -18.903, -19.186, -19.476
 -19.661, -19.764, -20.342, -20.648, -20.805, -20.922, -21.394, -21.740, -21.991, -22.291
 -22.792, -23.184, -23.680, -24.100, -24.222, -24.631, -24.979, -25.161, -25.282, -26.211
 -27.181, -27.626, -27.861, -28.054, -28.266, -28.369, -29.074, -29.329, -29.539, -29.689
 -30.216, -30.784, -31.269, -31.760, -32.218, -32.446, -32.785, -33.003, -33.448, -34.318

[업데이트 2]
방법 2 (b)
개선 사항은 품목별 편차를 일정하지 않은 수준으로 늘리고 상당히 적은 수의 공통 요소 (예 : 정수의 제곱근)로 줄이는 것입니다.

{  dimr = 100;
   dimc = sqrtint(dimr);        \\ 10 common factors
   L = matrix(dimr,dimr+dimc);  \\ loadings matrix 
                                \\     with dimr itemspecific and 
                                \\          dimc common factors
   for(r=1,dim, 
         vr=1.0;                \\ complete variance per item 
         vu=0.05+random(100)/1000.0;   \\ random variance +0.05
                                       \\ for itemspecific variance
         L[r,r]=sqrt(vu);              \\ itemspecific factor loading  
         vr=vr-vu;
         for(c=1,dimc,
                cv=if(c<dimc,random(100)/100,1.0)*vr;
                vr=vr-cv;
                L[r,dimr+c]=(-1)^(random(100) % 2)*sqrt(cv)
             )
        );}

   cov=L*L~
   cp=charpoly(cov)   \\ does not work even with 200 digits precision
   pr=polroots(cp)    \\ spurious negative and complex eigenvalues...

결과의 구조

상관 관계 분포 측면에서 :

유사하게 유지되지만 PariGP에 의한 불쾌한 비 분해성도 유지되지만 loadingmatrix의 jacobi-rotation에 의해 발견 될 때 고유 값은 더 나은 구조를 가지게되었습니다. 새로 계산 된 예에서 고유 값은 다음과 같습니다.

log_10(eigenvalues):
   1.677,   1.326,   1.063,   0.754,   0.415,   0.116,  -0.262,  -0.516,  -0.587,  -0.783
  -0.835,  -0.844,  -0.851,  -0.854,  -0.858,  -0.862,  -0.862,  -0.868,  -0.872,  -0.873
  -0.878,  -0.882,  -0.884,  -0.890,  -0.895,  -0.896,  -0.896,  -0.898,  -0.902,  -0.904
  -0.904,  -0.909,  -0.911,  -0.914,  -0.920,  -0.923,  -0.925,  -0.927,  -0.931,  -0.935
  -0.939,  -0.939,  -0.943,  -0.948,  -0.951,  -0.955,  -0.956,  -0.960,  -0.967,  -0.969
  -0.973,  -0.981,  -0.986,  -0.989,  -0.997,  -1.003,  -1.005,  -1.011,  -1.014,  -1.019
  -1.022,  -1.024,  -1.031,  -1.038,  -1.040,  -1.048,  -1.051,  -1.061,  -1.064,  -1.068
  -1.070,  -1.074,  -1.092,  -1.092,  -1.108,  -1.113,  -1.120,  -1.134,  -1.139,  -1.147
  -1.150,  -1.155,  -1.158,  -1.166,  -1.171,  -1.175,  -1.184,  -1.184,  -1.192,  -1.196
  -1.200,  -1.220,  -1.237,  -1.245,  -1.252,  -1.262,  -1.269,  -1.282,  -1.287,  -1.290

$A$$B$$\lambda A + (1-\lambda)B$$\lambda$

$A$$B$$C$$\lambda_A A + \lambda_B B + \lambda_C C$$\sum \lambda = 1$$\lambda \geq 0$

R에는 다음과 같은 메소드 를 구현 하는 패키지 (clusterGeneration) 가 있습니다 .

• Joe, H. (2006) 부분 상관 관계에 기초한 랜덤 상관 행렬 생성 . 다변량 분석 저널, 97, 2177--2189.

예:

> (cormat10 = clusterGeneration::rcorrmatrix(10, alphad = 1/100000000000000))
        [,1]   [,2]    [,3]     [,4]     [,5]   [,6]   [,7]    [,8]     [,9]   [,10]
 [1,]  1.000  0.344 -0.1406 -0.65786 -0.19411  0.246  0.688 -0.6146  0.36971 -0.1052
 [2,]  0.344  1.000 -0.4256 -0.35512  0.15973  0.192  0.340 -0.4907 -0.30539 -0.6104
 [3,] -0.141 -0.426  1.0000  0.01775 -0.61507 -0.485 -0.273  0.3492 -0.30284  0.1647
 [4,] -0.658 -0.355  0.0178  1.00000  0.00528 -0.335 -0.124  0.5256 -0.00583 -0.0737
 [5,] -0.194  0.160 -0.6151  0.00528  1.00000  0.273 -0.350 -0.0785  0.08285  0.0985
 [6,]  0.246  0.192 -0.4847 -0.33531  0.27342  1.000  0.278 -0.2220 -0.11010  0.0720
 [7,]  0.688  0.340 -0.2734 -0.12363 -0.34972  0.278  1.000 -0.6409  0.40314 -0.2800
 [8,] -0.615 -0.491  0.3492  0.52557 -0.07852 -0.222 -0.641  1.0000 -0.50796  0.1461
 [9,]  0.370 -0.305 -0.3028 -0.00583  0.08285 -0.110  0.403 -0.5080  1.00000  0.3219
[10,] -0.105 -0.610  0.1647 -0.07373  0.09847  0.072 -0.280  0.1461  0.32185  1.0000
> cormat10[lower.tri(cormat10)] %>% psych::describe()
   vars  n  mean   sd median trimmed mad   min  max range skew kurtosis   se
X1    1 45 -0.07 0.35  -0.08   -0.07 0.4 -0.66 0.69  1.35 0.03       -1 0.05

불행히도, 이것과 균일 한 분포를 따르는 상관 관계를 시뮬레이션하는 것은 불가능 해 보입니다. alphad매우 작은 값으로 설정 하면 더 강한 상관 관계를 만드는 것처럼 보이지만 에서도 1/100000000000000상관 범위는 약 1.40까지 올라갑니다.

그럼에도 불구하고 이것이 누군가에게 유용 할 수 있기를 바랍니다.