未记录事实核验 · 状态：维护中
记录仅说明核验时间与维护状态，不保证适用于所有环境；使用前请留意正文中的版本、适用条件与风险提示。
warning 适用边界与维护说明
本文适合学习回归原理、合成数据建模、正则化调参与模型比较，不是经真实电商数据验证的预测方案。regularization_comparison仍在交叉验证前对整个训练集拟合标准化器，验证折参与了预处理参数估计；多项式度数及电商最佳模型使用名为测试集的数据选型，选型后的分数与残差不能视为独立的最终泛化评估。真实销售预测需结合时间顺序及预测时可获得的特征设计验证。OLS逆矩阵表达式要求设计矩阵满列秩；电商案例的系数排序基于标准化特征，不代表业务因果影响。MAPE在目标值含零时返回NaN，R²可能为负，这两项已在正文正确处理。本次仅作结构审阅，未执行代码或开展外部事实核验。
回归算法技术详解
abstract 本章概览
- 线性回归数学原理：最小二乘法和梯度下降
- 多项式回归：非线性关系建模技术
- 正则化方法：Ridge、Lasso、ElasticNet详解
- 逻辑回归：分类问题的概率建模
- 高级算法：SVR和树回归简介
- 模型评估：MSE、MAE、R²指标体系
- 业务案例：电商销售预测完整实现
回归算法基础
回归算法是监督学习的核心技术，用于预测连续数值型目标变量。其数学表达为：
y = f(X) + ε
其中：
- y：目标变量（连续值）
- X：特征矩阵
- f(X)：回归函数
- ε：随机误差项
核心算法分类
线性回归族：
- 简单线性回归：单特征线性关系
- 多元线性回归：多特征线性组合
- 多项式回归：非线性关系建模
正则化回归：
- Ridge回归：L2正则化
- Lasso回归：L1正则化
- ElasticNet：L1+L2正则化
高级回归：
- 逻辑回归：概率分类模型
- 支持向量回归：SVM扩展
- 树回归：决策树预测
# 核心库导入
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet, LogisticRegression
from sklearn.svm import SVR
from sklearn.tree import DecisionTreeRegressor
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
线性回归数学原理
最小二乘法（OLS）
线性回归的核心是找到最优参数β，使预测误差最小化：
目标函数：
min J(β) = Σᵢ(yᵢ - ŷᵢ)² = ||y - Xβ||²
闭式解：
β = (XᵀX)⁻¹Xᵀy
梯度下降解：
βₜ₊₁ = βₜ - α∇J(βₜ)
简单线性回归实现
def linear_regression_from_scratch():
"""从零实现线性回归"""
# 生成数据
np.random.seed(42)
X = np.random.randn(100, 1)
y = 2 * X.ravel() + 1 + 0.1 * np.random.randn(100)
# 添加偏置项
X_bias = np.c_[np.ones(X.shape[0]), X]
# 最小二乘解
beta_ols = np.linalg.inv(X_bias.T @ X_bias) @ X_bias.T @ y
# 梯度下降解
def gradient_descent(X, y, lr=0.01, epochs=1000):
m, n = X.shape
beta = np.zeros(n)
for _ in range(epochs):
y_pred = X @ beta
gradient = (2/m) * X.T @ (y_pred - y)
beta -= lr * gradient
return beta
beta_gd = gradient_descent(X_bias, y)
print(f"最小二乘解: β₀={beta_ols[0]:.3f}, β₁={beta_ols[1]:.3f}")
print(f"梯度下降解: β₀={beta_gd[0]:.3f}, β₁={beta_gd[1]:.3f}")
print(f"真实参数: β₀=1.000, β₁=2.000")
return X, y, beta_ols
# scikit-learn实现对比
def sklearn_linear_regression():
"""使用sklearn的线性回归"""
X, y, beta_true = linear_regression_from_scratch()
# sklearn模型
model = LinearRegression()
model.fit(X, y)
# 预测和评估
y_pred = model.predict(X)
print(f"\nSklearn结果:")
print(f"截距: {model.intercept_:.3f}")
print(f"系数: {model.coef_[0]:.3f}")
print(f"R²: {r2_score(y, y_pred):.3f}")
print(f"MSE: {mean_squared_error(y, y_pred):.3f}")
return model
多元线性回归
多元线性回归扩展到多个特征： y = β₀ + β₁x₁ + β₂x₂ + ... + βₚxₚ + ε
矩阵形式：
y = Xβ + ε
其中X为特征矩阵，β为参数向量。
def multiple_regression_analysis():
"""多元线性回归分析"""
# 生成合成数据
np.random.seed(42)
n_samples, n_features = 1000, 5
# 特征矩阵（带相关性）
X = np.random.randn(n_samples, n_features)
# 引入特征相关性
X[:, 1] += 0.5 * X[:, 0] # x1和x0相关
# 真实系数
true_coef = np.array([2, -1, 0.5, 0, -1.5])
# 目标变量
y = X @ true_coef + 0.1 * np.random.randn(n_samples)
# 数据分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# 特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 训练模型
model = LinearRegression()
model.fit(X_train_scaled, y_train)
# 预测
y_pred = model.predict(X_test_scaled)
# 多重共线性检验（方差膨胀因子）
from statsmodels.stats.outliers_influence import variance_inflation_factor
vif_data = pd.DataFrame()
vif_data["Feature"] = [f"X{i}" for i in range(n_features)]
vif_data["VIF"] = [variance_inflation_factor(X_train_scaled, i)
for i in range(n_features)]
print("多重共线性检验 (VIF > 5表示存在共线性):")
print(vif_data)
# 模型评估
print(f"\n模型性能:")
print(f"R²: {r2_score(y_test, y_pred):.4f}")
print(f"MSE: {mean_squared_error(y_test, y_pred):.4f}")
# 系数对比
coef_comparison = pd.DataFrame({
'True_Coef': true_coef,
'Estimated_Coef': model.coef_ / scaler.scale_,
'Difference': np.abs(true_coef - model.coef_ / scaler.scale_)
})
print("\n系数估计对比:")
print(coef_comparison)
return model, X_test_scaled, y_test
多项式回归
非线性关系建模
多项式回归通过特征变换处理非线性关系： y = β₀ + β₁x + β₂x² + ... + βᵈxᵈ + ε
特征变换：
X = [1, x, x², x³, ..., xᵈ]
def polynomial_regression_analysis():
"""多项式回归完整分析"""
# 生成非线性数据
np.random.seed(42)
x = np.linspace(-2, 2, 100)
# 真实函数: y = 0.5x³ - 2x² + x + 1
y_true = 0.5 * x**3 - 2 * x**2 + x + 1
y = y_true + 0.3 * np.random.randn(len(x))
X = x.reshape(-1, 1)
# 数据分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# 不同多项式度数的偏差-方差权衡
degrees = range(1, 16)
train_scores = []
val_scores = []
for degree in degrees:
# 多项式特征变换
poly = PolynomialFeatures(degree=degree)
X_poly_train = poly.fit_transform(X_train)
X_poly_test = poly.transform(X_test)
# 训练模型
model = LinearRegression()
model.fit(X_poly_train, y_train)
# 计算训练和验证分数
train_score = model.score(X_poly_train, y_train)
val_score = model.score(X_poly_test, y_test)
train_scores.append(train_score)
val_scores.append(val_score)
# 找到最优度数
optimal_degree = degrees[np.argmax(val_scores)]
print(f"最优多项式度数: {optimal_degree}")
print(f"最佳验证分数: {max(val_scores):.4f}")
# 可视化偏差-方差权衡
plt.figure(figsize=(10, 6))
plt.plot(degrees, train_scores, 'b-', label='训练分数', marker='o')
plt.plot(degrees, val_scores, 'r-', label='验证分数', marker='s')
plt.axvline(optimal_degree, color='g', linestyle='--',
label=f'最优度数={optimal_degree}')
plt.xlabel('多项式度数')
plt.ylabel('R² 分数')
plt.legend()
plt.title('多项式回归：偏差-方差权衡')
plt.grid(True, alpha=0.3)
plt.show()
return optimal_degree, X, y
正则化回归技术
正则化通过在损失函数中添加惩罚项来防止过拟合：
Ridge回归（L2正则化）
目标函数：
J(β) = ||y - Xβ||² + α||β||²₂
闭式解：
β = (XᵀX + αI)⁻¹Xᵀy
Lasso回归（L1正则化）
目标函数：
J(β) = ||y - Xβ||² + α||β||₁
L1正则化具有特征选择能力，能将不重要特征的系数置零。
ElasticNet（L1+L2正则化）
目标函数：
J(β) = ||y - Xβ||² + α₁||β||₁ + α₂||β||²₂
def regularization_comparison():
"""正则化方法对比分析"""
from sklearn.linear_model import ElasticNet
from sklearn.model_selection import GridSearchCV
# 生成高维稀疏数据
np.random.seed(42)
n_samples, n_features = 100, 50
# 只有前5个特征有用
X = np.random.randn(n_samples, n_features)
true_coef = np.zeros(n_features)
true_coef[:5] = [2, -1.5, 1, 0.5, -2]
y = X @ true_coef + 0.1 * np.random.randn(n_samples)
# 数据分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
# 标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 超参数网格搜索
alphas = np.logspace(-3, 1, 20)
models = {
'Ridge': GridSearchCV(Ridge(), {'alpha': alphas}, cv=5),
'Lasso': GridSearchCV(Lasso(), {'alpha': alphas}, cv=5),
'ElasticNet': GridSearchCV(ElasticNet(),
{'alpha': alphas, 'l1_ratio': [0.1, 0.5, 0.9]},
cv=5)
}
results = {}
for name, model in models.items():
# 训练和预测
model.fit(X_train_scaled, y_train)
y_pred = model.predict(X_test_scaled)
# 性能指标
r2 = r2_score(y_test, y_pred)
mse = mean_squared_error(y_test, y_pred)
# 系数分析
coef = model.best_estimator_.coef_ / scaler.scale_
n_selected = np.sum(np.abs(coef) > 1e-5)
results[name] = {
'best_params': model.best_params_,
'r2': r2,
'mse': mse,
'n_selected': n_selected,
'coef': coef
}
print(f"{name}:")
print(f" 最佳参数: {model.best_params_}")
print(f" R²: {r2:.4f}")
print(f" MSE: {mse:.4f}")
print(f" 选择特征数: {n_selected}")
# 可视化系数路径
plt.figure(figsize=(15, 5))
for i, (name, result) in enumerate(results.items()):
plt.subplot(1, 3, i+1)
# 显示前10个特征的系数
coef_data = result['coef'][:10]
true_coef_data = true_coef[:10]
x = np.arange(10)
plt.bar(x - 0.2, true_coef_data, 0.4, label='真实系数', alpha=0.7)
plt.bar(x + 0.2, coef_data, 0.4, label='估计系数', alpha=0.7)
plt.xlabel('特征索引')
plt.ylabel('系数值')
plt.title(f'{name} 系数对比')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
return results
逻辑回归
虽然名为"回归"，逻辑回归实际上是分类算法，但其技术原理与线性回归密切相关。
数学原理
Sigmoid函数：
σ(z) = 1 / (1 + e⁻ᶻ)
概率建模：
P(y=1|x) = σ(β₀ + β₁x₁ + ... + βₚxₚ)
对数似然损失：
J(β) = -Σ[yᵢlog(pᵢ) + (1-yᵢ)log(1-pᵢ)]
def logistic_regression_demo():
"""逻辑回归演示"""
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report
# 生成分类数据
X, y = make_classification(n_samples=1000, n_features=2,
n_redundant=0, n_informative=2,
random_state=42)
# 数据分割
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
# 标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 逻辑回归模型
log_reg = LogisticRegression(random_state=42)
log_reg.fit(X_train_scaled, y_train)
# 预测
y_pred = log_reg.predict(X_test_scaled)
y_prob = log_reg.predict_proba(X_test_scaled)
# 评估
accuracy = accuracy_score(y_test, y_pred)
print(f"逻辑回归准确率: {accuracy:.4f}")
print("\n分类报告:")
print(classification_report(y_test, y_pred))
# 决策边界可视化
plt.figure(figsize=(12, 4))
# 原始数据分布
plt.subplot(1, 2, 1)
plt.scatter(X[y==0, 0], X[y==0, 1], c='red', alpha=0.6, label='类别 0')
plt.scatter(X[y==1, 0], X[y==1, 1], c='blue', alpha=0.6, label='类别 1')
plt.xlabel('特征 1')
plt.ylabel('特征 2')
plt.title('原始数据分布')
plt.legend()
plt.grid(True, alpha=0.3)
# 决策边界
plt.subplot(1, 2, 2)
h = 0.02
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
mesh_points = np.c_[xx.ravel(), yy.ravel()]
mesh_scaled = scaler.transform(mesh_points)
Z = log_reg.predict_proba(mesh_scaled)[:, 1]
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, levels=50, alpha=0.3, cmap='RdYlBu')
plt.scatter(X[y==0, 0], X[y==0, 1], c='red', alpha=0.8, label='类别 0')
plt.scatter(X[y==1, 0], X[y==1, 1], c='blue', alpha=0.8, label='类别 1')
plt.xlabel('特征 1')
plt.ylabel('特征 2')
plt.title('逻辑回归决策边界')
plt.legend()
plt.tight_layout()
plt.show()
return log_reg, X_test_scaled, y_test
高级回归算法简介
支持向量回归（SVR）
def svr_demo():
"""支持向量回归演示"""
from sklearn.svm import SVR
# 生成非线性数据
np.random.seed(42)
X = np.sort(5 * np.random.rand(100, 1), axis=0)
y = np.sin(X).ravel() + 0.1 * np.random.randn(100)
# SVR模型（不同核函数）
svr_models = {
'Linear': SVR(kernel='linear', C=1.0),
'RBF': SVR(kernel='rbf', C=1.0, gamma=0.1),
'Polynomial': SVR(kernel='poly', C=1.0, degree=3)
}
plt.figure(figsize=(15, 5))
for i, (name, model) in enumerate(svr_models.items()):
model.fit(X, y)
y_pred = model.predict(X)
plt.subplot(1, 3, i+1)
plt.scatter(X, y, alpha=0.6, label='数据')
plt.plot(X, y_pred, color='red', linewidth=2, label=f'SVR-{name}')
plt.xlabel('X')
plt.ylabel('Y')
plt.title(f'SVR - {name} 核')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
决策树回归
def tree_regression_demo():
"""决策树回归演示"""
from sklearn.tree import DecisionTreeRegressor
# 使用之前的数据
X, y = polynomial_regression_analysis()[1:]
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# 不同深度的决策树
depths = [2, 5, 10, None]
plt.figure(figsize=(15, 4))
for i, depth in enumerate(depths):
tree_reg = DecisionTreeRegressor(max_depth=depth, random_state=42)
tree_reg.fit(X_train, y_train)
# 预测
X_plot = np.linspace(X.min(), X.max(), 300).reshape(-1, 1)
y_plot_pred = tree_reg.predict(X_plot)
plt.subplot(1, 4, i+1)
plt.scatter(X, y, alpha=0.6, s=20, label='数据')
plt.plot(X_plot, y_plot_pred, color='red', linewidth=2,
label=f'深度={depth}')
plt.xlabel('X')
plt.ylabel('Y')
plt.title(f'决策树回归 (深度={depth})')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
模型评估指标详解
回归指标体系
def comprehensive_regression_metrics():
"""回归评估指标详解"""
def calculate_metrics(y_true, y_pred):
"""计算所有回归指标"""
# 基本指标
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
mae = mean_absolute_error(y_true, y_pred)
r2 = r2_score(y_true, y_pred)
# 高级指标
def mean_absolute_percentage_error(y_true, y_pred):
y_true = np.asarray(y_true)
y_pred = np.asarray(y_pred)
if np.any(y_true == 0):
return np.nan # 含零目标值时不报告常规定义的MAPE
return np.mean(np.abs((y_true - y_pred) / y_true)) * 100
def adjusted_r2(y_true, y_pred, n_features):
n = len(y_true)
adj_r2 = 1 - (1 - r2) * (n - 1) / (n - n_features - 1)
return adj_r2
mape = mean_absolute_percentage_error(y_true, y_pred)
return {
'MSE': mse,
'RMSE': rmse,
'MAE': mae,
'R²': r2,
'MAPE': mape
}
# 指标解释
print("回归评估指标解释:")
print("\n1. MSE (均方误差):")
print(" - 公式: MSE = Σ(yᵢ - ŷᵢ)² / n")
print(" - 特点: 对大误差敏感，单位是目标变量的平方")
print("\n2. RMSE (均方根误差):")
print(" - 公式: RMSE = √MSE")
print(" - 特点: 与目标变量同单位，便于理解")
print("\n3. MAE (平均绝对误差):")
print(" - 公式: MAE = Σ|yᵢ - ŷᵢ| / n")
print(" - 特点: 对异常值鲁棒，线性惩罚")
print("\n4. R² (决定系数):")
print(" - 公式: R² = 1 - SS_res/SS_tot")
print(" - 特点: 非常数目标下通常不超过1，也可能为负；同一评估集上越接近1越好")
print("\n5. MAPE (平均绝对百分比误差):")
print(" - 公式: MAPE = (1/n)Σ(|yᵢ - ŷᵢ|/|yᵢ|) × 100%，要求所有yᵢ非零")
print(" - 特点: 百分比形式，便于跨项目对比")
return calculate_metrics
业务案例：电商销售预测
def ecommerce_sales_prediction():
"""电商销售预测完整案例"""
# 模拟电商销售数据
np.random.seed(42)
n_samples = 1000
# 特征工程
data = {
'price': np.random.uniform(10, 100, n_samples),
'discount_rate': np.random.uniform(0, 0.5, n_samples),
'review_score': np.random.uniform(1, 5, n_samples),
'competitor_price': np.random.uniform(10, 120, n_samples),
'season': np.random.choice([0, 1, 2, 3], n_samples), # 春夏秋冬
'marketing_spend': np.random.uniform(100, 1000, n_samples),
'inventory_level': np.random.uniform(0, 100, n_samples)
}
df = pd.DataFrame(data)
# 构造目标变量（销售量）
# 销售量受价格、折扣、评分等因素影响
sales = (
-0.5 * df['price'] +
300 * df['discount_rate'] +
50 * df['review_score'] +
0.3 * df['marketing_spend'] +
-0.2 * df['competitor_price'] +
20 * (df['season'] == 3) + # 冬季销售更好
np.random.normal(0, 20, n_samples)
)
# 将模拟销售量截断为非负数，允许为零
df['sales'] = np.maximum(sales, 0)
print("电商销售数据概览:")
print(df.describe())
# 特征工程
# 1. 价格竞争力指标
df['price_competitiveness'] = df['competitor_price'] / df['price']
# 2. 营销效率
df['marketing_efficiency'] = df['marketing_spend'] / df['price']
# 3. 季节性处理（独热编码）
season_dummies = pd.get_dummies(df['season'], prefix='season')
df = pd.concat([df, season_dummies], axis=1)
df.drop('season', axis=1, inplace=True)
# 数据分割
X = df.drop('sales', axis=1)
y = df['sales']
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
# 特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 模型对比
models = {
'Linear': LinearRegression(),
'Ridge': Ridge(alpha=1.0),
'Lasso': Lasso(alpha=0.1),
'ElasticNet': ElasticNet(alpha=0.1, l1_ratio=0.5),
'SVR': SVR(kernel='rbf', C=1.0, gamma=0.1)
}
results = {}
calc_metrics = comprehensive_regression_metrics()
for name, model in models.items():
# 训练
model.fit(X_train_scaled, y_train)
# 预测
y_pred = model.predict(X_test_scaled)
# 评估
metrics = calc_metrics(y_test, y_pred)
results[name] = {
'model': model,
'predictions': y_pred,
'metrics': metrics
}
print(f"\n{name} 模型结果:")
for metric_name, value in metrics.items():
print(f" {metric_name}: {value:.4f}")
# 特征重要性分析（针对线性模型）
linear_model = results['Linear']['model']
feature_importance = pd.DataFrame({
'feature': X.columns,
'coefficient': linear_model.coef_,
'abs_coefficient': np.abs(linear_model.coef_)
}).sort_values('abs_coefficient', ascending=False)
print("\n特征重要性排序:")
print(feature_importance)
# 可视化模型对比
plt.figure(figsize=(15, 10))
# 1. 预测vs实际
plt.subplot(2, 3, 1)
for name, result in results.items():
if name in ['Linear', 'Ridge', 'Lasso']:
plt.scatter(y_test, result['predictions'], alpha=0.6, label=name)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')
plt.xlabel('实际销售量')
plt.ylabel('预测销售量')
plt.title('预测vs实际销售量')
plt.legend()
plt.grid(True, alpha=0.3)
# 2. 模型性能对比
plt.subplot(2, 3, 2)
model_names = list(results.keys())
r2_scores = [results[name]['metrics']['R²'] for name in model_names]
plt.bar(model_names, r2_scores)
plt.xlabel('模型')
plt.ylabel('R² Score')
plt.title('模型R²对比')
plt.xticks(rotation=45)
plt.grid(True, alpha=0.3)
# 3. 特征重要性
plt.subplot(2, 3, 3)
top_features = feature_importance.head(8)
plt.barh(top_features['feature'], top_features['abs_coefficient'])
plt.xlabel('系数绝对值')
plt.title('特征重要性')
plt.grid(True, alpha=0.3)
# 4. 残差分析
plt.subplot(2, 3, 4)
best_model = max(results.items(), key=lambda x: x[1]['metrics']['R²'])
residuals = y_test - best_model[1]['predictions']
plt.scatter(best_model[1]['predictions'], residuals, alpha=0.6)
plt.axhline(y=0, color='red', linestyle='--')
plt.xlabel('预测值')
plt.ylabel('残差')
plt.title(f'{best_model[0]} 残差图')
plt.grid(True, alpha=0.3)
# 5. 误差分布
plt.subplot(2, 3, 5)
plt.hist(residuals, bins=20, alpha=0.7, edgecolor='black')
plt.xlabel('残差')
plt.ylabel('频率')
plt.title('残差分布')
plt.grid(True, alpha=0.3)
# 6. 业务洞察
plt.subplot(2, 3, 6)
# 价格vs销售量关系
plt.scatter(df['price'], df['sales'], alpha=0.6, c=df['discount_rate'],
cmap='viridis')
plt.colorbar(label='折扣率')
plt.xlabel('价格')
plt.ylabel('销售量')
plt.title('价格-销售量关系（颜色表示折扣率）')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
return results, df
最佳实践与总结
模型选择策略
- 线性回归：数据量大、特征与目标呈线性关系
- Ridge回归：存在多重共线性、需要保留所有特征
- Lasso回归：需要特征选择、追求模型可解释性
- ElasticNet：兼顾特征选择和共线性处理
- SVR：非线性关系复杂、对异常值有要求
- 树回归：特征交互复杂、可解释性要求不高
实践建议
- 数据预处理：特征标准化、异常值处理、缺失值填充
- 特征工程：多项式特征、交互特征、领域知识特征
- 模型验证：交叉验证、时间序列分割、偏差-方差分析
- 超参数调优：网格搜索、贝叶斯优化、随机搜索
- 模型诊断：残差分析、Cook距离、影响力分析
相关链接：
标签：#回归算法 #线性回归 #正则化 #机器学习 #Python #预测建模 #业务分析