精华内容
下载资源
问答
  • 2020-10-08 14:47:19

    点击跳转
    《Numpy入门系列目录》


    • numpy.cov(m, y=None, rowvar=True)

      • m: array_like,包含多个变量和观测值的1-D或2-D数组,m的每一行代表一个变量,每一列都是对所有这些变量的单一观察。
      • y: array_like, 可选,另外一组变量和观察,y具有与m相同的形状。
      • rowvar: bool, 可选,如果rowvar为True(默认值),则每行代表一个变量X,另一个行为变量Y。否则,转换关系:每列代表一个变量X,另一个列为变量Y。
    • 功能:给定数据和权重,估计协方差矩阵。返回变量的协方差矩阵

    • 例子

      import numpy as np
      A = np.array([[0, 2], [1, 1], [2, 0]]).T
      print(A)  						# [[0 1 2][2 1 0]]
      B = np.cov(A)  					# 默认行为变量计算方式,即X为行,Y也为行
      print(B)  						# [[ 1. -1.][-1.  1.]]
      C = np.cov(A, rowvar=False)     # 此时列为变量计算方式 即X为列,Y也为列
      print(C)  						# [[ 2.  0. -2.][ 0.  0.  0.][-2.  0.  2.]]
      
    更多相关内容
  • np.mean() 搬运 :https://blog.csdn.net/lilong117194/article/details/78397329?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task >>> a = np.array([[1, 2], [3...
  • np.cov np.var

    千次阅读 2018-08-28 09:30:20
    np.cov 每一行代表一个随机变量,每列代表一个样本,若样本是m,最后除以m-1 x = [1,3] y = [2,1] z = [3,1] m = array([[3, 1] [1, 3], [2, 1]]) >&...

    协方差具体实列算法
    numpy.cov(m, y=None, rowvar=1, bias=0, ddof=None)
    bias=0 若样本是m,最后除以m-1
    bias=1 若样本是m,最后除以m
    输出是协方差阵,results[i][j]表示第i个随机变量与第j个随机变量的协方差

    x = [1,3]  #x,y,z代表随机变量
    y = [2,1]
    z = [3,1]
    m = array([[1, 3],
               [2, 1]
               [3, 1]])
     >>np.cov(m)                         # cov中每一行代表一个随机变量,每列代表一个样本
     array([[ 2. , -1. , -2. ],
           [-1. ,  0.5,  1. ],
           [-2. ,  1. ,  2. ]])
    

    np.correlate(a, v, mode=’valid’, old_behavior=False)
    计算随机变量的相关系数,以无偏估计算出来的,即以cov中bias=0 算出来的
    输出结果是一个相关系数阵, results[i][j]表示第i个随机变量与第j个随机变量的相关系数.

    x = [1,3]  #x,y代表随机变量
    y = [2,1]
    >>np.cov(x,y)
    array([[ 2. , -1. ],
           [-1. ,  0.5]])
    >>np.corrcoef(x,y)
    array([[ 1., -1.],
           [-1.,  1.]])
    X = np.vstack((x,y))
    >>X
    array([[1, 3],
           [2, 1]])
    >>np.corrcoef(X)  
        array([[ 1., -1.],
           [-1.,  1.]])
    >>> x = [-2.1, -1,  4.3]
    >>> y = [3,  1.1,  0.12]
    >>> X = np.vstack((x,y))
    array([[-2.1 , -1.  ,  4.3 ],
           [ 3.  ,  1.1 ,  0.12]])
    >>np.cov(X)
    [[ 11.71        -4.286     ]
     [ -4.286        2.14413333]]
    >>np.cov(x, y)
    [[ 11.71        -4.286     ]
     [ -4.286        2.14413333]]
    >>np.cov(x)
    11.71
    

    总结:
    1 单变量 cov(x)和corrcoef(x),x以行向量存放
    2 两个随机变量 cov(x,y)和corrcoef(x,y),x,y以行向量存放
    3 n个随机变量要以行向量放在矩阵N(列表,数组等)cov(N)和corrcoef(N)
    样本方差里面要除以(n-1)而不是n
    协方差除以m-1原理和方差一样,因为方差为协方差的特殊情况
    协方差 相关系数

    方差:np.var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=)

    方差

    >>> a = np.array([[1, 2], [3, 4]]) #均值:(1+2+3+4)/4=0.25
    >>> np.var(a)                      #([1-0.25)^2+....+(4-0.25)^2]/4=1.25
    1.25
    >>> np.var(a, axis=0)              
    array([ 1.,  1.])
    >>> np.var(a, axis=1)
    array([ 0.25,  0.25])

    标准差:np.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=)

    >>> a = np.array([[1, 2], [3, 4]]) #在numpy中np.std相当于对np.var开根号
    >>> np.std(a)                      
     1.118033988749895
    >>> np.std(a, axis=0)              
    array([ 1.,  1.])
    >>> np.var(a, axis=1)
    array([0.5, 0.5])
    
    展开全文
  • 【Numpy学习记录】np.cov详解

    万次阅读 多人点赞 2018-10-12 20:27:20
    写在篇前   在概率论和统计学中,协方差用于...其定义的数学形式是:Cov(X,Y)=E[(X−E(X))(Y−E(Y))]=E[XY]−E[X]E[Y]Cov(X,Y)=E[(X-E(X))(Y-E(Y))] =E[XY]-E[X]E[Y]Cov(X,Y)=E[(X−E(X))(Y−E(Y))]=E[XY]−E[X]E[...

    写在篇前

      在概率论和统计学中,协方差用于衡量两个变量的总体误差。而方差是协方差的一种特殊情况,即当两个变量是相同的情况。其定义的数学形式是: C o v ( X , Y ) = E [ ( X − E ( X ) ) ( Y − E ( Y ) ) ] = E [ X Y ] − E [ X ] E [ Y ] Cov(X,Y)=E[(X-E(X))(Y-E(Y))] =E[XY]-E[X]E[Y] Cov(X,Y)=E[(XE(X))(YE(Y))]=E[XY]E[X]E[Y]

    协方差数学形式

    1. 公式

      c o v ( X , Y ) = ∑ i = 1 n ( X i − X ˉ ) ( Y i − Y ˉ ) n − 1 cov(X,Y) = \frac{\sum_{i=1}^n(X_i-\bar{X})(Y_i-\bar{Y})}{n-1} cov(X,Y)=n1i=1n(XiXˉ)(YiYˉ)

    2. 结果形式

    C = ( c o v ( 1 , 1 ) c o v ( 1 , 2 ) c o v ( 1 , 3 ) ⋯ c o v ( 1 , n ) c o v ( 2 , 1 ) c o v ( 2 , 2 ) c o v ( 2 , 3 ) ⋯ c o v ( 2 , n ) c o v ( 3 , 1 ) c o v ( 3 , 2 ) c o v ( 3 , 3 ) ⋯ c o v ( 3 , n ) ⋮ ⋮ ⋮ ⋱ ⋮ c o v ( n , 1 ) c o v ( n , 2 ) c o v ( n , 3 ) ⋯ c o v ( n , n ) ) C = \begin{pmatrix} \color{#F00}{cov(1,1)} & \color{#0F0}{cov(1,2)} & \color{#F0F}{cov(1,3)} & \cdots & cov(1,n) \\ \color{#0F0}{cov(2,1)} & \color{#F00}{cov(2,2)} & cov(2,3) & \cdots & cov(2,n) \\ \color{#F0F}{cov(3,1)} & cov(3,2) &\color{#F00}{cov(3,3)} & \cdots & cov(3,n) \\ \vdots & \vdots& \vdots & \ddots & \vdots \\ cov(n,1) & cov(n,2) & cov(n,3) & \cdots & \color{#F00}{cov(n,n)} \end{pmatrix} C=cov(1,1)cov(2,1)cov(3,1)cov(n,1)cov(1,2)cov(2,2)cov(3,2)cov(n,2)cov(1,3)cov(2,3)cov(3,3)cov(n,3)cov(1,n)cov(2,n)cov(3,n)cov(n,n)

    协方差代码形式

    函数原型:def cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None,aweights=None)

    • m:一维或则二维的数组,默认情况下每一行代表一个变量(属性),每一列代表一个观测
    • y:与m具有一样的形式的一组数据
    • rowvar:默认为True,此时每一行代表一个变量(属性),每一列代表一个观测;为False时,则反之
    • bias:默认为False,此时标准化时除以n-1;反之为n。其中n为观测数
    • ddof:类型是int,当其值非None时,bias参数作用将失效。当ddof=1时,将会返回无偏估计(除以n-1),即使指定了fweights和aweights参数;当ddof=0时,则返回简单平均值。
    • frequency weights:一维数组,代表每个观测要重复的次数(相当于给观测赋予权重)
    • analytic weights:一维数组,代表观测矢量权重。对于被认为“重要”的观察,这些相对权重通常很大,而对于被认为不太重要的观察,这些相对权重较小。如果ddof = 0,则可以使用权重数组将概率分配给观测向量。

    代码示例

    基本使用

    import numpy as np
    
    # 计算协方差的时候,一行代表一个特征
    # 下面计算cov(T, S, M)
    T = np.array([9, 15, 25, 14, 10, 18, 0, 16, 5, 19, 16, 20])
    S = np.array([39, 56, 93, 61, 50, 75, 32, 85, 42, 70, 66, 80])
    M = np.asarray([38, 56, 90, 63, 56, 77, 30, 80, 41, 79, 64, 88])
    X = np.vstack((T, S, M))
    # X每行代表一个属性
    #  每列代表一个示例,或者说观测
    print(np.cov(X))
    
    # [[ 47.71969697 122.9469697  129.59090909]
    #  [122.9469697  370.08333333 374.59090909]
    #  [129.59090909 374.59090909 399.        ]]
    

      重点:协方差矩阵计算的是不同维度之间的协方差,而不是不同样本之间。拿到一个样本矩阵,首先要明确的就是行代表什么,列代表什么。

    fweights

      frequency weights:一维数组,代表每个观测要重复的次数(相当于给观测赋予权重)

    T = np.array([9, 15, 25, 14, 10, 18, 0, 16, 5, 19, 16, 20])
    S = np.array([39, 56, 93, 61, 50, 75, 32, 85, 42, 70, 66, 80])
    M = np.asarray([38, 56, 90, 63, 56, 77, 30, 80, 41, 79, 64, 88])
    X = np.vstack((T, S, M))
    print(np.cov(X, None, True, False, fweights=[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]))
    # 和上面例子结果一样
    # [[ 47.71969697 122.9469697  129.59090909]
    #  [122.9469697  370.08333333 374.59090909]
    #  [129.59090909 374.59090909 399.        ]]
    
    
    T = np.array([9, 15, 25, 14, 10, 18, 0, 16, 5, 19, 16, 20])
    S = np.array([39, 56, 93, 61, 50, 75, 32, 85, 42, 70, 66, 80])
    M = np.asarray([38, 56, 90, 63, 56, 77, 30, 80, 41, 79, 64, 88])
    X = np.vstack((T, S, M))
    print(np.cov(X, None, True, False, fweights=[2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]))
    # 结果变了,就是因为相当于在X中增加了一列[9,39,38].T
    # [[ 45.6025641  121.55769231 128.43589744]
    #  [121.55769231 381.42307692 389.30769231]
    #  [128.43589744 389.30769231 415.76923077]]
    
    
    T = np.array([9, 9, 15, 25, 14, 10, 18, 0, 16, 5, 19, 16, 20])
    S = np.array([39, 39, 56, 93, 61, 50, 75, 32, 85, 42, 70, 66, 80])
    M = np.asarray([38, 38, 56, 90, 63, 56, 77, 30, 80, 41, 79, 64, 88])
    X = np.vstack((T, S, M))
    print(np.cov(X, None, True, False))
    # 这样就验证了上面的话咯~
    # [[ 45.6025641  121.55769231 128.43589744]
    #  [121.55769231 381.42307692 389.30769231]
    #  [128.43589744 389.30769231 415.76923077]]
    
    

    aweights

      很遗憾,暂时不知道它的计算方式,等有时间我仔细看看源码怎么算的,再修正!

    注意事项

    参数y
    T = np.array([9, 15, 25, 14, 10, 18, 0, 16, 5, 19, 16, 20])
    S = np.array([39, 56, 93, 61, 50, 75, 32, 85, 42, 70, 66, 80])
    M = np.asarray([38, 56, 90, 63, 56, 77, 30, 80, 41, 79, 64, 88])
    X = np.vstack((T, S, M))
    
    # 你会惊奇发现,这个结果和上面的结果一致,这就是参数 m, y,不知道为什么要设置这样一个参数,hhh
    print(np.cov(X[0:1], X[1:]))
    
    # [[ 47.71969697 122.9469697  129.59090909]
    #  [122.9469697  370.08333333 374.59090909]
    #  [129.59090909 374.59090909 399.        ]]
    
    和方差的区别
    >>> a = [1,2,3,4]  # 当a是一维向量时
    >>> import numpy as np
    >>> np.cov(a)  # 计算样本方差
    array(1.66666667)
    >>> np.var(a)  # 计算总体方差
    1.25
    
    下面是 cov(a) 和 var(a)的区别
    >>> 1.666666666666666667*3/4
    1.25
    >>>
    
    展开全文
  • 协方差矩阵详解以及numpy计算协方差矩阵(np.cov) 协方差矩阵详解 均值,标准差与方差 由简单的统计学基础知识,我们有如下公式: Xˉ=∑i=1nXin\bar X{\rm{ = }}\frac{{\sum\limits_{i = 1}^n {{X_i}} }}{{\rm{n}}}X...

    协方差矩阵详解以及numpy计算协方差矩阵(np.cov)

    协方差矩阵详解

    均值,标准差与方差

    由简单的统计学基础知识,我们有如下公式:

    X ˉ = ∑ i = 1 n X i n \bar X{\rm{ = }}\frac{{\sum\limits_{i = 1}^n {{X_i}} }}{{\rm{n}}} Xˉ=ni=1nXi

    S = ∑ i = 1 n ( X i − X ˉ ) 2 n − 1 S = \sqrt {\frac{{\sum\limits_{i = 1}^n {{{({X_i} - \bar X)}^2}} }}{{n - 1}}} S=n1i=1n(XiXˉ)2

    S 2 = ∑ i = 1 n ( X i − X ˉ ) 2 n − 1 {S^2} = \frac{{\sum\limits_{i = 1}^n {{{({X_i} - \bar X)}^2}} }}{{n - 1}} S2=n1i=1n(XiXˉ)2
    其中 X ˉ \bar X Xˉ是样本均值,反映了n个样本观测值的整体大小情况。
    S S S是样本标准差,反应的是样本的离散程度。标准差越大,数据越分散。
    S 2 S^2 S2是样本方差,是 S S S的平方。

    均值虽然可以在一定程度上反应数据的整体大小,但是仍然不能反应数据的内部离散程度。而标准差和方差弥补了这一点。

    但是标准差和方差都是针对一维数组的,即1 x d数组。该数组的行代表的是一个随机变量(可理解为属性),如工资等。每一列代表一个观测值。如果一个事物具有多种属性,即有多个随机变量,那么我们会得到一个var_num x d数组。该数组的每一行都是一个随机变量(属性),每一列代表着一个在这些属性维度上的观测值样本。如果我们想要分析该事物,那么仅仅将其剥离为单独的1 x d去求其标准差是不够的,我们还需要关注这些随机变量(属性)variable内部之间的联系。如工资和年龄的联系,工资和技术水平的联系等。

    所以便自然而然的引入了协方差。

    协方差

    两个随机变量的协方差反映了这两个随机变量一致的分散程度有多大。
    通俗的讲,协方差反映了两个随机变量的正负相关关系。
    由方差的公式,我们可以类比得出协方差的公式:

    v a r ( X ) = S 2 = ∑ i = 1 n ( X i − X ˉ ) ( X i − X ˉ ) n − 1 {\mathop{\rm var}} (X) = {S^2} = \frac{{\sum\limits_{i = 1}^n {({X_i} - \bar X)({X_i} - \bar X)} }}{{n - 1}} var(X)=S2=n1i=1n(XiXˉ)(XiXˉ)

    c o v ( X , Y ) = ∑ i = 1 n ( X i − X ˉ ) ( Y i − Y ˉ ) n − 1 = E ( ( X − E ( X ) ) ( Y − E ( Y ) ) ) {\mathop{\rm cov}} (X,Y) = \frac{{\sum\limits_{i = 1}^n {({X_i} - \bar X)({Y_i} - \bar Y)} }}{{n - 1}} = E((X - E(X))(Y - E(Y))) cov(X,Y)=n1i=1n(XiXˉ)(YiYˉ)=E((XE(X))(YE(Y)))

    相关系数 ρ \rho ρ与协方差直接有如下关系:

    ρ = C o v ( X , Y ) σ X σ Y = E ( ( X − E ( X ) ) ( Y − E ( Y ) ) ) σ X σ Y = E ( ( X − E ( X ) σ X ) ( Y − E ( Y ) σ Y ) \rho = \frac{{Cov(X,Y)}}{{{\sigma _X}{\sigma _Y}}} = \frac{{E((X - E(X))(Y - E(Y)))}}{{{\sigma _X}{\sigma _Y}}} = E((\frac{{X - E(X)}}{{{\sigma _X}}})(\frac{{Y - E(Y)}}{{{\sigma _Y}}}) ρ=σXσYCov(X,Y)=σXσYE((XE(X))(YE(Y)))=E((σXXE(X))(σYYE(Y))

    从上述公式可见,相关系数 ρ \rho ρ实际上也是一种特殊的协方差。相关系数是数据XY做了归一化 x = ( X − X ˉ ) σ X x = \frac{{(X - \bar X)}}{{{\sigma _X}}} x=σX(XXˉ), y = ( Y − Y ˉ ) σ Y y = \frac{{(Y - \bar Y)}}{{{\sigma _Y}}} y=σY(YYˉ)之后的协方差。 x , y x,y x,y的方差为1,期望为0。有:

    ρ ( X , Y ) = c o v ( x , y ) \rho(X,Y) = cov(x,y) ρ(X,Y)=cov(x,y)

    协方差的意义此时应该很清晰了。

    协方差矩阵

    对于具有很多个随机变量的数据,随机变量之间两两都具有一个协方差,这样便形成了一个协方差矩阵。
    假设我们有一组数据,其具有三个随机变量,n个观测值:
    Data

    那么其协方差矩阵为:
    Covariance

    我们可以使用一种便捷的矩阵乘法来计算协方差矩阵。设原数据数组为 X X X。先对X进行处理,求X每一个随机变量的均值。然后对于每一行,减去该行随机变量的均值,得到 X ′ X^{'} X,记协方差矩阵为 M M M,那么就有:

    M = X ′ X ′ T n − 1 M = \frac{{X^{'}{X^{'}}^{T}}}{{n-1}} M=n1XXT

    用代码描述可能更加清晰:

    a = np.array([[1,2,3],[4,5,7]])
    cov1 = np.cov(a)
    mean_a = np.mean(a,axis=1,keepdims=True)
    tmpa = a-mean_a
    cov2 = np.matmul(tmpa,tmpa.T)/(tmpa.shape[1]-1)
    print(cov1)
    print(cov2)
    

    compute

    numpy计算协方差矩阵np.cov()

    语法

    numpy.cov(m,y=None,rowvar=True,bias=False,ddof=None,fweights=None,aweights=None,dtype)
    用于计算给定矩阵和权值的协方差矩阵。

    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.

    一维或者二维数组,包含有多个随机变量和观测值。m的每一行代表一个随机变量,每一列代表包含所有随机变量的一个观测值。当给一维数组时,相当于计算的就是方差。

    • y:array_like,optional

    An additional set of variables and observations. y has the same form as that of m.

    额外的一组数据,y必须在在数据形式上与m一致。
    如果m.shape = (var_num, obs_num),那么y.shape必须在第二维观测值个数上,即shape[1]m保持一致,即y也得有obs_num个观测值。实际执行时,会先将这两组数据concatenate,然后再求解。

    Example

    a = np.array([[1,2,3],[4,5,7]])
    b = np.array([[1,2,3,4],[4,5,6,7]])
    cov = np.cov(a,b)
    

    执行结果:
    Error

    从执行结果上可见,报错。报错的具体描述便是,两组数据在dimension1不一致。
    我们也可以从numpy.cov()源码中看到:

    if y is not None:
        y = array(y, copy=False, ndmin=2, dtype=dtype)
        if not rowvar and y.shape[0] != 1:
            y = y.T
        X = np.concatenate((X, y), axis=0)
    

    可见是对其进行了concatenate.

    • 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

    默认的采用无偏估计,即除以(N-1),N是样本个数。可以被ddof所覆盖。

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

    rowvar指定了行列谁为随机变量的问题。默认为True,即行代表一个随机变量。而列代表观测值。如果为False,那么列代表随机变量,而行代表观测值。

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

    .. versionadded:: 1.5
    

    ddof,duplicated degrees of freedom,即重复无效的自由度。参见源码详解。

    • fweights : array_like, int, optional

    1-D array of integer frequency weights; the number of times each
    observation vector should be repeated.

    .. versionadded:: 1.10
    

    一维int数组,shape[0]应当与数据的观测值个数一致(即当rowvar=True时候的shape[1])。指定每个观测值的频率权重,即这个观测值向量(column)应该被重复计算几次。

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

    .. versionadded:: 1.10
    

    一维数组,其shape[0]同样的,应该与观测值个数一致。指定的是每个计算权重,即较重要的观测值其aweight大一些,不那么重要的可以小一些。当ddof为0的时候,相当于观测值的概率。

    • Return:
      • out: ndarray: The covariance matrix of the variables.

    Example

    由于不太直观,所以不举例。分析一下源码。

    源码

        if ddof is not None and ddof != int(ddof):   # 这里说明ddof必须是int类型
            raise ValueError(
                "ddof must be integer")
    
        # Handles complex arrays too
        m = np.asarray(m)       # 所以m的输入类型可以是lists, lists of tuples
                                #tuples, tuples of tuples, tuples of lists and ndarrays.
        if m.ndim > 2:          # 不能超过两维
            raise ValueError("m has more than 2 dimensions")
    
        if y is None:           # 如果y是None,返回数组类型取原数组类型
                                # 与np.float64精度高的那一个。
            dtype = np.result_type(m, np.float64)   
        else:                   # 有y输入则先处理y,判断y的维度,再判断数据类型
            y = np.asarray(y)
            if y.ndim > 2:
                raise ValueError("y has more than 2 dimensions")
            dtype = np.result_type(m, y, np.float64)
    
        X = array(m, ndmin=2, dtype=dtype)
        if not rowvar and X.shape[0] != 1:  # 如果rowvar为False就转置
            X = X.T
        if X.shape[0] == 0:
            return np.array([]).reshape(0, 0)
        if y is not None:                    # 对y进行处理
            y = array(y, copy=False, ndmin=2, dtype=dtype)
            if not rowvar and y.shape[0] != 1:  # 判断rowvar是否转置
                y = y.T
            X = np.concatenate((X, y), axis=0)  # concatenate
    
        if ddof is None:            # 如果未指定ddof
            if bias == 0:           # 如果指定了bias=0,ddof=1,无偏
                ddof = 1
            else:                   # 否则ddof=0
                ddof = 0
    
        # Get the product of frequencies and weights
        w = None
        if fweights is not None:
            fweights = np.asarray(fweights, dtype=float)
            if not np.all(fweights == np.around(fweights)):  # round进行取整
        # 取整后判断是否全部相等,来判断全都是整数,必须全是整数,否则报错
                raise TypeError(
                    "fweights must be integer")
            if fweights.ndim > 1:  # 必须一维
                raise RuntimeError(
                    "cannot handle multidimensional fweights")
            if fweights.shape[0] != X.shape[1]: # 必须与观测数一致
                raise RuntimeError(
                    "incompatible numbers of samples and fweights")
            if any(fweights < 0):   #必须全部为正值
                raise ValueError(
                    "fweights cannot be negative")
            w = fweights        # 将fweight赋给w
        if aweights is not None:
            aweights = np.asarray(aweights, dtype=float)
            if aweights.ndim > 1:
                raise RuntimeError(
                    "cannot handle multidimensional aweights")
            if aweights.shape[0] != X.shape[1]:
                raise RuntimeError(
                    "incompatible numbers of samples and aweights")
            if any(aweights < 0):
                raise ValueError(
                    "aweights cannot be negative")
            if w is None:
                w = aweights    # 如果fweight为空,就直接把aweight赋给w
            else:
                w *= aweights   # 否则w = fweight * aweight
    
        avg, w_sum = average(X, axis=1, weights=w, returned=True)
        # 以列为操作单元,求每一个随便变量的所有观测值在权重w下的均值。
        # w_sum为w的所有元素的和(权重和)。
        w_sum = w_sum[0]
    
        # Determine the normalization
        if w is None:       # 如果w为None,那么直接用X的观测值个数(列数)减ddof
            fact = X.shape[1] - ddof
        elif ddof == 0:  # w不为空,ddof等于0,需要除以的分母就是 w_sum
            fact = w_sum
        elif aweights is None: # w不为空,aweight为空,ddof不为0
        # 直接用 w_sum-ddof(因为此时的w_sum就相当于重复后的观测值个数)
            fact = w_sum - ddof
        else:   # w不为空,aweight也不为空, fweight也不为空,ddof != 0
        # fact就相当于w_sum减去以w为权重的aweight的平均值乘以ddof
        # 当aweigth=None的时候,是这个公式的一个特殊情况
        # 在这里猜测:ddof: duplicated degreeds of freedom   
        # 即重复无效的自由度
            fact = w_sum - ddof*sum(w*aweights)/w_sum
    
        if fact <= 0:
            warnings.warn("Degrees of freedom <= 0 for slice",
                          RuntimeWarning, stacklevel=3)
            fact = 0.0
    
        X -= avg[:, None]   # X减去均值
        if w is None:
            X_T = X.T
        else:
            X_T = (X*w).T   # 乘以权重 
        c = dot(X, X_T.conj())  # X 乘以 X的转置的复共轭矩阵(对标量而言就是转置)
        c *= np.true_divide(1, fact)    # 再除以fact
        return c.squeeze()  # 删去c中dim为1的维度,输出。
    

    以上就是我对np.cov()的全部解读。


    如果觉得文章对您有帮助,可以点个赞,是对作者最大的鼓励。

    展开全文
  • np.cov(x)&np.var(x)

    2020-04-16 17:36:15
    np.cov(x): 计算的是x方差的无偏估计,即s2=∑i=1n(x−x^)n−1s^2=\frac{\sum_{i=1}^{n}{(x-\hat{x}})}{n-1}s2=n−1∑i=1n​(x−x^)​ np.var(x)计算的则是s2=∑i=1n(x−x^)ns^2=\frac{\sum_{i=1}^{n}{(x-\hat{x}})}...
  • np.cov()容易忽略的地方/坑

    千次阅读 2019-07-03 21:05:41
    五个样本,每个样本二维特征 import numpy as np a = np.array([(2.5, 2.3), (1.5, 1.3), (2.2, 2.9), (2.1...用np.cov(a)得到的结果 是一个shape为(5, 5)的array array([[ 0.02 , 0.02 , -0.07 , -0.06 , -0.02 ], ...
  • 定义: 协方差表示的是两个变量的总体的 误差 ,这与只表示一个变量误差的 方差 不同。... relation=correlation(cov,vect_1_sd,vect_2_sd) print(np.corrcoef(vect_1,vect_2)) print(relation)  
  • Python numpy.cov()用法及代码示例

    千次阅读 2020-12-10 05:49:03
    协方差提供了两个变量或更多组...如果COV(xi,xj)= 0,则变量不相关如果COV(xi,xj)> 0,则变量呈正相关如果COV(xi,xj)>用法:numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, a...
  • 协方差提供了两个变量或更多组...如果COV(xi,xj)= 0,则变量不相关如果COV(xi,xj)> 0,则变量呈正相关如果COV(xi,xj)>用法:numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweight...
  • numpy.cov()和numpy.var()的用法

    万次阅读 多人点赞 2017-10-31 09:21:28
    在PCA中涉及到了方差var和协方差cov,这里简单总结下。 首先:均值,样本方差,样本协方差的公式为均值:X¯=1N∑Ni=1Xi\bar{X}=\frac{1}{N} \sum_{i=1}^{N}X_i样本方差:S=1N−1∑Ni=1(Xi−X¯)2S=\frac{1}{N-1} \...
  • print('numpy.cov()计算的协方差矩阵:\n', np.cov(samples.T)) 3.2运行结果 runfile('C:/Users/tom/covariance_matrix.py', wdir='C:/Users/tom') 样本集(10行3列,10个样例,每个样例3个特征): [[10 15 29] [15...
  • 【4】np.linalg.eig()和np.linalg.svd()区别

    千次阅读 2021-11-14 14:44:06
    【1】np.linalg.eig()函数 输入:计算奇异值和右奇异值的方阵 输出:特征值和特征向量 计算过程: (1)输入计算的矩阵;(2)矩阵每个维度减去均值; (3)计算矩阵的协方差矩阵;(4)eig分解 参考代码: ...
  • numpy.cov() 计算协方差矩阵

    千次阅读 2020-11-28 13:08:49
    在PCA中会用到,记录一下numpy.cov()的作用是计算协方差矩阵,下面给出几个例子>>> x = np.array([[0, 2], [1, 1], [2, 0]]).T>>> xarray([[0, 1, 2],[2, 1, 0]])>>> np.cov(x)array([[ 1., -1.],[-1., 1.]])>>> x =...
  • 1.命令numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None)2.参数Parameters ---------- m : 一维或2维数组,每行代表一个特征,每列代表一个样本  y : 数组,可选 额外...
  • numpy.cov()求协方差矩阵

    万次阅读 2017-09-05 10:23:13
    numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None) 对给定的数据和权重,估计协方差矩阵 协方差表示两个变量在一起变化的水平。如果我们检查N维样本,则X = [x_1,x...
  • numpy.cov以及corrcoef

    千次阅读 2017-02-15 11:01:55
    Cov(X,Y)=E[(X-E(X))(Y-E(Y))] #Estimate a covariance matrix, given data and weights. 给定数据和权重,求解协方差矩阵# Covariance indicates the level to which two variables vary together. If ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,839
精华内容 3,935
关键字:

np.cov()