原标题：协方差矩阵、相关系数矩阵的EXCEL和python实现
CPDA广州19期学员
现任职务：数据分析师
史金乐
优秀学员原创文章
要计算相关系数矩阵，那就不得不提协方差矩阵。在《概率论与数据统计》中协方差矩阵的定义具体如下：
按照协方差矩阵中各元素cij的计算过程，我们可以得知要依次计算E（Xi），X - E（Xi），cij。
在得到协方差矩阵之后，可以根据相关系数公式：（其中D（X）为矩阵X的方差）
可以得出相关系数矩阵，具体如下：
所以综上所述，要求相关系数矩阵，那么首先要求得协方差矩阵。接下来，就用Excel和python来分别求得协方差矩阵和相关系数矩阵。
Excel
原始数据如下：（取10组数据，X1、X2、X3为数据的特征）
接下来，打开Excel中的“数据”-“数据分析”（“数据分析”是Excel的加载项，添加方式是“文件”-“选项”-“加载项”-“Excel加载项”-转到-“分析工具库”-确定），然后选择协方差。
输入区域选择X1-X3的区域，分组方式选择“逐列”，将“标志位于第一行”前面的钩子点上，输入区域选择本工作表的G1单元格，然后点击确定。
然后即可得出协方差矩阵。具体如下：
在选择数据分析时，选择“相关系数”，然后同样的操作流程，即可得到相关系数矩阵。具体如下：
Excel中的实现比较简单，接下来就用python来计算相关系数矩阵和协方差矩阵。
python
首先整理下思路：
1、加载数据；
2、读取数据到Dataframe中；
3、整理需要计算的数据到新的Dataframe中，准备应用于下一步计算；
4、用Dataframe的cov方法来求协方差矩阵，用corr方法来求相关系数矩阵。
编写代码，并运行后得到如下结果：
细心的同学可以发现，协方差矩阵（上面的矩阵）得出的结果是和Excel里面计算的结果有所不同。原因是因为Dataframe中求协方差矩阵时候是进行了标准化处理，具体可查阅方法的文档说明：
那如何可以得到和Excel里面计算的结果一样呢？
那就要把这10组数据当作是样本总体，使用numpy.cov(bias=True)方法来求即可。整体代码如下：
整体运行得到的结果如下：
其实不管是Excel还是python，求协方差矩阵和相关系数矩阵都很简单，但是要理解二者的计算过程，自己手动计算一遍求解过程还是很有必要的，下面是我自己在Excel里面的计算过程，贴出来供给大家参考。
总体上来讲，协方差矩阵和相关系数矩阵是数据分析中的基础知识点，计算过程和实现方法都是比较简单的。打好基础才能更深入的学习后续知识~
福利到 CPDA全国线上沙龙活动
将于5月15日晚7点如期举办！
扫码进群即可免费参加
责任编辑：

Estimate a covariance matrix, given data and weights.
Covariance indicates the level to which two variables vary together. If we examine N-dimensional samples,
, then the covariance matrix element 
 is the covariance of 
 and 
. The element 
 is the variance of 
.
See the notes for an outline of the algorithm.
Parameters:
m : array_like
A 1-D or 2-D array containing multiple variables and observations. Each row （行） of m represents a variable（变量）, and each column（列） a single observation of all those variables（样本）. Also see rowvar below.
y : array_like, optional
An additional set of variables and observations. y has the same form as that of m.
rowvar : bool, optional
If rowvar is True (default), then each row represents a variable, with observations in the columns. Otherwise, the relationship is transposed: each column represents a variable, while the rows contain observations.
bias : bool, optional
Default normalization (False) is by (N - 1), where N is the number of observations given (unbiased estimate). If bias is True, then normalization is by N. These values can be overridden by using the keyword ddof in numpy versions >= 1.5.
ddof : int, optional
If not None the default value implied by bias is overridden. Note that ddof=1 will return the unbiased estimate, even if both fweights and aweights are specified, and ddof=0 will return the simple average. See the notes for the details. The default value is None.
New in version 1.5.
fweights : array_like, int, optional
1-D array of integer freguency weights; the number of times each observation vector should be repeated.
New in version 1.10.
aweights : array_like, optional
1-D array of observation vector weights. These relative weights are typically large for observations considered “important” and smaller for observations considered less “important”. If ddof=0 the array of weights can be used to assign probabilities to observation vectors.
New in version 1.10.
Returns:
out : ndarray
The covariance matrix of the variables.
See also
Normalized covariance matrix
Notes
Assume that the observations are in the columns of the observation array m and let f = fweights and a = aweights for brevity. The steps to compute the weighted covariance are as follows:
>>> w = f * a
>>> v1 = np.sum(w)
>>> v2 = np.sum(w * a)
>>> m -= np.sum(m * w, axis=1, keepdims=True) / v1
>>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
Note that when a == 1, the normalization factor v1 / (v1**2 - ddof * v2) goes over to 1 / (np.sum(f) - ddof) as it should.
Examples
Consider two variables,
 and 
, which correlate perfectly, but in opposite directions:
>>> x = np.array([[0, 2], [1, 1], [2, 0]]).T
>>> x
array([[0, 1, 2],
[2, 1, 0]])
Note how
 increases while 
 decreases. The covariance matrix shows this clearly:
>>> np.cov(x)
array([[ 1., -1.],
[-1.,  1.]])
Note that element
, which shows the correlation between 
 and 
, is negative.
Further, note how x and y are combined:
>>> x = [-2.1, -1,  4.3]
>>> y = [3,  1.1,  0.12]
>>> X = np.stack((x, y), axis=0)
>>> print(np.cov(X))
[[ 11.71        -4.286     ]
[ -4.286        2.14413333]]
>>> print(np.cov(x, y))
[[ 11.71        -4.286     ]
[ -4.286        2.14413333]]
>>> print(np.cov(x))
11.71
总结
理解协方差矩阵的关键就在于牢记它的计算是不同维度之间的协方差，而不是不同样本之间。拿到一个样本矩阵，最先要明确的就是一行是一个样本还是一个维度，心中明确整个计算过程就会顺流而下，这么一来就不会迷茫了。

这是今天用到的所有代码：
>>> import numpy
>>> s=[100,120,140]
>>> t=[50,60,70]
>>> y=s+t
>>> y
[100, 120, 140, 50, 60, 70]
>>> y=[s,t]
>>> y
[[100, 120, 140], [50, 60, 70]]
>>> a=numpy.cov(y)
>>> a
array([[ 400.,  200.],
[ 200.,  100.]])
>>>
>>> x=[1,0,1]
>>> y=[s,t,x]
>>>
>>> a=numpy.cov(y)
>>> a
array([[  4.00000000e+02,   2.00000000e+02,   0.00000000e+00],
[  2.00000000e+02,   1.00000000e+02,   0.00000000e+00],
[  0.00000000e+00,   0.00000000e+00,   3.33333333e-01]])
>>>
>>>
>>>

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)