gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/DL_GWAS/DL_GWAS_class.py

@@ -0,0 +1,250 @@
+import os
+import time
+import psutil
+import swanlab
+import argparse
+import random
+import gc
+import torch
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+import keras
+import pynvml
+from keras import layers
+from keras import regularizers
+from keras.models import Model
+from keras.layers import Input, Conv1D, Dropout, Flatten, Dense
+from keras.callbacks import EarlyStopping
+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 . import DL_GWAS_he_class
+
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="DL_GWAS classification")
+    parser.add_argument("--methods", type=str, default="DL_GWAS/")
+    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("--epochs", type=int, default=1000)
+    parser.add_argument("--batch_size", type=int, default=128)
+    parser.add_argument("--learning_rate", type=float, default=0.01)
+    parser.add_argument("--patience", type=int, default=5)
+    return parser.parse_args()
+
+
+def indices_to_one_hot(data, nb_classes):
+    targets = np.array(data).reshape(-1)
+    return np.eye(nb_classes)[targets]
+
+
+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 = xData.astype(int)
+    arr = np.empty(shape=(nsample, nsnp, 4), dtype=np.float32)
+    xData[xData == -9] = 0
+    for i in range(0, nsample):
+        arr[i] = indices_to_one_hot(pd.to_numeric(xData[i], downcast="signed"), 4).astype(np.float32, copy=False)
+
+    return arr, 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)
+    tf.random.set_seed(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 resnet(args, nsnp: int, num_classes: int):
+    inputs = Input(shape=(nsnp, 4))
+
+    x = Conv1D(
+        10, 4, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(inputs)
+    x = Conv1D(
+        10, 20, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(x)
+    x = Dropout(0.75)(x)
+
+    shortcut = Conv1D(
+        10, 4, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(inputs)
+    x = layers.add([shortcut, x])
+
+    x = Conv1D(
+        10, 4, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(x)
+    x = Dropout(0.75)(x)
+    x = Flatten()(x)
+    x = Dropout(0.75)(x)
+
+    outputs = Dense(num_classes, activation="softmax", name="out")(x)
+    model = Model(inputs=inputs, outputs=outputs)
+
+    model.compile(
+        loss="sparse_categorical_crossentropy",
+        optimizer=keras.optimizers.Adam(learning_rate=args.learning_rate),
+        metrics=["accuracy"],
+    )
+    return model
+
+
+def run_nested_cv(args, data, label, nsnp: int, num_classes: int):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+    os.makedirs(result_dir, exist_ok=True)
+
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+    early_stopping = EarlyStopping(monitor="val_loss", patience=args.patience, restore_best_weights=True)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    cv_start_time = time.time()
+
+    for fold, (train_index, test_index) in enumerate(kf.split(data, label)):
+        fold_start_time = time.time()
+        process = psutil.Process(os.getpid())
+        print(f"\n===== Fold {fold} =====")
+
+        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,
+        )
+
+        model = resnet(args, nsnp=nsnp, num_classes=num_classes)
+        model.fit(
+            X_train_sub,
+            y_train_sub,
+            batch_size=args.batch_size,
+            epochs=args.epochs,
+            validation_data=(X_valid, y_valid),
+            callbacks=[early_stopping],
+            shuffle=True,
+            verbose=0,
+        )
+
+        y_prob = model.predict(X_test, verbose=0)
+        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() - fold_start_time
+        fold_gpu_mem = get_gpu_mem_by_pid(os.getpid(), handle)
+        fold_cpu_mem = process.memory_info().rss / 1024**2
+
+        print(
+            f"Fold {fold}: "
+            f"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"
+        )
+
+        pd.DataFrame({"Y_test": y_test, "Y_pred": y_pred}).to_csv(
+            os.path.join(result_dir, f"fold{fold}.csv"), index=False
+        )
+
+        del model
+        keras.backend.clear_session()
+        gc.collect()
+
+    cv_time = time.time() - cv_start_time
+    print("\n===== Cross-validation 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"Time: {cv_time:.2f}s")
+
+
+def DL_GWAS_class():
+    set_seed(42)
+    try:
+        gpus = tf.config.list_physical_devices("GPU")
+        for gpu in gpus:
+            tf.config.experimental.set_memory_growth(gpu, True)
+    except Exception:
+        pass
+
+    pynvml.nvmlInit()
+    handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+    args = parse_args()
+
+    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 = DL_GWAS_he_class.Hyperparameter(X, label, nsnp, num_classes)
+        args.learning_rate = best_params["learning_rate"]
+        args.batch_size = best_params["batch_size"]
+        args.patience = best_params["patience"]
+
+        start_time = time.time()
+        run_nested_cv(args, data=X, label=label, nsnp=nsnp, num_classes=num_classes)
+        elapsed_time = time.time() - start_time
+
+        print(f"Total running time: {elapsed_time:.2f}s")
+        print("Successfully finished:", args.species)
+
+
+if __name__ == "__main__":
+    DL_GWAS_class()

gpbench/method_class/DL_GWAS/DL_GWAS_he_class.py

@@ -0,0 +1,169 @@
+import os
+import time
+import psutil
+import random
+import optuna
+import gc
+import numpy as np
+import tensorflow as tf
+import keras
+from keras import layers
+from keras import regularizers
+from keras.models import Model
+from keras.layers import Input, Conv1D, Dropout, Flatten, Dense
+from keras.callbacks import EarlyStopping
+from sklearn.model_selection import StratifiedKFold, train_test_split
+from sklearn.metrics import accuracy_score
+from optuna.exceptions import TrialPruned
+
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "2"
+
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    tf.random.set_seed(seed)
+
+
+def resnet(nsnp: int, num_classes: int, learning_rate: float):
+    inputs = Input(shape=(nsnp, 4))
+
+    x = Conv1D(
+        10, 4, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(inputs)
+    x = Conv1D(
+        10, 20, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(x)
+    x = Dropout(0.75)(x)
+
+    shortcut = Conv1D(
+        10, 4, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(inputs)
+    x = layers.add([shortcut, x])
+
+    x = Conv1D(
+        10, 4, padding="same", activation="linear",
+        kernel_initializer="TruncatedNormal",
+        kernel_regularizer=regularizers.l2(0.1),
+        bias_regularizer=regularizers.l2(0.01),
+    )(x)
+    x = Dropout(0.75)(x)
+    x = Flatten()(x)
+    x = Dropout(0.75)(x)
+
+    outputs = Dense(num_classes, activation="softmax", name="out")(x)
+    model = Model(inputs=inputs, outputs=outputs)
+
+    model.compile(
+        loss="sparse_categorical_crossentropy",
+        optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
+        metrics=["accuracy"],
+    )
+    return model
+
+
+def run_nested_cv_with_early_stopping(
+    data,
+    label,
+    nsnp: int,
+    num_classes: int,
+    learning_rate: float,
+    batch_size: int,
+    patience: int,
+):
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+    early_stopping = EarlyStopping(monitor="val_loss", patience=patience, restore_best_weights=True)
+
+    all_acc = []
+    for fold, (train_index, test_index) in enumerate(kf.split(data, label)):
+        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,
+        )
+
+        model = resnet(nsnp=nsnp, num_classes=num_classes, learning_rate=learning_rate)
+        model.fit(
+            X_train_sub,
+            y_train_sub,
+            batch_size=batch_size,
+            epochs=1000,
+            validation_data=(X_valid, y_valid),
+            callbacks=[early_stopping],
+            shuffle=True,
+            verbose=0,
+        )
+
+        y_prob = model.predict(X_test, verbose=0)
+        y_pred = np.argmax(y_prob, axis=1)
+
+        acc = accuracy_score(y_test, y_pred)
+        if np.isnan(acc) or acc <= 0:
+            try:
+                model.stop_training = True
+            except Exception:
+                pass
+            del model
+            keras.backend.clear_session()
+            gc.collect()
+            raise TrialPruned()
+
+        all_acc.append(acc)
+
+        _ = process.memory_info().rss / 1024**2
+        _ = time.time() - fold_start_time
+        del model
+        keras.backend.clear_session()
+        gc.collect()
+
+    return float(np.mean(all_acc)) if all_acc else 0.0
+
+
+def Hyperparameter(data, label, nsnp: int, num_classes: int):
+    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", 5, 15)
+
+        try:
+            acc_score = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                nsnp=nsnp,
+                num_classes=num_classes,
+                learning_rate=learning_rate,
+                batch_size=batch_size,
+                patience=patience,
+            )
+        except TrialPruned:
+            return float("-inf")
+        finally:
+            keras.backend.clear_session()
+            gc.collect()
+
+        return acc_score
+
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+
+    print("Best hyperparameters:", study.best_params)
+    return study.best_params

gpbench/method_class/DL_GWAS/__init__.py

@@ -0,0 +1,5 @@
+from .DL_GWAS_class import DL_GWAS_class
+
+DL_GWAS = DL_GWAS_class
+
+__all__ = ["DL_GWAS","DL_GWAS_class"]

gpbench/method_class/DNNGP/DNNGP_class.py

@@ -0,0 +1,163 @@
+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 torch.utils.data import DataLoader, TensorDataset
+
+from .base_dnngp_class import DNNGP
+from . import DNNGP_he_class
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--methods', type=str, default='DNNGP/')
+    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=32)
+    parser.add_argument('--lr', type=float, default=0.01)
+    parser.add_argument('--patience', type=int, default=10)
+    parser.add_argument('--dropout1', type=float, default=0.5)
+    parser.add_argument('--dropout2', type=float, default=0.5)
+    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"]
+
+    print("Samples:", xData.shape[0])
+    print("SNPs:", xData.shape[1])
+    return xData, yData, xData.shape[0], xData.shape[1], names
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+def run_nested_cv(args, data, label, nsnp, device, le):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+    os.makedirs(result_dir, exist_ok=True)
+    num_classes = len(np.unique(label))
+
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    time_start = time.time()
+
+    for fold, (train_idx, test_idx) in enumerate(kf.split(data, label)):
+        print(f"\n===== Fold {fold} =====")
+        fold_start = time.time()
+        process = psutil.Process(os.getpid())
+
+        X_train, X_test = data[train_idx], data[test_idx]
+        y_train, y_test = label[train_idx], label[test_idx]
+
+        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
+        )
+
+        # tensor
+        x_train = torch.from_numpy(X_train_sub).float().unsqueeze(1).to(device)
+        y_train = torch.from_numpy(y_train_sub).long().to(device)
+        x_valid = torch.from_numpy(X_valid).float().unsqueeze(1).to(device)
+        y_valid = torch.from_numpy(y_valid).long().to(device)
+        x_test  = torch.from_numpy(X_test).float().unsqueeze(1).to(device)
+        y_test  = torch.from_numpy(y_test).long().to(device)
+
+        train_loader = DataLoader(TensorDataset(x_train, y_train), args.batch_size, shuffle=True)
+        valid_loader = DataLoader(TensorDataset(x_valid, y_valid), args.batch_size, shuffle=False)
+        test_loader  = DataLoader(TensorDataset(x_test, y_test), args.batch_size, shuffle=False)
+        model = DNNGP(nsnp, args.dropout1, args.dropout2, output_dim=num_classes).to(device)
+
+        model.train_model(
+            train_loader,
+            valid_loader,
+            args.epoch,
+            args.lr,
+            args.weight_decay,
+            args.patience,
+            device
+        )
+
+        y_pred = model.predict(test_loader)
+        y_pred_cls = np.argmax(y_pred, axis=1)
+
+        acc = accuracy_score(y_test.cpu().numpy(), y_pred_cls)
+        prec, rec, f1, _ = precision_recall_fscore_support(
+            y_test.cpu().numpy(), y_pred_cls,
+            average="macro", zero_division=0
+        )
+
+        all_acc.append(acc)
+        all_prec.append(prec)
+        all_rec.append(rec)
+        all_f1.append(f1)
+
+        print(
+            f"ACC={acc:.4f}, PREC={prec:.4f}, "
+            f"REC={rec:.4f}, F1={f1:.4f}, "
+            f"Time={time.time()-fold_start:.2f}s, "
+            f"CPU={process.memory_info().rss/1024**2:.2f}MB"
+        )
+
+        pd.DataFrame({
+            "Y_test": le.inverse_transform(y_test.cpu().numpy()),
+            "Y_pred": le.inverse_transform(y_pred_cls)
+        }).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 DNNGP_class():
+    set_seed(42)
+    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 = Y[:, 0]
+        label = np.nan_to_num(label, nan=np.nanmean(label))
+        le = LabelEncoder()
+        label = le.fit_transform(label)
+        num_classes = len(np.unique(label))
+
+        best_params = DNNGP_he_class.Hyperparameter(X, label, nsnp)
+        args.lr = best_params['learning_rate']
+        args.weight_decay = best_params['weight_decay']
+        args.patience = best_params['patience']
+        args.dropout1 = best_params['dropout1']
+        args.dropout2 = best_params['dropout2']
+        start_time = time.time() 
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+        process = psutil.Process(os.getpid())
+
+        run_nested_cv(args, X, label, nsnp, device, le)
+        elapsed_time = time.time() - start_time
+        print(f"Running time: {elapsed_time:.2f} s")
+        print("successfully")
+
+if __name__ == "__main__":
+    DNNGP_class()