2504 lines
97 KiB
Python
2504 lines
97 KiB
Python
"""
|
||
回归分析工具包
|
||
支持多种回归算法：线性回归、LASSO、岭回归、Boosting、神经网络等
|
||
包含超参数调优、模型评价和保存功能
|
||
"""
|
||
|
||
import pandas as pd
|
||
import numpy as np
|
||
import matplotlib.pyplot as plt
|
||
import seaborn as sns
|
||
from sklearn.model_selection import train_test_split, GridSearchCV, RandomizedSearchCV, cross_val_score
|
||
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
|
||
from sklearn.preprocessing import StandardScaler, MinMaxScaler
|
||
from sklearn.linear_model import LinearRegression, Lasso, Ridge, BayesianRidge, ElasticNet
|
||
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, ExtraTreesRegressor, AdaBoostRegressor
|
||
from sklearn.tree import DecisionTreeRegressor
|
||
from sklearn.svm import SVR
|
||
from sklearn.gaussian_process import GaussianProcessRegressor
|
||
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C
|
||
from sklearn.neural_network import MLPRegressor
|
||
from sklearn.neighbors import KNeighborsRegressor
|
||
from sklearn.base import BaseEstimator, RegressorMixin
|
||
import xgboost as xgb
|
||
import lightgbm as lgb
|
||
from statsmodels.api import OLS, GLM
|
||
from statsmodels.genmod.families import Gaussian
|
||
import warnings
|
||
import joblib
|
||
import os
|
||
from datetime import datetime
|
||
import json
|
||
from scipy.linalg import pinv
|
||
from scipy import stats
|
||
from typing import Optional, List, Dict, Any, Union
|
||
from dataclasses import dataclass, field
|
||
import time
|
||
|
||
warnings.filterwarnings('ignore')
|
||
|
||
|
||
@dataclass
|
||
class DataConfig:
|
||
"""数据配置类"""
|
||
csv_path: str = ""
|
||
label_column: Union[str, int] = ""
|
||
spectrum_columns: Optional[Union[str, List[Union[str, int]]]] = None
|
||
test_size: float = 0.2
|
||
random_state: int = 42
|
||
scale_method: str = 'standard'
|
||
|
||
|
||
@dataclass
|
||
class ModelConfig:
|
||
"""模型配置类"""
|
||
model_names: Optional[Union[str, List[str]]] = None
|
||
tune_hyperparams: bool = True
|
||
tuning_method: str = 'grid'
|
||
cv_folds: int = 5
|
||
random_search_iter: int = 20
|
||
|
||
|
||
@dataclass
|
||
class TrainingConfig:
|
||
"""训练配置类"""
|
||
epochs: int = 100
|
||
batch_size: int = 32
|
||
learning_rate: float = 0.001
|
||
|
||
|
||
@dataclass
|
||
class OutputConfig:
|
||
"""输出配置类"""
|
||
save_models: bool = True
|
||
plot_results: bool = True
|
||
save_dir: str = 'models'
|
||
plot_dir: str = 'plots'
|
||
|
||
|
||
@dataclass
|
||
class RegressionConfig:
|
||
"""回归分析完整配置类 - 为GUI对接设计的标准化接口"""
|
||
data: DataConfig = field(default_factory=DataConfig)
|
||
models: ModelConfig = field(default_factory=ModelConfig)
|
||
training: TrainingConfig = field(default_factory=TrainingConfig)
|
||
output: OutputConfig = field(default_factory=OutputConfig)
|
||
|
||
def __post_init__(self):
|
||
"""参数校验和默认值设置"""
|
||
self._validate_parameters()
|
||
|
||
def _validate_parameters(self):
|
||
"""参数校验"""
|
||
# 数据参数校验
|
||
if not self.data.csv_path:
|
||
raise ValueError("CSV file path must be specified")
|
||
if not self.data.label_column:
|
||
raise ValueError("Label column must be specified")
|
||
if not (0 < self.data.test_size < 1):
|
||
raise ValueError("Test size must be between 0 and 1")
|
||
if self.data.scale_method not in ['standard', 'minmax']:
|
||
raise ValueError("Scale method must be 'standard' or 'minmax'")
|
||
|
||
# 模型参数校验
|
||
if self.models.tuning_method not in ['grid', 'random']:
|
||
raise ValueError("Tuning method must be 'grid' or 'random'")
|
||
if self.models.cv_folds < 2:
|
||
raise ValueError("CV folds must be at least 2")
|
||
|
||
# 处理模型名称
|
||
self._process_model_names()
|
||
|
||
# 训练参数校验
|
||
if self.training.epochs <= 0:
|
||
raise ValueError("Epochs must be positive")
|
||
if self.training.batch_size <= 0:
|
||
raise ValueError("Batch size must be positive")
|
||
if self.training.learning_rate <= 0:
|
||
raise ValueError("Learning rate must be positive")
|
||
|
||
def _process_model_names(self):
|
||
"""处理模型名称，支持'all'参数"""
|
||
if isinstance(self.models.model_names, str):
|
||
if self.models.model_names.lower() == 'all':
|
||
# 获取所有支持的模型名称
|
||
supported_models = self._get_supported_models()
|
||
self.models.model_names = list(supported_models.keys())
|
||
print(f"选择所有可用模型: {len(self.models.model_names)} 个")
|
||
else:
|
||
# 单个模型名称
|
||
supported_models = self._get_supported_models()
|
||
if self.models.model_names not in supported_models:
|
||
raise ValueError(f"不支持的模型类型: {self.models.model_names}")
|
||
self.models.model_names = [self.models.model_names]
|
||
elif isinstance(self.models.model_names, list):
|
||
# 验证列表中的每个模型
|
||
supported_models = self._get_supported_models()
|
||
for model in self.models.model_names:
|
||
if model not in supported_models:
|
||
raise ValueError(f"不支持的模型类型: {model}")
|
||
elif self.models.model_names is None:
|
||
# 默认使用一些常用模型
|
||
self.models.model_names = ['linear', 'ridge', 'lasso', 'randomforest', 'svm']
|
||
|
||
def _get_supported_models(self) -> Dict[str, str]:
|
||
"""获取支持的模型列表"""
|
||
# 基于RegressionAnalyzer中注册的模型
|
||
models = {
|
||
# 线性模型
|
||
'linear': '多元线性回归',
|
||
'lasso': 'LASSO回归',
|
||
'ridge': '岭回归',
|
||
'elasticnet': '弹性网络回归',
|
||
'bayesianridge': '贝叶斯岭回归',
|
||
|
||
# 提升模型
|
||
'lsboost': '最小二乘提升',
|
||
'xgboost': 'XGBoost回归',
|
||
'lightgbm': 'LightGBM回归',
|
||
|
||
# 核方法
|
||
'gaussian': '高斯过程回归',
|
||
'gaussiansvm': '高斯SVM回归',
|
||
'svm': '支持向量回归',
|
||
|
||
# 神经网络
|
||
'elm': '极限学习机',
|
||
'mlp': '多层感知机',
|
||
'lstm': 'LSTM网络',
|
||
'gru': 'GRU网络',
|
||
|
||
# 其他模型
|
||
'gam': '广义加性模型',
|
||
'decisiontree': '决策树回归',
|
||
'randomforest': '随机森林回归',
|
||
'extratrees': '极端随机树回归',
|
||
'adaboost': 'AdaBoost回归'
|
||
}
|
||
|
||
# 只返回当前环境可用的模型
|
||
available_models = {}
|
||
for key, name in models.items():
|
||
try:
|
||
# 这里可以添加更复杂的可用性检查
|
||
available_models[key] = name
|
||
except:
|
||
continue
|
||
|
||
return available_models
|
||
|
||
@classmethod
|
||
def create_default(cls, csv_path: str, label_column: Union[str, int]) -> 'RegressionConfig':
|
||
"""创建默认配置的便捷方法"""
|
||
# 创建配置时暂时跳过验证
|
||
config = cls.__new__(cls)
|
||
config.data = DataConfig()
|
||
config.models = ModelConfig()
|
||
config.training = TrainingConfig()
|
||
config.output = OutputConfig()
|
||
|
||
# 设置必要参数
|
||
config.data.csv_path = csv_path
|
||
config.data.label_column = label_column
|
||
|
||
# 手动调用验证
|
||
config._validate_parameters()
|
||
|
||
return config
|
||
|
||
@classmethod
|
||
def create_quick_analysis(cls, csv_path: str, label_column: Union[str, int],
|
||
model_names: Optional[List[str]] = None) -> 'RegressionConfig':
|
||
"""创建快速分析配置"""
|
||
# 创建配置时暂时跳过验证
|
||
config = cls.__new__(cls)
|
||
config.data = DataConfig()
|
||
config.models = ModelConfig()
|
||
config.training = TrainingConfig()
|
||
config.output = OutputConfig()
|
||
|
||
# 设置必要参数
|
||
config.data.csv_path = csv_path
|
||
config.data.label_column = label_column
|
||
config.models.model_names = model_names
|
||
config.models.tune_hyperparams = False # 快速分析不调参
|
||
config.output.save_models = False # 不保存模型
|
||
|
||
# 手动调用验证
|
||
config._validate_parameters()
|
||
|
||
return config
|
||
|
||
|
||
class ExtremeLearningMachine(BaseEstimator, RegressorMixin):
|
||
"""
|
||
Extreme Learning Machine (ELM) 回归器
|
||
ELM是一种单隐层前馈神经网络，具有快速训练速度
|
||
"""
|
||
|
||
def __init__(self, n_hidden=100, activation='sigmoid', random_state=42):
|
||
self.n_hidden = n_hidden
|
||
self.activation = activation
|
||
self.random_state = random_state
|
||
self.input_weights_ = None
|
||
self.biases_ = None
|
||
self.output_weights_ = None
|
||
|
||
def _activation_function(self, X):
|
||
"""激活函数"""
|
||
if self.activation == 'sigmoid':
|
||
return 1 / (1 + np.exp(-X))
|
||
elif self.activation == 'tanh':
|
||
return np.tanh(X)
|
||
elif self.activation == 'relu':
|
||
return np.maximum(0, X)
|
||
elif self.activation == 'linear':
|
||
return X
|
||
else:
|
||
raise ValueError(f"Unsupported activation function: {self.activation}")
|
||
|
||
def fit(self, X, y):
|
||
"""训练ELM模型"""
|
||
np.random.seed(self.random_state)
|
||
n_samples, n_features = X.shape
|
||
|
||
# Initialize input weights and biases (random)
|
||
self.input_weights_ = np.random.randn(n_features, self.n_hidden)
|
||
self.biases_ = np.random.randn(self.n_hidden)
|
||
|
||
# 计算隐层输出
|
||
H = self._activation_function(X @ self.input_weights_ + self.biases_)
|
||
|
||
# 添加偏置列到隐层输出（可选）
|
||
H = np.column_stack([H, np.ones(n_samples)])
|
||
|
||
# 计算输出权重（解析解）
|
||
self.output_weights_ = pinv(H) @ y
|
||
|
||
return self
|
||
|
||
def predict(self, X):
|
||
"""预测"""
|
||
if self.input_weights_ is None:
|
||
raise ValueError("模型还未训练")
|
||
|
||
# 计算隐层输出
|
||
H = self._activation_function(X @ self.input_weights_ + self.biases_)
|
||
H = np.column_stack([H, np.ones(X.shape[0])])
|
||
|
||
# 计算输出
|
||
return H @ self.output_weights_
|
||
|
||
def _more_tags(self):
|
||
return {'no_validation': True}
|
||
|
||
|
||
class GeneralizedAdditiveModel(BaseEstimator, RegressorMixin):
|
||
"""
|
||
Generalized Additive Model (GAM) 回归器
|
||
使用样条基函数实现GAM
|
||
"""
|
||
|
||
def __init__(self, n_splines=10, degree=3, lambda_=0.1):
|
||
self.n_splines = n_splines
|
||
self.degree = degree
|
||
self.lambda_ = lambda_
|
||
self.coefficients_ = None
|
||
self.knots_ = None
|
||
|
||
def _create_spline_basis(self, X):
|
||
"""创建样条基函数"""
|
||
n_samples, n_features = X.shape
|
||
n_basis = self.n_splines + self.degree + 1
|
||
|
||
# 为每个特征创建基函数
|
||
basis_matrices = []
|
||
|
||
for feature_idx in range(n_features):
|
||
x = X[:, feature_idx]
|
||
x_min, x_max = np.min(x), np.max(x)
|
||
|
||
# 创建节点
|
||
if self.knots_ is None:
|
||
knots = np.linspace(x_min, x_max, self.n_splines + 2)[1:-1]
|
||
else:
|
||
knots = self.knots_[feature_idx]
|
||
|
||
# 创建B样条基函数
|
||
basis = np.zeros((n_samples, n_basis))
|
||
|
||
# 截断幂基函数（简化实现）
|
||
for i in range(n_basis):
|
||
if i < self.degree + 1:
|
||
# 左端多项式
|
||
basis[:, i] = np.power(np.maximum(0, x - x_min), i)
|
||
elif i > n_basis - self.degree - 2:
|
||
# 右端多项式
|
||
power = n_basis - 1 - i
|
||
basis[:, i] = np.power(np.maximum(0, x_max - x), power)
|
||
else:
|
||
# 中间截断幂函数
|
||
basis[:, i] = np.power(np.maximum(0, x - knots[i - self.degree - 1]), self.degree)
|
||
|
||
basis_matrices.append(basis)
|
||
|
||
# 组合所有特征的基函数
|
||
return np.concatenate(basis_matrices, axis=1)
|
||
|
||
def fit(self, X, y):
|
||
"""训练GAM模型"""
|
||
from sklearn.linear_model import Ridge
|
||
|
||
# 创建样条基函数
|
||
X_basis = self._create_spline_basis(X)
|
||
|
||
# 使用岭回归拟合系数（带正则化）
|
||
ridge = Ridge(alpha=self.lambda_, fit_intercept=True)
|
||
ridge.fit(X_basis, y)
|
||
|
||
self.coefficients_ = ridge.coef_
|
||
self.intercept_ = ridge.intercept_
|
||
|
||
return self
|
||
|
||
def predict(self, X):
|
||
"""预测"""
|
||
if self.coefficients_ is None:
|
||
raise ValueError("模型还未训练")
|
||
|
||
X_basis = self._create_spline_basis(X)
|
||
return X_basis @ self.coefficients_ + self.intercept_
|
||
|
||
|
||
class LSTMRegressor(BaseEstimator, RegressorMixin):
|
||
"""
|
||
LSTM回归器 - 将光谱数据视为序列数据
|
||
每个光谱样本的波段作为时间步
|
||
使用PyTorch实现
|
||
"""
|
||
|
||
def __init__(self, units=None, dropout=0.2, recurrent_dropout=0.2, epochs=None,
|
||
batch_size=None, learning_rate=None, random_state=42, device=None,
|
||
config: Optional['TrainingConfig'] = None):
|
||
"""
|
||
LSTM回归器构造函数
|
||
|
||
Parameters:
|
||
units (int, optional): LSTM单元数，如果为None则使用默认值50
|
||
dropout (float): Dropout比例
|
||
recurrent_dropout (float): 循环Dropout比例
|
||
epochs (int, optional): 训练轮数，如果为None则使用默认值100
|
||
batch_size (int, optional): 批次大小，如果为None则使用默认值32
|
||
learning_rate (float, optional): 学习率，如果为None则使用默认值0.001
|
||
random_state (int): 随机种子
|
||
device (str, optional): 计算设备
|
||
config (TrainingConfig, optional): 训练配置对象
|
||
"""
|
||
# 如果提供了配置对象，使用配置中的参数
|
||
if config is not None:
|
||
self.units = units if units is not None else 64 # LSTM默认使用更多单元
|
||
self.dropout = dropout
|
||
self.recurrent_dropout = recurrent_dropout
|
||
self.epochs = epochs if epochs is not None else config.epochs
|
||
self.batch_size = batch_size if batch_size is not None else config.batch_size
|
||
self.learning_rate = learning_rate if learning_rate is not None else config.learning_rate
|
||
else:
|
||
# 使用传统参数方式
|
||
self.units = units if units is not None else 50
|
||
self.dropout = dropout
|
||
self.recurrent_dropout = recurrent_dropout
|
||
self.epochs = epochs if epochs is not None else 100
|
||
self.batch_size = batch_size if batch_size is not None else 32
|
||
self.learning_rate = learning_rate if learning_rate is not None else 0.001
|
||
|
||
self.random_state = random_state
|
||
self.device = device
|
||
self.model_ = None
|
||
self.input_size_ = None
|
||
|
||
# 尝试导入PyTorch
|
||
try:
|
||
import torch
|
||
import torch.nn as nn
|
||
import torch.optim as optim
|
||
self.torch = torch
|
||
self.nn = nn
|
||
self.optim = optim
|
||
self.pytorch_available = True
|
||
|
||
# 设置设备
|
||
if self.device is None:
|
||
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
|
||
else:
|
||
self.device = torch.device(self.device)
|
||
|
||
except ImportError:
|
||
self.pytorch_available = False
|
||
print("Warning: PyTorch not installed, LSTM model will use MLPRegressor approximation")
|
||
|
||
def _create_model(self, input_size):
|
||
"""创建PyTorch LSTM模型"""
|
||
class LSTMModel(self.nn.Module):
|
||
def __init__(self, input_size, hidden_size, dropout, recurrent_dropout):
|
||
super(LSTMModel, self).__init__()
|
||
self.hidden_size = hidden_size
|
||
self.lstm = self.nn.LSTM(
|
||
input_size=input_size,
|
||
hidden_size=hidden_size,
|
||
num_layers=1,
|
||
batch_first=True,
|
||
dropout=recurrent_dropout if recurrent_dropout > 0 else 0,
|
||
bidirectional=False
|
||
)
|
||
self.dropout_layer = self.nn.Dropout(dropout)
|
||
self.fc = self.nn.Linear(hidden_size, 1)
|
||
|
||
def forward(self, x):
|
||
# LSTM前向传播
|
||
lstm_out, _ = self.lstm(x)
|
||
# 取最后一个时间步的输出
|
||
lstm_out = lstm_out[:, -1, :]
|
||
# Dropout
|
||
lstm_out = self.dropout_layer(lstm_out)
|
||
# 全连接层
|
||
output = self.fc(lstm_out)
|
||
return output
|
||
|
||
return LSTMModel(input_size, self.units, self.dropout, self.recurrent_dropout)
|
||
|
||
def fit(self, X, y):
|
||
"""训练LSTM模型"""
|
||
if not self.pytorch_available:
|
||
# 如果没有PyTorch，使用MLPRegressor作为近似
|
||
from sklearn.neural_network import MLPRegressor
|
||
self.model_ = MLPRegressor(
|
||
hidden_layer_sizes=(self.units, self.units//2),
|
||
activation='relu',
|
||
solver='adam',
|
||
max_iter=self.epochs,
|
||
random_state=self.random_state,
|
||
early_stopping=True
|
||
)
|
||
self.model_.fit(X, y)
|
||
return self
|
||
|
||
# 设置随机种子
|
||
self.torch.manual_seed(self.random_state)
|
||
if self.torch.cuda.is_available():
|
||
self.torch.cuda.manual_seed(self.random_state)
|
||
self.torch.cuda.manual_seed_all(self.random_state)
|
||
np.random.seed(self.random_state)
|
||
|
||
# 将特征数据重塑为序列格式 (samples, timesteps, features)
|
||
# 对于光谱数据，每个波段作为时间步，特征数为1
|
||
n_samples, n_features = X.shape
|
||
self.input_size_ = 1 # 每个时间步的特征数
|
||
|
||
# 转换为PyTorch张量
|
||
X_tensor = self.torch.FloatTensor(X.reshape(n_samples, n_features, 1)).to(self.device)
|
||
y_tensor = self.torch.FloatTensor(y.reshape(-1, 1)).to(self.device)
|
||
|
||
# 创建模型
|
||
self.model_ = self._create_model(self.input_size_).to(self.device)
|
||
|
||
# 定义损失函数和优化器
|
||
criterion = self.nn.MSELoss()
|
||
optimizer = self.optim.Adam(self.model_.parameters(), lr=self.learning_rate)
|
||
|
||
# 训练模型
|
||
self.model_.train()
|
||
for epoch in range(self.epochs):
|
||
# 随机打乱数据
|
||
indices = np.random.permutation(n_samples)
|
||
X_shuffled = X_tensor[indices]
|
||
y_shuffled = y_tensor[indices]
|
||
|
||
# 批量训练
|
||
for i in range(0, n_samples, self.batch_size):
|
||
batch_X = X_shuffled[i:i+self.batch_size]
|
||
batch_y = y_shuffled[i:i+self.batch_size]
|
||
|
||
# 前向传播
|
||
optimizer.zero_grad()
|
||
outputs = self.model_(batch_X)
|
||
loss = criterion(outputs, batch_y)
|
||
|
||
# 反向传播
|
||
loss.backward()
|
||
optimizer.step()
|
||
|
||
return self
|
||
|
||
def predict(self, X):
|
||
"""预测"""
|
||
if self.model_ is None:
|
||
raise ValueError("模型还未训练")
|
||
|
||
if not self.pytorch_available:
|
||
return self.model_.predict(X)
|
||
|
||
# 转换为评估模式
|
||
self.model_.eval()
|
||
|
||
# 重塑输入数据
|
||
n_samples, n_features = X.shape
|
||
X_tensor = self.torch.FloatTensor(X.reshape(n_samples, n_features, 1)).to(self.device)
|
||
|
||
# 预测
|
||
with self.torch.no_grad():
|
||
predictions = self.model_(X_tensor)
|
||
|
||
return predictions.cpu().numpy().flatten()
|
||
|
||
|
||
class GRURegressor(BaseEstimator, RegressorMixin):
|
||
"""
|
||
GRU回归器 - 将光谱数据视为序列数据
|
||
每个光谱样本的波段作为时间步
|
||
使用PyTorch实现
|
||
"""
|
||
|
||
def __init__(self, units=None, dropout=0.2, recurrent_dropout=0.2, epochs=None,
|
||
batch_size=None, learning_rate=None, random_state=42, device=None,
|
||
config: Optional['TrainingConfig'] = None):
|
||
"""
|
||
GRU回归器构造函数
|
||
|
||
Parameters:
|
||
units (int, optional): GRU单元数，如果为None则使用默认值50
|
||
dropout (float): Dropout比例
|
||
recurrent_dropout (float): 循环Dropout比例
|
||
epochs (int, optional): 训练轮数，如果为None则使用默认值100
|
||
batch_size (int, optional): 批次大小，如果为None则使用默认值32
|
||
learning_rate (float, optional): 学习率，如果为None则使用默认值0.001
|
||
random_state (int): 随机种子
|
||
device (str, optional): 计算设备
|
||
config (TrainingConfig, optional): 训练配置对象
|
||
"""
|
||
# 如果提供了配置对象，使用配置中的参数
|
||
if config is not None:
|
||
self.units = units if units is not None else 64 # GRU默认使用更多单元
|
||
self.dropout = dropout
|
||
self.recurrent_dropout = recurrent_dropout
|
||
self.epochs = epochs if epochs is not None else config.epochs
|
||
self.batch_size = batch_size if batch_size is not None else config.batch_size
|
||
self.learning_rate = learning_rate if learning_rate is not None else config.learning_rate
|
||
else:
|
||
# 使用传统参数方式
|
||
self.units = units if units is not None else 50
|
||
self.dropout = dropout
|
||
self.recurrent_dropout = recurrent_dropout
|
||
self.epochs = epochs if epochs is not None else 100
|
||
self.batch_size = batch_size if batch_size is not None else 32
|
||
self.learning_rate = learning_rate if learning_rate is not None else 0.001
|
||
|
||
self.random_state = random_state
|
||
self.device = device
|
||
self.model_ = None
|
||
self.input_size_ = None
|
||
|
||
# 尝试导入PyTorch
|
||
try:
|
||
import torch
|
||
import torch.nn as nn
|
||
import torch.optim as optim
|
||
self.torch = torch
|
||
self.nn = nn
|
||
self.optim = optim
|
||
self.pytorch_available = True
|
||
|
||
# 设置设备
|
||
if self.device is None:
|
||
self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
|
||
else:
|
||
self.device = torch.device(self.device)
|
||
|
||
except ImportError:
|
||
self.pytorch_available = False
|
||
print("Warning: PyTorch not installed, GRU model will use MLPRegressor approximation")
|
||
|
||
def _create_model(self, input_size):
|
||
"""创建PyTorch GRU模型"""
|
||
class GRUModel(self.nn.Module):
|
||
def __init__(self, input_size, hidden_size, dropout, recurrent_dropout):
|
||
super(GRUModel, self).__init__()
|
||
self.hidden_size = hidden_size
|
||
self.gru = self.nn.GRU(
|
||
input_size=input_size,
|
||
hidden_size=hidden_size,
|
||
num_layers=1,
|
||
batch_first=True,
|
||
dropout=recurrent_dropout if recurrent_dropout > 0 else 0,
|
||
bidirectional=False
|
||
)
|
||
self.dropout_layer = self.nn.Dropout(dropout)
|
||
self.fc = self.nn.Linear(hidden_size, 1)
|
||
|
||
def forward(self, x):
|
||
# GRU前向传播
|
||
gru_out, _ = self.gru(x)
|
||
# 取最后一个时间步的输出
|
||
gru_out = gru_out[:, -1, :]
|
||
# Dropout
|
||
gru_out = self.dropout_layer(gru_out)
|
||
# 全连接层
|
||
output = self.fc(gru_out)
|
||
return output
|
||
|
||
return GRUModel(input_size, self.units, self.dropout, self.recurrent_dropout)
|
||
|
||
def fit(self, X, y):
|
||
"""训练GRU模型"""
|
||
if not self.pytorch_available:
|
||
# 如果没有PyTorch，使用MLPRegressor作为近似
|
||
from sklearn.neural_network import MLPRegressor
|
||
self.model_ = MLPRegressor(
|
||
hidden_layer_sizes=(self.units, self.units//2),
|
||
activation='relu',
|
||
solver='adam',
|
||
max_iter=self.epochs,
|
||
random_state=self.random_state,
|
||
early_stopping=True
|
||
)
|
||
self.model_.fit(X, y)
|
||
return self
|
||
|
||
# 设置随机种子
|
||
self.torch.manual_seed(self.random_state)
|
||
if self.torch.cuda.is_available():
|
||
self.torch.cuda.manual_seed(self.random_state)
|
||
self.torch.cuda.manual_seed_all(self.random_state)
|
||
np.random.seed(self.random_state)
|
||
|
||
# 将特征数据重塑为序列格式 (samples, timesteps, features)
|
||
n_samples, n_features = X.shape
|
||
self.input_size_ = 1 # 每个时间步的特征数
|
||
|
||
# 转换为PyTorch张量
|
||
X_tensor = self.torch.FloatTensor(X.reshape(n_samples, n_features, 1)).to(self.device)
|
||
y_tensor = self.torch.FloatTensor(y.reshape(-1, 1)).to(self.device)
|
||
|
||
# 创建模型
|
||
self.model_ = self._create_model(self.input_size_).to(self.device)
|
||
|
||
# 定义损失函数和优化器
|
||
criterion = self.nn.MSELoss()
|
||
optimizer = self.optim.Adam(self.model_.parameters(), lr=self.learning_rate)
|
||
|
||
# 训练模型
|
||
self.model_.train()
|
||
for epoch in range(self.epochs):
|
||
# 随机打乱数据
|
||
indices = np.random.permutation(n_samples)
|
||
X_shuffled = X_tensor[indices]
|
||
y_shuffled = y_tensor[indices]
|
||
|
||
# 批量训练
|
||
for i in range(0, n_samples, self.batch_size):
|
||
batch_X = X_shuffled[i:i+self.batch_size]
|
||
batch_y = y_shuffled[i:i+self.batch_size]
|
||
|
||
# 前向传播
|
||
optimizer.zero_grad()
|
||
outputs = self.model_(batch_X)
|
||
loss = criterion(outputs, batch_y)
|
||
|
||
# 反向传播
|
||
loss.backward()
|
||
optimizer.step()
|
||
|
||
return self
|
||
|
||
def predict(self, X):
|
||
"""预测"""
|
||
if self.model_ is None:
|
||
raise ValueError("模型还未训练")
|
||
|
||
if not self.pytorch_available:
|
||
return self.model_.predict(X)
|
||
|
||
# 转换为评估模式
|
||
self.model_.eval()
|
||
|
||
# 重塑输入数据
|
||
n_samples, n_features = X.shape
|
||
X_tensor = self.torch.FloatTensor(X.reshape(n_samples, n_features, 1)).to(self.device)
|
||
|
||
# 预测
|
||
with self.torch.no_grad():
|
||
predictions = self.model_(X_tensor)
|
||
|
||
return predictions.cpu().numpy().flatten()
|
||
|
||
|
||
class RegressionAnalyzer:
|
||
"""
|
||
回归分析器类 - 支持GUI对接的标准化接口
|
||
支持多种回归算法和完整的分析流程
|
||
"""
|
||
|
||
def __init__(self, config: Optional[RegressionConfig] = None):
|
||
"""
|
||
初始化回归分析器
|
||
|
||
Parameters:
|
||
config (RegressionConfig, optional): 配置对象，如果为None则使用默认配置
|
||
"""
|
||
self.config = config or RegressionConfig()
|
||
self._validate_config() # 在构造函数中进行校验
|
||
self.models = {}
|
||
self.scalers = {}
|
||
self.best_params = {}
|
||
self.results = {}
|
||
self.data = None
|
||
self.X = None
|
||
self.y = None
|
||
self.X_train = None
|
||
self.X_test = None
|
||
self.y_train = None
|
||
self.y_test = None
|
||
|
||
# 初始化可视化器
|
||
self.visualizer = RegressionVisualizer(self)
|
||
|
||
def update_config(self, config: RegressionConfig):
|
||
"""
|
||
更新配置 - 为GUI动态配置预留接口
|
||
|
||
Parameters:
|
||
config (RegressionConfig): 新的配置对象
|
||
"""
|
||
self.config = config
|
||
self._validate_config()
|
||
|
||
def _validate_config(self):
|
||
"""配置校验"""
|
||
try:
|
||
self.config._validate_parameters()
|
||
except ValueError as e:
|
||
raise ValueError(f"Configuration validation failed: {e}")
|
||
|
||
def _parse_column_range(self, column_range, total_columns):
|
||
"""
|
||
解析列范围字符串，返回列索引列表
|
||
|
||
Parameters:
|
||
column_range (str or int or list): 列范围，如 "0:5", "2,4,6-8", [0,1,2] 或单个索引
|
||
total_columns (int): 总列数
|
||
|
||
Returns:
|
||
list: 列索引列表
|
||
"""
|
||
if isinstance(column_range, (int, np.integer)):
|
||
# 单个列索引
|
||
if column_range >= total_columns or column_range < 0:
|
||
raise ValueError(f"Column index {column_range} out of range [0, {total_columns-1}]")
|
||
return [column_range]
|
||
|
||
elif isinstance(column_range, str):
|
||
# 解析范围字符串
|
||
columns = []
|
||
# 分割多个范围（用逗号分隔）
|
||
for part in column_range.split(','):
|
||
part = part.strip()
|
||
if ':' in part:
|
||
# 范围选择，如 "0:5"
|
||
start, end = part.split(':')
|
||
start = int(start.strip()) if start.strip() else 0
|
||
end = int(end.strip()) if end.strip() else total_columns
|
||
if start < 0:
|
||
start = total_columns + start
|
||
if end < 0:
|
||
end = total_columns + end
|
||
if start >= total_columns or end > total_columns:
|
||
raise ValueError(f"Range {start}:{end} out of column range [0, {total_columns-1}]")
|
||
columns.extend(range(start, end))
|
||
else:
|
||
# 单个索引
|
||
idx = int(part.strip())
|
||
if idx < 0:
|
||
idx = total_columns + idx
|
||
if idx >= total_columns or idx < 0:
|
||
raise ValueError(f"Column index {idx} out of range [0, {total_columns-1}]")
|
||
columns.append(idx)
|
||
return list(set(columns)) # 去重
|
||
|
||
elif isinstance(column_range, (list, tuple)):
|
||
# 直接的列索引列表
|
||
columns = []
|
||
for idx in column_range:
|
||
if isinstance(idx, str):
|
||
if ':' in idx:
|
||
# 处理列表中的范围字符串
|
||
start, end = idx.split(':')
|
||
start = int(start.strip()) if start.strip() else 0
|
||
end = int(end.strip()) if end.strip() else total_columns
|
||
if start < 0:
|
||
start = total_columns + start
|
||
if end < 0:
|
||
end = total_columns + end
|
||
if start >= total_columns or end > total_columns:
|
||
raise ValueError(f"Range {start}:{end} out of column range [0, {total_columns-1}]")
|
||
columns.extend(range(start, end))
|
||
else:
|
||
idx_int = int(idx.strip())
|
||
if idx_int < 0:
|
||
idx_int = total_columns + idx_int
|
||
if idx_int >= total_columns or idx_int < 0:
|
||
raise ValueError(f"Column index {idx_int} out of range [0, {total_columns-1}]")
|
||
columns.append(idx_int)
|
||
else:
|
||
if idx < 0:
|
||
idx = total_columns + idx
|
||
if idx >= total_columns or idx < 0:
|
||
raise ValueError(f"Column index {idx} out of range [0, {total_columns-1}]")
|
||
columns.append(idx)
|
||
return list(set(columns)) # 去重
|
||
|
||
else:
|
||
raise ValueError(f"Unsupported column range format: {type(column_range)}")
|
||
|
||
def load_csv(self, file_path, label_column, spectrum_columns=None, delimiter=',', header=0):
|
||
"""
|
||
加载CSV文件并指定标签列和光谱列
|
||
|
||
Parameters:
|
||
file_path (str): CSV文件路径
|
||
label_column (str or int or range-like): 标签列，支持范围选择，如 "0:5", "2,4,6-8" 或单个索引
|
||
spectrum_columns (str or list or None): 光谱列，支持范围选择，如 "1:10", "2,4,6-8" 或列索引列表，如果为None则使用除标签列外的所有列
|
||
delimiter (str): 分隔符，默认为','
|
||
header (int): 表头行号，默认为0
|
||
"""
|
||
try:
|
||
# 读取CSV文件
|
||
self.data = pd.read_csv(file_path, delimiter=delimiter, header=header)
|
||
total_columns = len(self.data.columns)
|
||
|
||
# 处理标签列：先检查是否是列名，然后再检查是否是索引
|
||
if isinstance(label_column, str) and label_column in self.data.columns:
|
||
# 如果是有效的列名
|
||
label_idx = self.data.columns.get_loc(label_column)
|
||
self.y = self.data[label_column].values
|
||
else:
|
||
# 尝试作为列索引处理
|
||
try:
|
||
if isinstance(label_column, str):
|
||
# 可能是数字字符串，转换为整数
|
||
label_column = int(label_column)
|
||
label_idx = label_column
|
||
if label_idx < 0:
|
||
label_idx = total_columns + label_idx
|
||
if label_idx < 0 or label_idx >= total_columns:
|
||
raise ValueError(f"Column index {label_column} out of range [0, {total_columns-1}]")
|
||
self.y = self.data.iloc[:, label_idx].values
|
||
except (ValueError, TypeError):
|
||
raise ValueError(f"Invalid label column specification: {label_column}. Must be a valid column name or index.")
|
||
|
||
# 确定光谱列
|
||
if spectrum_columns is None:
|
||
# 使用除标签列外的所有列作为光谱列
|
||
spectrum_indices = [i for i in range(total_columns) if i != label_idx]
|
||
else:
|
||
# 解析光谱列范围
|
||
spectrum_indices = self._parse_column_range(spectrum_columns, total_columns)
|
||
# 排除标签列（如果在光谱列范围内）
|
||
spectrum_indices = [i for i in spectrum_indices if i != label_idx]
|
||
|
||
if not spectrum_indices:
|
||
raise ValueError("No valid spectrum columns found")
|
||
|
||
# 提取光谱数据
|
||
self.X = self.data.iloc[:, spectrum_indices].values
|
||
|
||
# 跳过缺失标签的行
|
||
valid_mask = ~pd.isna(self.y)
|
||
original_samples = len(self.y)
|
||
self.X = self.X[valid_mask]
|
||
self.y = self.y[valid_mask]
|
||
|
||
self.feature_names = [self.data.columns[i] for i in spectrum_indices]
|
||
|
||
skipped_samples = original_samples - len(self.y)
|
||
print(f"Successfully loaded data: {self.X.shape[0]} samples, {self.X.shape[1]} features")
|
||
print(f"Label column: {label_idx} ({self.data.columns[label_idx]})")
|
||
print(f"Spectrum column range: {min(spectrum_indices)}-{max(spectrum_indices)}")
|
||
if skipped_samples > 0:
|
||
print(f"Rows skipped due to missing labels: {skipped_samples}")
|
||
print(f"Label range: {self.y.min():.4f} - {self.y.max():.4f}")
|
||
print(f"Data type check: X type {self.X.dtype}, y type {self.y.dtype}")
|
||
|
||
# Check and process data types
|
||
if self.X.dtype != np.float64:
|
||
self.X = self.X.astype(np.float64)
|
||
if self.y.dtype != np.float64:
|
||
self.y = self.y.astype(np.float64)
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Failed to load data: {str(e)}")
|
||
return False
|
||
|
||
def preprocess_data(self, test_size=None, random_state=None, scale_method=None):
|
||
"""
|
||
数据预处理：分割训练集和测试集，标准化
|
||
|
||
Parameters:
|
||
test_size (float, optional): 测试集比例，如果为None则使用配置中的值
|
||
random_state (int, optional): 随机种子，如果为None则使用配置中的值
|
||
scale_method (str, optional): 标准化方法，如果为None则使用配置中的值
|
||
"""
|
||
# 使用配置中的默认值
|
||
test_size = test_size if test_size is not None else self.config.data.test_size
|
||
random_state = random_state if random_state is not None else self.config.data.random_state
|
||
scale_method = scale_method if scale_method is not None else self.config.data.scale_method
|
||
|
||
try:
|
||
# 分割数据集
|
||
self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(
|
||
self.X, self.y, test_size=test_size, random_state=random_state
|
||
)
|
||
|
||
# 标准化
|
||
if scale_method == 'standard':
|
||
self.scalers['X'] = StandardScaler()
|
||
elif scale_method == 'minmax':
|
||
self.scalers['X'] = MinMaxScaler()
|
||
else:
|
||
raise ValueError("scale_method must be 'standard' or 'minmax'")
|
||
|
||
self.X_train_scaled = self.scalers['X'].fit_transform(self.X_train)
|
||
self.X_test_scaled = self.scalers['X'].transform(self.X_test)
|
||
|
||
print(f"Data preprocessing completed:")
|
||
print(f"Training set: {self.X_train.shape[0]} samples")
|
||
print(f"Test set: {self.X_test.shape[0]} samples")
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Data preprocessing failed: {str(e)}")
|
||
return False
|
||
|
||
def add_linear_models(self):
|
||
"""添加线性回归模型"""
|
||
self.models['linear'] = {
|
||
'model': LinearRegression(),
|
||
'name': '多元线性回归'
|
||
}
|
||
|
||
self.models['lasso'] = {
|
||
'model': Lasso(random_state=42),
|
||
'name': 'LASSO回归',
|
||
'params': {
|
||
'alpha': [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
|
||
}
|
||
}
|
||
|
||
self.models['ridge'] = {
|
||
'model': Ridge(random_state=42),
|
||
'name': '岭回归',
|
||
'params': {
|
||
'alpha': [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
|
||
}
|
||
}
|
||
|
||
self.models['elasticnet'] = {
|
||
'model': ElasticNet(random_state=42),
|
||
'name': '弹性网络回归',
|
||
'params': {
|
||
'alpha': [0.001, 0.01, 0.1, 1.0, 10.0],
|
||
'l1_ratio': [0.1, 0.3, 0.5, 0.7, 0.9]
|
||
}
|
||
}
|
||
|
||
self.models['bayesianridge'] = {
|
||
'model': BayesianRidge(),
|
||
'name': '贝叶斯岭回归'
|
||
}
|
||
|
||
def add_boosting_models(self):
|
||
"""添加Boosting模型"""
|
||
self.models['lsboost'] = {
|
||
'model': GradientBoostingRegressor(random_state=42),
|
||
'name': 'LSBoost回归',
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'learning_rate': [0.01, 0.1, 0.2],
|
||
'max_depth': [3, 5, 7],
|
||
'subsample': [0.8, 0.9, 1.0]
|
||
}
|
||
}
|
||
|
||
self.models['xgboost'] = {
|
||
'model': xgb.XGBRegressor(random_state=42, objective='reg:squarederror'),
|
||
'name': 'XGBoost回归',
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'learning_rate': [0.01, 0.1, 0.2],
|
||
'max_depth': [3, 5, 7],
|
||
'subsample': [0.8, 0.9, 1.0],
|
||
'colsample_bytree': [0.8, 0.9, 1.0]
|
||
}
|
||
}
|
||
|
||
self.models['lightgbm'] = {
|
||
'model': lgb.LGBMRegressor(random_state=42),
|
||
'name': 'LightGBM回归',
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'learning_rate': [0.01, 0.1, 0.2],
|
||
'max_depth': [3, 5, 7],
|
||
'subsample': [0.8, 0.9, 1.0],
|
||
'colsample_bytree': [0.8, 0.9, 1.0]
|
||
}
|
||
}
|
||
|
||
def add_kernel_models(self):
|
||
"""添加核模型"""
|
||
# 高斯过程回归
|
||
kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))
|
||
self.models['gaussian'] = {
|
||
'model': GaussianProcessRegressor(kernel=kernel, random_state=42),
|
||
'name': '高斯过程回归'
|
||
}
|
||
|
||
# 高斯核SVM
|
||
self.models['gaussiansvm'] = {
|
||
'model': SVR(kernel='rbf'),
|
||
'name': '高斯核SVM回归',
|
||
'params': {
|
||
'C': [0.1, 1.0, 10.0, 100.0],
|
||
'gamma': ['scale', 'auto', 0.001, 0.01, 0.1, 1.0]
|
||
}
|
||
}
|
||
|
||
# 标准SVM回归
|
||
self.models['svm'] = {
|
||
'model': SVR(),
|
||
'name': 'SVM回归',
|
||
'params': {
|
||
'kernel': ['linear', 'poly', 'rbf', 'sigmoid'],
|
||
'C': [0.1, 1.0, 10.0, 100.0],
|
||
'gamma': ['scale', 'auto']
|
||
}
|
||
}
|
||
|
||
def add_neural_networks(self, training_config: Optional[TrainingConfig] = None):
|
||
"""添加神经网络模型"""
|
||
# ELM回归 (真正的极限学习机实现)
|
||
self.models['elm'] = {
|
||
'model': ExtremeLearningMachine(random_state=42),
|
||
'name': 'ELM回归',
|
||
'params': {
|
||
'n_hidden': [50, 100, 200, 500],
|
||
'activation': ['sigmoid', 'tanh', 'relu']
|
||
}
|
||
}
|
||
|
||
# BP/MLP回归
|
||
self.models['mlp'] = {
|
||
'model': MLPRegressor(random_state=42, max_iter=1000),
|
||
'name': 'BP/MLP回归',
|
||
'params': {
|
||
'hidden_layer_sizes': [(50,), (100,), (100, 50), (200, 100)],
|
||
'activation': ['relu', 'tanh'],
|
||
'learning_rate_init': [0.001, 0.01, 0.1],
|
||
'alpha': [0.0001, 0.001, 0.01]
|
||
}
|
||
}
|
||
|
||
# LSTM回归 (将光谱数据视为序列，波段作为时间步)
|
||
self.models['lstm'] = {
|
||
'model': LSTMRegressor(random_state=42, config=training_config),
|
||
'name': 'LSTM回归',
|
||
'params': {
|
||
'units': [32, 64, 128],
|
||
'dropout': [0.1, 0.2, 0.3],
|
||
'epochs': [50, 100, 200]
|
||
}
|
||
}
|
||
|
||
# GRU回归 (将光谱数据视为序列，波段作为时间步)
|
||
self.models['gru'] = {
|
||
'model': GRURegressor(random_state=42, config=training_config),
|
||
'name': 'GRU回归',
|
||
'params': {
|
||
'units': [32, 64, 128],
|
||
'dropout': [0.1, 0.2, 0.3],
|
||
'epochs': [50, 100, 200]
|
||
}
|
||
}
|
||
|
||
def add_specialized_models(self):
|
||
"""添加专业模型"""
|
||
# GAM回归 (真正的广义加性模型)
|
||
self.models['gam'] = {
|
||
'model': GeneralizedAdditiveModel(),
|
||
'name': 'GAM回归',
|
||
'params': {
|
||
'n_splines': [5, 10, 15, 20],
|
||
'degree': [3, 4],
|
||
'lambda_': [0.001, 0.01, 0.1, 1.0]
|
||
}
|
||
}
|
||
|
||
# 决策树回归
|
||
self.models['decisiontree'] = {
|
||
'model': DecisionTreeRegressor(random_state=42),
|
||
'name': '决策树回归',
|
||
'params': {
|
||
'max_depth': [None, 10, 20, 30],
|
||
'min_samples_split': [2, 5, 10],
|
||
'min_samples_leaf': [1, 2, 4],
|
||
'max_features': ['auto', 'sqrt', 'log2']
|
||
}
|
||
}
|
||
|
||
# 随机森林回归
|
||
self.models['randomforest'] = {
|
||
'model': RandomForestRegressor(random_state=42),
|
||
'name': '随机森林回归',
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'max_depth': [None, 10, 20, 30],
|
||
'min_samples_split': [2, 5, 10],
|
||
'min_samples_leaf': [1, 2, 4],
|
||
'max_features': ['auto', 'sqrt', 'log2']
|
||
}
|
||
}
|
||
|
||
# 极端随机树回归
|
||
self.models['extratrees'] = {
|
||
'model': ExtraTreesRegressor(random_state=42),
|
||
'name': '极端随机树回归',
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'max_depth': [None, 10, 20, 30],
|
||
'min_samples_split': [2, 5, 10],
|
||
'min_samples_leaf': [1, 2, 4],
|
||
'max_features': ['auto', 'sqrt', 'log2']
|
||
}
|
||
}
|
||
|
||
# AdaBoost回归
|
||
self.models['adaboost'] = {
|
||
'model': AdaBoostRegressor(random_state=42),
|
||
'name': 'AdaBoost回归',
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'learning_rate': [0.01, 0.1, 1.0],
|
||
'loss': ['linear', 'square', 'exponential']
|
||
}
|
||
}
|
||
|
||
def initialize_all_models(self, use_config: bool = True):
|
||
"""Initialize all models"""
|
||
self.add_linear_models()
|
||
self.add_boosting_models()
|
||
self.add_kernel_models()
|
||
|
||
# 神经网络模型可以选择是否使用配置
|
||
if use_config and hasattr(self, 'config'):
|
||
self.add_neural_networks(self.config.training)
|
||
else:
|
||
self.add_neural_networks()
|
||
|
||
self.add_specialized_models()
|
||
|
||
print(f"Initialized {len(self.models)} regression models")
|
||
|
||
def get_available_models(self):
|
||
"""获取所有可用模型的名称和描述"""
|
||
return {name: info['name'] for name, info in self.models.items()}
|
||
|
||
def hyperparameter_tuning(self, model_name, method=None, cv=None, n_iter=None):
|
||
"""
|
||
超参数调优
|
||
|
||
Parameters:
|
||
model_name (str): 模型名称
|
||
method (str, optional): 调优方法，如果为None则使用配置中的值
|
||
cv (int, optional): 交叉验证折数，如果为None则使用配置中的值
|
||
n_iter (int, optional): 随机搜索的迭代次数，如果为None则使用配置中的值
|
||
"""
|
||
# 使用配置中的默认值
|
||
method = method if method is not None else self.config.models.tuning_method
|
||
cv = cv if cv is not None else self.config.models.cv_folds
|
||
n_iter = n_iter if n_iter is not None else self.config.models.random_search_iter
|
||
if model_name not in self.models:
|
||
print(f"Model '{model_name}' does not exist")
|
||
return False
|
||
|
||
model_info = self.models[model_name]
|
||
if 'params' not in model_info:
|
||
print(f"Model '{model_name}' has no tunable parameters")
|
||
return False
|
||
|
||
print(f"Starting hyperparameter tuning for model: {model_info['name']}")
|
||
|
||
if method == 'grid':
|
||
search = GridSearchCV(
|
||
model_info['model'],
|
||
model_info['params'],
|
||
cv=cv,
|
||
scoring='neg_mean_squared_error',
|
||
n_jobs=-1,
|
||
verbose=1
|
||
)
|
||
elif method == 'random':
|
||
search = RandomizedSearchCV(
|
||
model_info['model'],
|
||
model_info['params'],
|
||
n_iter=n_iter,
|
||
cv=cv,
|
||
scoring='neg_mean_squared_error',
|
||
n_jobs=-1,
|
||
random_state=42,
|
||
verbose=1
|
||
)
|
||
else:
|
||
print("Tuning method must be 'grid' or 'random'")
|
||
return False
|
||
|
||
try:
|
||
search.fit(self.X_train_scaled, self.y_train)
|
||
self.best_params[model_name] = search.best_params_
|
||
self.models[model_name]['model'] = search.best_estimator_
|
||
|
||
print(f"Best parameters: {search.best_params_}")
|
||
print(f"Best score: {-search.best_score_:.4f}")
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Tuning failed: {str(e)}")
|
||
return False
|
||
|
||
def train_model(self, model_name):
|
||
"""训练单个模型"""
|
||
if model_name not in self.models:
|
||
print(f"Model '{model_name}' does not exist")
|
||
return False
|
||
|
||
try:
|
||
model_info = self.models[model_name]
|
||
model = model_info['model']
|
||
|
||
print(f"Training model: {model_info['name']}")
|
||
|
||
# Train model
|
||
model.fit(self.X_train_scaled, self.y_train)
|
||
|
||
# Predict
|
||
y_pred_train = model.predict(self.X_train_scaled)
|
||
y_pred_test = model.predict(self.X_test_scaled)
|
||
|
||
# Calculate evaluation metrics
|
||
metrics = self.calculate_metrics(self.y_train, y_pred_train, self.y_test, y_pred_test)
|
||
|
||
self.results[model_name] = {
|
||
'model': model,
|
||
'metrics': metrics,
|
||
'y_pred_train': y_pred_train,
|
||
'y_pred_test': y_pred_test
|
||
}
|
||
|
||
print(f"{model_info['name']} training completed")
|
||
print(f"Training R²: {metrics['train_r2']:.4f}, Test R²: {metrics['test_r2']:.4f}")
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Training failed: {str(e)}")
|
||
return False
|
||
|
||
def train_all_models(self, tune_hyperparams=False, tuning_method='grid'):
|
||
"""训练当前配置的所有模型"""
|
||
models_to_train = list(self.models.keys())
|
||
print(f"Training {len(models_to_train)} models: {', '.join(models_to_train)}")
|
||
|
||
for model_name in models_to_train:
|
||
if tune_hyperparams and 'params' in self.models[model_name]:
|
||
self.hyperparameter_tuning(model_name, method=tuning_method)
|
||
self.train_model(model_name)
|
||
|
||
def calculate_metrics(self, y_train, y_pred_train, y_test, y_pred_test):
|
||
"""计算评价指标"""
|
||
metrics = {}
|
||
|
||
# 训练集指标
|
||
metrics['train_mse'] = mean_squared_error(y_train, y_pred_train)
|
||
metrics['train_rmse'] = np.sqrt(metrics['train_mse'])
|
||
metrics['train_mae'] = mean_absolute_error(y_train, y_pred_train)
|
||
metrics['train_r2'] = r2_score(y_train, y_pred_train)
|
||
|
||
# 测试集指标
|
||
metrics['test_mse'] = mean_squared_error(y_test, y_pred_test)
|
||
metrics['test_rmse'] = np.sqrt(metrics['test_mse'])
|
||
metrics['test_mae'] = mean_absolute_error(y_test, y_pred_test)
|
||
metrics['test_r2'] = r2_score(y_test, y_pred_test)
|
||
|
||
return metrics
|
||
|
||
def plot_results(self, save_path=None, plot_type='comprehensive'):
|
||
"""
|
||
绘制结果比较图
|
||
|
||
Parameters:
|
||
save_path (str, optional): 保存路径
|
||
plot_type (str): 绘图类型 ('basic', 'comprehensive', 'prediction', 'residual',
|
||
'metrics', 'error_dist', 'ranking')
|
||
"""
|
||
if not self.results:
|
||
print("No training results to plot")
|
||
return
|
||
|
||
if plot_type == 'comprehensive':
|
||
# 生成综合报告
|
||
self.visualizer.generate_comprehensive_report(
|
||
save_dir=self.config.output.plot_dir,
|
||
prefix='regression_analysis'
|
||
)
|
||
elif plot_type == 'basic':
|
||
# 基础图表（保持向后兼容）
|
||
self._plot_basic_comparison(save_path)
|
||
elif plot_type == 'prediction':
|
||
# 预测值vs真实值散点图
|
||
self.visualizer.plot_prediction_scatter(save_path=save_path)
|
||
elif plot_type == 'residual':
|
||
# 残差分析图
|
||
self.visualizer.plot_residual_analysis(save_path=save_path)
|
||
elif plot_type == 'metrics':
|
||
# 性能指标对比图
|
||
self.visualizer.plot_metrics_comparison(save_path=save_path)
|
||
elif plot_type == 'error_dist':
|
||
# 误差分布图
|
||
self.visualizer.plot_error_distribution(save_path=save_path)
|
||
elif plot_type == 'ranking':
|
||
# 模型排名矩阵
|
||
self.visualizer.plot_model_ranking_matrix(save_path=save_path)
|
||
else:
|
||
print(f"Unknown plot type: {plot_type}")
|
||
return
|
||
|
||
def _plot_basic_comparison(self, save_path=None):
|
||
"""绘制基础比较图（向后兼容）"""
|
||
# 准备数据
|
||
model_names = []
|
||
train_r2 = []
|
||
test_r2 = []
|
||
train_rmse = []
|
||
test_rmse = []
|
||
|
||
for model_name, result in self.results.items():
|
||
model_names.append(self.models[model_name]['name'])
|
||
train_r2.append(result['metrics']['train_r2'])
|
||
test_r2.append(result['metrics']['test_r2'])
|
||
train_rmse.append(result['metrics']['train_rmse'])
|
||
test_rmse.append(result['metrics']['test_rmse'])
|
||
|
||
# 创建图表
|
||
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 12))
|
||
|
||
# R² Score Comparison
|
||
x = np.arange(len(model_names))
|
||
width = 0.35
|
||
|
||
ax1.bar(x - width/2, train_r2, width, label='Training Set', alpha=0.8)
|
||
ax1.bar(x + width/2, test_r2, width, label='Test Set', alpha=0.8)
|
||
ax1.set_xlabel('Model')
|
||
ax1.set_ylabel('R² Score')
|
||
ax1.set_title('R² Score Comparison')
|
||
ax1.set_xticks(x)
|
||
ax1.set_xticklabels(model_names, rotation=45, ha='right')
|
||
ax1.legend()
|
||
ax1.grid(True, alpha=0.3)
|
||
|
||
# RMSE Comparison
|
||
ax2.bar(x - width/2, train_rmse, width, label='Training Set', alpha=0.8)
|
||
ax2.bar(x + width/2, test_rmse, width, label='Test Set', alpha=0.8)
|
||
ax2.set_xlabel('Model')
|
||
ax2.set_ylabel('RMSE')
|
||
ax2.set_title('RMSE Comparison')
|
||
ax2.set_xticks(x)
|
||
ax2.set_xticklabels(model_names, rotation=45, ha='right')
|
||
ax2.legend()
|
||
ax2.grid(True, alpha=0.3)
|
||
|
||
# Predicted vs Actual Values Scatter Plot (Test Set)
|
||
colors = plt.cm.tab10(np.linspace(0, 1, len(self.results)))
|
||
for i, (model_name, result) in enumerate(self.results.items()):
|
||
ax3.scatter(self.y_test, result['y_pred_test'], alpha=0.6, color=colors[i],
|
||
label=self.models[model_name]['name'], s=20)
|
||
|
||
ax3.plot([self.y_test.min(), self.y_test.max()], [self.y_test.min(), self.y_test.max()],
|
||
'k--', linewidth=2, label='Perfect Prediction')
|
||
ax3.set_xlabel('Actual Values')
|
||
ax3.set_ylabel('Predicted Values')
|
||
ax3.set_title('Predicted vs Actual Values (Test Set)')
|
||
ax3.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
|
||
ax3.grid(True, alpha=0.3)
|
||
|
||
# Residual Plot
|
||
for i, (model_name, result) in enumerate(self.results.items()):
|
||
residuals = self.y_test - result['y_pred_test']
|
||
ax4.scatter(result['y_pred_test'], residuals, alpha=0.6, color=colors[i],
|
||
label=self.models[model_name]['name'], s=20)
|
||
|
||
ax4.axhline(y=0, color='k', linestyle='--', linewidth=2)
|
||
ax4.set_xlabel('Predicted Values')
|
||
ax4.set_ylabel('Residuals')
|
||
ax4.set_title('Residual Plot (Test Set)')
|
||
ax4.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
|
||
ax4.grid(True, alpha=0.3)
|
||
|
||
plt.tight_layout()
|
||
|
||
if save_path:
|
||
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
||
print(f"Chart saved to: {save_path}")
|
||
|
||
# plt.show()
|
||
|
||
def plot_prediction_scatter(self, save_path=None, **kwargs):
|
||
"""绘制预测值vs真实值散点图"""
|
||
self.visualizer.plot_prediction_scatter(save_path=save_path, **kwargs)
|
||
|
||
def plot_residual_analysis(self, save_path=None, **kwargs):
|
||
"""绘制残差分析图"""
|
||
self.visualizer.plot_residual_analysis(save_path=save_path, **kwargs)
|
||
|
||
def plot_metrics_comparison(self, save_path=None, **kwargs):
|
||
"""绘制性能指标对比图"""
|
||
self.visualizer.plot_metrics_comparison(save_path=save_path, **kwargs)
|
||
|
||
def plot_error_distribution(self, save_path=None, **kwargs):
|
||
"""绘制误差分布图"""
|
||
self.visualizer.plot_error_distribution(save_path=save_path, **kwargs)
|
||
|
||
def plot_model_ranking(self, save_path=None, **kwargs):
|
||
"""绘制模型排名矩阵"""
|
||
self.visualizer.plot_model_ranking_matrix(save_path=save_path, **kwargs)
|
||
|
||
def generate_visualization_report(self, save_dir=None, prefix=None):
|
||
"""生成完整的可视化报告"""
|
||
save_dir = save_dir or self.config.output.plot_dir
|
||
prefix = prefix or 'regression_analysis'
|
||
return self.visualizer.generate_comprehensive_report(save_dir=save_dir, prefix=prefix)
|
||
|
||
def save_model(self, model_name, save_dir='models'):
|
||
"""Save model"""
|
||
if model_name not in self.results:
|
||
print(f"Model '{model_name}' has no training results")
|
||
return False
|
||
|
||
if not os.path.exists(save_dir):
|
||
os.makedirs(save_dir)
|
||
|
||
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
|
||
model_path = os.path.join(save_dir, f'{model_name}_{timestamp}.pkl')
|
||
scaler_path = os.path.join(save_dir, f'scaler_{timestamp}.pkl')
|
||
info_path = os.path.join(save_dir, f'info_{model_name}_{timestamp}.json')
|
||
|
||
try:
|
||
# 保存模型
|
||
joblib.dump(self.results[model_name]['model'], model_path)
|
||
|
||
# 保存标准化器
|
||
joblib.dump(self.scalers['X'], scaler_path)
|
||
|
||
# 保存模型信息
|
||
info = {
|
||
'model_name': model_name,
|
||
'full_name': self.models[model_name]['name'],
|
||
'timestamp': timestamp,
|
||
'metrics': self.results[model_name]['metrics'],
|
||
'best_params': self.best_params.get(model_name, {}),
|
||
'feature_names': self.feature_names
|
||
}
|
||
|
||
with open(info_path, 'w', encoding='utf-8') as f:
|
||
json.dump(info, f, indent=4, ensure_ascii=False)
|
||
|
||
print(f"Model saved:")
|
||
print(f" Model file: {model_path}")
|
||
print(f" Scaler: {scaler_path}")
|
||
print(f" Info file: {info_path}")
|
||
|
||
return True
|
||
|
||
except Exception as e:
|
||
print(f"Save failed: {str(e)}")
|
||
return False
|
||
|
||
def save_all_models(self, save_dir='models'):
|
||
"""保存所有模型"""
|
||
for model_name in self.results.keys():
|
||
self.save_model(model_name, save_dir)
|
||
|
||
def load_model(self, model_path, scaler_path=None):
|
||
"""加载模型"""
|
||
try:
|
||
model = joblib.load(model_path)
|
||
if scaler_path:
|
||
scaler = joblib.load(scaler_path)
|
||
else:
|
||
scaler = None
|
||
|
||
return model, scaler
|
||
|
||
except Exception as e:
|
||
print(f"Load failed: {str(e)}")
|
||
return None, None
|
||
|
||
def print_summary(self):
|
||
"""Print results summary"""
|
||
if not self.results:
|
||
print("No training results")
|
||
return
|
||
|
||
print("\n" + "="*80)
|
||
print("Regression Model Performance Summary")
|
||
print("="*80)
|
||
|
||
# Header
|
||
header = "|30"
|
||
print(header)
|
||
|
||
# Result rows
|
||
for model_name, result in sorted(self.results.items(),
|
||
key=lambda x: x[1]['metrics']['test_r2'], reverse=True):
|
||
metrics = result['metrics']
|
||
model_full_name = self.models[model_name]['name']
|
||
print("|30")
|
||
|
||
print("-"*80)
|
||
print("Note: R² closer to 1 is better, RMSE/MAE smaller is better")
|
||
print("="*80)
|
||
|
||
def run_analysis_from_config(self) -> bool:
|
||
"""
|
||
基于配置对象运行完整分析流程 - 推荐用于GUI对接
|
||
|
||
Returns:
|
||
bool: 分析是否成功完成
|
||
"""
|
||
print("Starting regression analysis from configuration...")
|
||
|
||
# 1. 加载数据
|
||
if not self.load_csv(self.config.data.csv_path, self.config.data.label_column,
|
||
self.config.data.spectrum_columns):
|
||
return False
|
||
|
||
# 2. 数据预处理
|
||
if not self.preprocess_data():
|
||
return False
|
||
|
||
# 3. 初始化模型
|
||
self.initialize_all_models(use_config=True)
|
||
|
||
# 4. 过滤模型（如果指定了特定的模型）
|
||
if self.config.models.model_names is not None:
|
||
# 验证指定的模型名称
|
||
invalid_models = [name for name in self.config.models.model_names if name not in self.models]
|
||
if invalid_models:
|
||
print(f"Warning: The following models do not exist: {invalid_models}")
|
||
valid_model_names = [name for name in self.config.models.model_names if name in self.models]
|
||
else:
|
||
valid_model_names = self.config.models.model_names
|
||
|
||
# 只保留指定的模型
|
||
models_to_keep = {}
|
||
for model_name in valid_model_names:
|
||
if model_name in self.models:
|
||
models_to_keep[model_name] = self.models[model_name]
|
||
self.models = models_to_keep
|
||
print(f"Filtered to {len(self.models)} specified models")
|
||
|
||
# 5. 训练模型
|
||
self.train_all_models(tune_hyperparams=self.config.models.tune_hyperparams,
|
||
tuning_method=self.config.models.tuning_method)
|
||
|
||
# 6. 打印汇总
|
||
self.print_summary()
|
||
|
||
# 7. 保存模型
|
||
if self.config.output.save_models:
|
||
self.save_all_models(save_dir=self.config.output.save_dir)
|
||
|
||
# 8. 绘制结果
|
||
if self.config.output.plot_results:
|
||
os.makedirs(self.config.output.plot_dir, exist_ok=True)
|
||
self.generate_visualization_report(
|
||
save_dir=self.config.output.plot_dir,
|
||
prefix='regression_analysis'
|
||
)
|
||
|
||
print("Analysis completed!")
|
||
return True
|
||
|
||
def run_complete_analysis(self, csv_path=None, label_column=None, spectrum_columns=None,
|
||
test_size=None, scale_method=None, tune_hyperparams=None,
|
||
tuning_method=None, save_models=None, plot_results=None,
|
||
model_names=None):
|
||
"""
|
||
运行完整分析流程 - 保持向后兼容性
|
||
|
||
Parameters:
|
||
csv_path (str, optional): CSV文件路径，如果为None则使用配置中的值
|
||
label_column (str or int, optional): 标签列，如果为None则使用配置中的值
|
||
spectrum_columns (str or list or None, optional): 光谱列，如果为None则使用配置中的值
|
||
test_size (float, optional): 测试集比例，如果为None则使用配置中的值
|
||
scale_method (str, optional): 标准化方法，如果为None则使用配置中的值
|
||
tune_hyperparams (bool, optional): 是否调优超参数，如果为None则使用配置中的值
|
||
tuning_method (str, optional): 调优方法，如果为None则使用配置中的值
|
||
save_models (bool, optional): 是否保存模型，如果为None则使用配置中的值
|
||
plot_results (bool, optional): 是否绘制结果图，如果为None则使用配置中的值
|
||
model_names (list or None, optional): 要训练的模型名称列表，如果为None则使用配置中的值
|
||
"""
|
||
# 更新配置对象（向后兼容）
|
||
if csv_path is not None:
|
||
self.config.data.csv_path = csv_path
|
||
if label_column is not None:
|
||
self.config.data.label_column = label_column
|
||
if spectrum_columns is not None:
|
||
self.config.data.spectrum_columns = spectrum_columns
|
||
if test_size is not None:
|
||
self.config.data.test_size = test_size
|
||
if scale_method is not None:
|
||
self.config.data.scale_method = scale_method
|
||
if tune_hyperparams is not None:
|
||
self.config.models.tune_hyperparams = tune_hyperparams
|
||
if tuning_method is not None:
|
||
self.config.models.tuning_method = tuning_method
|
||
if save_models is not None:
|
||
self.config.output.save_models = save_models
|
||
if plot_results is not None:
|
||
self.config.output.plot_results = plot_results
|
||
if model_names is not None:
|
||
self.config.models.model_names = model_names
|
||
|
||
# 使用配置驱动的方法
|
||
return self.run_analysis_from_config()
|
||
|
||
|
||
class RegressionVisualizer:
|
||
"""
|
||
回归分析可视化器 - 提供丰富的可视化功能
|
||
支持预测值vs真实值散点图、残差图、性能指标对比等
|
||
"""
|
||
|
||
def __init__(self, analyzer: Optional['RegressionAnalyzer'] = None):
|
||
"""
|
||
初始化可视化器
|
||
|
||
Parameters:
|
||
analyzer (RegressionAnalyzer, optional): 回归分析器实例
|
||
"""
|
||
self.analyzer = analyzer
|
||
self.colorblind_friendly_palette = [
|
||
'#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd',
|
||
'#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf',
|
||
'#aec7e8', '#ffbb78', '#98df8a', '#ff9896', '#c5b0d5'
|
||
]
|
||
plt.style.use('seaborn-v0_8')
|
||
|
||
# 配置matplotlib支持中文显示
|
||
self._configure_chinese_font()
|
||
|
||
def _configure_chinese_font(self):
|
||
"""配置matplotlib以支持中文显示"""
|
||
import matplotlib as mpl
|
||
|
||
# 尝试设置中文字体
|
||
chinese_fonts = ['SimHei', 'Microsoft YaHei', 'DejaVu Sans', 'Arial Unicode MS',
|
||
'WenQuanYi Micro Hei', 'AR PL UMing CN', 'Liberation Serif']
|
||
|
||
font_set = False
|
||
for font in chinese_fonts:
|
||
try:
|
||
# 测试字体是否可用
|
||
test_text = "测试中文"
|
||
fig, ax = plt.subplots()
|
||
ax.text(0.5, 0.5, test_text, fontname=font, fontsize=12)
|
||
plt.close(fig)
|
||
|
||
# 如果没有报错，设置字体
|
||
mpl.rcParams['font.sans-serif'] = [font] + mpl.rcParams['font.sans-serif']
|
||
mpl.rcParams['axes.unicode_minus'] = False # 解决负号显示问题
|
||
font_set = True
|
||
print(f"Successfully set Chinese font to: {font}")
|
||
break
|
||
except:
|
||
continue
|
||
|
||
if not font_set:
|
||
# 如果没有找到合适的中文字体，使用系统默认并启用unicode
|
||
mpl.rcParams['font.sans-serif'] = ['DejaVu Sans', 'SimHei']
|
||
mpl.rcParams['axes.unicode_minus'] = False
|
||
print("Warning: Could not find suitable Chinese font. Using default fonts.")
|
||
|
||
def _ensure_chinese_text(self, text):
|
||
"""确保文本正确显示中文"""
|
||
if isinstance(text, str):
|
||
try:
|
||
# 尝试编码和解码以确保UTF-8格式
|
||
return text.encode('utf-8').decode('utf-8')
|
||
except:
|
||
return text
|
||
return text
|
||
|
||
def set_colorblind_palette(self):
|
||
"""设置色盲友好配色方案"""
|
||
import matplotlib as mpl
|
||
mpl.rcParams['axes.prop_cycle'] = mpl.cycler(color=self.colorblind_friendly_palette)
|
||
|
||
def plot_prediction_scatter(self, figsize=(16, 12), save_path=None, show_individual=True, show_overlay=True):
|
||
"""
|
||
绘制预测值vs真实值散点图
|
||
|
||
Parameters:
|
||
figsize (tuple): 图形尺寸
|
||
save_path (str, optional): 保存路径
|
||
show_individual (bool): 是否显示多子图
|
||
show_overlay (bool): 是否显示叠加图
|
||
"""
|
||
if not self.analyzer or not self.analyzer.results:
|
||
print("No analyzer results available for plotting")
|
||
return
|
||
|
||
self.set_colorblind_palette()
|
||
n_models = len(self.analyzer.results)
|
||
|
||
if show_individual and show_overlay:
|
||
# 创建复合图：上方多子图，下方叠加图
|
||
fig = plt.figure(figsize=figsize)
|
||
|
||
# 上方：多子图（每个模型一个子图）
|
||
n_cols = min(4, n_models)
|
||
n_rows = (n_models + n_cols - 1) // n_cols
|
||
|
||
gs = fig.add_gridspec(n_rows + 1, n_cols, hspace=0.3, wspace=0.3)
|
||
axes_scatter = []
|
||
for i in range(n_rows):
|
||
for j in range(n_cols):
|
||
if i * n_cols + j < n_models:
|
||
axes_scatter.append(fig.add_subplot(gs[i, j]))
|
||
|
||
# 下方：叠加图
|
||
ax_overlay = fig.add_subplot(gs[n_rows, :])
|
||
|
||
elif show_individual:
|
||
# 只有多子图
|
||
n_cols = min(4, n_models)
|
||
n_rows = (n_models + n_cols - 1) // n_cols
|
||
fig, axes_scatter = plt.subplots(n_rows, n_cols, figsize=figsize)
|
||
if n_models == 1:
|
||
axes_scatter = [axes_scatter]
|
||
else:
|
||
axes_scatter = axes_scatter.flatten()
|
||
ax_overlay = None
|
||
|
||
elif show_overlay:
|
||
# 只有叠加图
|
||
fig, ax_overlay = plt.subplots(1, 1, figsize=(10, 8))
|
||
axes_scatter = []
|
||
else:
|
||
print("At least one of show_individual or show_overlay must be True")
|
||
return
|
||
|
||
# 绘制多子图
|
||
if show_individual:
|
||
for idx, (model_name, result) in enumerate(self.analyzer.results.items()):
|
||
if idx < len(axes_scatter):
|
||
ax = axes_scatter[idx]
|
||
y_true = self.analyzer.y_test
|
||
y_pred = result['y_pred_test']
|
||
|
||
# 散点图
|
||
ax.scatter(y_true, y_pred, alpha=0.6, s=30, color=self.colorblind_friendly_palette[idx % len(self.colorblind_friendly_palette)])
|
||
|
||
# 45度参考线
|
||
min_val = min(y_true.min(), y_pred.min())
|
||
max_val = max(y_true.max(), y_pred.max())
|
||
ax.plot([min_val, max_val], [min_val, max_val], 'k--', linewidth=2, alpha=0.7)
|
||
|
||
# 添加R²和RMSE文本
|
||
r2 = result['metrics']['test_r2']
|
||
rmse = result['metrics']['test_rmse']
|
||
ax.text(0.05, 0.95, f'R² = {r2:.3f}\nRMSE = {rmse:.3f}',
|
||
transform=ax.transAxes, fontsize=10,
|
||
verticalalignment='top', bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.8))
|
||
|
||
ax.set_xlabel(self._ensure_chinese_text('True Values'))
|
||
ax.set_ylabel(self._ensure_chinese_text('Predicted Values'))
|
||
ax.set_title(self._ensure_chinese_text(f'{self.analyzer.models[model_name]["name"]}'))
|
||
ax.grid(True, alpha=0.3)
|
||
ax.axis('equal')
|
||
|
||
# 绘制叠加图
|
||
if show_overlay:
|
||
for idx, (model_name, result) in enumerate(self.analyzer.results.items()):
|
||
y_true = self.analyzer.y_test
|
||
y_pred = result['y_pred_test']
|
||
|
||
ax_overlay.scatter(y_true, y_pred, alpha=0.6, s=30,
|
||
color=self.colorblind_friendly_palette[idx % len(self.colorblind_friendly_palette)],
|
||
label=f'{self.analyzer.models[model_name]["name"]} (R²={result["metrics"]["test_r2"]:.3f})')
|
||
|
||
# 45度参考线
|
||
min_val = min(self.analyzer.y_test.min(), min([r['y_pred_test'].min() for r in self.analyzer.results.values()]))
|
||
max_val = max(self.analyzer.y_test.max(), max([r['y_pred_test'].max() for r in self.analyzer.results.values()]))
|
||
ax_overlay.plot([min_val, max_val], [min_val, max_val], 'k--', linewidth=2, alpha=0.7, label='Perfect Prediction')
|
||
|
||
ax_overlay.set_xlabel(self._ensure_chinese_text('True Values'))
|
||
ax_overlay.set_ylabel(self._ensure_chinese_text('Predicted Values'))
|
||
ax_overlay.set_title(self._ensure_chinese_text('Predicted vs True Values - All Models Overlay'))
|
||
ax_overlay.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
|
||
ax_overlay.grid(True, alpha=0.3)
|
||
ax_overlay.axis('equal')
|
||
|
||
plt.tight_layout()
|
||
|
||
if save_path:
|
||
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
||
print(f"Prediction scatter plot saved to: {save_path}")
|
||
|
||
# plt.show()
|
||
|
||
def plot_residual_analysis(self, figsize=(16, 8), save_path=None, n_feature_plots=3):
|
||
"""
|
||
绘制残差分析图
|
||
|
||
Parameters:
|
||
figsize (tuple): 图形尺寸
|
||
save_path (str, optional): 保存路径
|
||
n_feature_plots (int): 显示多少个特征的残差vs特征图
|
||
"""
|
||
if not self.analyzer or not self.analyzer.results:
|
||
print("No analyzer results available for plotting")
|
||
return
|
||
|
||
self.set_colorblind_palette()
|
||
|
||
# 选择表现最好的几个模型进行详细分析
|
||
sorted_models = sorted(self.analyzer.results.items(),
|
||
key=lambda x: x[1]['metrics']['test_r2'], reverse=True)
|
||
top_models = sorted_models[:min(3, len(sorted_models))]
|
||
|
||
fig, axes = plt.subplots(2, 3, figsize=figsize)
|
||
|
||
for idx, (model_name, result) in enumerate(top_models):
|
||
y_true = self.analyzer.y_test
|
||
y_pred = result['y_pred_test']
|
||
residuals = y_true - y_pred
|
||
|
||
# 残差vs预测值
|
||
ax1 = axes[0, 0] if idx == 0 else axes[0, idx]
|
||
ax1.scatter(y_pred, residuals, alpha=0.6, s=20,
|
||
color=self.colorblind_friendly_palette[idx % len(self.colorblind_friendly_palette)])
|
||
ax1.axhline(y=0, color='k', linestyle='--', linewidth=2)
|
||
ax1.set_xlabel('Predicted Values')
|
||
ax1.set_ylabel('Residuals')
|
||
ax1.set_title(f'Residuals vs Predicted\n{self.analyzer.models[model_name]["name"]}')
|
||
ax1.grid(True, alpha=0.3)
|
||
|
||
# Q-Q图
|
||
ax2 = axes[1, 0] if idx == 0 else axes[1, idx]
|
||
stats.probplot(residuals, dist="norm", plot=ax2)
|
||
ax2.set_title(f'Normal Q-Q Plot\n{self.analyzer.models[model_name]["name"]}')
|
||
|
||
# 残差vs重要特征（如果有特征重要性）
|
||
if idx < n_feature_plots - 2 and hasattr(result['model'], 'feature_importances_'):
|
||
ax3 = axes[idx // 3 + 1, idx % 3 + 1] if idx > 0 else axes[0, 2]
|
||
if idx < 2: # 只显示前两个模型的特征残差图
|
||
try:
|
||
importances = result['model'].feature_importances_
|
||
top_features_idx = np.argsort(importances)[-2:] # 最重要的两个特征
|
||
|
||
for i, feat_idx in enumerate(top_features_idx):
|
||
feat_name = self.analyzer.feature_names[feat_idx] if hasattr(self.analyzer, 'feature_names') else f'Feature {feat_idx}'
|
||
ax3.scatter(self.analyzer.X_test[:, feat_idx], residuals,
|
||
alpha=0.6, s=20, label=f'{feat_name}',
|
||
color=self.colorblind_friendly_palette[(idx*2 + i) % len(self.colorblind_friendly_palette)])
|
||
ax3.axhline(y=0, color='k', linestyle='--', linewidth=2)
|
||
ax3.set_xlabel('Feature Values')
|
||
ax3.set_ylabel('Residuals')
|
||
ax3.set_title(f'Residuals vs Top Features\n{self.analyzer.models[model_name]["name"]}')
|
||
ax3.legend()
|
||
ax3.grid(True, alpha=0.3)
|
||
except:
|
||
ax3.text(0.5, 0.5, 'Feature importance\nnot available',
|
||
transform=ax3.transAxes, ha='center', va='center')
|
||
ax3.set_title(f'Feature Analysis\n{self.analyzer.models[model_name]["name"]}')
|
||
|
||
plt.tight_layout()
|
||
|
||
if save_path:
|
||
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
||
print(f"Residual analysis plot saved to: {save_path}")
|
||
|
||
# plt.show()
|
||
|
||
def plot_metrics_comparison(self, figsize=(16, 10), save_path=None):
|
||
"""
|
||
绘制性能指标对比图
|
||
|
||
Parameters:
|
||
figsize (tuple): 图形尺寸
|
||
save_path (str, optional): 保存路径
|
||
"""
|
||
if not self.analyzer or not self.analyzer.results:
|
||
print("No analyzer results available for plotting")
|
||
return
|
||
|
||
self.set_colorblind_palette()
|
||
|
||
# 准备数据
|
||
model_names = []
|
||
model_full_names = []
|
||
r2_scores = []
|
||
rmse_scores = []
|
||
mae_scores = []
|
||
training_times = []
|
||
memory_usage = []
|
||
|
||
# 模拟训练时间和内存使用（实际应用中需要测量）
|
||
for model_name, result in self.analyzer.results.items():
|
||
model_names.append(model_name)
|
||
model_full_names.append(self.analyzer.models[model_name]['name'])
|
||
r2_scores.append(result['metrics']['test_r2'])
|
||
rmse_scores.append(result['metrics']['test_rmse'])
|
||
mae_scores.append(result['metrics']['test_mae'])
|
||
training_times.append(np.random.uniform(0.1, 5.0)) # 模拟时间
|
||
memory_usage.append(np.random.uniform(50, 500)) # 模拟内存
|
||
|
||
# 创建子图
|
||
fig, axes = plt.subplots(2, 2, figsize=figsize)
|
||
|
||
# 雷达图 - R², RMSE, MAE
|
||
ax_radar = axes[0, 0]
|
||
|
||
# 标准化指标到0-1范围
|
||
r2_norm = (r2_scores - np.min(r2_scores)) / (np.max(r2_scores) - np.min(r2_scores))
|
||
rmse_norm = 1 - (rmse_scores - np.min(rmse_scores)) / (np.max(rmse_scores) - np.min(rmse_scores)) # RMSE越小越好，反转
|
||
mae_norm = 1 - (mae_scores - np.min(mae_scores)) / (np.max(mae_scores) - np.min(mae_scores)) # MAE越小越好，反转
|
||
|
||
# 雷达图数据
|
||
categories = ['R² Score', 'RMSE (inv)', 'MAE (inv)']
|
||
n_models = len(model_names)
|
||
|
||
# 计算角度
|
||
angles = np.linspace(0, 2 * np.pi, len(categories), endpoint=False).tolist()
|
||
angles += angles[:1] # 闭合图形
|
||
|
||
for i in range(n_models):
|
||
values = [r2_norm[i], rmse_norm[i], mae_norm[i]]
|
||
values += values[:1] # 闭合图形
|
||
ax_radar.plot(angles, values, 'o-', linewidth=2,
|
||
color=self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)],
|
||
label=model_full_names[i])
|
||
ax_radar.fill(angles, values, alpha=0.25,
|
||
color=self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)])
|
||
|
||
ax_radar.set_xticks(angles[:-1])
|
||
ax_radar.set_xticklabels(categories)
|
||
ax_radar.set_title('Performance Metrics Radar Chart')
|
||
ax_radar.legend(bbox_to_anchor=(1.1, 1), loc='upper left')
|
||
ax_radar.grid(True, alpha=0.3)
|
||
|
||
# 分组柱状图 - 不同指标的比较
|
||
ax_bar = axes[0, 1]
|
||
x = np.arange(len(model_names))
|
||
width = 0.25
|
||
|
||
bars1 = ax_bar.bar(x - width, r2_scores, width, label='R²', alpha=0.8,
|
||
color=self.colorblind_friendly_palette[0])
|
||
bars2 = ax_bar.bar(x, [1/s for s in rmse_scores], width, label='1/RMSE', alpha=0.8,
|
||
color=self.colorblind_friendly_palette[1])
|
||
bars3 = ax_bar.bar(x + width, [1/s for s in mae_scores], width, label='1/MAE', alpha=0.8,
|
||
color=self.colorblind_friendly_palette[2])
|
||
|
||
ax_bar.set_xlabel('Models')
|
||
ax_bar.set_ylabel('Normalized Scores')
|
||
ax_bar.set_title('Normalized Performance Comparison')
|
||
ax_bar.set_xticks(x)
|
||
ax_bar.set_xticklabels(model_full_names, rotation=45, ha='right')
|
||
ax_bar.legend()
|
||
ax_bar.grid(True, alpha=0.3, axis='y')
|
||
|
||
# 堆叠柱状图 - 误差分解（偏差vs方差）
|
||
ax_stack = axes[1, 0]
|
||
bias_errors = [abs(np.mean(residuals)) for residuals in
|
||
[self.analyzer.y_test - result['y_pred_test'] for result in self.analyzer.results.values()]]
|
||
variance_errors = [np.var(residuals) for residuals in
|
||
[self.analyzer.y_test - result['y_pred_test'] for result in self.analyzer.results.values()]]
|
||
|
||
bars_bias = ax_stack.bar(model_names, bias_errors, label='Bias (Mean Abs Error)', alpha=0.8,
|
||
color=self.colorblind_friendly_palette[0])
|
||
bars_var = ax_stack.bar(model_names, variance_errors, bottom=bias_errors,
|
||
label='Variance (Residual Var)', alpha=0.8,
|
||
color=self.colorblind_friendly_palette[1])
|
||
|
||
ax_stack.set_xlabel('Models')
|
||
ax_stack.set_ylabel('Error Components')
|
||
ax_stack.set_title('Bias-Variance Decomposition')
|
||
ax_stack.set_xticklabels(model_full_names, rotation=45, ha='right')
|
||
ax_stack.legend()
|
||
ax_stack.grid(True, alpha=0.3, axis='y')
|
||
|
||
# 气泡图 - 综合评估（R² vs 1/RMSE，气泡大小表示1/MAE）
|
||
ax_bubble = axes[1, 1]
|
||
bubble_sizes = [100 * (1/s) for s in mae_scores] # MAE越大气泡越小
|
||
|
||
scatter = ax_bubble.scatter(r2_scores, [1/s for s in rmse_scores], s=bubble_sizes,
|
||
c=range(len(model_names)), cmap='viridis', alpha=0.6, edgecolors='black')
|
||
|
||
# 添加模型名称标签
|
||
for i, name in enumerate(model_full_names):
|
||
ax_bubble.annotate(name, (r2_scores[i], 1/rmse_scores[i]),
|
||
xytext=(5, 5), textcoords='offset points', fontsize=8)
|
||
|
||
ax_bubble.set_xlabel('R² Score')
|
||
ax_bubble.set_ylabel('1/RMSE')
|
||
ax_bubble.set_title('Comprehensive Performance Assessment\n(Bubble size ∝ 1/MAE)')
|
||
ax_bubble.grid(True, alpha=0.3)
|
||
|
||
# 添加颜色条
|
||
cbar = plt.colorbar(scatter, ax=ax_bubble)
|
||
cbar.set_label('Model Index')
|
||
|
||
plt.tight_layout()
|
||
|
||
if save_path:
|
||
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
||
print(f"Metrics comparison plot saved to: {save_path}")
|
||
|
||
# plt.show()
|
||
|
||
def plot_error_distribution(self, figsize=(16, 8), save_path=None):
|
||
"""
|
||
绘制误差分布图
|
||
|
||
Parameters:
|
||
figsize (tuple): 图形尺寸
|
||
save_path (str, optional): 保存路径
|
||
"""
|
||
if not self.analyzer or not self.analyzer.results:
|
||
print("No analyzer results available for plotting")
|
||
return
|
||
|
||
self.set_colorblind_palette()
|
||
|
||
# 计算所有模型的误差
|
||
model_errors = {}
|
||
for model_name, result in self.analyzer.results.items():
|
||
errors = self.analyzer.y_test - result['y_pred_test']
|
||
model_errors[model_name] = errors
|
||
|
||
fig, axes = plt.subplots(2, 2, figsize=figsize)
|
||
|
||
# 误差分布直方图 - 所有模型并排比较
|
||
ax_hist = axes[0, 0]
|
||
bins = np.linspace(min([min(errors) for errors in model_errors.values()]),
|
||
max([max(errors) for errors in model_errors.values()]), 30)
|
||
|
||
for i, (model_name, errors) in enumerate(model_errors.items()):
|
||
ax_hist.hist(errors, bins=bins, alpha=0.7, label=self.analyzer.models[model_name]['name'],
|
||
color=self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)],
|
||
density=True)
|
||
|
||
ax_hist.set_xlabel('Prediction Error')
|
||
ax_hist.set_ylabel('Density')
|
||
ax_hist.set_title('Error Distribution Histogram')
|
||
ax_hist.legend()
|
||
ax_hist.grid(True, alpha=0.3)
|
||
|
||
# 核密度估计曲线
|
||
ax_kde = axes[0, 1]
|
||
for i, (model_name, errors) in enumerate(model_errors.items()):
|
||
try:
|
||
sns.kdeplot(data=errors, ax=ax_kde, label=self.analyzer.models[model_name]['name'],
|
||
color=self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)],
|
||
fill=True, alpha=0.3)
|
||
except:
|
||
# 如果seaborn不可用，使用matplotlib
|
||
ax_kde.hist(errors, bins=30, alpha=0.3, density=True,
|
||
label=self.analyzer.models[model_name]['name'],
|
||
color=self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)])
|
||
|
||
ax_kde.set_xlabel('Prediction Error')
|
||
ax_kde.set_ylabel('Density')
|
||
ax_kde.set_title('Error Distribution KDE')
|
||
ax_kde.legend()
|
||
ax_kde.grid(True, alpha=0.3)
|
||
|
||
# 累积分布函数
|
||
ax_cdf = axes[1, 0]
|
||
error_range = np.linspace(min([min(errors) for errors in model_errors.values()]),
|
||
max([max(errors) for errors in model_errors.values()]), 100)
|
||
|
||
for i, (model_name, errors) in enumerate(model_errors.items()):
|
||
sorted_errors = np.sort(errors)
|
||
y_vals = np.arange(len(sorted_errors)) / float(len(sorted_errors))
|
||
ax_cdf.plot(sorted_errors, y_vals,
|
||
label=self.analyzer.models[model_name]['name'],
|
||
color=self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)],
|
||
linewidth=2)
|
||
|
||
ax_cdf.set_xlabel('Prediction Error')
|
||
ax_cdf.set_ylabel('Cumulative Probability')
|
||
ax_cdf.set_title('Cumulative Distribution Function')
|
||
ax_cdf.legend()
|
||
ax_cdf.grid(True, alpha=0.3)
|
||
|
||
# 箱线图
|
||
ax_box = axes[1, 1]
|
||
error_data = [errors for errors in model_errors.values()]
|
||
model_labels = [self.analyzer.models[name]['name'] for name in model_errors.keys()]
|
||
|
||
bp = ax_box.boxplot(error_data, labels=model_labels, patch_artist=True)
|
||
for patch, color in zip(bp['boxes'], self.colorblind_friendly_palette):
|
||
patch.set_facecolor(color)
|
||
patch.set_alpha(0.7)
|
||
|
||
# 添加均值点
|
||
for i, errors in enumerate(error_data):
|
||
ax_box.plot(i+1, np.mean(errors), 'ro', markersize=8, label='Mean' if i == 0 else "")
|
||
|
||
ax_box.set_xlabel('Models')
|
||
ax_box.set_ylabel('Prediction Error')
|
||
ax_box.set_title('Error Distribution Box Plot')
|
||
ax_box.legend()
|
||
ax_box.grid(True, alpha=0.3, axis='y')
|
||
|
||
plt.tight_layout()
|
||
|
||
if save_path:
|
||
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
||
print(f"Error distribution plot saved to: {save_path}")
|
||
|
||
# plt.show()
|
||
|
||
def plot_model_ranking_matrix(self, figsize=(14, 10), save_path=None):
|
||
"""
|
||
绘制模型排名矩阵
|
||
|
||
Parameters:
|
||
figsize (tuple): 图形尺寸
|
||
save_path (str, optional): 保存路径
|
||
"""
|
||
if not self.analyzer or not self.analyzer.results:
|
||
print("No analyzer results available for plotting")
|
||
return
|
||
|
||
self.set_colorblind_palette()
|
||
|
||
# 准备指标数据
|
||
metrics_data = []
|
||
model_names = []
|
||
metric_names = ['R²', 'RMSE', 'MAE', 'Training_R²', 'Training_RMSE', 'Training_MAE']
|
||
|
||
for model_name, result in self.analyzer.results.items():
|
||
model_names.append(self.analyzer.models[model_name]['name'])
|
||
metrics = result['metrics']
|
||
metrics_data.append([
|
||
metrics['test_r2'],
|
||
metrics['test_rmse'],
|
||
metrics['test_mae'],
|
||
metrics['train_r2'],
|
||
metrics['train_rmse'],
|
||
metrics['train_mae']
|
||
])
|
||
|
||
metrics_array = np.array(metrics_data)
|
||
|
||
# 计算排名（对于R²，越高越好；对于RMSE/MAE，越低越好）
|
||
rankings = np.zeros_like(metrics_array)
|
||
rankings[:, 0] = len(model_names) - stats.rankdata(metrics_array[:, 0]) + 1 # R²排名（反转）
|
||
rankings[:, 1] = stats.rankdata(metrics_array[:, 1]) # RMSE排名
|
||
rankings[:, 2] = stats.rankdata(metrics_array[:, 2]) # MAE排名
|
||
rankings[:, 3] = len(model_names) - stats.rankdata(metrics_array[:, 3]) + 1 # Training R²排名（反转）
|
||
rankings[:, 4] = stats.rankdata(metrics_array[:, 4]) # Training RMSE排名
|
||
rankings[:, 5] = stats.rankdata(metrics_array[:, 5]) # Training MAE排名
|
||
|
||
fig, axes = plt.subplots(2, 2, figsize=figsize)
|
||
|
||
# 热力图 - 模型vs指标的排名
|
||
ax_heatmap = axes[0, 0]
|
||
im = ax_heatmap.imshow(rankings, cmap='RdYlGn_r', aspect='auto', alpha=0.8)
|
||
|
||
# 设置标签
|
||
ax_heatmap.set_xticks(np.arange(len(metric_names)))
|
||
ax_heatmap.set_yticks(np.arange(len(model_names)))
|
||
ax_heatmap.set_xticklabels(metric_names, rotation=45, ha='right')
|
||
ax_heatmap.set_yticklabels(model_names)
|
||
|
||
# 添加数值标签
|
||
for i in range(len(model_names)):
|
||
for j in range(len(metric_names)):
|
||
text = ax_heatmap.text(j, i, f'{rankings[i, j]:.0f}',
|
||
ha="center", va="center", color="black", fontsize=10)
|
||
|
||
ax_heatmap.set_title('Model Ranking Matrix\n(Lower rank = Better performance)')
|
||
plt.colorbar(im, ax=ax_heatmap, label='Rank')
|
||
|
||
# 平行坐标图
|
||
ax_parallel = axes[0, 1]
|
||
|
||
# 标准化数据到0-1范围
|
||
normalized_data = np.zeros_like(metrics_array)
|
||
for j in range(metrics_array.shape[1]):
|
||
if j in [0, 3]: # R²指标，越高越好
|
||
normalized_data[:, j] = (metrics_array[:, j] - metrics_array[:, j].min()) / (metrics_array[:, j].max() - metrics_array[:, j].min())
|
||
else: # RMSE/MAE指标，越低越好，反转标准化
|
||
normalized_data[:, j] = 1 - (metrics_array[:, j] - metrics_array[:, j].min()) / (metrics_array[:, j].max() - metrics_array[:, j].min())
|
||
|
||
for i in range(len(model_names)):
|
||
ax_parallel.plot(range(len(metric_names)), normalized_data[i],
|
||
marker='o', linewidth=2, markersize=6,
|
||
color=self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)],
|
||
label=model_names[i], alpha=0.8)
|
||
|
||
ax_parallel.set_xticks(range(len(metric_names)))
|
||
ax_parallel.set_xticklabels(metric_names, rotation=45, ha='right')
|
||
ax_parallel.set_ylabel('Normalized Score (Higher = Better)')
|
||
ax_parallel.set_title('Parallel Coordinates Plot')
|
||
ax_parallel.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
|
||
ax_parallel.grid(True, alpha=0.3)
|
||
|
||
# 气泡图 - R² vs RMSE，气泡大小表示MAE
|
||
ax_bubble = axes[1, 0]
|
||
r2_scores = metrics_array[:, 0]
|
||
rmse_scores = metrics_array[:, 1]
|
||
mae_scores = metrics_array[:, 2]
|
||
|
||
# 气泡大小（MAE越小气泡越大）
|
||
bubble_sizes = 1000 / (mae_scores + 0.01) # 避免除零
|
||
|
||
scatter = ax_bubble.scatter(r2_scores, rmse_scores, s=bubble_sizes,
|
||
c=range(len(model_names)), cmap='viridis', alpha=0.6, edgecolors='black')
|
||
|
||
# 添加模型名称标签
|
||
for i, name in enumerate(model_names):
|
||
ax_bubble.annotate(name, (r2_scores[i], rmse_scores[i]),
|
||
xytext=(5, 5), textcoords='offset points', fontsize=8)
|
||
|
||
ax_bubble.set_xlabel('R² Score')
|
||
ax_bubble.set_ylabel('RMSE')
|
||
ax_bubble.set_title('Performance Bubble Chart\n(Bubble size ∝ 1/MAE)')
|
||
ax_bubble.grid(True, alpha=0.3)
|
||
|
||
# 添加颜色条
|
||
cbar = plt.colorbar(scatter, ax=ax_bubble)
|
||
cbar.set_label('Model Index')
|
||
|
||
# 综合排名条形图
|
||
ax_ranking = axes[1, 1]
|
||
avg_rankings = np.mean(rankings, axis=1)
|
||
sorted_indices = np.argsort(avg_rankings)
|
||
|
||
bars = ax_ranking.bar(range(len(model_names)),
|
||
avg_rankings[sorted_indices],
|
||
color=[self.colorblind_friendly_palette[i % len(self.colorblind_friendly_palette)]
|
||
for i in range(len(model_names))], alpha=0.7)
|
||
|
||
ax_ranking.set_xlabel('Models (Sorted by Average Rank)')
|
||
ax_ranking.set_ylabel('Average Rank')
|
||
ax_ranking.set_title('Overall Model Ranking')
|
||
ax_ranking.set_xticks(range(len(model_names)))
|
||
ax_ranking.set_xticklabels([model_names[i] for i in sorted_indices], rotation=45, ha='right')
|
||
ax_ranking.grid(True, alpha=0.3, axis='y')
|
||
|
||
# 添加数值标签
|
||
for i, bar in enumerate(bars):
|
||
height = bar.get_height()
|
||
ax_ranking.text(bar.get_x() + bar.get_width()/2., height,
|
||
'.2f', ha='center', va='bottom')
|
||
|
||
plt.tight_layout()
|
||
|
||
if save_path:
|
||
plt.savefig(save_path, dpi=300, bbox_inches='tight')
|
||
print(f"Model ranking matrix plot saved to: {save_path}")
|
||
|
||
# plt.show()
|
||
|
||
def generate_comprehensive_report(self, save_dir='plots', prefix='regression_analysis'):
|
||
"""
|
||
生成综合可视化报告
|
||
|
||
Parameters:
|
||
save_dir (str): 保存目录
|
||
prefix (str): 文件名前缀
|
||
"""
|
||
if not self.analyzer:
|
||
print("No analyzer available for report generation")
|
||
return
|
||
|
||
os.makedirs(save_dir, exist_ok=True)
|
||
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
|
||
|
||
# 生成各种图表
|
||
plot_configs = [
|
||
('prediction_scatter', self.plot_prediction_scatter),
|
||
('residual_analysis', self.plot_residual_analysis),
|
||
('metrics_comparison', self.plot_metrics_comparison),
|
||
('error_distribution', self.plot_error_distribution),
|
||
('model_ranking', self.plot_model_ranking_matrix)
|
||
]
|
||
|
||
saved_files = []
|
||
for plot_name, plot_func in plot_configs:
|
||
try:
|
||
save_path = f'{save_dir}/{prefix}_{plot_name}_{timestamp}.png'
|
||
plot_func(save_path=save_path)
|
||
saved_files.append(save_path)
|
||
plt.close('all') # 关闭所有图形以释放内存
|
||
except Exception as e:
|
||
print(f"Failed to generate {plot_name} plot: {str(e)}")
|
||
|
||
if saved_files:
|
||
print("Comprehensive visualization report generated:")
|
||
for file in saved_files:
|
||
print(f" - {file}")
|
||
else:
|
||
print("No plots were successfully generated")
|
||
|
||
return saved_files
|
||
|
||
|
||
def main():
|
||
"""主函数 - 展示配置驱动和向后兼容两种使用方式"""
|
||
|
||
print("="*60)
|
||
print("Regression Analysis Tool - Configuration-Driven Interface")
|
||
print("="*60)
|
||
|
||
# 方法1：配置驱动方式（推荐用于GUI对接）
|
||
print("\n--- Method 1: Configuration-Driven (Recommended for GUI) ---")
|
||
|
||
# 创建配置对象
|
||
csv_file_path = r"E:\code\content\change\6.csv"
|
||
|
||
|
||
config = RegressionConfig.create_default(
|
||
csv_path=csv_file_path,
|
||
label_column="0"
|
||
)
|
||
# 可选：自定义配置
|
||
config.data.spectrum_columns = "8:" # 光谱列范围
|
||
config.models.model_names ='all'# 选择部分模型进行演示
|
||
config.models.tune_hyperparams = False # 快速分析，不进行超参数调优
|
||
config.output.save_models = True # 不保存模型文件
|
||
config.output.plot_results = True # 启用可视化
|
||
config.output.plot_dir = 'E:\code\content\change\plot\yellow' # 可视化输出目录
|
||
|
||
# 创建分析器并传入配置
|
||
analyzer = RegressionAnalyzer(config)
|
||
|
||
# 查看可用模型
|
||
analyzer.initialize_all_models()
|
||
print("Available models:")
|
||
for model_key, model_name in analyzer.get_available_models().items():
|
||
print(f" {model_key}: {model_name}")
|
||
|
||
# 运行配置驱动的分析
|
||
success = analyzer.run_analysis_from_config()
|
||
if success:
|
||
print("Configuration-driven analysis completed successfully!")
|
||
|
||
# 演示各种可视化功能
|
||
print("\n--- Visualization Demo ---")
|
||
|
||
# 创建可视化目录
|
||
viz_dir = 'visualization_demo'
|
||
os.makedirs(viz_dir, exist_ok=True)
|
||
|
||
print("Generating various visualization plots...")
|
||
|
||
# 1. 预测值vs真实值散点图
|
||
print("1. Prediction vs True Values Scatter Plot...")
|
||
analyzer.plot_prediction_scatter(
|
||
save_path=f'{viz_dir}/prediction_scatter.png',
|
||
show_individual=True,
|
||
show_overlay=True
|
||
)
|
||
|
||
# 2. 残差分析图
|
||
print("2. Residual Analysis Plot...")
|
||
analyzer.plot_residual_analysis(
|
||
save_path=f'{viz_dir}/residual_analysis.png'
|
||
)
|
||
|
||
# 3. 性能指标对比图
|
||
print("3. Performance Metrics Comparison...")
|
||
analyzer.plot_metrics_comparison(
|
||
save_path=f'{viz_dir}/metrics_comparison.png'
|
||
)
|
||
|
||
# 4. 误差分布图
|
||
print("4. Error Distribution Analysis...")
|
||
analyzer.plot_error_distribution(
|
||
save_path=f'{viz_dir}/error_distribution.png'
|
||
)
|
||
|
||
# 5. 模型排名矩阵
|
||
print("5. Model Ranking Matrix...")
|
||
analyzer.plot_model_ranking(
|
||
save_path=f'{viz_dir}/model_ranking.png'
|
||
)
|
||
|
||
# 6. 生成完整可视化报告
|
||
print("6. Generating Comprehensive Visualization Report...")
|
||
saved_plots = analyzer.generate_visualization_report(
|
||
save_dir=viz_dir,
|
||
prefix='demo_report'
|
||
)
|
||
|
||
print(f"\nVisualization completed! Generated {len(saved_plots)} plot files in '{viz_dir}' directory:")
|
||
for plot_file in saved_plots:
|
||
print(f" - {plot_file}")
|
||
|
||
print("\nAvailable visualization methods:")
|
||
print(" - analyzer.plot_prediction_scatter() # 预测值vs真实值散点图")
|
||
print(" - analyzer.plot_residual_analysis() # 残差分析图")
|
||
print(" - analyzer.plot_metrics_comparison() # 性能指标对比图")
|
||
print(" - analyzer.plot_error_distribution() # 误差分布图")
|
||
print(" - analyzer.plot_model_ranking() # 模型排名矩阵")
|
||
print(" - analyzer.generate_visualization_report() # 生成完整报告")
|
||
|
||
else:
|
||
print("Configuration-driven analysis failed!")
|
||
|
||
# # 方法2：向后兼容方式（传统参数传递）
|
||
# print("\n--- Method 2: Backward Compatible (Legacy Parameter Passing) ---")
|
||
#
|
||
# analyzer2 = RegressionAnalyzer() # 使用默认配置
|
||
#
|
||
# # 使用传统的参数传递方式
|
||
# success2 = analyzer2.run_complete_analysis(
|
||
# csv_path=r"E:\code\WQ\pipeline_result\work_dir\5_training_spectra\training_spectra.csv",
|
||
# label_column="0",
|
||
# spectrum_columns="13:",
|
||
# test_size=0.2,
|
||
# scale_method='standard',
|
||
# tune_hyperparams=False,
|
||
# save_models=False,
|
||
# plot_results=True,
|
||
# model_names=['xgboost', 'lightgbm'] # 只训练这两个模型
|
||
# )
|
||
#
|
||
# if success2:
|
||
# print("Backward-compatible analysis completed successfully!")
|
||
# else:
|
||
# print("Backward-compatible analysis failed!")
|
||
#
|
||
# print("\n" + "="*60)
|
||
# print("Both methods are supported. Configuration-driven is recommended for GUI integration.")
|
||
# print("="*60)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main() |