pg-sui 1.6.14.dev9__py3-none-any.whl → 1.6.16a3__py3-none-any.whl

pgsui/impute/unsupervised/imputers/vae.py

@@ -7,6 +7,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import optuna
 import torch
+import torch.nn.functional as F
 from sklearn.exceptions import NotFittedError
 from sklearn.model_selection import train_test_split
 from snpio.analysis.genotype_encoder import GenotypeEncoder
@@ -152,6 +153,7 @@ class ImputeVAE(BaseNNImputer):
         self.verbose = self.cfg.io.verbose
         self.debug = self.cfg.io.debug
         self.rng = np.random.default_rng(self.seed)
+        self.pos_weights_: torch.Tensor | None = None
 
         # Simulated-missing controls (config defaults + ctor overrides)
         sim_cfg = getattr(self.cfg, "sim", None)
@@ -300,9 +302,10 @@ class ImputeVAE(BaseNNImputer):
         )
         self.ploidy = 1 if self.is_haploid else 2
         self.num_classes_ = 2 if self.is_haploid else 3
+        self.output_classes_ = 2
         self.logger.info(
             f"Data is {'haploid' if self.is_haploid else 'diploid'}; "
-            f"using {self.num_classes_} classes."
+            f"using {self.num_classes_} classes for scoring and {self.output_classes_} output channels."
         )
 
         if self.is_haploid:
@@ -314,7 +317,7 @@ class ImputeVAE(BaseNNImputer):
         # Model params (decoder outputs L*K logits)
         self.model_params = {
             "n_features": self.num_features_,
-            "num_classes": self.num_classes_,
+            "num_classes": self.output_classes_,
             "latent_dim": self.latent_dim,
             "dropout_rate": self.dropout_rate,
             "activation": self.activation,
@@ -352,6 +355,10 @@ class ImputeVAE(BaseNNImputer):
         self.class_weights_ = self._normalize_class_weights(
             self._class_weights_from_zygosity(self.X_train_)
         )
+        if not self.is_haploid:
+            self.pos_weights_ = self._compute_pos_weights(self.X_train_)
+        else:
+            self.pos_weights_ = None
 
         # DataLoader
         train_loader = self._get_data_loader(self.X_train_)
@@ -370,7 +377,7 @@ class ImputeVAE(BaseNNImputer):
             X_val=self.X_val_,
             params=self.best_params_,
             prune_metric=self.tune_metric,
-            prune_warmup_epochs=5,
+            prune_warmup_epochs=10,
             eval_interval=1,
             eval_requires_latents=False,  # no latent refinement for eval
             eval_latent_steps=0,
@@ -480,7 +487,7 @@ class ImputeVAE(BaseNNImputer):
         X_val: np.ndarray | None = None,
         params: dict | None = None,
         prune_metric: str | None = None,  # "f1" | "accuracy" | "pr_macro"
-        prune_warmup_epochs: int = 3,
+        prune_warmup_epochs: int = 10,
         eval_interval: int = 1,
         eval_requires_latents: bool = False,  # VAE: no latent eval refinement
         eval_latent_steps: int = 0,
@@ -562,7 +569,7 @@ class ImputeVAE(BaseNNImputer):
         X_val: np.ndarray | None = None,
         params: dict | None = None,
         prune_metric: str | None = None,
-        prune_warmup_epochs: int = 3,
+        prune_warmup_epochs: int = 10,
         eval_interval: int = 1,
         eval_requires_latents: bool = False,
         eval_latent_steps: int = 0,
@@ -755,14 +762,14 @@ class ImputeVAE(BaseNNImputer):
         for _, y_batch in loader:
             optimizer.zero_grad(set_to_none=True)
 
-            # targets: (B, L) int in {0,1,2,-1}
             y_int = y_batch.to(self.device, non_blocking=True).long()
 
-            # inputs: one-hot with zeros for missing
-            x_ohe = self._one_hot_encode_012(y_int)  # (B, L, K)
+            if self.is_haploid:
+                x_in = self._one_hot_encode_012(y_int)  # (B, L, 2)
+            else:
+                x_in = self._encode_multilabel_inputs(y_int)  # (B, L, 2)
 
-            # Forward. Expect model to return recon_logits, mu, logvar, ...
-            out = model(x_ohe)
+            out = model(x_in)
             if isinstance(out, (list, tuple)):
                 recon_logits, mu, logvar = out[0], out[1], out[2]
             else:
@@ -780,15 +787,30 @@ class ImputeVAE(BaseNNImputer):
             beta = float(getattr(model, "beta", getattr(self, "kl_beta_final", 0.0)))
             gamma = max(0.0, min(gamma, 10.0))
 
-            loss = compute_vae_loss(
-                recon_logits=recon_logits,
-                targets=y_int,
-                mu=mu,
-                logvar=logvar,
-                class_weights=class_weights,
-                gamma=gamma,
-                beta=beta,
-            )
+            if self.is_haploid:
+                loss = compute_vae_loss(
+                    recon_logits=recon_logits,
+                    targets=y_int,
+                    mu=mu,
+                    logvar=logvar,
+                    class_weights=class_weights,
+                    gamma=gamma,
+                    beta=beta,
+                )
+            else:
+                targets = self._multi_hot_targets(y_int)
+                pos_w = getattr(self, "pos_weights_", None)
+                bce = F.binary_cross_entropy_with_logits(
+                    recon_logits, targets, pos_weight=pos_w, reduction="none"
+                )
+                mask = (y_int != -1).unsqueeze(-1).float()
+                recon_loss = (bce * mask).sum() / mask.sum().clamp_min(1e-8)
+                kl = (
+                    -0.5
+                    * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
+                    / (y_int.shape[0] + 1e-8)
+                )
+                loss = recon_loss + beta * kl
 
             if l1_penalty > 0:
                 l1 = torch.zeros((), device=self.device)
@@ -845,11 +867,25 @@ class ImputeVAE(BaseNNImputer):
         with torch.no_grad():
             X_tensor = torch.from_numpy(X) if isinstance(X, np.ndarray) else X
             X_tensor = X_tensor.to(self.device).long()
-            x_ohe = self._one_hot_encode_012(X_tensor)
-            outputs = model(x_ohe)  # first element must be recon logits
-            logits = outputs[0].view(-1, self.num_features_, self.num_classes_)
-            probas = torch.softmax(logits, dim=-1)
-            labels = torch.argmax(probas, dim=-1)
+            if self.is_haploid:
+                x_ohe = self._one_hot_encode_012(X_tensor)
+                outputs = model(x_ohe)
+                logits = outputs[0].view(-1, self.num_features_, self.output_classes_)
+                probas = torch.softmax(logits, dim=-1)
+                labels = torch.argmax(probas, dim=-1)
+            else:
+                x_in = self._encode_multilabel_inputs(X_tensor)
+                outputs = model(x_in)
+                logits = outputs[0].view(-1, self.num_features_, self.output_classes_)
+                probas2 = torch.sigmoid(logits)
+                p_ref = probas2[..., 0]
+                p_alt = probas2[..., 1]
+                p_het = p_ref * p_alt
+                p_ref_only = p_ref * (1 - p_alt)
+                p_alt_only = p_alt * (1 - p_ref)
+                probas = torch.stack([p_ref_only, p_het, p_alt_only], dim=-1)
+                probas = probas / probas.sum(dim=-1, keepdim=True).clamp_min(1e-8)
+                labels = torch.argmax(probas, dim=-1)
 
         if return_proba:
             return labels.cpu().numpy(), probas.cpu().numpy()
@@ -1047,12 +1083,21 @@ class ImputeVAE(BaseNNImputer):
         try:
             params = self._sample_hyperparameters(trial)
 
-            X_train = getattr(self, "X_train_", self.ground_truth_[self.train_idx_])
-            X_val = getattr(self, "X_val_", self.ground_truth_[self.test_idx_])
+            # Use tune subsets when available (tune_fast)
+            X_train = getattr(self, "_tune_X_train", None)
+            X_val = getattr(self, "_tune_X_test", None)
+            if X_train is None or X_val is None:
+                X_train = getattr(self, "X_train_", self.ground_truth_[self.train_idx_])
+                X_val = getattr(self, "X_val_", self.ground_truth_[self.test_idx_])
 
             class_weights = self._normalize_class_weights(
                 self._class_weights_from_zygosity(X_train)
             )
+            # Pos weights for diploid multilabel BCE during tuning
+            if not self.is_haploid:
+                self.pos_weights_ = self._compute_pos_weights(X_train)
+            else:
+                self.pos_weights_ = None
             train_loader = self._get_data_loader(X_train)
 
             model = self.build_model(self.Model, params["model_params"])
@@ -1073,7 +1118,7 @@ class ImputeVAE(BaseNNImputer):
                 X_val=X_val,
                 params=params,
                 prune_metric=self.tune_metric,
-                prune_warmup_epochs=5,
+                prune_warmup_epochs=10,
                 eval_interval=self.tune_eval_interval,
                 eval_requires_latents=False,
                 eval_latent_steps=0,
@@ -1116,27 +1161,32 @@ class ImputeVAE(BaseNNImputer):
             Dict[str, int | float | str]: Sampled hyperparameters.
         """
         params = {
-            "latent_dim": trial.suggest_int("latent_dim", 2, 64),
-            "lr": trial.suggest_float("learning_rate", 1e-5, 1e-2, log=True),
-            "dropout_rate": trial.suggest_float("dropout_rate", 0.0, 0.6),
-            "num_hidden_layers": trial.suggest_int("num_hidden_layers", 1, 8),
+            "latent_dim": trial.suggest_int("latent_dim", 4, 16, step=2),
+            "lr": trial.suggest_float("learning_rate", 3e-4, 1e-3, log=True),
+            "dropout_rate": trial.suggest_float("dropout_rate", 0.0, 0.30, step=0.05),
+            "num_hidden_layers": trial.suggest_int("num_hidden_layers", 1, 6),
             "activation": trial.suggest_categorical(
-                "activation", ["relu", "elu", "selu"]
+                "activation", ["relu", "elu", "selu", "leaky_relu"]
             ),
-            "l1_penalty": trial.suggest_float("l1_penalty", 1e-7, 1e-2, log=True),
+            "l1_penalty": trial.suggest_float("l1_penalty", 1e-6, 1e-3, log=True),
             "layer_scaling_factor": trial.suggest_float(
-                "layer_scaling_factor", 2.0, 10.0
+                "layer_scaling_factor", 2.0, 4.0, step=0.5
             ),
             "layer_schedule": trial.suggest_categorical(
-                "layer_schedule", ["pyramid", "constant", "linear"]
+                "layer_schedule", ["pyramid", "linear"]
             ),
             # VAE-specific β (final value after anneal)
-            "beta": trial.suggest_float("beta", 0.25, 4.0),
+            "beta": trial.suggest_float("beta", 0.5, 2.0, step=0.5),
             # focal gamma (if used in VAE recon CE)
-            "gamma": trial.suggest_float("gamma", 0.0, 5.0),
+            "gamma": trial.suggest_float("gamma", 0.5, 3.0, step=0.5),
         }
 
-        input_dim = self.num_features_ * self.num_classes_
+        use_n_features = (
+            self._tune_num_features
+            if (self.tune and self.tune_fast and hasattr(self, "_tune_num_features"))
+            else self.num_features_
+        )
+        input_dim = use_n_features * self.output_classes_
         hidden_layer_sizes = self._compute_hidden_layer_sizes(
             n_inputs=input_dim,
             n_outputs=input_dim,
@@ -1150,8 +1200,8 @@ class ImputeVAE(BaseNNImputer):
         hidden_only = [hidden_layer_sizes[0]] + hidden_layer_sizes[1:-1]
 
         params["model_params"] = {
-            "n_features": self.num_features_,
-            "num_classes": self.num_classes_,
+            "n_features": use_n_features,
+            "num_classes": self.output_classes_,
             "latent_dim": params["latent_dim"],
             "dropout_rate": params["dropout_rate"],
             "hidden_layer_sizes": hidden_only,
@@ -1182,8 +1232,8 @@ class ImputeVAE(BaseNNImputer):
         self.gamma = best_params.get("gamma", self.gamma)
 
         hidden_layer_sizes = self._compute_hidden_layer_sizes(
-            n_inputs=self.num_features_ * self.num_classes_,
-            n_outputs=self.num_features_ * self.num_classes_,
+            n_inputs=self.num_features_ * self.output_classes_,
+            n_outputs=self.num_features_ * self.output_classes_,
             n_samples=len(self.train_idx_),
             n_hidden=best_params["num_hidden_layers"],
             alpha=best_params["layer_scaling_factor"],
@@ -1197,7 +1247,7 @@ class ImputeVAE(BaseNNImputer):
             "hidden_layer_sizes": hidden_only,
             "dropout_rate": self.dropout_rate,
             "activation": self.activation,
-            "num_classes": self.num_classes_,
+            "num_classes": self.output_classes_,
             "beta": self.kl_beta_final,
             "gamma": self.gamma,
         }
@@ -1209,8 +1259,8 @@ class ImputeVAE(BaseNNImputer):
             Dict[str, int | float | str | list]: VAE model parameters.
         """
         hidden_layer_sizes = self._compute_hidden_layer_sizes(
-            n_inputs=self.num_features_ * self.num_classes_,
-            n_outputs=self.num_features_ * self.num_classes_,
+            n_inputs=self.num_features_ * self.output_classes_,
+            n_outputs=self.num_features_ * self.output_classes_,
             n_samples=len(self.ground_truth_),
             n_hidden=self.num_hidden_layers,
             alpha=self.layer_scaling_factor,
@@ -1222,7 +1272,45 @@ class ImputeVAE(BaseNNImputer):
             "hidden_layer_sizes": hidden_layer_sizes,
             "dropout_rate": self.dropout_rate,
             "activation": self.activation,
-            "num_classes": self.num_classes_,
+            "num_classes": self.output_classes_,
             "beta": self.kl_beta_final,
             "gamma": self.gamma,
         }
+
+    def _encode_multilabel_inputs(self, y: torch.Tensor) -> torch.Tensor:
+        """Two-channel multi-hot for diploid: REF-only, ALT-only; HET sets both."""
+        if self.is_haploid:
+            return self._one_hot_encode_012(y)
+        y = y.to(self.device)
+        shape = y.shape + (2,)
+        out = torch.zeros(shape, device=self.device, dtype=torch.float32)
+        valid = y != -1
+        ref_mask = valid & (y != 2)
+        alt_mask = valid & (y != 0)
+        out[ref_mask, 0] = 1.0
+        out[alt_mask, 1] = 1.0
+        return out
+
+    def _multi_hot_targets(self, y: torch.Tensor) -> torch.Tensor:
+        """Targets aligned with _encode_multilabel_inputs for diploid training."""
+        if self.is_haploid:
+            raise RuntimeError("_multi_hot_targets called for haploid data.")
+        y = y.to(self.device)
+        out = torch.zeros(y.shape + (2,), device=self.device, dtype=torch.float32)
+        valid = y != -1
+        ref_mask = valid & (y != 2)
+        alt_mask = valid & (y != 0)
+        out[ref_mask, 0] = 1.0
+        out[alt_mask, 1] = 1.0
+        return out
+
+    def _compute_pos_weights(self, X: np.ndarray) -> torch.Tensor:
+        """Balance REF/ALT channels for multilabel BCE."""
+        ref_pos = np.count_nonzero((X == 0) | (X == 1))
+        alt_pos = np.count_nonzero((X == 2) | (X == 1))
+        total_valid = np.count_nonzero(X != -1)
+        pos_counts = np.array([ref_pos, alt_pos], dtype=np.float32)
+        neg_counts = np.maximum(total_valid - pos_counts, 1.0)
+        pos_counts = np.maximum(pos_counts, 1.0)
+        weights = neg_counts / pos_counts
+        return torch.tensor(weights, device=self.device, dtype=torch.float32)

pg_sui-1.6.14.dev9.dist-info/METADATA

@@ -1,344 +0,0 @@
-Metadata-Version: 2.4
-Name: pg-sui
-Version: 1.6.14.dev9
-Summary: Python machine and deep learning API to impute missing genotypes
-Author-email: "Drs. Bradley T. Martin and Tyler K. Chafin" <evobio721@gmail.com>
-Maintainer-email: "Dr. Bradley T. Martin" <evobio721@gmail.com>
-License: GNU General Public License v3 (GPLv3)
-Project-URL: Homepage, https://github.com/btmartin721/PG-SUI
-Project-URL: Documentation, https://pg-sui.readthedocs.io/en/latest/
-Project-URL: Source, https://github.com/btmartin721/PG-SUI.git
-Project-URL: BugTracker, https://github.com/btmartin721/PG-SUI/issues
-Keywords: impute,imputation,AI,deep learning,machine learning,neural network,vae,autoencoder,ubp,nlpca,population genetics,unsupervised,supervised,bioinformatics,snp,genomics,genotype,missing data,data analysis,data science,statistics,data visualization,python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Development Status :: 4 - Beta
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Science/Research
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Education
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
-Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
-Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Classifier: Topic :: Scientific/Engineering :: Information Analysis
-Classifier: Topic :: Scientific/Engineering :: Visualization
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Unix
-Classifier: Operating System :: POSIX
-Classifier: Natural Language :: English
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: matplotlib
-Requires-Dist: numpy>=2.1
-Requires-Dist: pandas>=2.2.2
-Requires-Dist: scikit-learn>=1.4
-Requires-Dist: scipy
-Requires-Dist: seaborn
-Requires-Dist: torch
-Requires-Dist: tqdm
-Requires-Dist: toytree
-Requires-Dist: optuna
-Requires-Dist: rich
-Requires-Dist: rich[jupyter]
-Requires-Dist: snpio
-Provides-Extra: intel
-Requires-Dist: scikit-learn-intelex; extra == "intel"
-Provides-Extra: docs
-Requires-Dist: sphinx; extra == "docs"
-Requires-Dist: sphinx-rtd-theme; extra == "docs"
-Requires-Dist: sphinx_autodoc_typehints; extra == "docs"
-Requires-Dist: sphinxcontrib-napoleon; extra == "docs"
-Requires-Dist: sphinxcontrib-programoutput; extra == "docs"
-Provides-Extra: dev
-Requires-Dist: twine; extra == "dev"
-Requires-Dist: wheel; extra == "dev"
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: sphinx; extra == "dev"
-Requires-Dist: sphinx-rtd-theme; extra == "dev"
-Requires-Dist: sphinx-autodoc-typehints; extra == "dev"
-Requires-Dist: sphinxcontrib-napoleon; extra == "dev"
-Requires-Dist: sphinxcontrib-programoutput; extra == "dev"
-Requires-Dist: requests; extra == "dev"
-Provides-Extra: optional
-Requires-Dist: PyObjC; extra == "optional"
-Provides-Extra: gui
-Requires-Dist: fastapi>=0.110; extra == "gui"
-Requires-Dist: uvicorn[standard]>=0.23; extra == "gui"
-Dynamic: license-file
-
-
-<img src="https://github.com/btmartin721/PG-SUI/blob/master/img/pgsui-logo-faded.png" alt="PG-SUI Logo" width="50%" height="50%">
-
-
-# PG-SUI
-
-Population Genomic Supervised and Unsupervised Imputation.
-
-## About PG-SUI
-
-PG-SUI is a Python 3 API that uses machine learning to impute missing values from population genomic SNP data. There are several supervised and unsupervised machine learning algorithms available to impute missing data, as well as some non-machine learning imputers that are useful.
-
-Below is some general information and a basic tutorial. For more detailed information, see our [API Documentation](https://pg-sui.readthedocs.io/en/latest/).
-
-### Supervised Imputation Methods
-
-Supervised methods utilze the scikit-learn's IterativeImputer, which is based on the MICE (Multivariate Imputation by Chained Equations) algorithm ([1](#1)), and iterates over each SNP site (i.e., feature) while uses the N nearest neighbor features to inform the imputation. The number of nearest features can be adjusted by users. IterativeImputer currently works with any of the following scikit-learn classifiers:
-
-+ K-Nearest Neighbors
-+ Random Forest
-+ XGBoost
-
-See the scikit-learn documentation (https://scikit-learn.org) for more information on IterativeImputer and each of the classifiers.
-
-### Unsupervised Imputation Methods
-
-Unsupervised imputers include three custom neural network models:
-
-+ Variational Autoencoder (VAE) ([2](#2))
-+ Standard Autoencoder (SAE) ([3](#3))
-+ Non-linear Principal Component Analysis (NLPCA) ([4](#4))
-+ Unsupervised Backpropagation (UBP) ([5](#5))
-
-VAE models train themselves to reconstruct their input (i.e., the genotypes). To use VAE for imputation, the missing values are masked and the VAE model gets trained to reconstruct only on known values. Once the model is trained, it is then used to predict the missing values.
-
-SAE is a standard autoencoder that trains the input to predict itself. As with VAE, missing values are masked and the model gets trained only on known values. Predictions are then made on the missing values.
-
-NLPCA initializes random, reduced-dimensional input, then trains itself by using the known values (i.e., genotypes) as targets and refining the random input until it accurately predicts the genotype output. The trained model can then predict the missing values.
-
-UBP is an extension of NLPCA that runs over three phases. Phase 1 refines the randomly generated, reduced-dimensional input in a single layer perceptron neural network to obtain good initial input values. Phase 2 uses the refined reduced-dimensional input from phase 1 as input into a multi-layer perceptron (MLP), but in Phase 2 only the neural network weights are refined. Phase three uses an MLP to refine both the weights and the reduced-dimensional input. Once the model is trained, it can be used to predict the missing values.
-
-### Non-Machine Learning Methods
-
-We also include several non-machine learning options for imputing missing data, including:
-
-+ Per-population mode per SNP site
-+ Global mode per SNP site
-+ Using a phylogeny as input to inform the imputation
-+ Matrix Factorization
-
-These four "simple" imputation methods can be used as standalone imputers, as the initial imputation strategy for IterativeImputer (at least one method is required to be chosen), and to validate the accuracy of both IterativeImputer and the neural network models.
-
-## Installing PG-SUI
-
-The easiest way to install PG-SUI is to use pip:
-
-```
-pip install pg-sui
-```
-
-If you have an Intel CPU and want to use the sklearn-genetic-intelex package to speed up scikit-learn computations, you can do:
-
-```
-pip install pg-sui[intel]
-```
-
-### Optional GUI (Electron)
-
-PG-SUI ships an Electron GUI wrapper around the Python CLI.
-
-1. Install the Python-side extras (FastAPI/uvicorn helper) if you want to serve from Python:  
-   `pip install pg-sui[gui]`
-2. Install Node.js (https://nodejs.org) and fetch the app dependencies once:  
-   `pgsui-gui-setup`
-3. Launch the GUI:  
-   `pgsui-gui`
-
-The GUI shells out to the same CLI underneath, so presets/overrides and YAML configs behave identically.
-
-## Manual Installation
-
-### Dependencies
-
-+ python >= 3.11
-+ pandas
-+ numpy
-+ scipy
-+ matplotlib
-+ seaborn
-+ plotly
-+ kaleido
-+ tqdm
-+ toytree
-+ scikit-learn
-+ xgboost
-+ snpio
-+ optuna
-
-#### Installation troubleshooting
-
-##### "use_2to3 is invalid" error
-
-Users running setuptools v58 may encounter this error during the last step of installation, using pip to install sklearn-genetic-opt:
-
-```
-ERROR: Command errored out with exit status 1:
-   command: /Users/tyler/miniforge3/envs/pg-sui/bin/python3.8 -c 'import io, os, sys, setuptools, tokenize; sys.argv[0] = '"'"'/private/var/folders/6x/t6g4kn711z5cxmc2_tvq0mlw0000gn/T/pip-install-6y5g_mhs/deap_1d32f65d60a44056bd7031f3aad44571/setup.py'"'"'; __file__='"'"'/private/var/folders/6x/t6g4kn711z5cxmc2_tvq0mlw0000gn/T/pip-install-6y5g_mhs/deap_1d32f65d60a44056bd7031f3aad44571/setup.py'"'"';f = getattr(tokenize, '"'"'open'"'"', open)(__file__) if os.path.exists(__file__) else io.StringIO('"'"'from setuptools import setup; setup()'"'"');code = f.read().replace('"'"'\r\n'"'"', '"'"'\n'"'"');f.close();exec(compile(code, __file__, '"'"'exec'"'"'))' egg_info --egg-base /private/var/folders/6x/t6g4kn711z5cxmc2_tvq0mlw0000gn/T/pip-pip-egg-info-7hg3hcq2
-       cwd: /private/var/folders/6x/t6g4kn711z5cxmc2_tvq0mlw0000gn/T/pip-install-6y5g_mhs/deap_1d32f65d60a44056bd7031f3aad44571/
-  Complete output (1 lines):
-  error in deap setup command: use_2to3 is invalid.
-```
-
-This occurs during the installation of DEAP, one of the dependencies for sklearn-genetic-opt. As a workaround, first downgrade setuptools, and then proceed with the installation as normal:
-```
-pip install setuptools==57
-pip install sklearn-genetic-opt[all]
-
-```
-
-##### Mac ARM architecture
-
-PG-SUI has been tested on the new Mac M1 chips and is working fine, but some changes to the installation process were necessary as of 9-December-21. Installation was successful using the following:
-
-```
-### Install Miniforge3 instead of Miniconda3
-### Download: https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
-bash ~/Downloads/Miniforge3-MacOSX-arm64.sh
-
-# Close and re-open terminal #
-
-#create and activate conda environment
-conda create -n pg-sui python
-
-#activate environment
-conda activate pg-sui
-
-#install packages
-conda install -c conda-forge matplotlib seaborn jupyterlab scikit-learn tqdm pandas numpy scipy xgboost lightgbm tensorflow keras sklearn-genetic-opt toytree
-conda install -c bioconda pyvolve
-
-#downgrade setuptools (may or may not be necessary)
-pip install setuptools==57
-
-#install sklearn-genetic-opt and mlflow
-pip install sklearn-genetic-opt mlflow
-
-```
-
-Any other problems we run into testing on the Mac ARM architecture will be adjusted here. Note that the step installing scikit-learn-intelex was skipped here. PG-SUI will automatically detect the CPU architecture you are running, and forgo importing this package (which will only work on Intel processors)
-
-## Input Data
-
-You can read your input files as a GenotypeData object from the [SNPio](https://snpio.readthedocs.io/en/latest/) package:
-
-```
-
-# Import snpio. Automatically installed with pgsui when using pip.
-from snpio import GenotypeData
-
-# Read in PHYLIP, VCF, or STRUCTURE-formatted alignments.
-data = GenotypeData(
-    filename="example_data/phylip_files/phylogen_nomx.u.snps.phy",
-    popmapfile="example_data/popmaps/phylogen_nomx.popmap",
-    force_popmap=True,
-    filetype="auto",
-    qmatrix_iqtree="example_data/trees/test.qmat",
-    siterates_iqtree="example_data/trees/test.rate",
-    guidetree="example_data/trees/test.tre",
-    include_pops=["EA", "TT", "GU"], # Only include these populations. There's also an exclude_pops option that will exclude the provided populations.
-)
-```
-
-## Supported Imputation Methods
-
-There are numerous supported algorithms to impute missing data. Each one can be run by calling the corresponding class. You must provide a GenotypeData instance as the first positional argument.
-
-You can import all the supported methods with:
-
-```
-from pgsui import *
-```
-
-Or you can import them one at a time.
-
-```
-from pgsui import ImputeVAE
-```
-
-### Supervised Imputers
-
-Various supervised imputation options are supported:
-
-```
-# Supervised IterativeImputer classifiers
-knn = ImputeKNN(data) # K-Nearest Neighbors
-rf = ImputeRandomForest(data) # Random Forest or Extra Trees
-xgb = ImputeXGBoost(data) # XGBoost
-```
-
-### Non-machine learning methods
-
-Use phylogeny to inform imputation:
-
-```
-phylo = ImputePhylo(data)
-```
-
-Use by-population or global allele frequency to inform imputation
-
-```
-pop_af = ImputeAlleleFreq(data, by_populations=True)
-global_af = ImputeAlleleFreq(data, by_populations=False)
-ref_af = ImputeRefAllele(data)
-```
-
-Non-matrix factorization:
-
-```
-mf = ImputeMF(*args) # Matrix factorization
-```
-
-### Unsupervised Neural Networks
-
-``` python
-vae = ImputeVAE(data) # Variational autoencoder
-nlpca = ImputeNLPCA(data) # Nonlinear PCA
-ubp = ImputeUBP(data) # Unsupervised backpropagation
-sae = ImputeStandardAutoEncoder(data) # standard autoencoder
-```
-
-## Command-Line Interface
-
-Run the PG-SUI CLI with ``pg-sui`` (installed alongside the library). The CLI follows the same precedence model as the Python API:
-
-``code defaults  <  preset (--preset)  <  YAML (--config)  <  explicit CLI flags  <  --set key=value``.
-
-Recent releases add explicit switches for the simulated-missingness workflow shared by the neural and supervised models:
-
-- ``--sim-strategy`` selects one of ``random``, ``random_weighted``, ``random_weighted_inv``, ``nonrandom``, ``nonrandom_weighted``.
-- ``--sim-prop`` sets the proportion of observed calls to temporarily mask when building the evaluation set.
-- ``--simulate-missing`` disables simulated masking entirely (store-false flag); omit it to inherit preset/YAML defaults or re-enable via ``--set sim.simulate_missing=True``.
-
-Example:
-
-```
-pg-sui \
-  --vcf data.vcf.gz \
-  --popmap pops.popmap \
-  --models ImputeUBP ImputeVAE \
-  --preset balanced \
-  --sim-strategy random_weighted_inv \
-  --sim-prop 0.25 \
-  --set io.prefix=vae_vs_ubp
-```
-
-CLI overrides cascade into every selected model, so a single invocation can evaluate multiple imputers with a consistent simulation strategy and output prefix.
-
-## To-Dos
-
-- simulations
-- Documentation
-
-## References:
-
-<a name="1">1. </a>Stef van Buuren, Karin Groothuis-Oudshoorn (2011). mice: Multivariate Imputation by Chained Equations in R. Journal of Statistical Software 45: 1-67.
-
-<a name="2">2. </a>Kingma, D.P. & Welling, M. (2013). Auto-encoding variational bayes. In: Proceedings  of  the  International Conference on Learning Representations (ICLR). arXiv:1312.6114 [stat.ML].
-
-<a name="3">3. </a>Hinton, G.E., & Salakhutdinov, R.R. (2006). Reducing the dimensionality of data with neural networks. Science, 313(5786), 504-507.
-
-<a name="4">4. </a>Scholz, M., Kaplan, F., Guy, C. L., Kopka, J., & Selbig, J. (2005). Non-linear PCA: a missing data approach. Bioinformatics, 21(20), 3887-3895.
-
-<a name="5">5. </a>Gashler, M. S., Smith, M. R., Morris, R., & Martinez, T. (2016). Missing value imputation with unsupervised backpropagation. Computational Intelligence, 32(2), 196-215.