1、协方差矩阵

1、问题描述
  在学习PCA降维处理的时候，我发现里面使用到了协方差矩阵以及求解方阵的特征值和特征向量，我想知道协方差矩阵的求解过程，以及验算方阵的特征值和特征向量，因此就使用到了下面的方法。
2、代码

import numpy as np

data1 = np.array([10, 11, 8, 3, 2, 1])
data2 = np.array([6, 4, 5, 3, 2.8, 1])

# 包含两个维度的数据
data = [data1, data2]
# <class 'list'>
print(type(data))
# [array([10, 11,  8,  3,  2,  1]), array([6. , 4. , 5. , 3. , 2.8, 1. ])]
print(data)
# 协方差矩阵
# [[18.96666667  6.48666667]
#  [ 6.48666667  3.12666667]]
print(np.cov(data))

# 求出每一个数据的均值
data1_mean = np.mean(data1)
data2_mean = np.mean(data2)
# 5.833333333333333
print(data1_mean)
3.6333333333333333
print(data2_mean)

# 使用常规方法计算cov11的协方差
# 18.96666666666667
cov_11 = (1 / (len(data1) - 1)) * np.dot((data1 - data1_mean), (data1 - data1_mean))
print(cov_11)

2、特征值和特征向量

1、代码

# 求解矩阵的特征值和特征向量
data3 = np.diag((1, 2, 3, 4))
result = np.linalg.eig(data3)
print(result)

# 结果
(array([1., 2., 3., 4.]), 
 array([[1., 0., 0., 0.],
       [0., 1., 0., 0.],
       [0., 0., 1., 0.],
       [0., 0., 0., 1.]]))

3、SVD分解

1、描述
  函数原型如下：

np.linalg.svd(a,full_matrices=1,compute_uv=1)

  a是一个（m，n）的矩阵；full_matrices默认为1，表示左奇异矩阵U形状为（m,m）,右奇异矩阵VT的形状为（n,n），如果为0时，U形状为（m,k）,VT的形状为（k,n），其中k = min（m,n）；compute_uv默认为1，表示计算U，sigma，VT矩阵，反之，只计算sigma。
  下面对4*5矩阵A进行SVD分解，代码如下：

2、代码

import numpy as np

# 4 * 5
a = np.array([[1, 0, 0, 0, 2], [0, 0, 3, 0, 0],
              [0, 0, 0, 0, 0], [0, 4, 0, 0, 0]])
U, sigma, VT = np.linalg.svd(a)
# [[ 0.  0.  1.  0.]
#  [ 0.  1.  0.  0.]
#  [ 0.  0.  0. -1.]
#  [ 1.  0.  0.  0.]]
print(U)
# (4,)
# [4.         3.         2.23606798 0.        ]
print(sigma)
# 5 * 5
# [[-0.          1.          0.          0.          0.        ]
#  [-0.          0.          1.          0.          0.        ]
#  [ 0.4472136   0.          0.          0.          0.89442719]
#  [ 0.          0.          0.          1.          0.        ]
#  [-0.89442719  0.          0.          0.          0.4472136 ]]
print(VT)

首先,对于将​​来可能会遇到这个问题的其他人：如果你确实有数据并且想要估计协方差矩阵,正如几个人所指出的那样,使用np.cov或类似的东西.

从模式构建阵列

但是,您的问题是如何在给定一些预定义规则的情况下构建大型矩阵.为了澄清评论中的一些混淆：你的问题似乎不是关于估计协方差矩阵,而是关于指定一个.换句话说,你问的是如何在给定一些预定义规则的情况下构建一个大型数组.

哪种方式最有效取决于你正在做的细节.在这种情况下,大多数性能技巧将涉及在您正在执行的计算中利用对称性. (例如,一行是否相同？)

如果不确切知道自己在做什么,就很难说清楚.因此,我将重点关注如何做这类事情. (注意：我刚注意到你的编辑.我将在稍后的例子中包含一个布朗桥的例子……)

常量(或简单)行/列

最基本的情况是输出数组中的常量行或列.使用切片语法可以轻松创建数组并为列或行指定值：

import numpy as np

num_vars = 10**4

cov = np.zeros((num_vars, num_vars), dtype=float)

要设置整个列/行：

# Third column will be all 9's

cov[:,2] = 9

# Second row will be all 1's (will overwrite the 9 in col3)

cov[1,:] = 1

您还可以将数组分配给列/行：

# 5th row will have random values

cov[4,:] = np.random.random(num_vars)

# 6th row will have a simple geometric sequence

cov[5,:] = np.arange(num_vars)**2

堆叠阵列

在许多情况下,(但可能不是这种情况)您需要从现有数组构建输出.您可以使用vstack / hstack / column_stack / tile以及许多其他类似的功能.

一个很好的例子是,如果我们为多项式的线性反演建立一个矩阵：

import numpy as np

num = 10

x = np.random.random(num) # Observation locations

# "Green's functions" for a second-order polynomial

# at our observed locations

A = np.column_stack([x**i for i in range(3)])

但是,这将构建几个临时数组(在本例中为三个).如果我们使用10000维多项式进行10 ^ 6次观测,则上述方法将使用太多RAM.因此,您可能会迭代列而不是：

ndim = 2

A = np.zeros((x.size, ndim + 1), dtype=float)

for j in range(ndim + 1):

A[:,j] = x**j

在大多数情况下,不要担心临时数组.除非您使用相对较大的数组,否则基于colum_stack的示例是正确的方法.

最通用的方法

没有任何更多的信息,我们不能利用任何形式的对称性.最通用的方法是迭代.通常你会想要避免这种方法,但有时它是不可避免的(特别是如果计算取决于先前的值).

速度方面,这与嵌套for循环相同,但使用np.ndindex而不是多个for循环更容易(特别是对于> 2D数组)：

import numpy as np

num_vars = 10**4

cov = np.zeros((num_vars, num_vars), dtype=float)

for i, j in np.ndindex(cov.shape):

# Logic presumably in some function...

cov[i, j] = calculate_value(i, j)

矢量基于索引的计算

如果情况很多,您可以对基于索引的计算进行矢量化.换句话说,直接在输出索引的数组上操作.

假设我们的代码看起来像：

import numpy as np

cov = np.zeros((10, 10)), dtype=float)

for i, j in np.ndindex(cov.shape):

cov[i,j] = i*j - i

我们可以用以下内容代替：

i, j = np.mgrid[:10, :10]

cov = i*j - i

再举一个例子,让我们建立一个100 x 100“倒锥”的值：

# The complex numbers in "mgrid" give the number of increments

# mgrid[min:max:num*1j, min:max:num*1j] is similar to

# meshgrid(linspace(min, max, num), linspace(min, max, num))

y, x = np.mgrid[-5:5:100j, -5:5:100j]

# Our "inverted cone" is just the distance from 0

r = np.hypot(x, y)

布朗桥

这是一个很容易被矢量化的例子.如果我正确地阅读你的例子,你会想要类似的东西：

import numpy as np

st = np.mgrid[1:101, 1:101]

s, t = st

cov = st.min(axis=0) - s * t

总的来说,我只涉及一些一般模式.但是,希望这会让你指向正确的方向.

首先，对于将来可能遇到这个问题的其他人：如果您确实有数据，并且想要估计协方差矩阵，正如一些人所指出的，请使用np.cov或类似的方法。

从模式构建数组

但是，您的问题是如何在给定一些预定义规则的情况下构建一个大型矩阵。为了澄清注释中的一些混乱：您的问题似乎不是关于估计协方差矩阵，而是关于指定一个协方差矩阵。换言之，您将询问如何在给定一些预定义规则的情况下构建大型数组。

哪种方法最有效取决于你在做什么。在这种情况下，大多数性能技巧都涉及到在执行计算时利用对称性。（例如，一行是否相同？）

在不知道自己在做什么的情况下，很难说出任何具体的事情。因此，我将集中讨论如何做这类事情。（注：我刚刚注意到你的编辑。我将包括一个布朗尼桥的例子在一点点…）

常量（或简单）行/列

最基本的情况是输出数组中的常量行或列。使用切片语法很容易创建数组并将值赋给列或行：import numpy as np

num_vars = 10**4

cov = np.zeros((num_vars, num_vars), dtype=float)

要设置整列/整行：# Third column will be all 9's

cov[:,2] = 9

# Second row will be all 1's (will overwrite the 9 in col3)

cov[1,:] = 1

也可以将数组分配给列/行：# 5th row will have random values

cov[4,:] = np.random.random(num_vars)

# 6th row will have a simple geometric sequence

cov[5,:] = np.arange(num_vars)**2

堆叠阵列

在许多情况下（但可能不是这种情况），您需要从现有数组中构建输出。您可以使用vstack/hstack/column_stack/tile和许多其他类似的函数。

一个很好的例子是，如果我们为多项式的线性反演建立一个矩阵：import numpy as np

num = 10

x = np.random.random(num) # Observation locations

# "Green's functions" for a second-order polynomial

# at our observed locations

A = np.column_stack([x**i for i in range(3)])

但是，这将构建几个临时数组（在本例中是三个）。如果我们用10^6的观测值处理10000维多项式，上面的方法会使用太多的RAM。因此，您可以在列上迭代：ndim = 2

A = np.zeros((x.size, ndim + 1), dtype=float)

for j in range(ndim + 1):

A[:,j] = x**j

在大多数情况下，不要担心临时数组。基于colum_stack的示例是正确的方法，除非您使用的是相对较大的数组。

最一般的方法

没有更多的信息，我们就不能利用任何对称性。最普遍的方法就是迭代。通常您会希望避免这种方法，但有时它是不可避免的（特别是如果计算依赖于以前的值）。

速度方面，这与嵌套for循环相同，但使用np.ndindex而不是多个for循环更容易（特别是对于&gt；2D数组）：import numpy as np

num_vars = 10**4

cov = np.zeros((num_vars, num_vars), dtype=float)

for i, j in np.ndindex(cov.shape):

# Logic presumably in some function...

cov[i, j] = calculate_value(i, j)

基于矢量索引的计算

如果很多情况下，可以对基于索引的计算进行矢量化。换句话说，直接对输出的索引数组进行操作。

假设我们有这样的代码：import numpy as np

cov = np.zeros((10, 10)), dtype=float)

for i, j in np.ndindex(cov.shape):

cov[i,j] = i*j - i

我们可以换成：i, j = np.mgrid[:10, :10]

cov = i*j - i

作为另一个例子，让我们建立一个100 x 100的“倒锥”值：# The complex numbers in "mgrid" give the number of increments

# mgrid[min:max:num*1j, min:max:num*1j] is similar to

# meshgrid(linspace(min, max, num), linspace(min, max, num))

y, x = np.mgrid[-5:5:100j, -5:5:100j]

# Our "inverted cone" is just the distance from 0

r = np.hypot(x, y)

布朗桥

这是一个很好的例子，可以很容易地矢量化。如果我没看错你的例子，你会想要类似的东西：import numpy as np

st = np.mgrid[1:101, 1:101]

s, t = st

cov = st.min(axis=0) - s * t

总的来说，我只谈到了一些一般的模式。不过，希望这能让你找到正确的方向。