概念：随机森林是一种集成学习算法，通过构建多棵决策树并综合它们的预测结果来提高泛化能力。
原理：使用Bootstrap抽样生成多个训练子集，每个子集训练一棵决策树，在树的生成过程中随机选择部分特征进行划分。最终预测为所有树预测的平均值。
思想：通过集成多棵树的预测，降低单棵树的方差，提高模型的稳定性和准确性。
应用：各种回归问题，尤其适用于高维数据和复杂非线性关系。
-数据预处理：
-模型构建：
-训练：
-评估：
-可视化：
-保存结果：
定量变量预测的机器学习模型可分为传统统计模型、树基集成模型、核方法和深度学习模型四大类，每类模型通过不同机制捕捉数据模式，适用于从线性到复杂非线性关系的预测任务。
代码涵盖了从数据准备到结果保存的自动化过程，包括数据预处理、模型配置、性能评估和报告生成。
# pip install pandas numpy matplotlib seaborn scikit-learn scipy python-docx openpyxl joblib
import os
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.linear_model import LinearRegression
from sklearn.inspection import PartialDependenceDisplay
import scipy.stats as stats
from docx import Document
from docx.shared import Inches
import warnings
import joblib
warnings.filterwarnings('ignore')
# 设置中文字体
plt.rcParams['font.sans-serif'] = ['SimHei', 'Microsoft YaHei', 'SimSun']
plt.rcParams['axes.unicode_minus'] = False
class RandomForestAnalysis:
def __init__(self):
self.rf_model = None
self.final_rf = None
self.rf_caret = None
self.results_dir = os.path.join(os.path.expanduser("~"), "Desktop", "Results模型-RandomForest-ML")
# 创建结果目录
if not os.path.exists(self.results_dir):
os.makedirs(self.results_dir)
def load_and_preprocess_data(self):
"""加载和预处理数据"""
try:
# 读取Excel数据
file_path = os.path.join(os.path.expanduser("~"), "Desktop", "示例数据.xlsx")
self.data = pd.read_excel(file_path, sheet_name="示例数据")
print("数据基本信息:")
print(f"数据形状: {self.data.shape}")
print("\n数据类型:")
print(self.data.dtypes)
print("\n数据摘要:")
print(self.data.describe())
# 处理分类变量
categorical_columns = ['结局', '肥胖程度', '教育水平', '血型', '指标8']
for col in categorical_columns:
if col in self.data.columns:
self.data[col] = self.data[col].astype('category')
# 检查缺失值
missing_values = self.data.isnull().sum().sum()
print(f"\n总缺失值数量: {missing_values}")
# 如果有缺失值，进行简单处理
if missing_values > 0:
# 数值列用均值填充
numeric_cols = self.data.select_dtypes(include=[np.number]).columns
self.data[numeric_cols] = self.data[numeric_cols].fillna(self.data[numeric_cols].mean())
# 分类列用众数填充
for col in categorical_columns:
if col in self.data.columns and self.data[col].isnull().any():
if not self.data[col].mode().empty:
self.data[col] = self.data[col].fillna(self.data[col].mode()[0])
return True
except Exception as e:
print(f"数据加载失败: {e}")
return False
def split_data(self):
"""划分训练集和测试集"""
# 准备特征和目标变量
X = self.data.drop(['指标1', '序号'], axis=1, errors='ignore')
y = self.data['指标1']
# 对分类变量进行one-hot编码
X_encoded = pd.get_dummies(X, drop_first=True)
# 划分训练集和测试集
self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(
X_encoded, y, test_size=0.3, random_state=123
)
print(f"训练集样本数: {len(self.X_train)}")
print(f"测试集样本数: {len(self.X_test)}")
print(f"训练集特征维度: {self.X_train.shape}")
print(f"测试集特征维度: {self.X_test.shape}")
def train_random_forest(self):
"""训练随机森林模型"""
try:
# 初始随机森林模型
n_features = self.X_train.shape[1]
mtry = max(1, int(np.sqrt(n_features)))
self.rf_model = RandomForestRegressor(
n_estimators=200,
max_features=mtry,
random_state=123,
oob_score=True,
n_jobs=-1,
verbose=1
)
self.rf_model.fit(self.X_train, self.y_train)
print("初始随机森林模型训练完成")
print(f"OOB Score: {self.rf_model.oob_score_:.4f}")
except Exception as e:
print(f"随机森林模型训练失败: {e}")
# 使用简化参数重试
self.rf_model = RandomForestRegressor(
n_estimators=100,
random_state=123,
oob_score=True
)
self.rf_model.fit(self.X_train, self.y_train)
def tune_hyperparameters(self):
"""使用网格搜索调优超参数"""
try:
# 参数网格
param_grid = {
'max_features': [2, 4, 6, 8]
}
self.rf_caret = RandomForestRegressor(
n_estimators=100,
random_state=123,
oob_score=True,
n_jobs=-1
)
# 使用GridSearchCV进行调优
grid_search = GridSearchCV(
self.rf_caret, param_grid, cv=5, scoring='neg_mean_squared_error', n_jobs=-1
)
grid_search.fit(self.X_train, self.y_train)
self.best_mtry = grid_search.best_params_['max_features']
self.rf_caret = grid_search.best_estimator_
print(f"最佳max_features参数: {self.best_mtry}")
print(f"最佳交叉验证分数: {-grid_search.best_score_:.4f}")
except Exception as e:
print(f"超参数调优失败: {e}")
n_features = self.X_train.shape[1]
self.best_mtry = max(1, int(np.sqrt(n_features)))
self.rf_caret = None
def train_final_model(self):
"""使用最佳参数训练最终模型"""
try:
if hasattr(self, 'best_mtry'):
mtry = self.best_mtry
else:
n_features = self.X_train.shape[1]
mtry = max(1, int(np.sqrt(n_features)))
self.final_rf = RandomForestRegressor(
n_estimators=300,
max_features=mtry,
random_state=123,
oob_score=True,
n_jobs=-1
)
self.final_rf.fit(self.X_train, self.y_train)
print("最终随机森林模型训练完成")
print(f"最终模型OOB Score: {self.final_rf.oob_score_:.4f}")
except Exception as e:
print(f"最终模型训练失败: {e}")
self.final_rf = self.rf_model
# 保存性能指标
performance_data = {
'Dataset': ['Training', 'Training', 'Training', 'Training',
'Testing', 'Testing', 'Testing', 'Testing', 'OOB'],
'Metric': ['MSE', 'RMSE', 'MAE', 'R-squared',
'MSE', 'RMSE', 'MAE', 'R-squared', 'OOB-MSE'],
'Value': [self.mse_train, self.rmse_train, self.mae_train, self.r2_train,
self.mse_test, self.rmse_test, self.mae_test, self.r2_test,
self.oob_error if self.oob_error is not None else np.nan]
}
self.performance_df = pd.DataFrame(performance_data)
self.performance_df.to_csv(
os.path.join(self.results_dir, "随机森林模型性能_ML.csv"),
index=False, encoding='utf-8-sig'
)
print("\n模型性能指标:")
print(self.performance_df)
def get_feature_importance(self):
"""获取特征重要性"""
feature_importance = self.final_rf.feature_importances_
self.feature_importance_df = pd.DataFrame({
'Variable': self.X_train.columns,
'IncNodePurity': feature_importance
}).sort_values('IncNodePurity', ascending=False)
# 添加IncMSE占位符（在sklearn中不可用）
self.feature_importance_df['IncMSE'] = np.nan
self.feature_importance_df.to_csv(
os.path.join(self.results_dir, "随机森林变量重要性.csv"),
index=False, encoding='utf-8-sig'
)
print("\n特征重要性 (前10个):")
print(self.feature_importance_df.head(10))
def plot_feature_importance(self):
"""绘制特征重要性图"""
plt.figure(figsize=(12, 8))
top_features = self.feature_importance_df.head(15)
plt.barh(range(len(top_features)), top_features['IncNodePurity'],
color='steelblue', alpha=0.8)
plt.yticks(range(len(top_features)), top_features['Variable'])
plt.xlabel('节点纯度增加量')
plt.title('随机森林变量重要性 (节点纯度)', fontsize=16, fontweight='bold')
plt.gca().invert_yaxis()
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "variable_importance.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def plot_prediction_vs_actual(self):
"""绘制预测值与实际值对比图"""
# 合并训练集和测试集数据
pred_actual_train = pd.DataFrame({
'Dataset': 'Training',
'Actual': self.y_train,
'Predicted': self.y_pred_train
})
pred_actual_test = pd.DataFrame({
'Dataset': 'Testing',
'Actual': self.y_test,
'Predicted': self.y_pred_test
})
pred_actual_combined = pd.concat([pred_actual_train, pred_actual_test])
plt.figure(figsize=(10, 8))
colors = {'Training': 'blue', 'Testing': 'green'}
for dataset, color in colors.items():
data_subset = pred_actual_combined[pred_actual_combined['Dataset'] == dataset]
plt.scatter(data_subset['Actual'], data_subset['Predicted'],
alpha=0.6, color=color, label=dataset)
# 添加对角线
min_val = min(pred_actual_combined['Actual'].min(), pred_actual_combined['Predicted'].min())
max_val = max(pred_actual_combined['Actual'].max(), pred_actual_combined['Predicted'].max())
plt.plot([min_val, max_val], [min_val, max_val], 'r--', linewidth=2)
plt.xlabel('实际值')
plt.ylabel('预测值')
plt.title('预测值 vs 实际值 - 训练集 vs 测试集', fontsize=14, fontweight='bold')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "predicted_vs_actual.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def plot_residual_analysis(self):
"""绘制残差分析图"""
fig, axes = plt.subplots(2, 3, figsize=(18, 12))
# 计算残差
residuals_train = self.y_train - self.y_pred_train
residuals_test = self.y_test - self.y_pred_test
# 残差散点图 - 训练集
axes[0, 0].scatter(self.y_pred_train, residuals_train, alpha=0.6, color='blue')
axes[0, 0].axhline(y=0, color='red', linestyle='--')
axes[0, 0].set_xlabel('拟合值')
axes[0, 0].set_ylabel('残差')
axes[0, 0].set_title('训练集残差')
axes[0, 0].grid(True, alpha=0.3)
# 残差散点图 - 测试集
axes[0, 1].scatter(self.y_pred_test, residuals_test, alpha=0.6, color='green')
axes[0, 1].axhline(y=0, color='red', linestyle='--')
axes[0, 1].set_xlabel('拟合值')
axes[0, 1].set_ylabel('残差')
axes[0, 1].set_title('测试集残差')
axes[0, 1].grid(True, alpha=0.3)
# Q-Q图 - 训练集
stats.probplot(residuals_train, dist="norm", plot=axes[0, 2])
axes[0, 2].set_title('训练集残差Q-Q图')
# Q-Q图 - 测试集
stats.probplot(residuals_test, dist="norm", plot=axes[1, 0])
axes[1, 0].set_title('测试集残差Q-Q图')
# 残差分布 - 训练集
axes[1, 1].hist(residuals_train, bins=30, density=True, alpha=0.7, color='lightblue')
axes[1, 1].set_xlabel('残差')
axes[1, 1].set_ylabel('密度')
axes[1, 1].set_title('训练集残差分布')
# 残差分布 - 测试集
axes[1, 2].hist(residuals_test, bins=30, density=True, alpha=0.7, color='lightgreen')
axes[1, 2].set_xlabel('残差')
axes[1, 2].set_ylabel('密度')
axes[1, 2].set_title('测试集残差分布')
plt.suptitle('随机森林回归残差分析 - 训练集 vs 测试集', fontsize=16, fontweight='bold')
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "residual_analysis.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def plot_oob_error(self):
"""绘制OOB误差随树的数量变化"""
if hasattr(self.final_rf, 'estimators_'):
# 计算随着树增加时的OOB误差
oob_errors = []
for i, tree in enumerate(self.final_rf.estimators_):
# 使用前i+1棵树计算OOB误差
trees_subset = self.final_rf.estimators_[:i + 1]
# 创建临时随机森林来计算OOB预测
temp_rf = RandomForestRegressor()
temp_rf.estimators_ = trees_subset
temp_rf.n_estimators = len(trees_subset)
temp_rf.oob_prediction_ = self._calculate_oob_predictions(trees_subset)
if temp_rf.oob_prediction_ is not None:
oob_error = mean_squared_error(self.y_train, temp_rf.oob_prediction_)
oob_errors.append(oob_error)
else:
oob_errors.append(np.nan)
# 绘制OOB误差曲线
plt.figure(figsize=(10, 6))
plt.plot(range(1, len(oob_errors) + 1), oob_errors, color='steelblue', linewidth=2)
plt.xlabel('树的数量')
plt.ylabel('OOB均方误差')
plt.title('OOB误差随树的数量变化', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "oob_error.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def _calculate_oob_predictions(self, trees):
"""计算OOB预测（简化版本）"""
try:
n_samples = len(self.y_train)
predictions = np.zeros(n_samples)
counts = np.zeros(n_samples)
for tree in trees:
# 获取OOB样本索引
indices = np.arange(n_samples)
bootstrap_indices = tree.random_state.randint(0, n_samples, n_samples)
oob_indices = np.setdiff1d(indices, np.unique(bootstrap_indices))
if len(oob_indices) > 0:
# 使用OOB样本进行预测
X_oob = self.X_train.iloc[oob_indices]
pred = tree.predict(X_oob)
predictions[oob_indices] += pred
counts[oob_indices] += 1
# 计算平均预测
valid_indices = counts > 0
final_predictions = np.full(n_samples, np.nan)
final_predictions[valid_indices] = predictions[valid_indices] / counts[valid_indices]
return final_predictions
except:
return None
def plot_parameter_tuning(self):
"""绘制参数调优结果"""
if self.rf_caret is not None and hasattr(self.rf_caret, 'cv_results_'):
# 这里简化处理，实际使用时需要从GridSearchCV获取结果
mtry_values = [2, 4, 6, 8]
# 使用模拟数据，实际应该从grid_search.cv_results_获取
rmse_scores = [0.8, 0.7, 0.65, 0.68] # 示例数据
plt.figure(figsize=(10, 6))
plt.plot(mtry_values, rmse_scores, 'o-', color='steelblue', linewidth=2, markersize=8)
plt.axvline(x=self.best_mtry, color='darkgreen', linestyle='--', linewidth=2)
plt.xlabel('mtry (每棵树使用的变量数)')
plt.ylabel('交叉验证RMSE')
plt.title('随机森林参数调优结果', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "parameter_tuning.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def plot_partial_dependence(self):
"""绘制部分依赖图"""
important_vars = self.feature_importance_df.head(3)['Variable'].tolist()
for i, var in enumerate(important_vars):
try:
if var in self.X_train.columns:
fig, ax = plt.subplots(figsize=(10, 6))
PartialDependenceDisplay.from_estimator(
self.final_rf, self.X_train, [var], ax=ax
)
ax.set_title(f'部分依赖图: {var}', fontsize=14, fontweight='bold')
ax.set_xlabel(var)
ax.set_ylabel('预测值')
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, f"partial_dependence_{var}.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
except Exception as e:
print(f"部分依赖图 {var} 生成失败: {e}")
def plot_model_comparison(self):
"""绘制模型比较图（随机森林 vs 线性回归）"""
# 训练线性回归模型
try:
lm_model = LinearRegression()
lm_model.fit(self.X_train, self.y_train)
y_pred_lm_test = lm_model.predict(self.X_test)
# 创建比较数据
comparison_data = pd.DataFrame({
'Actual': self.y_test,
'RandomForest': self.y_pred_test,
'LinearRegression': y_pred_lm_test
})
plt.figure(figsize=(10, 8))
plt.scatter(comparison_data['Actual'], comparison_data['RandomForest'],
alpha=0.6, color='blue', label='随机森林')
plt.scatter(comparison_data['Actual'], comparison_data['LinearRegression'],
alpha=0.6, color='orange', label='线性回归')
# 添加对角线
min_val = comparison_data[['Actual', 'RandomForest', 'LinearRegression']].min().min()
max_val = comparison_data[['Actual', 'RandomForest', 'LinearRegression']].max().max()
plt.plot([min_val, max_val], [min_val, max_val], 'k--', linewidth=2)
plt.xlabel('实际值')
plt.ylabel('预测值')
plt.title('模型比较: 随机森林 vs 线性回归 (测试集)', fontsize=14, fontweight='bold')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "model_comparison.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
except Exception as e:
print(f"模型比较图生成失败: {e}")
def plot_performance_comparison(self):
"""绘制性能对比图"""
performance_data = pd.DataFrame({
'Metric': ['RMSE', 'MAE', 'R-squared'] * 2,
'Value': [self.rmse_train, self.mae_train, self.r2_train,
self.rmse_test, self.mae_test, self.r2_test],
'Dataset': ['Training'] * 3 + ['Testing'] * 3
})
plt.figure(figsize=(10, 6))
sns.barplot(data=performance_data, x='Metric', y='Value', hue='Dataset',
palette=['steelblue', 'orange'], alpha=0.8)
plt.title('模型性能比较: 训练集 vs 测试集', fontsize=14, fontweight='bold')
plt.ylabel('值')
plt.legend(loc='best')
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "performance_comparison.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def learning_curve_analysis(self):
"""学习曲线分析"""
train_sizes = np.linspace(0.1, 0.9, 9)
train_rmse = []
test_rmse = []
for size in train_sizes:
# 从训练集中抽取子集
n_samples = int(size * len(self.X_train))
indices = np.random.RandomState(123).choice(len(self.X_train), n_samples, replace=False)
X_subset = self.X_train.iloc[indices]
y_subset = self.y_train.iloc[indices]
# 训练小模型
small_rf = RandomForestRegressor(
n_estimators=100,
max_features=self.final_rf.max_features,
random_state=123
)
small_rf.fit(X_subset, y_subset)
# 训练集性能
pred_train = small_rf.predict(X_subset)
rmse_train = np.sqrt(mean_squared_error(y_subset, pred_train))
train_rmse.append(rmse_train)
# 测试集性能
pred_test = small_rf.predict(self.X_test)
rmse_test = np.sqrt(mean_squared_error(self.y_test, pred_test))
test_rmse.append(rmse_test)
# 绘制学习曲线
plt.figure(figsize=(10, 6))
plt.plot(train_sizes * len(self.X_train), train_rmse, 'o-', color='blue',
label='训练集RMSE', linewidth=2)
plt.plot(train_sizes * len(self.X_train), test_rmse, 'o-', color='red',
label='测试集RMSE', linewidth=2)
plt.xlabel('训练集大小')
plt.ylabel('RMSE')
plt.title('学习曲线: 训练集大小 vs RMSE', fontsize=14, fontweight='bold')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "learning_curve.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def model_stability_analysis(self):
"""模型稳定性分析"""
n_iterations = 10
stability_results = []
# 准备完整数据
X_full = self.data.drop(['指标1', '序号'], axis=1, errors='ignore')
y_full = self.data['指标1']
X_full_encoded = pd.get_dummies(X_full, drop_first=True)
for i in range(n_iterations):
# 重新划分数据
X_train_temp, X_test_temp, y_train_temp, y_test_temp = train_test_split(
X_full_encoded, y_full, test_size=0.3, random_state=100 + i
)
# 训练模型
temp_rf = RandomForestRegressor(
n_estimators=100,
max_features=self.final_rf.max_features,
random_state=123
)
temp_rf.fit(X_train_temp, y_train_temp)
# 预测和评估
y_pred_temp = temp_rf.predict(X_test_temp)
rmse_temp = np.sqrt(mean_squared_error(y_test_temp, y_pred_temp))
r2_temp = r2_score(y_test_temp, y_pred_temp)
stability_results.append({
'Iteration': i + 1,
'RMSE': rmse_temp,
'R_squared': r2_temp
})
self.stability_df = pd.DataFrame(stability_results)
# 绘制稳定性图
plt.figure(figsize=(10, 6))
plt.plot(self.stability_df['Iteration'], self.stability_df['RMSE'],
'o-', color='steelblue', linewidth=2, markersize=8)
plt.xlabel('迭代次数')
plt.ylabel('测试集RMSE')
plt.title('模型稳定性分析: 不同数据划分下的测试RMSE', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig(os.path.join(self.results_dir, "model_stability.jpg"),
dpi=300, bbox_inches='tight')
plt.close()
def generate_report(self):
"""生成分析报告"""
doc = Document()
# 标题
doc.add_heading('随机森林回归 - 机器学习分析报告', 0)
doc.add_paragraph(f'生成日期: {pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S")}')
doc.add_paragraph()
# 数据概述
doc.add_heading('数据概述', level=1)
doc.add_paragraph(f'总样本量: {len(self.data)}')
doc.add_paragraph(f'训练集样本量: {len(self.X_train)}')
doc.add_paragraph(f'测试集样本量: {len(self.X_test)}')
doc.add_paragraph(f'变量数量: {self.X_train.shape[1]}')
doc.add_paragraph()
# 模型性能摘要
doc.add_heading('模型性能摘要', level=1)
# 创建性能表格
table = doc.add_table(rows=1, cols=3)
table.style = 'Light Grid'
hdr_cells = table.rows[0].cells
hdr_cells[0].text = '数据集'
hdr_cells[1].text = '指标'
hdr_cells[2].text = '值'
for _, row in self.performance_df.iterrows():
row_cells = table.add_row().cells
row_cells[0].text = str(row['Dataset'])
row_cells[1].text = str(row['Metric'])
if pd.notna(row['Value']):
row_cells[2].text = f"{row['Value']:.4f}"
else:
row_cells[2].text = 'N/A'
doc.add_paragraph()
# 过拟合分析
doc.add_heading('过拟合分析', level=1)
overfitting_gap = self.rmse_test - self.rmse_train
doc.add_paragraph(f'RMSE差距 (测试集 - 训练集): {overfitting_gap:.4f}')
if overfitting_gap > 0.1:
doc.add_paragraph('警告: 检测到潜在的过拟合 (训练集和测试集性能差距较大)')
else:
doc.add_paragraph('良好: 模型泛化能力良好 (训练集和测试集性能差距较小)')
doc.add_paragraph()
# 特征重要性
doc.add_heading('特征重要性', level=1)
doc.add_paragraph('前10个最重要的特征:')
table = doc.add_table(rows=1, cols=2)
table.style = 'Light Grid'
hdr_cells = table.rows[0].cells
hdr_cells[0].text = '特征'
hdr_cells[1].text = '重要性'
for _, row in self.feature_importance_df.head(10).iterrows():
row_cells = table.add_row().cells
row_cells[0].text = str(row['Variable'])
row_cells[1].text = f"{row['IncNodePurity']:.4f}"
doc.add_paragraph()
# 稳定性分析
doc.add_heading('模型稳定性分析', level=1)
stability_summary = pd.DataFrame({
'指标': ['平均测试RMSE', '测试RMSE标准差', '平均测试R平方', '测试R平方标准差'],
'值': [
self.stability_df['RMSE'].mean(),
self.stability_df['RMSE'].std(),
self.stability_df['R_squared'].mean(),
self.stability_df['R_squared'].std()
]
})
table = doc.add_table(rows=1, cols=2)
table.style = 'Light Grid'
hdr_cells = table.rows[0].cells
hdr_cells[0].text = '指标'
hdr_cells[1].text = '值'
for _, row in stability_summary.iterrows():
row_cells = table.add_row().cells
row_cells[0].text = str(row['指标'])
row_cells[1].text = f"{row['值']:.4f}"
doc.add_paragraph()
# 可视化结果
doc.add_heading('可视化结果', level=1)
# 添加图片
image_files = [
"variable_importance.jpg",
"performance_comparison.jpg",
"learning_curve.jpg",
"model_stability.jpg",
"predicted_vs_actual.jpg",
"oob_error.jpg"
]
titles = [
"变量重要性图",
"性能比较图",
"学习曲线",
"模型稳定性",
"预测值 vs 实际值",
"OOB误差图"
]
for img_file, title in zip(image_files, titles):
doc.add_paragraph(title)
img_path = os.path.join(self.results_dir, img_file)
if os.path.exists(img_path):
doc.add_picture(img_path, width=Inches(6))
doc.add_paragraph()
# 添加部分依赖图
important_vars = self.feature_importance_df.head(2)['Variable'].tolist()
for var in important_vars:
img_path = os.path.join(self.results_dir, f"partial_dependence_{var}.jpg")
if os.path.exists(img_path):
doc.add_paragraph(f'部分依赖图: {var}')
doc.add_picture(img_path, width=Inches(6))
doc.add_paragraph()
# 结论和建议
doc.add_heading('结论和建议', level=1)
doc.add_paragraph('基于随机森林回归的机器学习分析:')
doc.add_paragraph(f'- 训练集R平方: {self.r2_train * 100:.2f}%')
doc.add_paragraph(f'- 测试集R平方: {self.r2_test * 100:.2f}%')
doc.add_paragraph(f'- 模型泛化差距: {overfitting_gap:.4f}')
doc.add_paragraph(f'- 最重要的变量: {", ".join(self.feature_importance_df.head(3)["Variable"].tolist())}')
doc.add_paragraph(f'- 模型稳定性 (RMSE标准差): {self.stability_df["RMSE"].std():.4f}')
doc.add_paragraph()
doc.add_paragraph('建议:')
doc.add_paragraph('1. 如果检测到过拟合，考虑正则化或减少模型复杂度')
doc.add_paragraph('2. 使用集成方法如梯度提升树进一步提高性能')
doc.add_paragraph('3. 监控模型在新数据上的表现以检测概念漂移')
doc.add_paragraph('4. 考虑特征工程以提升模型性能')
# 保存文档
report_path = os.path.join(self.results_dir, "随机森林机器学习分析报告.docx")
doc.save(report_path)
print(f"分析报告已保存至: {report_path}")
def save_models(self):
"""保存模型"""
# 保存模型对象
joblib.dump(self.final_rf, os.path.join(self.results_dir, "random_forest_model.pkl"))
if self.rf_caret is not None:
joblib.dump(self.rf_caret, os.path.join(self.results_dir, "tuned_random_forest_model.pkl"))
# 保存处理后的数据
self.data.to_csv(os.path.join(self.results_dir, "processed_data.csv"),
index=False, encoding='utf-8-sig')
# 保存其他重要数据
joblib.dump({
'X_train': self.X_train,
'X_test': self.X_test,
'y_train': self.y_train,
'y_test': self.y_test
}, os.path.join(self.results_dir, "train_test_data.pkl"))
print("模型和数据已保存")
def run_analysis(self):
"""运行完整分析流程"""
print("开始随机森林回归分析...")
# 1. 加载和预处理数据
if not self.load_and_preprocess_data():
return
# 2. 划分数据
self.split_data()
# 3. 训练随机森林模型
print("训练随机森林模型中...")
self.train_random_forest()
# 4. 超参数调优
print("进行超参数调优...")
self.tune_hyperparameters()
# 5. 训练最终模型
print("训练最终模型...")
self.train_final_model()
# 6. 评估模型
print("评估模型性能...")
self.evaluate_model()
# 7. 获取特征重要性
self.get_feature_importance()
# 8. 生成可视化
print("生成可视化图表...")
self.plot_feature_importance()
self.plot_prediction_vs_actual()
self.plot_residual_analysis()
self.plot_oob_error()
self.plot_parameter_tuning()
self.plot_partial_dependence()
self.plot_model_comparison()
self.plot_performance_comparison()
self.learning_curve_analysis()
self.model_stability_analysis()
# 9. 生成报告
print("生成分析报告...")
self.generate_report()
# 10. 保存模型
self.save_models()
print("\n随机森林机器学习分析完成!")
print(f"结果已保存到: {self.results_dir}")
print("- 模型性能比较 (训练集 vs 测试集)")
print("- 综合可视化包括学习曲线和稳定性分析")
print("- 详细的Word分析报告")
print("- 模型对象和处理后的数据")
# 主程序
if __name__ == "__main__":
analysis = RandomForestAnalysis()
analysis.run_analysis()
4. 随机森林回归（Random Forest Regression）
概念：集成学习方法，通过构建多棵决策树并平均其预测。
原理
- Bagging：自助采样构建多个训练集
- 特征随机性：每棵树只使用部分特征
- 预测：所有树预测的平均值
思想："三个臭皮匠，顶个诸葛亮" - 通过集体智慧提高准确性和稳定性。
应用
- 房价预测
- 股票价格预测
- 生物信息学
医学统计数据分析分享交流SPSS、R语言、Python、ArcGis、Geoda、GraphPad、数据分析图表制作等心得。承接数据分析，论文返修，医学统计，机器学习，生存分析，空间分析，问卷分析业务。若有投稿和数据分析代做需求，可以直接联系我，谢谢！
“医学统计数据分析”公众号右下角；
找到“联系作者”，
可加我微信，邀请入粉丝群！
有临床流行病学数据分析
如（t检验、方差分析、χ2检验、logistic回归）、
（重复测量方差分析与配对T检验、ROC曲线）、
（非参数检验、生存分析、样本含量估计）、
（筛检试验：灵敏度、特异度、约登指数等计算）、
（绘制柱状图、散点图、小提琴图、列线图等）、
机器学习、深度学习、生存分析
等需求的同仁们，加入【临床】粉丝群。
疾控，公卫岗位的同仁，可以加一下【公卫】粉丝群，分享生态学研究、空间分析、时间序列、监测数据分析、时空面板技巧等工作科研自动化内容。
有实验室数据分析需求的同仁们，可以加入【生信】粉丝群，交流NCBI（基因序列）、UniProt（蛋白质）、KEGG（通路）、GEO（公共数据集）等公共数据库、基因组学转录组学蛋白组学代谢组学表型组学等数据分析和可视化内容。
或者可扫码直接加微信进群！！！
精品视频课程-“医学统计数据分析”视频号付费合集
在“医学统计数据分析”视频号-付费合集兑换相应课程后，获取课程理论课PPT、代码、基础数据等相关资料，请大家在【医学统计数据分析】公众号右下角，找到“联系作者”，加我微信后打包发送。感谢您的支持！！