哈喽，我是小白~
今儿和大家再聊一个Numpy非常重要的方面：统计函数的使用！~
在机器学习实验中，NumPy 统计函数是数据预处理和特征分析的重要工具，能快速计算数据的均值、方差、标准差等关键统计量，为模型训练提供基础。通过计算相关系数和协方差，帮助研究变量之间的关系，发现潜在的依赖性。
NumPy 函数还在评估模型性能、处理大规模数据集时表现出色，提升实验的效率和准确性。
今天涉及到的Numpy实现统计函数的内容有：
np.mean() - 算术平均值 np.median() - 中位数 np.std() - 标准差 np.var() - 方差 np.min() - 最小值 np.max() - 最大值 np.percentile() - 百分位数 np.quantile() - 分位数 np.corrcoef() - 相关系数矩阵 np.cov() - 协方差矩阵
一起来看细节，大家后续可以用到实际的项目中~
往期 Numpy 合集
1. np.mean() - 算术平均值
功能
np.mean() 计算输入数组的算术平均值，也就是所有元素的和除以元素的数量。它可以沿着特定的轴计算均值，这在处理多维数组时非常有用。
参数和返回值
arr: 输入的数组，支持多维数组（如 ndarray）。
axis: 指定计算均值的轴。
如果 axis=None（默认），则计算整个数组的均值。如果指定轴，如 axis=0或axis=1，则沿着该轴计算均值。
返回值: 返回数组的算术平均值。如果输入是多维数组且指定了轴，则返回沿该轴的均值。
Python 实现
一维数组：
import numpy as np
data = np.array([1, 2, 3, 4, 5])
mean_value = np.mean(data)
print("Mean value:", mean_value)
输出：
Mean value: 3.0
解释：数组 [1, 2, 3, 4, 5] 的平均值为 (1+2+3+4+5)/5 = 3.0。
二维数组：
data_2d = np.array([[1, 2, 3], [4, 5, 6]])
# 沿 axis=0（即列方向）计算均值
mean_axis0 = np.mean(data_2d, axis=0)
print("Mean along axis 0:", mean_axis0)
# 沿 axis=1（即行方向）计算均值
mean_axis1 = np.mean(data_2d, axis=1)
print("Mean along axis 1:", mean_axis1)
输出：
Mean along axis 0: [2.5 3.5 4.5]
Mean along axis 1: [2. 5.]
解释：
沿着 axis=0，每列的平均值为[ (1+4)/2, (2+5)/2, (3+6)/2 ] = [2.5, 3.5, 4.5]。沿着 axis=1，每行的平均值为[ (1+2+3)/3, (4+5+6)/3 ] = [2, 5]。
2. np.median() - 中位数
功能
np.median() 用于计算数据的中位数，即排序后位于中间的那个值。对于偶数个数据，中位数是中间两个数的平均值。
参数和返回值
arr: 输入的数组。
axis: 指定计算中位数的轴。
如果 axis=None，则计算整个数组的中位数。如果指定轴，则沿该轴计算中位数。 返回值: 返回中位数。
Python 实现
一维数组：
data = np.array([3, 1, 4, 1, 5, 9])
median_value = np.median(data)
print("Median value:", median_value)
输出：
Median value: 3.5
解释：数组 [3, 1, 4, 1, 5, 9] 排序后为 [1, 1, 3, 4, 5, 9]，中间的两个数是 3 和 4，它们的平均值为 (3+4)/2 = 3.5。
二维数组：
data_2d = np.array([[3, 1, 4], [1, 5, 9]])
# 沿 axis=0（列方向）计算中位数
median_axis0 = np.median(data_2d, axis=0)
print("Median along axis 0:", median_axis0)
# 沿 axis=1（行方向）计算中位数
median_axis1 = np.median(data_2d, axis=1)
print("Median along axis 1:", median_axis1)
输出：
Median along axis 0: [2. 3. 6.5]
Median along axis 1: [3. 5.]
解释：
沿着 axis=0，每列的中位数分别是[2, 3, 6.5]。沿着 axis=1，每行的中位数分别是[3, 5]。
3. np.std() - 标准差
功能
np.std() 用于计算数据的标准差，标准差反映数据的离散程度。标准差越大，数据的波动越大；标准差越小，数据越接近均值。
参数和返回值
arr: 输入的数组。
axis: 指定计算标准差的轴。
如果 axis=None，则计算整个数组的标准差。如果指定轴，则沿该轴计算标准差。 ddof: Delta Degrees of Freedom，自由度调整参数。ddof=0表示正则标准差计算，ddof=1用于无偏估计。
返回值: 返回标准差。
Python 实现
一维数组：
data = np.array([1, 2, 3, 4, 5])
std_value = np.std(data)
print("Standard deviation:", std_value)
输出：
Standard deviation: 1.4142135623730951
解释：标准差为数据的波动程度。该数据集的均值为 3，标准差为约 1.41。
二维数组：
data_2d = np.array([[1, 2, 3], [4, 5, 6]])
# 沿 axis=0（列方向）计算标准差
std_axis0 = np.std(data_2d, axis=0)
print("Standard deviation along axis 0:", std_axis0)
# 沿 axis=1（行方向）计算标准差
std_axis1 = np.std(data_2d, axis=1)
print("Standard deviation along axis 1:", std_axis1)
输出：
Standard deviation along axis 0: [1.5 1.5 1.5]
Standard deviation along axis 1: [0.81649658 0.81649658]
解释：
沿着 axis=0，每列的标准差为[1.5, 1.5, 1.5]。沿着 axis=1，每行的标准差为0.816，这表明每行数据较为接近均值。
4. np.var() - 方差
功能
np.var() 用于计算数据的方差，方差是标准差的平方，也用于衡量数据的离散程度。
参数和返回值
arr: 输入的数组。
axis: 指定计算方差的轴。
如果 axis=None，则计算整个数组的方差。如果指定轴，则沿该轴计算方差。 ddof: 自由度调整，默认ddof=0。
返回值: 返回方差。
Python 实现
一维数组：
data = np.array([1, 2, 3, 4, 5])
var_value = np.var(data)
print("Variance:", var_value)
输出：
Variance: 2.0
解释：方差表示数据与其均值的偏离程度，方差为 2.0 表示数据有一定波动。
二维数组：
data_2d = np.array([[1, 2, 3], [4, 5, 6]])
# 沿 axis=0（列方向）计算方差
var_axis0 = np.var(data_2d, axis=0)
print("Variance along axis 0:", var_axis0)
# 沿 axis=1（行方向）计算方差
var_axis1 = np.var(data_2d, axis=1)
print("Variance along axis 1:", var_axis1)
输出：
Variance along axis 0: [2.25 2.25 2.25]
Variance along axis 1: [0.66666667 0.666666
67]
解释：
沿着 axis=0，每列的方差为[2.25, 2.25, 2.25]。沿着 axis=1，每行的方差为0.67。
5. np.min() - 最小值
功能
np.min() 函数用于返回数组中的最小值。可以在多维数组中指定轴，沿特定轴查找最小值。
参数和返回值
arr: 输入的数组。
axis: 指定计算最小值的轴。
如果 axis=None（默认），则返回整个数组中的最小值。如果指定轴，则沿该轴计算最小值。 返回值: 返回数组的最小值，或者沿指定轴的最小值数组。
Python 实现
一维数组：
import numpy as np
data = np.array([5, 2, 8, 1, 7])
min_value = np.min(data)
print("Minimum value:", min_value)
输出：
Minimum value: 1
解释：数组 [5, 2, 8, 1, 7] 中的最小值为 1。
二维数组：
data_2d = np.array([[5, 2, 8], [1, 7, 3]])
# 沿 axis=0（列方向）计算最小值
min_axis0 = np.min(data_2d, axis=0)
print("Minimum along axis 0:", min_axis0)
# 沿 axis=1（行方向）计算最小值
min_axis1 = np.min(data_2d, axis=1)
print("Minimum along axis 1:", min_axis1)
输出：
Minimum along axis 0: [1 2 3]
Minimum along axis 1: [2 1]
解释：
沿着 axis=0，每列的最小值分别是[1, 2, 3]。沿着 axis=1，每行的最小值分别是[2, 1]。
6. np.max() - 最大值
功能
np.max() 用于返回数组中的最大值。类似于 np.min()，也可以指定轴来沿该轴查找最大值。
参数和返回值
arr: 输入的数组。
axis: 指定计算最大值的轴。
如果 axis=None（默认），则返回整个数组的最大值。如果指定轴，则沿该轴计算最大值。 返回值: 返回数组的最大值，或者沿指定轴的最大值数组。
Python 实现
一维数组：
data = np.array([5, 2, 8, 1, 7])
max_value = np.max(data)
print("Maximum value:", max_value)
输出：
Maximum value: 8
解释：数组 [5, 2, 8, 1, 7] 中的最大值为 8。
二维数组：
data_2d = np.array([[5, 2, 8], [1, 7, 3]])
# 沿 axis=0（列方向）计算最大值
max_axis0 = np.max(data_2d, axis=0)
print("Maximum along axis 0:", max_axis0)
# 沿 axis=1（行方向）计算最大值
max_axis1 = np.max(data_2d, axis=1)
print("Maximum along axis 1:", max_axis1)
输出：
Maximum along axis 0: [5 7 8]
Maximum along axis 1: [8 7]
解释：
沿着 axis=0，每列的最大值分别是[5, 7, 8]。沿着 axis=1，每行的最大值分别是[8, 7]。
7. np.percentile() - 百分位数
功能
np.percentile() 用于计算指定百分位数的值。百分位数表示在数据集中，某个值位于多少百分比的数值之下。例如，第 50 个百分位数就是数据的中位数。
参数和返回值
arr: 输入的数组。
q: 百分位数值，可以是 0 到 100 的数或数组，表示要计算的百分位数。
axis: 指定计算百分位数的轴。如果 axis=None，则计算整个数组的百分位数。
返回值: 返回指定百分位数的值。
Python 实现
一维数组：
data = np.array([1, 2, 3, 4, 5])
percentile_25 = np.percentile(data, 25)
percentile_50 = np.percentile(data, 50) # 50% 百分位数即中位数
percentile_75 = np.percentile(data, 75)
print("25th percentile:", percentile_25)
print("50th percentile (median):", percentile_50)
print("75th percentile:", percentile_75)
输出：
25th percentile: 2.0
50th percentile (median): 3.0
75th percentile: 4.0
解释：
第 25 个百分位数是 2.0，意味着 25% 的数据小于或等于 2。 第 50 个百分位数（中位数）是 3.0。 第 75 个百分位数是 4.0。
二维数组：
data_2d = np.array([[10, 20, 30], [40, 50, 60]])
# 沿 axis=0（列方向）计算百分位数
percentile_50_axis0 = np.percentile(data_2d, 50, axis=0)
print("50th percentile along axis 0:", percentile_50_axis0)
# 沿 axis=1（行方向）计算百分位数
percentile_50_axis1 = np.percentile(data_2d, 50, axis=1)
print("50th percentile along axis 1:", percentile_50_axis1)
输出：
50th percentile along axis 0: [25. 35. 45.]
50th percentile along axis 1: [20. 50.]
解释：
沿着 axis=0，第 50 个百分位数为[25, 35, 45]。沿着 axis=1，第 50 个百分位数为[20, 50]。
8. np.quantile() - 分位数
功能
np.quantile() 与 np.percentile() 类似，但它接受 0 到 1 之间的小数作为分位数参数，而不是 0 到 100 之间的百分比。分位数是数据集中某个数值的相对位置。
参数和返回值
arr: 输入的数组。
q: 分位数，可以是 0 到 1 之间的数或数组，表示要计算的分位数位置。
axis: 指定计算分位数的轴。如果 axis=None，则计算整个数组的分位数。
返回值: 返回指定分位数的值。
Python 实现
一维数组：
data = np.array([1, 2, 3, 4, 5])
quantile_25 = np.quantile(data, 0.25)
quantile_50 = np.quantile(data, 0.50) # 50% 分位数即中位数
quantile_75 = np.quantile(data, 0.75)
print("25th quantile:", quantile_25)
print("50th quantile (median):", quantile_50)
print("75th quantile:", quantile_75)
输出：
25th quantile: 2.0
50th quantile (median): 3.0
75th quantile: 4.0
解释：
与 percentile() 的输出相同，因为分位数的百分比计算一致。
二维数组：
data_2d = np.array([[10, 20, 30], [40, 50, 60]])
# 沿 axis=0（列方向）计算分位数
quantile_50_axis0 = np.quantile(data_2d, 0.50, axis=0)
print("50th quantile along axis 0:", quantile_50_axis0)
# 沿 axis=1（行方向）计算分位数
quantile_50_axis1 = np.quantile(data_2d, 0.50, axis=1)
print("50th quantile along axis 1:", quantile_50_axis1)
输出：
50th quantile along axis 0: [25. 35. 45.]
50th quant
ile along axis 1: [20. 50.]
解释：
与 percentile() 的输出相同。
9. np.corrcoef() - 相关系数矩阵
功能
np.corrcoef() 用于计算两个数据集之间的相关系数。它返回的是相关系数矩阵，矩阵的对角线是 1（表示一个数据集与自身的完全相关性）。
参数和返回值
arr: 输入的数组。可以是单个数组或多个数组的组合。
返回值: 返回相关系数矩阵。
Python 实现
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 4, 3, 2, 1])
correlation_matrix = np.corrcoef(x, y)
print("Correlation matrix:\n", correlation_matrix)
输出：
Correlation matrix:
[[ 1. -1.]
[-1. 1.]]
解释：
两个数组 [1, 2, 3, 4, 5] 和 [5, 4, 3, 2, 1] 之间的相关系数是 -1，表明它们完全负相关。
10. np.cov() - 协方差矩阵
功能
np.cov() 用于计算协方差矩阵。协方差反映两个变量共同变化的趋势。正协方差表示同方向变化，负协方差表示反方向变化。
参数和返回值
arr: 输入的数组。可以是单个数组或多个数组的组合。
返回值: 返回协方差矩阵。
Python 实现
x = np.array([1, 2, 3, 4, 5])
y = np.array([5, 4, 3, 2, 1])
covariance_matrix = np.cov(x, y)
print("Covariance matrix:\n", covariance_matrix)
输出：
Covariance matrix:
[[ 2.5 -2.5]
[-2.5 2.5]]
解释：
协方差矩阵中的负值（-2.5）表示 x 和 y 之间的负相关关系。
总结
上述 10 个 NumPy 统计函数在数据分析和机器学习中非常常用，分别用于计算均值、方差、标准差、百分位数、相关系数、协方差等。这些函数可以处理不同维度的数据，并通过指定轴来实现不同方向的统计计算。在 Python 中，利用这些函数可以轻松处理复杂的数据集并进行统计分析。
这里是一个完整的案例，使用了 NumPy 统计函数分析虚拟数据集并生成多种图形，包括散点图、直方图和折线图。该案例演示了不同 NumPy 统计函数如何帮助理解数据特征，同时使用 matplotlib 将多个图像绘制在一个图里。
案例说明
虚拟数据集生成：生成两个包含1000个样本的随机数据集，分别代表变量
x和y。其中y是一个带有噪声的线性函数，模拟出相关关系。数据分析：
计算 x和y的均值、方差、标准差、最小值和最大值。计算 x和y的百分位数和分位数。计算 x和y的相关系数和协方差矩阵。
数据可视化：
使用散点图显示 x和y之间的关系，观察其相关性。使用直方图显示 x和y的分布，查看其均值和标准差。使用折线图展示 x和y的百分位数趋势。
Python 代码
import numpy as np
import matplotlib.pyplot as plt
# 设置随机数种子以确保结果可重复
np.random.seed(42)
# 生成虚拟数据集
x = np.random.normal(loc=50, scale=10, size=1000) # 平均值为50，标准差为10的正态分布
y = 2 * x + np.random.normal(loc=0, scale=10, size=1000) # 带有噪声的线性关系 y = 2x + 噪声
# 计算统计量
mean_x = np.mean(x)
mean_y = np.mean(y)
var_x = np.var(x)
var_y = np.var(y)
std_x = np.std(x)
std_y = np.std(y)
min_x = np.min(x)
min_y = np.min(y)
max_x = np.max(x)
max_y = np.max(y)
percentile_25_x = np.percentile(x, 25)
percentile_25_y = np.percentile(y, 25)
percentile_50_x = np.percentile(x, 50)
percentile_50_y = np.percentile(y, 50)
percentile_75_x = np.percentile(x, 75)
percentile_75_y = np.percentile(y, 75)
correlation = np.corrcoef(x, y)[0, 1]
covariance = np.cov(x, y)[0, 1]
# 打印统计结果
print(f"Mean of x: {mean_x:.2f}, Mean of y: {mean_y:.2f}")
print(f"Variance of x: {var_x:.2f}, Variance of y: {var_y:.2f}")
print(f"Standard Deviation of x: {std_x:.2f}, Standard Deviation of y: {std_y:.2f}")
print(f"Min of x: {min_x:.2f}, Max of x: {max_x:.2f}")
print(f"Min of y: {min_y:.2f}, Max of y: {max_y:.2f}")
print(f"25th Percentile of x: {percentile_25_x:.2f}, 50th Percentile (Median) of x: {percentile_50_x:.2f}, 75th Percentile of x: {percentile_75_x:.2f}")
print(f"25th Percentile of y: {percentile_25_y:.2f}, 50th Percentile (Median) of y: {percentile_50_y:.2f}, 75th Percentile of y: {percentile_75_y:.2f}")
print(f"Correlation between x and y: {correlation:.2f}")
print(f"Covariance between x and y: {covariance:.2f}")
# 创建图形
fig, axs = plt.subplots(2, 2, figsize=(12, 10))
# 子图 1：散点图 (x, y) 显示两者之间的关系
axs[0, 0].scatter(x, y, color='red', alpha=0.6)
axs[0, 0].set_title("Scatter plot of x and y")
axs[0, 0].set_xlabel("x")
axs[0, 0].set_ylabel("y")
# 子图 2：x 和 y 的直方图
axs[0, 1].hist(x, bins=30, color='blue', alpha=0.7, label='x')
axs[0, 1].hist(y, bins=30, color='green', alpha=0.7, label='y')
axs[0, 1].set_title("Histograms of x and y")
axs[0, 1].set_xlabel("Value")
axs[0, 1].set_ylabel("Frequency")
axs[0, 1].legend()
# 子图 3：x 的百分位数折线图
percentiles_x = np.percentile(x, [0, 25, 50, 75, 100])
axs[1, 0].plot([0, 25, 50, 75, 100], percentiles_x, marker='o', color='purple', label='x')
axs[1, 0].set_title("Percentiles of x")
axs[1, 0].set_xlabel("Percentile")
axs[1, 0].set_ylabel("Value")
axs[1, 0].legend()
# 子图 4：y 的百分位数折线图
percentiles_y = np.percentile(y, [0, 25, 50, 75, 100])
axs[1, 1].plot([0, 25, 50, 75, 100], percentiles_y, marker='s', color='orange', label='y')
axs[1, 1].set_title("Percentiles of y")
axs[1, 1].set_xlabel("Percentile")
axs[1, 1].set_ylabel("Value")
axs[1, 1].legend()
# 调整布局
plt.tight_layout()
plt.show()
数据生成：
x是一个正态分布的数据集，均值为 50，标准差为 10。y是通过x生成的带有噪声的线性数据集，模拟出相关性。
统计计算：
使用 np.mean()、np.var()、np.std()、np.min()和np.max()等 NumPy 函数分别计算x和y的统计信息。使用 np.percentile()计算x和y的 25%、50%、75% 的百分位数。使用 np.corrcoef()和np.cov()分别计算x和y的相关系数和协方差。
子图 1：散点图展示 x 和 y 之间的关系，表明两者存在一定的线性相关性。清楚展示 x 和 y 的线性相关性，表明两者具有较强的正相关（由相关系数和协方差支持）。
子图 2：两个直方图展示 x 和 y 的分布情况，颜色鲜艳，展示了数据的均值、方差等特性。显示了 x 和 y 的分布，帮助直观地查看数据的集中趋势（均值）和离散程度（标准差）。
子图 3 和 4：分别为 x 和 y 的百分位数折线图，用以观察数据的分布特性。表明 x 和 y 的分布趋势和分位数的变化，展示了数据的范围和四分位点的差异。
整个内容和案例展示了如何使用 NumPy 的统计函数对虚拟数据进行分析，并通过图表可视化这些统计特征，有助于大家更深入地理解数据。
往期 Numpy 合集
最后
