gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/LightGBM/LightGBM_class.py

@@ -0,0 +1,224 @@
+import os
+import time
+import psutil
+import swanlab
+import argparse
+import random
+import torch
+import pandas as pd
+import numpy as np
+import lightgbm as lgb
+import subprocess
+import threading
+import queue
+
+from sklearn.model_selection import StratifiedKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+from . import LightGBM_he_class
+
+class GPUMonitor:
+    def __init__(self, gpu_id=0, interval=0.2):
+        self.gpu_id = gpu_id
+        self.interval = interval
+        self.max_memory = 0
+        self.current_memory = 0
+        self.monitoring = False
+        self.pid = os.getpid()
+
+    def _get_gpu_memory_by_pid(self):
+        try:
+            result = subprocess.check_output([
+                'nvidia-smi',
+                '--query-compute-apps=pid,used_memory',
+                '--format=csv,nounits,noheader'
+            ])
+            lines = result.decode().strip().split('\n')
+            for line in lines:
+                pid, mem = line.split(',')
+                if int(pid.strip()) == self.pid:
+                    return int(mem.strip())
+            return 0
+        except Exception:
+            return 0
+
+    def _monitor_loop(self):
+        while self.monitoring:
+            mem = self._get_gpu_memory_by_pid()
+            self.current_memory = mem
+            self.max_memory = max(self.max_memory, mem)
+            time.sleep(self.interval)
+
+    def start(self):
+        self.max_memory = 0
+        self.monitoring = True
+        self.thread = threading.Thread(target=self._monitor_loop, daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        self.monitoring = False
+        self.thread.join(timeout=1)
+        return self.max_memory
+gpu_monitor = GPUMonitor()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--methods', type=str, default='LightGBM/')
+    parser.add_argument('--species', type=str, default='')
+    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.01)
+    parser.add_argument('--num_leaves', type=int, default=31)
+    parser.add_argument('--min_data_in_leaf', type=int, default=20)
+    parser.add_argument('--max_depth', type=int, default=-1)
+    parser.add_argument('--lambda_l1', type=float, default=0.0)
+    parser.add_argument('--lambda_l2', type=float, default=0.0)
+    parser.add_argument('--min_gain_to_split', type=float, default=0.0)
+    parser.add_argument('--feature_fraction', type=float, default=0.9)
+    parser.add_argument('--bagging_fraction', type=float, default=0.9)
+    parser.add_argument('--bagging_freq', type=int, default=1)
+    parser.add_argument('--num_boost_round', type=int, default=200)
+
+    return parser.parse_args()
+
+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 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"]
+    return X, Y
+
+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)
+
+    le = LabelEncoder()
+    y_all = le.fit_transform(label)
+    n_classes = len(np.unique(y_all))
+
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    process = psutil.Process(os.getpid())
+
+    params = {
+        'objective': 'binary' if n_classes == 2 else 'multiclass',
+        'metric': 'binary_logloss' if n_classes == 2 else 'multi_logloss',
+        'num_class': n_classes if n_classes > 2 else None,
+        'learning_rate': args.learning_rate,
+        'num_leaves': args.num_leaves,
+        'min_data_in_leaf': args.min_data_in_leaf,
+        'max_depth': args.max_depth,
+        'lambda_l1': args.lambda_l1,
+        'lambda_l2': args.lambda_l2,
+        'min_gain_to_split': args.min_gain_to_split,
+        'feature_fraction': args.feature_fraction,
+        'bagging_fraction': args.bagging_fraction,
+        'bagging_freq': args.bagging_freq,
+        'device_type': 'gpu',
+        'gpu_device_id': 0,
+        'num_threads': 8,
+        'verbose': -1
+    }
+
+    for fold, (train_idx, test_idx) in enumerate(kf.split(data, y_all)):
+        print(f"\n===== Fold {fold} =====")
+        start_time = time.time()
+
+        gpu_monitor.start()
+        cpu_mem_before = process.memory_info().rss / 1024**2
+
+        X_train, X_test = data[train_idx], data[test_idx]
+        y_train, y_test = y_all[train_idx], y_all[test_idx]
+
+        train_set = lgb.Dataset(X_train, label=y_train)
+        test_set = lgb.Dataset(X_test, label=y_test)
+
+        model = lgb.train(
+            params,
+            train_set,
+            num_boost_round=args.num_boost_round,
+            valid_sets=[test_set]
+        )
+
+        y_prob = model.predict(X_test)
+        if n_classes == 2:
+            y_pred = (y_prob > 0.5).astype(int)
+        else:
+            y_pred = np.argmax(y_prob, axis=1)
+
+        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() - start_time
+        gpu_mem = gpu_monitor.stop()
+        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, "
+            f"GPU={gpu_mem:.2f}MB, CPU={cpu_mem:.2f}MB"
+        )
+
+        pd.DataFrame({
+            "Y_test": le.inverse_transform(y_test),
+            "Y_pred": le.inverse_transform(y_pred)
+        }).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}")
+
+
+def LightGBM_class():
+    set_seed(42)
+    args = parse_args()
+
+    all_species = ["Human/Sim/"]
+
+    for species in all_species:
+        args.species = species
+        X, Y = load_data(args)
+        label = Y[:, 0]
+
+        best_params = LightGBM_he_class.Hyperparameter(X, label)
+        args.learning_rate = best_params['learning_rate']
+        args.num_leaves = best_params['num_leaves']
+        args.min_data_in_leaf = best_params['min_data_in_leaf']
+        args.max_depth = best_params['max_depth']
+        args.lambda_l1 = best_params['lambda_l1']
+        args.lambda_l2 = best_params['lambda_l2']
+        args.min_gain_to_split = best_params['min_gain_to_split']
+        args.feature_fraction = best_params['feature_fraction']
+        args.bagging_fraction = best_params['bagging_fraction']
+        args.bagging_freq = best_params['bagging_freq']
+        
+        start_time = time.time()
+        run_nested_cv(args, X, label)
+        elapsed_time = time.time() - start_time
+        print(f"Running time: {elapsed_time:.2f}s")
+        print("successfully")
+
+
+if __name__ == "__main__":
+    LightGBM_class()

gpbench/method_class/LightGBM/LightGBM_he_class.py

@@ -0,0 +1,121 @@
+import random
+import torch
+import numpy as np
+import lightgbm as lgb
+import optuna
+
+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)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def run_cv_eval(data, label, params):
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    le = LabelEncoder()
+    y_all = le.fit_transform(label)
+    n_classes = len(np.unique(y_all))
+
+    accs, precs, recs, f1s = [], [], [], []
+
+    for fold, (train_idx, test_idx) in enumerate(kf.split(data, y_all)):
+        print(f"===== Fold {fold+1} =====")
+
+        X_train, X_test = data[train_idx], data[test_idx]
+        y_train, y_test = y_all[train_idx], y_all[test_idx]
+
+        train_set = lgb.Dataset(X_train, label=y_train)
+        valid_set = lgb.Dataset(X_test, label=y_test)
+
+
+        model = lgb.train(
+            params,
+            train_set,
+            valid_sets=[valid_set],
+            num_boost_round=100,
+        )
+
+        y_prob = model.predict(X_test)
+
+        # ===== binary / multiclass safe =====
+        if n_classes == 2:
+            y_pred = (y_prob > 0.5).astype(int)
+        else:
+            y_pred = np.argmax(y_prob, axis=1)
+
+        acc = accuracy_score(y_test, y_pred)
+        prec, rec, f1, _ = precision_recall_fscore_support(
+            y_test,
+            y_pred,
+            average="macro",
+            zero_division=0
+        )
+
+        accs.append(acc)
+        precs.append(prec)
+        recs.append(rec)
+        f1s.append(f1)
+
+        print(
+            f"Fold {fold+1}: "
+            f"ACC={acc:.4f}, "
+            f"PREC={prec:.4f}, "
+            f"REC={rec:.4f}, "
+            f"F1={f1:.4f}"
+        )
+
+    return (
+        np.mean(accs),
+        np.mean(precs),
+        np.mean(recs),
+        np.mean(f1s)
+    )
+
+def Hyperparameter(X, label):
+    set_seed(42)
+    torch.cuda.empty_cache()
+
+    n_classes = len(np.unique(label))
+
+    def objective(trial):
+        params = {
+            'objective': 'binary' if n_classes == 2 else 'multiclass',
+            'metric': 'multi_logloss' if n_classes > 2 else 'binary_logloss',
+            'num_class': n_classes if n_classes > 2 else None,
+
+            'learning_rate': trial.suggest_float('learning_rate', 1e-3, 0.2, log=True),
+            'num_leaves': trial.suggest_int('num_leaves', 15, 255),
+            'min_data_in_leaf': trial.suggest_int('min_data_in_leaf', 10, 100),
+            'max_depth': trial.suggest_int('max_depth', 3, 10),
+            'lambda_l1': trial.suggest_float('lambda_l1', 0.0, 5.0),
+            'lambda_l2': trial.suggest_float('lambda_l2', 0.0, 5.0),
+            'min_gain_to_split': trial.suggest_float('min_gain_to_split', 0.0, 5.0),
+            'feature_fraction': trial.suggest_float('feature_fraction', 0.6, 1.0),
+            'bagging_fraction': trial.suggest_float('bagging_fraction', 0.6, 1.0),
+            'bagging_freq': trial.suggest_int('bagging_freq', 0, 10),
+
+            'num_boost_round': trial.suggest_int('num_boost_round', 100, 1000),
+
+            'device_type': 'gpu',
+            'gpu_device_id': 1,
+            'num_threads': 8,
+            'verbosity': -1
+        }
+
+        acc, prec, rec, f1 = run_cv_eval(X, label, params)
+
+        # ===== optimize macro-F1 =====
+        return f1
+
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+    print("Best macro-F1:", study.best_value)
+
+    return study.best_params

gpbench/method_class/LightGBM/__init__.py

@@ -0,0 +1,5 @@
+from .LightGBM_class import LightGBM_class
+
+LightGBM = LightGBM_class
+
+__all__ = ["LightGBM","LightGBM_class"]

gpbench/method_class/RF/RF_GPU_class.py

@@ -0,0 +1,165 @@
+import os
+import time
+import psutil
+import pynvml
+import argparse
+import random
+import torch
+import pandas as pd
+import numpy as np
+import swanlab
+import cupy as cp
+
+from sklearn.preprocessing import LabelEncoder
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from . import RF_GPU_he_class
+
+try:
+    from cuml.ensemble import RandomForestClassifier as cuRFClassifier
+    GPU_AVAILABLE = True
+except ImportError:
+    from sklearn.ensemble import RandomForestClassifier
+    GPU_AVAILABLE = False
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--methods', type=str, default='RF/')
+    parser.add_argument('--species', type=str, default='')
+    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('--n_estimators', type=int, default=200)
+    parser.add_argument('--max_depth', type=int, default=10)
+    parser.add_argument('--use_gpu', type=bool, default=True)
+    return parser.parse_args()
+
+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)
+
+
+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']
+    return X, Y
+
+
+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_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)
+    num_classes = len(np.unique(y_all))
+    np.save(os.path.join(result_dir, "label_mapping.npy"), le.classes_)
+
+    print(f"Classes: {le.classes_} (n={num_classes})")
+
+    skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    process = psutil.Process(os.getpid())
+    start_time = time.time()
+
+    for fold, (train_idx, test_idx) in enumerate(skf.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]
+
+        X_train = cp.asarray(X_train, dtype=cp.float32)
+        X_test = cp.asarray(X_test, dtype=cp.float32)
+        y_train = cp.asarray(y_train, dtype=cp.int32)
+
+        model = cuRFClassifier(
+            n_estimators=args.n_estimators,
+            max_depth=args.max_depth,
+            random_state=42
+        )
+
+        model.fit(X_train, y_train)
+
+        y_pred = model.predict(X_test)
+        y_pred = cp.asnumpy(y_pred)
+
+        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()) if args.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, "
+            f"GPU={gpu_mem:.2f}MB, CPU={cpu_mem:.2f}MB"
+        )
+
+        pd.DataFrame({
+            "y_true": le.inverse_transform(y_test),
+            "y_pred": le.inverse_transform(y_pred)
+        }).to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+    # ===== Summary =====
+    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}")
+
+
+def RF_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}")
+        label = Y[:, 0]
+        label = np.nan_to_num(label, nan=np.nanmedian(label))
+
+        best_params = RF_GPU_he_class.Hyperparameter(X, label)
+        args.n_estimators = best_params['n_estimators']
+        args.max_depth = best_params['max_depth']
+
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+        process = psutil.Process(os.getpid())
+
+        start_time = time.time()
+    
+        run_cv(args, X, label)
+        elapsed_time = time.time() - start_time
+        print(f"Running time: {elapsed_time:.2f}s")
+
+        if GPU_AVAILABLE:
+            cp.get_default_memory_pool().free_all_blocks()
+
+
+if __name__ == "__main__":
+    RF_class()

gpbench/method_class/RF/RF_GPU_he_class.py

@@ -0,0 +1,124 @@
+import os
+import random
+import torch
+import numpy as np
+import optuna
+from sklearn.model_selection import KFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+try:
+    import cupy as cp
+    from cuml.ensemble import RandomForestClassifier as cuRandomForestClassifier
+    CUML_AVAILABLE = True
+except ImportError:
+    from sklearn.ensemble import RandomForestClassifier
+    CUML_AVAILABLE = False
+
+def run_nested_cv_with_early_stopping(
+        data, label, outer_cv,
+        n_estimators, max_depth, use_gpu=True):
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    le = LabelEncoder()
+    y_all = le.fit_transform(label)
+    num_classes = len(np.unique(y_all))
+    print(f"Classes: {le.classes_} (n={num_classes})")
+
+    gpu_available = use_gpu and CUML_AVAILABLE and torch.cuda.is_available()
+
+    import time
+    time_start = 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]
+
+        X_train = X_train.astype(np.float32)
+        X_test = X_test.astype(np.float32)
+
+        if gpu_available:
+            X_train = cp.asarray(X_train)
+            X_test = cp.asarray(X_test)
+            y_train = cp.asarray(y_train)
+
+            model = cuRandomForestClassifier(
+                n_estimators=n_estimators,
+                max_depth=max_depth,
+                random_state=42,
+                n_streams=1
+            )
+        else:
+            model = RandomForestClassifier(
+                n_estimators=n_estimators,
+                max_depth=max_depth,
+                random_state=42,
+                n_jobs=-1
+            )
+
+        model.fit(X_train, y_train)
+
+        y_pred = model.predict(X_test)
+
+        if gpu_available:
+            y_pred = cp.asnumpy(y_pred)
+
+        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)
+
+        device = "GPU" if gpu_available else "CPU"
+        print(
+            f"Fold {fold + 1}[{device}]: "
+            f"ACC={acc:.4f}, PREC={prec:.4f}, "
+            f"REC={rec:.4f}, F1={f1:.4f}"
+        )
+
+        if gpu_available:
+            cp.get_default_memory_pool().free_all_blocks()
+
+    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() - time_start:.2f}s")
+    return np.mean(all_f1)
+
+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)
+
+def Hyperparameter(data, label, use_gpu=True):
+    set_seed(42)
+
+    def objective(trial):
+        n_estimators = trial.suggest_int("n_estimators", 100, 1000)
+        max_depth = trial.suggest_int("max_depth", 3, 10)
+
+        outer_cv = KFold(n_splits=10, shuffle=True, random_state=42)
+
+        score = run_nested_cv_with_early_stopping(
+            data=data,
+            label=label,
+            outer_cv=outer_cv,
+            n_estimators=n_estimators,
+            max_depth=max_depth,
+            use_gpu=use_gpu
+        )
+        return score
+
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+
+    print("best params:", study.best_params)
+    return study.best_params

gpbench/method_class/RF/__init__.py

@@ -0,0 +1,5 @@
+from .RF_GPU_class import RF_class
+
+RF = RF_class
+
+__all__ = ["RF","RF_class"]