pg-sui 0.2.0__py3-none-any.whl → 1.6.14.dev9__py3-none-any.whl

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")

test/test_tkc.py

@@ -1,185 +0,0 @@
-import sys
-import os
-import copy
-import unittest
-import pprint
-from pgsui.impute.estimators import (
-    ImputeKNN,
-    ImputeRandomForest,
-    ImputeXGBoost,
-    ImputeVAE,
-    ImputeStandardAutoEncoder,
-    ImputeUBP,
-    ImputeNLPCA,
-)
-from pgsui.impute.simple_imputers import (
-    ImputePhylo,
-    ImputeMF,
-    ImputeAlleleFreq,
-    ImputeRefAllele,
-)
-
-from snpio import GenotypeData
-from pgsui.data_processing.transformers import SimGenotypeDataTransformer
-import numpy as np
-
-
-class HiddenPrints:
-    def __enter__(self):
-        self._original_stdout = sys.stdout
-        sys.stdout = open(os.devnull, "w")
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        sys.stdout.close()
-        sys.stdout = self._original_stdout
-
-
-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_weighted",
-            )
-            self.transformer.fit(self.genotype_data.genotypes_012(fmt="numpy"))
-            self.simulated_data = copy.deepcopy(self.genotype_data)
-
-            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
-
-        kwargs = {
-            'sim_strategy': "random_weighted"
-        }
-
-        instance = class_instance(
-            self.simulated_data, 
-            gridparams=param_grid, 
-            **kwargs)
-
-        imputed_data = instance.imputed.genotypes_012(fmt="numpy")
-
-        # Test that the imputed values are close to the original values
-        accuracy = self.transformer.accuracy(
-            self.genotype_data.genotypes_012(fmt="numpy"), imputed_data
-        )
-
-        (
-            auc_roc_scores,
-            precision_scores,
-            recall_scores,
-            avg_precision_scores,
-        ) = self.transformer.auc_roc_pr_ap(
-            self.genotype_data.genotypes_012(fmt="numpy"), imputed_data
-        )
-
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"OVERALL ACCURACY: {accuracy}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"AUC-ROC PER CLASS: {dict(zip(range(3), auc_roc_scores))}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"PRECISION PER CLASS: {dict(zip(range(3), precision_scores))}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"RECALL PER CLASS: {dict(zip(range(3), recall_scores))}"
-        )
-        pprint.PrettyPrinter(indent=4, sort_dicts=True).pprint(
-            f"AVERAGE PRECISION PER CLASS: {dict(zip(range(3), avg_precision_scores))}"
-        )
-        print("\n")
-
-    # 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_ImputeRefAllele(self):
-    #     self._test_class(ImputeRefAllele)
-
-    # def test_ImputeMF(self):
-    #     self._test_class(ImputeMF)
-
-    # def test_ImputeRefAllele(self):
-    #     self._test_class(ImputeRefAllele)
-
-
-if __name__ == "__main__":
-    unittest.main()