9.Scipy

定位

基于 NumPy 的高级科学计算工具库。‌数值计算库,在numPy库的基础上增加了众多的数学、科学以及工程计算中常用的库函数。

SciPy‌的中文翻译是“Scientific Python”，发音为“Sigh Pie”。

官方文档：https://scipy.org/。

为什么使用SciPy

SciPy基于NumPy开发，为何不直接使用NumPy?

SciPy已经优化并增加了NumPy和数据科学中经常使用的函数。

SciPy是一个开源的Python库，它是NumPy生态系统的核心组成部分之一，提供了大量高级数学、科学和工程计算功能‌。

方便、易于使用、专为科学和工程设计的Python工具包.

它包括统计,优化,整合,线性代数模块,傅里叶变换,信号和图像处理,常微分方程求解器等等。

功能

扩展 NumPy 的功能，提供更复杂的数学算法（如优化、积分、信号处理、统计等）。

模块化设计（例如 scipy.optimize、scipy.stats）。

依赖关系

完全依赖 NumPy，但 不包含 NumPy。

与 NumPy 是兄弟关系，共同构成科学计算的核心工具链。

SciPy是用哪种语言编写的

SciPy主要是用Python编写的，但也有一些片段是用C语言编写的。

Scipy的代码库在哪里?

SciPy的源代码位于这个github仓库：https://github.com/scipy/scipy

安装 SciPy

# pip 安装最新版
pip install scipy

# conda 安装
conda install scipy

检查 SciPy 版本

版本字符串存储在__verslon__属性中

方法 1：在 Python 中直接查看

在 Python 脚本或交互式终端（如 Jupyter Notebook）中运行：

import scipy
print(scipy.__version__)
# 示例输出: 1.11.1

方法 2：命令行查询

根据你的包管理工具选择以下命令：

pip 用户：

pip show scipy
# 输出信息中查找 "Version: x.x.x"

conda 用户：

conda list scipy
# 输出列表中显示版本号

常量（constants）

由于SciPy更专注于科学的实现，它提供了许多内置的科学常量，当你从事数据科学工作时，这些常量会很有帮助。

from scipy import constants

print(constants.pi)#3.141592653589793
# 查看所有常量列表
print(dir(constants))

点击查看所有常量

['Avogadro', 'Boltzmann', 'Btu', 'Btu_IT', 'Btu_th', 'ConstantWarning', 'G', 'Julian_year', 'N_A', 'Planck', 'R', 'Rydberg', 'Stefan_Boltzmann', 'Wien', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '_codata', '_constants', '_obsolete_constants', 'acre', 'alpha', 'angstrom', 'arcmin', 'arcminute', 'arcsec', 'arcsecond', 'astronomical_unit', 'atm', 'atmosphere', 'atomic_mass', 'atto', 'au', 'bar', 'barrel', 'bbl', 'blob', 'c', 'calorie', 'calorie_IT', 'calorie_th', 'carat', 'centi', 'codata', 'constants', 'convert_temperature', 'day', 'deci', 'degree', 'degree_Fahrenheit', 'deka', 'dyn', 'dyne', 'e', 'eV', 'electron_mass', 'electron_volt', 'elementary_charge', 'epsilon_0', 'erg', 'exa', 'exbi', 'femto', 'fermi', 'find', 'fine_structure', 'fluid_ounce', 'fluid_ounce_US', 'fluid_ounce_imp', 'foot', 'g', 'gallon', 'gallon_US', 'gallon_imp', 'gas_constant', 'gibi', 'giga', 'golden', 'golden_ratio', 'grain', 'gram', 'gravitational_constant', 'h', 'hbar', 'hectare', 'hecto', 'horsepower', 'hour', 'hp', 'inch', 'k', 'kgf', 'kibi', 'kilo', 'kilogram_force', 'kmh', 'knot', 'lambda2nu', 'lb', 'lbf', 'light_year', 'liter', 'litre', 'long_ton', 'm_e', 'm_n', 'm_p', 'm_u', 'mach', 'mebi', 'mega', 'metric_ton', 'micro', 'micron', 'mil', 'mile', 'milli', 'minute', 'mmHg', 'mph', 'mu_0', 'nano', 'nautical_mile', 'neutron_mass', 'nu2lambda', 'ounce', 'oz', 'parsec', 'pebi', 'peta', 'physical_constants', 'pi', 'pico', 'point', 'pound', 'pound_force', 'precision', 'proton_mass', 'psi', 'pt', 'quecto', 'quetta', 'ronna', 'ronto', 'short_ton', 'sigma', 'slinch', 'slug', 'speed_of_light', 'speed_of_sound', 'stone', 'survey_foot', 'survey_mile', 'tebi', 'tera', 'test', 'ton_TNT', 'torr', 'troy_ounce', 'troy_pound', 'u', 'unit', 'value', 'week', 'yard', 'year', 'yobi', 'yocto', 'yotta', 'zebi', 'zepto', 'zero_Celsius', 'zetta']

单位类别

单位被置于这些类别之下：

公制长度二进制质量角度

时间英制长度压力体积

速度温度能量功率力

点击查看全部单位类型

#1 公制长度
#返回指定的单位，以米为单位(例如，centi#返回0.01)。
constants.kilo#1000.0

#2 二进制单位
#返回以字节为单位的指定单位(例如，kibi#返回1024)
print (constants.kibi)
print (constants.mebi)
print (constants.gibi)
print(constants.tebi)
print(constants.pebi)
print(constants.exbi)
print(constants.zebi)
print(constants.yobi)

#3 质量
#返回以公斤为单位的指定单位(例如，克#返回0.001)。
print(constants.gram)
print(constants.metric_ton)
print(constants.grain)
print(constants.lb)
print(constants.pound)
print(constants.oz)
print(constants.ounce)
print(constants.stone)
print(constants.long_ton)
print(constants.short_ton)
print(constants.troy_ounce)
print(constants.troy_pound)
print(constants.carat)
print(constants.atomic_mass)
print(constants.m_u)
print(constants.u)

#4 角度
#返回以弧度为单位的指定单位(例如，度#返回0.01745#329251994#3295)
print(constants.degree)
print(constants.arcmin)
print(constants.arcminute)
print(constants.arcsec)
print(constants.arcsecond)

#5 时间
#返回指定的单位，以秒为单位(例如，小时#返回#3600.0)
print(constants.minute)
print(constants.hour)
print(constants.day)
print(constants.week)
print(constants.year)
print(constants.Julian_year)

#6 英制长度
#返回指定的单位，以米为单位(例如，海里#返回1852.0)。
print(constants.inch)
print(constants.foot)
print(constants.yard)
print(constants.mile)
print(constants.mil)
print(constants.pt)
print(constants.point)
print(constants.survey_foot)
print(constants.survey_mile)
print(constants.nautical_mile)
print(constants.fermi)
print(constants.angstrom)
print(constants.micron)
print(constants.au)
print(constants.astronomical_unit)
print(constants.light_year)
print(constants.parsec)

#7 压力
#返回以帕斯卡为单位的指定单位(例如:psi#返回6894.75729#3168#361)。
print(constants.atm)
print(constants.atmosphere)
print(constants.bar)
print(constants.torr)
print(constants.mmHg)
print (constants.psi)

#8 面积
#返回以平方米为单位的指定单位(例如，公顷#返回10000.0)
print(constants.hectare)
print(constants.acre)

#9 体积
#返回以立方米为单位的指定单位(例如，升#返回0.001)。
print(constants.liter)
print(constants.litre)
print(constants.gallon)
print(constants.gallon_US)
print(constants.gallon_imp)
print(constants.fluid_ounce)
print(constants.fluid_ounce_US)
print(constants.fluid_ounce_imp)
print(constants.barrel)
print(constants.bbl)

##10 速度
#返回指定的单位，单位为米/秒(例如，音速#返回#340.5)
print(constants.kmh)
print (constants.mph)
print(constants.mach)
print(constants.speed_of_sound)
print(constants.knot)

#11 温度
#返回指定的开尔文单位(如季摄氏度#返回27#15)
print(constants.zero_Celsius)
print(constants.degree_Fahrenheit)

#12_能量
#返回以焦耳为单位的指定单位(如卡路里#返回4.184)。
print(constants.eV)
print(constants.electron_volt)
print(constants.calorie)
print(constants.calorie_th)
print(constants.calorie_IT)
print(constants.erg)
print(constants.Btu)
print(constants.Btu_IT)
print(constants.Btu_th)
print(constants.ton_TNT)

#13 功率
#返回以瓦为单位的指定单位(例如，马力#返回745.6998)
print(constants.hp)
print(constants.horsepower)

#14 力
#返回指定的牛顿单位(例如，千克力#返回9.80665)
print(constants.dyn)
print(constants.dyne)
print(constants.lbf)
print(constants.pound_force)
print(constants.kgf)
print(constants.kilogram_force)

优化器（optimize：优化和求根）

SciPy 的 scipy.optimize 模块提供了丰富的优化算法，适用于不同场景的数值优化问题。

是SciPy中定义的多个程序（方法或算法），它可以找到一个方程的根，或者找到一个函数的最小值等等。

方程求根（Root Finding）

NumPy能够找到多项式和线性方程的根，但它不能找到非线性方程的根，比如：x + cos(x)

适用场景：求解非线性方程组，如化学平衡计算。
算法：
- root：支持多种方法（hybr, lm等）。

root函数初步使用

import numpy as np
from scipy.optimize import root

# 定义目标函数
def eqn(x):
    return np.array([x[0] + np.cos(x[0])])

# 初始猜测
x0 = np.array([0.0])

# 求解
sol = root(eqn, x0, method='hybr')

# 解析结果
if sol.success:
    print(f"解: x = {sol.x[0]:.5f}")
    print(f"残差: {sol.fun[0]:.2e}")
else:
    print("失败:", sol.message)

解: x = -0.73909
残差: 0.00e+00

root函数使用说明

参数说明：

目标函数 fun

一个代表方程的函数。

必须接受数组输入并返回数组输出，即使是一维问题。

import numpy as np

def eqn(x):
    return np.array([x[0] + np.cos(x[0])])  # 单变量问题，返回数组

初始猜测 x0

一个对根的初始猜测（越接近真实值越好，就是你自己估计一下方程的解约等于多少）。

格式：必须为 NumPy 数组，即使单变量。

x0 = np.array([0.0])  # 初始猜测为数组形式

选择求解方法 method

推荐方法：

单变量问题：method='hybr'（默认，高效稳定）。
多变量小规模问题：method='hybr' 或 method='lm'（最小二乘法）。
大规模/稀疏问题：method='krylov'（无需显式雅可比矩阵）。

sol = root(eqn, x0, method='hybr')

提供雅可比矩阵 jac（可选）

解析雅可比加速收敛：

def jacobian(x):
    return np.array([[1 - np.sin(x[0])]])  # 导数为 1 - sin(x)

sol = root(eqn, x0, jac=jacobian, method='hybr')

数值估计雅可比（默认）：

sol = root(eqn, x0, jac=False)  # 默认使用数值差分估计

‌Jacobian‌，也称为雅可比行列式（Jacobian determinant），是由德国数学家卡尔·古斯塔夫·雅各布·雅可比（Carl Gustav Jacob Jacobi）提出的数学概念。它用于描述由n个函数组成的系统在某一点的局部线性变换性质，其值为该点处偏导数构成的n×n行列式‌。

处理多变量方程组

示例：解方程组

def system_eqn(z):
    x, y = z
    return [x + y - 3, x**2 + y**2 - 9]

x0 = np.array([1.0, 1.0])  # 初始猜测为数组
sol = root(system_eqn, x0, method='hybr')
print(sol.x)  # 输出解：[0., 3.] 或 [3., 0.]

传递额外参数 args

示例：解带参数的方程 $x + a cos (b x) = 0$

def eqn_param(x, a, b):
    return np.array([x[0] + a * np.cos(b * x[0])])

a_val, b_val = 2.0, 0.5
sol = root(eqn_param, x0=np.array([1.0]), args=(a_val, b_val))

调整求解器选项 options

常用选项：
- tol：容差（默认1e-8），控制精度。
- maxiter：最大迭代次数（默认依赖方法）。

options = {'xtol': 1e-10, 'maxiter': 100}
sol = root(eqn, x0, method='hybr', options=options)

解析结果对象

该函数返回一个包含解的信息的对象

关键属性：
- sol.x：解的估计值。
- sol.success：是否成功收敛（True/False）。
- sol.message：终止原因的详细描述。
- sol.fun：解处的残差（应接近零）。

if sol.success:
    print(f"解为 x = {sol.x[0]:.5f}, 残差 = {sol.fun[0]:.2e}")
else:
    print("求解失败:", sol.message)

核心结果字段解析

字段名	值示例	含义
`x`	`[-0.7391]`	解的数值：方程 $x + cos (x) = 0$ 的根约为 $- 0.73908513$ 。
`fun`	`[ 0.000e+00]`	函数值：在解处的方程值 $f (x) = x + cos (x)$ ，接近 0 表示收敛成功。
`success`	`True`	收敛状态：`True` 表示算法成功找到满足容差的解。
`message`	`'The solution converged.'`	状态描述：明确说明收敛原因或失败信息。
`status`	`1`	状态码：`1` 表示成功收敛，其他值参考文档。

算法细节字段

字段名	值示例	技术含义
`method`	`hybr`	使用的算法：此处为改进的Powell混合方法（适合中小规模问题）。
`nfev`	`9`	函数调用次数：算法计算 $f (x)$ 的总次数，反映计算成本。
`fjac`	`[[-1.000e+00]]`	雅可比矩阵：解处的近似雅可比矩阵（此处为1x1矩阵），用于评估局部曲率。
`r`	`[-1.674e+00]`	QR分解的上三角矩阵：用于算法内部迭代更新。
`qtf`	`[-2.668e-13]`	正交因子：反映梯度与残差的夹角，接近0表示迭代终止合理。

如何验证解的可靠性？

检查 success 字段：必须为 True。
确认 fun 接近0：示例中 0.000e+00 表明残差极小。
收敛消息：message 明确说明收敛，无警告。
物理意义验证：将解代入原方程检查合理性（如示例中 $- 0.739 + cos (- 0.739) \approx 0$ ）。

常见问题处理

收敛失败（success=False）：
- 调整初始猜测（x0 参数）。
- 尝试其他算法（如 method='lm' 用于非线性最小二乘）。
- 增大容差（tol 参数）。
结果不精确：减小 tol 参数（默认值为 1e-8）。

处理常见问题

收敛失败：
- 调整初始猜测：选择更接近真实解的初始值。
- 增大容差：options={'xtol': 1e-6}。
- 尝试不同方法：如 method='lm'。
数值不稳定：
- 检查目标函数是否可导或存在奇点。
- 使用更稳定的算法（如 method='hybr'）。

掌握这些字段的解读，能有效诊断数值优化问题并提升计算结果的可信度！

优化器

初步使用

函数最小值
在这里，一个函数代表一条曲线，曲线有高点和低点;
高点被称为最大值;
低点被称为最小值;
整条曲线上的最高点被称为全局最大值，其余的被称为局部最大值;

整条曲线的最低点称为全局最小值，其余的称为局部最小值.

寻找最小值
我们可以使用 scipy.optimize.minimize() 函数来最小化函数（寻找最小值）。
minimize()函数接受以下参数：

fun--个代表方程的函数。
x0--根的初始猜测
method--要使用的方法的名称。合法值:CG、BFGS、牛顿-CG、L-BFGS-B、SLSQP
caliback--每次优化迭代后调用的函数，
options--一个定义额外参数的字典。

{

"disp”:boolean -打印详细的描述

“gtol”:数字 -错误的容忍度

}

from scipy.optimize import minimize
import numpy as np
def eqn(x):
    return np.array([x[0]**2+x[0]+2])
x0=np.array([0])
mini=minimize(eqn,x0=x0,method='BFGS')
print(mini)

查看打印结果

   message: Optimization terminated successfully.
  success: True
   status: 0
      fun: 1.75
        x: [-5.000e-01]
      nit: 2
      jac: [ 0.000e+00]
 hess_inv: [[ 5.000e-01]]
     nfev: 8
     njev: 4

一、分类与核心算法

1. 无约束优化（Unconstrained Optimization）

适用场景：无限制的连续参数空间，如逻辑回归、神经网络训练。

常用算法：

方法名	特点	调用参数
`BFGS`	拟牛顿法，适用于中小规模光滑问题，需计算梯度。	`method='BFGS'`
`L-BFGS-B`	内存优化版BFGS，支持边界约束，适合大规模问题。	`method='L-BFGS-B'`
`Nelder-Mead`	单纯形法，无需梯度，适用于非光滑或高噪声问题。	`method='Nelder-Mead'`
`CG`	共轭梯度法，适合大规模稀疏问题。	`method='CG'`

示例代码（最小化Rosenbrock函数）：

from scipy.optimize import minimize

def rosen(x):
    return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)

result = minimize(rosen, x0=[0, 0], method='BFGS')
print(f"最优解: {result.x}, 迭代次数: {result.nit}")

2. 约束优化（Constrained Optimization）

适用场景：带等式或不等式约束的问题，如SVM、资源分配。

常用算法：

方法名	特点	调用参数
`SLSQP`	序列最小二乘规划，支持多类型约束。	`method='SLSQP'`
`trust-constr`	信赖域算法，高精度但计算成本较高。	`method='trust-constr'`

示例代码（带不等式约束）：

# 目标函数: min x1^2 + x2^2
# 约束: x1 + x2 >= 1
cons = {'type': 'ineq', 'fun': lambda x: x[0] + x[1] - 1}
result = minimize(lambda x: x[0]**2 + x[1]**2, x0=[0,0], 
                  constraints=cons, method='SLSQP')

3. 全局优化（Global Optimization）

适用场景：多峰函数，避免陷入局部最优，如超参数搜索。
常用算法：

方法名特点

differential_evolution 差分进化法，适用于连续、离散混合问题。

basinhopping 盆地跳跃法，结合局部搜索和随机跳跃。

方法名	特点
`differential_evolution`	差分进化法，适用于连续、离散混合问题。
`basinhopping`	盆地跳跃法，结合局部搜索和随机跳跃。

示例代码：

from scipy.optimize import differential_evolution

bounds = [(-5, 5)] * 2  # 2维问题
result = differential_evolution(rosen, bounds)
print(f"全局最优解: {result.x}")

4. 最小二乘问题（Least-Squares）

适用场景：拟合非线性方程，如曲线拟合、传感器校准。

算法：

least_squares：灵活处理边界和损失函数。

from scipy.optimize import least_squares

def model(params, t):
    A, k = params
    return A * np.exp(-k * t)

t_data = np.array([0, 1, 2, 3])
y_data = np.array([3.0, 1.5, 0.75, 0.35])
result = least_squares(lambda p: model(p, t_data) - y_data, x0=[2, 0.5])

二、算法选择决策树

问题是否有约束？
- 是 → 选择 SLSQP 或 trust-constr。
- 否 → 进入下一步。
目标函数是否光滑（可导）？
- 是 → 使用梯度类方法（BFGS, CG）。
- 否 → 使用无梯度方法（Nelder-Mead）。
是否可能存在多个局部最优？
- 是 → 全局优化（differential_evolution）。
- 否 → 继续。
数据规模？
- 小规模 → BFGS。
- 大规模 → L-BFGS-B 或 CG。

三、性能优化技巧

梯度加速：提供解析梯度（jac参数）可减少30%以上计算时间。

def rosen_der(x):
    grad = np.zeros_like(x)
    grad[:-1] = -400*x[:-1]*(x[1:]-x[:-1]**2) - 2*(1-x[:-1])
    grad[1:] += 200*(x[1:]-x[:-1]**2)
    return grad

minimize(rosen, x0=[0,0], method='BFGS', jac=rosen_der)

并行计算：对目标函数中独立计算部分使用joblib：

from joblib import Parallel, delayed

def parallel_objective(x):
    return sum(Parallel(n_jobs=4)(delayed(np.exp)(xi) for xi in x))

四、调试与问题排查

收敛失败处理：
- 调整初始值：尝试不同初始猜测。
- 增大迭代次数：options={'maxiter': 1000}。
- 放宽容差：tol=1e-4。
数值不稳定：
- 数据归一化：将输入缩放到[0,1]或标准化。
- 添加正则化：在损失函数中加入L2项。
梯度验证：

import numpy as np

def eqn(x):
    return np.array([x[0] + np.cos(x[0])])  # 单变量问题，返回数组

五、实战案例：逻辑回归参数估计

import numpy as np
from scipy.optimize import minimize

# 生成模拟数据
np.random.seed(42)
X = np.hstack([np.ones((100,1)), np.random.randn(100,2)])
y = (X @ np.array([-2, 3, -1]) + np.random.randn(100) > 0).astype(int)

# 定义损失函数和梯度
def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def loss(theta, X, y):
    p = sigmoid(X @ theta)
    return -np.mean(y * np.log(p) + (1-y) * np.log(1-p))

def grad(theta, X, y):
    p = sigmoid(X @ theta)
    return X.T @ (p - y) / len(y)

# 优化
result = minimize(loss, x0=np.zeros(3), args=(X, y), 
                  method='BFGS', jac=grad)
print(f"估计参数: {result.x.round(2)}")
# 输出: 估计参数: [-1.92  2.89 -0.97] (接近真实值 [-2, 3, -1])

总结

核心原则：根据问题类型选择算法，优先使用解析梯度加速。
扩展应用：结合 scipy 的线性代数模块 (scipy.linalg) 处理大规模问题。
进阶学习：探索 scipy.optimize 中的高级选项（如自定义回调函数、Hessian矩阵利用）。

稀疏矩阵

什么是稀疏数据
稀疏数据是指那些大部分没有使用的元素(不携带任何信息的元素)的数据，它可以是一个像这样的数组：
[1, 0, 2、0, 0, 3, 0, 0, 0，0，0, 0]
稀疏数据:是一个数据集，其中大部分项目的值为零

密集数组:是稀疏数组的反面:大部分数值不为零，
在科学计算中，当我们在线性代数中处理偏导时，我们会遇到稀疏数据，
如何处理稀疏数据
SciPy有一个模块，scipy.sparse，提供了处理稀疏数据的函数，
我们主要使用两种类型的稀疏矩阵。
CSC-压缩稀疏列。用于高效的算术，快速的列切分。
CSR-压缩稀疏行。用于快速的行切分，更快的矩阵向量乘积。

我们将在本教程中使用CSR矩阵

CSR矩阵
我们可以通过向函数scipy.sparse.csr_matrix()传递一个array来创建CSR矩阵。

arr2=np.array([[0,0,0],[0,0,1],[1,0,2]])
print(arr2)
#转化为csr
csr_arr=csr_matrix(arr2)
print(csr_arr)
'''
  (2, 0)	1
  (1, 2)	1
  (2, 2)	2
'''
# 计算非零元素个数
csr_arr=csr_matrix(arr2)
print(csr_arr.count_nonzero())
# 去除矩阵中的0条目
csr_arr=csr_matrix(arr2)
csr_arr.eliminate_zeros()
print(csr_arr)
# 去除重复条目
csr_arr=csr_matrix(arr2)
csr_arr.sum_duplicates()
print(csr_arr)
# 转化为csc矩阵
csr_arr=csr_matrix(arr2)
print(csr_arr.tocsc())

图形

使用图形
图是一种重要的数据结构。
SciPy为我们提供了scipy.sparse.csgraph模块来处理这种数据结构。
毗连矩阵
邻接矩阵是一个n*n矩阵，其中n是图中元素的数量。而数值代表元素之间的联系。

例子：

对于这样一个图，有元素A、B和C，其连接是：

A和B是以权重1连接的。
A和C以权重2相连
C和B没有连接。

邻接矩阵看起来像这样：

ABC

A:[0 1 2]

B:[1 0 0]

C:[2 0 0]

下面是一些最常用的处理邻接矩阵的方法。

连通区域

例如上面的ABS就构成一个联通区域，此时如果又有一个单独的D，或者D和E相连，那么D或者D和E又构成一个新的联通区域。
用connected_components()方法找到所有的连通区域。

import numpy as np 
from scipy.sparse import csr_matrix
from scipy.sparse.csgraph import connected_components
arr=np.array([
    [0,1,2],
    [1,0,0],
    [1,0,0]
])
graph=csr_matrix(arr)
print(graph)
# 打印连通域个数
print(connected_components(graph))
'''
  (0, 1)	1
  (0, 2)	2
  (1, 0)	1
  (2, 0)	1
  连通域个数,数组（该连通域内元素个数及维度，0代表1维）
(1, array([0, 0, 0]))
'''

Dijkstra
使用Dijkstra方法来寻找图中从一个元素到另一个元素的最短路径它需要以下参数：

return_predecessors:布尔值(返回整个路径，否则为假)
indices:元素的索引，只返回该元素的所有路径
limit:路径的最大权重

from scipy.sparse.csgraph import dijkstra
print(dijkstra(graph,indices=0))
#[0. 1. 2.]A到A距离为0，到B距离为1，到C距离为2

Floyd Warshall
使用foyd_warshall()方法来寻找所有元素对之间的最短路径

from scipy.sparse.csgraph import floyd_warshall
print(floyd_warshall(graph))
'''
[[0. 1. 2.]
 [1. 0. 3.]
 [1. 2. 0.]]
'''

Bellman Ford
bellman_ford()方法也可以找到所有元素对之间的最短路径，但这个方法也可以处理负的权重

from scipy.sparse.csgraph import bellman_ford
print(bellman_ford(graph,indices=0))

from scipy.sparse.csgraph import bellman_ford
print(bellman_ford(graph,indices=0))
#[0. 1. 2.]

深度优先
depth_first_order()方法返回一个节点的深度优先遍历.

遍历图形的起始元素:

from scipy.sparse.csgraph import depth_first_order
print(depth_first_order(graph,0))
#(array([0, 1, 2]), array([-9999,     0,     0]))【A的前一个节点，不存在，所以显示-9999，B的前一个节点是A，所以显示0，B的前一个节点也是A，也显示0】

广度优先
breadth_first_order()方法返回一个节点的广度优先遍历。

遍历图形的起始元素。

from scipy.sparse.csgraph import breadth_first_order
print(breadth_first_order(graph,0))
#(array([0, 1, 2]), array([-9999,     0,     0]))

空间数据

使用空间数据
空间数据是指在一个几何空间中表示的数据。例如，坐标系上的点。
我们在许多任务中处理空问数据问题，
例如，寻找一个点是否在一个边界内。
ScIPy为我们提供了scipy.spatial模块，它具有处理空间数据的功能。
三角测量
多边形的三角测量是将多边形划分为多个三角形，我们可以通过这些三角形计算出多边形的面积。

带点三角剖分是指创建由三角形组成的曲面，其中所有给定的点都在该曲面中任何一个三角形的至少一个顶点上。(就是把所有点都用上，任意一个点，至少是一个三角形的顶点)

通过点来生成三角形的方法是Delaunay()。

import numpy as np
import matplotlib.pyplot as plt
from scipy.spatial import Delaunay
points=np.array([
    [2,4],
    [3,4],
    [3,0],
    [2,2],
    [4,1]
])
simplices=Delaunay(points).simplices
print(simplices)
# 切片操作：
# points[:,0] → 取所有行的第0列 → [2,3,3,2,4]
# points[:,1] → 取所有行的第1列 → [4,4,0,2,1]
plt.triplot(points[:,0],points[:,1],simplices)
plt.scatter(points[:,0],points[:,1],color='r')
plt.show()

凸面体
凸面体是覆盖所有给定点的最小的多边形。
便用ConvexHul()方法来创建一个凸面体。

from scipy.spatial import ConvexHull
points=np.array([
    [2,4],
    [3,4],
    [3,0],
    [2,2],
    [4,1],
    [1,2],
    [5,0],
    [3,1],
    [1,2],
    [0,2]
])

simp=ConvexHull(points).simplices
print(simp)
'''
[[0 9]
 [1 6]
 [1 0]
 [2 9]
 [2 6]]
'''
plt.scatter(points[:,0],points[:,1])
for s in simp:
    plt.plot(points[s,0],points[s,1])
plt.show()

KDTrees
KDTrees是一种为最近的邻居查询而优化的数据结构
例如，在一个点的集合中，使用KDTree我们可以有效地询问哪些点离某个给定的点最近

KDTree()方法返回一个KDTree对象
query()方法返回与最近的邻居的距离和邻居的位置。

from scipy.spatial import KDTree
points=np.array([[-2,-3],[2,3],[-2,3],[2,-3]])
kdtree=KDTree(points)
res=kdtree.query((1,1))
print(res)#(2.23606797749979, 1)距离点（1,1）最近的点是points[1],最短距离是：2.23606797749979
plt.scatter(points[:,0],points[:,1])
plt.scatter(1,1)
plt.show()

距离矩阵
在数据科学中，有许多距离度量用于寻找两点之间的各种类型的距离，欧氏距离、余弦距离等。详参：常见距离度量公式

两个向里之间的距离可能不仅仅是它们之间的直线长度，它也可以是它们与原点之间的角度，或者需要的单位步数等。

许多机器学习算法的性能在很大程度上取决于距离矩阵。例如："K邻近"或"K平均值"等

让我们来看看一些距离矩阵
欧氏距离 Euclidean Distance
找到给定点之间的欧氏距离。

from scipy.spatial.distance import euclidean
p1=(1,0)
p2=(10,2)
res=euclidean(p1,p2)
print(res)#9.219544457292887

城市街区距离(曼哈顿距离)
在4个方向上计算的距离。
例如，我们只能移动:向上、向下、向右或向左，而不是斜向移动。

from scipy.spatial.distance import cityblock
p1=(1,0)
p2=(10,2)
res=cityblock(p1,p2)
print(res)#11

余弦距离

⼏何中，夹⻆余弦可⽤来衡量两个向量⽅向的差异；机器学习中，借⽤这⼀概念来衡量样本向量之间的差异。

from scipy.spatial.distance import cosine
p1=(1,0)
p2=(10,2)
res=cosine(p1,p2)
print(res)#0.019419324309079777

汉明距离Hamming距离

两个等⻓字符串s1与s2的汉明距离为：将其中⼀个变为另外⼀个，所需要作的最⼩字符替换次数。

例如:

The Hamming distance between "1011101" and "1001001" is 2.

The Hamming distance between "2143896" and "2233796" is 3.

The Hamming distance between "toned" and "roses" is 3.

是指两个比特有差异的比特的比例。
它是衡量二进制序列距离的一种方法。

from scipy.spatial.distance import hamming
p1=(True,False,False)
p2=(True,False,True)
res=hamming(p1,p2)
print(res)#0.3333333333333333=有差异的位置数量除以总位置=1/3

MatLab

使用Matlab数组
我们知道NumPy为我们提供了以Python的可读格式来保存数据的方法。但是SciPy也为我们提供了与Matlab的互操作性。SciPy为我们提供了scipy.io模块，它具有与Matlab数组一起工作的功能。
以Matlab格式导出数据
savemat()函数允许我们以Matlab格式导出数据。
该方法需要以下参数：

filename：用于保存数据的文件名。
mdict：一个包含数据的字典。
do_compression：一个布尔值，指定是否对结果进行压缩。默认为假。

from scipy import io
import numpy as np
arr=np.arange(1,10)
io.savemat(r'D:\data\jupyter\SciPy\test.mat',{'vec':arr})

从Matlab格式导入数据
loadmat()函数允许我们从Matlab文件中导入数据。

该函数需要一个必要的参数。

flename-保存数据的文件名

它将返回一个结构化数组，其键是变量名称，相的值是变量值。

mydata=io.loadmat(r'D:\data\jupyter\SciPy\test.mat')
print(mydata)#{'__header__': b'MATLAB 5.0 MAT-file Platform: nt, Created on: Wed May 21 16:03:03 2025', '__version__': '1.0', '__globals__': [], 'vec': array([[1, 2, 3, 4, 5, 6, 7, 8, 9]])}
# 从上述打印结果可知，我们存储时数组原本是一维的，但是在提取时变成了2维的，我们可以添加参数解决该问题
mydata=io.loadmat(r'D:\data\jupyter\SciPy\test.mat',squeeze_me=True)#'vec': array([1, 2, 3, 4, 5, 6, 7, 8, 9]
print(mydata)

插值法

什么是插值法?
插值法是一种在给定的点之间生成点的方法。

例如:对于点1和2，我们可以通过插值找到点1.33和1.66。

插值法有很多用途，在机器学习中，我们经常处理数据集中的缺失数据，内插法经常被用来替代这些值。

这种填补数值的方法被称为归因法。
除了估算，内插法还经常用于我们需要平滑数据集中的离散点的地方。
如何在SciPy中实现它?
SciPy为我们提供了-个叫scipy.interpolate的模块，它有许多处理插值的函数。
一维插值
函数interp1d()是用来插值一个有1个变量的分布
它接收x和y点并返回一个可调用的函数，可以用新的x来调用并返回相应的y。

from scipy.interpolate import interp1d
import numpy as np
x=np.arange(10)
y=x**2+np.sin(x)+1
fun=interp1d(x,y)
z=np.arange(2.1,3,0.1)
newarr=fun(z)

print(x)#[0 1 2 3 4 5 6 7 8 9]
print(y)#[ 1. 2.84147098  5.90929743 10.14112001 16.2431975  25.04107573 36.7205845  50.6569866  65.98935825 82.41211849]
print(z)#[2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9]
print(newarr)#[6.33247968 6.75566194 7.1788442  7.60202646 8.02520872 8.44839098 8.87157323 9.29475549 9.71793775]

样条插值
在一维插值中，点被拟合为一条曲线，而在样条插值中，点被拟合为一个用多项式定义的片状函数，称为样条.

UnivariateSpline()函数接收x和y并产生一个可调用的函数，可以用新的x调用。

from scipy.interpolate import UnivariateSpline
import numpy as np
x=np.arange(10)
y=x**2+np.sin(x)+1
fun=UnivariateSpline(x,y)
z=np.arange(2.1,3,0.1)
newarr=fun(z)

print(x)#[0 1 2 3 4 5 6 7 8 9]
print(y)[ 1. 2.84147098  5.90929743 10.14112001 16.2431975  25.04107573 36.7205845  50.6569866  65.98935825 82.41211849]
print(z)#[2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9]
print(newarr)[5.62826474 6.03987348 6.47131994 6.92265019 7.3939103  7.88514634 8.39640439 8.92773053 9.47917082]

径向基函数的插值
径向基函数是一个对应于固定参考点定义的函数。
Rbf()函数也以xs和ys为参数，并产生一个可调用的函数，可以用新的xs调用，

from scipy.interpolate import Rbf
import numpy as np
x=np.arange(10)
y=x**2+np.sin(x)+1
fun=Rbf(x,y)
z=np.arange(2.1,3,0.1)
newarr=fun(z)

print(x)#[0 1 2 3 4 5 6 7 8 9]
print(y)#[ 1. 2.84147098  5.90929743 10.14112001 16.2431975  25.04107573 36.7205845  50.6569866  65.98935825 82.41211849]
print(z)#[2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9]
print(newarr)#[6.25748981 6.62190817 7.00310702 7.40121814 7.8161443  8.24773402 8.69590519 9.16070828 9.64233874]

统计学-假设检验

统计学意义

在统计学中，统计学意义意味着产生的结果背后有一个原因，它不是随机产生的，也不是偶然的。

想象你发现一种新药能让感冒好得更快。统计学意义就是判断这种效果是真实存在，还是纯属运气。

如果结果有统计学意义，说明数据足够可信，不是随机出现的偶然现象。

统计学意义测试

SciPy为我们提供了一个叫scipy.stats的模块，它有执行统计学意义测试的函数。
下面有一些技术和关键词，在进行这种测试时很重要：

二、核心概念拆解

1. 假设（Hypothesis）

定义：对总体特征的猜测，比如“新药平均缩短感冒时间2天”。
例子：
- “班级平均分 = 75分” → 这是一个假设。
- “新广告点击率 > 旧广告” → 这也是一个假设。

2. 零假设（Null Hypothesis, H₀）（空白假说）

定义：默认的“无效果”假设，认为观察到的差异是随机波动。观察结果没有稳定的意义.
例子：
- 新药无效（感冒时间与旧药无差异）。
- 广告点击率无变化。

3. 备择假设（Alternative Hypothesis, H₁）(替代假说)

定义：与零假设对立，认为差异是真实存在的。它假定观察结果是由于某种原因造成的。
例子：
- 新药有效（感冒时间缩短）。
- 广告点击率提升。

4. 单尾检验 vs 双尾检验

类型	检验方向	适用场景	例子	备注
单尾检验	只检测一个方向（更大或更小）	明确预测变化方向时	“新药是否缩短感冒时间？”	当我们的假设只测试一边的数值时，它被称为"单尾测试"例子。 "平均数等于k"，我们可以有另一个假设: "平均数小于k"，或者"平均数大于k"
双尾检验	检测两个方向（是否有差异）	仅关心差异是否存在，不限定方向	“新药是否改变感冒时间？”	当我们的假设是对两边的数值进行检验。例： "平均数等于k"，我们可以有另一个假设："平均数不等于K” 在这种情况下，平均数小于，或大于k，两边都要检查。

5. 显著性水平（α值）

定义：判断结果是否显著的门槛，常用值为0.01、0.05、0.1。
比喻：考试及格线（如α=0.05相当于60分，低于它则“不及格”，拒绝零假设）。
作用：控制第一类错误（误判有效）的概率。

6. P值（P-value）

定义：数据支持零假设的概率。
解读：
- P值小（如P=0.01）：数据与零假设矛盾，支持备择假设。
- P值大（如P=0.3）：数据与零假设一致，无法拒绝H₀。
决策规则：
若P ≤ α → 拒绝零假设（结果显著）
若P > α → 不拒绝零假设（结果不显著）

P值告诉我们数据实际上有多接近极端。P值和a值进行比较以确定统计学意义。如果P值<=a，我们拒绝无效假设，并说数据具有统计学意义。

正确比喻

α值（显著性水平）：类似考试及格线（例如60分）。
- 作用：设定拒绝零假设的门槛。
P值：类似你的实际考试分数。

为什么P值小反而要拒绝零假设？

P值的本质：是“零假设成立时，当前数据出现的概率”。
- P值越小 → 数据与H₀矛盾的证据越强。
- 例如P=0.01表示：如果H₀为真，只有1%的概率观测到当前数据。
结论：P值小说明数据更支持备择假设（H₁）。

α=0.05的严格性

若α=0.05，相当于允许5%的误判风险（即H₀为真时错误拒绝它）。
若α=0.01，则标准更严格（误判风险1%）。

三、假设检验的5步流程

提出问题：明确研究目标（如“新药是否有效？”）。
设立假设：
- H₀：新药无效（感冒时间均值 = 旧药均值）。
- H₁：新药有效（感冒时间均值 < 旧药均值）→ 单尾检验。
选择检验方法：根据数据类型选择t检验、卡方检验等。
计算P值：用统计工具（如SciPy）计算数据支持H₀的概率。
得出结论：
- P ≤ α → 拒绝H₀，支持H₁（有效）。
- P > α → 不拒绝H₀（无效）。

四、案例

某公司宣称其能量饮料平均提神时长为120分钟。你随机抽取10名用户测试，得到时长数据：
[118, 124, 115, 122, 119, 126, 117, 121, 123, 120]
检验该公司宣传是否属实（α=0.05）。

from scipy import stats

# 样本数据
sample = [118, 124, 115, 122, 119, 126, 117, 121, 123, 120]

# 单样本t检验（双尾检验，H₀: 均值=120，H₁: 均值≠120）
t_stat, p_value = stats.ttest_1samp(sample, popmean=120)

print(f"t统计量: {t_stat:.2f}")
print(f"P值: {p_value:.3f}")

# 决策
alpha = 0.05
if p_value <= alpha:
    print("拒绝零假设：实际平均时长 ≠ 120分钟")
else:
    print("无法拒绝零假设：数据支持平均时长为120分钟")

t统计量: 0.47
P值: 0.651
无法拒绝零假设：数据支持平均时长为120分钟

解读

P值=0.467 > α=0.05 → 样本数据不足以推翻“平均时长为120分钟”的假设。

五、常见误区

P值不是效果大小：P值小只说明差异显著，不意味差异幅度大。
- 正确做法：报告置信区间（如“平均缩短1.2小时，95% CI [0.8, 1.6]”）。
不拒绝H₀ ≠ 接受H₀：只能说明“证据不足”，而非“证明H₀正确”。
盲目追求P < 0.05：可能导致假阳性，需结合业务意义判断。

六、总结

核心口诀：
- 零假设是“没效果”，备择假设是“有原因”。
- P值小于α值，拒绝零假设。
工具选择：
- 均值对比 → t检验
- 比例对比 → 卡方检验
- 多组比较 → ANOVA

T-检验

T检验用于确定两个变量的平均值之间是否存在显著的差异，并让我们知道它们是否属于同一分布。

它是一个双尾检验。

from scipy.stats import ttest_ind
import numpy as np

v1=np.random.normal(size=100)
v2=np.random.normal(size=100)

res=ttest_ind(v1,v2)
print(res)#TtestResult(statistic=-0.37781208560850904, pvalue=0.7059748953051883, df=198.0)

一、T检验是什么？

T检验用于比较均值差异，判断两组数据是否存在统计学显著差异。其核心假设是数据服从正态分布或近似正态分布（尤其是小样本时）。

二、T检验的三种类型

类型	应用场景	假设条件
单样本T检验	检验样本均值是否等于已知总体均值。	数据独立且近似正态分布。
独立双样本T检验	比较两个独立样本的均值差异（如男女身高差异）。	两样本独立、正态分布且方差齐性。
配对样本T检验	比较同一组对象两次测量的差异（如用药前后对比）。	差值数据近似正态分布。

三、T检验公式与原理

1. 单样本T检验

$x ˉ$ ：样本均值
$μ_{0}$ ：假设的总体均值
$s$ ：样本标准差
$n$ ：样本量

2. 独立双样本T检验（假设方差齐性）

$s_{p}$ ：合并标准差
$n_{1}, n_{2}$ ：两样本量

3. 配对样本T检验

$d ˉ$ ：差值的均值
$s_{d}$ ：差值的标准差

四、Python实战示例

1. 单样本T检验

from scipy import stats
import numpy as np

# 样本数据：某班级数学成绩（假设总体均值为75）
scores = np.array([72, 78, 80, 68, 75, 71, 76, 74, 77, 73])
mu = 75  # 总体均值假设

# 执行单样本T检验
t_stat, p_value = stats.ttest_1samp(scores, mu)

print(f"t统计量: {t_stat:.2f}")
print(f"P值: {p_value:.4f}")

alpha = 0.05
if p_value < alpha:
    print("拒绝H₀：班级平均分 ≠ 75")
else:
    print("无法拒绝H₀：班级平均分可能为75")

t统计量: -0.53
P值: 0.6075
无法拒绝H₀：班级平均分可能为75

2. 独立双样本T检验

# 两组独立数据（如A/B测试结果）
group_A = np.array([82, 85, 88, 80, 79])
group_B = np.array([75, 78, 80, 73, 72])

# 方差齐性检验（Levene检验）
_, p_levene = stats.levene(group_A, group_B)
if p_levene > 0.05:
    # 方差齐性时使用独立双样本T检验
    t_stat, p_value = stats.ttest_ind(group_A, group_B)
else:
    # 方差不齐时使用Welch校正T检验
    t_stat, p_value = stats.ttest_ind(group_A, group_B, equal_var=False)

print(f"t统计量: {t_stat:.2f}")
print(f"P值: {p_value:.4f}")

if p_value < alpha:
    print("拒绝H₀：两组均值存在显著差异")
else:
    print("无法拒绝H₀：两组均值可能相同")

t统计量: 3.22
P值: 0.0122
拒绝H₀：两组均值存在显著差异

3. 配对样本T检验

# 同一组患者治疗前后的血压数据
before = np.array([140, 138, 135, 142, 145])
after = np.array([132, 135, 130, 138, 140])

# 执行配对T检验
t_stat, p_value = stats.ttest_rel(before, after)

print(f"t统计量: {t_stat:.2f}")
print(f"P值: {p_value:.4f}")

if p_value < alpha:
    print("拒绝H₀：治疗前后血压有显著变化")
else:
    print("无法拒绝H₀：治疗可能无效")

t统计量: 5.98
P值: 0.0039
拒绝H₀：治疗前后血压有显著变化

五、结果解读

t统计量：绝对值越大，差异越显著。
P值：
- P < α（如0.05）→ 拒绝H₀，差异显著。
- P ≥ α → 无法拒绝H₀，但不证明H₀为真。

六、适用条件与注意事项

条件	处理建议
数据非正态	使用非参数检验（如Mann-Whitney U检验）。
小样本（n < 30）	必须检查正态性（QQ图或Shapiro-Wilk检验）。
方差不齐	使用Welch校正的T检验（`equal_var=False`）。

七、常见误区

误用独立检验处理配对数据：
- 错误：将治疗前后的数据视为独立两组。
- 正确：使用配对T检验，考虑个体差异。
忽略正态性检验：
- 小样本非正态数据使用T检验会导致结果偏差。
混淆显著性与实际意义：
- 即使差异显著（P小），也可能因效应量过小而无实际价值。

八、T检验 vs Z检验

检验	适用场景	核心区别
T检验	样本量小（n < 30）且总体方差未知	使用样本标准差替代总体标准差。
Z检验	样本量大（n ≥ 30）或总体方差已知	直接使用总体标准差或大样本近似。

九、总结

核心公式：均值差异 / 标准误。
使用场景：比较均值差异，尤其是小样本数据。
实践口诀：
- 正态分布用T检验，非正态改用非参数。
- 独立数据看方差，配对数据算差值。

通过以上步骤，你可以轻松掌握T检验的逻辑与应用！ 📈

Z检验（Z-Test）

一、Z检验是什么？

Z检验是一种基于正态分布的假设检验方法，用于判断样本均值与总体均值或两总体均值之间的差异是否具有统计学意义。其核心场景是：

总体方差已知（即便样本量小）。
样本量足够大（通常n ≥ 30，根据中心极限定理近似正态分布）。

二、核心公式

1. 单样本Z检验

$x ˉ$ ：样本均值
$μ_{0}$ ：假设的总体均值
$σ$ ：总体标准差（已知）
$n$ ：样本量

2. 双样本Z检验（比较两独立总体均值）

$σ_{1}, σ_{2}$ ：两总体的标准差（已知）
$n_{1}, n_{2}$ ：两样本量

三、适用场景

场景	方法选择	示例
大样本均值检验	总体方差未知但样本量大（用样本方差替代σ）	调查100人的平均收入是否等于5000元
已知总体方差	小样本但总体方差已知	工厂已知产品重量标准差，检验新批次均值

四、检验步骤

提出假设：
- 单样本： $H_{0} : μ = μ_{0}$ vs $H_{1} : μ\neq μ_{0}$ （双尾）或 $H_{1} : μ > μ_{0}$ （单尾）。
- 双样本： $H_{0} : μ_{1} = μ_{2}$ vs $H_{1} : μ_{1} μ_{2}$ 。
计算Z值：根据公式计算统计量。
确定临界值：根据显著性水平α（如0.05）查Z表或计算临界值。
决策：
- 若|Z| ≥ Z临界值 → 拒绝H₀（差异显著）。
- 若|Z| < Z临界值 → 无法拒绝H₀。

五、Python代码示例

1. 单样本Z检验（手动计算）

import numpy as np
from scipy.stats import norm

# 样本数据：某班级数学成绩（假设总体均值μ₀=75，总体标准差σ=5）
scores = np.array([72, 78, 80, 68, 75, 71, 76, 74, 77, 73])
mu_0 = 75
sigma = 5  # 已知总体标准差
n = len(scores)
sample_mean = np.mean(scores)

# 计算Z值
Z = (sample_mean - mu_0) / (sigma / np.sqrt(n))
print(f"Z统计量: {Z:.2f}")

# 计算P值（双尾检验）
p_value = 2 * (1 - norm.cdf(abs(Z)))
print(f"P值: {p_value:.4f}")

alpha = 0.05
if p_value < alpha:
    print("拒绝H₀：班级平均分 ≠ 75")
else:
    print("无法拒绝H₀：数据支持平均分为75")

2. 双样本Z检验（使用statsmodels库）

import statsmodels.stats.weightstats as st

# 两组独立样本数据（已知总体标准差σ1=2, σ2=3）
group1 = np.array([82, 85, 88, 80, 79])
group2 = np.array([75, 78, 80, 73, 72])
sigma1, sigma2 = 2, 3

# 计算Z值与P值
Z_stat, p_value = st.ztest(
    x1=group1, x2=group2, 
    value=0,  # H₀: μ1 - μ2 = 0
    alternative='two-sided',  # 双尾检验
    ddof1=0, ddof2=0,  # 使用总体方差（已知时无需自由度校正）
    sigma1=sigma1, sigma2=sigma2
)

print(f"Z统计量: {Z_stat:.2f}, P值: {p_value:.4f}")

六、结果解读

Z值：绝对值越大，样本均值与假设均值的差异越显著。
P值：
- P < α（如0.05）→ 拒绝H₀，差异显著。
- P ≥ α → 无法拒绝H₀，但不证明H₀为真。

七、Z检验 vs T检验

检验	总体方差	样本量	分布	应用场景
Z检验	已知或大样本近似	大样本（n ≥ 30）	标准正态分布	已知σ或大样本均值检验
T检验	未知	小样本（n < 30）	t分布（自由度）	小样本且σ未知时均值检验

八、注意事项

正态性假设：
- 小样本需严格满足正态分布，大样本可依赖中心极限定理。
总体方差未知时的替代：
- 大样本中可用样本方差 $s^{2}$ 近似替代总体方差 $σ^{2}$ 。
单尾 vs 双尾：
- 单尾检验需明确方向（如H₁: μ > μ₀），双尾检验更保守。

九、总结

核心公式：均值差异 / 标准误（基于已知σ或大样本）。
使用场景：已知总体方差或大样本下的均值比较。
实践口诀：
- 方差已知用Z检验，大样本近似更简便。
- 若遇小样本未知σ，T检验才是正确选。

通过以上步骤，你可以轻松掌握Z检验的逻辑与应用！ 📈

卡方检验（Chi-Square Test）

一、卡方检验是什么？

卡方检验用于分析分类数据之间的关联性或适配性，核心是判断观测频数与理论频数之间的差异是否由随机因素引起。主要分为两类：

拟合优度检验：检验样本是否符合某个理论分布（如骰子是否公平）。
独立性检验：检验两个分类变量是否独立（如性别与饮食习惯是否相关）。

二、适用场景

检验类型	问题示例	数据形式
拟合优度检验	骰子是否公平？	单变量的观测频数 vs 理论频数
独立性检验	性别与饮食偏好是否相关？	列联表（如2x2表格）

三、核心公式

卡方统计量（ $χ^{2}$ ）计算公式：

$O_{i}$ ：观测频数（实际计数）。
$E_{i}$ ：理论频数（假设成立时的预期计数）。
自由度（df）：
- 拟合优度检验： $df = 类别数 - 1$
- 独立性检验： $df = (行数 - 1) \times (列数 - 1)$

四、检验步骤

1. 拟合优度检验（以骰子公平性为例）

问题：抛骰子60次，检验各面出现次数是否均匀。
观测频数： $6, 10, 9, 8, 12, 15$ （6个面的出现次数）。
理论频数：均匀分布时，每面期望频数
计算卡方值：

自由度： $df = 6 - 1 = 5$
查表或计算P值：若显著性水平α=0.05，临界值
结论： $χ^{2} = 5.0 < 11.07$ → 无法拒绝H₀，骰子可能公平。

2. 独立性检验（以性别与饮食偏好为例）

列联表数据：

素食非素食合计

男性 20 30 50

女性 25 25 50

合计 45 55 100
计算理论频数（假设性别与饮食独立）：
- 男性素食的理论频数：
- 其他单元格同理计算。
计算卡方值：
自由度： $df = (2 - 1) (2 - 1) = 1$
临界值：
结论： $χ^{2} = 1.02 < 3.84$ → 无法拒绝H₀，性别与饮食可能独立。

	素食	非素食	合计
男性	20	30	50
女性	25	25	50
合计	45	55	100

五、Python代码示例

1. 拟合优度检验

from scipy.stats import chisquare

# 观测频数与理论频数（假设骰子公平）
observed = [6, 10, 9, 8, 12, 15]
expected = [10] * 6  # 每面期望频数10

chi2_stat, p_value = chisquare(f_obs=observed, f_exp=expected)
print(f"卡方统计量: {chi2_stat:.2f}, P值: {p_value:.4f}")

卡方统计量: 5.00, P值: 0.4159

2. 独立性检验

from scipy.stats import chi2_contingency

# 列联表数据
data = [[20, 30],
        [25, 25]]

chi2_stat, p_value, df, expected = chi2_contingency(data)
print(f"卡方统计量: {chi2_stat:.2f}, P值: {p_value:.4f}, 自由度: {df}")

六、注意事项

期望频数限制：
- 每个单元格的期望频数应≥5，否则需合并类别或使用Fisher精确检验。
结果解读：
- 拒绝H₀仅说明存在关联，不表示因果关系。
- 可进一步计算效应量（如Cramer's V）衡量关联强度。
误区：
- 误用于连续型数据（需先分箱处理）。
- 忽略自由度计算错误。

七、总结

核心公式：
使用场景：分类数据适配性检验或变量独立性分析。
实践口诀：
- 频数对比卡方算，期望太低需合并。
- 若P小于α值，拒绝原假设关联显。

通过以上步骤，你可以轻松掌握卡方检验的应用与解读！ 📊

KS-检验

该函数将待测值和CDF作为两个参数
CDF可以是一个字符串，也可以是一个返回概率的可调用函数，它可以作为一个单尾或双尾测试使用。
默认情况下，它是双尾的。我们可以将参数替代作为一个字符串，即双侧、较小或较大中的一个。

一、KS检验是什么？

KS检验（Kolmogorov-Smirnov Test）是一种非参数检验方法，用于：

单样本检验：判断样本数据是否服从某个理论分布（如正态分布、指数分布）。
双样本检验：比较两个独立样本是否来自同一分布。

二、核心思想

零假设（H₀）：样本服从指定分布（单样本）或两样本来自同一分布（双样本）。
备择假设（H₁）：样本不服从指定分布或两样本分布不同。
检验统计量（D）：两个累积分布函数（CDF）之间的最大垂直距离。

三、检验统计量计算

单样本检验：比较样本经验分布 $F_{n} (x)$ 与理论分布 $F (x)$ 。

双样本检验：比较两个样本的经验分布 $F_{n} (x)$ 和 $G_{m} (x)$ 。

四、适用场景

场景	方法对比
单样本分布检验	替代卡方检验（无需分箱，适合连续型数据）
双样本分布比较	比t检验更通用（不假设正态性或同方差）

五、Python实现

1. 单样本KS检验（检验是否服从正态分布）

from scipy import stats
import numpy as np

# 生成样本数据（假设真实分布为N(0,1)）
np.random.seed(42)
sample = np.random.normal(loc=0, scale=1, size=100)

# 执行KS检验（检验样本是否服从N(0,1)）
d_statistic, p_value = stats.kstest(sample, 'norm', args=(0, 1))  # args=(均值, 标准差)

print(f"KS统计量D: {d_statistic:.4f}")
print(f"P值: {p_value:.4f}")

# 判断显著性（α=0.05）
alpha = 0.05
if p_value < alpha:
    print("拒绝H₀：样本不服从正态分布N(0,1)")
else:
    print("无法拒绝H₀：样本可能服从N(0,1)")

KS统计量D: 0.1036
P值: 0.2181
无法拒绝H₀：样本可能服从N(0,1)

2. 双样本KS检验（比较两样本分布）

# 生成两个样本（假设来自不同分布）
sample1 = np.random.normal(0, 1, 100)
sample2 = np.random.normal(0.5, 1, 100)

# 执行双样本KS检验
d_statistic, p_value = stats.ks_2samp(sample1, sample2)

print(f"KS统计量D: {d_statistic:.4f}")
print(f"P值: {p_value:.4f}")

if p_value < alpha:
    print("拒绝H₀：两样本分布不同")
else:
    print("无法拒绝H₀：两样本可能同分布")

KS统计量D: 0.3000
P值: 0.0002
拒绝H₀：两样本分布不同

六、结果解读

KS统计量（D）：值域为[0,1]，D越大，分布差异越明显。
P值：
- P < α（如0.05）→ 拒绝H₀，认为分布不同。
- P ≥ α → 无法拒绝H₀，但不能证明分布相同。

七、优缺点对比

优点	缺点
非参数方法，无需假设数据分布	对样本量敏感（大样本易拒绝H₀）
适用于任何连续分布	对分布中心差异敏感，尾部差异不敏感
无需数据分箱（优于卡方检验）	双样本检验要求样本独立

八、常见问题

1. KS检验与卡方检验的区别？

KS检验：直接比较累积分布，适合连续数据，无需分箱。
卡方检验：基于分箱频数，适合离散数据，依赖分箱方式。

2. 样本量多大时KS检验可靠？

单样本：至少20个数据点。
双样本：两组样本量相近时效果更好。

3. 如何选择单尾或双尾检验？

KS检验默认是双尾检验（检测任何方向的分布差异）。

九、总结

核心公式：D = 最大分布差异距离。
使用场景：验证数据分布假设或比较两组数据分布。
实践建议：结合P值和效应量（D值）综合判断，避免仅依赖P值。

通过以上内容，你可以轻松上手KS检验，快速判断数据分布特征！ 📊

数据的统计描述

为了查看一个数组中的数值摘要，我们可以使用describe()函数。它返回以下描述：

观测值的数量(nobs)
最小值和最大值=minmax
平均值
方差
偏度
峰度

from scipy.stats import describe
import numpy as np

v=np.random.normal(size=100)
res=describe(v)
print(res)

DescribeResult(nobs=100, minmax=(-2.123895724309807, 2.1898029332176723), mean=0.10684012069730453, variance=0.7816353144964703, skewness=0.19663344250390627, kurtosis=-0.23497952015548895)

正态性测试(偏度和峰度)

正态性检验是基于偏度和峰度的。
normaltest()函数返回无效假设的p值。
"X来自于正态分布"

偏度

对数据对称性的衡量
对于正态分布，它是0.
如果它是负的，意味着数据向左倾斜。
如果它是正数，意味着数据向右倾斜。

峰度

衡量数据是重尾还是轻尾的正态分布，
正的峰度意味着重尾、
负的峰度意味着轻度尾巴。

from scipy.stats import skew,kurtosis
import numpy as np
v=np.random.normal(size=100)
print(skew(v))#0.254753238065515
print(kurtosis(v))#-0.3090503920993788

正态分布

norm.pdf()概率密度函数

scipy.stats.norm.pdf() 用于计算正态分布（高斯分布）在指定位置的概率密度值。

一、函数定义

pdf(x, loc=0, scale=1)

作用：计算正态分布在 x 处的概率密度函数（PDF）值。
参数：
- x：要计算密度的点（支持标量或数组）。
- loc：正态分布的均值（μ，默认为0）。
- scale：正态分布的标准差（σ，默认为1，需 > 0）。
返回：概率密度值（标量或数组）。

二、核心公式

正态分布的概率密度函数公式：

三、示例代码

1. 标准正态分布（μ=0, σ=1）

计算 x=0 处的密度值：

from scipy.stats import norm

# 标准正态分布（默认参数）
density = norm.pdf(0)  # loc=0, scale=1
print(f"PDF at x=0: {density:.4f}")  # 输出：0.3989

2. 自定义均值和标准差

计算均值为5、标准差为2的正态分布在 x=5 处的密度值：

density = norm.pdf(5, loc=5, scale=2)
print(f"PDF at x=5: {density:.4f}")  # 输出：0.1995

3. 批量计算多个点

计算 x=[-1, 0, 1] 处的密度值：

x = [-1, 0, 1]
density = norm.pdf(x)
print(f"PDF at x={x}: {density.round(4)}")  # 输出：[0.242 0.3989 0.242]

4. 绘制正态分布曲线

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm
# 生成数据
mu, sigma = 0, 1
x = np.linspace(-4, 4, 100)
y = norm.pdf(x, loc=mu, scale=sigma)

# 绘图
plt.plot(x, y, 'b-', label=f'N({mu}, {sigma}^2)')
plt.title('Normal Distribution PDF')
plt.xlabel('x')
plt.ylabel('Density')
plt.legend()
plt.show()

四、常见问题

1. `loc` 和 `scale` 参数的作用？

loc 控制分布的中心位置（均值）。
scale 控制分布的宽度（标准差越大，数据越分散）。

2. 与非标准正态分布的关系？

若 X 服从 N(μ, σ²)，则标准化变量服从标准正态分布 N(0,1)。

3. 如何计算累积概率？

使用 norm.cdf(x, loc, scale) 计算累积分布函数（CDF）：

cum_prob = norm.cdf(1.96, loc=0, scale=1)  # P(Z ≤ 1.96) = 0.975

norm.cdf()累积分布函数

norm.cdf() 用于计算正态分布（高斯分布）的累积分布函数（CDF），即随机变量 $X$ 小于或等于某个值 $x$ 的概率。

一、函数定义

cdf(x, loc=0, scale=1)

作用：计算正态分布在 x 处的累积概率 $P (X \leq x)$ 。
参数：
- x：要计算累积概率的点（支持标量或数组）。
- loc：正态分布的均值（μ，默认为0）。
- scale：正态分布的标准差（σ，默认为1，需 > 0）。
返回：累积概率值（标量或数组），范围在 [0, 1]。

二、核心公式

正态分布的累积分布函数（CDF）公式：

其中，erf 是误差函数，用于近似计算积分。

三、示例代码

1. 标准正态分布（μ=0, σ=1）

计算 $P (X \leq 1.96)$ ：

from scipy.stats import norm

prob = norm.cdf(1.96)  # loc=0, scale=1
print(f"P(X ≤ 1.96) = {prob:.4f}")  # 输出：0.9750

2. 自定义均值和标准差

计算均值为5、标准差为2的正态分布在 $x = 7$ 处的累积概率：

prob = norm.cdf(7, loc=5, scale=2)
print(f"P(X ≤ 7) = {prob:.4f}")  # 输出：0.8413

3. 批量计算多个点

计算 $x = [- 1, 0, 1]$ 处的累积概率：

x = [-1, 0, 1]
prob = norm.cdf(x)
print(f"累积概率：{prob.round(4)}")  # 输出：[0.1587 0.5    0.8413]

4. 计算置信区间

计算标准正态分布的 95% 置信区间临界值：

alpha = 0.05
z_critical = norm.ppf(1 - alpha/2)  # 计算Z值
print(f"95% 置信区间临界值: ±{z_critical:.2f}")  # 输出：±1.96

四、常见应用场景

计算概率：
- 如“某次考试成绩 ≤ 80分的概率”。
假设检验：
- 计算P值，判断是否拒绝原假设。
置信区间：
- 结合分位数函数（norm.ppf()）确定置信区间范围。

六、与 `norm.pdf()` 的区别

方法	用途	输出意义
`norm.cdf`	计算累积概率（积分）	$P (X \leq x)$
`norm.pdf`	计算概率密度（导数）	密度值（非概率，需积分得概率）

七、注意事项

结果解释：CDF值直接表示概率，无需额外积分。
非对称分布：对于非正态数据，需使用其他分布的CDF（如 stats.t.cdf）。

总结

核心公式： $P (X \leq x) = norm.cdf (x, μ, σ)$ 。
使用场景：概率计算、假设检验、置信区间构建。
关键参数：loc（均值）、scale（标准差）。

通过 norm.cdf()，你可以快速计算正态分布的累积概率，广泛应用于统计分析、风险建模和机器学习中！ 📊

norm.rvs()生成随机变量

rvs 是 SciPy 统计模块中用于生成随机变量的核心方法，支持多种概率分布（如正态分布、泊松分布）。

参数解析

参数	类型	说明
`loc`	float 或 array-like	位置参数（均值，默认0），决定分布的中心位置。
`scale`	float 或 array-like	尺度参数（标准差，默认1），控制分布的宽度。
`size`	int 或 tuple	输出形状。若为 `None`（默认），返回单个值；若为整数或元组，返回对应形状的数组。
`random_state`	int/Generator/None	随机种子，确保结果可复现（示例：`random_state=42`）。

注：

对于其他分布（如伽马分布），可能需要额外形状参数（如 a）, 需在 rvs 中直接传递，如 gamma.rvs(a=2, size=10)。
正态分布（norm）无需形状参数，仅需 loc 和 scale。

使用示例

from scipy.stats import norm

# 示例1：生成单个标准正态随机数
sample1 = norm.rvs()
print(sample1)  # 如：0.265

# 示例2：生成5个均值为10，标准差为2的随机数
sample2 = norm.rvs(loc=10, scale=2, size=5)
print(sample2)  # 如：[11.2, 9.8, 10.5, 8.7, 12.1]

# 示例3：生成2x3矩阵，指定随机种子
sample3 = norm.rvs(loc=5, scale=1, size=(2,3), random_state=42)
print(sample3)
# 输出：
# [[6.49, 4.10, 5.33]
#  [4.67, 4.80, 4.84]]

如何生成其他分布的随机数？
替换分布名称并指定对应参数。例如，生成伽马分布的随机数：

from scipy.stats import gamma
gamma_data = gamma.rvs(a=2, loc=0, scale=1, size=100)

参数传递规则

位置参数顺序：若分布需要形状参数（如伽马分布的 a），需在 loc 和 scale 之前传递：

# ❌ 错误，a 是形状参数，不能通过关键字传递
gamma.rvs(loc=0, scale=1, a=2, size=10)

# ✅ 正确
gamma.rvs(2, loc=0, scale=1, size=10)

输出类型

当 size=None 时，返回 标量。
当 size 为整数或元组时，返回 NumPy 数组，形状由 size 指定。

关键总结：rvs 是生成随机数据的关键工具，通过调节参数灵活控制分布特性，结合 random_state 保证可重复性。其他分布的用法类似，但需关注其特定参数。

二项分布

二项分布的随机变量表示在 n 次独立试验中成功的次数，其概率质量函数（pmf）为：

$$ Binom(k|N,p) = {N \choose k}p^{k}(1-p)^{N-k} $$
$N \cdot p$ 表示分布的均值

n：试验总次数（整数 ≥ 0）。
p：每次试验成功的概率（0 ≤ p ≤ 1）。
k：可能的成功次数（取值范围是 0, 1, 2, ..., n）。

binom.pmf()概率质量函数

这个API是SciPy库中二项分布（binom）的概率质量函数（PMF）方法，用于计算离散型随机变量在某个具体取值点的概率。

📌 核心概念

二项分布：描述n次独立试验中成功次数的概率分布，每次试验的成功概率为p。
PMF：Probability Mass Function，计算离散型随机变量取某个具体值k的概率（连续型对应的是PDF概率密度函数）。

🛠️ 参数解释

k（必须）:
- 要计算概率的离散值（例如：抛硬币3次，正面朝上的次数）。
- 可以是单个数值，也可以是数组（计算多个值的概率）。
*args（必须）:
- 二项分布的参数：n（试验次数）, p（每次试验成功概率）。
- 例如：binom.pmf(k, n, p)。
loc（可选，默认0）:
- 分布的位移参数。通常保持默认值0，表示分布从k=0开始计算。
- 如果设为其他值（如loc=1），则实际计算的k会变为k - loc。

📝 使用示例

1. 基本用法

计算抛硬币5次，正面恰好出现2次的概率（假设硬币公平，p=0.5）：

from scipy.stats import binom

n = 5  # 试验次数
p = 0.5  # 成功概率
k = 2  # 计算k=2的概率

prob = binom.pmf(k, n, p)
print(prob)  # 输出: 0.3125

2. 计算多个k值的概率

一次性计算k=0到5的所有概率：

import numpy as np

k_values = np.arange(0, 6)  # [0,1,2,3,4,5]
probs = binom.pmf(k_values, n=5, p=0.5)
print(probs)
# 输出: [0.03125 0.15625 0.3125  0.3125  0.15625 0.03125]

3. 使用`loc`参数

假设位移loc=1，实际计算的是k - 1处的概率：

# 等价于计算k=1在n=5, p=0.5时的概率
prob = binom.pmf(2, n=5, p=0.5, loc=1)
print(prob)  # 输出: 0.15625 (对应k=1原本的概率)

通过这个API，你可以快速计算二项分布的概率，适用于统计建模、假设检验、蒙特卡洛模拟等场景。如果有更复杂的需求（如计算CDF或生成随机变量），可以进一步探索SciPy的binom模块。

binom.cdf()累积分布函数

这个API是SciPy库中二项分布（binom）的累积分布函数（CDF）方法，用于计算离散型随机变量在某个值k处累积概率（即随机变量取值小于等于k的概率）。以下是详细说明和示例：

📌 核心概念

CDF（累积分布函数）：计算离散型随机变量取值小于等于k的累积概率。
与PMF的区别：
- PMF：计算恰好等于k的概率（单点概率）。
- CDF：计算从0到k所有可能值的概率之和（累积概率）。

🛠️ 参数解释

k（必须）:
- 要计算累积概率的值（例如：抛硬币5次，正面出现次数≤2）。
- 可以是整数或数组（计算多个值的累积概率）。
*args（必须）:
- 二项分布的参数：n（试验次数）, p（每次试验成功概率）。
- 例如：binom.cdf(k, n, p)。
loc（可选，默认0）:
- 位移参数，调整分布的起点。默认loc=0，表示从k=0开始计算。
- 若设置loc=1，实际计算的k会变为k - loc。

📝 使用示例

1. 基本用法

计算抛硬币5次，正面出现次数不超过2次的概率（硬币公平，p=0.5）：

from scipy.stats import binom

n = 5
p = 0.5
k = 2  # 计算P(X ≤ 2)

cum_prob = binom.cdf(k, n, p)
print(cum_prob)  # 输出: 0.5 (即0.03125 + 0.15625 + 0.3125)

2. 计算多个k值的CDF

批量计算k=0到5的累积概率：

import numpy as np

k_values = np.arange(0, 6)  # [0,1,2,3,4,5]
cum_probs = binom.cdf(k_values, n=5, p=0.5)
print(cum_probs)
# 输出: [0.03125 0.1875  0.5     0.8125  0.96875 1.     ]

from scipy.stats import binom

# probability of x less or equal 0.3
print("P(X <=3) = {}".format(binom.cdf(k=3, p=0.3, n=10)))

# probability of x in [-0.2, +0.2]
print(
    "P(2 < X <= 8) = {}".format(
        binom.cdf(k=8, p=0.3, n=10) - binom.cdf(k=2, p=0.3, n=10)
    )
)
P(X <=3) = 0.6496107183999998
P(2 < X <= 8) = 0.6170735276999999

3. 使用`loc`参数

当loc=1时，实际计算的是k - 1的累积概率：

# 等价于计算k=1的累积概率（P(X ≤1)）
cum_prob = binom.cdf(2, n=5, p=0.5, loc=1)
print(cum_prob)  # 输出: 0.1875 (对应原k=1的累积概率)

k为浮点数时的处理：

CDF会向下取整。例如k=2.9会被视为k=2。

🌟 应用场景

假设检验：
计算观测结果是否具有统计学显著性（例如：判断硬币是否公平）。
质量控制：
若产品合格率要求≥95%，计算生产批次中最多允许的次品数。
风险评估：
预测某事件在多次独立试验中发生次数的累积风险（如设备故障次数≤k的概率）。

通过binom.cdf，你可以快速获得二项分布的累积概率，适用于统计分析和数据建模。如果需要反向操作（从概率反推k值），可以使用ppf方法（百分位点函数）。

binom.rvs()随机变量生成

这个API是SciPy库中二项分布（binom）的随机变量生成方法（RVS），用于生成服从二项分布的随机样本。

🛠️ 参数解释

n 和 p（必须，通过*args传递）:
- n：试验次数（正整数）。
- p：每次试验的成功概率（取值范围 [0, 1]）。
loc（可选，默认0）:
- 位移参数，生成的随机值会加上loc。例如，loc=5时，结果 = 原生随机数 + 5。
size（可选，默认1）:
- 输出的随机样本数量。可以是整数（如size=10）或元组（如size=(2,3)生成矩阵）。
random_state（可选）:
- 随机数种子，用于复现结果。可接受整数、numpy.random.Generator 或 RandomState 对象。

📝 使用示例

1. 生成单个随机数

抛硬币5次（n=5），每次正面概率0.5，生成一次实验的正面次数：

from scipy.stats import binom

n, p = 5, 0.5
sample = binom.rvs(n, p)  # 结果可能是0到5之间的整数，如3
print(sample)

2. 生成多个随机数

生成10次独立实验的随机数（每次实验抛5次硬币）：

samples = binom.rvs(n=5, p=0.5, size=10)  # 结果如 [2, 4, 1, 3, 3, 0, 5, 2, 3, 4]
print(samples)

3. 生成矩阵形式的随机数

生成一个2x3矩阵的随机数：

matrix_samples = binom.rvs(n=5, p=0.5, size=(2,3))
# 结果示例:
# [[3 2 4]
#  [1 5 2]]

4. 使用`loc`参数

生成的随机数整体偏移：

# 原生随机数 + 2（例如原生随机数3 → 5）
sample = binom.rvs(n=5, p=0.5, loc=2)
print(sample)  # 可能输出5, 3, 4等

5. 固定随机种子

确保结果可复现：

# 第一次生成
samples1 = binom.rvs(n=5, p=0.5, size=3, random_state=42)
# 第二次使用相同种子
samples2 = binom.rvs(n=5, p=0.5, size=3, random_state=42)
print(samples1, samples2)  # 输出相同，例如 [3 3 1] [3 3 1]

🌟 应用场景

模拟实验：
模拟抛硬币100次，统计正面出现的次数分布。
```
samples = binom.rvs(n=100, p=0.5, size=1000)  # 模拟1000次实验
```

质量控制：
假设某产品合格率95%，模拟生产100件产品中的合格品数量。

good_products = binom.rvs(n=100, p=0.95, size=20)  # 模拟20批生产

风险评估：
计算某服务在10次调用中失败次数超过3次的概率（通过生成大量样本估计）。

failures = binom.rvs(n=10, p=0.1, size=10000)  # 模拟10000次
prob = np.mean(failures > 3)  # 估计概率

泊松分布

poisson.pdf()

这个API是SciPy库中泊松分布（poisson）的概率质量函数（PMF）方法，用于计算泊松分布在某个值k处的概率。

📌 核心概念

泊松分布：描述固定时间或空间内稀有事件发生次数的概率分布（例如：单位时间内接到的电话次数、网站每分钟的访问量）。
参数 mu（λ）：事件发生的平均速率（均值 = 方差 = λ）。
PMF：计算事件恰好发生k次的概率。

🛠️ 参数解释

k（必须）:
- 要计算概率的事件发生次数（例如：某小时内接到3个电话）。
- 支持单个数值或数组（批量计算多个k值的概率）。
mu（通过*args传递）:
- 泊松分布的参数，表示事件的平均发生率（必须 > 0）。例如：poisson.pmf(k, mu=2)。
loc（可选，默认0）:
- 位移参数，调整分布的起点。默认loc=0，表示从k=0开始计算。
- 若设为loc=1，实际计算的k会变为k - loc。

📝 使用示例

1. 基本用法

计算某商店平均每小时接待5位顾客（mu=5），恰好接待3位顾客的概率：

from scipy.stats import poisson

mu = 5  # 平均每小时5次
k = 3   # 计算k=3的概率

prob = poisson.pmf(k, mu)
print(prob)  # 输出: 0.14037389581428056

2. 计算多个k值的概率

批量计算k=0到5的概率：

import numpy as np

k_values = np.arange(0, 6)  # [0,1,2,3,4,5]
probs = poisson.pmf(k_values, mu=2)  # 平均发生率为2
print(probs)
# 输出: [0.13533528 0.27067057 0.27067057 0.18044704 0.09022352 0.03608941]

3. 使用`loc`参数

当loc=1时，实际计算的是k - 1处的概率：

# 等价于计算k=2在mu=5时的概率
prob = poisson.pmf(3, mu=5, loc=1)
print(prob)  # 输出: 0.14037389581428056 (即原k=2的概率)

注意与二项分布区分：

泊松分布用于事件发生率已知且独立的场景，二项分布用于固定试验次数的场景。

🌟 应用场景

客服中心：
预测某小时接到10个电话的概率（已知平均每小时8个电话）。
交通流量：
计算某路口每分钟通过5辆车的概率（历史平均为4辆）。
设备故障：
估计某机器每月故障2次的概率（平均每月故障1.5次）。

通过poisson.pmf，你可以快速计算泊松分布的单点概率，适用于事件发生频率的建模与分析。如果需要计算累积概率（如P(X ≤ k)），可使用poisson.cdf方法。

poisson.cdf()

这个API是SciPy库中泊松分布（poisson）的累积分布函数（CDF）方法，用于计算泊松分布在某个值k处累积概率（即随机变量取值小于等于k的概率）。以下是详细说明和示例：

📌 核心概念

泊松分布：描述固定时间/空间内稀有事件发生次数的概率分布（如每小时接到的电话次数、每分钟网站的访问量）。
CDF：计算事件发生次数小于等于k的累积概率（与PMF的“恰好等于k”对比）。
参数 mu（λ）：事件的平均发生率（均值 = 方差 = mu）。

🛠️ 参数解释

k（必须）:
- 要计算累积概率的事件发生次数（例如：某小时接到电话次数 ≤3）。
- 支持整数或数组（批量计算多个k值的累积概率）。
mu（通过*args传递）:
- 泊松分布的参数，表示事件的平均发生率（必须 > 0）。例如：poisson.cdf(k, mu=2)。
loc（可选，默认0）:
- 位移参数，调整分布的起点。默认loc=0，表示从k=0开始计算。
- 若设为loc=1，实际计算的k会变为k - loc。

📝 使用示例

1. 基本用法

某客服中心平均每小时接听5个电话（mu=5），计算接到电话次数不超过3次的概率：

from scipy.stats import poisson

mu = 5
k = 3  # 计算P(X ≤ 3)
cum_prob = poisson.cdf(k, mu)
print(cum_prob)  # 输出: 0.2650259152973617

2. 计算多个k值的累积概率

批量计算k=0到5的累积概率：

import numpy as np

k_values = np.arange(0, 6)  # [0,1,2,3,4,5]
cum_probs = poisson.cdf(k_values, mu=2)  # 平均发生率为2
print(cum_probs)
# 输出: [0.13533528 0.40600585 0.67667642 0.85712346 0.94734698 0.98343639]

3. 使用`loc`参数

当loc=1时，实际计算的是k - 1的累积概率：

# 计算k=3的累积概率时，等价于原k=2的概率和
cum_prob = poisson.cdf(3, mu=5, loc=1)
print(cum_prob)  # 输出: 0.12465201948308105 (即原k=2的累积概率)

注意事项：

混淆PMF和CDF：
- pmf(3, mu=5) → 返回0.14037（恰好3次的概率）。
- cdf(3, mu=5) → 返回0.26502（0+1+2+3次的概率总和）。
k为浮点数时的处理：
- CDF会向下取整。例如k=3.9会被视为k=3。

🌟 应用场景

服务质量评估：
计算某服务器每分钟请求数 ≤10 的概率（已知平均请求数8次/分钟）。
库存管理：
预测某商品日销量不超过50件的概率（历史平均销量45件）。
风险控制：
估计某系统每月故障次数 ≤2 的概率（平均故障1.5次/月）。

通过poisson.cdf，你可以快速获得泊松分布的累积概率，适用于统计分析和决策支持。如果需要反向查询（从概率反推k值），可以使用ppf方法。

poisson.rvs()随机变量

这个API是SciPy库中泊松分布（poisson）的随机变量生成方法（RVS），用于生成服从泊松分布的随机样本。以下是详细说明和示例：

📌 核心概念

泊松分布：描述固定时间或空间内稀有事件发生次数的概率分布（例如：每分钟网站访问量、每小时客服电话次数）。
RVS (Random Variates Sampling)：根据泊松分布参数生成随机数，模拟事件发生的次数。

🛠️ 参数解释

mu（必须，通过*args传递）:
- 泊松分布的参数，表示事件的平均发生率（必须 > 0）。例如：poisson.rvs(mu=3)。
loc（可选，默认0）:
- 位移参数，生成的随机值会加上loc。例如，loc=2时，结果 = 原生随机数 + 2。
size（可选，默认1）:
- 输出的随机样本数量。可以是整数（如size=10）或元组（如size=(2,3)生成矩阵）。
random_state（可选）:
- 随机数种子，用于复现结果。可接受整数、numpy.random.Generator 或 RandomState 对象。

📝 使用示例

1. 生成单个随机数

模拟某客服中心平均每小时接听5个电话（mu=5），生成一次观测的来电次数：

from scipy.stats import poisson

mu = 5
sample = poisson.rvs(mu)  # 结果可能是0到15之间的整数，如3、6等
print(sample)

2. 生成多个随机数

生成10次观测数据（每次观测代表一小时的来电次数）：

samples = poisson.rvs(mu=5, size=10)  # 示例输出: [3, 7, 5, 2, 6, 4, 5, 5, 3, 8]
print(samples)

3. 生成矩阵形式的随机数

生成一个2x3矩阵的随机样本：

matrix_samples = poisson.rvs(mu=3, size=(2,3))
# 示例输出:
# [[4 2 5]
#  [1 3 2]]

4. 使用`loc`参数

生成的随机数整体偏移（例如模拟基线值）：

# 原生随机数 + 2（例如原生随机数3 → 5）
sample = poisson.rvs(mu=5, loc=2)
print(sample)  # 可能输出5, 7, 4等

5. 固定随机种子

确保结果可复现：

# 第一次生成
samples1 = poisson.rvs(mu=5, size=3, random_state=42)
# 第二次使用相同种子
samples2 = poisson.rvs(mu=5, size=3, random_state=42)
print(samples1, samples2)  # 输出相同，例如 [6 6 4] [6 6 4]

🌟 应用场景

流量模拟：
模拟某网站每分钟的访问量（历史平均为100次/分钟）：

visits = poisson.rvs(mu=100, size=1440)  # 模拟一天（1440分钟）的访问量

库存预测：
生成某商品日销量的随机样本（平均每日售出20件）：

sales = poisson.rvs(mu=20, size=30)  # 模拟一个月的销量

风险评估：
估计某设备每月故障次数超过5次的概率（平均故障率3次/月）：

failures = poisson.rvs(mu=3, size=10000)  # 模拟10000个月的数据
prob = np.mean(failures > 5)  # 计算概率

通过poisson.rvs，你可以轻松生成符合泊松分布的随机数据，为统计建模、风险分析和实验模拟提供基础。如果需要进一步分析生成数据的分布，可结合直方图或统计检验方法。

均匀分布

uniform.pdf()概率密度函数

这个API是SciPy库中均匀分布（uniform）的概率密度函数（PDF）方法，用于计算均匀分布在某个值x处的概率密度。以下是详细说明和示例：

📌 核心概念

均匀分布：一种连续概率分布，区间 [loc, loc + scale] 内的所有值具有相同概率密度，区间外密度为0。
PDF：Probability Density Function，计算连续型随机变量在x处的概率密度（注意：PDF值不是概率，只有积分面积代表概率）。

🛠️ 参数解释

x（必须）:
- 要计算概率密度的值，可以是单个数值或数组。
loc（可选，默认0）:
- 分布的区间起点（最小值），对应传统均匀分布的参数a。
scale（可选，默认1）:
- 分布的区间长度（最大值 = loc + scale），对应传统均匀分布的参数范围 b - a。

📝 使用示例

1. 基本用法

计算均匀分布 [2, 5]（即loc=2, scale=3）在x=3.5处的概率密度：

from scipy.stats import uniform

loc = 2
scale = 3  # 区间为 [2, 5]
x = 3.5

pdf_value = uniform.pdf(x, loc, scale)
print(pdf_value)  # 输出: 0.3333333333333333 (即1/scale)

2. 计算多个x值的密度

批量计算x=-1, 0.5, 1.5在均匀分布 [0, 2]（loc=0, scale=2）中的密度：

x_values = [-1, 0.5, 1.5]
pdf_values = uniform.pdf(x_values, loc=0, scale=2)
print(pdf_values) 
# 输出: [0.  0.5 0.5] （-1在区间外，密度为0；0.5和1.5在区间内，密度=1/2）

3. 默认参数（loc=0, scale=1）

计算标准均匀分布 [0, 1] 在x=0.3处的密度：

pdf_default = uniform.pdf(0.3)
print(pdf_default)  # 输出: 1.0

⚠️ 常见问题

区间外值的密度：

如果x < loc或x > loc + scale，密度为0：

 print(uniform.pdf(5.1, loc=2, scale=3))  # 输出: 0.0

PDF值大于1：

当scale < 1时，密度可能超过1（但积分面积仍为1）。例如：

print(uniform.pdf(0.5, loc=0, scale=0.5))  # 输出: 2.0 (区间[0, 0.5]的密度=1/0.5=2)

🌟 应用场景

随机生成数据：
生成均匀分布在 [10, 20] 的随机数：

samples = uniform.rvs(loc=10, scale=10, size=100)

物理模拟：
模拟粒子在区间 [0, L] 内的随机位置分布。
财务模型：
假设某商品价格在 [100, 150] 元间均匀波动，计算价格概率密度。

🔄 与其他分布的关系

离散均匀分布：用scipy.stats.randint处理整数均匀分布（如骰子点数）。
自定义区间：通过调整loc和scale可覆盖任意区间 [a, b]。

通过uniform.pdf，你可以快速验证均匀分布的概率密度特性，适用于数据建模、统计检验和蒙特卡洛模拟等场景。

uniform.cdf()累计分布函数

这个API是SciPy库中均匀分布（uniform）的累积分布函数（CDF）方法，用于计算均匀分布在某个值x处的累积概率（即随机变量取值小于等于x的概率）。以下是详细说明和示例：

📌 核心概念

均匀分布：在区间 [loc, loc + scale] 内，所有值具有相同的概率密度，区间外概率密度为0。
CDF：计算随机变量 X 小于等于 x 的概率，即 $P (X \leq x)$ 。

🛠️ 参数解释

x（必须）:
- 要计算累积概率的值，可以是单个数值或数组。
loc（可选，默认0）:
- 分布的区间起点（最小值），对应传统均匀分布的参数 a。
scale（可选，默认1）:
- 分布的区间长度（最大值 = loc + scale），对应传统均匀分布的参数范围 b - a。

📝 使用示例

1. 基本用法

计算均匀分布 [2, 5]（loc=2, scale=3）在 x=3.5 处的累积概率：

from scipy.stats import uniform

loc = 2
scale = 3  # 区间为 [2, 5]
x = 3.5

cdf_value = uniform.cdf(x, loc, scale)
print(cdf_value)  # 输出: 0.5 (因为 (3.5 - 2)/3 = 0.5)

2. 区间外的CDF值

x < loc：概率为0
x > loc + scale：概率为1

print(uniform.cdf(1, loc=2, scale=3))  # 输出: 0.0（x在区间左外）
print(uniform.cdf(6, loc=2, scale=3))  # 输出: 1.0（x在区间右外）

3. 批量计算多个x值

计算x=-1, 0.5, 1.5在均匀分布 [0, 2]（loc=0, scale=2）中的累积概率：

x_values = [-1, 0.5, 1.5]
cdf_values = uniform.cdf(x_values, loc=0, scale=2)
print(cdf_values) 
# 输出: [0.   0.25 0.75]

4. 默认参数（loc=0, scale=1）

计算标准均匀分布 [0, 1] 在x=0.3处的累积概率：

cdf_default = uniform.cdf(0.3)
print(cdf_default)  # 输出: 0.3

浮点精度问题：

当x接近loc或loc + scale时，结果可能因浮点运算略有误差，但通常可忽略。

🌟 应用场景

随机数生成验证：
验证生成的数据是否服从均匀分布（通过比较CDF的理论值与经验值）。
资源分配模型：
假设任务完成时间在 [2小时, 5小时] 内均匀分布，计算任务在3小时内完成的概率：

prob = uniform.cdf(3, loc=2, scale=3)
print(prob)  # 输出: 0.333...

财务风险评估：
若某投资回报率均匀分布在 [-5%, 10%]，计算亏损（回报率 ≤0）的概率：

prob_loss = uniform.cdf(0, loc=-0.05, scale=0.15)
print(prob_loss)  # 输出: 0.333...

uniform.rvs()随机数

这个API是SciPy库中均匀分布（uniform）的随机变量生成方法（RVS），用于生成服从均匀分布的随机样本。以下是详细说明和示例：

📌 核心概念

均匀分布：一种连续概率分布，区间 [loc, loc + scale] 内的所有值具有相同概率密度，区间外概率为0。
RVS (Random Variates Sampling)：根据均匀分布参数生成随机数，模拟从区间中均匀采样。

🛠️ 参数解释

loc（可选，默认0）:
- 分布的区间起点（最小值），对应传统均匀分布的参数 a。
scale（可选，默认1）:
- 分布的区间长度（最大值 = loc + scale），对应传统均匀分布的参数范围 b - a。
size（可选，默认1）:
- 输出的随机样本数量。可以是整数（如size=10）或元组（如size=(2,3)生成矩阵）。
random_state（可选）:
- 随机数种子，用于复现结果。可接受整数、numpy.random.Generator 或 RandomState 对象。

📝 使用示例

1. 生成单个随机数

从均匀分布 [2, 5]（loc=2, scale=3）生成一个随机数：

from scipy.stats import uniform

sample = uniform.rvs(loc=2, scale=3)  # 输出可能是2到5之间的任意浮点数，如3.7
print(sample)

2. 生成多个随机数

生成10个服从 [0, 1] 标准均匀分布的随机数：

samples = uniform.rvs(size=10)  # 示例输出: [0.37, 0.92, 0.48, ..., 0.65]
print(samples)

3. 生成矩阵形式的随机数

生成一个2x3矩阵的随机样本（区间 [10, 20]）：

matrix_samples = uniform.rvs(loc=10, scale=10, size=(2,3))
# 示例输出:
# [[12.3 15.8 11.1]
#  [18.9 10.5 19.7]]

4. 固定随机种子

确保结果可复现：

# 第一次生成
samples1 = uniform.rvs(loc=2, scale=3, size=3, random_state=42)
# 第二次使用相同种子
samples2 = uniform.rvs(loc=2, scale=3, size=3, random_state=42)
print(samples1, samples2)  # 输出相同，如 [3.745 2.478 4.981] [3.745 2.478 4.981]

🌟 应用场景

蒙特卡洛模拟：
生成大量均匀分布的随机数进行积分或优化计算：

samples = uniform.rvs(loc=0, scale=1, size=10000)
integral_estimate = np.mean(np.sin(samples))  # 估计 ∫₀¹ sin(x) dx ≈ 1 - cos(1)

游戏开发：
模拟宝箱掉落物品的随机位置（地图区域 [x_min, x_max]）：

x_drop = uniform.rvs(loc=x_min, scale=x_max - x_min, size=100)

统计实验：
验证均匀分布的统计性质（如均值和方差）：

samples = uniform.rvs(loc=2, scale=5, size=1000)
print("均值:", np.mean(samples))  # 应接近 2 + 5/2 = 4.5
print("方差:", np.var(samples))   # 应接近 5²/12 ≈ 2.083

通过 uniform.rvs，你可以轻松生成符合均匀分布的随机数据，适用于仿真、数值计算和统计建模。

卡方分布

chi2.pdf（）概率密度函数（PDF）

📌 核心概念

卡方分布：描述 k 个独立标准正态分布变量平方和 的分布，由自由度 df（即参数 k）控制形态。
PDF：Probability Density Function，计算在给定值 x 处的概率密度（非概率本身，密度曲线下面积为1）。

🛠️ 参数解释

x（必须）:
- 要计算概率密度的值（支持单个数值或数组）。
df（通过 *args 传递，必须）:
- 自由度（正整数），表示独立正态变量的个数。
loc（可选，默认0）:
- 分布的位置平移参数，调整分布的起点。通常保持默认值0。
scale（可选，默认1）:
- 分布的缩放参数，调整分布的宽度。卡方分布通常不缩放，保持默认值1。

📝 使用示例

1. 基本用法

计算自由度为 df=3 的卡方分布在 x=5 处的概率密度：

from scipy.stats import chi2

df = 3
x = 5
pdf_value = chi2.pdf(x, df)  # 等价于 chi2.pdf(x, 3)
print(pdf_value)  # 输出: 0.1410474

2. 批量计算多个x值

计算自由度为2时，x=0, 1, 2处的概率密度：

import numpy as np

x_values = np.array([0, 1, 2])
pdf_values = chi2.pdf(x_values, df=2)
print(pdf_values)  
# 输出: [0.       0.303265 0.18394 ] 
# 解释：x=0时密度为0，x=1时密度约为0.303

3. 可视化卡方分布

绘制自由度为2、3、5的卡方分布PDF曲线：

import matplotlib.pyplot as plt

x = np.linspace(0, 10, 100)
for df in [2, 3, 5]:
    plt.plot(x, chi2.pdf(x, df), label=f'df={df}')

plt.xlabel('x')
plt.ylabel('PDF')
plt.legend()
plt.show()

x 为负数：

卡方分布定义域为 x ≥ 0，负数处的密度为0：

print(chi2.pdf(-1, df=3))  # 输出: 0.0

🌟 应用场景

假设检验：
计算卡方检验统计量的理论密度，辅助判断观测值是否显著。

observed_chi2 = 6.25  # 卡方检验统计量
df = 2                # 自由度
density = chi2.pdf(observed_chi2, df)
print(f"在自由度为{df}时，统计量{observed_chi2}处的密度为{density:.4f}")

分布对比：
比较不同自由度下卡方分布的形态差异（如右偏程度）。

🔄 与其他分布的关系

伽马分布：卡方分布是伽马分布的特例（形状参数 $α = k /2$ ，速率参数 $β = 1/2$ ）。
非中心卡方分布：当正态变量均值非零时的扩展形式。

通过 chi2.pdf，你可以准确计算卡方分布在任意点的概率密度，为统计推断和数据分析提供支持。如需计算累积概率，使用 chi2.cdf；生成随机样本则用 chi2.rvs。

chi2.cdf（）累积分布函数（PDF）

📌 核心概念

卡方分布：描述 k 个独立标准正态分布变量平方和 的分布，由自由度 df 控制形态。
CDF：Cumulative Distribution Function，计算随机变量 $X \leq x$ 的累积概率 $P (X \leq x)$ 。

🛠️ 参数解释

x（必须）:
- 要计算累积概率的值（支持单个数值或数组）。
df（通过 *args 传递，必须）:
- 自由度（正整数），表示独立正态变量的个数。
loc（可选，默认0）:
- 分布的位置平移参数，通常保持默认值0（卡方分布起点为0）。
scale（可选，默认1）:
- 分布的缩放参数，卡方分布一般不需要调整，保持默认值1。

📝 使用示例

1. 基本用法

计算自由度为3的卡方分布在 $x = 5$ 处的累积概率：

from scipy.stats import chi2

df = 3
x = 5
cdf_value = chi2.cdf(x, df)  # 等价于 chi2.cdf(5, 3)
print(cdf_value)  # 输出: 0.828202

2. 批量计算多个x值

计算自由度为2时，x=0, 1, 2处的累积概率：

import numpy as np

x_values = np.array([0, 1, 2])
cdf_values = chi2.cdf(x_values, df=2)
print(cdf_values)  
# 输出: [0.         0.39346934 0.63212056]

3. 可视化卡方分布CDF

绘制不同自由度的CDF曲线：

import matplotlib.pyplot as plt

x = np.linspace(0, 10, 100)
for df in [2, 3, 5]:
    plt.plot(x, chi2.cdf(x, df), label=f'df={df}')

plt.xlabel('x')
plt.ylabel('CDF')
plt.legend()
plt.show()

🌟 应用场景

1. 假设检验（计算p值）

在卡方检验中，根据统计量计算p值：

observed_chi2 = 6.25  # 卡方检验统计量
df = 2                # 自由度
p_value = 1 - chi2.cdf(observed_chi2, df)
print(f"p值为: {p_value:.4f}")  # 输出: p值为: 0.0439

2. 置信区间估计

计算自由度为5的卡方分布95%置信区间的临界值：

alpha = 0.975
critical_value = chi2.ppf(alpha, df=5)  # 使用分位点函数 (PPF)
print(f"临界值为: {critical_value:.2f}")  # 输出: 临界值为: 12.83

3. 模型拟合评估

验证数据方差是否符合理论分布（自由度为 $n - 1$ ）：

data = np.random.normal(0, 1, 100)  # 假设总体方差σ²=1
sample_var = np.var(data, ddof=1)   # 样本方差（无偏估计）
n = len(data)
chi2_stat = (n-1) * sample_var / 1  # 统计量服从χ²(n-1)
cum_prob = chi2.cdf(chi2_stat, df=n-1)
print(f"累积概率: {cum_prob:.4f}")  # 若接近0.5，说明样本方差接近总体方差

🔄 与其他函数结合

PPF（分位点函数）：通过 chi2.ppf 从概率反推临界值。
生存函数：chi2.sf(x, df) 等价于 1 - chi2.cdf(x, df)，直接计算右尾概率。

通过 chi2.cdf，你可以快速评估卡方分布的累积概率，为统计推断提供关键支持。

卡方分布随机变量生成（RVS）

核心概念

卡方分布：由 k 个独立标准正态变量平方和生成的分布，由自由度 df 控制形态。
RVS (Random Variates Sampling)：生成服从卡方分布的随机样本，用于模拟或蒙特卡洛分析。

🛠️ 参数解释

df（通过 *args 传递，必须）:
- 自由度（正整数），表示参与平方和的标准正态变量个数。
loc（可选，默认0）:
- 位置参数，将生成的随机数整体平移（例如 loc=5 → 结果 = 原生随机数 + 5）。
scale（可选，默认1）:
- 缩放参数，调整分布的离散程度（例如 scale=2 → 结果 = 原生随机数 * 2）。
size（可选，默认1）:
- 输出形状，指定生成样本的数量（如整数 10 或元组 (2,3) 生成矩阵）。
random_state（可选）:
- 随机种子，确保结果可复现（接受整数或 NumPy 随机状态对象）。

📝 使用示例

1. 生成单个随机数

生成自由度为3的卡方分布随机数：

from scipy.stats import chi2

df = 3
sample = chi2.rvs(df, size=1)
print(sample)  # 示例输出: [2.315]

2. 生成多个随机数

生成10个自由度为5的卡方随机样本：

samples = chi2.rvs(df=5, size=10)
print(samples)  # 示例输出: [3.67, 7.89, 4.12, ..., 6.45]

📈 数学验证

生成的随机样本应满足卡方分布的理论性质：

理论均值：df
理论方差：2*df

验证示例：

import numpy as np

samples = chi2.rvs(df=5, size=10000)
print("样本均值:", np.mean(samples))  # 应接近5
print("样本方差:", np.var(samples))  # 应接近10（2 * 5）

🌟 应用场景

蒙特卡洛模拟：
估计自由度为4的卡方分布中，超过10的概率：

samples = chi2.rvs(df=4, size=100000)
prob = np.mean(samples > 10)
print(f"概率约为: {prob:.4f}")  # 理论值 ≈ 0.0403

假设检验验证：
生成服从卡方分布的数据，验证卡方检验的准确性：

from scipy.stats import chisquare

# 生成观察频数（自由度为3）
observed = chi2.rvs(df=3, size=1000)
# 卡方拟合优度检验
hist, bins = np.histogram(observed, bins=10)
expected = len(observed)/10  # 均匀分布的期望频数（对比用）
chi2_stat, p_value = chisquare(hist, expected)
print(f"p值: {p_value:.4f}")  # p值应大于0.05（符合卡方分布）

贝叶斯统计：
作为先验分布生成后验抽样（需配合MCMC等算法）。

🔄 与其他方法结合

PDF/CDF分析：将生成的样本与理论PDF/CDF对比：

import matplotlib.pyplot as plt

samples = chi2.rvs(df=3, size=1000)
x = np.linspace(0, 15, 100)
plt.hist(samples, bins=30, density=True, alpha=0.5)
plt.plot(x, chi2.pdf(x, df=3), 'r-', label='PDF')
plt.legend()
plt.show()

通过 chi2.rvs，你可以生成符合卡方分布的随机数据，支撑统计模拟、算法测试和实证研究。确保正确设置自由度，并结合理论性质验证生成数据的合理性。

Beta分布

beta.pdf()概率密度函数（PDF）

🛠️ 参数解释

x（必须）:
- 要计算概率密度的值（在 [loc, loc + scale] 区间内有效）。
- 支持单个数值或数组。
a 和 b（通过 *args 传递，必须）:
- 形状参数，控制分布形态。例如 beta.pdf(x, a=2, b=5)。
loc（可选，默认0）:
- 分布的区间起点（即原Beta分布 [0, 1] 的左端平移后的位置）。
scale（可选，默认1）:
- 扩展分布的区间长度（即原Beta分布 [0,1] 的区间长度变为 scale）。

📝 使用示例

1. 基本用法

计算Beta分布 a=2, b=5 在 x=0.3 处的概率密度：

from scipy.stats import beta

a, b = 2, 5
x = 0.3

pdf_value = beta.pdf(x, a, b)  # 或 beta.pdf(x, 2, 5)
print(f"PDF值: {pdf_value:.4f}")  # 输出: 1.1760

2. 使用自定义区间（`loc` 和 `scale`）

计算分布区间 [10, 15]（即 loc=10, scale=5）中 x=12 处的密度：

# 将原始Beta分布的 [0,1] 映射到 [10, 15]
x = 12
pdf_value = beta.pdf(x, a=2, b=5, loc=10, scale=5)
print(pdf_value)  # 输出: 0.2352（原始PDF在0.4处的值 = 1.1760 / scale）

3. 批量计算多个x值

计算x=0.2, 0.5, 0.8在Beta(2, 5)中的密度：

x_values = [0.2, 0.5, 0.8]
pdf_values = beta.pdf(x_values, a=2, b=5)
print(pdf_values)  
# 输出: [1.3824  0.5466  0.0679]

4. 可视化Beta分布PDF

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import beta
x = np.linspace(0, 1, 100)
a_values = [0.5, 2, 5]
b = 2

for a in a_values:
    plt.plot(x, beta.pdf(x, a, b), label=f'Beta({a}, {b})')

plt.xlabel('x')
plt.ylabel('PDF')
plt.title('Beta分布PDF示例')
plt.legend()
plt.show()

区间外值的密度：

x < loc 或 x > loc + scale 时，密度为0：

print(beta.pdf(-0.5, 2, 5))  # 输出: 0.0
print(beta.pdf(1.5, 2, 5))   # 输出: 0.0

无效形状参数：

a 或 b ≤ 0 时报错 ValueError:

beta.pdf(0.5, -1, 2)  # ValueError: a <= 0

🌟 应用场景

贝叶斯A/B测试：
作为转化率的共轭先验分布：

# 策略A：50次展示，10次转化 → 后验为 Beta(10 + a=1, 40 + b=1)
x = 0.2
post_density = beta.pdf(x, 11, 41)

概率校准模型：
使用Beta分布校准分类模型输出的概率置信度。
项目管理：
模拟任务完成时间在调整后的区间 [min_time, max_time] 内的分布。

通过调整 loc 和 scale，Beta分布可灵活扩展到任意区间，而形状参数 a 和 b 允许精准控制分布形态，是建模不确定性概率的核心工具。

beta.cdf()累积分布函数（CDF）

x（必须）:
- 要计算累积概率的值，必须在 [loc, loc + scale] 区间内。支持单个数值或数组。
a 和 b（通过 *args 传递，必须）:
- 形状参数，控制分布形态。例如 beta.cdf(x, a=2, b=5)。
loc（可选，默认0）:
- 分布的区间起点，将原Beta分布 [0,1] 平移至 [loc, loc + scale]。
scale（可选，默认1）:
- 分布的区间长度，将原Beta分布 [0,1] 扩展至 [loc, loc + scale]。

📝 使用示例

1. 基本用法

计算Beta分布 a=2, b=5 在 x=0.3 处的累积概率：

from scipy.stats import beta

a, b = 2, 5
x = 0.3

cdf_value = beta.cdf(x, a, b)  # 或 beta.cdf(0.3, 2, 5)
print(f"累积概率 P(X ≤ 0.3): {cdf_value:.4f}")  # 输出: 0.5798

2. 使用自定义区间（`loc` 和 `scale`）

计算分布区间 [10, 15]（即 loc=10, scale=5）中 x=12 处的累积概率：

# 将原始Beta分布的 [0,1] 映射到 [10, 15]
x = 12
# 计算标准化后的位置：(12 - 10)/5 = 0.4
cdf_value = beta.cdf(x, a=2, b=5, loc=10, scale=5)
print(cdf_value)  # 输出: 0.5798（与示例1结果一致）

3. 批量计算多个x值

计算x=0.2, 0.5, 0.8在Beta(2, 5)中的累积概率：

x_values = [0.2, 0.5, 0.8]
cdf_values = beta.cdf(x_values, a=2, b=5)
print(cdf_values)  
# 输出: [0.2627  0.8906  0.9987]

4. 可视化Beta分布CDF

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 1, 100)
a_values = [0.5, 2, 5]
b = 2

for a in a_values:
    plt.plot(x, beta.cdf(x, a, b), label=f'Beta({a}, {b})')

plt.xlabel('x')
plt.ylabel('CDF')
plt.title('Beta分布CDF示例')
plt.legend()
plt.show()

区间外值的处理：

x < loc 时，CDF为0；x > loc + scale 时，CDF为1：

print(beta.cdf(-0.5, 2, 5))  # 输出: 0.0
print(beta.cdf(1.5, 2, 5))    # 输出: 1.0

无效形状参数：

a 或 b ≤ 0 时报错 ValueError:

beta.cdf(0.5, -1, 2)  # ValueError: a <= 0

🌟 应用场景

贝叶斯假设检验：
计算后验概率 $P (θ \leq 0.3)$ （θ为成功概率）：

# 后验分布 Beta(a=12, b=18)
prob = beta.cdf(0.3, 12, 18)
print(f"概率: {prob:.2%}")  # 示例输出: 8.45%

质量控制：
若产品合格率服从Beta(5, 2)，计算合格率 ≤80% 的概率：

prob = beta.cdf(0.8, 5, 2)
print(f"概率: {prob:.1%}")  # 输出: 99.3%

风险管理：
估计投资回报率在调整区间内的累积风险（如回报率 ≤ -5% 的概率）。

🔄 与其他分布的关系

均匀分布：Beta(1, 1) 的CDF为线性函数。
二项分布：Beta分布是二项分布的成功概率的共轭先验。

通过灵活调整 a、b、loc 和 scale，Beta分布的CDF可广泛应用于概率建模和统计推断。

beta.rvs()随机数

RVS (Random Variates Sampling)：生成服从Beta分布的随机样本，常用于蒙特卡洛模拟和贝叶斯统计中的概率采样。

🛠️ 参数解释

a 和 b（必须，通过 *args 传递）:
- 形状参数，控制分布的形态。必须满足 a > 0 和 b > 0。
loc（可选，默认0）:
- 分布的区间起点。例如，loc=10 表示分布的区间起点为10。
scale（可选，默认1）:
- 分布的区间长度。默认区间为 [loc, loc + scale]，例如 scale=5 时，区间为 [10, 15]（当 loc=10）。
size（可选，默认1）:
- 输出的样本维度，可指定为整数（如100）或元组（如 (2,3) 生成2x3矩阵）。
random_state（可选）:
- 随机种子，确保结果可复现。接受整数或NumPy的随机状态对象。

📝 使用示例

1. 生成单个随机样本

生成一个服从Beta分布 a=2、b=5 的随机数：

from scipy.stats import beta

sample = beta.rvs(2, 5)  
print(sample)  # 示例输出: 0.253（位于[0,1]间）

2. 生成自定义区间的样本

生成10个服从区间 [10, 15]（即 loc=10，scale=5）的Beta(2,5)随机数：

samples = beta.rvs(2, 5, loc=10, scale=5, size=10)
print(samples)  # 示例输出: [12.14, 11.89, 13.76, ...]

3. 生成多维数组

生成一个3x2矩阵的随机样本：

matrix_samples = beta.rvs(2, 5, size=(3,2))
# [[0.34 0.18]
#  [0.29 0.41]
#  [0.22 0.33]]

4. 固定随机种子

确保每次生成的随机样本相同：

samples1 = beta.rvs(2, 5, size=3, random_state=42)
samples2 = beta.rvs(2, 5, size=3, random_state=42)
print(samples1 == samples2)  # 输出: [True True True]

无效参数值：

a 或 b ≤ 0 时触发错误：

区间反向问题：
- scale 必须 >0，若需降序区间可以用公式 loc=upper, scale=lower-upper，但需注意数据逻辑。

📊 统计检验示例

验证生成的样本是否符合Beta(2,5)的预期均值和方差：

import numpy as np

samples = beta.rvs(2, 5, size=10000)
mean = np.mean(samples)  # 理论均值 = a/(a+b) = 2/7 ≈ 0.2857
var = np.var(samples)    # 理论方差 = ab/((a+b)^2 (a+b+1)) ≈ 0.0255

print(f"样本均值: {mean:.4f}")  # 约0.2857
print(f"样本方差: {var:.4f}")   # 约0.0255

🌟 应用场景

1. 贝叶斯参数采样

假设某产品转化率θ的后验分布为Beta(10, 20)，生成可能的转化率样本：

theta_samples = beta.rvs(10, 20, size=1000)
prob_over_25 = np.mean(theta_samples > 0.25)
print(f"转化率 >25% 的估计概率: {prob_over_25:.1%}")  # 示例输出: 85.3%

2. 金融风险模拟

模拟投资组合回报率（假设回报率分布在 [-5%, 15%] 区间，服从Beta(3,2)）：

# 区间映射: loc=-0.05, scale=0.2
returns = beta.rvs(3, 2, loc=-0.05, scale=0.2, size=1000)
negative_returns = returns[returns < 0]
print(f"亏损概率: {len(negative_returns)/1000:.1%}")  # 约3%

3. A/B测试数据生成

模拟两种广告点击率（假设A组点击率 ~ Beta(5,195)，B组 ~ Beta(10,190)）：

ctr_A = beta.rvs(5, 195, size=1000)  # 平均点击率约5/(5+195)=2.5%
ctr_B = beta.rvs(10, 190, size=1000) # 平均点击率约10/(10+190)=5%
significant_win = np.mean(ctr_B > ctr_A)
print(f"B组更优的概率: {significant_win:.0%}")  # 约99%

🔄 与其他方法的关联

密度验证：生成样本后，可用 beta.pdf 绘制理论密度曲线，比较样本直方图。
概率计算：结合 beta.ppf 计算分位数，验证生成样本的分布区间。

通过合理设置 a、b、loc 和 scale，beta.rvs 能够灵活生成符合实际场景需求的概率样本，是数据仿真和统计推断中的关键工具。

posted @ 2025-05-21 16:46 指尖下的世界阅读(168) 评论(0) 收藏举报

刷新页面返回顶部

指尖下的世界

今日事今日毕,今日无事早休息.

9.Scipy

常量（constants）

单位类别

优化器 （optimize：优化和求根）

方程求根（Root Finding）​​

root函数初步使用

root函数使用说明

解析结果对象​

优化器

初步使用

一、分类与核心算法​

​​1. 无约束优化（Unconstrained Optimization）​​

​​2. 约束优化（Constrained Optimization）​​

​​3. 全局优化（Global Optimization）​​

​​4. 最小二乘问题（Least-Squares）​​

​​二、算法选择决策树​​

​​三、性能优化技巧​​

​​四、调试与问题排查​​

​​五、实战案例：逻辑回归参数估计​​

​​总结​​

稀疏矩阵

图形

空间数据

MatLab

插值法

统计学-假设检验

T-检验

​​2. 独立双样本T检验（假设方差齐性）​​

​​3. 配对样本T检验​​

​​四、Python实战示例​​

​​1. 单样本T检验​

Z检验（Z-Test）

​​1. 单样本Z检验（手动计算）​

卡方检验（Chi-Square Test）

KS-检验

数据的统计描述

正态性测试(偏度和峰度)

偏度

峰度

正态分布

norm.pdf()概率密度函数

​​一、函数定义​

​​二、核心公式​​

​​三、示例代码​​

​​1. 标准正态分布（μ=0, σ=1）​​

2. 自定义均值和标准差​​

3. 批量计算多个点​​

4. 绘制正态分布曲线​

四、常见问题​​

​​1. loc 和 scale 参数的作用？​​

​​2. 与非标准正态分布的关系？​​

​​3. 如何计算累积概率？​​

norm.cdf()累积分布函数

一、函数定义​

​​二、核心公式​​

​​三、示例代码​​

​​1. 标准正态分布（μ=0, σ=1）​​

3. 批量计算多个点​​

四、常见应用场景​​

六、与 norm.pdf() 的区别​​

​​七、注意事项​​

​​总结​​

norm.rvs()生成随机变量

二项分布

binom.pmf()概率质量函数

📌 ​​核心概念​​

🛠️ ​​参数解释​​

📝 ​​使用示例​​

1. 基本用法

2. 计算多个k值的概率

3. 使用loc参数

binom.cdf()累积分布函数

📌 ​​核心概念​​

🛠️ ​​参数解释​​

📝 ​​使用示例​​

1. 基本用法

2. 计算多个k值的CDF

3. 使用loc参数

优化器（optimize：优化和求根）

方程求根（Root Finding）

解析结果对象

一、分类与核心算法

1. 无约束优化（Unconstrained Optimization）

2. 约束优化（Constrained Optimization）

3. 全局优化（Global Optimization）

4. 最小二乘问题（Least-Squares）

二、算法选择决策树

三、性能优化技巧

四、调试与问题排查

五、实战案例：逻辑回归参数估计

总结

2. 独立双样本T检验（假设方差齐性）

3. 配对样本T检验

四、Python实战示例

1. 单样本T检验

1. 单样本Z检验（手动计算）

一、函数定义

二、核心公式

三、示例代码

1. 标准正态分布（μ=0, σ=1）

2. 自定义均值和标准差

3. 批量计算多个点

4. 绘制正态分布曲线

四、常见问题

1. `loc` 和 `scale` 参数的作用？

2. 与非标准正态分布的关系？

3. 如何计算累积概率？

一、函数定义

二、核心公式

三、示例代码

1. 标准正态分布（μ=0, σ=1）

3. 批量计算多个点

四、常见应用场景

六、与 `norm.pdf()` 的区别

七、注意事项

总结

📌 核心概念

🛠️ 参数解释

📝 使用示例

3. 使用`loc`参数

📌 核心概念

🛠️ 参数解释

📝 使用示例

3. 使用`loc`参数

🌟 应用场景

🛠️ 参数解释

📝 使用示例

4. 使用`loc`参数

🌟 应用场景

📌 核心概念

🛠️ 参数解释

📝 使用示例

3. 使用`loc`参数

🌟 应用场景

📌 核心概念

🛠️ 参数解释

📝 使用示例

3. 使用`loc`参数

🌟 应用场景

📌 核心概念

🛠️ 参数解释

📝 使用示例

4. 使用`loc`参数

🌟 应用场景

📌 核心概念

🛠️ 参数解释

📝 使用示例

⚠️ 常见问题

🌟 应用场景

🔄 与其他分布的关系

📌 核心概念

🛠️ 参数解释

📝 使用示例

🌟 应用场景

📌 核心概念

🛠️ 参数解释

📝 使用示例

🌟 应用场景