link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

在Numpy中生成对称矩阵

39 人关注

我正试图在numpy中生成对称矩阵。具体来说，这些矩阵要有随机的地方条目，而且每个条目的内容都可以是随机的。沿着主对角线，我们并不关心里面有什么条目，所以我把这些条目也随机化了。

我采取的方法是首先生成一个nxn的全零矩阵，然后简单地在矩阵的索引上循环。我怎样才能用numpy更有效地做到这一点？

import numpy as np
import random
def empty(x, y):
    return x*0
b = np.fromfunction(empty, (n, n), dtype = int)
for i in range(0, n):
    for j in range(0, n):
        if i == j:
            b[i][j] = random.randrange(-2000, 2000)
        else:
            switch = random.random()
            random.seed()
            if switch > random.random():
                a = random.randrange(-2000, 2000)
                b[i][j] = a
                b[j][i] = a
            else:
                b[i][j] = 0
                b[j][i] = 0


         python


         random


         matrix


         numpy


         adjacency-matrix


        7
        
        个回答


          已采纳


         0
         
         人赞同


          
           You could just do something like:
          
          import numpy as np
N = 100
b = np.random.random_integers(-2000,2000,size=(N,N))
b_symm = (b + b.T)/2
在这里，你可以在np.random或同等的scipy模块中选择你想要的任何分布。
更新。如果你想建立类似图的结构，一定要看看networkx软件包。
http://networkx.lanl.gov
它有许多内置的例程来构建图形。
http://networkx.lanl.gov/reference/generators.html
另外，如果你想增加一些随机放置的零，你总是可以生成一组随机的指数，并用零替换这些值。


           
            
             谢谢!这是一个有效的解决方案。然而，我是否有办法让它在一些地方随机地放置零？这个矩阵应该代表一种图的邻接矩阵，所以最好是有一个随机分布的零的矩阵。


           
            
             @Ryan：你关心随机条目有什么样的分布吗？如果你加上
             
              b + b.T
             
             ，你会得到一个集中在0附近的非均匀分布。


           
            
             我正在验证矩阵的一些属性。它更多的是努力为一些数学特性提供令人信服的证据，所以这里的分布并不那么重要。不过还是要谢谢你!


           
            
             @unutbu , true, use
             
              np.tril(a) + np.tril(a, -1).T
             
             then.


           
            
             
              np.random.randint(-5,5,size=(N,N))
             
             似乎已被废弃，需要使用
             
              randint
             
             。


          
           
            I'd better do:
           
           a = np.random.rand(N, N)
m = np.tril(a) + np.tril(a, -1).T
因为在这种情况下，一个矩阵的所有元素都来自于相同的分布(在这种情况下是统一的）。


           
            
             
              这是一个非常优雅的保持相同分布的方法！这也是一个很好的方法。


          
           
            
             矩阵中有一个数学特性，可以轻易地创建这样的结构。
             
              A.T * A
             
             其中A是一个行向量，而
             
              A.t
             
             是转置（一个列向量）。这总是返回一个方形正定对称矩阵，它总是可逆的，所以你不用担心空枢轴的问题;)
            
            # any matrix algebra will do it, numpy is simpler
import numpy.matlib as mt
# create a row vector of given size
size  = 3
A = mt.rand(1,size)
# create a symmetric matrix size * size
symmA = A.T * A


           
            
             
              
               ps:"总是可逆的 "对矩阵来说是真的，对向量来说不是。所以，从数值上来说，做mt.rand(size, size)会更稳健。无论如何，它将返回一个size x size的矩阵，但在计算上更昂贵。


          
           
            
             
              如果你不介意对角线上有零，你可以使用下面的片段。
             
             def random_symmetric_matrix(n):
    _R = np.random.uniform(-1,1,n*(n-1)/2)
    P = np.zeros((n,n))
    P[np.triu_indices(n, 1)] = _R
    P[np.tril_indices(n, -1)] = P.T[np.tril_indices(n, -1)]
    return P
注意，由于对称性，你只需要生成n*(n-1)/2个随机变量。


          
           
            
             
              
               
               
                Apoorv Mote
               
              
              
               发布于
               
               2019-10-09


          
           
            
             
              import numpy as np
n = 5
M = np.random.randint(-2000,2000,(n,n))
symm = [email protected]
# test for symmetry
print(symm == symm.T)
This worked for me


          
           
            
             
              
               
                我正在使用以下函数使一个矩阵在垂直和水平方向上都是对称的。
               
               def make_sym(a):
    w, h = a.shape
    a[w - w // 2 :, :] = np.flipud(a[:w // 2, :])
    a[:, h - h // 2:] = np.fliplr(a[:, :h // 2])
Let check how it works:
>>> m = (np.random.rand(10, 10) * 10).astype(np.int)
>>> make_sym(m)
array([[2, 7, 5, 7, 7, 7, 7, 5, 7, 2],
       [6, 3, 9, 3, 6, 6, 3, 9, 3, 6],
       [1, 4, 6, 7, 2, 2, 7, 6, 4, 1],
       [9, 2, 7, 0, 8, 8, 0, 7, 2, 9],
       [5, 5, 6, 1, 9, 9, 1, 6, 5, 5],
       [5, 5, 6, 1, 9, 9, 1, 6, 5, 5],
       [9, 2, 7, 0, 8, 8, 0, 7, 2, 9],
       [1, 4, 6, 7, 2, 2, 7, 6, 4, 1],
       [6, 3, 9, 3, 6, 6, 3, 9, 3, 6],
       [2, 7, 5, 7, 7, 7, 7, 5, 7, 2]])


          
           
            
             
              
               
                
                 
                  
                  
                   Fábio Reale
                  
                 
                 
                  发布于
                  
                  2019-10-09


          
           
            
             
              
               
                
                 
                  这里有一个优雅的答案，产生一个所有条目都遵循相同分布的矩阵。然而，这个答案抛弃了
                  
                   (n-1)*n/2
                  
                  的随机数而没有使用它们。
                 
                 
                  如果你想让所有的值都遵循相同的分布，一次性生成，并且只生成你要使用的值，那么你可以运行以下程序。
                 
                 >>> import numpy as np
>>> n = 5
>>> r = np.random.rand(n*(n+1)//2)
>>> sym = np.zeros((n,n))
>>> for i in range(n):
...     t = i*(i+1)//2
...     sym[i,0:i+1] = r[t:t+i+1]
...     sym[0:i,i] = r[t:t+i]
>>> print(sym)
[[0.03019945 0.30679756 0.85722724 0.78498237 0.56146757]
 [0.30679756 0.46276869 0.45104513 0.28677046 0.10779794]
 [0.85722724 0.45104513 0.62193894 0.86898652 0.11543257]