gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/SVC/SVC_GPU.py

@@ -0,0 +1,181 @@
+import os
+import time
+import psutil
+import argparse
+import random
+import torch
+import numpy as np
+import pandas as pd
+import swanlab
+import pynvml
+
+from sklearn.model_selection import StratifiedKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+try:
+    import cupy as cp
+    from cuml.svm import SVC as cuSVC
+    CUML_AVAILABLE = True
+except ImportError:
+    from sklearn.svm import SVC
+    CUML_AVAILABLE = False
+
+from . import SVC_GPU_he
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--methods', type=str, default='SVR/')
+    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('--C', type=float, default=1.0)
+    parser.add_argument('--kernel', type=str, default='rbf')
+    parser.add_argument('--gamma', type=str, default='scale')
+    parser.add_argument('--degree', type=int, default=3)
+    parser.add_argument('--use_gpu',default=True)
+
+    return parser.parse_args()
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(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"]
+    print(f"Samples: {X.shape[0]}, SNPs: {X.shape[1]}")
+    return X, Y
+
+def get_gpu_mem_by_pid(pid, handle):
+    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, y, handle=None):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species)
+    os.makedirs(result_dir, exist_ok=True)
+
+    use_gpu = args.use_gpu and CUML_AVAILABLE
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    le = LabelEncoder()
+    y_all = le.fit_transform(y)
+    np.save(os.path.join(result_dir, 'label_mapping.npy'), le.classes_)
+
+    all_acc, all_prec, all_rec, all_f1 = [], [], [], []
+    start_time = time.time()
+    process = psutil.Process(os.getpid())
+
+    for fold, (train_idx, test_idx) in enumerate(kf.split(X, y_all)):
+        fold_start = time.time()
+        print(f"\n===== Fold {fold} =====")
+
+        X_train, X_test = X[train_idx], X[test_idx]
+        y_train, y_test = y_all[train_idx], y_all[test_idx]
+
+        if use_gpu:
+            X_train_gpu = cp.asarray(X_train, dtype=cp.float32)
+            X_test_gpu = cp.asarray(X_test, dtype=cp.float32)
+            y_train_gpu = cp.asarray(y_train, dtype=cp.int32)
+            
+            model = cuSVC(
+                C=args.C,
+                kernel=args.kernel,
+                gamma=args.gamma,
+                degree=args.degree,
+                probability=True
+            )
+            model.fit(X_train_gpu, y_train_gpu)
+            y_pred = model.predict(X_test_gpu)
+            y_pred = cp.asnumpy(y_pred)
+        else:
+            model = SVC(
+                C=args.C,
+                kernel=args.kernel,
+                gamma=args.gamma,
+                degree=args.degree,
+                probability=True
+            )
+            model.fit(X_train, y_train)
+            y_pred = model.predict(X_test)
+
+        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(), handle) if (use_gpu and handle) else 0.0  # 修正：检查handle
+        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"GPU={gpu_mem:.2f}MB, "
+            f"CPU={cpu_mem:.2f}MB"
+        )
+
+        df = pd.DataFrame({
+            "Y_test": le.inverse_transform(y_test),
+            "Y_pred": le.inverse_transform(y_pred)
+        })
+        df.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 SVC_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)        
+        label = Y[:, 0]
+        best_params = SVC_GPU_he.Hyperparameter(X, label)
+        args.C = best_params['C']
+        args.kernel = best_params['kernel']
+        args.gamma = best_params['gamma']
+        args.degree = best_params['degree']
+        
+        start_time = time.time()
+        run_cv(args, X, label, handle)
+        
+        elapsed_time = time.time() - start_time
+        print(f"Total running time: {elapsed_time:.2f} s")
+        print("Successfully finished!")
+
+        if CUML_AVAILABLE:
+            cp.get_default_memory_pool().free_all_blocks()
+
+
+if __name__ == "__main__":
+    SVC_class()

gpbench/method_class/SVC/SVC_GPU_he.py

@@ -0,0 +1,106 @@
+import gc
+import random
+import time
+import torch
+import optuna
+import numpy as np
+
+from sklearn.model_selection import StratifiedKFold
+from sklearn.preprocessing import LabelEncoder
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+try:
+    import cupy as cp
+    from cuml.svm import SVC as cuSVC
+    CUML_AVAILABLE = True
+except ImportError:
+    from sklearn.svm import SVC
+    CUML_AVAILABLE = False
+
+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 run_cv_eval(data, label, C, kernel, gamma, degree):
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+
+    le = LabelEncoder()
+    y_all = le.fit_transform(label)
+
+    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]
+
+        if CUML_AVAILABLE:
+            X_train_gpu = cp.asarray(X_train, dtype=cp.float32)
+            X_test_gpu = cp.asarray(X_test, dtype=cp.float32)
+            y_train_gpu = cp.asarray(y_train, dtype=cp.int32)
+            
+            model = cuSVC(
+                C=C,
+                kernel=kernel,
+                gamma=gamma,
+                degree=degree,
+                probability=True
+            )
+            model.fit(X_train_gpu, y_train_gpu)
+            y_pred = model.predict(X_test_gpu)
+            y_pred = cp.asnumpy(y_pred)
+        else:
+            model = SVC(
+                C=C,
+                kernel=kernel,
+                gamma=gamma,
+                degree=degree,
+                probability=True
+            )
+            model.fit(X_train, y_train)
+            y_pred = model.predict(X_test)
+
+        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}: acc={acc:.4f}, prec={prec:.4f}, rec={rec:.4f}, f1={f1:.4f}") 
+
+        del model
+        if CUML_AVAILABLE:
+            cp.get_default_memory_pool().free_all_blocks()
+        gc.collect()
+
+    return (np.mean(accs), np.mean(precs), np.mean(recs), np.mean(f1s))
+
+def Hyperparameter(data, label):
+    set_seed(42)
+
+    def objective(trial):
+        C = trial.suggest_loguniform("C", 1e-3, 1)
+        kernel = trial.suggest_categorical("kernel", ["rbf", "poly"])
+        gamma = trial.suggest_categorical("gamma", ["scale", "auto"])
+        degree = trial.suggest_int("degree", 1, 5)
+
+        acc, prec, rec, f1 = run_cv_eval(data=data, label=label, C=C,
+            kernel=kernel, gamma=gamma, degree=degree)
+        return f1
+
+    study = optuna.create_study(direction="maximize")
+    study.optimize(objective, n_trials=20)
+
+    print("\n===== Best Parameters =====")
+    print(study.best_params)
+    print("Best macro-F1:", study.best_value)
+    print("Successfully finished Optuna search")
+
+    return study.best_params

gpbench/method_class/SVC/__init__.py

@@ -0,0 +1,5 @@
+from .SVC_GPU import SVC_class
+
+SVC = SVC_class
+
+__all__ = ["SVC","SVC_class"]

gpbench/method_class/SoyDNGP/AlexNet_206_class.py

@@ -0,0 +1,179 @@
+import torch
+from torch import nn 
+from torch.nn import Module
+import numpy as np
+class CA_Block(nn.Module):
+    def __init__(self, channel, h, w, reduction=16):
+        super(CA_Block, self).__init__()
+ 
+        self.h = h
+        self.w = w
+ 
+        self.avg_pool_x = nn.AdaptiveAvgPool2d((h, 1))
+        self.avg_pool_y = nn.AdaptiveAvgPool2d((1, w))
+ 
+        self.conv_1x1 = nn.Conv2d(in_channels=channel, out_channels=channel//reduction, kernel_size=1, stride=1, bias=False)
+ 
+        self.relu = nn.ReLU()
+        self.bn = nn.BatchNorm2d(channel//reduction)
+ 
+        self.F_h = nn.Conv2d(in_channels=channel//reduction, out_channels=channel, kernel_size=1, stride=1, bias=False)
+        self.F_w = nn.Conv2d(in_channels=channel//reduction, out_channels=channel, kernel_size=1, stride=1, bias=False)
+ 
+        self.sigmoid_h = nn.Sigmoid()
+        self.sigmoid_w = nn.Sigmoid()
+ 
+    def forward(self, x):
+ 
+        x_h = self.avg_pool_x(x).permute(0, 1, 3, 2)
+        x_w = self.avg_pool_y(x)
+ 
+        x_cat_conv_relu = self.relu(self.conv_1x1(torch.cat((x_h, x_w), 3)))
+ 
+        x_cat_conv_split_h, x_cat_conv_split_w = x_cat_conv_relu.split([self.h, self.w], 3)
+ 
+        s_h = self.sigmoid_h(self.F_h(x_cat_conv_split_h.permute(0, 1, 3, 2)))
+        s_w = self.sigmoid_w(self.F_w(x_cat_conv_split_w))
+ 
+        out = x * s_h.expand_as(x) * s_w.expand_as(x)
+ 
+        return out
+
+class AlexNet(nn.Module):
+    def __init__(self, num_classes):
+        super().__init__()
+        self.num_classes = num_classes
+        self.net = nn.Sequential(
+
+            nn.Conv2d(3,32,kernel_size=3,padding=1,padding_mode='reflect',stride=1,bias=False),
+            nn.BatchNorm2d(32),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            CA_Block(32,206,206,reduction=16),
+
+            nn.Conv2d(32,64,kernel_size=4,padding=1,padding_mode='reflect',stride=2,bias=False),
+            nn.BatchNorm2d(64),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Conv2d(64,64,kernel_size=3,padding=1,padding_mode='reflect',stride=2,bias=False),
+            nn.BatchNorm2d(64),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Conv2d(64,64,kernel_size=3,padding=1,padding_mode='reflect',stride=1,bias=False),
+            nn.BatchNorm2d(64),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Conv2d(64,128,kernel_size=3,padding=1,padding_mode='reflect',stride=1,bias=False),
+            nn.BatchNorm2d(128),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+            
+            nn.Conv2d(128,128,kernel_size=3,padding=1,padding_mode='reflect',stride=1,bias=False),
+            nn.BatchNorm2d(128),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Conv2d(128,256,kernel_size=2,stride=2,bias=False),
+            nn.BatchNorm2d(256),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Conv2d(256,256,kernel_size=3,padding=1,padding_mode='reflect',stride=1,bias=False),
+            nn.BatchNorm2d(256),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Conv2d(256,512,kernel_size=2,stride=2,bias=False),
+            nn.BatchNorm2d(512),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Conv2d(512,512,kernel_size=3,padding=1,padding_mode='reflect',stride=1,bias=False),
+            nn.BatchNorm2d(512),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+            
+            nn.Conv2d(512,1024,kernel_size=3,padding=1,padding_mode='reflect',stride=2,bias=False),
+            nn.BatchNorm2d(1024),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+            
+            nn.Conv2d(1024,1024,kernel_size=3,padding=1,padding_mode='reflect',stride=1,bias=False),
+            nn.BatchNorm2d(1024),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+            
+            CA_Block(1024,7,7,reduction=16),           
+            
+            nn.Flatten(),
+            nn.Dropout(0.3),
+            nn.ReLU(),
+
+            nn.Linear(50176, num_classes),
+        )
+    def forward(self, x):
+        x = x.permute(0, 3, 1, 2)
+        return self.net(x)
+    
+    def train_model(self, train_loader, valid_loader, num_epochs, learning_rate, patience, device):
+        optimizer = torch.optim.Adam(self.parameters(), lr=learning_rate, weight_decay=1e-5)
+        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, labels = inputs.to(device), labels.to(device).long()  # long() for classification
+                optimizer.zero_grad()
+                outputs = self(inputs)  # (B, num_classes)
+                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, labels = inputs.to(device), labels.to(device).long()
+                    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()
+        y_pred = []
+        with torch.no_grad():
+            for inputs, _ in test_loader:
+                outputs = self(inputs)  # (B, num_classes)
+                preds = torch.argmax(outputs, dim=1)  # (B,)
+                y_pred.append(preds.cpu().numpy())
+        y_pred = np.concatenate(y_pred, axis=0)
+        return y_pred

gpbench/method_class/SoyDNGP/SoyDNGP_class.py

@@ -0,0 +1,189 @@
+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 .AlexNet_206_class import AlexNet
+from torch.utils.data import DataLoader, TensorDataset
+from . import SoyDNGP_he_class
+import pynvml
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser")
+    parser.add_argument('--methods', type=str, default='SoyDNGP/', help='Random seed')
+    parser.add_argument('--species', type=str, default='Chicken/', help='Species name')
+    parser.add_argument('--phe', type=str, default='', help='Dataset name')
+    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, help='Number of training rounds')
+    parser.add_argument('--batch_size', type=int, default=32, help='Batch size')
+    parser.add_argument('--learning_rate', type=float, default=0.01, help='Learning rate')
+    parser.add_argument('--patience', type=int, default=10, help='Patience for early stopping')
+    args = parser.parse_args()
+    return args
+
+def get_data(dataframe):
+    data_matrix = np.array(dataframe)
+    total_sample, total_snp = data_matrix.shape
+
+    one_hot = np.zeros((total_sample, total_snp, 3), dtype=np.float32)
+    one_hot[data_matrix == 2] = [1, 1, 0]
+    one_hot[data_matrix == 1] = [1, 0, 1]
+    one_hot[data_matrix == 0] = [0, 1, 1]
+
+    target_snp = 206 * 206
+    if total_snp != target_snp:
+        print(f"⚠ SNP Number {total_snp} != {target_snp}")
+        new_one_hot = np.zeros((total_sample, target_snp, 3), dtype=np.float32)
+        copy_len = min(total_snp, target_snp)
+        new_one_hot[:, :copy_len] = one_hot[:, :copy_len]
+        one_hot = new_one_hot
+
+    one_hot = one_hot.reshape(total_sample, 206, 206, 3)
+    return one_hot
+
+
+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 = get_data(xData)
+    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):
+    procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
+    for p in procs:
+        if p.pid == pid:
+            return p.usedGpuMemory / 1024**2
+    return 0.0
+
+
+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)
+    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().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)
+
+        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)
+        valid_loader = DataLoader(valid_data, args.batch_size, shuffle=False)
+        test_loader = DataLoader(test_data, args.batch_size, shuffle=False)
+
+        model = AlexNet(num_classes=num_classes)
+        model.train_model(train_loader, valid_loader, args.epochs, args.learning_rate, 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_time
+        fold_gpu_mem = get_gpu_mem_by_pid(os.getpid())
+        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 SoyDNGP_class():
+    set_seed(42)
+    torch.cuda.empty_cache()  
+    pynvml.nvmlInit()
+    handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+    
+    args = parse_args()
+    all_species = ["Human/Sim/"]
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    args.device = device
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        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 = SoyDNGP_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()
+        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)
+
+        elapsed_time = time.time() - start_time
+        print(f"Running time: {elapsed_time:.2f}s")
+        print("successfully")
+
+
+if __name__ == "__main__":
+    SoyDNGP_class()