让我们定义一些重要的术语：
数据挖掘、机器学习和统计学习是相关的：
graph LR
A[数据挖掘] --> C(共同点) # 数据挖掘指向共同点
B[机器学习] --> C(共同点) # 机器学习指向共同点
D[统计学习] --> C(共同点) # 统计学习指向共同点
C --> E[洞察与预测] # 共同点指向洞察与预测graph LR
A[数据挖掘] --> C(共同点) # 数据挖掘指向共同点
B[机器学习] --> C(共同点) # 机器学习指向共同点
D[统计学习] --> C(共同点) # 统计学习指向共同点
C --> E[洞察与预测] # 共同点指向洞察与预测
它们都旨在提取洞察并进行预测。机器学习和统计学习提供了在更广泛的数据挖掘环境中使用的工具。
Python 在数据分析中占据主导地位，原因如下：
典型的模型开发工作流程：
graph LR
A[数据加载 (pandas)] --> B[数据清洗 (pandas)] # 数据加载指向数据清洗
B --> C[特征工程 (pandas, 其他工具)] # 数据清洗指向特征工程
C --> D[模型构建 (statsmodels, scikit-learn)] # 特征工程指向模型构建
D --> E[模型评估 (statsmodels, scikit-learn)] # 模型构建指向模型评估
E --> F[预测/推理] # 模型评估指向预测/推理graph LR
A[数据加载 (pandas)] --> B[数据清洗 (pandas)] # 数据加载指向数据清洗
B --> C[特征工程 (pandas, 其他工具)] # 数据清洗指向特征工程
C --> D[模型构建 (statsmodels, scikit-learn)] # 特征工程指向模型构建
D --> E[模型评估 (statsmodels, scikit-learn)] # 模型构建指向模型评估
E --> F[预测/推理] # 模型评估指向预测/推理
主要的接口通常是 NumPy 数组。pandas DataFrame 构建在 NumPy 之上，因此转换很容易。
使用 .to_numpy() 将 DataFrame 转换为 NumPy 数组：
重要提示： .to_numpy() 优于 .values。
import pandas as pd # 导入 pandas 库
import numpy as np # 导入 numpy 库
# 创建一个 DataFrame
data = pd.DataFrame({
'x0': [1, 2, 3, 4, 5], # 列 'x0'
'x1': [0.01, -0.01, 0.25, -4.1, 0.], # 列 'x1'
'y': [-1.5, 0., 3.6, 1.3, -2.] # 列 'y'
})
print(data) # 打印 DataFrame x0 x1 y
0 1 0.01 -1.5
1 2 -0.01 0.0
2 3 0.25 3.6
3 4 -4.10 1.3
4 5 0.00 -2.0从 NumPy 数组创建 DataFrame：
# 使用 NumPy 数组和列名创建 DataFrame
df2 = pd.DataFrame(data_array, columns=['one', 'two', 'three'])
print(df2) # 打印 DataFrame one two three
0 1.0 0.01 -1.5
1 2.0 -0.01 0.0
2 3.0 0.25 3.6
3 4.0 -4.10 1.3
4 5.0 0.00 -2.0我们在创建 DataFrame 时提供了列名。
dtype=object 数组（对于数值计算效率较低）。示例：
df3 = data.copy() # 复制 DataFrame
df3['strings'] = ['a', 'b', 'c', 'd', 'e'] # 添加一个字符串列
print(df3) # 打印 DataFrame
print("\n异构数组:") # 打印提示信息
print(df3.to_numpy()) # 打印异构 NumPy 数组 (数据类型是object) x0 x1 y strings
0 1 0.01 -1.5 a
1 2 -0.01 0.0 b
2 3 0.25 3.6 c
3 4 -4.10 1.3 d
4 5 0.00 -2.0 e
异构数组:
[[1 0.01 -1.5 'a']
[2 -0.01 0.0 'b']
[3 0.25 3.6 'c']
[4 -4.1 1.3 'd']
[5 0.0 -2.0 'e']]对于建模，在转换之前使用 .loc 选择列：
分类变量（例如，“male”、“female”）需要数值表示。使用虚拟变量（或独热编码）。
get_dummies() 🐼pd.get_dummies() 简化了此操作：
# 创建一个分类列
data['category'] = pd.Categorical(['a', 'b', 'a', 'a', 'b'], categories=['a', 'b'])
print(data) # 打印 DataFrame
# 使用 get_dummies() 创建虚拟变量
dummies = pd.get_dummies(data.category, prefix='category')
print("\n虚拟变量:") # 打印提示信息
print(dummies) # 打印虚拟变量 x0 x1 y category
0 1 0.01 -1.5 a
1 2 -0.01 0.0 b
2 3 0.25 3.6 a
3 4 -4.10 1.3 a
4 5 0.00 -2.0 b
虚拟变量:
category_a category_b
0 True False
1 False True
2 True False
3 True False
4 False True# 删除原始分类列，并连接虚拟变量
data_with_dummies = data.drop('category', axis=1).join(dummies)
print("\n包含虚拟变量的 DataFrame:") # 打印提示信息
print(data_with_dummies) # 打印包含虚拟变量的 DataFrame
包含虚拟变量的 DataFrame:
x0 x1 y category_a category_b
0 1 0.01 -1.5 True False
1 2 -0.01 0.0 False True
2 3 0.25 3.6 True False
3 4 -4.10 1.3 True False
4 5 0.00 -2.0 False Trueprefix 添加一个前缀（例如，category_a）。
Patsy 使用公式语法（类似于 R）来指定模型，尤其是线性模型。
它随 statsmodels 一起安装： conda install statsmodels
示例公式：
# y ~ x0 + x1y：因变量（响应变量）。x0, x1：自变量（预测变量）。~：分隔左侧（响应变量）和右侧（预测变量）。+：包含项（不是数学加法！）。patsy.dmatrices() 🧮dmatrices() 接受一个公式和数据，返回设计矩阵：
import patsy # 导入 patsy 库
# 使用 dmatrices() 创建设计矩阵
y, X = patsy.dmatrices('y ~ x0 + x1', data)
print("y (响应变量的设计矩阵):") # 打印提示信息
print(y) # 打印响应变量的设计矩阵
print("\nX (预测变量的设计矩阵):") # 打印提示信息
print(X) # 打印预测变量的设计矩阵y (响应变量的设计矩阵):
[[-1.5]
[ 0. ]
[ 3.6]
[ 1.3]
[-2. ]]
X (预测变量的设计矩阵):
[[ 1. 1. 0.01]
[ 1. 2. -0.01]
[ 1. 3. 0.25]
[ 1. 4. -4.1 ]
[ 1. 5. 0. ]]Patsy 默认包含一个截距（一列 1）——当预测变量为零时的基线响应。
使用 + 0 删除截距：
Patsy 中的设计矩阵可与 NumPy（例如 np.linalg.lstsq）或 statsmodels 一起使用：
import numpy as np # 导入 numpy 库
# 使用 NumPy 的最小二乘法拟合线性模型
coef, resid, _, _ = np.linalg.lstsq(X, y, rcond=None) # 添加 rcond=None 以兼容
print(coef) # 打印系数
# 将系数转换为 pandas Series
coef = pd.Series(coef.squeeze(), index=X.design_info.column_names)
print(coef) # 打印带有索引的系数[[ 0.31290976]
[-0.07910564]
[-0.26546384]]
Intercept 0.312910
x0 -0.079106
x1 -0.265464
dtype: float64在公式中包含 Python 代码以进行转换：
# 在公式中使用 Python 函数进行数据转换
y, X = patsy.dmatrices('y ~ x0 + np.log(np.abs(x1) + 1)', data)
print(X) # 打印转换后的 X[[1. 1. 0.00995033]
[1. 2. 0.00995033]
[1. 3. 0.22314355]
[1. 4. 1.62924054]
[1. 5. 0. ]]Patsy 在作用域中查找 np.log 等函数。
standardize、center 🛠️Patsy 具有内置函数：
standardize(x)：标准化 x（均值为 0，标准差为 1）。center(x)：减去均值。build_design_matrices 💾当应用像center和standardize这样的转换时，在转换新数据时使用原始数据集的统计数据。 patsy.build_design_matrices 可以提供帮助：
# 创建新数据
new_data = pd.DataFrame({
'x0': [6, 7, 8, 9],
'x1': [3.1, -0.5, 0, 2.3],
'y' : [1, 2, 3, 4]
})
# 使用原始 X 的 design_info 构建新数据的设计矩阵
new_X = patsy.build_design_matrices([X.design_info], new_data)
print(new_X) # 打印新数据的设计矩阵[DesignMatrix with shape (4, 3)
Intercept standardize(x0) center(x1)
1 2.12132 3.87
1 2.82843 0.27
1 3.53553 0.77
1 4.24264 3.07
Terms:
'Intercept' (column 0)
'standardize(x0)' (column 1)
'center(x1)' (column 2)]要添加列，请将它们包装在 I() 中：
Patsy 自动处理分类变量：
# 创建一个包含分类变量的 DataFrame
data = pd.DataFrame({
'key1': ['a', 'a', 'b', 'b', 'a', 'b', 'a', 'b'],
'key2': [0, 1, 0, 1, 0, 1, 0, 0],
'v1': [1, 2, 3, 4, 5, 6, 7, 8],
'v2': [-1, 0, 2.5, -0.5, 4.0, -1.2, 0.2, -1.7]
})
# 使用 Patsy 处理分类变量
y, X = patsy.dmatrices('v2 ~ key1', data)
print(X) # 打印设计矩阵[[1. 0.]
[1. 0.]
[1. 1.]
[1. 1.]
[1. 0.]
[1. 1.]
[1. 0.]
[1. 1.]]Patsy 省略了一个级别以避免共线性（与截距）。
没有截距时，将包含所有类别列：
使用 C() 将数字视为分类变量：
交互项对组合效应进行建模。使用 :：
# 将 key2 映射为字符串
data['key2'] = data['key2'].map({0: 'zero', 1: 'one'})
print(data) # 打印 DataFrame
# 创建包含交互项的设计矩阵
y, X = patsy.dmatrices('v2 ~ key1 + key2 + key1:key2', data)
print(X) # 打印设计矩阵 key1 key2 v1 v2
0 a zero 1 -1.0
1 a one 2 0.0
2 b zero 3 2.5
3 b one 4 -0.5
4 a zero 5 4.0
5 b one 6 -1.2
6 a zero 7 0.2
7 b zero 8 -1.7
[[1. 0. 1. 0.]
[1. 0. 0. 0.]
[1. 1. 1. 1.]
[1. 1. 0. 0.]
[1. 0. 1. 0.]
[1. 1. 0. 0.]
[1. 0. 1. 0.]
[1. 1. 1. 1.]]statsmodels 用于统计建模、假设检验和数据探索。它侧重于统计推断，与 scikit-learn 互补。
statsmodels 包括：
使用数组和公式 API 拟合线性模型。
创建示例数据：
import statsmodels.api as sm # 导入 statsmodels.api 模块
import statsmodels.formula.api as smf # 导入 statsmodels.formula.api 模块
# 可重现的示例
rng = np.random.default_rng(seed=12345) # 设置随机数种子以实现可重复性
# 定义一个生成正态分布随机数的函数
def dnorm(mean, variance, size=1):
if isinstance(size, int): # 如果 size 是整数
size = size, # 将其转换为元组
return mean + np.sqrt(variance) * rng.standard_normal(*size) # 生成正态分布随机数
N = 100 # 样本数量
# 生成自变量 X
X = np.c_[dnorm(0, 0.4, size=N),
dnorm(0, 0.6, size=N),
dnorm(0, 0.2, size=N)]
eps = dnorm(0, 0.1, size=N) # 生成随机误差项
beta = [0.1, 0.3, 0.5] # 系数
y = np.dot(X, beta) + eps # 生成因变量 yX_model = sm.add_constant(X) # 添加截距项
model = sm.OLS(y, X_model) # 创建普通最小二乘 (OLS) 模型
results = model.fit() # 拟合模型
print(results.params) # 打印模型参数
print(results.summary()) # 打印模型摘要[-0.02079903 0.06581276 0.26897046 0.44941894]
OLS Regression Results
==============================================================================
Dep. Variable: y R-squared: 0.470
Model: OLS Adj. R-squared: 0.453
Method: Least Squares F-statistic: 28.36
Date: Wed, 02 Apr 2025 Prob (F-statistic): 3.23e-13
Time: 13:35:13 Log-Likelihood: -25.390
No. Observations: 100 AIC: 58.78
Df Residuals: 96 BIC: 69.20
Df Model: 3
Covariance Type: nonrobust
==============================================================================
coef std err t P>|t| [0.025 0.975]
------------------------------------------------------------------------------
const -0.0208 0.032 -0.653 0.516 -0.084 0.042
x1 0.0658 0.054 1.220 0.226 -0.041 0.173
x2 0.2690 0.043 6.312 0.000 0.184 0.354
x3 0.4494 0.068 6.567 0.000 0.314 0.585
==============================================================================
Omnibus: 0.429 Durbin-Watson: 1.878
Prob(Omnibus): 0.807 Jarque-Bera (JB): 0.296
Skew: 0.133 Prob(JB): 0.863
Kurtosis: 2.995 Cond. No. 2.16
==============================================================================
Notes:
[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.sm.add_constant(X) 添加一列 1 以表示截距。
# 创建包含自变量和因变量的 DataFrame
data = pd.DataFrame(X, columns=['col0', 'col1', 'col2'])
data['y'] = y
# 使用公式 API 拟合 OLS 模型
results = smf.ols('y ~ col0 + col1 + col2', data=data).fit()
print(results.params) # 打印模型参数
print(results.tvalues) # 打印 t 值
print(results.predict(data[:5])) # 对前 5 个样本进行预测Intercept -0.020799
col0 0.065813
col1 0.268970
col2 0.449419
dtype: float64
Intercept -0.652501
col0 1.219768
col1 6.312369
col2 6.567428
dtype: float64
0 -0.592959
1 -0.531160
2 0.058636
3 0.283658
4 -0.102947
dtype: float64公式 API 处理截距并与 DataFrame 一起使用。
statsmodels 具有时间序列工具。示例：自回归 (AR) 模型：
from statsmodels.tsa.ar_model import AutoReg # 导入 AutoReg 类
init_x = 4 # 初始值
values = [init_x, init_x] # 初始值列表
N = 1000 # 时间序列长度
b0 = 0.8 # AR(1) 系数
b1 = -0.4 # AR(2) 系数
noise = dnorm(0, 0.1, N) # 生成噪声
# 生成 AR(2) 时间序列
for i in range(N):
new_x = values[-1] * b0 + values[-2] * b1 + noise[i]
values.append(new_x)
MAXLAGS = 5 # 最大滞后阶数
model = AutoReg(values, MAXLAGS) # 创建 AutoReg 模型
results = model.fit() # 拟合模型
print(results.params) # 打印模型参数[ 0.02346612 0.8096828 -0.42865278 -0.03336517 0.04267874 -0.05671529]scikit-learn 是一个强大、广泛使用的机器学习库。它具有用于分类、回归、聚类等的算法。
使用泰坦尼克号数据集展示 scikit-learn 工作流程。
| PassengerId | Survived | Pclass | Name | Sex | Age | SibSp | Parch | Ticket | Fare | Cabin | Embarked | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 1 | 0 | 3 | Braund, Mr. Owen Harris | male | 22.0 | 1 | 0 | A/5 21171 | 7.2500 | NaN | S |
| 1 | 2 | 1 | 1 | Cumings, Mrs. John Bradley (Florence Briggs Th... | female | 38.0 | 1 | 0 | PC 17599 | 71.2833 | C85 | C |
| 2 | 3 | 1 | 3 | Heikkinen, Miss. Laina | female | 26.0 | 0 | 0 | STON/O2. 3101282 | 7.9250 | NaN | S |
| 3 | 4 | 1 | 1 | Futrelle, Mrs. Jacques Heath (Lily May Peel) | female | 35.0 | 1 | 0 | 113803 | 53.1000 | C123 | S |
impute_value = train['Age'].median() # 计算 'Age' 列的中位数
train['Age'] = train['Age'].fillna(impute_value) # 使用中位数填充 'Age' 列中的缺失值
test['Age'] = test['Age'].fillna(impute_value) # 使用中位数填充 'Age' 列中的缺失值
# 创建一个新特征 'IsFemale'
train['IsFemale'] = (train['Sex'] == 'female').astype(int)
test['IsFemale'] = (test['Sex'] == 'female').astype(int)
# 定义预测变量
predictors = ['Pclass', 'IsFemale', 'Age']
X_train = train[predictors].to_numpy() # 获取训练集的特征
X_test = test[predictors].to_numpy() # 获取测试集的特征
y_train = train['Survived'].to_numpy() # 获取训练集的标签
print(X_train[:5]) # 打印前 5 个训练样本的特征
print(y_train[:5]) # 打印前 5 个训练样本的标签[[ 3. 0. 22.]
[ 1. 1. 38.]
[ 3. 1. 26.]
[ 1. 1. 35.]
[ 3. 0. 35.]]
[0 1 1 1 0]from sklearn.linear_model import LogisticRegressionCV # 导入 LogisticRegressionCV 类
from sklearn.model_selection import cross_val_score # 导入 cross_val_score 函数
# 使用交叉验证创建 LogisticRegression 模型
model_cv = LogisticRegressionCV(Cs=10)
model_cv.fit(X_train, y_train) # 使用训练数据训练模型
# 使用交叉验证评估模型
model = LogisticRegression(C=10)
scores = cross_val_score(model, X_train, y_train, cv=4) # 进行 4 折交叉验证
print(scores) # 打印交叉验证分数[0.77578475 0.79820628 0.77578475 0.78828829]交叉验证有助于避免过拟合，并提供更稳健的模型。
statsmodels 和 scikit-learn 将 pandas 数据整理和模型构建联系起来。.to_numpy() 将 DataFrame 转换为 NumPy 数组。statsmodels 擅长统计推断。scikit-learn 对于许多机器学习任务具有通用性。statsmodels 和 scikit-learn 之间进行选择？考虑推断与预测。