Bagaimana cara menghasilkan matriks korelasi acak peringkat penuh yang besar dengan beberapa korelasi kuat yang ada?

Saya ingin menghasilkan korelasi matriks acak dari ukuran sehingga ada beberapa korelasi cukup kuat hadir: n × $\mathbf C$$n \times n$

• matriks simetris nyata persegi ukuran , dengan mis ;n = $n \times n$$n=100$
• positif-pasti, yaitu dengan semua nilai eigen nyata dan positif;
• peringkat penuh;
• semua elemen diagonal sama dengan ;$1$
• elemen off-diagonal harus terdistribusi secara merata pada . Distribusi yang tepat tidak masalah, tetapi saya ingin memiliki jumlah yang cukup besar (misalnya ) dari nilai yang cukup besar (misalnya dengan nilai absolut atau lebih tinggi). Pada dasarnya saya ingin memastikan bahwa adalah tidak hampir diagonal dengan semua elemen off-diagonal .10 % 0,5 $(-1, 1)$$10\%$$0.5$$\mathbf C$$\approx 0$

Apakah ada cara sederhana untuk melakukannya?

Tujuannya adalah untuk menggunakan matriks acak semacam itu untuk membandingkan beberapa algoritma yang bekerja dengan matriks korelasi (atau kovarians).

Metode yang tidak berfungsi

Berikut adalah beberapa cara untuk menghasilkan matriks korelasi acak yang saya ketahui, tetapi itu tidak berfungsi untuk saya di sini:

1. Menghasilkan acak dari ukuran, pusat, standarisasi dan membentuk matriks korelasi . Jika , ini umumnya akan menghasilkan semua korelasi off-diagonal menjadi sekitar . Jika , beberapa korelasi akan kuat, tetapi tidak akan peringkat penuh. s × $\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. Hasilkan matriks pasti positif acak dalam salah satu cara berikut:$\mathbf B$

   • Hasilkan kuadrat acak dan buat pasti positif simetris .B = A A$\mathbf A$$\mathbf B = \mathbf A \mathbf A^\top$

   • Hasilkan kuadrat acak , buat simetris , dan jadikan positif dengan melakukan eigen-dekomposisi dan mengatur semua nilai eigen negatif ke nol: . NB: ini akan menghasilkan matriks yang kekurangan peringkat.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$

   • Hasilkan ortogonal acak (misalnya dengan menghasilkan kuadrat acak dan melakukan dekomposisi QR-nya, atau melalui proses Gram-Schmidt) dan random diagonal dengan semua elemen positif; bentuk .$\mathbf Q$$\mathbf A$$\mathbf D$$\mathbf B = \mathbf Q \mathbf D \mathbf Q^\top$

   Matriks yang diperoleh dapat dengan mudah dinormalisasi untuk memiliki semua yang ada di diagonal: , di mana adalah matriks diagonal dengan diagonal yang sama seperti . Ketiga cara yang tercantum di atas untuk menghasilkan menghasilkan memiliki elemen off-diagonal tutup .$\mathbf B$$\mathbf C = \mathbf D^{-1/2}\mathbf B \mathbf D^{-1/2}$$\mathbf D = \mathrm{diag}\:\mathbf B$$\mathbf B$$\mathbf B$$\mathbf C$$0$

Pembaruan: Utas yang lebih lama

Setelah memposting pertanyaan saya, saya menemukan dua duplikat di masa lalu:

• Bagaimana menghasilkan matriks korelasi acak yang memiliki entri off-diagonal yang terdistribusi normal dengan deviasi standar yang diberikan?
• Bagaimana cara secara efisien menghasilkan matriks korelasi positif-semidefinit acak?

Sayangnya, tidak ada utas ini yang berisi jawaban yang memuaskan (sampai sekarang :)

Jawaban lain muncul dengan trik yang bagus untuk menyelesaikan masalah saya dengan berbagai cara. Namun, saya menemukan pendekatan berprinsip yang menurut saya memiliki keuntungan besar karena secara konsep sangat jelas dan mudah disesuaikan.

Di utas ini: Bagaimana cara efisien menghasilkan matriks korelasi positif-semidefinit acak? - Saya menjelaskan dan menyediakan kode untuk dua algoritma yang efisien untuk menghasilkan matriks korelasi acak. Keduanya berasal dari sebuah makalah oleh Lewandowski, Kurowicka, dan Joe (2009), bahwa @ssdecontrol disebut dalam komentar di atas (terima kasih banyak!).

Silakan lihat jawaban saya di sana banyak angka, penjelasan, dan kode matlab. Metode yang disebut "anggur" memungkinkan untuk menghasilkan matriks korelasi acak dengan distribusi korelasi parsial dan dapat digunakan untuk menghasilkan matriks korelasi dengan nilai off-diagonal yang besar. Berikut ini contoh gambar dari utas itu:

Satu-satunya hal yang berubah di antara subplot, adalah satu parameter yang mengontrol seberapa banyak distribusi korelasi parsial terkonsentrasi di sekitar $\pm 1$ .

Saya menyalin kode saya untuk menghasilkan matriks ini di sini juga, untuk menunjukkan bahwa itu tidak lebih dari metode lain yang disarankan di sini. Silakan lihat jawaban tertaut saya untuk beberapa penjelasan. Nilai betaparamuntuk gambar di atas adalah (dan dimensi adalah 100 ).${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

Perbarui: nilai eigen

@psarka bertanya tentang nilai eigen dari matriks ini. Pada gambar di bawah ini saya plot spektrum nilai eigen dari enam matriks korelasi yang sama seperti di atas. Perhatikan bahwa mereka menurun secara bertahap; sebaliknya, metode yang disarankan oleh @psarka umumnya menghasilkan matriks korelasi dengan satu nilai eigen besar, tetapi sisanya cukup seragam.

Memperbarui. Metode yang sangat sederhana: beberapa faktor

Mirip dengan apa yang ditulis @ttnphns dalam komentar di atas dan @GottfriedHelms dalam jawabannya, satu cara yang sangat sederhana untuk mencapai tujuan saya adalah dengan secara acak menghasilkan beberapa ( ) pemuatan faktor W (matriks acak ukuran k × n ), membentuk matriks kovarian W W ⊤ (yang tentu saja tidak akan peringkat penuh) dan menambahkannya matriks diagonal acak D dengan elemen positif untuk membuat B = W W ⊤ + $k<n$$\mathbf W$$k \times n$$\mathbf W \mathbf W^\top$$\mathbf D$$\mathbf B = \mathbf W \mathbf W^\top + \mathbf D$peringkat penuh. Matriks kovarians yang dihasilkan dapat dinormalisasi menjadi matriks korelasi (seperti yang dijelaskan dalam pertanyaan saya). Ini sangat sederhana dan bermanfaat. Berikut adalah beberapa contoh matriks korelasi untuk :$k={100, 50, 20, 10, 5, 1}$

Satu-satunya downside adalah bahwa matriks yang dihasilkan akan memiliki nilai eigen besar dan kemudian penurunan tiba-tiba, yang bertentangan dengan pembusukan bagus yang ditunjukkan di atas dengan metode anggur. Berikut adalah spektrum yang sesuai:$k$

Ini kodenya:

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()

Hmm, setelah saya melakukan contoh dalam bahasa MatMate saya, saya melihat bahwa sudah ada jawaban python, yang mungkin lebih disukai karena python banyak digunakan. Tetapi karena Anda masih memiliki pertanyaan, saya menunjukkan kepada Anda pendekatan saya menggunakan bahasa Matmate-matrix, mungkin itu lebih mandiri.

Metode 1
(Menggunakan 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

Masalahnya di sini mungkin, bahwa kita mendefinisikan blok-blok submatrices yang memiliki korelasi tinggi di dalam dengan sedikit korelasi di antara dan ini tidak terprogram tetapi dengan konatenasi-ekspresi konstan. Mungkin pendekatan ini bisa dimodelkan dengan lebih elegan dalam python.

{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~

dan matriks korelasi yang dihasilkan adalah

     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

Mungkin ini menghasilkan matriks korelasi dengan komponen utama yang dominan karena aturan pembangkit kumulatif untuk matriks faktor-pembebanan. Juga mungkin lebih baik untuk memastikan kepastian positif dengan membuat bagian terakhir dari varians sebagai faktor unik. Saya meninggalkannya di program untuk tetap fokus pada prinsip umum.

Matriks korelasi 100x100 memiliki frekuensi korelasi berikut (dibulatkan ke 1 tempat des)

    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

[memperbarui]. Hmm, matriks 100x100 dikondisikan dengan buruk; Pari / GP tidak dapat menentukan nilai eigen dengan benar dengan polroot (charpoly ()) - berfungsi bahkan dengan presisi 200 digit. Saya telah melakukan rotasi Jacobi ke pca-form pada loadingsmatrix L dan menemukan nilai eigen yang sangat kecil, mencetaknya dalam logaritma ke basis 10 (yang secara kasar memberikan posisi titik desimal). Baca dari kiri ke kanan lalu baris demi baris:

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

[pembaruan 2]
Metode 2 (b)
Peningkatan mungkin untuk meningkatkan varians spesifik item ke beberapa level non-marginal dan mengurangi ke sejumlah faktor umum yang cukup kecil (misalnya integer-squareroot dari itemnumber):

{  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...

Struktur hasilnya

dalam hal distribusi korelasi:

tetap serupa (juga dekomposabilitas buruk oleh PariGP), tetapi nilai eigen, ketika ditemukan oleh rotasi jacobi dari loadingsmatrix, sekarang memiliki struktur yang lebih baik, untuk contoh yang baru dihitung saya mendapatkan nilai eigen sebagai

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 memiliki paket (clusterGeneration) yang mengimplementasikan metode dalam:

• Joe, H. (2006) Menghasilkan Matriks Korelasi Acak Berdasarkan Korelasi Parsial . Jurnal Analisis Multivariat, 97, 2177--2189.

Contoh:

> (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

Sayangnya, sepertinya tidak mungkin untuk mensimulasikan korelasi yang mengikuti distribusi seragam-ish dengan ini. Tampaknya membuat korelasi yang lebih kuat ketika alphaddiatur ke nilai yang sangat kecil, tetapi bahkan pada1/100000000000000 , kisaran korelasi hanya akan naik menjadi sekitar 1,40.

Meskipun demikian, saya harap ini bisa berguna bagi seseorang.