gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/DNNGP/DNNGP_he_class.py

@@ -0,0 +1,138 @@
+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 sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from torch.utils.data import DataLoader, TensorDataset
+from optuna.exceptions import TrialPruned
+from .base_dnngp_class import DNNGP
+
+def run_nested_cv_with_early_stopping(
+        data, label, nsnp,
+        learning_rate, dropout1, dropout2,
+        weight_decay, patience,
+        batch_size=64, epoch=1000):
+
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("Starting 10-fold cross-validation...")
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+
+    num_classes = len(np.unique(label))
+
+    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).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)
+
+        x_train_tensor = x_train_tensor.unsqueeze(1)
+        x_valid_tensor = x_valid_tensor.unsqueeze(1)
+        x_test_tensor  = x_test_tensor.unsqueeze(1)
+
+        train_loader = DataLoader(
+            TensorDataset(x_train_tensor, y_train_tensor),
+            batch_size=batch_size, shuffle=True
+        )
+        valid_loader = DataLoader(
+            TensorDataset(x_valid_tensor, y_valid_tensor),
+            batch_size=batch_size, shuffle=False
+        )
+        test_loader = DataLoader(
+            TensorDataset(x_test_tensor, y_test_tensor),
+            batch_size=batch_size, shuffle=False
+        )
+
+        model = DNNGP(nsnp, dropout1, dropout2, output_dim=num_classes).to(device)
+        model.loss_fn = torch.nn.CrossEntropyLoss()
+
+        model.train_model(
+            train_loader, valid_loader,
+            epoch, learning_rate, weight_decay, patience, device
+        )
+
+        logits = model.predict(test_loader)
+        y_pred = torch.argmax(torch.tensor(logits), dim=1).cpu().numpy()
+
+        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_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, CPU={fold_cpu_mem:.2f}MB"
+        )
+
+    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)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def Hyperparameter(data, label, nsnp):
+    set_seed(42)
+
+    def objective(trial):
+        lr = trial.suggest_float("learning_rate", 1e-4, 0.1, log=True)
+        patience = trial.suggest_int("patience", 1, 10)
+        batch_size = trial.suggest_categorical("batch_size", [32, 64])
+        dropout1 = trial.suggest_float("dropout1", 0.0, 0.9, step=0.1)
+        dropout2 = trial.suggest_float("dropout2", 0.0, 0.9, step=0.1)
+        weight_decay = trial.suggest_categorical("weight_decay", [1e-5, 1e-4, 1e-3])
+
+        try:
+            f1 = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                nsnp=nsnp,
+                learning_rate=lr,
+                dropout1=dropout1,
+                dropout2=dropout2,
+                weight_decay=weight_decay,
+                patience=patience,
+                batch_size=batch_size
+            )
+        except TrialPruned:
+            return float("-inf")
+
+        return f1
+
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+
+    print("Best hyperparameters:", study.best_params)
+    print("successfully")
+    return study.best_params

gpbench/method_class/DNNGP/__init__.py

@@ -0,0 +1,5 @@
+from .DNNGP_class import DNNGP_class
+
+DNNGP = DNNGP_class
+
+__all__ = ["DNNGP","DNNGP_class"]

gpbench/method_class/DNNGP/base_dnngp_class.py

@@ -0,0 +1,116 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class DNNGP(nn.Module):
+    def __init__(self, input_size, dropout1, dropout2, output_dim):
+        super().__init__()
+
+        self.CNN1 = nn.Conv1d(in_channels=1, out_channels=64, kernel_size=4)
+        self.Relu1 = nn.ReLU()
+        self.Drop1 = nn.Dropout(dropout1)
+
+        self.Batchnorm = nn.BatchNorm1d(num_features=64)
+
+        self.CNN2 = nn.Conv1d(in_channels=64, out_channels=64, kernel_size=4)
+        self.Relu2 = nn.ReLU()
+        self.Drop2 = nn.Dropout(dropout2)
+
+        self.CNN3 = nn.Conv1d(in_channels=64, out_channels=64, kernel_size=4)
+        self.Relu3 = nn.ReLU()
+
+        self.Flatten = nn.Flatten()
+        self.Dense = nn.Linear(in_features=64 * (input_size - 9), out_features=3)
+
+        self.Output = nn.Linear(in_features=3, out_features=output_dim)
+
+    def forward(self, x):
+        x = self.CNN1(x)
+        x = self.Relu1(x)
+        x = self.Drop1(x)
+        x = self.Batchnorm(x)
+
+        x = self.CNN2(x)
+        x = self.Relu2(x)
+        x = self.Drop2(x)
+
+        x = self.CNN3(x)
+        x = self.Relu3(x)
+
+        x = self.Flatten(x)
+        x = self.Dense(x)
+        x = self.Output(x)
+        return x
+
+
+    def train_model(
+        self, train_loader, valid_loader,
+        num_epochs, learning_rate, weight_decay,
+        patience, device
+    ):
+        optimizer = torch.optim.Adam(
+            self.parameters(), lr=learning_rate, weight_decay=weight_decay
+        )
+        criterion = nn.CrossEntropyLoss()
+        self.to(device)
+
+        best_loss = float('inf')
+        best_state = None
+        trigger_times = 0
+
+        for epoch in range(num_epochs):
+            self.train()
+            train_loss = 0.0
+
+            for inputs, labels in train_loader:
+                inputs = inputs.to(device)
+                labels = labels.to(device)
+                optimizer.zero_grad()
+                outputs = self(inputs)
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()
+
+                train_loss += loss.item() * inputs.size(0)
+
+            self.eval()
+            valid_loss = 0.0
+            with torch.no_grad():
+                for inputs, labels in valid_loader:
+                    inputs = inputs.to(device)
+                    labels = labels.to(device)
+                    outputs = self(inputs)
+                    loss = criterion(outputs, labels)
+                    valid_loss += loss.item() * inputs.size(0)
+
+            train_loss /= len(train_loader.dataset)
+            valid_loss /= len(valid_loader.dataset)
+
+            # ---------- Early stopping ----------
+            if valid_loss < best_loss:
+                best_loss = valid_loss
+                best_state = self.state_dict()
+                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:
+            self.load_state_dict(best_state)
+
+        return best_loss
+
+
+    def predict(self, test_loader):
+        self.eval()
+        logits = []
+        with torch.no_grad():
+            for inputs, _ in test_loader:
+                outputs = self(inputs)
+                logits.append(outputs.cpu().numpy())
+
+        logits = np.concatenate(logits, axis=0)  # (N, C)
+        return logits

gpbench/method_class/DeepCCR/DeepCCR_class.py

@@ -0,0 +1,172 @@
+import os
+import time
+import psutil
+import swanlab
+import argparse
+import random
+import torch
+import numpy as np
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder
+from sklearn.model_selection import StratifiedKFold, train_test_split
+from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score
+from torch.utils.data import DataLoader, TensorDataset
+
+from .base_DeepCCR_class import DeepCCR
+from . import DeepCCR_he_class
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--methods', type=str, default='DeepCCR/')
+    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 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)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+def run_nested_cv(args, data, label, nsnp, num_classes, device):
+
+    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)
+
+    all_acc, all_f1, all_prec, all_rec = [], [], [], []
+    time_start = 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()
+
+        X_train, X_test = data[train_index], data[test_index]
+        y_train, y_test = label[train_index], label[test_index]
+
+        X_tr, X_val, y_tr, y_val = train_test_split(
+            X_train, y_train, test_size=0.1, random_state=42, stratify=y_train
+        )
+
+        # Tensor
+        x_tr = torch.from_numpy(X_tr).float().unsqueeze(1)
+        y_tr = torch.from_numpy(y_tr).long()
+        x_val = torch.from_numpy(X_val).float().unsqueeze(1)
+        y_val = torch.from_numpy(y_val).long()
+        x_te = torch.from_numpy(X_test).float().unsqueeze(1)
+        y_te = torch.from_numpy(y_test).long()
+
+        train_loader = DataLoader(TensorDataset(x_tr, y_tr), args.batch_size, shuffle=True)
+        valid_loader = DataLoader(TensorDataset(x_val, y_val), args.batch_size)
+        test_loader  = DataLoader(TensorDataset(x_te, y_te), args.batch_size)
+
+        model = DeepCCR(input_seq_len=nsnp, num_classes=num_classes)
+        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)
+        f1   = f1_score(y_test, y_pred, average='macro')
+        prec = precision_score(y_test, y_pred, average='macro', zero_division=0)
+        rec  = recall_score(y_test, y_pred, average='macro')
+
+        all_acc.append(acc)
+        all_f1.append(f1)
+        all_prec.append(prec)
+        all_rec.append(rec)
+
+        fold_time = time.time() - fold_start
+        gpu_mem = torch.cuda.max_memory_allocated() / 1024**2 if torch.cuda.is_available() else 0
+        cpu_mem = process.memory_info().rss / 1024**2
+
+        print(
+            f"Fold {fold}: ACC={acc:.4f}, F1={f1:.4f}, "
+            f"Prec={prec:.4f}, Rec={rec:.4f}, "
+            f"Time={fold_time:.2f}s"
+        )
+
+        pd.DataFrame({
+            "y_true": y_test,
+            "y_pred": y_pred
+        }).to_csv(os.path.join(result_dir, f"fold{fold}.csv"), index=False)
+
+        torch.cuda.empty_cache()
+        torch.cuda.reset_peak_memory_stats()
+
+    total_time = time.time() - time_start
+
+    print("\n===== CV Summary =====")
+    print(f"ACC : {np.mean(all_acc):.4f} ± {np.std(all_acc):.4f}")
+    print(f"F1  : {np.mean(all_f1):.4f} ± {np.std(all_f1):.4f}")
+    print(f"Time: {total_time:.2f}s")
+
+
+
+def DeepCCR_class():
+    set_seed(42)
+    torch.cuda.empty_cache()
+
+    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_series = pd.Series(label)
+        if label_series.isna().any():
+            mode_val = label_series.mode()
+            fill_val = mode_val.iloc[0] if len(mode_val) > 0 else label_series.dropna().iloc[0] if not label_series.dropna().empty else 0
+            label = label_series.fillna(fill_val).values
+        else:
+            label = label_series.values
+
+        le = LabelEncoder()
+        label = le.fit_transform(label)
+        num_classes = len(np.unique(label))
+
+        result_dir = os.path.join(args.result_dir, args.methods + args.species + args.phe)
+        os.makedirs(result_dir, exist_ok=True)
+        np.save(os.path.join(result_dir, 'label_mapping.npy'), le.classes_)
+
+        best_params = DeepCCR_he_class.Hyperparameter(X, label, nsnp)
+        args.lr = best_params['learning_rate']
+        args.patience = best_params['patience']
+        args.batch_size = best_params['batch_size']
+        start_time = time.time()
+        run_nested_cv(args, X, label, nsnp, num_classes, device)
+        elapsed = time.time() - start_time
+
+        print(f"Total running time: {elapsed:.2f}s")
+        print("Successfully finished\n")
+
+
+if __name__ == "__main__":
+    DeepCCR_class()

gpbench/method_class/DeepCCR/DeepCCR_he_class.py

@@ -0,0 +1,161 @@
+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 sklearn.metrics import (
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score
+)
+from torch.utils.data import DataLoader, TensorDataset
+from optuna.exceptions import TrialPruned
+
+from .base_DeepCCR_class import DeepCCR
+
+def run_nested_cv_with_early_stopping(
+    data,
+    label,
+    nsnp,
+    num_classes,
+    learning_rate,
+    batch_size,
+    patience,
+    epoch=1000
+):
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    print("Starting 10-fold cross-validation...")
+
+    kf = KFold(n_splits=10, shuffle=True, random_state=42)
+
+    acc_list, pre_list, rec_list, f1_list = [], [], [], []
+
+    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_tr, X_val, y_tr, y_val = train_test_split(
+            X_train, y_train, test_size=0.1, random_state=42
+        )
+
+        x_tr = torch.from_numpy(X_tr).float().unsqueeze(1)
+        y_tr = torch.from_numpy(y_tr).long()
+        x_val = torch.from_numpy(X_val).float().unsqueeze(1)
+        y_val = torch.from_numpy(y_val).long()
+        x_te = torch.from_numpy(X_test).float().unsqueeze(1)
+        y_te = torch.from_numpy(y_test).long()
+
+        train_loader = DataLoader(
+            TensorDataset(x_tr, y_tr), batch_size, shuffle=True
+        )
+        valid_loader = DataLoader(
+            TensorDataset(x_val, y_val), batch_size, shuffle=False
+        )
+        test_loader = DataLoader(
+            TensorDataset(x_te, y_te), batch_size, shuffle=False
+        )
+
+        model = DeepCCR(
+            input_seq_len=nsnp,
+            num_classes=num_classes
+        )
+
+        model.train_model(
+            train_loader,
+            valid_loader,
+            epoch,
+            learning_rate,
+            patience,
+            device
+        )
+
+        y_pred = model.predict(test_loader, device)
+        acc = accuracy_score(y_test, y_pred)
+        pre = precision_score(y_test, y_pred, average="macro", zero_division=0)
+        rec = recall_score(y_test, y_pred, average="macro", zero_division=0)
+        f1 = f1_score(y_test, y_pred, average="macro", zero_division=0)
+
+        if np.isnan(f1):
+            print(f"Fold {fold} produced NaN F1, pruning trial.")
+            raise TrialPruned()
+
+        acc_list.append(acc)
+        pre_list.append(pre)
+        rec_list.append(rec)
+        f1_list.append(f1)
+
+        fold_time = time.time() - fold_start_time
+        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}: "
+            f"ACC={acc:.4f}, PRE={pre:.4f}, REC={rec:.4f}, F1={f1:.4f}, "
+            f"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()
+
+    return {
+        "acc": np.mean(acc_list),
+        "pre": np.mean(pre_list),
+        "rec": np.mean(rec_list),
+        "f1": np.mean(f1_list),
+    }
+
+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)
+
+    label = label.astype(int)
+    num_classes = len(np.unique(label))
+    print("Number of classes:", num_classes)
+
+    def objective(trial):
+        lr = trial.suggest_float("learning_rate", 1e-4, 1e-2, log=True)
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128])
+        patience = trial.suggest_int("patience", 3, 15)
+
+        try:
+            metrics = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                nsnp=nsnp,
+                num_classes=num_classes,
+                learning_rate=lr,
+                batch_size=batch_size,
+                patience=patience
+            )
+        except TrialPruned:
+            return float("-inf")
+        return metrics["f1"]
+
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+
+    print("Best parameters:", study.best_params)
+    print("successfully")
+    return study.best_params

gpbench/method_class/DeepCCR/__init__.py

@@ -0,0 +1,5 @@
+from .DeepCCR_class import DeepCCR_class
+
+DeepCCR = DeepCCR_class
+
+__all__ = ["DeepCCR","DeepCCR_class"]