1137 lines
44 KiB
Python
1137 lines
44 KiB
Python
import numpy as np
|
||
import pandas as pd
|
||
import joblib
|
||
import os
|
||
from pathlib import Path
|
||
from typing import List, Dict, Union, Tuple, Optional
|
||
import warnings
|
||
|
||
warnings.filterwarnings('ignore')
|
||
|
||
# 机器学习模型导入 - 改为回归模型
|
||
from sklearn.svm import SVR
|
||
from sklearn.ensemble import RandomForestRegressor
|
||
from sklearn.neighbors import KNeighborsRegressor
|
||
from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet
|
||
from sklearn.model_selection import GridSearchCV, cross_val_score, KFold, train_test_split
|
||
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
|
||
from sklearn.cross_decomposition import PLSRegression
|
||
from sklearn.ensemble import GradientBoostingRegressor, AdaBoostRegressor, ExtraTreesRegressor
|
||
from sklearn.tree import DecisionTreeRegressor
|
||
from sklearn.neural_network import MLPRegressor
|
||
from joblib import parallel_backend
|
||
# 第三方模型导入
|
||
# try:
|
||
# import lightgbm as lgb
|
||
# LGB_AVAILABLE = True
|
||
# except ImportError:
|
||
# LGB_AVAILABLE = False
|
||
LGB_AVAILABLE = False # 注释掉lightgbm
|
||
|
||
# try:
|
||
# import catboost as cb
|
||
# CB_AVAILABLE = True
|
||
# except ImportError:
|
||
# CB_AVAILABLE = False
|
||
CB_AVAILABLE = False # 注释掉catboost
|
||
|
||
# 导入预处理模块
|
||
# 动态导入预处理模块
|
||
import sys
|
||
import os
|
||
|
||
from src.preprocessing.spectral_Preprocessing import Preprocessing
|
||
|
||
|
||
class WaterQualityModelingBatch:
|
||
"""水质参数反演批量建模类"""
|
||
|
||
def __init__(self, artifacts_dir: str = "models/artifacts"):
|
||
"""
|
||
初始化批量建模类
|
||
|
||
Args:
|
||
artifacts_dir: 模型保存目录
|
||
"""
|
||
self.artifacts_dir = Path(artifacts_dir)
|
||
self.artifacts_dir.mkdir(parents=True, exist_ok=True)
|
||
|
||
# 定义支持的回归模型及其参数网格
|
||
self.model_configs = {
|
||
'SVR': {
|
||
'model': SVR,
|
||
'params': {
|
||
'C': [0.1, 1, 10, 100],
|
||
'gamma': ['scale', 'auto', 0.001, 0.01, 0.1, 1],
|
||
'kernel': ['rbf', 'poly', 'sigmoid'],
|
||
'epsilon': [0.01, 0.1, 0.2]
|
||
},
|
||
'available': True
|
||
},
|
||
'RF': {
|
||
'model': RandomForestRegressor,
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'max_depth': [None, 10, 20, 30],
|
||
'min_samples_split': [2, 5, 10],
|
||
'min_samples_leaf': [1, 2, 4]
|
||
},
|
||
'available': True
|
||
},
|
||
'KNN': {
|
||
'model': KNeighborsRegressor,
|
||
'params': {
|
||
'n_neighbors': [3, 5, 7, 9, 11],
|
||
'weights': ['uniform', 'distance'],
|
||
'metric': ['euclidean', 'manhattan', 'minkowski']
|
||
},
|
||
'available': True
|
||
},
|
||
'LinearRegression': {
|
||
'model': LinearRegression,
|
||
'params': {
|
||
'fit_intercept': [True, False]
|
||
},
|
||
'available': True
|
||
},
|
||
'Ridge': {
|
||
'model': Ridge,
|
||
'params': {
|
||
'alpha': [0.01, 0.1, 1, 10, 100],
|
||
'fit_intercept': [True, False]
|
||
},
|
||
'available': True
|
||
},
|
||
'Lasso': {
|
||
'model': Lasso,
|
||
'params': {
|
||
'alpha': [0.01, 0.1, 1, 10, 100],
|
||
'fit_intercept': [True, False],
|
||
'max_iter': [1000, 2000]
|
||
},
|
||
'available': True
|
||
},
|
||
'ElasticNet': {
|
||
'model': ElasticNet,
|
||
'params': {
|
||
'alpha': [0.01, 0.1, 1, 10],
|
||
'l1_ratio': [0.1, 0.3, 0.5, 0.7, 0.9],
|
||
'fit_intercept': [True, False],
|
||
'max_iter': [1000, 2000]
|
||
},
|
||
'available': True
|
||
},
|
||
'XGBoost': {
|
||
'model': None, # xgboost is removed, so set to None
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'max_depth': [3, 6, 9],
|
||
'learning_rate': [0.01, 0.1, 0.2],
|
||
'subsample': [0.8, 0.9, 1.0]
|
||
},
|
||
'available': False
|
||
},
|
||
'LightGBM': {
|
||
'model': lgb.LGBMRegressor if LGB_AVAILABLE else None,
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'max_depth': [3, 6, 9],
|
||
'learning_rate': [0.01, 0.1, 0.2],
|
||
'num_leaves': [31, 50, 100]
|
||
},
|
||
'available': LGB_AVAILABLE
|
||
},
|
||
'CatBoost': {
|
||
'model': cb.CatBoostRegressor if CB_AVAILABLE else None,
|
||
'params': {
|
||
'iterations': [50, 100, 200],
|
||
'depth': [3, 6, 9],
|
||
'learning_rate': [0.01, 0.1, 0.2],
|
||
'l2_leaf_reg': [1, 3, 5]
|
||
},
|
||
'available': CB_AVAILABLE
|
||
},
|
||
'PLS': {
|
||
'model': PLSRegression,
|
||
'params': {
|
||
'n_components': [2, 3, 5, 7, 10]
|
||
},
|
||
'available': True
|
||
},
|
||
'GradientBoosting': {
|
||
'model': GradientBoostingRegressor,
|
||
'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],
|
||
'min_samples_split': [2, 5, 10],
|
||
'min_samples_leaf': [1, 2, 4]
|
||
},
|
||
'available': True
|
||
},
|
||
'AdaBoost': {
|
||
'model': AdaBoostRegressor,
|
||
'params': {
|
||
'n_estimators': [50, 100, 200],
|
||
'learning_rate': [0.01, 0.1, 0.2],
|
||
'loss': ['linear', 'square', 'exponential']
|
||
},
|
||
'available': True
|
||
},
|
||
'DecisionTree': {
|
||
'model': DecisionTreeRegressor,
|
||
'params': {
|
||
'max_depth': [None, 5, 10, 20, 30],
|
||
'min_samples_split': [2, 5, 10],
|
||
'min_samples_leaf': [1, 2, 4],
|
||
'max_features': ['auto', 'sqrt', 'log2']
|
||
},
|
||
'available': True
|
||
},
|
||
'MLP': {
|
||
'model': MLPRegressor,
|
||
'params': {
|
||
'hidden_layer_sizes': [(50,), (100,), (50, 50), (100, 50)],
|
||
'activation': ['relu', 'tanh', 'logistic'],
|
||
'solver': ['adam', 'sgd'],
|
||
'alpha': [0.0001, 0.001, 0.01],
|
||
'learning_rate': ['constant', 'invscaling', 'adaptive'],
|
||
'max_iter': [1000, 2000]
|
||
},
|
||
'available': True
|
||
},
|
||
'ExtraTrees': {
|
||
'model': ExtraTreesRegressor,
|
||
'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']
|
||
},
|
||
'available': True
|
||
}
|
||
}
|
||
|
||
# 预处理方法列表
|
||
self.preprocessing_methods = [
|
||
"None", "MMS", "SS", "CT", "SNV", "MA", "SG", "MSC", "D1", "D2", "DT", "WVAE"
|
||
]
|
||
|
||
# 样本划分方法列表
|
||
self.split_methods = ["random", "spxy", "ks"]
|
||
|
||
self.results = {}
|
||
self.best_models = {}
|
||
|
||
def load_data_batch(self, csv_path: str, feature_start_column: Union[int, str]) -> Tuple[pd.DataFrame, Dict[str, pd.Series]]:
|
||
"""
|
||
批量加载CSV数据，将指定列之前的列作为目标值
|
||
|
||
Args:
|
||
csv_path: CSV文件路径
|
||
feature_start_column: 特征开始列索引（int）或列名（str）
|
||
|
||
Returns:
|
||
X: 特征数据
|
||
y_dict: 目标值数据字典，键为列名
|
||
"""
|
||
# 读取CSV数据，处理空字符串和缺失值
|
||
try:
|
||
data = pd.read_csv(csv_path, na_values=['', ' ', 'NaN', 'nan', 'NULL', 'null'])
|
||
except pd.errors.EmptyDataError:
|
||
raise ValueError(f"CSV文件 '{csv_path}' 为空或不存在")
|
||
except Exception as e:
|
||
raise ValueError(f"读取CSV文件 '{csv_path}' 时出错: {e}")
|
||
|
||
# 检查并清理数据中的空字符串和其他无效值
|
||
print("数据清理...")
|
||
original_shape = data.shape
|
||
|
||
# 将空字符串替换为NaN
|
||
data = data.replace(r'^\s*$', np.nan, regex=True)
|
||
|
||
# 对于数值列，将无法转换为数字的字符串替换为NaN
|
||
for col in data.columns:
|
||
try:
|
||
# 尝试将列转换为数值类型
|
||
data[col] = pd.to_numeric(data[col], errors='coerce')
|
||
except Exception:
|
||
# 如果转换失败，保持原样（可能是字符串列）
|
||
pass
|
||
|
||
cleaned_shape = data.shape
|
||
if cleaned_shape != original_shape:
|
||
print(f"数据清理完成: {original_shape[0]}行{original_shape[1]}列 -> {cleaned_shape[0]}行{cleaned_shape[1]}列")
|
||
|
||
print(f"数据加载完成，总列数: {data.shape[1]}")
|
||
print(f"所有列名: {list(data.columns)}")
|
||
|
||
# 如果feature_start_column是列名，转换为索引
|
||
if isinstance(feature_start_column, str):
|
||
if feature_start_column not in data.columns:
|
||
raise ValueError(f"指定的特征开始列 '{feature_start_column}' 不存在于数据中")
|
||
feature_start_index = data.columns.get_loc(feature_start_column)
|
||
print(f"特征开始列 '{feature_start_column}' 对应索引: {feature_start_index}")
|
||
else:
|
||
feature_start_index = feature_start_column
|
||
print(f"特征开始列索引: {feature_start_index}")
|
||
|
||
# 提取特征数据（从feature_start_index开始）
|
||
X = data.iloc[:, feature_start_index:]
|
||
|
||
# 提取所有目标列（从0列到feature_start_index-1列）
|
||
y_dict = {}
|
||
target_columns = data.columns[:feature_start_index]
|
||
|
||
print(f"检测到的目标列: {list(target_columns)}")
|
||
|
||
for col_name in target_columns:
|
||
y_series = data[col_name]
|
||
# 检查是否有非空值
|
||
if not y_series.isna().all():
|
||
y_dict[col_name] = y_series
|
||
print(f" 目标列 '{col_name}': {y_series.count()} 个非空值, 范围: {y_series.min():.4f} ~ {y_series.max():.4f}")
|
||
else:
|
||
print(f" 跳过目标列 '{col_name}': 所有值为空")
|
||
|
||
print(f"特征数据形状: {X.shape}")
|
||
print(f"有效目标列数量: {len(y_dict)}")
|
||
|
||
return X, y_dict
|
||
|
||
def load_data_single(self, csv_path: str, target_column_name: str, feature_start_column: Union[int, str]) -> Tuple[pd.DataFrame, pd.Series]:
|
||
"""
|
||
加载单个目标列的CSV数据
|
||
|
||
Args:
|
||
csv_path: CSV文件路径
|
||
target_column_name: 目标列名
|
||
feature_start_column: 特征开始列索引（int）或列名（str）
|
||
|
||
Returns:
|
||
X: 特征数据
|
||
y: 目标值数据
|
||
"""
|
||
data = pd.read_csv(csv_path)
|
||
|
||
# 检查目标列是否存在
|
||
if target_column_name not in data.columns:
|
||
raise ValueError(f"目标列 '{target_column_name}' 不存在于数据中")
|
||
|
||
# 如果feature_start_column是列名，转换为索引
|
||
if isinstance(feature_start_column, str):
|
||
if feature_start_column not in data.columns:
|
||
raise ValueError(f"指定的特征开始列 '{feature_start_column}' 不存在于数据中")
|
||
feature_start_index = data.columns.get_loc(feature_start_column)
|
||
else:
|
||
feature_start_index = feature_start_column
|
||
|
||
# 提取目标值和特征
|
||
y = data[target_column_name]
|
||
X = data.iloc[:, feature_start_index:]
|
||
|
||
# 去除y值为空的行
|
||
mask = ~y.isna()
|
||
data_cleaned = data[mask]
|
||
|
||
# 重新定义y和X，去除对应的空值行
|
||
y = data_cleaned[target_column_name]
|
||
X = data_cleaned.iloc[:, feature_start_column:]
|
||
|
||
print(f"目标列 '{target_column_name}' 数据加载完成:")
|
||
print(f" 样本数量: {X.shape[0]}")
|
||
print(f" 特征数量: {X.shape[1]}")
|
||
print(f" 目标值范围: {y.min():.4f} ~ {y.max():.4f}")
|
||
print(f" 目标值均值: {y.mean():.4f}")
|
||
|
||
return X, y
|
||
|
||
def preprocess_data(self, X: pd.DataFrame, method: str) -> np.ndarray:
|
||
"""
|
||
数据预处理
|
||
|
||
Args:
|
||
X: 原始特征数据
|
||
method: 预处理方法
|
||
|
||
Returns:
|
||
预处理后的数据
|
||
"""
|
||
print(f"应用预处理方法: {method}")
|
||
|
||
# 如果方法为None，直接返回原始数据
|
||
if method == "None" or method is None:
|
||
print("跳过预处理，使用原始数据")
|
||
return X.values
|
||
|
||
try:
|
||
X_processed = Preprocessing(method, X)
|
||
|
||
# 确保返回的是numpy数组
|
||
if isinstance(X_processed, pd.DataFrame):
|
||
X_processed = X_processed.values
|
||
|
||
print(f"预处理完成，数据形状: {X_processed.shape}")
|
||
return X_processed
|
||
|
||
except Exception as e:
|
||
print(f"预处理失败: {e}")
|
||
print("使用原始数据")
|
||
return X.values
|
||
|
||
def random(self, data, label, test_ratio=0.2, random_state=123):
|
||
"""
|
||
随机划分数据集
|
||
|
||
Args:
|
||
data: shape (n_samples, n_features)
|
||
label: shape (n_sample, )
|
||
test_ratio: 测试集比例，默认: 0.2
|
||
random_state: 随机种子，默认: 123
|
||
|
||
Returns:
|
||
X_train: (n_samples, n_features)
|
||
X_test: (n_samples, n_features)
|
||
y_train: (n_sample, )
|
||
y_test: (n_sample, )
|
||
"""
|
||
X_train, X_test, y_train, y_test = train_test_split(
|
||
data, label, test_size=test_ratio, random_state=random_state
|
||
)
|
||
return X_train, X_test, y_train, y_test
|
||
|
||
def spxy(self, data, label, test_size=0.2):
|
||
"""
|
||
SPXY算法划分数据集（考虑X和Y空间的距离）
|
||
|
||
Args:
|
||
data: shape (n_samples, n_features)
|
||
label: shape (n_samples, )
|
||
test_size: 测试集比例，默认: 0.2
|
||
|
||
Returns:
|
||
X_train: (n_samples, n_features)
|
||
X_test: (n_samples, n_features)
|
||
y_train: (n_samples, )
|
||
y_test: (n_samples, )
|
||
"""
|
||
# 确保 data 和 label 是 NumPy 数组
|
||
data = data.to_numpy() if isinstance(data, pd.DataFrame) else data
|
||
label = label.to_numpy() if isinstance(label, pd.Series) else label
|
||
|
||
# 备份原始数据和标签
|
||
x_backup = data
|
||
y_backup = label
|
||
|
||
M = data.shape[0]
|
||
N = round((1 - test_size) * M)
|
||
samples = np.arange(M)
|
||
|
||
# 归一化标签数据
|
||
label = (label - np.mean(label)) / np.std(label)
|
||
D = np.zeros((M, M))
|
||
Dy = np.zeros((M, M))
|
||
|
||
# 计算样本之间的距离
|
||
for i in range(M - 1):
|
||
xa = data[i, :]
|
||
ya = label[i]
|
||
for j in range((i + 1), M):
|
||
xb = data[j, :]
|
||
yb = label[j]
|
||
D[i, j] = np.linalg.norm(xa - xb)
|
||
Dy[i, j] = np.linalg.norm(ya - yb)
|
||
|
||
# 距离归一化
|
||
Dmax = np.max(D)
|
||
Dymax = np.max(Dy)
|
||
D = D / Dmax + Dy / Dymax
|
||
|
||
# 找到最远的两个点
|
||
maxD = D.max(axis=0)
|
||
index_row = D.argmax(axis=0)
|
||
index_column = maxD.argmax()
|
||
|
||
m = np.zeros(N, dtype=int)
|
||
m[0] = index_row[index_column]
|
||
m[1] = index_column
|
||
|
||
dminmax = np.zeros(N)
|
||
dminmax[1] = D[m[0], m[1]]
|
||
|
||
# 根据距离选择训练集
|
||
for i in range(2, N):
|
||
pool = np.delete(samples, m[:i])
|
||
dmin = np.zeros(M - i)
|
||
for j in range(M - i):
|
||
indexa = pool[j]
|
||
d = np.zeros(i)
|
||
for k in range(i):
|
||
indexb = m[k]
|
||
if indexa < indexb:
|
||
d[k] = D[indexa, indexb]
|
||
else:
|
||
d[k] = D[indexb, indexa]
|
||
dmin[j] = np.min(d)
|
||
dminmax[i] = np.max(dmin)
|
||
index = np.argmax(dmin)
|
||
m[i] = pool[index]
|
||
|
||
m_complement = np.delete(samples, m)
|
||
|
||
# 划分训练集和测试集
|
||
X_train = data[m, :]
|
||
y_train = y_backup[m]
|
||
X_test = data[m_complement, :]
|
||
y_test = y_backup[m_complement]
|
||
|
||
return X_train, X_test, y_train, y_test
|
||
|
||
def ks(self, data, label, test_size=0.2):
|
||
"""
|
||
Kennard-Stone算法划分数据集
|
||
|
||
Args:
|
||
data: shape (n_samples, n_features)
|
||
label: shape (n_sample, )
|
||
test_size: 测试集比例，默认: 0.2
|
||
|
||
Returns:
|
||
X_train: (n_samples, n_features)
|
||
X_test: (n_samples, n_features)
|
||
y_train: (n_samples, )
|
||
y_test: (n_samples, )
|
||
"""
|
||
# 确保 data 和 label 是 NumPy 数组
|
||
data = data.to_numpy() if isinstance(data, pd.DataFrame) else data
|
||
label = label.to_numpy() if isinstance(label, pd.Series) else label
|
||
|
||
M = data.shape[0]
|
||
N = round((1 - test_size) * M)
|
||
samples = np.arange(M)
|
||
|
||
D = np.zeros((M, M))
|
||
|
||
for i in range((M - 1)):
|
||
xa = data[i, :]
|
||
for j in range((i + 1), M):
|
||
xb = data[j, :]
|
||
D[i, j] = np.linalg.norm(xa - xb)
|
||
|
||
maxD = np.max(D, axis=0)
|
||
index_row = np.argmax(D, axis=0)
|
||
index_column = np.argmax(maxD)
|
||
|
||
m = np.zeros(N)
|
||
m[0] = np.array(index_row[index_column])
|
||
m[1] = np.array(index_column)
|
||
m = m.astype(int)
|
||
dminmax = np.zeros(N)
|
||
dminmax[1] = D[m[0], m[1]]
|
||
|
||
for i in range(2, N):
|
||
pool = np.delete(samples, m[:i])
|
||
dmin = np.zeros((M - i))
|
||
for j in range((M - i)):
|
||
indexa = pool[j]
|
||
d = np.zeros(i)
|
||
for k in range(i):
|
||
indexb = m[k]
|
||
if indexa < indexb:
|
||
d[k] = D[indexa, indexb]
|
||
else:
|
||
d[k] = D[indexb, indexa]
|
||
dmin[j] = np.min(d)
|
||
dminmax[i] = np.max(dmin)
|
||
index = np.argmax(dmin)
|
||
m[i] = pool[index]
|
||
|
||
m_complement = np.delete(np.arange(data.shape[0]), m)
|
||
|
||
X_train = data[m, :]
|
||
y_train = label[m]
|
||
X_test = data[m_complement, :]
|
||
y_test = label[m_complement]
|
||
|
||
return X_train, X_test, y_train, y_test
|
||
|
||
def split_data(self, X: np.ndarray, y: pd.Series, method: str = "random",
|
||
test_size: float = 0.2, random_state: int = 42) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
|
||
"""
|
||
根据指定方法划分数据集
|
||
|
||
Args:
|
||
X: 特征数据
|
||
y: 目标值数据
|
||
method: 划分方法 ("random", "spxy", "ks")
|
||
test_size: 测试集比例
|
||
random_state: 随机种子（仅对random方法有效）
|
||
|
||
Returns:
|
||
X_train, X_test, y_train, y_test
|
||
"""
|
||
print(f"使用 {method} 方法划分数据集")
|
||
|
||
if method == "random":
|
||
return self.random(X, y, test_ratio=test_size, random_state=random_state)
|
||
elif method == "spxy":
|
||
return self.spxy(X, y, test_size=test_size)
|
||
elif method == "ks":
|
||
return self.ks(X, y, test_size=test_size)
|
||
else:
|
||
raise ValueError(f"不支持的划分方法: {method}. 支持的方法: {self.split_methods}")
|
||
|
||
def train_single_model(self, X: np.ndarray, y: pd.Series, model_name: str,
|
||
cv_folds: int = 5, scoring: str = 'neg_mean_squared_error',
|
||
test_size: float = 0.2, random_state: int = 42,
|
||
split_method: str = "random") -> Dict:
|
||
"""
|
||
训练单个回归模型
|
||
|
||
Args:
|
||
X: 特征数据
|
||
y: 目标值数据
|
||
model_name: 模型名称
|
||
cv_folds: 交叉验证折数
|
||
scoring: 评分指标
|
||
test_size: 测试集比例
|
||
random_state: 随机种子
|
||
split_method: 数据划分方法
|
||
|
||
Returns:
|
||
训练结果字典
|
||
"""
|
||
if model_name not in self.model_configs:
|
||
raise ValueError(f"不支持的模型: {model_name}")
|
||
|
||
config = self.model_configs[model_name]
|
||
|
||
if not config['available']:
|
||
print(f"模型 {model_name} 不可用，请安装相应的库")
|
||
return None
|
||
|
||
print(f"开始训练模型: {model_name}")
|
||
|
||
# 使用指定方法分割训练集和测试集
|
||
X_train, X_test, y_train, y_test = self.split_data(
|
||
X, y, method=split_method, test_size=test_size, random_state=random_state
|
||
)
|
||
|
||
print(f"数据分割完成:")
|
||
print(f" 训练集样本数: {X_train.shape[0]}")
|
||
print(f" 测试集样本数: {X_test.shape[0]}")
|
||
|
||
# 创建模型实例
|
||
if callable(config['model']):
|
||
base_model = config['model']()
|
||
else:
|
||
base_model = config['model']
|
||
|
||
# 特殊处理某些模型
|
||
if model_name == 'CatBoost':
|
||
base_model.set_params(verbose=False)
|
||
elif model_name == 'LightGBM':
|
||
base_model.set_params(verbose=-1)
|
||
|
||
# 网格搜索 - 使用KFold代替StratifiedKFold
|
||
cv_strategy = KFold(n_splits=cv_folds, shuffle=True, random_state=random_state)
|
||
|
||
grid_search = GridSearchCV(
|
||
base_model,
|
||
config['params'],
|
||
cv=cv_strategy,
|
||
scoring=scoring,
|
||
n_jobs=-1,
|
||
verbose=1
|
||
)
|
||
|
||
# 在训练集上训练模型
|
||
# with parallel_backend("threading", n_jobs=-1):
|
||
# grid_search.fit(X_train, y_train)
|
||
grid_search.fit(X_train, y_train)
|
||
|
||
# 获取最佳模型
|
||
best_model = grid_search.best_estimator_
|
||
|
||
# 交叉验证评估（在训练集上）
|
||
cv_scores = cross_val_score(best_model, X_train, y_train, cv=cv_strategy, scoring=scoring)
|
||
|
||
# 计算训练集上的回归指标
|
||
y_train_pred = best_model.predict(X_train)
|
||
train_mse = mean_squared_error(y_train, y_train_pred)
|
||
train_mae = mean_absolute_error(y_train, y_train_pred)
|
||
train_r2 = r2_score(y_train, y_train_pred)
|
||
train_rmse = np.sqrt(train_mse)
|
||
|
||
# 计算测试集上的回归指标
|
||
y_test_pred = best_model.predict(X_test)
|
||
test_mse = mean_squared_error(y_test, y_test_pred)
|
||
test_mae = mean_absolute_error(y_test, y_test_pred)
|
||
test_r2 = r2_score(y_test, y_test_pred)
|
||
test_rmse = np.sqrt(test_mse)
|
||
|
||
result = {
|
||
'model': best_model,
|
||
'best_params': grid_search.best_params_,
|
||
'best_score': grid_search.best_score_,
|
||
'cv_mean': cv_scores.mean(),
|
||
'cv_std': cv_scores.std(),
|
||
'cv_scores': cv_scores,
|
||
# 训练集指标
|
||
'train_mse': train_mse,
|
||
'train_mae': train_mae,
|
||
'train_rmse': train_rmse,
|
||
'train_r2': train_r2,
|
||
# 测试集指标
|
||
'test_mse': test_mse,
|
||
'test_mae': test_mae,
|
||
'test_rmse': test_rmse,
|
||
'test_r2': test_r2,
|
||
# 数据分割信息
|
||
'train_size': X_train.shape[0],
|
||
'test_size': X_test.shape[0],
|
||
'split_method': split_method
|
||
}
|
||
|
||
print(f"模型 {model_name} 训练完成:")
|
||
print(f" 最佳参数: {result['best_params']}")
|
||
print(f" 最佳得分: {result['best_score']:.4f}")
|
||
print(f" CV均值: {result['cv_mean']:.4f} ± {result['cv_std']:.4f}")
|
||
print(f" 训练集指标:")
|
||
print(f" R²: {result['train_r2']:.4f}")
|
||
print(f" RMSE: {result['train_rmse']:.4f}")
|
||
print(f" MAE: {result['train_mae']:.4f}")
|
||
print(f" 测试集指标:")
|
||
print(f" R²: {result['test_r2']:.4f}")
|
||
print(f" RMSE: {result['test_rmse']:.4f}")
|
||
print(f" MAE: {result['test_mae']:.4f}")
|
||
|
||
return result
|
||
|
||
def save_model(self, model, target_column_name: str, preprocess_method: str, model_name: str,
|
||
metadata: Dict = None):
|
||
"""
|
||
保存模型，使用目标列名作为文件名的一部分
|
||
|
||
Args:
|
||
model: 训练好的模型
|
||
target_column_name: 目标列名
|
||
preprocess_method: 预处理方法名称
|
||
model_name: 模型名称
|
||
metadata: 模型元数据
|
||
"""
|
||
# 清理目标列名，移除可能的特殊字符
|
||
safe_target_name = "".join(c for c in target_column_name if c.isalnum() or c in ('-', '_')).rstrip()
|
||
|
||
filename = f"{safe_target_name}_{preprocess_method}_{model_name}.joblib"
|
||
filepath = self.artifacts_dir / filename
|
||
|
||
# 保存模型和元数据
|
||
save_data = {
|
||
'model': model,
|
||
'target_column_name': target_column_name,
|
||
'preprocess_method': preprocess_method,
|
||
'model_name': model_name,
|
||
'metadata': metadata or {}
|
||
}
|
||
|
||
joblib.dump(save_data, filepath)
|
||
print(f"模型已保存: {filepath}")
|
||
|
||
def train_models_batch(self, csv_path: str, feature_start_column: Union[int, str],
|
||
preprocessing_methods: Union[str, List[str]] = "None",
|
||
model_names: Union[str, List[str]] = "RF",
|
||
split_methods: Union[str, List[str]] = "random",
|
||
cv_folds: int = 5,
|
||
scoring: str = 'neg_mean_squared_error',
|
||
test_size: float = 0.2,
|
||
random_state: int = 42) -> Dict:
|
||
"""
|
||
批量训练多个目标列的模型
|
||
|
||
Args:
|
||
csv_path: 数据文件路径
|
||
feature_start_column: 特征开始列索引（int）或列名（str）
|
||
preprocessing_methods: 预处理方法列表
|
||
model_names: 模型名称列表
|
||
split_methods: 数据划分方法列表
|
||
cv_folds: 交叉验证折数
|
||
scoring: 评分指标（回归指标）
|
||
test_size: 测试集比例
|
||
random_state: 随机种子
|
||
|
||
Returns:
|
||
所有模型的训练结果
|
||
"""
|
||
# 转换为列表
|
||
if isinstance(preprocessing_methods, str):
|
||
preprocessing_methods = [preprocessing_methods]
|
||
if isinstance(model_names, str):
|
||
model_names = [model_names]
|
||
if isinstance(split_methods, str):
|
||
split_methods = [split_methods]
|
||
|
||
# 加载数据
|
||
X_raw, y_dict = self.load_data_batch(csv_path, feature_start_column)
|
||
|
||
all_results = {}
|
||
|
||
# 对每个目标列进行训练
|
||
for target_column_name, y in y_dict.items():
|
||
print(f"\n{'='*80}")
|
||
print(f"开始训练目标列: {target_column_name}")
|
||
print(f"{'='*80}")
|
||
|
||
# 创建该目标列的子目录
|
||
target_artifacts_dir = self.artifacts_dir / target_column_name
|
||
target_artifacts_dir.mkdir(parents=True, exist_ok=True)
|
||
|
||
# 临时更改artifacts_dir
|
||
original_artifacts_dir = self.artifacts_dir
|
||
self.artifacts_dir = target_artifacts_dir
|
||
|
||
try:
|
||
# 去除该目标列的空值
|
||
mask = ~y.isna()
|
||
if mask.sum() == 0:
|
||
print(f"目标列 '{target_column_name}' 无有效数据，跳过")
|
||
continue
|
||
|
||
X_clean = X_raw[mask]
|
||
y_clean = y[mask]
|
||
|
||
print(f"有效样本数: {len(y_clean)}")
|
||
|
||
# 训练该目标列的所有模型组合
|
||
target_results = self.train_models_single_target(
|
||
X_clean, y_clean, target_column_name,
|
||
preprocessing_methods, model_names, split_methods,
|
||
cv_folds, scoring, test_size, random_state
|
||
)
|
||
|
||
all_results[target_column_name] = target_results
|
||
|
||
except Exception as e:
|
||
print(f"训练目标列 '{target_column_name}' 时出错: {e}")
|
||
continue
|
||
finally:
|
||
# 恢复原始artifacts_dir
|
||
self.artifacts_dir = original_artifacts_dir
|
||
|
||
# 保存所有结果的汇总
|
||
self._save_batch_results_summary(all_results)
|
||
|
||
return all_results
|
||
|
||
def train_models_single_target(self, X_raw: pd.DataFrame, y: pd.Series, target_column_name: str,
|
||
preprocessing_methods: List[str], model_names: List[str],
|
||
split_methods: List[str], cv_folds: int, scoring: str,
|
||
test_size: float, random_state: int) -> Dict:
|
||
"""
|
||
训练单个目标列的所有模型组合
|
||
"""
|
||
results = {}
|
||
|
||
# 遍历所有组合
|
||
for split_method in split_methods:
|
||
for preprocess_method in preprocessing_methods:
|
||
for model_name in model_names:
|
||
combo_key = f"{split_method}_{preprocess_method}_{model_name}"
|
||
print(f"\n{'-' * 60}")
|
||
print(f"训练组合: {combo_key}")
|
||
print(f"{'-' * 60}")
|
||
|
||
try:
|
||
# 数据预处理
|
||
X_processed = self.preprocess_data(X_raw, preprocess_method)
|
||
|
||
# 训练模型
|
||
result = self.train_single_model(X_processed, y, model_name,
|
||
cv_folds, scoring, test_size, random_state, split_method)
|
||
|
||
if result is not None:
|
||
# 保存模型
|
||
metadata = {
|
||
'target_column_name': target_column_name,
|
||
'cv_mean': result['cv_mean'],
|
||
'cv_std': result['cv_std'],
|
||
'best_params': result['best_params'],
|
||
'data_shape': X_processed.shape,
|
||
'target_range': [float(y.min()), float(y.max())],
|
||
'train_r2': result['train_r2'],
|
||
'train_rmse': result['train_rmse'],
|
||
'train_mae': result['train_mae'],
|
||
'test_r2': result['test_r2'],
|
||
'test_rmse': result['test_rmse'],
|
||
'test_mae': result['test_mae'],
|
||
'train_size': result['train_size'],
|
||
'test_size': result['test_size'],
|
||
'split_method': result['split_method']
|
||
}
|
||
|
||
self.save_model(result['model'], target_column_name,
|
||
f"{split_method}_{preprocess_method}",
|
||
model_name, metadata)
|
||
|
||
results[combo_key] = result
|
||
|
||
except Exception as e:
|
||
print(f"训练组合 {combo_key} 失败: {e}")
|
||
continue
|
||
|
||
# 保存该目标列的结果摘要
|
||
self._save_single_target_results_summary(target_column_name, results)
|
||
|
||
return results
|
||
|
||
def _save_single_target_results_summary(self, target_column_name: str, results: Dict):
|
||
"""保存单个目标列的结果摘要"""
|
||
if not results:
|
||
print(f"目标列 '{target_column_name}' 没有训练结果")
|
||
return
|
||
|
||
summary_data = []
|
||
|
||
for combo_key, result in results.items():
|
||
# 分离划分方法、预处理方法和建模方法
|
||
parts = combo_key.split('_', 2)
|
||
split_method = parts[0] if len(parts) > 0 else ''
|
||
preprocess_method = parts[1] if len(parts) > 1 else ''
|
||
model_method = parts[2] if len(parts) > 2 else ''
|
||
|
||
summary_data.append({
|
||
'划分方法': split_method,
|
||
'预处理方法': preprocess_method,
|
||
'建模方法': model_method,
|
||
'CV均值': result['cv_mean'],
|
||
'CV标准差': result['cv_std'],
|
||
'最佳得分': result['best_score'],
|
||
'训练集R²': result['train_r2'],
|
||
'训练集RMSE': result['train_rmse'],
|
||
'训练集MAE': result['train_mae'],
|
||
'训练集MSE': result['train_mse'],
|
||
'测试集R²': result['test_r2'],
|
||
'测试集RMSE': result['test_rmse'],
|
||
'测试集MAE': result['test_mae'],
|
||
'测试集MSE': result['test_mse'],
|
||
'训练样本数': result['train_size'],
|
||
'测试样本数': result['test_size'],
|
||
'最佳参数': str(result['best_params'])
|
||
})
|
||
|
||
summary_df = pd.DataFrame(summary_data)
|
||
# 按测试集R²降序排列（R²越大越好）
|
||
summary_df = summary_df.sort_values('测试集R²', ascending=False)
|
||
|
||
# 清理目标列名，移除可能的特殊字符
|
||
safe_target_name = "".join(c for c in target_column_name if c.isalnum() or c in ('-', '_')).rstrip()
|
||
|
||
# 保存详细结果CSV（中文版）
|
||
detailed_path = self.artifacts_dir / f"{safe_target_name}_detailed_results.csv"
|
||
summary_df.to_csv(detailed_path, index=False, encoding='utf-8-sig')
|
||
|
||
# 保存简化版本用于兼容性（英文版）
|
||
summary_data_simple = []
|
||
for combo_key, result in results.items():
|
||
summary_data_simple.append({
|
||
'combination': combo_key,
|
||
'cv_mean': result['cv_mean'],
|
||
'cv_std': result['cv_std'],
|
||
'best_score': result['best_score'],
|
||
'train_r2': result['train_r2'],
|
||
'train_rmse': result['train_rmse'],
|
||
'train_mae': result['train_mae'],
|
||
'test_r2': result['test_r2'],
|
||
'test_rmse': result['test_rmse'],
|
||
'test_mae': result['test_mae'],
|
||
'train_size': result['train_size'],
|
||
'test_size': result['test_size'],
|
||
'split_method': result.get('split_method', 'unknown'),
|
||
'best_params': str(result['best_params'])
|
||
})
|
||
|
||
summary_df_simple = pd.DataFrame(summary_data_simple)
|
||
summary_df_simple = summary_df_simple.sort_values('test_r2', ascending=False)
|
||
simple_summary_path = self.artifacts_dir / f"{safe_target_name}_training_summary.csv"
|
||
summary_df_simple.to_csv(simple_summary_path, index=False)
|
||
|
||
print(f"\n{'-' * 60}")
|
||
print(f"目标列 '{target_column_name}' 训练结果摘要:")
|
||
print(f"{'-' * 60}")
|
||
print(summary_df[
|
||
['划分方法', '预处理方法', '建模方法', '训练集R²', '测试集R²', '训练集RMSE', '测试集RMSE', 'CV均值']].to_string(
|
||
index=False))
|
||
print(f"\n详细结果已保存: {detailed_path}")
|
||
print(f"简化结果已保存: {simple_summary_path}")
|
||
|
||
def _save_batch_results_summary(self, all_results: Dict):
|
||
"""保存批量训练结果汇总"""
|
||
all_summary_data = []
|
||
|
||
for target_column_name, target_results in all_results.items():
|
||
for combo_key, result in target_results.items():
|
||
# 分离划分方法、预处理方法和建模方法
|
||
parts = combo_key.split('_', 2)
|
||
split_method = parts[0] if len(parts) > 0 else ''
|
||
preprocess_method = parts[1] if len(parts) > 1 else ''
|
||
model_method = parts[2] if len(parts) > 2 else ''
|
||
|
||
all_summary_data.append({
|
||
'目标列': target_column_name,
|
||
'划分方法': split_method,
|
||
'预处理方法': preprocess_method,
|
||
'建模方法': model_method,
|
||
'CV均值': result['cv_mean'],
|
||
'CV标准差': result['cv_std'],
|
||
'最佳得分': result['best_score'],
|
||
'训练集R²': result['train_r2'],
|
||
'训练集RMSE': result['train_rmse'],
|
||
'训练集MAE': result['train_mae'],
|
||
'训练集MSE': result['train_mse'],
|
||
'测试集R²': result['test_r2'],
|
||
'测试集RMSE': result['test_rmse'],
|
||
'测试集MAE': result['test_mae'],
|
||
'测试集MSE': result['test_mse'],
|
||
'训练样本数': result['train_size'],
|
||
'测试样本数': result['test_size'],
|
||
'最佳参数': str(result['best_params'])
|
||
})
|
||
|
||
if all_summary_data:
|
||
summary_df = pd.DataFrame(all_summary_data)
|
||
# 按目标列和测试集R²排序
|
||
summary_df = summary_df.sort_values(['目标列', '测试集R²'], ascending=[True, False])
|
||
|
||
# 保存详细结果CSV（中文版）
|
||
detailed_path = self.artifacts_dir / "batch_detailed_results.csv"
|
||
summary_df.to_csv(detailed_path, index=False, encoding='utf-8-sig')
|
||
|
||
# 保持原有的批量训练汇总结果（中文版）
|
||
batch_summary_path = self.artifacts_dir / "batch_training_summary.csv"
|
||
summary_df.to_csv(batch_summary_path, index=False, encoding='utf-8-sig')
|
||
|
||
# 创建简化版本用于兼容性（英文版）
|
||
all_summary_data_simple = []
|
||
for target_column_name, target_results in all_results.items():
|
||
for combo_key, result in target_results.items():
|
||
all_summary_data_simple.append({
|
||
'target_column': target_column_name,
|
||
'combination': combo_key,
|
||
'cv_mean': result['cv_mean'],
|
||
'cv_std': result['cv_std'],
|
||
'best_score': result['best_score'],
|
||
'train_r2': result['train_r2'],
|
||
'train_rmse': result['train_rmse'],
|
||
'train_mae': result['train_mae'],
|
||
'test_r2': result['test_r2'],
|
||
'test_rmse': result['test_rmse'],
|
||
'test_mae': result['test_mae'],
|
||
'train_size': result['train_size'],
|
||
'test_size': result['test_size'],
|
||
'split_method': result.get('split_method', 'unknown'),
|
||
'best_params': str(result['best_params'])
|
||
})
|
||
|
||
summary_df_simple = pd.DataFrame(all_summary_data_simple)
|
||
summary_df_simple = summary_df_simple.sort_values(['target_column', 'test_r2'], ascending=[True, False])
|
||
simple_summary_path = self.artifacts_dir / "batch_training_summary_simple.csv"
|
||
summary_df_simple.to_csv(simple_summary_path, index=False)
|
||
|
||
print(f"\n{'='*80}")
|
||
print("批量训练结果汇总:")
|
||
print(f"{'='*80}")
|
||
|
||
# 显示每个目标列的最佳模型
|
||
for target_col in summary_df['目标列'].unique():
|
||
target_data = summary_df[summary_df['目标列'] == target_col]
|
||
best_row = target_data.iloc[0] # 已经按R²降序排列
|
||
print(f"\n目标列 '{target_col}' 最佳模型:")
|
||
print(f" 组合: {best_row['划分方法']}_{best_row['预处理方法']}_{best_row['建模方法']}")
|
||
print(f" 测试集R²: {best_row['测试集R²']:.4f}")
|
||
print(f" 测试集RMSE: {best_row['测试集RMSE']:.4f}")
|
||
print(f" 最佳参数: {best_row['最佳参数']}")
|
||
|
||
print(f"\n详细结果已保存: {detailed_path}")
|
||
print(f"批量训练汇总结果已保存: {batch_summary_path}")
|
||
print(f"简化结果已保存: {simple_summary_path}")
|
||
|
||
def load_model(self, preprocess_method: str, model_name: str):
|
||
"""
|
||
加载保存的模型
|
||
|
||
Args:
|
||
preprocess_method: 预处理方法名称
|
||
model_name: 模型名称
|
||
|
||
Returns:
|
||
加载的模型数据
|
||
"""
|
||
filename = f"{preprocess_method}_{model_name}.joblib"
|
||
filepath = self.artifacts_dir / filename
|
||
|
||
if not filepath.exists():
|
||
raise FileNotFoundError(f"模型文件不存在: {filepath}")
|
||
|
||
return joblib.load(filepath)
|
||
|
||
def get_best_model(self, metric: str = 'test_r2') -> Tuple[str, Dict]:
|
||
"""
|
||
获取最佳模型
|
||
|
||
Args:
|
||
metric: 评估指标（默认使用测试集R²）
|
||
可选：'test_r2', 'train_r2', 'test_rmse', 'test_mae',
|
||
'train_rmse', 'train_mae', 'cv_mean', 'best_score'
|
||
|
||
Returns:
|
||
最佳模型的组合名称和结果
|
||
"""
|
||
if not self.results:
|
||
raise ValueError("没有训练结果，请先训练模型")
|
||
|
||
# 对于回归指标，R²和负MSE需要取最大值，RMSE和MAE需要取最小值
|
||
if metric in ['test_r2', 'train_r2', 'cv_mean', 'best_score']:
|
||
best_combo = max(self.results.keys(),
|
||
key=lambda k: self.results[k][metric])
|
||
else: # rmse, mae等，越小越好
|
||
best_combo = min(self.results.keys(),
|
||
key=lambda k: self.results[k][metric])
|
||
|
||
return best_combo, self.results[best_combo]
|
||
|
||
|
||
def main():
|
||
"""主函数示例 - 批量训练"""
|
||
# 创建批量建模实例
|
||
modeler = WaterQualityModelingBatch(r"D:\BaiduNetdiskDownload\yaobao\model")
|
||
|
||
# 批量训练多个目标列的模型
|
||
all_results = modeler.train_models_batch(
|
||
csv_path=r"D:\BaiduNetdiskDownload\yaobao\csv\yangdian_output.csv",
|
||
feature_start_column="374.285004", # 使用列名指定特征开始位置
|
||
preprocessing_methods=['None', 'MMS', 'SS', 'SNV', 'MA', 'SG', 'MSC', 'D1', 'D2', 'DT', 'CT'],#
|
||
model_names=['SVR', 'RF', 'Ridge', 'Lasso'],#, 'ElasticNet', 'XGBoost', 'LightGBM', 'CatBoost'
|
||
split_methods=['spxy', 'ks','random' ], #
|
||
cv_folds=5
|
||
)
|
||
|
||
print(f"\n批量训练完成，共训练了 {len(all_results)} 个目标列的模型")
|
||
|
||
# 显示每个目标列的最佳模型
|
||
for target_column_name, target_results in all_results.items():
|
||
if target_results:
|
||
best_combo = max(target_results.keys(),
|
||
key=lambda k: target_results[k]['test_r2'])
|
||
best_result = target_results[best_combo]
|
||
|
||
print(f"\n目标列 '{target_column_name}' 最佳模型:")
|
||
print(f" 组合: {best_combo}")
|
||
print(f" 测试集R²: {best_result['test_r2']:.4f}")
|
||
print(f" 测试集RMSE: {best_result['test_rmse']:.4f}")
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|