gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/BayesC/_param_free_base_model.py

@@ -0,0 +1,84 @@
+import abc
+import joblib
+import numpy as np
+import pathlib
+
+
+class ParamFreeBaseModel(abc.ABC):
+    """
+    BaseModel parent class for all models that do not have hyperparameters, e.g. BLUP.
+
+    Every model must be based on :obj:`~easypheno.model.param_free_base_model.ParamFreeBaseModel` directly or ParamFreeBaseModel's child classes.
+
+    Please add ``super().__init__(PARAMS)`` to the constructor in case you override it in a child class
+
+    **Attributes**
+
+        *Class attributes*
+
+        - standard_encoding (*str*): the standard encoding for this model
+        - possible_encodings (*List<str>*): a list of all encodings that are possible according to the model definition
+
+        *Instance attributes*
+
+        - task (*str*): ML task ('regression' or 'classification') depending on target variable
+        - encoding (*str*): the encoding to use (standard encoding or user-defined)
+
+
+    :param task: ML task (regression or classification) depending on target variable
+    :param encoding: the encoding to use (standard encoding or user-defined)
+
+    """
+
+    # Class attributes #
+    @property
+    @classmethod
+    @abc.abstractmethod
+    def standard_encoding(cls):
+        """the standard encoding for this model"""
+        raise NotImplementedError
+
+    @property
+    @classmethod
+    @abc.abstractmethod
+    def possible_encodings(cls):
+        """a list of all encodings that are possible according to the model definition"""
+        raise NotImplementedError
+
+    # Constructor super class #
+    def __init__(self, task: str, encoding: str = None):
+        self.task = task
+        self.encoding = self.standard_encoding if encoding is None else encoding
+
+    # Methods required by each child class #
+
+    @abc.abstractmethod
+    def fit(self, X: np.array, y: np.array) -> np.array:
+        """
+        Method that fits the model based on features X and targets y
+
+        :param X: feature matrix for retraining
+        :param y: target vector
+
+        :return: numpy array with values predicted for X
+        """
+
+    @abc.abstractmethod
+    def predict(self, X_in: np.array) -> np.array:
+        """
+        Method that predicts target values based on the input X_in
+
+        :param X_in: feature matrix as input
+
+        :return: numpy array with the predicted values
+        """
+
+    def save_model(self, path: pathlib.Path, filename: str):
+        """
+        Persist the whole model object on a hard drive
+        (can be loaded with :obj:`~easypheno.model._model_functions.load_model`)
+
+        :param path: path where the model will be saved
+        :param filename: filename of the model
+        """
+        joblib.dump(self, path.joinpath(filename), compress=3)

gpbench/method_class/BayesC/bayesCfromR.py

@@ -0,0 +1,16 @@
+from . import _bayesfromR
+
+
+class BayesC(_bayesfromR.Bayes_R):
+    """
+    Implementation of a class for Bayes C.
+
+    *Attributes*
+
+        *Inherited attributes*
+
+        See :obj:`~easypheno.model._bayesfromR.Bayes_R` for more information on the attributes.
+    """
+
+    def __init__(self, task: str, encoding: str = None):
+        super().__init__(task=task, model_name='BayesC', encoding=encoding)

gpbench/method_class/CropARNet/CropARNet_class.py

@@ -0,0 +1,186 @@
+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_CropARNet_class import SimpleSNPModel
+from . import CropARNet_he_class
+import pynvml
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser")
+    parser.add_argument('--methods', type=str, default='CropARNet/')
+    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=500)
+    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):
+    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("Number of samples:", xData.shape[0])
+    print("Number of 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 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_nested_cv(args, data, label, nsnp, num_classes, device, handle=None, le=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 = [], [], [], []
+    time_star = time.time()
+
+    for fold, (train_index, test_index) in enumerate(kf.split(data, label)):
+        print(f"\nRunning 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
+        )
+
+        x_train = torch.from_numpy(X_tr).float().to(device)
+        y_train_t = torch.from_numpy(y_tr).long().to(device)
+        x_valid = torch.from_numpy(X_val).float().to(device)
+        y_valid_t = torch.from_numpy(y_val).long().to(device)
+        x_test  = torch.from_numpy(X_test).float().to(device)
+        y_test_t = torch.from_numpy(y_test).long().to(device)
+
+        train_loader = DataLoader(TensorDataset(x_train, y_train_t), args.batch_size, shuffle=True)
+        valid_loader = DataLoader(TensorDataset(x_valid, y_valid_t), args.batch_size, shuffle=False)
+        test_loader  = DataLoader(TensorDataset(x_test, y_test_t), args.batch_size, shuffle=False)
+
+        model = SimpleSNPModel(num_snps = nsnp, num_classes=num_classes)
+        model.train_model(
+            train_loader,
+            valid_loader,
+            args.epochs,
+            args.learning_rate,
+            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(), handle) if handle else 0.0
+        cpu_mem = process.memory_info().rss / 1024**2
+
+        print(
+            f"Fold {fold}: ACC={acc:.4f}, PREC={prec:.4f}, "
+            f"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_true": le.inverse_transform(y_test),
+            "y_pred": le.inverse_transform(y_pred)
+        }).to_csv(
+            os.path.join(result_dir, f"fold{fold}.csv"), index=False
+        )
+
+        torch.cuda.empty_cache()
+
+    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: {time.time() - time_star:.2f}s")
+
+
+def CropARNet_class():
+    set_seed(42)
+    pynvml.nvmlInit()
+    handle = pynvml.nvmlDeviceGetHandleByIndex(0)
+
+    args = parse_args()
+    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+    all_species = ["Human/Sim/"]
+
+    for sp in all_species:
+        args.species = sp
+        X, Y, _, nsnp, names = load_data(args)
+
+        print("Starting:", args.methods + args.species)
+        if Y.ndim == 1:
+            label = Y
+        else:
+            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))
+        
+        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 = CropARNet_he_class.Hyperparameter(X, label, nsnp)
+        args.learning_rate = best_params["learning_rate"]
+        args.batch_size = best_params["batch_size"]
+        args.weight_decay = best_params["weight_decay"]
+        args.patience = best_params["patience"]
+        start_time = time.time() 
+        torch.cuda.reset_peak_memory_stats()
+        process = psutil.Process(os.getpid())
+
+        run_nested_cv(args, X, label, nsnp, num_classes, device, handle, le)
+        elapsed_time = time.time() - start_time
+        print(f"运行时间: {elapsed_time:.2f} 秒")
+        print("successfully")
+
+
+
+if __name__ == "__main__":
+    CropARNet_class()

gpbench/method_class/CropARNet/CropARNet_he_class.py

@@ -0,0 +1,154 @@
+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_CropARNet_class import SimpleSNPModel
+
+def run_nested_cv_with_early_stopping(
+    data,
+    label,
+    nsnp,
+    num_classes,
+    learning_rate,
+    weight_decay,
+    patience,
+    batch_size,
+    num_round=500
+):
+    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 = [], [], [], []
+
+    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)
+
+        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 = SimpleSNPModel(num_snps = nsnp, num_classes=num_classes)
+
+        model.train_model(
+            train_loader,
+            valid_loader,
+            num_round,
+            learning_rate,
+            weight_decay,
+            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
+        )
+
+        if np.isnan(f1):
+            print(f"Fold {fold} resulted in NaN F1, pruning 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}, "
+            f"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) 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):
+    set_seed(42)
+    le = LabelEncoder()
+    label = le.fit_transform(label)
+    num_classes = len(np.unique(label))
+
+    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])
+        weight_decay = trial.suggest_categorical(
+            "weight_decay", [1e-4, 1e-3, 1e-2, 1e-1]
+        )
+        patience = trial.suggest_int("patience", 5, 30)
+
+        try:
+            f1_score = run_nested_cv_with_early_stopping(
+                data=data,
+                label=label,
+                nsnp=nsnp,
+                num_classes=num_classes,
+                learning_rate=learning_rate,
+                weight_decay=weight_decay,
+                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 hyperparameters:", study.best_params)
+    print("successfully")
+    return study.best_params

gpbench/method_class/CropARNet/__init__.py

@@ -0,0 +1,5 @@
+from .CropARNet_class import CropARNet_class
+
+CropARNet = CropARNet_class
+
+__all__ = ["CropARNet","CropARNet_class"]

gpbench/method_class/CropARNet/base_CropARNet_class.py

@@ -0,0 +1,178 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+config = {
+    "batch_size": 64,
+    "weights_units": [64, 32],
+    "classifier_units": [64, 32],
+    "dropout": 0.3,
+}
+
+
+class SimpleSNPModel(nn.Module):
+    """
+    Classification version of SimpleSNPModel
+    (Attention + Residual + MLP)
+    """
+
+    def __init__(self, num_snps: int, num_classes: int):
+        super().__init__()
+
+        if not isinstance(num_snps, int) or num_snps <= 0:
+            raise ValueError(f"num_snps must be positive integer, got {num_snps}")
+        if not isinstance(num_classes, int) or num_classes <= 1:
+            raise ValueError(f"num_classes must be >=2, got {num_classes}")
+
+        self.config = config
+        self.num_classes = num_classes
+
+        self.attention = self._build_attention_module(num_snps)
+        self.classifier = self._build_classifier_module(num_snps, num_classes)
+
+    # ==================================================
+    # Attention module
+    # ==================================================
+    def _build_attention_module(self, num_snps):
+        layers = []
+        prev_size = num_snps
+
+        for i, h_size in enumerate(self.config["weights_units"]):
+            if h_size <= 0:
+                raise ValueError(f"Invalid hidden size {h_size}")
+            layers.append(nn.Linear(prev_size, h_size))
+            layers.append(nn.GELU())
+            prev_size = h_size
+
+        layers.append(nn.Linear(prev_size, num_snps))
+        layers.append(nn.Sigmoid())
+        return nn.Sequential(*layers)
+
+    # ==================================================
+    # Classifier module
+    # ==================================================
+    def _build_classifier_module(self, num_snps, num_classes):
+        layers = []
+        prev_size = num_snps
+
+        for i, h_size in enumerate(self.config["classifier_units"]):
+            if h_size <= 0:
+                raise ValueError(f"Invalid hidden size {h_size}")
+            layers.append(nn.Linear(prev_size, h_size))
+            layers.append(nn.LayerNorm(h_size))
+            layers.append(nn.GELU())
+            layers.append(nn.Dropout(self.config["dropout"]))
+            prev_size = h_size
+
+        layers.append(nn.Linear(prev_size, num_classes))
+        return nn.Sequential(*layers)
+
+    # ==================================================
+    # Forward
+    # ==================================================
+    def forward(self, x):
+        if x.dim() != 2:
+            raise ValueError(f"Input must be 2D tensor, got {x.dim()}D")
+
+        # Attention
+        pre_sigmoid_weights = self.attention[:-1](x)
+        att_weights = self.attention(x)
+
+        # Residual weighted SNPs
+        weighted = x * att_weights + x
+
+        logits = self.classifier(weighted)
+        return logits, pre_sigmoid_weights
+
+    # ==================================================
+    # Training (classification)
+    # ==================================================
+    def train_model(
+        self,
+        train_loader,
+        valid_loader,
+        num_epochs,
+        learning_rate,
+        weight_decay,
+        patience,
+        device
+    ):
+        self.to(device)
+
+        optimizer = torch.optim.AdamW(
+            self.parameters(),
+            lr=learning_rate,
+            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).long()
+
+                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).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 = 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
+
+    # ==================================================
+    # 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)  # logits
+                preds = torch.argmax(outputs, dim=1)
+                y_pred.append(preds.cpu().numpy())
+
+        return np.concatenate(y_pred, axis=0)