gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/ElasticNet/ElasticNet_he_class.py

@@ -0,0 +1,91 @@
+import gc
+import random
+import time
+import numpy as np
+import optuna
+from sklearn.model_selection import StratifiedKFold
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from optuna.exceptions import TrialPruned
+
+def run_nested_cv_with_early_stopping(data, label, outer_cv, C, l1_ratio):
+    best_accs, best_precs, best_recs, best_f1s = [], [], [], []
+    time_star = time.time()
+
+    for fold, (train_idx, test_idx) in enumerate(outer_cv.split(data, label)):
+        x_train = data[train_idx]
+        x_test = data[test_idx]
+        y_train = label[train_idx]
+        y_test = label[test_idx]
+
+        model = LogisticRegression(
+            penalty='elasticnet',
+            C=C,
+            l1_ratio=l1_ratio,
+            solver='saga',
+            max_iter=1000,
+            random_state=42,
+            n_jobs=-1
+        )
+        model.fit(x_train, y_train)
+        y_test_preds = model.predict(x_test)
+
+        acc = accuracy_score(y_test, y_test_preds)
+        prec, rec, f1, _ = precision_recall_fscore_support(
+            y_test, y_test_preds, average="macro", zero_division=0
+        )
+
+        best_accs.append(acc)
+        best_precs.append(prec)
+        best_recs.append(rec)
+        best_f1s.append(f1)
+
+        print(f'Fold {fold + 1}: ACC={acc:.4f}, PREC={prec:.4f}, REC={rec:.4f}, F1={f1:.4f}')
+        del model, y_test_preds, x_train, x_test, y_train, y_test
+
+    print("==== Final Results ====")
+    print(f"ACC: {np.mean(best_accs):.4f} ± {np.std(best_accs):.4f}")
+    print(f"PREC: {np.mean(best_precs):.4f} ± {np.std(best_precs):.4f}")
+    print(f"REC: {np.mean(best_recs):.4f} ± {np.std(best_recs):.4f}")
+    print(f"F1: {np.mean(best_f1s):.4f} ± {np.std(best_f1s):.4f}")
+
+    print(f"Time: {time.time() - time_star:.2f}s")
+    gc.collect()
+
+    mean_f1 = float(np.mean(best_f1s)) if best_f1s else 0.0
+    if np.isnan(mean_f1) or mean_f1 <= 0:
+        raise TrialPruned()
+
+    return mean_f1
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+
+def Hyperparameter(data, label):
+    set_seed(42)
+    
+    def objective(trial):
+        C = trial.suggest_float("C", 1e-4, 100.0, log=True)
+        l1_ratio = trial.suggest_categorical("l1_ratio", [0.1, 0.3, 0.5, 0.7, 0.9])
+        
+        outer_cv = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+        try:
+            f1_score = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                outer_cv=outer_cv,
+                C=C,
+                l1_ratio=l1_ratio
+            )
+        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/ElasticNet/__init__.py

@@ -0,0 +1,5 @@
+from .ElasticNet_class import ElasticNet_class
+
+ElasticNet = ElasticNet_class
+
+__all__ = ["ElasticNet","ElasticNet_class"]

gpbench/method_class/G2PDeep/G2PDeep_he_class.py

@@ -0,0 +1,217 @@
+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 sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from torch.utils.data import DataLoader, TensorDataset
+from optuna.exceptions import TrialPruned
+from .base_G2PDeep_class import G2PDeep, ModelHyperparams
+
+
+def train_model(model, train_loader, valid_loader, optimizer, criterion, num_epochs, patience, device):
+    model.to(device)
+    best_loss = float('inf')
+    best_state = None
+    trigger_times = 0
+
+    use_amp = device.type == 'cuda'
+    scaler = torch.amp.GradScaler('cuda') if use_amp else None
+
+    for epoch in range(num_epochs):
+        model.train()
+        train_loss = 0.0
+        for inputs, labels in train_loader:
+            inputs = inputs.to(device, non_blocking=True)
+            labels = labels.to(device, non_blocking=True)
+
+            optimizer.zero_grad()
+
+            if use_amp:
+                with torch.amp.autocast('cuda'):
+                    outputs = model(inputs)
+                    loss = criterion(outputs, labels)
+                scaler.scale(loss).backward()
+                scaler.step(optimizer)
+                scaler.update()
+            else:
+                outputs = model(inputs)
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()
+
+            train_loss += loss.item() * inputs.size(0)
+        train_loss /= len(train_loader.dataset)
+
+        model.eval()
+        valid_loss = 0.0
+        with torch.no_grad():
+            for inputs, labels in valid_loader:
+                inputs = inputs.to(device, non_blocking=True)
+                labels = labels.to(device, non_blocking=True)
+
+                if use_amp:
+                    with torch.amp.autocast('cuda'):
+                        outputs = model(inputs)
+                        loss = criterion(outputs, labels)
+                else:
+                    outputs = model(inputs)
+                    loss = criterion(outputs, labels)
+
+                valid_loss += loss.item() * inputs.size(0)
+        valid_loss /= len(valid_loader.dataset)
+
+        if valid_loss < best_loss:
+            best_loss = valid_loss
+            best_state = {k: v.cpu().clone() for k, v in model.state_dict().items()}
+            trigger_times = 0
+        else:
+            trigger_times += 1
+            if trigger_times >= patience:
+                print(f"Early stopping at epoch {epoch+1}")
+                break
+
+    if best_state is not None:
+        cur_device = next(model.parameters()).device
+        best_state = {k: v.to(cur_device) for k, v in best_state.items()}
+        model.load_state_dict(best_state)
+    return best_loss
+
+
+def predict(model, test_loader, device):
+    model.eval()
+    model.to(device)
+    y_pred_list = []
+    use_amp = device.type == 'cuda'
+    with torch.no_grad():
+        for inputs, _ in test_loader:
+            inputs = inputs.to(device, non_blocking=True)
+            if use_amp:
+                with torch.amp.autocast('cuda'):
+                    outputs = model(inputs)
+            else:
+                outputs = model(inputs)
+            preds = torch.argmax(outputs, dim=1)
+            y_pred_list.append(preds.cpu())
+    y_pred = torch.cat(y_pred_list, dim=0).numpy()
+    return y_pred
+
+
+def run_nested_cv_with_early_stopping(data, label, nsnp, num_classes, learning_rate, patience, batch_size, epochs=1000):
+    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()
+        y_train_tensor = torch.from_numpy(y_train_sub).long()
+        x_valid_tensor = torch.from_numpy(X_valid).float()
+        y_valid_tensor = torch.from_numpy(y_valid).long()
+        x_test_tensor = torch.from_numpy(X_test).float()
+        y_test_tensor = torch.from_numpy(y_test).long()
+
+        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,
+            num_workers=4, pin_memory=True, persistent_workers=True
+        )
+        valid_loader = DataLoader(
+            valid_data, batch_size, shuffle=False,
+            num_workers=4, pin_memory=True, persistent_workers=True
+        )
+        test_loader = DataLoader(
+            test_data, batch_size, shuffle=False,
+            num_workers=4, pin_memory=True, persistent_workers=True
+        )
+
+        hp = ModelHyperparams()
+        model = G2PDeep(nsnp=nsnp, num_classes=num_classes, hyperparams=hp).to(device)
+        optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, weight_decay=1e-4)
+        loss_fn = torch.nn.CrossEntropyLoss()
+
+        train_model(model, train_loader, valid_loader, optimizer, loss_fn, epochs, patience, device)
+        y_pred = predict(model, test_loader, device)
+
+        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===== 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}")
+
+    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/G2PDeep/G2Pdeep_class.py

@@ -0,0 +1,205 @@
+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, train_test_split
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from .base_G2PDeep_class import G2PDeep, ModelHyperparams
+from torch.utils.data import DataLoader, TensorDataset
+from . import G2PDeep_he_class
+import pynvml
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="G2PDeep classification")
+    parser.add_argument('--methods', type=str, default='G2PDeep/')
+    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('--epoch', type=int, default=1000)
+    parser.add_argument('--batch_size', type=int, default=64)
+    parser.add_argument('--lr', type=float, default=0.001)
+    parser.add_argument('--patience', type=int, default=10)
+    return parser.parse_args()
+
+
+def process_snp_data(data: np.array) -> np.array:
+    nb_classes = 4
+    onehot_x = np.empty(
+        shape=(data.shape[0], data.shape[1], nb_classes),
+        dtype=np.float32
+    )
+
+    for i in range(data.shape[0]):
+        _data = pd.to_numeric(data[i], errors='coerce')
+        _targets = np.array(_data).reshape(-1).astype(np.int64)
+        onehot_x[i] = np.eye(nb_classes)[_targets]
+
+    return onehot_x
+
+
+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"]
+
+    xData[xData == -9] = 0
+    xData = process_snp_data(xData)
+    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 get_gpu_mem_by_pid(pid, handle=None):
+    if handle is None:
+        return 0.0
+    try:
+        procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
+        for p in procs:
+            if p.pid == pid:
+                return p.usedGpuMemory / 1024**2
+        return 0.0
+    except Exception:
+        return 0.0
+
+
+def run_nested_cv(args, data, label, nsnp, num_classes, device, gpu_handle=None):
+    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 = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    time_star = time.time()
+
+    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()
+        y_train_tensor = torch.from_numpy(y_train_sub).long()
+        x_valid_tensor = torch.from_numpy(X_valid).float()
+        y_valid_tensor = torch.from_numpy(y_valid).long()
+        x_test_tensor = torch.from_numpy(X_test).float()
+        y_test_tensor = torch.from_numpy(y_test).long()
+
+        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,
+            num_workers=4, pin_memory=True, persistent_workers=True
+        )
+        valid_loader = DataLoader(
+            valid_data, args.batch_size, shuffle=False,
+            num_workers=4, pin_memory=True, persistent_workers=True
+        )
+        test_loader = DataLoader(
+            test_data, args.batch_size, shuffle=False,
+            num_workers=4, pin_memory=True, persistent_workers=True
+        )
+
+        hp = ModelHyperparams()
+        model = G2PDeep(nsnp=nsnp, num_classes=num_classes, hyperparams=hp).to(device)
+        model.train_model(train_loader, valid_loader, args.epoch, args.lr, args.patience, device)
+        y_pred = model.predict(test_loader, device)
+
+        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_time
+        fold_gpu_mem = get_gpu_mem_by_pid(os.getpid(), gpu_handle)
+        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')
+        
+        if torch.cuda.is_available():
+            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 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"Time: {time.time() - time_star:.2f}s")
+
+
+def G2PDeep_class():
+    set_seed(42)
+    gpu_handle = None
+    try:
+        if torch.cuda.is_available():
+            pynvml.nvmlInit()
+            gpu_handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+    except Exception as e:
+        print(f"Warning: GPU monitoring initialization failed: {e}")
+        gpu_handle = None
+
+    args = parse_args()
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+
+    all_species = ["Human/Sim/"]
+    for species in all_species:
+        args.species = species
+        X, Y, nsamples, nsnp, names = load_data(args)
+
+        print("Starting:", args.methods + args.species)
+        label_raw = np.nan_to_num(Y[:, 0])
+        le = LabelEncoder()
+        label = le.fit_transform(label_raw)
+        num_classes = len(le.classes_)
+
+        best_params = G2PDeep_he_class.Hyperparameter(X, label, nsnp, num_classes)
+        args.lr = best_params['learning_rate']
+        args.patience = best_params['patience']
+        args.batch_size = best_params['batch_size']
+
+        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, nsnp=nsnp, num_classes=num_classes, device=device, gpu_handle=gpu_handle)
+
+        elapsed_time = time.time() - start_time
+        print(f"Running time: {elapsed_time:.2f}s")
+        print("successfully")
+
+if __name__ == "__main__":
+    G2PDeep_class()

gpbench/method_class/G2PDeep/__init__.py

@@ -0,0 +1,5 @@
+from .G2Pdeep_class import G2PDeep_class
+
+G2PDeep = G2PDeep_class
+
+__all__ = ["G2PDeep","G2PDeep_class"]