gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/SoyDNGP/SoyDNGP_he_class.py

@@ -0,0 +1,112 @@
+import os
+import time
+import psutil
+import random
+import torch
+import numpy as np
+import optuna
+from sklearn.model_selection import StratifiedKFold, train_test_split
+from .AlexNet_206_class import AlexNet
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from torch.utils.data import DataLoader, TensorDataset
+from optuna.exceptions import TrialPruned 
+
+def run_nested_cv_with_early_stopping(data, label, nsnp, num_classes, learning_rate, patience, batch_size, num_round=300):
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("Starting 10-fold cross-validation...")
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    
+    for fold, (train_index, test_index) in enumerate(kf.split(data, label)):
+        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, stratify=y_train, random_state=42
+        )
+
+        x_train_tensor = torch.from_numpy(X_train_sub).float().to(device)
+        y_train_tensor = torch.from_numpy(y_train_sub).long().to(device)
+        x_valid_tensor = torch.from_numpy(X_valid).float().to(device)
+        y_valid_tensor = torch.from_numpy(y_valid).long().to(device)
+        x_test_tensor = torch.from_numpy(X_test).float().to(device)
+        y_test_tensor = torch.from_numpy(y_test).long().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(num_classes=num_classes)
+        model.train_model(train_loader, valid_loader, num_round, learning_rate, patience, device)
+        y_pred = model.predict(test_loader)
+
+        acc = accuracy_score(y_test, y_pred)
+        prec, rec, f1, _ = precision_recall_fscore_support(
+            y_test, y_pred, average="macro", zero_division=0
+        )
+
+        if np.isnan(f1) or f1 <= 0:
+            print(f"Fold {fold} resulted in NaN or zero F1, pruning the trial...")
+            raise TrialPruned()
+        
+        all_acc.append(acc)
+        all_prec.append(prec)
+        all_rec.append(rec)
+        all_f1.append(f1)
+
+        fold_time = time.time() - fold_start_time
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        print(f'Fold {fold}:  ACC={acc:.4f}, PREC={prec:.4f}, REC={rec:.4f}, F1={f1:.4f}, '
+              f'Time={fold_time:.2f}s, CPU={fold_cpu_mem:.2f}MB')
+        
+    print("\n===== CV Summary =====")
+    print(f"ACC : {np.mean(all_acc):.4f} ± {np.std(all_acc):.4f}")
+    print(f"PREC: {np.mean(all_prec):.4f} ± {np.std(all_prec):.4f}")
+    print(f"REC : {np.mean(all_rec):.4f} ± {np.std(all_rec):.4f}")
+    print(f"F1  : {np.mean(all_f1):.4f} ± {np.std(all_f1):.4f}")
+        
+    return float(np.mean(all_f1)) if all_f1 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, num_classes):
+    set_seed(42)
+    def objective(trial):
+        learning_rate = trial.suggest_float("learning_rate", 1e-4, 0.1, log=True)
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128])
+        patience = trial.suggest_int("patience", 10, 100, step=10)
+        try:
+            f1_score = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                nsnp=nsnp,
+                num_classes=num_classes,
+                learning_rate=learning_rate,
+                patience=patience,
+                batch_size=batch_size
+            )
+        except TrialPruned:
+            return float("-inf")
+        return f1_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_class/SoyDNGP/__init__.py

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

gpbench/method_class/XGBoost/XGboost_GPU_class.py

@@ -0,0 +1,198 @@
+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
+import swanlab
+
+from sklearn.model_selection import StratifiedKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+from . import XGboost_GPU_he_class
+
+# =======================
+# Argument parser
+# =======================
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--methods', type=str, default='XGBoost/')
+    parser.add_argument('--species', type=str, default='Horse/')
+    parser.add_argument('--phe', type=str, default='')
+    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=200)
+    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', action='store_true')
+    return parser.parse_args()
+
+def load_data(args):
+    X = np.load(os.path.join(args.data_dir, args.species, 'genotype.npz'))["arr_0"]
+    Y = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_0"]
+    print(f"Samples: {X.shape[0]}, SNPs: {X.shape[1]}")
+    return X, Y
+
+def get_gpu_mem_by_pid(pid, handle):
+    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_cv(args, X, label):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+    os.makedirs(result_dir, exist_ok=True)
+    le = LabelEncoder()
+    y_all = le.fit_transform(label)
+    np.save(os.path.join(result_dir, 'label_mapping.npy'), le.classes_)
+    num_classes = len(np.unique(y_all))
+
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    # ===== GPU / CPU =====
+    use_gpu = args.use_gpu and torch.cuda.is_available()
+    if use_gpu:
+        tree_method = "hist"
+        device = "cuda:0"
+        print("🚀 Using GPU XGBoost")
+    else:
+        tree_method = "hist"
+        device = "cpu"
+        print("⚠ Using CPU XGBoost")
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    start_time = time.time()
+    process = psutil.Process(os.getpid())
+
+    for fold, (train_idx, test_idx) in enumerate(kf.split(X, y_all)):
+        print(f"\n===== Fold {fold} =====")
+        fold_start = time.time()
+
+        X_train, X_test = X[train_idx], X[test_idx]
+        y_train, y_test = y_all[train_idx], y_all[test_idx]
+
+        # ===== Objective =====
+        if num_classes == 2:
+            objective = "binary:logistic"
+            eval_metric = "logloss"
+        else:
+            objective = "multi:softprob"
+            eval_metric = "mlogloss"
+
+        model = xgb.XGBClassifier(
+            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=objective,
+            eval_metric=eval_metric,
+            num_class=num_classes if num_classes > 2 else None,
+            tree_method=tree_method,
+            device=device,
+            random_state=42,
+            n_jobs=-1
+        )
+
+        model.fit(X_train, y_train)
+
+        # ===== Prediction =====
+        y_proba = model.predict_proba(X_test)
+        y_pred = np.argmax(y_proba, axis=1)
+
+        # ===== Metrics =====
+        acc = accuracy_score(y_test, y_pred)
+        prec, rec, f1, _ = precision_recall_fscore_support(
+            y_test, y_pred, average="macro", zero_division=0
+        )
+
+        all_acc.append(acc)
+        all_prec.append(prec)
+        all_rec.append(rec)
+        all_f1.append(f1)
+
+        fold_time = time.time() - fold_start
+        gpu_mem = get_gpu_mem_by_pid(os.getpid(), handle) if use_gpu else 0.0
+        cpu_mem = process.memory_info().rss / 1024**2
+
+        print(
+            f"ACC={acc:.4f}, PREC={prec:.4f}, REC={rec:.4f}, "
+            f"F1={f1:.4f},  Time={fold_time:.2f}s"
+        )
+
+        df = pd.DataFrame({
+            "Y_test": le.inverse_transform(y_test),
+            "Y_pred": le.inverse_transform(y_pred)
+        })
+        df.to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+    print("\n===== CV Summary =====")
+    print(f"ACC : {np.mean(all_acc):.4f} ± {np.std(all_acc):.4f}")
+    print(f"PREC: {np.mean(all_prec):.4f} ± {np.std(all_prec):.4f}")
+    print(f"REC : {np.mean(all_rec):.4f} ± {np.std(all_rec):.4f}")
+    print(f"F1  : {np.mean(all_f1):.4f} ± {np.std(all_f1):.4f}")
+    print(f"Total Time: {time.time() - start_time:.2f}s")
+
+
+def XGBoost_class():
+    set_seed(42)
+    pynvml.nvmlInit()
+    handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+
+    args = parse_args()
+
+    all_species = ["Human/Sim/"] 
+    for species in all_species:
+        args.species = species
+        X, Y = load_data(args)
+        print(f"\n=== Running {args.methods}{args.species}{args.phe} ===")
+        label = Y[:, 0]
+
+        best_params = XGboost_GPU_he_class.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']
+        args.min_child_weight = best_params['min_child_weight']
+        
+        start_time = time.time()
+        run_cv(args, X, label)
+        
+        elapsed_time = time.time() - start_time
+        print(f"Total running time: {elapsed_time:.2f} s")
+        print("✔ Finished successfully")
+
+
+if __name__ == "__main__":
+    XGBoost_class()

gpbench/method_class/XGBoost/XGboost_GPU_he_class.py

@@ -0,0 +1,178 @@
+import os
+import random
+import torch
+import numpy as np
+import argparse
+import time
+import optuna
+import xgboost as xgb
+
+from sklearn.model_selection import StratifiedKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import (
+    accuracy_score,
+    precision_recall_fscore_support
+)
+
+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_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
+):
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+
+    # ===== Encode labels =====
+    le = LabelEncoder()
+    y_all = le.fit_transform(label)
+    num_classes = len(np.unique(y_all))
+
+    # ===== GPU / CPU =====
+    gpu_available = torch.cuda.is_available() and use_gpu
+    if gpu_available:
+        tree_method = "hist"
+        device = "cuda:0"
+        print("🚀 使用 GPU 加速 XGBoost")
+    else:
+        tree_method = "hist"
+        device = "cpu"
+        print("⚠ 使用 CPU XGBoost")
+
+    start_time = time.time()
+
+    for fold, (train_idx, test_idx) in enumerate(outer_cv.split(data, y_all)):
+        X_train, X_test = data[train_idx], data[test_idx]
+        y_train, y_test = y_all[train_idx], y_all[test_idx]
+
+        if num_classes == 2:
+            objective = "binary:logistic"
+            eval_metric = "logloss"
+            num_class_param = None
+        else:
+            objective = "multi:softprob"
+            eval_metric = "mlogloss"
+            num_class_param = num_classes
+
+        model = xgb.XGBClassifier(
+            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=objective,
+            eval_metric=eval_metric,
+            num_class=num_class_param,
+            early_stopping_rounds=50,
+            random_state=42,
+            tree_method=tree_method,
+            device=device,
+            n_jobs=-1
+        )
+
+        model.fit(
+            X_train,
+            y_train,
+            eval_set=[(X_test, y_test)],
+            verbose=False
+        )
+
+        # ===== Prediction =====
+        y_proba = model.predict_proba(X_test)
+        y_pred = np.argmax(y_proba, axis=1)
+
+        # ===== Metrics =====
+        acc = accuracy_score(y_test, y_pred)
+        prec, rec, f1, _ = precision_recall_fscore_support(
+            y_test,
+            y_pred,
+            average="macro",
+            zero_division=0
+        )
+
+        all_acc.append(acc)
+        all_prec.append(prec)
+        all_rec.append(rec)
+        all_f1.append(f1)
+
+        accel = "GPU" if gpu_available else "CPU"
+        print(
+            f"Fold {fold + 1}[{accel}]: "
+            f"ACC={acc:.4f}, "
+            f"PREC={prec:.4f}, "
+            f"REC={rec:.4f}, "
+            f"F1={f1:.4f}"
+        )
+
+    print("\n==== Final Results ====")
+    print(f"ACC : {np.mean(all_acc):.4f} ± {np.std(all_acc):.4f}")
+    print(f"PREC: {np.mean(all_prec):.4f} ± {np.std(all_prec):.4f}")
+    print(f"REC : {np.mean(all_rec):.4f} ± {np.std(all_rec):.4f}")
+    print(f"F1  : {np.mean(all_f1):.4f} ± {np.std(all_f1):.4f}")
+    print(f"Time: {time.time() - start_time:.2f}s")
+
+    return np.mean(all_f1)
+
+def Hyperparameter(data, label, use_gpu=True):
+    set_seed(42)
+
+    def objective(trial):
+        params = {
+            "learning_rate": trial.suggest_float("learning_rate", 1e-2, 0.3),
+            "n_estimators": trial.suggest_int("n_estimators", 50, 800),
+            "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.5, 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 = StratifiedKFold(
+            n_splits=10, shuffle=True, random_state=42
+        )
+
+        f1_mean = run_nested_cv_with_early_stopping(
+            data=data,
+            label=label,
+            outer_cv=outer_cv,
+            use_gpu=use_gpu,
+            **params
+        )
+        return f1_mean
+
+    study = optuna.create_study(direction="maximize")
+
+    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("\n===== Optuna Result =====")
+    print("Best F1:", study.best_value)
+    print("Best params:", study.best_params)
+
+    return study.best_params

gpbench/method_class/XGBoost/__init__.py

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

gpbench/method_class/__init__.py

@@ -0,0 +1,52 @@
+
+#==============================================================
+#使用示例:
+#import method_class
+#print(method_class.METHODS)
+#m = method_class.load_method("BayesA")
+#print(m)  # method_class.BayesA
+
+#或
+
+#from method_class.BayesA import BayesA_class
+#BayesA_class()
+#==============================================================
+from __future__ import annotations
+import importlib
+from typing import List
+
+METHODS: List[str] = [
+    "BayesA",
+    "BayesB",
+    "BayesC",
+    "LightGBM",
+    "CropARNet",
+    "Cropformer",
+    "DeepCCR",
+    "DeepGS",
+    "DNNGP",
+    "EIR",
+    "G2PDeep",
+    "GBLUP",
+    "GEFormer",
+    "RF",
+    "rrBLUP",
+    "SoyDNGP",
+    "SVC",
+    "XGBoost",
+    "ElasticNet",
+    "DL_GWAS"
+]
+
+__all__ = ["METHODS", "load_method"]
+
+def load_method(name: str):
+    """
+    动态加载某个方法子包并返回该子包模块对象
+    用法:
+      m = method_class.load_method("BayesA")
+      # m 里面就是 method_class.BayesA 包
+    """
+    if name not in METHODS:
+        raise ValueError(f"Unknown method '{name}'. Available: {METHODS}")
+    return importlib.import_module(f"{__name__}.{name}")

gpbench/method_class/rrBLUP/__init__.py

@@ -0,0 +1,5 @@
+from .rrBLUP_class import rrBLUP_class
+
+rrBLUP = rrBLUP_class
+
+__all__ = ["rrBLUP","rrBLUP_class"]

gpbench/method_class/rrBLUP/rrBLUP_class.py

@@ -0,0 +1,140 @@
+import os
+import time
+import psutil
+import swanlab
+import argparse
+import random
+import torch
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import StratifiedKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+from rpy2.robjects.packages import importr
+from rpy2.robjects import pandas2ri
+pandas2ri.activate()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser")
+    parser.add_argument('--methods', type=str, default='rrBLUP/', help='Method name')
+    parser.add_argument('--species', type=str, default='', help='Species name')
+    parser.add_argument('--data_dir', type=str, default='../../data/')
+    parser.add_argument('--result_dir', type=str, default='result/')
+    return parser.parse_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 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 run_nested_cv(args, data, label):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species)
+    os.makedirs(result_dir, exist_ok=True)
+    rrblup = importr('rrBLUP')
+    print("Successfully loaded rrBLUP")
+
+    print("Starting 10-fold cross-validation...")
+    skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+    le = LabelEncoder()
+    label_all = le.fit_transform(label)
+
+    np.save(os.path.join(result_dir, 'label_mapping.npy'), le.classes_)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    start_time = time.time()
+    process = psutil.Process(os.getpid())
+
+    for fold, (train_index, test_index) in enumerate(skf.split(data, label_all)):
+        fold_start = time.time()
+        print(f"\n===== Fold {fold} =====")
+        X_train, X_test = data[train_index], data[test_index]
+        Y_train, Y_test = label_all[train_index], label_all[test_index]
+
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+
+        classes = np.unique(Y_train)
+        scores = np.zeros((len(classes), X_test.shape[0]))
+        for idx, cls in enumerate(classes):
+            y_train_bin = (Y_train == cls).astype(float)
+            model = rrblup.mixed_solve(y=y_train_bin, Z=X_train)
+            beta = np.array(model.rx2('beta')).flatten()
+            u = np.array(model.rx2('u')).flatten()
+            y_pred = np.dot(X_test, u) + beta
+            scores[idx, :] = y_pred
+
+        Y_pred = np.argmax(scores, axis=0)
+        acc = accuracy_score(Y_test, Y_pred)
+        prec, rec, f1, _ = precision_recall_fscore_support(Y_test, Y_pred, average='macro', zero_division=0)
+        cm = confusion_matrix(Y_test, Y_pred)
+
+        all_acc.append(acc)
+        all_prec.append(prec)
+        all_rec.append(rec)
+        all_f1.append(f1)
+
+        fold_time = time.time() - fold_start
+        fold_gpu_mem = torch.cuda.max_memory_allocated() / 1024**2 if torch.cuda.is_available() else 0
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+        print(f'Fold {fold}: ACC={acc:.4f}, PREC={prec:.4f}, REC={rec:.4f}, F1={f1:.4f}, '
+              f'Time={fold_time:.2f}s, GPU={fold_gpu_mem:.2f}MB, CPU={fold_cpu_mem:.2f}MB')
+
+        Y_test_orig = le.inverse_transform(Y_test)
+        Y_pred_orig = le.inverse_transform(Y_pred)
+        results_df = pd.DataFrame({'Y_test': Y_test_orig, 'Y_pred': Y_pred_orig})
+        results_df.to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+    print("\n===== Cross-validation summary =====")
+    print(f"Average ACC: {np.mean(all_acc):.4f} ± {np.std(all_acc):.4f}")
+    print(f"Average PREC: {np.mean(all_prec):.4f} ± {np.std(all_prec):.4f}")
+    print(f"Average REC: {np.mean(all_rec):.4f} ± {np.std(all_rec):.4f}")
+    print(f"Average F1 : {np.mean(all_f1):.4f} ± {np.std(all_f1):.4f}")
+    print(f"Total time : {time.time() - start_time:.2f}s")
+
+
+def rrBLUP_class():
+    set_seed(42)
+    torch.cuda.empty_cache()
+    args = parse_args()
+
+    all_species = ["Human/Sim/"]
+
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        X, Y, nsamples, nsnp, names = load_data(args)
+        print("Starting run " + args.methods + args.species)
+        label = Y[:, 0]
+
+        s = pd.Series(label)
+        fill_val = s.mode().iloc[0] if not s.dropna().empty else 0
+        label = np.nan_to_num(label, nan=fill_val)
+
+        start_time = time.time()
+        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"Total running time: {elapsed_time:.2f} s")
+        print("Successfully finished!")
+
+
+if __name__ == "__main__":
+    rrBLUP_class()