Comment générer une grande matrice de corrélation aléatoire de rang complet avec de fortes corrélations présentes?

25

Je voudrais générer une matrice de corrélation aléatoire de telle sorte qu'il y ait des corrélations modérément fortes présentes: n × nCn×n

  • matrice symétrique réelle carrée de taille, avec par exemple ;n = 100n×nn=100
  • positif-défini, c'est-à-dire avec toutes les valeurs propres réelles et positives;
  • rang complet;
  • tous les éléments diagonaux égaux à ;1
  • les éléments hors diagonale doivent être répartis de manière raisonnablement uniforme sur . La distribution exacte n'a pas d'importance, mais j'aimerais avoir une quantité modérément grande (par exemple ) de valeurs modérément grandes (par exemple avec une valeur absolue de ou plus). Fondamentalement, je veux m'assurer que n'est pas presque en diagonale avec tous les éléments hors diagonale .10 % 0,5 C(1,1)10%0.5C0

Existe-t-il un moyen simple de le faire?

Le but est d'utiliser de telles matrices aléatoires pour comparer certains algorithmes travaillant avec des matrices de corrélation (ou covariance).


Méthodes qui ne fonctionnent pas

Voici quelques façons de générer des matrices de corrélation aléatoires que je connais, mais qui ne fonctionnent pas pour moi ici:

  1. Générer au hasard de dimensions, du centre, de normaliser et de former la matrice de corrélation . Si , cela se traduira généralement par toutes les corrélations hors diagonale autour de . Si , certaines corrélations seront fortes, mais ne sera pas de rang complet. s × n C = 1Xs×ns>n0snCC=1s1XXs>n0snC

  2. Générez une matrice définie positive aléatoire de l'une des manières suivantes:B

    • Générez un carré aléatoire et symétrique positif défini .B = A AAB=AA

    • Générer un carré aléatoire , rendre symétrique et le rendre positif défini en effectuant la décomposition propre et mettre toutes les valeurs propres négatives à zéro: . NB: cela se traduira par une matrice de rang déficient.E = A + AE = U S UB = UAE=A+AE=USUB=Umax{S,0}U

    • Générer aléatoire orthogonal (par exemple en générant un carré aléatoire et en faisant sa décomposition QR, ou via le processus de Gram-Schmidt) et aléatoire diagonal avec tous les éléments positifs; forme .QADB=QDQ

    La matrice obtenue peut être facilement normalisée pour avoir toutes celles sur la diagonale: , où est la matrice diagonale avec la même diagonale que . Les trois méthodes répertoriées ci-dessus pour générer résultat que des éléments hors diagonale fermant .BC=D1/2BD1/2D=diagBBBC0


Mise à jour: anciens threads

Après avoir posté ma question, j'ai trouvé deux doublons dans le passé:

Malheureusement, aucun de ces fils ne contenait de réponse satisfaisante (jusqu'à présent :)

amibe dit réintégrer Monica
la source
1
Vous pouvez créer une matrice orthogonale aléatoire par des processus QR ou Gram-Schmidt. Ce seront des "vecteurs propres de PCA". Ajoutez de l'échelle à ses colonnes (transformez-les en "chargements"). Obtenez la matrice de covariance de ces chargements. Quelque chose comme ça ...
ttnphns
1
Uhm, eh bien. Imaginez que nous voulons créer une nXkmatrice de chargement W, pas entièrement aléatoire, mais celle que nous voulons (elle WW'+diag(noise)définira la matrice cov que nous recherchons. La seule tâche est de corriger le W normalisé par colonne (c'est-à-dire le k "vecteurs propres") pour devenir orthogonaux. Toute méthode pour décorréler les variables corrélées (ici les variables sont les vecteurs propres) fera probablement l'affaire. (C'est une idée brute.)
ttnphns
1
Ah, @whuber, maintenant je vois ce que tu veux dire. Oui, vous avez raison: si tous les éléments hors diagonale sont identiques et égaux à , alors la matrice est en effet de plein rang et définie positivement ... Ce n'est bien sûr pas ce que j'avais en tête: je voudrais la distribution des éléments hors diagonale dans chaque matrice pour être raisonnablement "répartis", pas la distribution entre les matrices ...ρ
amibe dit Reinstate Monica
3
Vous voudrez peut-être examiner la distribution LKJ
shadowtalker
2
@ttnphns: Je pense que j'ai finalement compris que vous aviez raison depuis le début: ce que vous avez suggéré est le moyen le plus simple d'atteindre le but. J'ai ajouté une mise à jour à ma réponse implémentant essentiellement ce que vous avez écrit ci-dessus.
amibe dit Réintégrer Monica

Réponses:

14

D'autres réponses ont fourni de belles astuces pour résoudre mon problème de différentes manières. Cependant, j'ai trouvé une approche fondée sur des principes qui, je pense, a un grand avantage d'être conceptuellement très claire et facile à ajuster.

Dans ce fil de discussion: Comment générer efficacement des matrices de corrélation aléatoire semi-définies positives? - J'ai décrit et fourni le code de deux algorithmes efficaces de génération de matrices de corrélation aléatoire. Tous deux proviennent d'un article de Lewandowski, Kurowicka et Joe (2009), auquel @ssdecontrol a fait référence dans les commentaires ci-dessus (merci beaucoup!).

S'il vous plaît voir ma réponse là pour beaucoup de chiffres, d'explications et de code matlab. La méthode dite de "vigne" permet de générer des matrices de corrélation aléatoires avec n'importe quelle distribution de corrélations partielles et peut être utilisée pour générer des matrices de corrélation avec de grandes valeurs hors diagonales. Voici l'exemple de figure de ce fil:

Méthode de la vigne

La seule chose qui change entre les sous-parcelles est un paramètre qui contrôle la concentration de la distribution des corrélations partielles autour de .±1

Je copie mon code pour générer ces matrices ici aussi, pour montrer qu'il n'est pas plus long que les autres méthodes suggérées ici. Veuillez voir ma réponse liée pour quelques explications. Les valeurs de betaparampour la figure ci-dessus étaient (et la dimensionnalité était de 100 ).50,20,dix,5,2,1d100

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

Mise à jour: valeurs propres

@psarka pose des questions sur les valeurs propres de ces matrices. Sur la figure ci-dessous, je trace les spectres de valeurs propres des six mêmes matrices de corrélation que ci-dessus. Notez qu'ils diminuent progressivement; en revanche, la méthode suggérée par @psarka aboutit généralement à une matrice de corrélation avec une grande valeur propre, mais le reste étant assez uniforme.

valeurs propres des matrices ci-dessus


Mise à jour. Méthode vraiment simple: plusieurs facteurs

Semblable à ce que @ttnphns a écrit dans les commentaires ci-dessus et à @GottfriedHelms dans sa réponse, un moyen très simple d'atteindre mon objectif est de générer aléatoirement plusieurs ( ) chargements de facteur W (matrice aléatoire de taille k × n ), forment le matrice de covariance W W (qui bien sûr ne sera pas de rang complet) et y ajouter une matrice diagonale aléatoire D avec des éléments positifs pour faire B = W W + Dk<nWk×nWWB=WW+rang complet. La matrice de covariance résultante peut être normalisée pour devenir une matrice de corrélation (comme décrit dans ma question). C'est très simple et fait l'affaire. Voici quelques exemples de matrices de corrélation pour :k=100,50,20,dix,5,1

matrices de corrélation aléatoire à partir de facteurs aléatoires

Le seul inconvénient est que la matrice résultante aura grandes valeurs propres, puis une chute soudaine, par opposition à une belle désintégration illustrée ci-dessus avec la méthode de la vigne. Voici les spectres correspondants:k

eigenspectra de ces matrices

Voici le code:

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)));
amibe dit réintégrer Monica
la source
+1. Cependant, voici juste un rappel de votre dernière section sur la "méthode factorielle". L'approche strictement droite appelle les colonnes Worthogonales (c'est-à-dire que les cosinus entre elles sont 0). La simple génération aléatoire Wne le fournit bien sûr pas. S'ils ne sont pas orthogonaux - c'est-à-dire que les facteurs sont obliques (appelons alors Was W_) - le théorème des facteurs n'est pas WW'mais W_CW_'avec des C"corrélations" (cosinus) entre les facteurs. Maintenant, C=Q'Qavec Qétant la matrice de rotation non orthogonal de rotation W_=inv(Q)'W(et donc W=W_Q'). Générez Q-en une matrice avec colonne ss = 1 et matrice ss = taille de la matrice.
ttnphns
... faute de frappe W_=inv(Q)'W, bien sûr W_= W inv(Q)'.
ttnphns
WWW+W
1
Traduire cela en R:W = replicate(k, rnorm(d)); S = W%*%t(W) + diag(rnorm(d),nrow=d); S = diag(1/sqrt(diag(S)))%*%S%*%diag(1/sqrt(diag(S)))
Scott Worland
1
@Mihai, bon point et vos suggestions sont probablement les plus simples. Vous pourriez aussi faireS <- matrix(nearPD(S, corr = TRUE, keepDiag = TRUE)$mat@x,ncol(S),ncol(S))
Scott Worland le
7

une

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

La distribution quelque peu uniforme Les résultats de imshow

psarka
la source
crsk[-une,une]X
Oui, vous avez tout à fait raison! (Oh mon garçon, c'était vraiment idiot: D). J'ai changé la partie aléatoire en randn (1) * a et maintenant c'est beaucoup mieux.
psarka
k
unen
Un inconvénient de cette méthode est que la matrice de corrélation résultante a une grande valeur propre, mais les autres sont presque uniformes. Donc cette procédure ne donne pas de matrice de corrélation "générale" ... Non pas que je l'ai spécifiée dans ma question. Mais @ssdecontrol a mentionné dans les commentaires ci-dessus qu'il semble qu'il existe des moyens d'échantillonner à partir de toutes les matrices de corrélation; cela semble intéressant mais beaucoup plus compliqué.
amibe dit Réintégrer Monica
6

Hmm, après avoir fait un exemple dans mon langage MatMate, je vois qu'il y a déjà une réponse python, ce qui pourrait être préférable car python est largement utilisé. Mais parce que vous aviez encore des questions, je vous montre mon approche en utilisant le langage Matmate-matrix, c'est peut-être plus auto-commenté.

Méthode 1
(à l'aide de 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

Le problème ici pourrait être que nous définissons des blocs de sous-matrices qui ont de fortes corrélations à l'intérieur avec peu de corrélation entre et ce n'est pas par programme mais par les expressions de concaténation constantes. Peut-être que cette approche pourrait être modélisée plus élégamment en python.


Méthode 2 (a)
Après cela, il y a une approche complètement différente, où nous remplissons la covariance restante possible par des quantités aléatoires de 100 pour cent dans une matrice de charges de facteurs. Cela se fait en Pari / GP:

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

et la matrice de corrélation produite est

     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

Il est possible que cela génère une matrice de corrélation avec des composants principaux dominants en raison de la règle de génération cumulative pour la matrice de charges factorielles. Il serait également préférable d’assurer un caractère définitif positif en faisant de la dernière partie de la variance un facteur unique. Je l'ai laissé dans le programme pour rester concentré sur le principe général.

Une matrice de corrélation 100x100 avait les fréquences de corrélations suivantes (arrondies à 1 déc.)

    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

[mise à jour]. Hmm, la matrice 100x100 est mal conditionnée; Pari / GP ne peut pas déterminer correctement les valeurs propres avec la fonction polroots (charpoly ()), même avec une précision de 200 chiffres. J'ai fait une rotation de Jacobi pour former pca sur la matrice de chargement L et j'ai trouvé des valeurs propres extrêmement petites, les ai imprimées en logarithmes à la base 10 (qui donnent approximativement la position de la virgule décimale). Lisez de gauche à droite, puis ligne par ligne:

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

[mise à jour 2]
Méthode 2 (b)
Une amélioration pourrait être d'augmenter la variance spécifique à un élément à un niveau non marginal et de réduire à un nombre raisonnablement plus petit de facteurs communs (par exemple, racine carrée entière du numéro d'article):

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

La structure du résultat

en termes de distribution des corrélations:image

reste similaire (également la non décomposabilité désagréable par PariGP), mais les valeurs propres, lorsqu'elles sont trouvées par jacobi-rotation de la matrice de chargement, ont maintenant une meilleure structure, pour un exemple nouvellement calculé, j'ai obtenu les valeurs propres comme

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
Heaumes Gottfried
la source
Merci beaucoup! Très intéressant, mais il me faudra du temps pour digérer ...
amibe dit Reinstate Monica
Je dois encore parcourir attentivement votre réponse, mais en attendant, j'ai lu un article sur l'échantillonnage des matrices de corrélation aléatoire, et l'une des méthodes à partir de là peut être utilisée pour faire exactement ce dont j'ai besoin. J'ai posté une réponse ici, vous pourriez être intéressé de jeter un œil! Il renvoie à une réponse beaucoup plus détaillée que j'ai écrite dans un autre fil.
amibe dit Réintégrer Monica
@amoeba: heureux d'avoir trouvé quelque chose qui fonctionne bien pour vous! C'est une question intéressante, j'y reviendrai plus tard moi-même, peut-être améliorer / adapter les procédures MatMate (et en faire des sous-programmes) selon le document sur lequel vous avez travaillé.
Gottfried Helms
2

UNEBλUNE+(1-λ)Bλ

UNEBCλUNEUNE+λBB+λCCλ=1λ0

Andrew M
la source
UNEB
Ah, mais à partir d'un tel algorithme, et d'une diversité appropriée dans les "sommets" (c'est-à-dire les matrices) qui définissent votre polytope de matrices de corrélation positive-définie, vous pouvez utiliser l'échantillonnage de rejet pour obtenir la distribution des valeurs propres, l'uniformité des entrées, etc, que vous désirez. Cependant, il n'est pas clair pour moi quelle serait une bonne base. Cela ressemble à une question pour quelqu'un qui a étudié l'algèbre abstraite plus récemment que moi.
Andrew M
Bonjour, j'ai lu un article sur l'échantillonnage des matrices de corrélation aléatoire, et l'une des méthodes à partir de là peut être utilisée pour faire exactement ce dont j'ai besoin. J'ai posté une réponse ici, vous pourriez être intéressé de jeter un œil! Il renvoie à une réponse beaucoup plus détaillée que j'ai écrite dans un autre fil.
amibe dit Réintégrer Monica
2

R a un package (clusterGeneration) qui implémente la méthode dans:

Exemple:

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

Malheureusement, il ne semble pas possible de simuler des corrélations qui suivent une distribution uniforme avec cela. Il semble faire des corrélations plus fortes quand il alphadest réglé sur de très petites valeurs, mais même à 1/100000000000000, la plage de corrélations ne monterait qu'à environ 1,40.

Néanmoins, j'espère que cela pourrait être utile à quelqu'un.

Deleet
la source