gpbench 1.0.0__py3-none-any.whl

gpbench/method_class/BayesA/_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/BayesA/bayesAfromR.py

@@ -0,0 +1,16 @@
+from . import _bayesfromR
+
+
+class BayesA(_bayesfromR.Bayes_R):
+    """
+    Implementation of a class for Bayes A.
+
+    *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='BayesA', encoding=encoding)

gpbench/method_class/BayesB/BayesB_class.py

@@ -0,0 +1,140 @@
+import os
+import time
+import psutil
+import swanlab
+import argparse
+import random
+import torch
+import numpy as np
+import pandas as pd
+import sys
+from .bayesBfromR import BayesB
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+from sklearn.preprocessing import LabelEncoder
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser")
+    parser.add_argument('--methods', type=str, default='BayesB/', help='Model name')
+    parser.add_argument('--species', type=str, default='Human/', help='Species name')
+    parser.add_argument('--phe', type=str, default='', help='Phenotype name')
+    parser.add_argument('--task', type=str, default='classification', choices=['regression','classification'], help='Task: regression or classification')
+    parser.add_argument('--data_dir', type=str, default='../../data/', help='Path to data directory')
+    parser.add_argument('--result_dir', type=str, default='result/', help='Path to result directory')
+    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"]
+
+    nsample = xData.shape[0]
+    nsnp = xData.shape[1]
+    print("Number of samples: ", nsample)
+    print("Number of SNPs: ", nsnp)
+    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 run_nested_cv(args, data, label):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species)
+    os.makedirs(result_dir, exist_ok=True)
+    print("Starting 10-fold cross-validation...")
+
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+    le = LabelEncoder()
+    label_all = le.fit_transform(label)
+    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_index, test_index) in enumerate(kf.split(data, label_all)):
+        fold_start = time.time()
+        print(f"\n===== Fold {fold} =====")
+        X_train, X_test = data[train_index], data[test_index]
+        Y_train, Y_test = label_all[train_index], label_all[test_index]
+
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+
+        classes = np.unique(Y_train)
+        scores = np.zeros((len(classes), X_test.shape[0]))
+        for idx, cls in enumerate(classes):
+            y_train_bin = (Y_train == cls).astype(float)
+            model_k = BayesB(task="regression")
+            model_k.fit(X_train, y_train_bin)
+            scores[idx, :] = model_k.predict(X_test)
+
+        Y_pred = np.argmax(scores, axis=0)
+
+        acc = accuracy_score(Y_test, Y_pred)
+        prec, rec, f1, _ = precision_recall_fscore_support(Y_test, Y_pred, average='macro', zero_division=0)
+        cm = confusion_matrix(Y_test, Y_pred)
+
+        all_acc.append(acc)
+        all_prec.append(prec)
+        all_rec.append(rec)
+        all_f1.append(f1)
+
+        fold_time = time.time() - fold_start
+        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}: ACC={acc:.4f}, PREC={prec:.4f}, REC={rec:.4f}, F1={f1:.4f}, Time={fold_time:.2f}s, '
+              f'GPU={fold_gpu_mem:.2f}MB, CPU={fold_cpu_mem:.2f}MB')
+
+        Y_test_orig = le.inverse_transform(Y_test)
+        Y_pred_orig = le.inverse_transform(Y_pred)
+        results_df = pd.DataFrame({'Y_test': Y_test_orig, 'Y_pred': Y_pred_orig})
+        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"Total time : {time.time() - start_time:.2f}s")
+
+
+def BayesB_class():
+    set_seed(42)
+    torch.cuda.empty_cache()
+    args = parse_args()
+    all_species = ["Human/Sim/"]
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        X, Y, nsamples, nsnp, names = load_data(args)
+        args.phe = names
+        print("Starting run " + args.methods + args.species)
+        label = Y[:, 0]
+
+        if args.task == 'classification':
+            s = pd.Series(label)
+            fill_val = s.mode().iloc[0] if not s.dropna().empty else 0
+            label = np.nan_to_num(label, nan=fill_val)
+
+        start_time = time.time()
+        torch.cuda.reset_peak_memory_stats()
+        process = psutil.Process(os.getpid())
+
+        run_nested_cv(args, data=X, label=label)
+
+        elapsed_time = time.time() - start_time
+        print(f"Total running time: {elapsed_time:.2f} s")
+        print("Successfully finished!")
+
+
+if __name__ == "__main__":
+    BayesB_class()

gpbench/method_class/BayesB/__init__.py

@@ -0,0 +1,5 @@
+from .BayesB_class import BayesB_class
+
+BayesB = BayesB_class
+
+__all__ = ["BayesB","BayesB_class"]

gpbench/method_class/BayesB/_bayesfromR.py

@@ -0,0 +1,96 @@
+import numpy as np
+import rpy2
+from rpy2.robjects import numpy2ri
+rpy2.robjects.numpy2ri.activate()
+import rpy2.robjects as robjects
+from rpy2.robjects.packages import importr
+from . import _param_free_base_model
+from joblib import Parallel, delayed
+
+class Bayes_R(_param_free_base_model.ParamFreeBaseModel):
+    """
+    Implementation of a class for Bayesian alphabet.
+
+    *Attributes*
+
+        *Inherited attributes*
+
+        See :obj:`~easypheno.model._param_free_base_model.ParamFreeBaseModel` for more information on the attributes.
+
+        *Additional attributes*
+
+        - mu (*np.array*): intercept
+        - beta (*np.array*): effect size
+        - model_name (*str*): model to use (BayesA, BayesB or BayesC)
+        - n_iter (*int*): iterations for sampling
+        - burn_in (*int*): warmup/burnin for sampling
+    """
+    standard_encoding = '012'
+    possible_encodings = ['101']
+
+    def __init__(self, task: str, model_name: str, encoding: str = None, n_iter: int =1000, burn_in: int = 200):
+        super().__init__(task=task, encoding=encoding)
+        self.model_name = model_name
+        self.n_iter = n_iter
+        self.burn_in = burn_in
+        self.n_jobs = 1
+        self.mu = None
+        self.beta = None
+
+    def _run_chain(self, chain_num: int, R_X, R_y):
+        """
+        Helper function to run an individual MCMC chain.
+        """
+        BGLR = importr('BGLR')
+
+        # Run BGLR for BayesB on a single chain
+        ETA = robjects.r['list'](robjects.r['list'](X=R_X, model=self.model_name))
+        fmBB = BGLR.BGLR(y=R_y, ETA=ETA, verbose=False, nIter=self.n_iter, burnIn=self.burn_in)
+
+        # Extract the results for this chain
+        beta_chain = np.asarray(fmBB.rx2('ETA').rx2(1).rx2('b'))
+        mu_chain = np.asarray(fmBB.rx2('mu'))  # Extract mu (intercept) for this chain
+        return beta_chain, mu_chain
+
+    def fit(self, X: np.array, y: np.array) -> np.array:
+        """
+        Implementation of fit function for Bayesian alphabet imported from R.
+
+        See :obj:`~easypheno.model._param_free_base_model.ParamFreeBaseModel` for more information.
+        """
+        # import necessary R packages
+        base = importr('base')
+        BGLR = importr('BGLR')
+
+        # create R objects for X and y
+        R_X = robjects.r['matrix'](X, nrow=X.shape[0], ncol=X.shape[1])
+        R_y = robjects.FloatVector(y)
+
+        results = Parallel(n_jobs=self.n_jobs)(
+            delayed(self._run_chain)(chain_num, R_X, R_y) for chain_num in range(self.n_jobs)
+        )
+
+        # Aggregate results from all chains
+        beta_chains = [result[0] for result in results]
+        mu_chains = [result[1] for result in results]
+
+        # Compute the mean of beta and mu over all chains
+        self.beta = np.mean(beta_chains, axis=0)
+        self.mu = np.mean(mu_chains, axis=0)
+
+        # run BGLR for BayesB
+        # ETA = base.list(base.list(X=R_X, model=self.model_name))
+        # fmBB = BGLR.BGLR(y=R_y, ETA=ETA, verbose=True, nIter=self.n_iter, burnIn=self.burn_in)
+
+        # # save results as numpy arrays
+        # self.beta = np.asarray(fmBB.rx2('ETA').rx2(1).rx2('b'))
+        # self.mu = fmBB.rx2('mu')
+        return self.predict(X_in=X)
+
+    def predict(self, X_in: np.array) -> np.array:
+        """
+        Implementation of predict function for Bayesian alphabet model imported from R.
+
+        See :obj:`~easypheno.model._param_free_base_model.ParamFreeBaseModel` for more information.
+        """
+        return self.mu + np.matmul(X_in, self.beta)

gpbench/method_class/BayesB/_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/BayesB/bayesBfromR.py

@@ -0,0 +1,16 @@
+from . import _bayesfromR
+
+
+class BayesB(_bayesfromR.Bayes_R):
+    """
+    Implementation of a class for Bayes B.
+
+    *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='BayesB', encoding=encoding)

gpbench/method_class/BayesC/BayesC_class.py

@@ -0,0 +1,141 @@
+import os
+import time
+import psutil
+import swanlab
+import argparse
+import random
+import torch
+import numpy as np
+import pandas as pd
+import sys
+from .bayesCfromR import BayesC
+from sklearn.model_selection import StratifiedKFold
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+from sklearn.preprocessing import LabelEncoder
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="Argument parser")
+    parser.add_argument('--methods', type=str, default='BayesC/', help='Model name')
+    parser.add_argument('--species', type=str, default='Human/', help='Species name')
+    parser.add_argument('--phe', type=str, default='', help='Phenotype name')
+    parser.add_argument('--task', type=str, default='classification', choices=['regression','classification'], help='Task: regression or classification')
+    parser.add_argument('--data_dir', type=str, default='../../data/', help='Path to data directory')
+    parser.add_argument('--result_dir', type=str, default='result/', help='Path to result directory')
+    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"]
+
+    nsample = xData.shape[0]
+    nsnp = xData.shape[1]
+    print("Number of samples: ", nsample)
+    print("Number of SNPs: ", nsnp)
+    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 run_nested_cv(args, data, label):
+    result_dir = os.path.join(args.result_dir, args.methods + args.species)
+    os.makedirs(result_dir, exist_ok=True)
+    print("Starting 10-fold cross-validation...")
+
+    kf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)
+    le = LabelEncoder()
+    label_all = le.fit_transform(label)
+
+    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_index, test_index) in enumerate(kf.split(data, label_all)):
+        fold_start = time.time()
+        print(f"\n===== Fold {fold} =====")
+        X_train, X_test = data[train_index], data[test_index]
+        Y_train, Y_test = label_all[train_index], label_all[test_index]
+
+        if torch.cuda.is_available():
+            torch.cuda.reset_peak_memory_stats()
+
+        classes = np.unique(Y_train)
+        scores = np.zeros((len(classes), X_test.shape[0]))
+        for idx, cls in enumerate(classes):
+            y_train_bin = (Y_train == cls).astype(float)
+            model_k = BayesC(task="regression")
+            model_k.fit(X_train, y_train_bin)
+            scores[idx, :] = model_k.predict(X_test)
+
+        Y_pred = np.argmax(scores, axis=0)
+
+        acc = accuracy_score(Y_test, Y_pred)
+        prec, rec, f1, _ = precision_recall_fscore_support(Y_test, Y_pred, average='macro', zero_division=0)
+        cm = confusion_matrix(Y_test, Y_pred)
+
+        all_acc.append(acc)
+        all_prec.append(prec)
+        all_rec.append(rec)
+        all_f1.append(f1)
+
+        fold_time = time.time() - fold_start
+        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}: ACC={acc:.4f}, PREC={prec:.4f}, REC={rec:.4f}, F1={f1:.4f}, Time={fold_time:.2f}s, '
+              f'GPU={fold_gpu_mem:.2f}MB, CPU={fold_cpu_mem:.2f}MB')
+
+        Y_test_orig = le.inverse_transform(Y_test)
+        Y_pred_orig = le.inverse_transform(Y_pred)
+        results_df = pd.DataFrame({'Y_test': Y_test_orig, 'Y_pred': Y_pred_orig})
+        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"Total time : {time.time() - start_time:.2f}s")
+
+
+
+def BayesC_class():
+    set_seed(42)
+    torch.cuda.empty_cache()
+    args = parse_args()
+    all_species = ["Human/Sim/"]
+    for i in range(len(all_species)):
+        args.species = all_species[i]
+        X, Y, nsamples, nsnp, names = load_data(args)
+        args.phe = names
+        print("Starting run " + args.methods + args.species)
+        label = Y[:, 0]
+
+        if args.task == 'classification':
+            s = pd.Series(label)
+            fill_val = s.mode().iloc[0] if not s.dropna().empty else 0
+            label = np.nan_to_num(label, nan=fill_val)
+
+        start_time = time.time()
+        torch.cuda.reset_peak_memory_stats()
+        process = psutil.Process(os.getpid())
+        run_nested_cv(args, data=X, label=label)
+
+        elapsed_time = time.time() - start_time
+        print(f"Total running time: {elapsed_time:.2f} s")
+        print("Successfully finished!")
+
+
+if __name__ == "__main__":
+    BayesC_class()

gpbench/method_class/BayesC/__init__.py

@@ -0,0 +1,4 @@
+from .BayesC_class import BayesC_class
+
+BayesC = BayesC_class
+__all__ = ["BayesC","BayesC_class"]

gpbench/method_class/BayesC/_bayesfromR.py

@@ -0,0 +1,96 @@
+import numpy as np
+import rpy2
+from rpy2.robjects import numpy2ri
+rpy2.robjects.numpy2ri.activate()
+import rpy2.robjects as robjects
+from rpy2.robjects.packages import importr
+from . import _param_free_base_model
+from joblib import Parallel, delayed
+
+class Bayes_R(_param_free_base_model.ParamFreeBaseModel):
+    """
+    Implementation of a class for Bayesian alphabet.
+
+    *Attributes*
+
+        *Inherited attributes*
+
+        See :obj:`~easypheno.model._param_free_base_model.ParamFreeBaseModel` for more information on the attributes.
+
+        *Additional attributes*
+
+        - mu (*np.array*): intercept
+        - beta (*np.array*): effect size
+        - model_name (*str*): model to use (BayesA, BayesB or BayesC)
+        - n_iter (*int*): iterations for sampling
+        - burn_in (*int*): warmup/burnin for sampling
+    """
+    standard_encoding = '012'
+    possible_encodings = ['101']
+
+    def __init__(self, task: str, model_name: str, encoding: str = None, n_iter: int =1000, burn_in: int = 200):
+        super().__init__(task=task, encoding=encoding)
+        self.model_name = model_name
+        self.n_iter = n_iter
+        self.burn_in = burn_in
+        self.n_jobs = 1
+        self.mu = None
+        self.beta = None
+
+    def _run_chain(self, chain_num: int, R_X, R_y):
+        """
+        Helper function to run an individual MCMC chain.
+        """
+        BGLR = importr('BGLR')
+
+        # Run BGLR for BayesB on a single chain
+        ETA = robjects.r['list'](robjects.r['list'](X=R_X, model=self.model_name))
+        fmBB = BGLR.BGLR(y=R_y, ETA=ETA, verbose=False, nIter=self.n_iter, burnIn=self.burn_in)
+
+        # Extract the results for this chain
+        beta_chain = np.asarray(fmBB.rx2('ETA').rx2(1).rx2('b'))
+        mu_chain = np.asarray(fmBB.rx2('mu'))  # Extract mu (intercept) for this chain
+        return beta_chain, mu_chain
+
+    def fit(self, X: np.array, y: np.array) -> np.array:
+        """
+        Implementation of fit function for Bayesian alphabet imported from R.
+
+        See :obj:`~easypheno.model._param_free_base_model.ParamFreeBaseModel` for more information.
+        """
+        # import necessary R packages
+        base = importr('base')
+        BGLR = importr('BGLR')
+
+        # create R objects for X and y
+        R_X = robjects.r['matrix'](X, nrow=X.shape[0], ncol=X.shape[1])
+        R_y = robjects.FloatVector(y)
+
+        results = Parallel(n_jobs=self.n_jobs)(
+            delayed(self._run_chain)(chain_num, R_X, R_y) for chain_num in range(self.n_jobs)
+        )
+
+        # Aggregate results from all chains
+        beta_chains = [result[0] for result in results]
+        mu_chains = [result[1] for result in results]
+
+        # Compute the mean of beta and mu over all chains
+        self.beta = np.mean(beta_chains, axis=0)
+        self.mu = np.mean(mu_chains, axis=0)
+
+        # run BGLR for BayesB
+        # ETA = base.list(base.list(X=R_X, model=self.model_name))
+        # fmBB = BGLR.BGLR(y=R_y, ETA=ETA, verbose=True, nIter=self.n_iter, burnIn=self.burn_in)
+
+        # # save results as numpy arrays
+        # self.beta = np.asarray(fmBB.rx2('ETA').rx2(1).rx2('b'))
+        # self.mu = fmBB.rx2('mu')
+        return self.predict(X_in=X)
+
+    def predict(self, X_in: np.array) -> np.array:
+        """
+        Implementation of predict function for Bayesian alphabet model imported from R.
+
+        See :obj:`~easypheno.model._param_free_base_model.ParamFreeBaseModel` for more information.
+        """
+        return self.mu + np.matmul(X_in, self.beta)