gpbench 1.0.0__py3-none-any.whl

gpbench/method_reg/SoyDNGP/SoyDNGP.py

@@ -0,0 +1,179 @@
+import os
+import time
+import psutil
+import argparse
+import random
+import torch
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import KFold, train_test_split
+from .AlexNet_206 import AlexNet
+from scipy.stats import pearsonr
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from torch.utils.data  import DataLoader, TensorDataset
+from . import SoyDNGP_Hyperparameters
+import pynvml
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser")
+    parser.add_argument('--methods', type=str, default='SoyDNGP/', help='Random seed')
+    parser.add_argument('--species', type=str, default='Chicken/', help='Species name')
+    parser.add_argument('--phe', type=str, default='', help='Dataset name')
+    parser.add_argument('--data_dir', type=str, default='../../data/')
+    parser.add_argument('--result_dir', type=str, default='result/')
+    
+    parser.add_argument('--epochs', type=int, default=1000, help='Number of training rounds')
+    parser.add_argument('--batch_size', type=int, default=32, help='Batch size')
+    parser.add_argument('--learning_rate', type=float, default=0.01, help='Learning rate')
+    parser.add_argument('--patience', type=int, default=10, help='Patience for early stopping')
+    args = parser.parse_args()
+    return args
+
+def get_data(dataframe):
+    data_matrix = np.array(dataframe)
+    total_sample, total_snp = data_matrix.shape
+    one_hot = np.zeros((total_sample, total_snp, 3), dtype=np.float32)
+    one_hot[data_matrix == 2] = [1, 1, 0]
+    one_hot[data_matrix == 1] = [1, 0, 1]
+    one_hot[data_matrix == 0] = [0, 1, 1]
+
+    target_snp = 206 * 206
+    if total_snp != target_snp:
+        new_one_hot = np.zeros((total_sample, target_snp, 3), dtype=np.float32)
+        copy_len = min(total_snp, target_snp)
+        new_one_hot[:, :copy_len] = one_hot[:, :copy_len]
+        one_hot = new_one_hot
+
+    one_hot = one_hot.reshape(total_sample, 206, 206, 3)
+    return one_hot
+
+
+def load_data(args):
+    xData = np.load(os.path.join(args.data_dir, args.species, 'genotype.npz'))["arr_0"]
+    yData = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_0"]
+    names = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_1"]
+
+    nsample = xData.shape[0]
+    nsnp = xData.shape[1]
+    print("Number of samples: ", nsample)
+    print("Number of SNPs: ", nsnp)
+    xData = get_data(xData)
+    return xData, yData, nsample, nsnp, names
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def get_gpu_mem_by_pid(pid):
+    procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
+    for p in procs:
+        if p.pid == pid:
+            return p.usedGpuMemory / 1024**2
+    return 0.0
+
+
+def run_nested_cv(args, data, label, nsnp, device):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+    os.makedirs(result_dir, exist_ok=True)
+    print("Starting 10-fold cross-validation...")
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_mse, all_mae, all_r2, all_pcc = [], [], [], []
+    time_star = time.time()
+    for fold, (train_index, test_index) in enumerate(kf.split(data)):
+        print(f"Running fold {fold}...")
+        process = psutil.Process(os.getpid())
+        fold_start_time = time.time()
+
+        X_train, X_test = data[train_index], data[test_index]
+        y_train, y_test = label[train_index], label[test_index]
+
+        X_train_sub, X_valid, y_train_sub, y_valid = train_test_split(X_train, y_train, test_size=0.1, random_state=42)
+        
+        x_train_tensor = torch.from_numpy(X_train_sub).float().to(device)
+        y_train_tensor = torch.from_numpy(y_train_sub).float().to(device)
+        x_valid_tensor = torch.from_numpy(X_valid).float().to(device)
+        y_valid_tensor = torch.from_numpy(y_valid).float().to(device)
+        x_test_tensor = torch.from_numpy(X_test).float().to(device)
+        y_test_tensor = torch.from_numpy(y_test).float().to(device)
+
+        train_data = TensorDataset(x_train_tensor, y_train_tensor)
+        valid_data = TensorDataset(x_valid_tensor, y_valid_tensor)
+        test_data = TensorDataset(x_test_tensor, y_test_tensor)
+
+        train_loader = DataLoader(train_data, args.batch_size, shuffle=True)
+        valid_loader = DataLoader(valid_data, args.batch_size, shuffle=False)
+        test_loader = DataLoader(test_data, args.batch_size, shuffle=False)
+
+        model = AlexNet()
+        model.train_model(train_loader, valid_loader, args.epochs, args.learning_rate, args.patience, device)
+        y_pred = model.predict(test_loader)
+
+        mse = mean_squared_error(y_test, y_pred)
+        r2 = r2_score(y_test, y_pred)
+        mae = mean_absolute_error(y_test, y_pred)
+        pcc, _ = pearsonr(y_test, y_pred)
+
+        all_mse.append(mse)
+        all_r2.append(r2)
+        all_mae.append(mae)
+        all_pcc.append(pcc)
+
+        fold_time = time.time() - fold_start_time
+        fold_gpu_mem =  get_gpu_mem_by_pid(os.getpid())
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        print(f'Fold {fold}:  Corr={pcc:.4f}, MAE={mae:.4f}, MSE={mse:.4f}, R2={r2:.4f}, Time={fold_time:.2f}s, '
+              f'GPU={fold_gpu_mem:.2f}MB, CPU={fold_cpu_mem:.2f}MB')
+    
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+        results_df = pd.DataFrame({'Y_test': y_test, 'Y_pred': y_pred})
+        results_df.to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+    print("\n===== Cross-validation summary =====")
+    print(f"Average PCC: {np.mean(all_pcc):.4f} ± {np.std(all_pcc):.4f}")
+    print(f"Average MAE: {np.mean(all_mae):.4f} ± {np.std(all_mae):.4f}")
+    print(f"Average MSE: {np.mean(all_mse):.4f} ± {np.std(all_mse):.4f}")
+    print(f"Average R2 : {np.mean(all_r2):.4f} ± {np.std(all_r2):.4f}")
+    print(f"Time: {time.time() - time_star:.2f}s")
+
+
+def SoyDNGP_reg():
+    set_seed(42)
+    torch.cuda.empty_cache()  
+    pynvml.nvmlInit()
+    handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+    
+    args = parse_args()
+    all_species =['Cotton/']
+    
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    args.device = device
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        X, Y, nsamples, nsnp, names = load_data(args)
+        for j in range(len(names)):
+            args.phe = names[j]
+            print("starting run " + args.methods + args.species + args.phe)
+            label = Y[:, j]
+            label = np.nan_to_num(label, nan=np.nanmean(label))
+            best_params = SoyDNGP_Hyperparameters.Hyperparameter(X, label, nsnp)
+            args.learning_rate = best_params['learning_rate']
+            args.batch_size = best_params['batch_size']
+            args.patience = best_params['patience']
+            start_time = time.time() 
+            torch.cuda.reset_peak_memory_stats()
+            process = psutil.Process(os.getpid())
+            run_nested_cv(args, data=X, label=label, nsnp = nsnp, device = args.device)
+
+            elapsed_time = time.time() - start_time
+            print(f"running time: {elapsed_time:.2f} s")
+            print("successfully")
+
+
+if __name__ == "__main__":
+    SoyDNGP_reg()

gpbench/method_reg/SoyDNGP/SoyDNGP_Hyperparameters.py

@@ -0,0 +1,105 @@
+import os
+import time
+import psutil
+import random
+import torch
+import numpy as np
+import optuna
+from sklearn.model_selection import KFold, train_test_split
+from .AlexNet_206 import AlexNet
+from scipy.stats import pearsonr
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from torch.utils.data  import DataLoader, TensorDataset
+from optuna.exceptions import TrialPruned 
+
+def run_nested_cv_with_early_stopping(data, label, nsnp, learning_rate, patience, batch_size, num_round=300):
+    device = torch.device("cuda:0")
+    print("Starting 10-fold cross-validation...")
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+    all_mse, all_mae, all_r2, all_pcc = [], [], [], []
+    
+    for fold, (train_index, test_index) in enumerate(kf.split(data)):
+        print(f"Running fold {fold}...")
+        process = psutil.Process(os.getpid())
+        fold_start_time = time.time()
+
+        X_train, X_test = data[train_index], data[test_index]
+        y_train, y_test = label[train_index], label[test_index]
+
+        X_train_sub, X_valid, y_train_sub, y_valid = train_test_split(X_train, y_train, test_size=0.1, random_state=42)
+
+        x_train_tensor = torch.from_numpy(X_train_sub).float().to(device)
+        y_train_tensor = torch.from_numpy(y_train_sub).float().to(device)
+        x_valid_tensor = torch.from_numpy(X_valid).float().to(device)
+        y_valid_tensor = torch.from_numpy(y_valid).float().to(device)
+        x_test_tensor = torch.from_numpy(X_test).float().to(device)
+        y_test_tensor = torch.from_numpy(y_test).float().to(device)
+        
+        train_data = TensorDataset(x_train_tensor, y_train_tensor)
+        valid_data = TensorDataset(x_valid_tensor, y_valid_tensor)
+        test_data = TensorDataset(x_test_tensor, y_test_tensor)
+
+        train_loader = DataLoader(train_data, batch_size, shuffle=True)
+        valid_loader = DataLoader(valid_data, batch_size, shuffle=False)
+        test_loader = DataLoader(test_data, batch_size, shuffle=False)
+
+        model = AlexNet()
+        model.train_model(train_loader, valid_loader, num_round, learning_rate, patience, device)
+        y_pred = model.predict(test_loader)
+
+        mse = mean_squared_error(y_test, y_pred)
+        r2 = r2_score(y_test, y_pred)
+        mae = mean_absolute_error(y_test, y_pred)
+        pcc, _ = pearsonr(y_test, y_pred)
+
+        if np.isnan(pcc):
+            print(f"Fold {fold} resulted in NaN PCC, pruning the trial...")
+            raise TrialPruned()
+
+        all_mse.append(mse)
+        all_r2.append(r2)
+        all_mae.append(mae)
+        all_pcc.append(pcc)
+
+        fold_time = time.time() - fold_start_time
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        print(f'Fold {fold}:  Corr={pcc:.4f}, MAE={mae:.4f}, MSE={mse:.4f}, R2={r2:.4f}, Time={fold_time:.2f}s, '
+                f'CPU={fold_cpu_mem:.2f}MB')
+        
+    return np.mean(all_pcc) if all_pcc else 0.0
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def Hyperparameter(data, label, nsnp):
+    set_seed(42)
+    def objective(trial):
+        learning_rate = trial.suggest_loguniform("learning_rate", 1e-4,0.1)
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128])
+        patience = trial.suggest_int("patience", 1, 10)
+        try:
+            corr_score = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                nsnp=nsnp,
+                learning_rate=learning_rate,
+                patience=patience,
+                batch_size=batch_size
+            )
+        
+        except TrialPruned:
+            return float("-inf")
+        return corr_score
+    
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+
+    print("best params:", study.best_params)
+    print("successfully")
+    return study.best_params

gpbench/method_reg/SoyDNGP/__init__.py

@@ -0,0 +1,5 @@
+from .SoyDNGP import SoyDNGP_reg
+
+SoyDNGP = SoyDNGP_reg
+
+__all__ = ["SoyDNGP","SoyDNGP_reg"]

gpbench/method_reg/XGBoost/XGboost_GPU.py

@@ -0,0 +1,188 @@
+import os
+import time
+import torch
+import psutil
+import argparse
+import random
+import xgboost as xgb
+import numpy as np
+import pandas as pd
+import pynvml
+from sklearn.model_selection import KFold
+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
+from scipy.stats import pearsonr
+from . import XGboost_Hyperparameters
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser for XGBoost")
+    parser.add_argument('--methods', type=str, default='XGBoost/', help='Method name')
+    parser.add_argument('--species', type=str, default='Chickpea/GSTP012/', help='Species name')
+    parser.add_argument('--phe', type=str, default='', help='Dataset name')
+    parser.add_argument('--data_dir', type=str, default='../../data/')
+    parser.add_argument('--result_dir', type=str, default='result/')
+
+    parser.add_argument('--learning_rate', type=float, default=0.1)
+    parser.add_argument('--n_estimators', type=int, default=100)
+    parser.add_argument('--max_depth', type=int, default=6)
+    parser.add_argument('--min_child_weight', type=int, default=1)
+    parser.add_argument('--subsample', type=float, default=0.8)
+    parser.add_argument('--colsample_bytree', type=float, default=0.8)
+    parser.add_argument('--gamma', type=float, default=0)
+    parser.add_argument('--reg_alpha', type=float, default=0)
+    parser.add_argument('--reg_lambda', type=float, default=1)
+    parser.add_argument('--use_gpu', type=bool, default=True, help='Whether to use GPU acceleration')  # 新增参数
+    args = parser.parse_args()
+    return args
+
+def load_data(args):
+    xData = np.load(os.path.join(args.data_dir, args.species, 'genotype.npz'))["arr_0"]
+    yData = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_0"]
+    names = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_1"]
+
+    nsample = xData.shape[0]
+    nsnp = xData.shape[1]
+    print("Number of samples: ", nsample)
+    print("Number of SNPs: ", nsnp)
+    return xData, yData, nsample, nsnp, names
+
+def get_gpu_mem_by_pid(pid):
+    procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
+    for p in procs:
+        if p.pid == pid:
+            return p.usedGpuMemory / 1024**2
+    return 0.0
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def run_nested_cv(args, data, label):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+    os.makedirs(result_dir, exist_ok=True)
+    print("Starting 10-fold cross-validation with XGBoost...")
+    use_gpu = args.use_gpu and torch.cuda.is_available()
+    if use_gpu:
+        print("🚀 GPU XGBoost (XGBoost 2.0+ API)")
+        tree_method = 'hist'
+        device = 'cuda:0' 
+    else:
+        print("⚠ CPU")
+        tree_method = 'hist'
+        device = 'cpu'
+    
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_mse, all_mae, all_r2, all_pcc = [], [], [], []
+    time_star = time.time()
+
+    for fold, (train_index, test_index) in enumerate(kf.split(data)):
+        print(f"Running fold {fold}...")
+        fold_start_time = time.time()
+        process = psutil.Process(os.getpid())
+
+        
+        x_train, x_test = data[train_index], data[test_index]
+        y_train, y_test = label[train_index], label[test_index]
+
+        model = xgb.XGBRegressor(
+            learning_rate=args.learning_rate,
+            n_estimators=args.n_estimators,
+            max_depth=args.max_depth,
+            min_child_weight=args.min_child_weight,
+            subsample=args.subsample,
+            colsample_bytree=args.colsample_bytree,
+            gamma=args.gamma,
+            reg_alpha=args.reg_alpha,
+            reg_lambda=args.reg_lambda,
+            objective='reg:squarederror',
+            eval_metric='rmse',
+            random_state=42,
+
+            tree_method=tree_method,   
+            device=device, 
+            n_jobs=-1,     
+        )
+
+        model.fit(x_train, y_train)
+
+        y_test_preds = model.predict(x_test)
+        y_pred = y_test_preds.reshape(-1)
+        y_test_original = y_test.reshape(-1)
+    
+        mse = mean_squared_error(y_test_original, y_pred)
+        r2 = r2_score(y_test_original, y_pred)
+        mae = mean_absolute_error(y_test_original, y_pred)
+        pcc, _ = pearsonr(y_test_original, y_pred)
+
+        all_mse.append(mse)
+        all_r2.append(r2)
+        all_mae.append(mae)
+        all_pcc.append(pcc)
+
+        fold_time = time.time() - fold_start_time
+        fold_gpu_mem = get_gpu_mem_by_pid(os.getpid()) if use_gpu else 0.0
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        
+        acceleration_status = "GPU" if use_gpu else "CPU"
+        print(f'Fold {fold}[{acceleration_status}]: Corr={pcc:.4f}, MAE={mae:.4f}, MSE={mse:.4f}, R2={r2:.4f}, Time={fold_time:.2f}s, '
+              f'GPU={fold_gpu_mem:.2f}MB, CPU={fold_cpu_mem:.2f}MB')
+        
+        results_df = pd.DataFrame({'Y_test': y_test, 'Y_pred': y_test_preds})
+        results_df.to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+    print("\n===== Cross-validation summary =====")
+    print(f"Average PCC: {np.mean(all_pcc):.4f} ± {np.std(all_pcc):.4f}")
+    print(f"Average MAE: {np.mean(all_mae):.4f} ± {np.std(all_mae):.4f}")
+    print(f"Average MSE: {np.mean(all_mse):.4f} ± {np.std(all_mse):.4f}")
+    print(f"Average R2 : {np.mean(all_r2):.4f} ± {np.std(all_r2):.4f}")
+    print(f"Time: {time.time() - time_star:.2f}s")
+
+
+def XGBoost_reg():
+    set_seed(42)
+    pynvml.nvmlInit()
+    handle = pynvml.nvmlDeviceGetHandleByIndex(0)  
+    args = parse_args()
+    all_species =['Cotton/']
+    
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        os.makedirs(args.result_dir + args.methods + args.species + args.phe, exist_ok=True)
+        X, Y, nsamples, nsnp, names = load_data(args)
+        
+        for j in range(len(names)):
+            args.phe = names[j]
+            print("starting run " + args.methods + args.species + args.phe)
+            label = Y[:, j]
+            label = np.nan_to_num(label, nan=np.nanmean(label))
+
+            best_params = XGboost_Hyperparameters.Hyperparameter(X, label)
+            args.learning_rate =best_params['learning_rate']
+            args.n_estimators = best_params['n_estimators']
+            args.max_depth = best_params['max_depth']
+            args.subsample = best_params['subsample']
+            args.colsample_bytree = best_params['colsample_bytree']
+            args.gamma = best_params['gamma']
+            args.reg_alpha = best_params['reg_alpha']
+            args.reg_lambda = best_params['reg_lambda']
+
+            start_time = time.time()
+            if torch.cuda.is_available():
+                torch.cuda.reset_peak_memory_stats()
+            process = psutil.Process(os.getpid())
+
+            run_nested_cv(args, data=X, label=label)
+            
+            elapsed_time = time.time() - start_time
+            print(f"running time: {elapsed_time:.2f} s")
+            print("successfully")
+
+
+if __name__ == "__main__":
+    XGBoost_reg()

gpbench/method_reg/XGBoost/XGboost_Hyperparameters.py

@@ -0,0 +1,167 @@
+import os
+import random
+import torch
+import numpy as np
+import argparse
+from sklearn.model_selection import KFold
+from sklearn.preprocessing import StandardScaler
+import xgboost as xgb
+from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
+import optuna
+import cupy as cp
+
+def run_nested_cv_with_early_stopping(data, label, outer_cv, learning_rate, n_estimators, max_depth, min_child_weight, 
+                                      subsample, colsample_bytree, gamma, reg_alpha, reg_lambda, use_gpu=True):
+    best_corr_coefs = []
+    best_maes = []
+    best_r2s = []
+    best_mses = []
+
+    # 检查 GPU 可用性
+    gpu_available = torch.cuda.is_available() and use_gpu
+    
+    # 使用新的 XGBoost 2.0+ API
+    if gpu_available:
+        print("🚀 使用 GPU 加速 XGBoost (XGBoost 2.0+ API)")
+        tree_method = 'hist'  # 使用 hist 算法
+        device = 'cuda:0'     # 新的设备参数
+    else:
+        print("⚠ 使用 CPU 版本")
+        tree_method = 'hist'
+        device = 'cpu'
+
+    import time
+    time_star = time.time()
+    
+    for fold, (train_idx, test_idx) in enumerate(outer_cv.split(data)):
+        x_train, x_test = data[train_idx], data[test_idx]
+        y_train, y_test = label[train_idx], label[test_idx]
+
+        # # 标准化数据
+        # scaler = StandardScaler()
+        # x_train = scaler.fit_transform(x_train)
+        # x_test = scaler.transform(x_test)
+
+        # # ==== y 标准化 ====
+        # scaler_y = StandardScaler()
+        # y_train_scaled = scaler_y.fit_transform(y_train.reshape(-1, 1)).reshape(-1)
+        # y_test_scaled = scaler_y.transform(y_test.reshape(-1, 1)).reshape(-1)
+
+        # x_train = cp.asarray(x_train)  # 转换为cupy数组（GPU内存）
+        # y_train_scaled = cp.asarray(y_train_scaled)
+        # x_test = cp.asarray(x_test)  # 转换为cupy数组（GPU内存）
+        # y_test_scaled = cp.asarray(y_test_scaled)
+
+        # 初始化XGBoost模型 - 使用新的GPU参数设置 (XGBoost 2.0+)
+        model = xgb.XGBRegressor(
+            learning_rate=learning_rate,
+            n_estimators=n_estimators,
+            max_depth=max_depth,
+            min_child_weight=min_child_weight,
+            subsample=subsample,
+            colsample_bytree=colsample_bytree,
+            gamma=gamma,
+            reg_alpha=reg_alpha,
+            reg_lambda=reg_lambda,
+            objective='reg:squarederror',
+            early_stopping_rounds=50,
+            eval_metric='rmse',
+            random_state=42,
+            # ==== 新的 GPU 加速参数 (XGBoost 2.0+) ====
+            tree_method=tree_method,      # 使用 hist 算法
+            device=device,                # 新的设备参数：'cuda' 或 'cpu'
+            n_jobs=-1,                   # 使用所有CPU核心
+        )
+
+        # 训练模型
+        model.fit(x_train, 
+                  y_train,
+                eval_set=[(x_test, y_test)],
+                verbose=False)
+
+        # 预测
+        y_test_preds = model.predict(x_test)
+        # y_test_preds = scaler_y.inverse_transform(y_test_preds.reshape(-1, 1)).reshape(-1)
+        # y_test_trues = scaler_y.inverse_transform(y_test_scaled.reshape(-1, 1)).reshape(-1)
+        y_test_preds = y_test_preds.reshape(-1)
+        y_test_trues = y_test.reshape(-1)
+        # 计算评价指标
+        corr_coef = np.corrcoef(y_test_preds, y_test_trues)[0, 1]
+        mae = mean_absolute_error(y_test_trues, y_test_preds)
+        mse = mean_squared_error(y_test_trues, y_test_preds)
+        r2 = r2_score(y_test_trues, y_test_preds)
+
+        best_corr_coefs.append(corr_coef)
+        best_maes.append(mae)
+        best_r2s.append(r2)
+        best_mses.append(mse)
+
+        acceleration_status = "GPU" if gpu_available else "CPU"
+        print(f'Fold {fold + 1}[{acceleration_status}]: MAE={mae:.4f}, MSE={mse:.4f}, R2={r2:.4f}, Corr={corr_coef:.4f}')
+
+    print("==== Final Results ====")
+    print(f"加速方式: {'GPU' if gpu_available else 'CPU'}")
+    print(f"MAE: {np.mean(best_maes):.4f} ± {np.std(best_maes):.4f}")
+    print(f"MSE: {np.mean(best_mses):.4f} ± {np.std(best_mses):.4f}")
+    print(f"R2 : {np.mean(best_r2s):.4f} ± {np.std(best_r2s):.4f}")
+    print(f"Corr: {np.mean(best_corr_coefs):.4f} ± {np.std(best_corr_coefs):.4f}")
+
+    print(f"Time: {time.time() - time_star:.2f}s")
+    return np.mean(best_corr_coefs)
+
+# 设置随机种子
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def Hyperparameter(data, label, use_gpu=True):
+    set_seed(42)
+    
+    def objective(trial):
+        learning_rate = trial.suggest_float("learning_rate", 1e-2, 0.2)
+        n_estimators = trial.suggest_int("n_estimators", 50, 1000)
+        max_depth = trial.suggest_int("max_depth", 3, 10)
+        min_child_weight = trial.suggest_int("min_child_weight", 1, 10)
+        subsample = trial.suggest_float("subsample", 0.05, 1.0)
+        colsample_bytree = trial.suggest_float("colsample_bytree", 0.5, 1.0)
+        gamma = trial.suggest_float("gamma", 0, 10)
+        reg_alpha = trial.suggest_float("reg_alpha", 1e-3, 10, log=True)
+        reg_lambda = trial.suggest_float("reg_lambda",1e-3, 10, log=True)
+
+        outer_cv = KFold(n_splits=10, shuffle=True, random_state=42)
+
+        corr_score = run_nested_cv_with_early_stopping(
+            data=data,
+            label=label,
+            outer_cv=outer_cv,
+            learning_rate=learning_rate,
+            n_estimators=n_estimators,
+            max_depth=max_depth,
+            min_child_weight=min_child_weight,
+            subsample=subsample,
+            colsample_bytree=colsample_bytree,
+            gamma=gamma,
+            reg_alpha=reg_alpha,
+            reg_lambda=reg_lambda,
+            use_gpu=use_gpu
+        )
+        return corr_score
+
+    # 运行Optuna超参数优化
+    study = optuna.create_study(direction="maximize")
+    
+    # 添加GPU信息到study
+    study.set_user_attr('gpu_available', torch.cuda.is_available())
+    study.set_user_attr('using_gpu', use_gpu and torch.cuda.is_available())
+    study.set_user_attr('xgboost_version', xgb.__version__)
+    
+    study.optimize(objective, n_trials=20)
+
+    print("最佳参数:", study.best_params)
+    print(f"优化完成 - 使用 {'GPU' if (use_gpu and torch.cuda.is_available()) else 'CPU'}")
+    return study.best_params

gpbench/method_reg/XGBoost/__init__.py

@@ -0,0 +1,5 @@
+from .XGboost_GPU import XGBoost_reg
+
+XGBoost = XGBoost_reg
+
+__all__ = ["XGBoost","XGBoost_reg"]