pg-sui 1.0.2.1__py3-none-any.whl → 1.6.8__py3-none-any.whl

test/test.py

@@ -1,297 +0,0 @@
-import unittest
-import pprint
-from snpio import GenotypeData
-from pgsui import *
-from pgsui.utils.misc import HiddenPrints
-import matplotlib.pyplot as plt
-import numpy as np
-
-from sklearn.metrics import (
-    roc_auc_score,
-    precision_recall_fscore_support,
-    f1_score,
-    average_precision_score,
-    accuracy_score,
-)
-
-from sklearn.preprocessing import label_binarize
-
-from sklearn.utils.class_weight import compute_class_weight
-
-
-# Initialize dictionaries to store metrics for all methods
-all_accuracies = {}
-all_auc_rocs = {}
-all_precisions = {}
-all_recalls = {}
-all_avg_precisions = {}
-all_f1s = {}
-
-
-def plot_scoring_metrics():
-    """
-    Plot the accumulated scoring metrics for all test methods in separate subplots.
-
-    Args:
-        None
-
-    Returns:
-        None: The function generates a grouped bar chart displaying the scoring metrics.
-    """
-
-    metrics = [
-        "Accuracy",
-        "AUC-ROC",
-        "Precision",
-        "Recall",
-        "Average Precision",
-        "F1 Score",
-    ]
-    metric_dicts = [
-        all_accuracies,
-        all_auc_rocs,
-        all_precisions,
-        all_recalls,
-        all_avg_precisions,
-        all_f1s,
-    ]
-
-    num_metrics = len(metrics)
-    fig, axes = plt.subplots(2, num_metrics // 2, figsize=(20, 20))
-
-    # Loop through each metric and its corresponding dictionary
-    colcount = 0
-    rowcount = 0
-
-    for i, (metric, metric_dict) in enumerate(zip(metrics, metric_dicts)):
-        if i > 0 and i % num_metrics // 2 == 0:
-            rowcount += 1
-            colcount = 0
-
-        methods = list(metric_dict.keys())
-        values = list(metric_dict.values())
-
-        # Find the index of the highest bar
-        highest_bar_idx = np.argmax(values)
-
-        # Create the bar plot on the i-th subplot
-        bars = axes[rowcount, colcount].bar(methods, values, color="gray")
-
-        # Color the highest bar in orange
-        bars[highest_bar_idx].set_color("orange")
-
-        # Rotate x-axis labels
-        axes[rowcount, colcount].tick_params(axis="x", rotation=90)
-
-        # Annotate the bars with the actual values
-        for j, v in enumerate(values):
-            axes[rowcount, colcount].text(
-                j, v, f"{v:.2f}", ha="center", va="bottom"
-            )
-
-        axes[rowcount, colcount].set_title(metric)
-        axes[rowcount, colcount].set_ylabel("Score")
-        colcount += 1
-
-    plt.suptitle("Scoring Metrics for All Methods")
-
-    fig.savefig("scores.png", facecolor="white", bbox_inches="tight")
-
-
-class TestMyClasses(unittest.TestCase):
-    def setUp(self):
-        with HiddenPrints():
-            self.genotype_data = GenotypeData(
-                filename="pgsui/example_data/phylip_files/test_n100.phy",
-                popmapfile="pgsui/example_data/popmaps/test.popmap",
-                guidetree="pgsui/example_data/trees/test.tre",
-                qmatrix="pgsui/example_data/trees/test.qmat",
-                siterates="pgsui/example_data/trees/test_siterates_n100.txt",
-                prefix="test_imputer",
-                force_popmap=True,
-                plot_format="png",
-            )
-
-            # Create a SimGenotypeDataTransformer instance and use it
-            # to simulate missing data
-            self.transformer = SimGenotypeDataTransformer(
-                genotype_data=self.genotype_data,
-                prop_missing=0.2,
-                strategy="random",
-            )
-            self.transformer.fit(self.genotype_data.genotypes_012(fmt="numpy"))
-            self.simulated_data = self.genotype_data.copy()
-
-            self.simulated_data.genotypes_012 = self.transformer.transform(
-                self.genotype_data.genotypes_012(fmt="numpy")
-            )
-
-    def _test_class(self, class_instance, do_gridsearch=False):
-        print(f"\nMETHOD: {class_instance.__name__}\n")
-
-        if do_gridsearch:
-            # Do a simple test.
-            if class_instance in [ImputeRandomForest, ImputeXGBoost]:
-                param_grid = {"n_estimators": [50, 100]}  # Do a simple test
-            elif class_instance in [
-                ImputeVAE,
-                ImputeStandardAutoEncoder,
-                ImputeNLPCA,
-                ImputeUBP,
-            ]:
-                param_grid = {"dropout_rate": [0.1, 0.2]}
-            elif class_instance == ImputeKNN:
-                param_grid = {"n_neighbors": [5, 8]}
-        else:
-            param_grid = None
-
-        instance = class_instance(
-            self.simulated_data,
-            gridparams=param_grid,
-            sample_weights=None,
-        )
-        imputed_data = instance.imputed.genotypes_int
-
-        # Test that the imputed values are close to the original values
-        # accuracy = self.transformer.accuracy(
-        #     self.genotype_data.genotypes_012(fmt="numpy"), imputed_data
-        # )
-
-        (
-            accuracy,
-            auc_roc_scores,
-            precision_scores,
-            recall_scores,
-            avg_precision_scores,
-            f1,
-        ) = self._scoring_metrics(
-            self.genotype_data.genotypes_int, imputed_data
-        )
-
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"ACCURACY: {accuracy}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"AUC-ROC: {auc_roc_scores}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"PRECISION: {precision_scores}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"RECALL: {recall_scores}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"AVERAGE PRECISION: {avg_precision_scores}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"F1 SCORE: {f1}"
-        )
-        print("\n")
-
-        # Store metrics
-        all_accuracies[class_instance.__name__] = accuracy
-        all_auc_rocs[class_instance.__name__] = auc_roc_scores
-        all_precisions[class_instance.__name__] = precision_scores
-        all_recalls[class_instance.__name__] = recall_scores
-        all_avg_precisions[class_instance.__name__] = avg_precision_scores
-        all_f1s[class_instance.__name__] = f1
-        plot_scoring_metrics()
-
-    def test_ImputeKNN(self):
-        self._test_class(ImputeKNN)
-
-    def test_ImputeRandomForest(self):
-        self._test_class(ImputeRandomForest)
-
-    def test_ImputeXGBoost(self):
-        self._test_class(ImputeXGBoost)
-
-    def test_ImputeVAE(self):
-        self._test_class(ImputeVAE)
-
-    def test_ImputeStandardAutoEncoder(self):
-        self._test_class(ImputeStandardAutoEncoder)
-
-    def test_ImputeUBP(self):
-        self._test_class(ImputeUBP)
-
-    def test_ImputeNLPCA(self):
-        self._test_class(ImputeNLPCA)
-
-    def test_ImputeKNN_grid(self):
-        self._test_class(ImputeKNN, do_gridsearch=True)
-
-    def test_ImputeRandomForest_grid(self):
-        self._test_class(ImputeRandomForest, do_gridsearch=True)
-
-    def test_ImputeXGBoost_grid(self):
-        self._test_class(ImputeXGBoost, do_gridsearch=True)
-
-    def test_ImputeVAE_grid(self):
-        self._test_class(ImputeVAE, do_gridsearch=True)
-
-    def test_ImputeStandardAutoEncoder_grid(self):
-        self._test_class(ImputeStandardAutoEncoder, do_gridsearch=True)
-
-    def test_ImputeUBP_grid(self):
-        self._test_class(ImputeUBP, do_gridsearch=True)
-
-    def test_ImputeNLPCA_grid(self):
-        self._test_class(ImputeNLPCA, do_gridsearch=True)
-
-    def test_ImputePhylo(self):
-        self._test_class(ImputePhylo)
-
-    def test_ImputeAlleleFreq(self):
-        self._test_class(ImputeAlleleFreq)
-
-    def test_ImputeMF(self):
-        self._test_class(ImputeMF)
-
-    def test_ImputeRefAllele(self):
-        self._test_class(ImputeRefAllele)
-
-    def _scoring_metrics(self, y_true, y_pred):
-        """Calcuate AUC-ROC, Precision-Recall, and Average Precision (AP).
-
-        Args:
-            X_true (np.ndarray): True values.
-
-            X_pred (np.ndarray): Imputed values.
-
-        Returns:
-            List[float]: List of AUC-ROC scores in order of: 0,1,2.
-            List[float]: List of precision scores in order of: 0,1,2.
-            List[float]: List of recall scores in order of: 0,1,2.
-            List[float]: List of average precision scores in order of 0,1,2.
-
-        """
-        y_true = y_true[self.transformer.sim_missing_mask_]
-        y_pred = y_pred[self.transformer.sim_missing_mask_]
-
-        # Binarize the output
-        y_true_bin = label_binarize(y_true, classes=[0, 1, 2])
-        y_pred_bin = label_binarize(y_pred, classes=[0, 1, 2])
-
-        accuracy = accuracy_score(y_true, y_pred)
-
-        # AUC-ROC score
-        auc_roc = roc_auc_score(y_true_bin, y_pred_bin, average="weighted")
-
-        # Precision-recall score
-        precision, recall, _, _ = precision_recall_fscore_support(
-            y_true_bin, y_pred_bin, average="weighted"
-        )
-
-        # Average precision score
-        avg_precision = average_precision_score(
-            y_true_bin, y_pred_bin, average="weighted"
-        )
-
-        f1 = f1_score(y_true_bin, y_pred_bin, average="weighted")
-
-        return (accuracy, auc_roc, precision, recall, avg_precision, f1)
-
-
-if __name__ == "__main__":
-    unittest.main()

test/test_pgsui.py

@@ -1,374 +0,0 @@
-#!/usr/bin/env python
-
-# Standard library imports
-import os
-import sys
-
-from contextlib import redirect_stdout
-
-try:
-    from importlib.resources import files, as_file
-except ImportError:
-    # Try backported to PY<37 `importlib_resources`.
-    from importlib_resources import files, as_file
-
-import numpy as np
-import pandas as pd
-import scipy.stats as stats
-
-from sklearn_genetic.space import Continuous, Categorical, Integer
-
-from pgsui import GenotypeData
-from pgsui.impute.estimators import *
-from pgsui.impute.simple_imputers import *
-from pgsui.example_data import structure_files, phylip_files, popmaps, trees
-
-
-def main():
-    """Test all PG-SUI Methods.
-
-    Can be invoked by typing 'pgsuitest' on the command line.
-    """
-
-    # Redirect stdout to logfile
-    with open("pgsuitest.log.txt", "w") as logfile:
-        with redirect_stdout(logfile):
-            testaln = {
-                "phylip": "test_n10.phy",
-                "structure2row": "test.nopops.2row.10sites.str",
-                "structure2rowPopID": "test.pops.2row.10sites.str",
-                "structure1row": "test.nopops.1row.10sites.str",
-                "structure1rowPopID": "test.pops.1row.10sites.str",
-            }
-
-            popmap = "test.popmap"
-            tre = "test.tre"
-            iqtre = "test.iqtree"
-            qmat = "test.qmat"
-            siterateiqtree = "test_n10.rate"
-            siterate = "test_siterates_n10.txt"
-            prefix = "setuptest"
-            t = ".xxinput_treexx.tre"  # temporary treefile
-
-            strfile = files(structure_files).joinpath(testaln["structure2row"])
-            popmapfile = files(popmaps).joinpath(popmap)
-            treefile = files(trees).joinpath(tre)
-            iqtreeqmatfile = files(trees).joinpath(iqtre)
-            qmatfile = files(trees).joinpath(qmat)
-            siteratefileiqtree = files(trees).joinpath(siterateiqtree)
-            siteratefile = files(trees).joinpath(siterate)
-
-            with as_file(popmapfile) as m, as_file(
-                treefile
-            ) as guidetree, as_file(iqtreeqmatfile) as i, as_file(
-                qmatfile
-            ) as q, as_file(
-                siteratefileiqtree
-            ) as siq, as_file(
-                siteratefile
-            ) as s:
-
-                # Added this code block because for some reason toytree won't
-                # read the as_file() temporary file using the context manager.
-                with open(guidetree, "r") as fin:
-                    input_tree = fin.read()
-                    with open(t, "w") as fout:
-                        fout.write(input_tree)
-
-                print("############################################")
-                print("### TESTING GenotypeData WITH EACH FILETYPE")
-                print("############################################")
-                print("\n")
-
-                for ft, aln in testaln.items():
-                    if ft == "phylip":
-                        data_dir = phylip_files
-                    else:
-                        data_dir = structure_files
-
-                    alnfile = files(data_dir).joinpath(aln)
-
-                    print("--------------------------------------------------")
-                    print(f"--- Testing GenotypeData with {ft} filetype...")
-                    print("--------------------------------------------------")
-                    print("\n")
-
-                    with as_file(alnfile) as a:
-                        data = GenotypeData(
-                            filename=a,
-                            filetype=ft,
-                            popmapfile=m,
-                            guidetree=t,
-                            qmatrix_iqtree=i,
-                            siterates_iqtree=siq,
-                        )
-
-                print("-------------------------------------------------------")
-                print("--- Testing GenotypeData with non-iqtree rates files...")
-                print("-------------------------------------------------------")
-                print("\n")
-
-                with as_file(strfile) as a:
-                    data = GenotypeData(
-                        filename=a,
-                        filetype="structure2row",
-                        popmapfile=m,
-                        guidetree=t,
-                        qmatrix=q,
-                        siterates=s,
-                    )
-
-                    data = GenotypeData(
-                        filename=a,
-                        filetype="structure2row",
-                        popmapfile=m,
-                        guidetree=t,
-                        qmatrix_iqtree=i,
-                        siterates_iqtree=siq,
-                    )
-
-                print("++++++++++++++++++++++++++++++++")
-                print("+++ SUCCESS!")
-                print("++++++++++++++++++++++++++++++++")
-                print("\n")
-
-                print("################################")
-                print("### TESTING SIMPLE IMPUTERS...")
-                print("################################")
-                print("\n")
-
-                print("-----------------------------------------------------")
-                print("--- Testing ImputeAlleleFreq by-population...")
-                print("-----------------------------------------------------")
-                print("\n")
-
-                afpops = ImputeAlleleFreq(
-                    genotype_data=data,
-                    by_populations=True,
-                    prefix=prefix,
-                    write_output=False,
-                )
-
-                print("-----------------------------------------------------")
-                print("--- Testing ImputeAlleleFreq global...")
-                print("-----------------------------------------------------")
-                print("\n")
-
-                afpops = ImputeAlleleFreq(
-                    genotype_data=data,
-                    by_populations=False,
-                    prefix=prefix,
-                    write_output=False,
-                )
-
-                print("-----------------------------------------------------")
-                print("--- Testing ImputePhylo...")
-                print("-----------------------------------------------------")
-                print("\n")
-
-                phylo = ImputePhylo(
-                    genotype_data=data,
-                    prefix=prefix,
-                    disable_progressbar=True,
-                    write_output=False,
-                )
-
-                print("-----------------------------------------------------")
-                print("--- Testing ImputeNMF...")
-                print("-----------------------------------------------------")
-                print("\n")
-
-                mf = ImputeNMF(
-                    genotype_data=data,
-                    prefix=prefix,
-                    write_output=False,
-                )
-
-                print("++++++++++++++++++++++++++++++++")
-                print("+++ SUCCESS!")
-                print("++++++++++++++++++++++++++++++++")
-                print("\n")
-
-                ##############################################
-                ### Make gridparams
-                ##############################################
-
-                # For randomizedsearchcv
-                # Number of trees in random forest
-                n_estimators = [
-                    int(x) for x in np.linspace(start=100, stop=1000, num=10)
-                ]
-
-                # Number of features to consider at every split
-                max_features = ["sqrt", "log2"]
-
-                # Maximum number of levels in the tree
-                max_depth = [int(x) for x in np.linspace(10, 110, num=11)]
-                max_depth.append(None)
-
-                # Minimmum number of samples required to split a node
-                min_samples_split = [int(x) for x in np.linspace(2, 10, num=5)]
-
-                # Minimum number of samples required at each leaf node
-                min_samples_leaf = [int(x) for x in np.linspace(1, 5, num=5)]
-
-                # Proportion of dataset to use with bootstrapping
-                # max_samples = [x for x in np.linspace(0.5, 1.0, num=6)]
-
-                # Random Forest gridparams - RandomizedSearchCV
-                grid_params_random = {
-                    "max_features": max_features,
-                    "max_depth": max_depth,
-                    "min_samples_split": min_samples_split,
-                    "min_samples_leaf": min_samples_leaf,
-                }
-
-                # Genetic Algorithm grid_params
-                grid_params_ga = {
-                    "max_features": Categorical(["sqrt", "log2"]),
-                    "min_samples_split": Integer(2, 10),
-                    "min_samples_leaf": Integer(1, 10),
-                    "max_depth": Integer(2, 110),
-                }
-
-                print("#################################")
-                print("### TESTING IterativeImputer...")
-                print("#################################")
-                print("\n")
-
-                print("-----------------------------------------------------")
-                print(
-                    "--- Testing ImputeRandomForest with randomized grid\n"
-                    "--- search and initial_strategy == 'populations'..."
-                )
-                print("-----------------------------------------------------")
-                print("\n")
-
-                # Random forest imputation with RandomizedSearchCV grid search
-                rf_imp = ImputeRandomForest(
-                    data,
-                    prefix=prefix,
-                    n_estimators=50,
-                    n_nearest_features=2,
-                    gridparams=grid_params_random,
-                    cv=3,
-                    grid_iter=40,
-                    n_jobs=-1,
-                    max_iter=2,
-                    column_subset=1.0,
-                    ga=False,
-                    disable_progressbar=True,
-                    extratrees=False,
-                    mutation_probability=0.1,
-                    chunk_size=1.0,
-                    initial_strategy="populations",
-                )
-
-                print("-----------------------------------------------------")
-                print(
-                    "--- Testing ImputeRandomForest with GA grid search and\n"
-                    "--- initial_strategy == 'phylogeny'..."
-                )
-                print("-----------------------------------------------------")
-                print("\n")
-
-                # Genetic Algorithm grid search Test
-                rf_imp2 = ImputeRandomForest(
-                    data,
-                    prefix=prefix,
-                    n_estimators=50,
-                    n_nearest_features=2,
-                    gridparams=grid_params_ga,
-                    cv=3,
-                    grid_iter=40,
-                    n_jobs=-1,
-                    max_iter=2,
-                    column_subset=1.0,
-                    ga=True,
-                    disable_progressbar=True,
-                    extratrees=False,
-                    chunk_size=1.0,
-                    initial_strategy="phylogeny",
-                )
-
-                print("++++++++++++++++++++++++++++++++")
-                print("+++ SUCCESS!")
-                print("++++++++++++++++++++++++++++++++")
-                print("\n")
-
-                print("#################################")
-                print("TESTING NEURAL NETWORKS...")
-                print("#################################")
-                print("\n")
-
-                print("-----------------------------------------------------")
-                print(
-                    "--- Testing VAE with validation procedure with\n"
-                    "--- intial_strategy='populations'..."
-                )
-                print("-----------------------------------------------------")
-                print("\n")
-
-                vae = ImputeVAE(
-                    genotype_data=data,
-                    prefix=prefix,
-                    disable_progressbar=True,
-                    validation_only=1.0,
-                    initial_strategy="populations",
-                    cv=3,
-                )
-
-                print("-----------------------------------------------------")
-                print(
-                    "--- Testing ImputeNLPCA with\n"
-                    "--- initial_strategy == 'phylogeny'..."
-                )
-                print("-----------------------------------------------------")
-                print("\n")
-
-                nlpca = ImputeNLPCA(
-                    data,
-                    n_components=3,
-                    initial_strategy="phylogeny",
-                    disable_progressbar=True,
-                    cv=3,
-                    hidden_activation="elu",
-                    hidden_layer_sizes="midpoint",
-                    validation_only=None,
-                    num_hidden_layers=1,
-                    learning_rate=0.1,
-                )
-
-                print("-------------------------------------------------------")
-                print("--- Testing ImputeUBP with initial_strategy == 'nmf'...")
-                print("-------------------------------------------------------")
-                print("\n")
-
-                ubp = ImputeUBP(
-                    genotype_data=data,
-                    initial_strategy="nmf",
-                    disable_progressbar=True,
-                    validation_only=None,
-                    learning_rate=0.1,
-                    num_hidden_layers=1,
-                    hidden_layer_sizes=1,
-                    hidden_activation="elu",
-                    cv=3,
-                    n_components=3,
-                )
-
-                print("++++++++++++++++++++++++++++++++")
-                print("+++ SUCCESS!")
-                print("++++++++++++++++++++++++++++++++")
-                print("\n")
-
-                # Try to remove temporary treefile.
-                try:
-                    os.remove(t)
-                except OSError:
-                    pass
-
-            print("######################################")
-            print("### ALL TESTS PASSED SUCCESSFULLY!")
-            print("######################################")
-            print("\n")