gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/DeepCCR/base_DeepCCR_class.py

@@ -0,0 +1,209 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+
+class DeepCCR(nn.Module):
+    def __init__(
+        self,
+        input_channels=1,
+        input_seq_len=162,
+        lstm_hidden_size=64,
+        fc1_hidden_dim=128,
+        num_classes=2,
+    ):
+        super(DeepCCR, self).__init__()
+
+        # ==================== Conv1 ====================
+        self.conv1_kernel = 500
+        self.conv1_stride = 100
+        self.conv1_out_ch = 150
+
+        if input_seq_len < self.conv1_kernel:
+            pad_left = (self.conv1_kernel - input_seq_len) // 2
+            pad_right = self.conv1_kernel - input_seq_len - pad_left
+            self.conv1_padding = (pad_left, pad_right)
+            conv1_input_len = self.conv1_kernel
+        else:
+            self.conv1_padding = (0, 0)
+            conv1_input_len = input_seq_len
+
+        self.conv1 = nn.Conv1d(
+            in_channels=input_channels,
+            out_channels=self.conv1_out_ch,
+            kernel_size=self.conv1_kernel,
+            stride=self.conv1_stride,
+            padding=0
+        )
+        self.relu1 = nn.ReLU()
+
+        conv1_seq_len = (conv1_input_len - self.conv1_kernel) // self.conv1_stride + 1
+        self.max_pool1 = nn.MaxPool1d(kernel_size=2, stride=2, ceil_mode=True)
+        pool1_seq_len = (conv1_seq_len + 1) // 2
+
+        # ==================== BiLSTM ====================
+        self.bilstm = nn.LSTM(
+            input_size=150,
+            hidden_size=lstm_hidden_size,
+            batch_first=True,
+            bidirectional=True
+        )
+
+        # ==================== Conv2 ====================
+        self.conv2_kernel = 30
+        self.conv2_stride = 5
+        self.conv2_out_ch = 150
+
+        if pool1_seq_len < self.conv2_kernel:
+            pad_left2 = (self.conv2_kernel - pool1_seq_len) // 2
+            pad_right2 = self.conv2_kernel - pool1_seq_len - pad_left2
+            self.conv2_padding = (pad_left2, pad_right2)
+            conv2_input_len = self.conv2_kernel
+        else:
+            self.conv2_padding = (0, 0)
+            conv2_input_len = pool1_seq_len
+
+        self.conv2 = nn.Conv1d(
+            in_channels=lstm_hidden_size * 2,
+            out_channels=self.conv2_out_ch,
+            kernel_size=self.conv2_kernel,
+            stride=self.conv2_stride,
+            padding=0
+        )
+        self.relu2 = nn.ReLU()
+
+        conv2_seq_len = (conv2_input_len - self.conv2_kernel) // self.conv2_stride + 1
+        self.max_pool2 = nn.MaxPool1d(kernel_size=2, stride=2, ceil_mode=True)
+        pool2_seq_len = (conv2_seq_len + 1) // 2
+
+        # ==================== FC ====================
+        flatten_dim = self.conv2_out_ch * pool2_seq_len
+
+        self.fc1 = nn.Linear(flatten_dim, fc1_hidden_dim)
+        self.relu3 = nn.ReLU()
+        self.fc2 = nn.Linear(fc1_hidden_dim, num_classes)
+
+    # ==================================================
+    # Forward
+    # ==================================================
+    def forward(self, x):
+        """
+        x: [batch, channels, seq_len]
+        return: logits [batch, num_classes]
+        """
+
+        if self.conv1_padding != (0, 0):
+            x = F.pad(x, self.conv1_padding)
+
+        x = self.relu1(self.conv1(x))
+        x = self.max_pool1(x)
+
+        x = x.permute(0, 2, 1)  # [B, T, C]
+        x, _ = self.bilstm(x)
+        x = x.permute(0, 2, 1)  # [B, C, T]
+
+        if self.conv2_padding != (0, 0):
+            x = F.pad(x, self.conv2_padding)
+
+        x = self.relu2(self.conv2(x))
+        x = self.max_pool2(x)
+
+        x = torch.flatten(x, start_dim=1)
+        x = self.relu3(self.fc1(x))
+        logits = self.fc2(x)
+
+        return logits
+
+    # ==================================================
+    # Training (Classification)
+    # ==================================================
+    def train_model(
+        self,
+        train_loader,
+        valid_loader,
+        num_epochs,
+        learning_rate,
+        patience,
+        device
+    ):
+        self.to(device)
+
+        optimizer = torch.optim.AdamW(
+            self.parameters(),
+            lr=learning_rate,
+            weight_decay=1e-4
+        )
+        criterion = nn.CrossEntropyLoss()
+
+        best_loss = float("inf")
+        best_state = None
+        trigger_times = 0
+
+        for epoch in range(num_epochs):
+            # -------- Train --------
+            self.train()
+            train_loss = 0.0
+
+            for inputs, labels in train_loader:
+                inputs = inputs.to(device)
+                labels = labels.to(device).long()
+
+                optimizer.zero_grad()
+                outputs = self(inputs)          # logits
+                loss = criterion(outputs, labels)
+                loss.backward()
+                optimizer.step()
+
+                train_loss += loss.item() * inputs.size(0)
+
+            train_loss /= len(train_loader.dataset)
+
+            # -------- Validation --------
+            self.eval()
+            valid_loss = 0.0
+            with torch.no_grad():
+                for inputs, labels in valid_loader:
+                    inputs = inputs.to(device)
+                    labels = labels.to(device).long()
+                    outputs = self(inputs)
+                    loss = criterion(outputs, labels)
+                    valid_loss += loss.item() * inputs.size(0)
+
+            valid_loss /= len(valid_loader.dataset)
+
+            # -------- Early stopping --------
+            if valid_loss < best_loss:
+                best_loss = valid_loss
+                best_state = {k: v.cpu().clone() for k, v in self.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(self.parameters()).device
+            best_state = {k: v.to(cur_device) for k, v in best_state.items()}
+            self.load_state_dict(best_state)
+
+        return best_loss
+
+    # ==================================================
+    # Predict (Classification)
+    # ==================================================
+    def predict(self, test_loader, device):
+        self.eval()
+        self.to(device)
+
+        y_pred = []
+        with torch.no_grad():
+            for inputs, _ in test_loader:
+                inputs = inputs.to(device)
+                outputs = self(inputs)                 # logits
+                preds = torch.argmax(outputs, dim=1)  # class index
+                y_pred.append(preds.cpu().numpy())
+
+        y_pred = np.concatenate(y_pred, axis=0)
+        return y_pred

gpbench/method_class/DeepGS/DeepGS_class.py

@@ -0,0 +1,184 @@
+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_deepgs_class import DeepGS
+from . import DeepGS_he_class
+import pynvml
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--methods', type=str, default='DeepGS/')
+    parser.add_argument('--species', type=str, default='Wheat/')
+    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('--num_round', type=int, default=6000)
+    parser.add_argument('--batch_size', type=int, default=32)
+    parser.add_argument('--weight_decay', type=float, default=1e-5)
+    parser.add_argument('--momentum', type=float, default=0.5)
+    parser.add_argument('--learning_rate', type=float, default=0.01)
+    parser.add_argument('--patience', type=int, default=50)
+    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"]
+    names = np.load(os.path.join(args.data_dir, args.species, 'phenotype.npz'))["arr_1"]
+    print("Samples:", X.shape[0], "SNPs:", X.shape[1])
+    return X, Y, X.shape[0], X.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 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)
+
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    cv_start_time = time.time()
+
+    for fold, (train_idx, test_idx) in enumerate(kf.split(data, label)):
+        fold_start = time.time()
+        process = psutil.Process(os.getpid())
+        print(f"\n===== Fold {fold} =====")
+
+        X_train, X_test = data[train_idx], data[test_idx]
+        y_train, y_test = label[train_idx], label[test_idx]
+
+        X_tr, X_val, y_tr, y_val = train_test_split(
+            X_train, y_train,
+            test_size=0.1,
+            stratify=y_train,
+            random_state=42
+        )
+
+        x_tr = torch.from_numpy(X_tr).float().unsqueeze(1).to(device)
+        x_val = torch.from_numpy(X_val).float().unsqueeze(1).to(device)
+        x_te = torch.from_numpy(X_test).float().unsqueeze(1).to(device)
+
+        y_tr = torch.from_numpy(y_tr).long().to(device)
+        y_val = torch.from_numpy(y_val).long().to(device)
+        y_te = torch.from_numpy(y_test).long().to(device)
+
+        train_loader = DataLoader(TensorDataset(x_tr, y_tr), args.batch_size, shuffle=True)
+        valid_loader = DataLoader(TensorDataset(x_val, y_val), args.batch_size, shuffle=False)
+        test_loader  = DataLoader(TensorDataset(x_te, y_te), args.batch_size, shuffle=False)
+
+        model = DeepGS(nsnp, num_classes=num_classes)
+
+        model.train_model(
+            train_loader,
+            valid_loader,
+            args.num_round,
+            args.learning_rate,
+            args.momentum,
+            args.weight_decay,
+            args.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
+        )
+
+        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(), gpu_handle)
+        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={gpu_mem:.2f}MB, CPU={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)
+
+        torch.cuda.empty_cache()
+
+
+def DeepGS_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 = DeepGS_he_class.Hyperparameter(X, label, nsnp)
+        args.learning_rate = best_params['learning_rate']
+        args.batch_size = best_params['batch_size']
+        args.momentum = best_params['momentum']
+        args.weight_decay = best_params['weight_decay']
+        args.patience = best_params['patience']
+
+        start_time = time.time()
+        run_nested_cv(args, X, label, nsnp, num_classes, device, gpu_handle)
+        elapsed_time = time.time() - start_time
+        print(f"Total running time: {elapsed_time:.2f}s")
+        print("Successfully finished:", args.species, args.phe)
+
+
+if __name__ == "__main__":
+    DeepGS_class()

gpbench/method_class/DeepGS/DeepGS_he_class.py

@@ -0,0 +1,150 @@
+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.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+from torch.utils.data import DataLoader, TensorDataset
+from optuna.exceptions import TrialPruned
+from .base_deepgs_class import DeepGS
+
+def run_nested_cv_classification( data, label, nsnp, learning_rate, momentum, weight_decay,
+    patience, batch_size, num_round=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"\n===== Fold {fold} =====")
+        fold_start_time = time.time()
+        process = psutil.Process(os.getpid())
+
+        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
+        )
+
+        # 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),
+            batch_size=batch_size, shuffle=True
+        )
+        valid_loader = DataLoader(
+            TensorDataset(x_valid, y_valid),
+            batch_size=batch_size, shuffle=False
+        )
+        test_loader = DataLoader(
+            TensorDataset(x_test, y_test),
+            batch_size=batch_size, shuffle=False
+        )
+
+        model = DeepGS(nsnp, num_classes=num_classes)
+        model.loss_fn = torch.nn.CrossEntropyLoss()
+
+        model.train_model(
+            train_loader, valid_loader,
+            num_round, learning_rate,
+            momentum, weight_decay,
+            patience, device
+        )
+
+        y_pred = model.predict(test_loader)
+
+        if y_pred.ndim == 2:
+            y_pred_class = np.argmax(y_pred, axis=1)
+        else:
+            y_pred_class = y_pred
+
+        acc = accuracy_score(y_test.cpu().numpy(), y_pred_class)
+        prec, rec, f1, _ = precision_recall_fscore_support(
+            y_test.cpu().numpy(),
+            y_pred_class,
+            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
+        cpu_mem = process.memory_info().rss / 1024**2
+
+        print(
+            f"Fold {fold}: "
+            f"ACC={acc:.4f}, "
+            f"PREC={prec:.4f}, "
+            f"REC={rec:.4f}, "
+            f"F1={f1:.4f}, "
+            f"Time={fold_time:.2f}s, "
+            f"CPU={cpu_mem:.2f}MB"
+        )
+
+    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}")
+
+    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):
+        learning_rate = trial.suggest_float("learning_rate", 1e-4, 0.1, log=True)
+        momentum = trial.suggest_float("momentum", 0.1, 0.9, step=0.1)
+        batch_size = trial.suggest_categorical("batch_size", [32, 64, 128])
+        weight_decay = trial.suggest_categorical(
+            "weight_decay", [1e-4, 1e-3, 1e-2, 1e-1]
+        )
+        patience = trial.suggest_int("patience", 10, 100, step=10)
+
+        try:
+            f1 = run_nested_cv_classification(
+                data=data,
+                label=label,
+                nsnp=nsnp,
+                learning_rate=learning_rate,
+                momentum=momentum,
+                weight_decay=weight_decay,
+                patience=patience,
+                batch_size=batch_size
+            )
+        except Exception as e:
+            raise TrialPruned()
+
+        return f1
+
+    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/DeepGS/__init__.py

@@ -0,0 +1,5 @@
+from .DeepGS_class import DeepGS_class
+
+DeepGS = DeepGS_class
+
+__all__ = ["DeepGS","DeepGS_class"]

gpbench/method_class/DeepGS/base_deepgs_class.py

@@ -0,0 +1,153 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+
+class DeepGS(nn.Module):
+    """
+    DeepGS for multi-class classification
+    Fully compatible with:
+    - Optuna hyperparameter optimization
+    - 10-fold cross-validation
+    """
+
+    def __init__(self, input_size: int, num_classes: int):
+        super().__init__()
+
+        # ========= Feature extractor =========
+        self.conv1 = nn.Conv1d(
+            in_channels=1,
+            out_channels=8,
+            kernel_size=18,
+            stride=1
+        )
+        self.act1 = nn.ReLU()
+        self.pool1 = nn.MaxPool1d(kernel_size=4, stride=4)
+        self.drop1 = nn.Dropout(p=0.2)
+
+        # ========= Dynamically infer FC input =========
+        with torch.no_grad():
+            dummy = torch.zeros(1, 1, input_size)
+            dummy = self.pool1(self.act1(self.conv1(dummy)))
+            conv_out_dim = dummy.view(1, -1).size(1)
+
+        # ========= Classifier =========
+        self.fc1 = nn.Linear(conv_out_dim, 32)
+        self.act2 = nn.ReLU()
+        self.drop2 = nn.Dropout(p=0.1)
+
+        self.fc2 = nn.Linear(32, num_classes)
+
+    # ==================================================
+    # Forward
+    # ==================================================
+    def forward(self, x):
+        x = self.conv1(x)
+        x = self.act1(x)
+        x = self.pool1(x)
+        x = self.drop1(x)
+
+        x = torch.flatten(x, 1)
+
+        x = self.fc1(x)
+        x = self.act2(x)
+        x = self.drop2(x)
+
+        x = self.fc2(x)   # logits
+        return x
+
+    # ==================================================
+    # Training (classification)
+    # ==================================================
+    def train_model(
+        self,
+        train_loader,
+        valid_loader,
+        num_epochs: int,
+        learning_rate: float,
+        momentum: float,
+        weight_decay: float,
+        patience: int,
+        device: torch.device
+    ):
+        self.to(device)
+
+        optimizer = torch.optim.SGD(
+            self.parameters(),
+            lr=learning_rate,
+            momentum=momentum,
+            weight_decay=weight_decay
+        )
+
+        criterion = nn.CrossEntropyLoss()
+
+        best_loss = float("inf")
+        best_state = None
+        trigger_times = 0
+
+        for epoch in range(num_epochs):
+            # -------- Train --------
+            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)
+
+            train_loss /= len(train_loader.dataset)
+
+            # -------- Validation --------
+            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)
+
+            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:
+                    break
+
+        if best_state is not None:
+            self.load_state_dict(best_state)
+
+        return best_loss
+
+    # ==================================================
+    # Prediction (classification)
+    # ==================================================
+    def predict(self, test_loader):
+        self.eval()
+        device = next(self.parameters()).device
+
+        y_pred = []
+
+        with torch.no_grad():
+            for inputs, _ in test_loader:
+                inputs = inputs.to(device)
+                outputs = self(inputs)        # (N, C)
+                preds = torch.argmax(outputs, dim=1)
+                y_pred.append(preds.cpu().numpy())
+
+        return np.concatenate(y_pred, axis=0)