numpy.nanpercentile
原文:
numpy.org/doc/1.26/reference/generated/numpy.nanpercentile.html
numpy.nanpercentile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=<no value>, *, interpolation=None)
计算指定轴上的数据的第 q 个百分位数,同时忽略 nan 值。
返回数组元素的第 q 个百分位数。
版本 1.9.0 中的新功能。
参数:
aarray_like
输入数组或可以转换为数组的对象,其中包含要忽略的 nan 值。
qarray_like of float
要计算的百分位数或百分位数序列,必须在 0 和 100 之间(包括 0 和 100)。
axis{int, tuple of int, None},可选
计算百分位数的轴或轴。默认值是沿数组的平坦版本计算百分位数。
outndarray, 可选
替代的输出数组,用于放置结果。它必须具有与预期输出相同的形状和缓冲区长度,但如果需要,输出的类型将被强制转换。
overwrite_inputbool,可选
如果为 True,则允许对中间计算修改输入数组a,以节省内存。在这种情况下,此函数完成后输入a的内容未定义。
methodstr,可选
此参数指定用于估计百分位数的方法。有许多不同的方法,一些是 NumPy 特有的。请参阅注释以了解解释。按照 H&F 论文[1]中总结的它们的 R 类型排序的选项是:
前三种方法是不连续的。NumPy 进一步对默认的‘linear’(7.)选项定义了以下不连续的变体:
从版本 1.22.0 开始更改:此参数以前称为“interpolation”,并且仅提供了“linear”默认值和最后四个选项。
keepdimsbool,可选
如果设置为 True,则减少的轴将作为尺寸为 1 的维度保留在结果中。使用此选项,结果将正确广播到原始数组a。
如果这不是默认值,它将被传递(在特殊情况下是空数组)到底层数组的mean
函数中。如果数组是子类,并且mean
没有 kwarg keepdims,这将引发 RuntimeError。
interpolationstr,可选
方法关键字参数的不推荐名称。
自版本 1.22.0 起不推荐使用。
返回:
percentilescalar or ndarray
如果q是一个单一的百分位数,axis=None,那么结果是一个标量。如果给定了多个百分位数,结果的第一个轴对应于百分位数。其他轴是* a * 减少后保留的轴。如果输入包含小于float64
的整数或浮点数,则输出数据类型是float64
。否则,输出数据类型与输入的相同。如果指定了out,则返回该数组。
另请参阅
nanmean
nanmedian
相当于nanpercentile(..., 50)
percentile
, median
, mean
nanquantile
相当于 nanpercentile,除了 q 的范围是[0, 1]。
注意
更多信息请参见numpy.percentile
参考资料
[1]
R. J. Hyndman 和 Y. Fan,“统计软件包中的样本分位数”,《美国统计学家》,第 50 卷,第 361-365 页,1996 年
示例
>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
>>> a[0][1] = np.nan
>>> a
array([[10., nan, 4.],
[ 3., 2., 1.]])
>>> np.percentile(a, 50)
nan
>>> np.nanpercentile(a, 50)
3.0
>>> np.nanpercentile(a, 50, axis=0)
array([6.5, 2\. , 2.5])
>>> np.nanpercentile(a, 50, axis=1, keepdims=True)
array([[7.],
[2.]])
>>> m = np.nanpercentile(a, 50, axis=0)
>>> out = np.zeros_like(m)
>>> np.nanpercentile(a, 50, axis=0, out=out)
array([6.5, 2\. , 2.5])
>>> m
array([6.5, 2\. , 2.5])
>>> b = a.copy()
>>> np.nanpercentile(b, 50, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)
numpy.quantile
原文:
numpy.org/doc/1.26/reference/generated/numpy.quantile.html
numpy.quantile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=False, *, interpolation=None)
计算沿指定轴的数据的 q-th 分位数。
版本 1.15.0 中的新内容。
参数:
a实数 array_like
输入数组或可转换为数组的对象。
qfloat array_like
用于计算分位数的概率或分位数序列。值必须在 0 到 1 之间(包括 0 和 1)。
axis{int,int 元组,None},可选
计算分位数的轴或轴。默认是沿数组的扁平版本计算分位数。
输出ndarray,可选
替代的输出数组,其中放置结果。它必须具有与预期输出相同的形状和缓冲区长度,但如果需要,输出的类型(输出)将被转换。
overwrite_inputbool,可选
如果为 True,则允许对中间计算修改输入数组a,以节省内存。在这种情况下,此函数完成后输入a的内容是不确定的。
methodstr,可选
此参数指定用于估算分位数的方法。有许多不同的方法,其中一些是 NumPy 独有的。请参见注释以了解解释。按照它们在 H&F 论文[1]中总结的 R 类型的排序,选项分为:
前三种方法是不连续的。NumPy 还进一步定义了默认的‘linear’(7)选项的以下不连续变体:
在版本 1.22.0 中更改:此参数以前称为“interpolation”,并且仅提供了“linear”默认值和最后四个选项。
keepdimsbool,可选
如果设置为 True,则减少的轴将保留在结果中,作为尺寸为一的维度。选择此选项,结果将正确地针对原始数组a进行广播。
插值str,可选
方法关键字参数的不推荐名称。
从版本 1.22.0 开始不推荐使用。
返回:
分位数标量或 ndarray
如果q是单个概率且axis=None,则结果是标量。如果给定了多个概率水平,则结果的第一个轴对应于分位数。其他轴是对a减少后保留的轴。如果输入包含小于float64
的整数或浮点数,则输出数据类型为float64
。否则,输出数据类型与输入的相同。如果指定了out,则返回该数组。
另请参阅
mean
百分位数
等效于 quantile,但 q 在范围[0,100]内。
中位数
等效于quantile(..., 0.5)
nanquantile
注意事项
给定长度为 n
的向量 V
,V
的第 q
个分位数是在 V
的排序副本中从最小值到最大值的 q
处的值。如果归一化排名与 q
的位置不完全匹配,则两个最近邻居的值和距离以及 method 参数将确定分位数。如果 q=0.5
,则此函数与中位数相同;如果 q=0.0
,则与最小值相同;如果 q=1.0
,则与最大值相同。
可选的 method 参数指定当所需分位数位于两个索引 i
和 j = i + 1
之间时要使用的方法。在这种情况下,我们首先确定 i + g
,即位于 i
和 j
之间的虚拟索引,其中 i
是地板,g
是索引的小数部分。然后,最终结果是根据 g
对 a[i]
和 a[j]
进行插值。在计算 g
时,使用修正常数 alpha
和 beta
修改 i
和 j
,其选择取决于所使用的 method
。最后,请注意,由于 Python 使用基于 0 的索引,因此代码在内部从索引中再减去另外 1。
以下公式确定了排序样本中分位数的虚拟索引 i + g
的位置:
[i + g = q * ( n - alpha - beta + 1 ) + alpha]
然后,不同的方法工作如下:
倒数累积分布:
H&F 方法 1 [1]。此方法提供不连续的结果:
平均倒数累积分布:
H&F 方法 2 [1]。此方法提供不连续的结果:
最近观察值:
H&F 方法 3 [1]。此方法提供不连续的结果:
插值倒数累积分布:
H&F 方法 4 [1]。此方法使用连续结果:
哈兹恩:
H&F 方法 5 [1]。此方法使用连续结果:
威布尔:
H&F 方法 6 [1]。此方法使用连续结果:
线性:
H&F 方法 7 [1]。此方法使用连续结果:
中位数无偏:
H&F 方法 8 [1]。如果样本分布函数未知,则此方法可能是最佳方法(参见参考资料)。此方法使用连续结果:
正态无偏:
H&F 方法 9 [1]。如果已知样本分布函数为正态分布,则此方法可能是最佳方法。此方法使用连续结果:
低值:
NumPy 方法保留以确保向后兼容性。以 i
为插值点。
更高:
NumPy 方法保留以确保向后兼容性。以 j
为插值点。
最近的:
NumPy 方法保留以供向后兼容。取i
或j
,以最近的一个为准。
中点:
NumPy 方法保留以供向后兼容。使用(i + j) / 2
。
参考
[1] (1,2,3,4,5,6,7,8,9,10)
R. J. Hyndman 和 Y. Fan,“统计软件包中的样本分位数”,美国统计学家, 50(4), 第 361-365 页, 1996
例子
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10, 7, 4],
[ 3, 2, 1]])
>>> np.quantile(a, 0.5)
3.5
>>> np.quantile(a, 0.5, axis=0)
array([6.5, 4.5, 2.5])
>>> np.quantile(a, 0.5, axis=1)
array([7., 2.])
>>> np.quantile(a, 0.5, axis=1, keepdims=True)
array([[7.],
[2.]])
>>> m = np.quantile(a, 0.5, axis=0)
>>> out = np.zeros_like(m)
>>> np.quantile(a, 0.5, axis=0, out=out)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5])
>>> b = a.copy()
>>> np.quantile(b, 0.5, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a == b)
另请参阅numpy.percentile
以获取大多数方法的可视化。
numpy.nanquantile
原文:
numpy.org/doc/1.26/reference/generated/numpy.nanquantile.html
numpy.nanquantile(a, q, axis=None, out=None, overwrite_input=False, method='linear', keepdims=<no value>, *, interpolation=None)
在忽略 nan 值的情况下计算指定轴上的第 q 分位数。返回数组元素的 q 分位数。
1.15.0 版中新增。
参数:
aarray_like
输入数组或可以转换为数组的对象,其中包含要忽略的 nan 值
qfloat 的 array_like
概率或用于计算分位数的概率序列。值必须在 0 和 1 之间(包括 0 和 1)。
轴{int, int 的 tuple, None}, 可选参数
计算分位数的轴或轴。默认值是在数组的扁平化版本上计算分位数。
outndarray,可选参数
替代输出数组,用于存放结果。它必须具有与预期输出相同的形状和缓冲区长度,但如果需要,输出的类型将会转换。
overwrite_input布尔值,可选参数
如果为 True,则允许修改中间计算的输入数组a,以节省内存。在这种情况下,此函数完成后输入 a 的内容是未定义的。
method字符串,可选参数
该参数指定用于估计分位数的方法。有许多不同的方法,其中一些是 NumPy 特有的。请参见注释以获取解释。根据它们在 H&F 论文中总结的 R 类型,选项如下[1]:
前三种方法是不连续的。NumPy 进一步定义了默认的‘linear’(7.)选项的以下不连续变化:
自 1.22.0 版本更改:该参数以前称为“interpolation”,并且只提供“linear”默认值和最后四个选项。
keepdims布尔值,可选参数
如果设置为 True,那么被减少的轴将作为大小为一的维度保留在结果中。使用此选项,结果将正确地对原始数组a进行广播。
如果这不是默认值,那么它将通过(在空数组的特殊情况下)传递给底层数组的mean
函数。如果数组是子类,而mean
没有 kwarg keepdims,则会引发运行时错误。
interpolation字符串,可选参数
方法关键字参数的已弃用名称。
自 1.22.0 版起已弃用。
返回值:
quantile标量或 ndarray
如果q是单个概率且axis=None,则结果是标量。如果给定多个概率水平,则结果的第一个轴对应于分位数。其他轶轴是在a减少后保留的轴。如果输入包含小于float64
的整数或浮点数,则输出数据类型为float64
。否则,输出数据类型与输入相同。如果指定了out,则返回该数组。
另请参阅
quantile
nanmean
,nanmedian
nanmedian
等同于nanquantile(..., 0.5)
nanpercentile
与 nanquantile 相同,但 q 在范围[0, 100]内。
注意事项
有关更多信息,请参
参考文献
[1]
R. J. Hyndman 和 Y. Fan,“统计软件包中的样本分位数”,《美国统计学家》,50(4),pp. 361-365,1996
例子
>>> a = np.array([[10., 7., 4.], [3., 2., 1.]])
>>> a[0][1] = np.nan
>>> a
array([[10., nan, 4.],
[ 3., 2., 1.]])
>>> np.quantile(a, 0.5)
nan
>>> np.nanquantile(a, 0.5)
3.0
>>> np.nanquantile(a, 0.5, axis=0)
array([6.5, 2\. , 2.5])
>>> np.nanquantile(a, 0.5, axis=1, keepdims=True)
array([[7.],
[2.]])
>>> m = np.nanquantile(a, 0.5, axis=0)
>>> out = np.zeros_like(m)
>>> np.nanquantile(a, 0.5, axis=0, out=out)
array([6.5, 2\. , 2.5])
>>> m
array([6.5, 2\. , 2.5])
>>> b = a.copy()
>>> np.nanquantile(b, 0.5, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)
numpy.median
numpy.median(a, axis=None, out=None, overwrite_input=False, keepdims=False)
计算沿指定轴的中位数。
返回数组元素的中位数。
参数:
a array_like
输入数组或可转换为数组的对象。
axis{int, int 序列, None}, 可选
计算中位数的轴或轴。默认值是计算数组的扁平版本沿中位数。自版本 1.9.0 以来支持轴序列。
out ndarray,可选
替代输出数组,其中放置结果。它必须具有与预期输出相同的形状和缓冲区长度,但必要时将转换(输出)的类型。
overwrite_inputbool, 可选
如果为 True,则允许使用输入数组a的内存进行计算。该调用对输入数组进行修改。当不需要保留输入数组的内容时,这将节省内存。将输入视为未定义,但可能完全或部分排序。默认值为 False。如果overwrite_input为True
且a还不是ndarray
,则会引发错误。
keepdimsbool, 可选
如果设置为 True,则减少的轴将作为具有大小为一的维度留在结果中。使用此选项,结果将针对原始arr进行正确的广播。
新版本 1.9.0。
返回:
median ndarray
存储结果的新数组。如果输入包含小于float64
的整数或浮点数,则输出数据类型为np.float64
。否则,输出的数据类型与输入的相同。如果指定了out,则返回该数组。
另请参阅
mean
,percentile
注意
给定长度为N
的向量V
,V
的中位数是排序副本V_sorted
的中间值 - 即 V_sorted[(N-1)/2]
,当N
为奇数时,以及V_sorted
的两个中间值的平均值,当N
为偶数时。
示例
>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> a
array([[10, 7, 4],
[ 3, 2, 1]])
>>> np.median(a)
3.5
>>> np.median(a, axis=0)
array([6.5, 4.5, 2.5])
>>> np.median(a, axis=1)
array([7., 2.])
>>> m = np.median(a, axis=0)
>>> out = np.zeros_like(m)
>>> np.median(a, axis=0, out=m)
array([6.5, 4.5, 2.5])
>>> m
array([6.5, 4.5, 2.5])
>>> b = a.copy()
>>> np.median(b, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)
>>> b = a.copy()
>>> np.median(b, axis=None, overwrite_input=True)
3.5
>>> assert not np.all(a==b)
numpy.average
原文:
numpy.org/doc/1.26/reference/generated/numpy.average.html
numpy.average(a, axis=None, weights=None, returned=False, *, keepdims=<no value>)
计算沿指定轴的加权平均值。
参数:
aarray_like
包含要平均的数据的数组。如果a不是数组,则会尝试转换。
axisNone 或 int 或 int 元组,可选
沿着其进行平均值计算的轴或轴。默认情况下,axis=None 将对输入数组的所有元素进行平均值计算。如果 axis 为负数,则从最后一个轴到第一个轴计数。
新功能在版本 1.7.0 中。
如果轴是整数元组,则对元组中指定的所有轴执行平均值计算,而不是以前的单个轴或所有轴。
weightsarray_like,可选
与a中的值相关联的权重数组。a中的每个值根据其关联的权重对平均值做出贡献。权重数组可以是 1-D(在这种情况下,其长度必须是给定轴上a的大小)或与a相同形状。如果weights=None,则假定a中的所有数据的权重都等于 1。1-D 计算如下:
avg = sum(a * weights) / sum(weights)
权重的唯一约束是*sum(weights)*不能为 0。
returnedbool,可选
默认值为False。如果True,则返回元组(average
,sum_of_weights),否则仅返回平均值。如果weights=None,sum_of_weights等于计算平均值的元素数量。
keepdimsbool,可选
如果设置为 True,则被减少的轴将作为尺寸为 1 的维度保留在结果中。使用此选项,结果将正确广播到原始a。注意: keepdims不适用于numpy.matrix
或其他不支持keepdims方法的类的实例。
新功能在版本 1.23.0 中。
返回:
**retval,[sum_of_weights]**array_type 或 double
沿指定轴计算平均值。当returned为True时,返回一个元组,第一个元素是平均值,第二个元素是权重的总和。sum_of_weights与retval的类型相同。结果 dtype 遵循一般模式。如果weights为 None,则结果 dtype 将是a的 dtype,或者如果a是整数,则为float64
。否则,如果weights不为 None 且a不是整数,则结果类型将是能够表示a和weights值的最低精度类型。如果a恰好是整数,则仍然适用先前的规则,但结果 dtype 至少为float64
。
引发:
零除错误
当沿轴的所有权重都为零时。查看numpy.ma.average
以获得对此类型错误鲁棒的版本。
类型错误
当 1D weights的长度与沿轴的a的形状不同时。
另请参阅
mean
ma.average
用于掩码数组的平均值 - 如果您的数据包含“缺失”值,则非常有用
numpy.result_type
返回应用 numpy 类型提升规则到参数后的类型。
示例
>>> data = np.arange(1, 5)
>>> data
array([1, 2, 3, 4])
>>> np.average(data)
2.5
>>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
4.0
>>> data = np.arange(6).reshape((3, 2))
>>> data
array([[0, 1],
[2, 3],
[4, 5]])
>>> np.average(data, axis=1, weights=[1./4, 3./4])
array([0.75, 2.75, 4.75])
>>> np.average(data, weights=[1./4, 3./4])
Traceback (most recent call last):
...
TypeError: Axis must be specified when shapes of a and weights differ.
>>> a = np.ones(5, dtype=np.float128)
>>> w = np.ones(5, dtype=np.complex64)
>>> avg = np.average(a, weights=w)
>>> print(avg.dtype)
complex256
运用keepdims=True
,以下结果的形状为(3, 1)。
>>> np.average(data, axis=1, keepdims=True)
array([[0.5],
[2.5],
[4.5]])
numpy.mean
numpy.mean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)
沿指定轴计算算术平均值。
返回数组元素的平均值。默认情况下,平均值是在扁平化数组上计算的,否则在指定的轴上计算。对于整数输入,中间和返回值使用float64
。
参数:
aarray_like
包含所需平均值的数字的数组。如果a不是数组,则会尝试进行转换。
axisNone 或 int 或 int 元组, 可选
计算平均值的轴。默认情况下,计算扁平数组的平均值。
1.7.0 版本中的新内容。
如果这是一个 int 元组,则将在多个轴上执行平均值,而不是以前的单个轴或所有轴的平均值。
dtype数据类型, 可选
用于计算平均值的类型。对于整数输入,默认值为float64
;对于浮点输入,它与输入 dtype 相同。
outndarray, 可选
备选输出数组,用于放置结果。默认值为None
;如果提供,则必须具有与预期输出相同的形状,但必要时将进行类型转换。详情请参阅输出类型确定。
keepdimsbool, 可选
如果设置为 True,则被减少的轴将作为大小为 1 的维度保留在结果中。使用此选项,结果将正确地广播到输入数组。
如果传递了默认值,则keepdims将不会传递给mean
方法的子类,但任何非默认值都将传递。如果子类方法不实现keepdims,则会引发任何异常。
wherearray_like of bool, 可选
要包括在均值中的元素。详情请参阅reduce
。
1.20.0 版本中的新内容。
返回:
mndarray,参见上面的 dtype 参数
如果out=None,返回一个包含平均值的新数组,否则返回对输出数组的引用。
另请参阅
average
加权平均
std
, var
, nanmean
, nanstd
, nanvar
注意
算术平均值是沿着轴的元素之和除以元素个数。
请注意,对于浮点输入,均值是使用与输入相同的精度计算的。根据输入数据,这可能导致结果不准确,特别是对于float32
(见下面的示例)。使用dtype
关键字指定更高精度的累加器可以缓解这个问题。
默认情况下,float16
的结果是用float32
作为中间值计算,以获得额外的精度。
示例
>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([2., 3.])
>>> np.mean(a, axis=1)
array([1.5, 3.5])
在单精度下,mean
可能不准确:
>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.mean(a)
0.54999924
用float64
计算均值更精确:
>>> np.mean(a, dtype=np.float64)
0.55000000074505806 # may vary
指定一个where
参数:
>>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])
>>> np.mean(a)
12.0
>>> np.mean(a, where=[[True], [False], [False]])
9.0
numpy.std
numpy.std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>)
沿指定轴计算标准差。
返回数组元素的标准差,这是对分布的扩展度的一种测量。默认情况下,通过压平的数组计算标准差,或者可以沿指定轴进行计算。
参数:
a类似数组
计算这些值的标准差。
axisNone 或 int 或 int 的元组,可选
计算标准差的轴或轴。默认值是计算压平数组的标准差。
自 1.7.0 版本新增。
如果传入的是 int 的元组,则会在多个轴上执行标准差计算,而不是之前的单个轴或所有轴的计算。
dtypedtype,可选
用于计算标准差的类型。对于整数类型的数组,默认值是 float64,对于浮点类型的数组,它与数组类型相同。
outndarray,可选
替代输出数组,用于放置结果。它必须具有与期望输出相同的形状,但如果需要,将会对计算的值进行类型强制转换。
ddofint,可选
自由度差异。计算中使用的除数是N - ddof
,其中N
代表元素的数量。默认情况下,ddof为零。
keepdimsbool,可选
如果设置为 True,则被减少的轴会留在结果中作为大小为 1 的维度。使用此选项,结果将正确地广播到输入数组。
如果传入的是默认值,那么keepdims将不会传递给 std
的子类的方法,然而任何非默认值都会。如果子类的方法没有实现keepdims,则会引发任何异常。
wherebool 值的数组或类似数组,可选
包括在标准差中的元素。有关详细信息,请参见 reduce
。
自 1.20.0 版本新增。
返回:
standard_deviationndarray,参见上面的 dtype 参数。
如果out为空,则返回一个包含标准差的新数组,否则返回对输出数组的引用。
参见
var
, mean
, nanmean
, nanstd
, nanvar
输出类型确定
注释
标准差是平均平方离差的平方根,即std = sqrt(mean(x))
,其中x = abs(a - a.mean())**2
。
平均平方偏差通常被计算为 x.sum() / N
,其中 N = len(x)
。然而,如果指定了 ddof,则会使用除数 N - ddof
。在标准统计实践中,ddof=1
提供了无偏估计的方差,适用于无限总体。ddof=0
提供了正态分布变量方差的最大似然估计。该函数计算的标准偏差是估计方差的平方根,因此即使使用 ddof=1
,它也不会是标准偏差的无偏估计。
请注意,对于复数,std
在平方之前取绝对值,因此结果总是实数且非负。
对于浮点输入,std 是使用与输入相同的精度来计算的。根据输入数据的不同,这可能导致结果不准确,特别是对于 float32(见下面的例子)。使用 dtype
关键字指定更高精度的累加器可以缓解这个问题。
例子
>>> a = np.array([[1, 2], [3, 4]])
>>> np.std(a)
1.1180339887498949 # may vary
>>> np.std(a, axis=0)
array([1., 1.])
>>> np.std(a, axis=1)
array([0.5, 0.5])
在单精度中,std() 可能不准确:
>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.std(a)
0.45000005
在 float64 中计算标准偏差更精确:
>>> np.std(a, dtype=np.float64)
0.44999999925494177 # may vary
指定一个 where 参数:
>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.std(a)
2.614064523559687 # may vary
>>> np.std(a, where=[[True], [True], [False]])
2.0
numpy.var
numpy.var(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>)
沿指定轴计算方差。
返回数组元素的方差,是分布扩散的一种度量。默认情况下,计算扁平化数组的方差,否则计算沿指定轴的方差。
参数:
a 像数组
包含要求方差的数字的数组。如果a不是数组,则会尝试转换。
axisNone 或整数或整数元组,可选
计算方差的轴或轴。默认是计算扁平化数组的方差。
版本 1.7.0 中的新功能。
如果这是一个整数元组,将在多个轴上执行方差,而不是以前的单个轴或所有轴。
dtype数据类型,可选
用于计算方差的类型。对于整数型数组,默认值为float64
;对于浮点类型数组,它与数组类型相同。
out ndarray,可选
替代输出数组,其中放置结果。它必须具有与预期输出相同的形状,但必要时会进行类型转换。
ddof 整数,可选
“自由度差”: 计算中使用的除数为N - ddof
,其中N
表示元素数量。 默认情况下,ddof为零。
keepdims 布尔值,可选
如果设置为 True,那么被减少的轴会作为大小为一的维度保留在结果中。使用此选项,结果将正确地广播到输入数组。
如果传递了默认值,则keepdims将不会传递给var
方法的ndarray
子类中,但任何非默认值将会传递。如果子类的方法没有实现keepdims,则会引发任何异常。
where 布尔值数组,可选
包括在方差中的元素。有关详细信息,请参见reduce
。
版本 1.20.0 中的新功能。
返回:
方差 ndarray,参见上面的 dtype 参数
如果out=None
,则返回一个包含方差的新数组;否则,返回对输出数组的引用。
另请参见
std
,mean
,nanmean
,nanstd
,nanvar
输出类型确定
注意
方差是平均偏离均值的平方,即var = mean(x)
,其中x = abs(a - a.mean())**2
。
均值通常计算为 x.sum() / N
,其中 N = len(x)
。然而,如果指定了 ddof,则会使用除数 N - ddof
。在标准统计实践中,ddof=1
提供了对假设无限总体方差的无偏估计。ddof=0
对于正态分布的变量提供了方差的最大似然估计。
注意,在处理复数时,先取绝对值再进行平方,以确保结果始终为实数且非负。
对于浮点输入,方差的计算与输入数据的精度相同。根据输入数据的不同,这可能导致结果不准确,尤其是对于 float32
(请参见下面的示例)。使用 dtype
关键字指定更高精度的累加器可以缓解问题。
示例
>>> a = np.array([[1, 2], [3, 4]])
>>> np.var(a)
1.25
>>> np.var(a, axis=0)
array([1., 1.])
>>> np.var(a, axis=1)
array([0.25, 0.25])
在单精度下,var() 可能不准确:
>>> a = np.zeros((2, 512*512), dtype=np.float32)
>>> a[0, :] = 1.0
>>> a[1, :] = 0.1
>>> np.var(a)
0.20250003
使用 float64 计算方差更准确:
>>> np.var(a, dtype=np.float64)
0.20249999932944759 # may vary
>>> ((1-0.55)**2 + (0.1-0.55)**2)/2
0.2025
指定 where 参数:
>>> a = np.array([[14, 8, 11, 10], [7, 9, 10, 11], [10, 15, 5, 10]])
>>> np.var(a)
6.833333333333333 # may vary
>>> np.var(a, where=[[True], [True], [False]])
4.0
numpy.nanmedian
原文:
numpy.org/doc/1.26/reference/generated/numpy.nanmedian.html
numpy.nanmedian(a, axis=None, out=None, overwrite_input=False, keepdims=<no value>)
沿指定轴计算中位数,同时忽略 NaN。
返回数组元素的中位数。
自版本 1.9.0 新增。
参数:
aarray_like
输入数组或可转换为数组的对象。
axis{int, sequence of int, None}, optional
计算中位数的轴或轴。默认是沿数组的扁平版本计算中位数。自版本 1.9.0 开始支持一系列轴。
outndarray, optional
用于放置结果的备用输出数组。它必须具有与预期输出相同的形状和缓冲区长度,但根据需要将被转换为输出的类型。
overwrite_inputbool, optional
如果为 True,则允许使用输入数组a的内存进行计算。调用median
将修改输入数组。当您不需要保留输入数组的内容时,这将节省内存。将输入视为未定义,但可能已全部或部分排序。默认值为 False。如果overwrite_input为True
,且a不是已经是ndarray
,则会引发错误。
keepdimsbool, optional
如果设置为 True,则减少的轴将作为大小为 1 的维度保留在结果中。使用此选项,结果将对原始a正确广播。
如果这不是默认值,将通过(在空数组的特殊情况下)传递给基础数组的mean
函数。如果数组是子类,且mean
没有 kwarg keepdims,这将引发 RuntimeError。
返回:
medianndarray
持有结果的新数组。如果输入包含小于float64
的整数或浮点数,则输出数据类型为np.float64
。否则,输出的数据类型与输入的数据类型相同。如果指定了out,则返回该数组。
另请参见
mean
, median
, percentile
注意
给定长度为N
的向量V
,V
的中位数是排序副本V_sorted
的中间值,即V_sorted[(N-1)/2]
,当N
为奇数时,V_sorted
的两个中间值的平均值,当N
为偶数时。
示例
>>> a = np.array([[10.0, 7, 4], [3, 2, 1]])
>>> a[0, 1] = np.nan
>>> a
array([[10., nan, 4.],
[ 3., 2., 1.]])
>>> np.median(a)
nan
>>> np.nanmedian(a)
3.0
>>> np.nanmedian(a, axis=0)
array([6.5, 2\. , 2.5])
>>> np.median(a, axis=1)
array([nan, 2.])
>>> b = a.copy()
>>> np.nanmedian(b, axis=1, overwrite_input=True)
array([7., 2.])
>>> assert not np.all(a==b)
>>> b = a.copy()
>>> np.nanmedian(b, axis=None, overwrite_input=True)
3.0
>>> assert not np.all(a==b)
numpy.nanmean
原文:
numpy.org/doc/1.26/reference/generated/numpy.nanmean.html
numpy.nanmean(a, axis=None, dtype=None, out=None, keepdims=<no value>, *, where=<no value>)
沿指定轴计算算术平均值,忽略 NaN。
返回数组元素的平均值。默认情况下,通过平坦数组进行平均,否则通过指定的轴进行平均。对于整数输入,默认情况下使用float64
中间和返回值。
对于所有-NaN 切片,返回 NaN 并引发RuntimeWarning。
版本 1.8.0 中的新功能。
参数:
aarray_like
包含所需平均值的数字的数组。如果a不是数组,则会尝试转换。
axis{int, tuple of int, None},可选
计算平均值的轴或轴。默认值是计算平均值的扁平数组。
dtype数据类型,可选
用于计算平均值的类型。对于整数输入,默认值为float64
;对于非精确输入,与输入 dtype 相同。
outndarray,可选
交替的输出数组,其中放置结果。默认值为None
;如果提供,它必须具有与预期输出相同的形状,但如果需要,类型将被转换。有关更多详细信息,请参见输出类型确定。
keepdimsbool, optional
如果设置为 True,则被减少的轴会作为尺寸为一的维度留在结果中。使用此选项,结果将正确地广播对原始a。
如果值不是默认值,则keepdims将通过传递给mean
或sum
的子类的方法。如果子类方法未实现keepdims,则将引发任何异常。
wherebool 类型数组,可选
包含在均值中的元素。有关详细信息,请参阅reduce
。
版本 1.22.0 中的新功能。
返回:
mndarray,见上面的 dtype 参数
如果out=None,返回包含平均值的新数组,否则返回对输出数组的引用。对于只包含 NaN 的切片,返回 NaN。
另见
average
加权平均
mean
不忽略 NaN 的算术平均值
var
, nanvar
注意
算术平均值是沿轴向的非 NaN 元素的总和除以非 NaN 元素的数量。
请注意,对于浮点数输入,均值是使用输入数据的相同精度计算的。根据输入数据的不同,这可能会导致结果不准确,特别是对于float32
。使用dtype
关键字指定更高精度的累加器可以缓解这个问题。
例子
>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanmean(a)
2.6666666666666665
>>> np.nanmean(a, axis=0)
array([2., 4.])
>>> np.nanmean(a, axis=1)
array([1., 3.5]) # may vary
numpy.nanstd
numpy.nanstd(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>)
计算沿指定轴的标准差,同时忽略 NaN。
返回非 NaN 数组元素的标准差,即分布的展开度量,默认情况下计算平均值的标准差,否则计算指定轴上的标准差。
对于所有包含全为 NaN 或自由度为零的切片,都会返回 NaN 并引发RuntimeWarning。
新版本 1.8.0 中更新。
参数:
aarray_like
计算非 NaN 值的标准差。
axis{int, tuple of int, None},可选
计算标准差的轴或轴。默认值是计算扁平化数组的标准差。
dtypedtype,可选
用于计算标准差的类型。对于整数类型的数组,默认值是 float64,对于浮点类型的数组,它与数组类型相同。
outndarray,可选
替代输出数组,其中存放结果。它必须具有与预期输出相同的形状,但如有必要,计算值的类型(类型)将被转换。
ddofint,可选
表示自由度的度。计算中使用的除数是N - ddof
,其中N
表示非 NaN 元素的数量。默认情况下ddof为零。
keepdimsbool,可选
如果设置为 True,则将被减少的轴保留为大小为一的维度。使用此选项,结果将正确广播到原始a。
如果此值不是默认值,则将其原样传递给子类的相关函数。如果这些函数没有keepdims kwarg,则会引发运行时错误。
wherearray_like of bool,可选
要包括在标准差中的元素。有关详细信息,请参见reduce
。
新版本 1.22.0 中更新。
返回:
standard_deviationndarray,参见上述 dtype 参数。
如果out为 None,则返回一个包含标准差的新数组,否则返回对输出数组的引用。如果 ddof 大于等于切片中的非 NaN 元素数量或切片只包含 NaN,则该切片的结果为 NaN。
另请参阅
var
,mean
,std
nanvar
,nanmean
输出类型确定
注意
标准差是平均值与平方偏差的平均值的平方根:std = sqrt(mean(abs(x - x.mean())**2))
。
平均平方偏差通常计算为x.sum() / N
,其中N = len(x)
。然而,如果指定了ddof,那么除数将改为使用N - ddof
。在标准统计实践中,ddof=1
提供了无偏估计的无限总体方差。ddof=0
提供了正态分布变量方差的最大似然估计。此函数计算的标准差是估计方差的平方根,所以即使ddof=1
,它也不会是标准偏差的无偏估计。
请注意,对于复数,std
在平方前取绝对值,以使结果始终是实数且非负数。
对于浮点输入,std 是使用输入精度计算的。根据输入数据,这可能导致结果不准确,特别是对于 float32(参见下面的示例)。使用dtype
关键字指定更高精度的累加器可以缓解这个问题。
示例
>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanstd(a)
1.247219128924647
>>> np.nanstd(a, axis=0)
array([1., 0.])
>>> np.nanstd(a, axis=1)
array([0., 0.5]) # may vary
numpy.nanvar
numpy.nanvar(a, axis=None, dtype=None, out=None, ddof=0, keepdims=<no value>, *, where=<no value>)
沿着指定轴计算方差,同时忽略 NaN。
返回数组元素的方差,表示分布的扩展程度。默认情况下,通过对扁平化数组进行计算来计算方差,否则通过指定的轴进行计算。
对于所有为 NaN 的片段或自由度为零的片段,将返回 NaN,并引发RuntimeWarning。
新特性在版本 1.8.0 中添加。
参数:
aarray_like
包含所需方差的数字的数组。如果a不是数组,则会尝试进行转换。
axis{int, tuple of int, None},可选
计算方差的轴或轴。默认是计算扁平化数组的方差。
dtype数据类型,可���
用于计算方差的数据类型。对于整数类型的数组,默认值是float64
;对于浮点数类型的数组,其数据类型与数组类型相同。
outndarray,可选
可选的输出数组,用来存放结果。它必须与预期的输出具有相同的形状,但如果需要会进行类型转换。
ddofint,可选
“自由度差值”: 计算中使用的除数为N - ddof
,其中N
表示非 NaN 元素的数量。默认情况下ddof为零。
keepdimsbool,可选
如果设置为 True,则被缩减的轴在结果中保留为具有大小为 1 的维度。使用此选项,结果将正确地广播到原始a。
wherearray_like of bool,可选
包含在方差中的元素。详情参见reduce
。
新特性在版本 1.22.0 中添加。
返回:
variancendarray,参见上面的 dtype 参数
如果out为 None,则返回一个包含方差的新数组,否则返回对输出数组的引用。如果 ddof >= 切片中非 NaN 元素的数量,或者切片仅包含 NaN,则该切片的结果为 NaN。
另请参阅
std
标准差
mean
平均值
var
忽略 NaN 时的方差
nanstd
,nanmean
输出类型确定
注意事项
方差是平均值的平方偏差,即,var = mean(abs(x - x.mean())**2)
。
平均值通常计算为x.sum() / N
,其中N = len(x)
。如果指定了ddof,则使用除数N - ddof
。在标准统计实践中,ddof=1
提供了假设无限总体方差的无偏估计。ddof=0
为正态分布变量的方差提供了最大似然估计。
请注意,对于复数,先取绝对值再平方,以确保结果始终是实数且非负。
对于浮点输入,方差是使用与输入相同的精度计算的。根据输入数据,这可能导致结果不准确,特别是对于float32
(见下面的示例)。使用dtype
关键字指定更高精度的累加器可以缓解此问题。
要使此函数在 ndarray 的子类上工作,它们必须使用 kwarg keepdims定义sum
。
例子
>>> a = np.array([[1, np.nan], [3, 4]])
>>> np.nanvar(a)
1.5555555555555554
>>> np.nanvar(a, axis=0)
array([1., 0.])
>>> np.nanvar(a, axis=1)
array([0., 0.25]) # may vary
numpy.corrcoef
原文:
numpy.org/doc/1.26/reference/generated/numpy.corrcoef.html
numpy.corrcoef(x, y=None, rowvar=True, bias=<no value>, ddof=<no value>, *, dtype=None)
返回 Pearson 积矩相关系数。
请参考cov
文档获取更多细节。相关系数矩阵 R 与协方差矩阵 C 之间的关系为
[R_{ij} = \frac{ C_{ij} } { \sqrt{ C_{ii} C_{jj} } }]
R 的值介于 -1 到 1 之间,包括端点。
参数:
xarray_like
包含多个变量和观测值的 1-D 或 2-D 数组。x 的每一行代表一个变量,每一列代表所有这些变量的单个观测值。也请参阅下方的 rowvar。
yarray_like, 可选
一个包含额外变量和观测值的集合。y 的形状与 x 相同。
rowvar布尔值,可选
如果 rowvar 为 True(默认情况),则每行代表一个变量,列中包含观测值。否则,关系被转置:每列代表一个变量,而行包含观测值。
bias_NoValue, 可选
无效果,请勿使用。
自版本 1.10.0 弃用。
ddof_NoValue, 可选
无效果,请勿使用。
自版本 1.10.0 弃用。
dtype数据类型,可选
结果的数据类型。默认情况下,返回的数据类型至少具有numpy.float64
精度。
1.20 版本中推出。
返回:
Rndarray
变量的相关系数矩阵。
另请参见
cov
协方差矩阵
备注
由于浮点舍入的结果,最终数组可能不会是 Hermite 矩阵,对角线元素可能不会是 1,元素可能不满足不等式 abs(a) <= 1。为了改善这种情况,实部和虚部被剪切到区间[-1, 1],但在复杂情况下帮助不大。
此函数接受但忽略参数 bias 和 ddof。这是为了向后兼容以前版本的函数。这些参数对函数的返回值没有影响,在这个版本和以前的 numpy 版本中可以安全地忽略。
示例
在此示例中,我们生成两个随机数组,xarr
和 yarr
,并计算行-wise 和列-wise 的 Pearson 相关系数 R
。由于默认情况下 rowvar
为真,我们首先找到 xarr
的变量之间的行-wise Pearson 相关系数。
>>> import numpy as np
>>> rng = np.random.default_rng(seed=42)
>>> xarr = rng.random((3, 3))
>>> xarr
array([[0.77395605, 0.43887844, 0.85859792],
[0.69736803, 0.09417735, 0.97562235],
[0.7611397 , 0.78606431, 0.12811363]])
>>> R1 = np.corrcoef(xarr)
>>> R1
array([[ 1\. , 0.99256089, -0.68080986],
[ 0.99256089, 1\. , -0.76492172],
[-0.68080986, -0.76492172, 1\. ]])
如果我们增加另一组变量和观测值 yarr
,我们可以计算 xarr
和 yarr
变量之间的按行 Pearson 相关系数。
>>> yarr = rng.random((3, 3))
>>> yarr
array([[0.45038594, 0.37079802, 0.92676499],
[0.64386512, 0.82276161, 0.4434142 ],
[0.22723872, 0.55458479, 0.06381726]])
>>> R2 = np.corrcoef(xarr, yarr)
>>> R2
array([[ 1\. , 0.99256089, -0.68080986, 0.75008178, -0.934284 ,
-0.99004057],
[ 0.99256089, 1\. , -0.76492172, 0.82502011, -0.97074098,
-0.99981569],
[-0.68080986, -0.76492172, 1\. , -0.99507202, 0.89721355,
0.77714685],
[ 0.75008178, 0.82502011, -0.99507202, 1\. , -0.93657855,
-0.83571711],
[-0.934284 , -0.97074098, 0.89721355, -0.93657855, 1\. ,
0.97517215],
[-0.99004057, -0.99981569, 0.77714685, -0.83571711, 0.97517215,
1\. ]])
最后,如果我们使用选项 rowvar=False
,那么现在列会被视为变量,我们将在 xarr
和 yarr
中变量之间计算列-wise Pearson 相关系数。
>>> R3 = np.corrcoef(xarr, yarr, rowvar=False)
>>> R3
array([[ 1\. , 0.77598074, -0.47458546, -0.75078643, -0.9665554 ,
0.22423734],
[ 0.77598074, 1\. , -0.92346708, -0.99923895, -0.58826587,
-0.44069024],
[-0.47458546, -0.92346708, 1\. , 0.93773029, 0.23297648,
0.75137473],
[-0.75078643, -0.99923895, 0.93773029, 1\. , 0.55627469,
0.47536961],
[-0.9665554 , -0.58826587, 0.23297648, 0.55627469, 1\. ,
-0.46666491],
[ 0.22423734, -0.44069024, 0.75137473, 0.47536961, -0.46666491,
1\. ]])
numpy.correlate
原文:
numpy.org/doc/1.26/reference/generated/numpy.correlate.html
numpy.correlate(a, v, mode='valid')
两个一维序列的互相关。
此函数计算信号处理文本中通常定义的相关性:
[c_k = \sum_n a_{n+k} \cdot \overline{v}_n]
其中 a 和 v 序列在必要时进行零填充,(\overline x) 表示复共轭。
参数:
a, varray_like
输入序列。
mode{‘valid’, ‘same’, ‘full’}, 可选
参考 convolve
文档字符串。请注意,默认值为 ‘valid’,与 convolve
不同,后者使用 ‘full’。
old_behaviorbool
old_behavior 在 NumPy 1.10 中已移除。如果需要旧行为,请使用 multiarray.correlate。
返回:
outndarray
a 和 v 的离散互相关。
另请参见
convolve
两个一维序列的离散线性卷积。
multiarray.correlate
互相关的旧版本,无复共轭。
使用 FFT 在大数组上具有优越性能。
注意事项
上述相关性的定义并不唯一,有时相关性可能有不同的定义。另一个常见的定义是:
[c’k = \sum_n a{n} \cdot \overline{v_{n+k}}]
与 (c_k) 通过 (c’k = c{-k}) 相关。
在大数组中,numpy.correlate
可能执行缓慢(即 n = 1e5),因为它不使用 FFT 来计算卷积;在这种情况下,scipy.signal.correlate
可能更可取。
示例
>>> np.correlate([1, 2, 3], [0, 1, 0.5])
array([3.5])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "same")
array([2\. , 3.5, 3\. ])
>>> np.correlate([1, 2, 3], [0, 1, 0.5], "full")
array([0.5, 2\. , 3.5, 3\. , 0\. ])
使用复数序列:
>>> np.correlate([1+1j, 2, 3-1j], [0, 1, 0.5j], 'full')
array([ 0.5-0.5j, 1.0+0.j , 1.5-1.5j, 3.0-1.j , 0.0+0.j ])
当两个输入序列 a 和 v 交换位置时,注意到你会得到时间反转、复共轭的结果 ((\overline{c_{-k}})):
>>> np.correlate([0, 1, 0.5j], [1+1j, 2, 3-1j], 'full')
array([ 0.0+0.j , 3.0+1.j , 1.5+1.5j, 1.0+0.j , 0.5+0.5j])
numpy.cov
numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None, *, dtype=None)
给定数据和权重,估算协方差矩阵。
协方差指示了两个变量一起变化的程度。如果我们检查 N 维样本,(X = [x_1, x_2, … x_N]^T),那么协方差矩阵元素 (C_{ij}) 即为(x_i)和(x_j)的协方差。元素 (C_{ii}) 即为(x_i)的方差。
请参见算法概述中的注释。
参数:
marray_like
包含多个变量和观察值的一维或二维数组。 m的每一行代表一个变量,每一列代表所有这些变量的单个观察值。也参见下面的 rowvar。
yarray_like,可选
另一组变量和观察值。y与m具有相同的形式。
rowvarbool,可选
如果 rowvar 为 True(默认值),则每行代表一个变量,列中包含观察。否则,关系被转置:每列代表一个变量,而行包含观察。
biasbool,可选
默认归一化(False)是由(N - 1)
实现的,其中N
是给定的观察数量(无偏估计)。如果 bias 为 True,则正常化为N
。这些值可以在 numpy 版本 >= 1.5 中通过使用关键字ddof
进行覆盖。
ddofint,可选
如果不是None
,则会覆盖 bias 隐含的默认值。请注意,即使 fweights 和 aweights 都被指定,当ddof=1
时也会返回无偏估计,而ddof=0
将返回简单平均值。详情请参阅注释。默认值为None
。
版本 1.5 中的新增内容。
fweightsarray_like,int,可选
整数频率权重的一维数组;每个观察向量应重复的次数。
版本 1.10 中的新增内容。
aweightsarray_like,可选
观察向量权重的一维数组。这些相对权重对于被认为“重要”的观察通常很大,对于被认为不太“重要”的观察则较小。如果ddof=0
,权重数组可以用于为观察向量分配概率。
版本 1.10 中的新增内容。
dtype数据类型,可选
结果的数据类型。默认情况下,返回数据类型至少为numpy.float64
精度。
版本 1.20 中的新增内容。
返回:
outndarray
变量的协方差矩阵。
另请参阅
corrcoef
标准化协方差矩阵
注释
假设观察在观察数组 m 的列中,并且为简洁起见,令f = fweights
和a = aweights
。计算加权协方差的步骤如下:
>>> m = np.arange(10, dtype=np.float64)
>>> f = np.arange(10) * 2
>>> a = np.arange(10) ** 2.
>>> ddof = 1
>>> w = f * a
>>> v1 = np.sum(w)
>>> v2 = np.sum(w * a)
>>> m -= np.sum(m * w, axis=None, keepdims=True) / v1
>>> cov = np.dot(m * w, m.T) * v1 / (v1**2 - ddof * v2)
请注意,当a == 1
时,归一化因子v1 / (v1**2 - ddof * v2)
应为1 / (np.sum(f) - ddof)
。
示例
考虑两个变量,(x_0)和(x_1),它们之间存在完美的负相关关系:
>>> x = np.array([[0, 2], [1, 1], [2, 0]]).T
>>> x
array([[0, 1, 2],
[2, 1, 0]])
注意当(x_0)增加时,(x_1)减少。协方差矩阵清楚地显示了这一点:
>>> np.cov(x)
array([[ 1., -1.],
[-1., 1.]])
请注意元素(C_{0,1}),显示了(x_0)和(x_1)之间的相关性为负。
此外,注意x和y是如何结合在一起的:
>>> x = [-2.1, -1, 4.3]
>>> y = [3, 1.1, 0.12]
>>> X = np.stack((x, y), axis=0)
>>> np.cov(X)
array([[11.71 , -4.286 ], # may vary
[-4.286 , 2.144133]])
>>> np.cov(x, y)
array([[11.71 , -4.286 ], # may vary
[-4.286 , 2.144133]])
>>> np.cov(x)
array(11.71)
numpy.histogram
原文:
numpy.org/doc/1.26/reference/generated/numpy.histogram.html
numpy.histogram(a, bins=10, range=None, density=None, weights=None)
计算数据集的直方图。
参数:
a类似数组
输入数据。直方图是在扁平化数组上计算的。
bins整数或标量序列或字符串,可选
如果bins为整数,则定义给定范围内等宽箱的数量(默认为 10)。如果bins为序列,则定义一个单调递增的箱边数组,包括最右边的边缘,允许不均匀的箱宽。
新版本 1.11.0 中引入。
如果bins为字符串,则定义用于计算最佳箱宽的方法,定义为histogram_bin_edges
。
range(浮点数,浮点数),可选
箱子的下限和上限。如果未提供,则范围简单地为(a.min(), a.max())
。超出范围的值将被忽略。范围的第一个元素必须小于或等于第二个元素。range也会影响自动箱计算。虽然根据range内的实际数据计算出最优的箱宽,但箱数将填满整个范围,包括不包含数据的部分。
weights类似数组,可选
与a形状相同的权重数组。仅对a中的每个值对应的权重对箱计数做贡献(而不是 1)。如果density为 True,则权重将被归一化,以使范围上的密度积分保持为 1。
density布尔型,可选
如果为False
,结果将包含每个箱中的样本数。如果为True
,结果是箱中概率密度函数的值,在此范围上归一化为 1。请注意,直方图值的总和除非选择单位宽度的箱子,否则将不等于 1;这不是概率质量函数。
返回:
hist数组
直方图的值。请参阅密度和权重以了解可能的语义。
bin_edges浮点数数组
返回箱边(hist 的长度+1)
。
另请参阅
histogramdd
, bincount
, searchsorted
, digitize
, histogram_bin_edges
注释
所有除了最后(右手边最大)箱子都是半开放的。换句话说,如果bins为:
[1, 2, 3, 4]
那么第一个箱子是[1, 2)
(包括 1,但不包括 2),第二个是[2, 3)
。然而,最后一个箱子是[3, 4]
,它包括4。
示例
>>> np.histogram([1, 2, 1], bins=[0, 1, 2, 3])
(array([0, 2, 1]), array([0, 1, 2, 3]))
>>> np.histogram(np.arange(4), bins=np.arange(5), density=True)
(array([0.25, 0.25, 0.25, 0.25]), array([0, 1, 2, 3, 4]))
>>> np.histogram([[1, 2, 1], [1, 0, 1]], bins=[0,1,2,3])
(array([1, 4, 1]), array([0, 1, 2, 3]))
>>> a = np.arange(5)
>>> hist, bin_edges = np.histogram(a, density=True)
>>> hist
array([0.5, 0\. , 0.5, 0\. , 0\. , 0.5, 0\. , 0.5, 0\. , 0.5])
>>> hist.sum()
2.4999999999999996
>>> np.sum(hist * np.diff(bin_edges))
1.0
新版本 1.11.0 中引入。
使用 2 个顶峰随机数据和 2000 个点的自动箱选择方法示例:
>>> import matplotlib.pyplot as plt
>>> rng = np.random.RandomState(10) # deterministic random data
>>> a = np.hstack((rng.normal(size=1000),
... rng.normal(loc=5, scale=2, size=1000)))
>>> _ = plt.hist(a, bins='auto') # arguments are passed to np.histogram
>>> plt.title("Histogram with 'auto' bins")
Text(0.5, 1.0, "Histogram with 'auto' bins")
>>> plt.show()
numpy.histogram2d
numpy.org/doc/1.26/reference/generated/numpy.histogram2d.html
numpy.histogram2d(x, y, bins=10, range=None, density=None, weights=None)
计算两个数据样本的二维直方图。
参数:
x array_like,形状(N,)
包含要进行直方图制作的点的 x 坐标的数组。
y array_like,形状(N,)
包含要进行直方图制作的点的 y 坐标的数组。
bins int 或 array_like 或[int, int]或[array, array],可选
bin 规范:
range array_like,形状(2,2),可选
沿每个维度的 bin 的最左边和最右边的边缘(如果在bins参数中没有明确指定):[[xmin, xmax], [ymin, ymax]]
。此范围之外的所有值将被视为异常值,不计入直方图。
density bool,可选
如果为 False,返回每个 bin 中的样本数量。如果为 True,返回 bin 处的概率density函数,bin_count / sample_count / bin_area
。
weights array_like,形状(N,),可选
一个加权值数组w_i
,对每个样本(x_i, y_i)
进行加权。如果density为 True,则将对权重进行归一化为 1。如果density为 False,则返回的直方图的值等于落入每个 bin 的样本的权重之和。
返回:
H ndarray,形状(nx, ny)
与样本x和y的二维直方图。x中的值沿第一个维度进行直方图处理,而y中的值沿第二个维度进行直方图处理。
xedges ndarray,形状(nx+1,)
第一个维度的 bin 边缘。
yedges ndarray,形状(ny+1,)
第二个维度的 bin 边缘。
参见
histogram
1D 直方图
histogramdd
多维直方图
注意
当density为 True 时,返回的直方图是样本密度,定义为对bin_value * bin_area
的乘积的所有 bin 的总和为 1。
请注意,直方图不遵循笛卡尔坐标系的惯例,其中x值在横轴上,y值在纵轴上。相反,x沿数组的第一个维度(垂直)进行直方图处理,y沿数组的第二个维度(水平)进行直方图处理。这确保与histogramdd
的兼容性。
示例
>>> from matplotlib.image import NonUniformImage
>>> import matplotlib.pyplot as plt
使用可变 bin 宽度构建 2-D 直方图。首先定义 bin 的边缘:
>>> xedges = [0, 1, 3, 5]
>>> yedges = [0, 2, 3, 4, 6]
接下来我们创建一个具有随机 bin 内容的直方图 H:
>>> x = np.random.normal(2, 1, 100)
>>> y = np.random.normal(1, 1, 100)
>>> H, xedges, yedges = np.histogram2d(x, y, bins=(xedges, yedges))
>>> # Histogram does not follow Cartesian convention (see Notes),
>>> # therefore transpose H for visualization purposes.
>>> H = H.T
imshow
(https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.imshow.html#matplotlib.pyplot.imshow)只能显示方形箱子:
>>> fig = plt.figure(figsize=(7, 3))
>>> ax = fig.add_subplot(131, title='imshow: square bins')
>>> plt.imshow(H, interpolation='nearest', origin='lower',
... extent=[xedges[0], xedges[-1], yedges[0], yedges[-1]])
<matplotlib.image.AxesImage object at 0x...>
pcolormesh
(https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.pcolormesh.html#matplotlib.pyplot.pcolormesh)可以显示实际的边缘:
>>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
... aspect='equal')
>>> X, Y = np.meshgrid(xedges, yedges)
>>> ax.pcolormesh(X, Y, H)
<matplotlib.collections.QuadMesh object at 0x...>
NonUniformImage
(https://matplotlib.org/stable/api/image_api.html#matplotlib.image.NonUniformImage)可用于显示实际的箱边和插值:
>>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
>>> im = NonUniformImage(ax, interpolation='bilinear')
>>> xcenters = (xedges[:-1] + xedges[1:]) / 2
>>> ycenters = (yedges[:-1] + yedges[1:]) / 2
>>> im.set_data(xcenters, ycenters, H)
>>> ax.add_image(im)
>>> plt.show()
也可以构建一个二维直方图而不指定箱边:
>>> # Generate non-symmetric test data
>>> n = 10000
>>> x = np.linspace(1, 100, n)
>>> y = 2*np.log(x) + np.random.rand(n) - 0.5
>>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
>>> H, yedges, xedges = np.histogram2d(y, x, bins=20)
现在我们可以使用pcolormesh
(https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.pcolormesh.html#matplotlib.pyplot.pcolormesh)绘制直方图,并使用hexbin
(https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.hexbin.html#matplotlib.pyplot.hexbin)进行比较。
>>> # Plot histogram using pcolormesh
>>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
>>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
>>> ax1.plot(x, 2*np.log(x), 'k-')
>>> ax1.set_xlim(x.min(), x.max())
>>> ax1.set_ylim(y.min(), y.max())
>>> ax1.set_xlabel('x')
>>> ax1.set_ylabel('y')
>>> ax1.set_title('histogram2d')
>>> ax1.grid()
>>> # Create hexbin plot for comparison
>>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
>>> ax2.plot(x, 2*np.log(x), 'k-')
>>> ax2.set_title('hexbin')
>>> ax2.set_xlim(x.min(), x.max())
>>> ax2.set_xlabel('x')
>>> ax2.grid()
>>> plt.show()
>>> ax = fig.add_subplot(132, title='pcolormesh: actual edges',
... aspect='equal')
>>> X, Y = np.meshgrid(xedges, yedges)
>>> ax.pcolormesh(X, Y, H)
<matplotlib.collections.QuadMesh object at 0x...>
NonUniformImage
(https://matplotlib.org/stable/api/image_api.html#matplotlib.image.NonUniformImage)可用于显示实际的箱边和插值:
>>> ax = fig.add_subplot(133, title='NonUniformImage: interpolated',
... aspect='equal', xlim=xedges[[0, -1]], ylim=yedges[[0, -1]])
>>> im = NonUniformImage(ax, interpolation='bilinear')
>>> xcenters = (xedges[:-1] + xedges[1:]) / 2
>>> ycenters = (yedges[:-1] + yedges[1:]) / 2
>>> im.set_data(xcenters, ycenters, H)
>>> ax.add_image(im)
>>> plt.show()
[外链图片转存中…(img-BAmkj6IO-1719458427240)]
也可以构建一个二维直方图而不指定箱边:
>>> # Generate non-symmetric test data
>>> n = 10000
>>> x = np.linspace(1, 100, n)
>>> y = 2*np.log(x) + np.random.rand(n) - 0.5
>>> # Compute 2d histogram. Note the order of x/y and xedges/yedges
>>> H, yedges, xedges = np.histogram2d(y, x, bins=20)
现在我们可以使用pcolormesh
(https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.pcolormesh.html#matplotlib.pyplot.pcolormesh)绘制直方图,并使用hexbin
(https://matplotlib.org/stable/api/_as-gen/matplotlib.pyplot.hexbin.html#matplotlib.pyplot.hexbin)进行比较。
>>> # Plot histogram using pcolormesh
>>> fig, (ax1, ax2) = plt.subplots(ncols=2, sharey=True)
>>> ax1.pcolormesh(xedges, yedges, H, cmap='rainbow')
>>> ax1.plot(x, 2*np.log(x), 'k-')
>>> ax1.set_xlim(x.min(), x.max())
>>> ax1.set_ylim(y.min(), y.max())
>>> ax1.set_xlabel('x')
>>> ax1.set_ylabel('y')
>>> ax1.set_title('histogram2d')
>>> ax1.grid()
>>> # Create hexbin plot for comparison
>>> ax2.hexbin(x, y, gridsize=20, cmap='rainbow')
>>> ax2.plot(x, 2*np.log(x), 'k-')
>>> ax2.set_title('hexbin')
>>> ax2.set_xlim(x.min(), x.max())
>>> ax2.set_xlabel('x')
>>> ax2.grid()
>>> plt.show()