scdesigner 0.0.3__py3-none-any.whl → 0.0.5__py3-none-any.whl

scdesigner/minimal/standard_copula.py

@@ -0,0 +1,383 @@
+from .copula import Copula
+from .formula import standardize_formula
+from .kwargs import DEFAULT_ALLOWED_KWARGS, _filter_kwargs
+from anndata import AnnData
+from scipy.stats import norm, multivariate_normal
+from tqdm import tqdm
+from typing import Dict, Union, Callable, Tuple
+import numpy as np
+import torch
+from .copula import CovarianceStructure
+import warnings
+
+class StandardCopula(Copula):
+    """Standard Gaussian Copula Model"""
+    def __init__(self, formula: str = "~ 1"):
+        """Initialize the StandardCopula model.
+
+        Args:
+            formula (str, optional): _description_. Defaults to "~ 1".
+        """
+        formula = standardize_formula(formula, allowed_keys=['group'])
+        super().__init__(formula)
+        self.groups = None
+
+
+    def setup_data(self, adata: AnnData, marginal_formula: Dict[str, str], **kwargs):
+        """Set up the data for the standard covariance model. After setting up the data, x_dict will always have a "group" key.
+
+        Args:
+            adata (AnnData): The AnnData object containing the data.
+            marginal_formula (Dict[str, str]): The formula for the marginal model.
+        Raises:
+            ValueError: If the groupings are not binary.
+        """
+        data_kwargs = _filter_kwargs(kwargs, DEFAULT_ALLOWED_KWARGS['data'])
+        super().setup_data(adata, marginal_formula, **data_kwargs)
+        _, obs_batch = next(iter(self.loader))
+        obs_batch_group = obs_batch.get("group")
+
+        # fill in group indexing variables
+        self.groups = self.loader.dataset.predictor_names["group"]
+        self.n_groups = len(self.groups)
+        self.group_col = {g: i for i, g in enumerate(self.groups)}
+
+        # check that obs_batch is a binary grouping matrix (only if group exists)
+        if obs_batch_group is not None:
+            unique_vals = torch.unique(obs_batch_group)
+            if (not torch.all((unique_vals == 0) | (unique_vals == 1)).item()):
+                raise ValueError("Only categorical groups are currently supported in copula covariance estimation.")
+
+    def fit(self, uniformizer: Callable, **kwargs):
+        """
+        Fit the copula covariance model.
+
+        Args:
+            uniformizer (Callable): Function to convert data to uniform distribution
+            **kwargs: Additional arguments
+                top_k (int, optional): Use only top-k most expressed genes for covariance estimation.
+                                    If None, estimates full covariance for all genes.
+
+        Returns:
+            None: Stores fitted parameters in self.parameters as dict of CovarianceStructure objects.
+
+        Raises:
+            ValueError: If top_k is not a positive integer or exceeds n_outcomes
+        """
+        top_k = kwargs.get("top_k", None)
+        if top_k is not None:
+            if not isinstance(top_k, int):
+                raise ValueError("top_k must be an integer")
+            if top_k <= 0:
+                raise ValueError("top_k must be positive")
+            if top_k > self.n_outcomes:
+                raise ValueError(f"top_k ({top_k}) cannot exceed number of outcomes ({self.n_outcomes})")
+            gene_total_expression = np.array(self.adata.X.sum(axis=0)).flatten()
+            sorted_indices = np.argsort(gene_total_expression)
+            top_k_indices = sorted_indices[-top_k:]
+            remaining_indices = sorted_indices[:-top_k]
+            covariances = self._compute_block_covariance(uniformizer, top_k_indices,
+                                                             remaining_indices, top_k)
+        else:
+            covariances = self._compute_full_covariance(uniformizer)
+
+        self.parameters = covariances
+
+    def pseudo_obs(self, x_dict: Dict):
+        # convert one-hot encoding memberships to a map
+        #      {"group1": [indices of group 1], "group2": [indices of group 2]}
+        # The initialization method ensures that x_dict will always have a "group" key.
+        group_data = x_dict.get("group")
+        memberships = group_data.cpu().numpy()
+        group_ix = {g: np.where(memberships[:, self.group_col[g] == 1])[0] for g in self.groups}
+
+        # initialize the result
+        u = np.zeros((len(memberships), self.n_outcomes))
+        parameters = self.parameters
+
+        # loop over groups and sample each part in turn
+        for group, cov_struct in parameters.items():
+            if cov_struct.remaining_var is not None:
+                u[group_ix[group]] = self._fast_normal_pseudo_obs(len(group_ix[group]), cov_struct)
+            else:
+                u[group_ix[group]] = self._normal_pseudo_obs(len(group_ix[group]), cov_struct)
+        return u
+
+    def likelihood(self, uniformizer: Callable, batch: Tuple[torch.Tensor, Dict[str, torch.Tensor]]):
+        """
+        Compute likelihood of data given the copula model.
+
+        Args:
+            uniformizer (Callable): Function to convert expression data to uniform distribution
+            batch (Tuple[torch.Tensor, Dict[str, torch.Tensor]]): Data batch containing:
+                - Y (torch.Tensor): Expression data of shape (n_cells, n_genes)
+                - X_dict (Dict[str, torch.Tensor]): Covariates dict with keys as parameter names
+                                                and values as tensors of shape (n_cells, n_covariates)
+
+        Returns:
+            np.ndarray: Log-likelihood for each cell, shape (n_cells,)
+        """
+        # uniformize the observations
+        y, x_dict = batch
+        u = uniformizer(y, x_dict)
+        z = norm().ppf(u)
+
+        # same group manipulation as for pseudobs
+        parameters = self.parameters
+        if type(parameters) is not dict:
+            parameters = {self.groups[0]: parameters}
+
+        group_data = x_dict.get("group")
+        memberships = group_data.numpy()
+        group_ix = {g: np.where(memberships[:, self.group_col[g] == 1])[0] for g in self.groups}
+
+        ll = np.zeros(len(z))
+
+        for group, cov_struct in parameters.items():
+            ix = group_ix[group]
+            if len(ix) > 0:
+                z_modeled = z[ix][:, cov_struct.modeled_indices]
+
+                ll_modeled = multivariate_normal.logpdf(z_modeled,
+                                                       np.zeros(cov_struct.num_modeled_genes),
+                                                       cov_struct.cov.values)
+                if cov_struct.num_remaining_genes > 0:
+                    z_remaining = z[ix][:, cov_struct.remaining_indices]
+                    ll_remaining = norm.logpdf(z_remaining,
+                                            loc=0,
+                                            scale = np.sqrt(cov_struct.remaining_var.values))
+                else:
+                    ll_remaining = 0
+                ll[ix] = ll_modeled + ll_remaining
+        return ll
+
+    def num_params(self, **kwargs):
+        S = self.parameters
+        per_group = [((S[g].num_modeled_genes * (S[g].num_modeled_genes - 1)) / 2) for g in self.groups]
+        return sum(per_group)
+
+    def _validate_parameters(self, **kwargs):
+        top_k = kwargs.get("top_k", None)
+        if top_k is not None:
+            if not isinstance(top_k, int):
+                raise ValueError("top_k must be an integer")
+            if top_k <= 0:
+                raise ValueError("top_k must be positive")
+            if top_k > self.n_outcomes:
+                raise ValueError(f"top_k ({top_k}) cannot exceed number of outcomes ({self.n_outcomes})")
+        return top_k
+
+
+
+    def _accumulate_top_k_stats(self, uniformizer:Callable, top_k_idx, rem_idx, top_k) \
+        -> Tuple[Dict[Union[str, int], np.ndarray],
+                 Dict[Union[str, int], np.ndarray],
+                 Dict[Union[str, int], np.ndarray],
+                 Dict[Union[str, int], np.ndarray],
+                 Dict[Union[str, int], int]]:
+        """Accumulate sufficient statistics for top-k covariance estimation.
+
+        Args:
+            uniformizer (Callable): Function to convert to uniform distribution
+            top_k_idx (np.ndarray): Indices of the top-k genes
+            rem_idx (np.ndarray): Indices of the remaining genes
+            top_k (int): Number of top-k genes
+
+        Returns:
+            top_k_sums (dict): Sums of the top-k genes for each group
+            top_k_second_moments (dict): Second moments of the top-k genes for each group
+            rem_sums (dict): Sums of the remaining genes for each group
+            rem_second_moments (dict): Second moments of the remaining genes for each group
+            Ng (dict): Number of observations for each group
+        """
+        top_k_sums = {g: np.zeros(top_k) for g in self.groups}
+        top_k_second_moments = {g: np.zeros((top_k, top_k)) for g in self.groups}
+        rem_sums = {g: np.zeros(self.n_outcomes - top_k) for g in self.groups}
+        rem_second_moments = {g: np.zeros(self.n_outcomes - top_k) for g in self.groups}
+        Ng = {g: 0 for g in self.groups}
+
+        for y, x_dict in tqdm(self.loader, desc="Estimating top-k copula covariance"):
+            group_data = x_dict.get("group")
+            memberships = group_data.cpu().numpy()
+            u = uniformizer(y, x_dict)
+            z = norm.ppf(u)
+
+            for g in self.groups:
+                mask = memberships[:, self.group_col[g]] == 1
+                if not np.any(mask):
+                    continue
+
+                z_g = z[mask]
+                n_g = mask.sum()
+
+                top_k_z, rem_z = z_g[:, top_k_idx], z_g[:, rem_idx]
+
+                top_k_sums[g] += top_k_z.sum(axis=0)
+                top_k_second_moments[g] += top_k_z.T @ top_k_z
+
+                rem_sums[g] += rem_z.sum(axis=0)
+                rem_second_moments[g] += (rem_z ** 2).sum(axis=0)
+
+                Ng[g] += n_g
+
+        return top_k_sums, top_k_second_moments, rem_sums, rem_second_moments, Ng
+
+    def _accumulate_full_stats(self, uniformizer:Callable) \
+        -> Tuple[Dict[Union[str, int], np.ndarray],
+                 Dict[Union[str, int], np.ndarray],
+                 Dict[Union[str, int], int]]:
+        """Accumulate sufficient statistics for full covariance estimation.
+
+        Args:
+            uniformizer (Callable): Function to convert to uniform distribution
+
+        Returns:
+            sums (dict): Sums of the genes for each group
+            second_moments (dict): Second moments of the genes for each group
+            Ng (dict): Number of observations for each group
+        """
+        sums = {g: np.zeros(self.n_outcomes) for g in self.groups}
+        second_moments = {g: np.zeros((self.n_outcomes, self.n_outcomes)) for g in self.groups}
+        Ng = {g: 0 for g in self.groups}
+
+        for y, x_dict in tqdm(self.loader, desc="Estimating copula covariance"):
+            group_data = x_dict.get("group")
+            memberships = group_data.cpu().numpy()
+
+            u = uniformizer(y, x_dict)
+            z = norm.ppf(u)
+
+            for g in self.groups:
+                mask = memberships[:, self.group_col[g]] == 1
+
+                if not np.any(mask):
+                    continue
+
+                z_g = z[mask]
+                n_g = mask.sum()
+
+                second_moments[g] += z_g.T @ z_g
+                sums[g] += z_g.sum(axis=0)
+
+                Ng[g] += n_g
+
+        return sums, second_moments, Ng
+
+    def _compute_block_covariance(self, uniformizer:Callable,
+                                  top_k_idx: np.ndarray, rem_idx: np.ndarray, top_k: int) \
+        -> Dict[Union[str, int], CovarianceStructure]:
+        """Compute the covariance matrix for the top-k and remaining genes.
+
+        Args:
+            top_k_sums (dict): Sums of the top-k genes for each group
+            top_k_second_moments (dict): Second moments of the top-k genes for each group
+            remaining_sums (dict): Sums of the remaining genes for each group
+            remaining_second_moments (dict): Second moments of the remaining genes for each group
+            Ng (dict): Number of observations for each group
+
+        Returns:
+            covariance (dict): Covariance matrix for each group
+        """
+        top_k_sums, top_k_second_moments, remaining_sums, remaining_second_moments, Ng \
+            = self._accumulate_top_k_stats(uniformizer, top_k_idx, rem_idx, top_k)
+        covariance = {}
+        for g in self.groups:
+            if Ng[g] == 0:
+                warnings.warn(f"Group {g} has no observations, skipping")
+                continue
+            mean_top_k = top_k_sums[g] / Ng[g]
+            cov_top_k = top_k_second_moments[g] / Ng[g] - np.outer(mean_top_k, mean_top_k)
+            mean_remaining = remaining_sums[g] / Ng[g]
+            var_remaining = remaining_second_moments[g] / Ng[g] - mean_remaining ** 2
+            top_k_names = self.adata.var_names[top_k_idx]
+            remaining_names = self.adata.var_names[rem_idx]
+            covariance[g] = CovarianceStructure(
+                cov=cov_top_k,
+                modeled_names=top_k_names,
+                modeled_indices=top_k_idx,
+                remaining_var=var_remaining,
+                remaining_indices=rem_idx,
+                remaining_names=remaining_names
+            )
+        return covariance
+
+    def _compute_full_covariance(self, uniformizer:Callable) -> Dict[Union[str, int], CovarianceStructure]:
+        """Compute the covariance matrix for the full genes.
+
+        Args:
+            uniformizer (Callable): Function to convert to uniform distribution
+
+        Returns:
+            covariance (dict): Covariance matrix for each group
+        """
+        sums, second_moments, Ng = self._accumulate_full_stats(uniformizer)
+        covariance = {}
+        for g in self.groups:
+            if Ng[g] == 0:
+                warnings.warn(f"Group {g} has no observations, skipping")
+                continue
+            mean = sums[g] / Ng[g]
+            cov = second_moments[g] / Ng[g] - np.outer(mean, mean)
+            covariance[g] = CovarianceStructure(
+                cov=cov,
+                modeled_names=self.adata.var_names,
+                modeled_indices=np.arange(self.n_outcomes),
+                remaining_var=None,
+                remaining_indices=None,
+                remaining_names=None
+            )
+        return covariance
+
+    def _fast_normal_pseudo_obs(self, n_samples: int, cov_struct: CovarianceStructure) -> np.ndarray:
+        """Sample pseudo-observations from the covariance structure.
+
+        Args:
+            n_samples (int): Number of samples to generate
+            cov_struct (CovarianceStructure): The covariance structure
+
+        Returns:
+            np.ndarray: Pseudo-observations with shape (n_samples, total_genes)
+        """
+        u = np.zeros((n_samples, cov_struct.total_genes))
+
+        z_modeled = np.random.multivariate_normal(
+            mean=np.zeros(cov_struct.num_modeled_genes),
+            cov=cov_struct.cov.values,
+            size=n_samples
+        )
+
+        z_remaining = np.random.normal(
+            loc=0,
+            scale=cov_struct.remaining_var.values ** 0.5,
+            size=(n_samples, cov_struct.num_remaining_genes)
+        )
+
+        normal_distn_modeled = norm(0, np.diag(cov_struct.cov.values) ** 0.5)
+        u[:, cov_struct.modeled_indices] = normal_distn_modeled.cdf(z_modeled)
+
+        normal_distn_remaining = norm(0, cov_struct.remaining_var.values ** 0.5)
+        u[:, cov_struct.remaining_indices] = normal_distn_remaining.cdf(z_remaining)
+
+        return u
+
+    def _normal_pseudo_obs(self, n_samples: int, cov_struct: CovarianceStructure) -> np.ndarray:
+        """Sample pseudo-observations from the covariance structure.
+
+        Args:
+            n_samples (int): Number of samples to generate
+            cov_struct (CovarianceStructure): The covariance structure
+
+        Returns:
+            np.ndarray: Pseudo-observations with shape (n_samples, total_genes)
+        """
+        u = np.zeros((n_samples, cov_struct.total_genes))
+        z = np.random.multivariate_normal(
+            mean=np.zeros(cov_struct.total_genes),
+            cov=cov_struct.cov.values,
+            size=n_samples
+        )
+
+        normal_distn = norm(0, np.diag(cov_struct.cov.values) ** 0.5)
+        u = normal_distn.cdf(z)
+
+        return u

scdesigner/minimal/transform.py

@@ -1,8 +1,10 @@
 from typing import Union, Sequence
 import numpy as np
+import pandas as pd
 import re
 import torch
 import copy
+from .copula import CovarianceStructure
 
 
 def nullify(sim, row_pattern: str, col_pattern: str, param: str):
@@ -31,41 +33,33 @@ def amplify(sim, factor: float, row_pattern: str, col_pattern: str, param: str):
 
 
 def decorrelate(sim, row_pattern: str, col_pattern: str, group: Union[str, None] = None):
-    """Zero out selected off-diagonal entries of a covariance."""
-    sim = copy.deepcopy(sim)
-    def _apply_to_df(df):
-        m1 = data_frame_mask(df, ".", col_pattern)
-        m2 = data_frame_mask(df, row_pattern, ".")
-        mask = (m1 | m2)
-        np.fill_diagonal(mask, False)
-        df.values[mask] = 0
-
-    cov = sim.parameters["copula"]
-    _apply_to_groups(cov, group, _apply_to_df)
-    return sim
+    """Zero out selected off-diagonal entries of a covariance.
+    """
+    decorr_sim = copy.deepcopy(sim)
+    decorr_sim.copula.decorrelate(row_pattern, col_pattern, group)
+    return decorr_sim
 
 
 def correlate(sim, factor: float, row_pattern: str, col_pattern: str, group: Union[str, None] = None):
     """Multiply selected off-diagonal entries by factor."""
-    sim = copy.deepcopy(sim)
-    def _apply_to_df(df):
-        m1 = data_frame_mask(df, ".", col_pattern)
-        m2 = data_frame_mask(df, row_pattern, ".")
-        mask = (m1 | m2)
-        np.fill_diagonal(mask, False)
-        df.values[mask] = df.values[mask] * factor
-
-    cov = sim.parameters["copula"]
-    _apply_to_groups(cov, group, _apply_to_df)
-    return sim
+    corr_sim = copy.deepcopy(sim)
+    corr_sim.copula.correlate(factor, row_pattern, col_pattern, group)
+    return corr_sim
 
 
-def replace_param(sim, path: Sequence[str], new_param):
+def replace_param(sim, path: Sequence[str], new_param: Union[np.ndarray, pd.DataFrame, CovarianceStructure]):
     """Substitute a new parameter for an old one.
 
     Use the path to the parameter starting from sim.parameters to identify the
     parameter to transform.  Examples: ['marginal','mean'] or
     ['copula','group_name']
+    
+    Args:
+        sim (Simulator): The simulator object.
+        path (Sequence[str]): The path to the parameter to transform.
+        new_param (np.ndarray): The new parameter to substitute. 
+        For replacing a covariance structure, new_param could be a numpy array of shape (n_genes, n_genes)
+        or a CovarianceStructure object defined by the user.
     """
     sim = copy.deepcopy(sim)
     if path[0] == "marginal":
@@ -74,13 +68,16 @@ def replace_param(sim, path: Sequence[str], new_param):
         _update_marginal_param(sim, param, mat)
 
     if path[0] == "copula":
-        key = path[1]
-        cov = sim.parameters["copula"]
-        if isinstance(cov, dict):
-            cov[key] = new_param
+        if isinstance(new_param, np.ndarray):
+            sim.parameters["copula"][path[1]] = CovarianceStructure(new_param,
+                                                                    modeled_names=sim.adata.var_names)
+        elif isinstance(new_param, pd.DataFrame):
+            sim.parameters["copula"][path[1]] = CovarianceStructure(new_param.values,
+                                                                    modeled_names=new_param.index)
+        elif isinstance(new_param, CovarianceStructure):
+            sim.parameters["copula"][path[1]] = new_param
         else:
-            sim.parameters["copula"] = new_param
-
+            raise ValueError(f"new_param must be a numpy array or a CovarianceStructure object, got {type(new_param)}")
     return sim
 
 

scdesigner/samplers/glm_factory.py

@@ -14,18 +14,80 @@ def glm_sample_factory(sample_array):
     return sampler
 
 def gaussian_copula_pseudo_obs(N, G, sigma, groups):
+
+    # Import here to avoid circular imports
+    from ..estimators.gaussian_copula_factory import FastCovarianceStructure
+    
     u = np.zeros((N, G))
 
     # cycle across groups
     for group, ix in groups.items():
+        # If sigma is not a dict, then every group shares the same sigma
         if type(sigma) is not dict:
             sigma = {group: sigma}
+        
+        group_sigma = sigma[group]
+    
+        # Handle FastCovarianceStructure
+        if isinstance(group_sigma, FastCovarianceStructure):
+            u[ix] = _fast_copula_pseudo_obs(len(ix), group_sigma)
+        else:
+            # Traditional full covariance matrix approach
+            z = np.random.multivariate_normal(
+                mean=np.zeros(G), cov=group_sigma, size=len(ix)
+            )
+            normal_distn = norm(0, np.diag(group_sigma ** 0.5))
+            u[ix] = normal_distn.cdf(z)
+    return u
 
-        z = np.random.multivariate_normal(
-            mean=np.zeros(G), cov=sigma[group], size=len(ix)
+
+def _fast_copula_pseudo_obs(n_samples, fast_cov_struct):
+    """
+    Efficient pseudo-observation generation using FastCovarianceStructure.
+    
+    This function separately samples:
+    1. Top-k genes using full multivariate normal with their covariance matrix
+    2. Remaining genes using independent normal with their individual variances
+    
+    Parameters:
+    -----------
+    n_samples : int
+        Number of samples to generate for this group
+    fast_cov_struct : FastCovarianceStructure
+        Structure containing top-k covariance and remaining variances
+        
+    Returns:
+    --------
+    np.ndarray : Pseudo-observations with shape (n_samples, total_genes)
+    """
+    u = np.zeros((n_samples, fast_cov_struct.total_genes))
+    
+    # Sample top-k genes with full covariance
+    if fast_cov_struct.top_k > 0:
+        z_top_k = np.random.multivariate_normal(
+            mean=np.zeros(fast_cov_struct.top_k), 
+            cov=fast_cov_struct.top_k_cov, 
+            size=n_samples
+        )
+        
+        # Convert to uniform via marginal CDFs
+        top_k_std = np.sqrt(np.diag(fast_cov_struct.top_k_cov))
+        normal_distn_top_k = norm(0, top_k_std)
+        u[:, fast_cov_struct.top_k_indices] = normal_distn_top_k.cdf(z_top_k)
+    
+    # Sample remaining genes independently
+    if len(fast_cov_struct.remaining_indices) > 0:
+        remaining_std = np.sqrt(fast_cov_struct.remaining_var)
+        z_remaining = np.random.normal(
+            loc=0, 
+            scale=remaining_std, 
+            size=(n_samples, len(fast_cov_struct.remaining_indices))
         )
-        normal_distn = norm(0, np.diag(sigma[group] ** 0.5))
-        u[ix] = normal_distn.cdf(z)
+        
+        # Convert to uniform via marginal CDFs  
+        normal_distn_remaining = norm(0, remaining_std)
+        u[:, fast_cov_struct.remaining_indices] = normal_distn_remaining.cdf(z_remaining)
+    
     return u
 
 

scdesigner/transform/nullify.py

@@ -18,7 +18,7 @@ def nullify(params: dict, id: str, mask: Union[np.array, None] = None) -> dict:
     null_params = nullify(params, "beta", mask)
     """
     if mask is None:
-        mask = np.ones(params[id].shape)
+        mask = np.ones(params[id].shape, dtype=bool)
 
     result = deepcopy(params)
     result[id][mask] = 0

{scdesigner-0.0.3.dist-info → scdesigner-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scdesigner
-Version: 0.0.3
+Version: 0.0.5
 Summary: Interactive simulation for rigorous and transparent multi-omics analysis.
 Project-URL: Homepage, https://github.com/krisrs1128/scDesigner/
 Project-URL: Issues, https://github.com/krisrs1128/scDesigner/Issues/
@@ -11,7 +11,6 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Requires-Dist: anndata
 Requires-Dist: formulaic
-Requires-Dist: lightning
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: rich

{scdesigner-0.0.3.dist-info → scdesigner-0.0.5.dist-info}/RECORD

@@ -6,14 +6,14 @@ scdesigner/data/sparse.py,sha256=lMp8gI8sq_fUTj3HiAmia0YiCdMRS1QGyyRePmuq3zY,138
 scdesigner/diagnose/__init__.py,sha256=XRBlc0_ns9Tbwq-aMWMIv1c-tcTOgRFQBywBFV46Gt4,3579
 scdesigner/diagnose/aic_bic.py,sha256=9GmtxdEXbbmCvL__pm7jSvQeeCb8KjwawY3UebahVBs,5022
 scdesigner/diagnose/plot.py,sha256=JP1vLbZVnMs171aOBawKbbCUgGiwIfCGKWrQyNh7Y2s,7225
-scdesigner/estimators/__init__.py,sha256=XqtTCAE02FyxMJkbnlg-qi-C_eF-OoOzP2wqa3MJEJ8,907
+scdesigner/estimators/__init__.py,sha256=TDkbc25TvXJp5O4_U2QipM8tmEoJ0HpNG53rlYthsBk,1221
 scdesigner/estimators/bernoulli.py,sha256=vnIETFbHjXErgkKps4ImgeM5W6nta0c-8-ZetYpqK8g,3324
 scdesigner/estimators/gaussian.py,sha256=-CKumYQWw8KbshdCmCdFgpcH5dNbqY-3vNTXCyjJbqc,4311
-scdesigner/estimators/gaussian_copula_factory.py,sha256=tAX4jABUWNmiheDot74k7yuRlviXwZ0iO7meECbotEM,5391
+scdesigner/estimators/gaussian_copula_factory.py,sha256=yeIx_C2fN2jiotTkJstV4pjQYW4aO6RJ-jMuuXR2HVs,14054
 scdesigner/estimators/glm_factory.py,sha256=tjVlEfJwBPK_Vk4G4P_eTYnBqeI8Y0r5_u_iSYB7qfA,2618
-scdesigner/estimators/negbin.py,sha256=JCVDIqFe-IfgYSmFz8gAPXFb4PiIaYiFTqNlU42iFZg,4812
+scdesigner/estimators/negbin.py,sha256=4q_XZOZA8gYHXOOY5Mz17cexs-kzadqB9JlxqWnZ7VQ,5639
 scdesigner/estimators/pnmf.py,sha256=-0WDbwh0uU4V-eyl_0uQ3qLZpT2IuEo9Pa-GEC6vJYI,4781
-scdesigner/estimators/poisson.py,sha256=-B-xXX-XRS22PQUkOTCFiT8HlWtKIXN2WCL_EJtb83w,3365
+scdesigner/estimators/poisson.py,sha256=FMYtkip2NDYmmkyEuO_9hSuM6gtM-AZpPa9GwFrFfD8,4174
 scdesigner/estimators/zero_inflated_negbin.py,sha256=OeMbXf20wzhJUmll2meMXBdLfeHGSya2hikmXNRUKI4,7959
 scdesigner/estimators/zero_inflated_poisson.py,sha256=2lrD2H4QMBxhNbak3gDUHVxPBURLS16IyfN5eCEbq9Q,3364
 scdesigner/format/__init__.py,sha256=PR12wZFvixIqHEd--d1oZkuj6o8tAQx-rgnpUKkr03I,179
@@ -21,20 +21,20 @@ scdesigner/format/format.py,sha256=WLsGnfeM52Mg3fhKHwPx0XbkYJSXfehu2_HmQfUpHdY,5
 scdesigner/format/print.py,sha256=HK3yLQcFw-f5-nSxMy52bD8Mixw_xxAYV2W9K4_ULwg,794
 scdesigner/minimal/__init__.py,sha256=IdMK1a2iiYyJ1gsWoupc2_3wyEu3Udjbm_iC0U724kM,378
 scdesigner/minimal/bernoulli.py,sha256=KvkXiS5aOYIT_L_xymaAWd92ZJyRXZowTcOv_b1RsJo,2304
-scdesigner/minimal/composite.py,sha256=H-OzRUzv52F49zw3eM9Bz6HPC4deXQDNr9zTkR_7Xz4,4548
-scdesigner/minimal/copula.py,sha256=VgjOuKgNhKgSnGEt8GXCdjUfIhucymHFTYmAtCn4c5U,1105
+scdesigner/minimal/composite.py,sha256=lOafmycSpW5U7Yrmm_NgRJx8Y9GvkuS0BVf8IGFse9c,4536
+scdesigner/minimal/copula.py,sha256=nNnK9Pxrp4-jlYWFY4NBt0hiUXGVHjMQMH5P5EhxLVw,8884
 scdesigner/minimal/formula.py,sha256=VFTadNxn-2elBvCkD_yuyh9O-vDZFiitSqjJkZYJy3Y,879
 scdesigner/minimal/gaussian.py,sha256=CKsluKk_XduYMNNUZTtENzH3wf4iTRGRc4L2nzq7qYw,2351
 scdesigner/minimal/kwargs.py,sha256=a32BLKNBj7ont5fR_uUpppYwel55dpP3fqaPeVbmCKM,979
-scdesigner/minimal/loader.py,sha256=gufdcWWKo7MyZQ5e7lzia96ZDKV5Pz8v0WwhZGQEeYM,5947
-scdesigner/minimal/marginal.py,sha256=mxGZH6walwNY8HUqYxp47chPrIysiLEMRacsqAvCxWI,5425
-scdesigner/minimal/negbin.py,sha256=RvReWG50h3LuBBfrHv34AFylcZ8TTjV5WOugR5tBTCg,2572
+scdesigner/minimal/loader.py,sha256=N6bFyRkJGkpi1NIHU9gwfJTbBP_Z51p6tX2ymxML5Fk,7483
+scdesigner/minimal/marginal.py,sha256=5SB1biCpO8PzMb_--mzBdpTHrnbTEt0BMp7188afxd0,5790
+scdesigner/minimal/negbin.py,sha256=NorV0CQ_wmKwTWuWd-Y1mE3gWYmVPHgmjp3pgI86bEI,2563
 scdesigner/minimal/positive_nonnegative_matrix_factorization.py,sha256=oMIC1aqdH4Cgn2pU446lh2-H3axEe-FSC_ZNcgSBrdk,7445
-scdesigner/minimal/scd3.py,sha256=8D8amY7zqSBgyRkrTvYzaf7r9i6mHNtZCCqeopcFbYY,3047
-scdesigner/minimal/scd3_instances.py,sha256=7Jb45VzEkpYegxbzqVlqpb-zMkIXebdiIMEWdZZnRzc,1993
+scdesigner/minimal/scd3.py,sha256=4EKi6Wonc0LRfWjLdvn8HMhbuR-c5kZbmVNLGbJd7mw,3083
+scdesigner/minimal/scd3_instances.py,sha256=vbCbF_SbCqyCUdi_STwV2ufn9ouoEk14_D9g4Wc9O14,1969
 scdesigner/minimal/simulator.py,sha256=DmeT_uXswR9larJ_OuysXUt32BqIVwxS-2yYMk9PGQw,631
-scdesigner/minimal/standard_covariance.py,sha256=9JlAI9C8bWSGSQRFtBYnKMnoF3UghB0DG08A4piOJ4E,4956
-scdesigner/minimal/transform.py,sha256=FdTOsPoGk3I-M-t8Ugmqx-Znxo0avJs5Os3kCkHotIk,4919
+scdesigner/minimal/standard_copula.py,sha256=_NHCKL90eR7oHmgYtZAC9dyZDBKqYj987nrUxYoDAtM,16204
+scdesigner/minimal/transform.py,sha256=j2sj2vHpFi3YdK9sz4Npl05i8UPGBcDU3kT-n72u28s,5459
 scdesigner/minimal/zero_inflated_negbin.py,sha256=npDoyAGWs9n5rl3HwvAUvDG9UDG3DlwRMUGwkpeqvlc,3179
 scdesigner/predictors/__init__.py,sha256=3ycFB7ifR2y-27Kx2GhESyfcyZsJ-6ds6vxgzwrl6ss,462
 scdesigner/predictors/bernoulli.py,sha256=ln7GpOTh7nxCVX0nvARPXw0E-l3SalDwur0iUEz-SWQ,261
@@ -46,7 +46,7 @@ scdesigner/predictors/zero_inflated_poisson.py,sha256=Krr4r-9vkh7SVy3d45v226NVUY
 scdesigner/samplers/__init__.py,sha256=ns3tA_Q7jYIPgnYPfItvHCUpBV9fDimUg0dEHcNB7wE,775
 scdesigner/samplers/bernoulli.py,sha256=1GLOU69_D2sxcedmxC2dIj1MQbmX5D8i0ccvyxjTcR8,791
 scdesigner/samplers/gaussian.py,sha256=H8DwD4XzzALFguxB1uiwUsUURF_G1B6d2j4r0up-srU,943
-scdesigner/samplers/glm_factory.py,sha256=QUtphZEd-hWE8G0e8o98i3ojQqyvucqanrWiMN2oUew,1287
+scdesigner/samplers/glm_factory.py,sha256=aQvFTgBKAk7kV-SnFJ61aSHQGwemxW9Hl4ZXBmwGJug,3607
 scdesigner/samplers/negbin.py,sha256=d9oWIDxfXl_kNOPCjYUvtVie3uQmBN6yHfxHbrQiX-I,930
 scdesigner/samplers/poisson.py,sha256=_TxotqGuVDFRXJOIiBGqRE_qJK0XkXn96clkCDCRV1A,789
 scdesigner/samplers/zero_inflated_negbin.py,sha256=Z9kUSEQL8Z-lf48wWBLAuz74FcK7mjsKmeIzyBE9ov4,1287
@@ -58,9 +58,9 @@ scdesigner/simulators/pnmf_regression.py,sha256=B_fMK7Q9D4q31HT77384EKZEST7XXVNC
 scdesigner/transform/__init__.py,sha256=cuLIP0_tocIA3dupO7npH2mLFpL1ApLZlLWPudzPt6M,236
 scdesigner/transform/amplify.py,sha256=aNxpuyoDpXI4xK5FyCaGKqLqUh4SxFCZhwZeW8XonEQ,351
 scdesigner/transform/mask.py,sha256=z-NQ6xcnEzCFWvlfCRhQOrE-TWvtAwQ6Cs8KBPahBSk,1032
-scdesigner/transform/nullify.py,sha256=OjeS9UJA1Cm8LImuGFytIKnA-Oy_qXY_C9NBFMjyjNQ,780
+scdesigner/transform/nullify.py,sha256=pEtYNDVT2Z_BmVc5CKl3CoxB37KOvqMReoQGnvFYMKE,792
 scdesigner/transform/split.py,sha256=AK3mU52DHSagdyW-d79tsZ12zMKc5xMF_MockUUvciE,741
 scdesigner/transform/substitute.py,sha256=pozV7IVJLyUzJVKeaSX86v0bl9foSFIAQpZ0oC18xak,326
-scdesigner-0.0.3.dist-info/METADATA,sha256=r2NUcpEnqH9rvuRj3N-qv0yXU7e3yx4fKbojR_RLYvc,766
-scdesigner-0.0.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-scdesigner-0.0.3.dist-info/RECORD,,
+scdesigner-0.0.5.dist-info/METADATA,sha256=SykpXsuJatehhOj2nFtqVrW5o82d5JEij4r6ndCEf_8,741
+scdesigner-0.0.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+scdesigner-0.0.5.dist-info/RECORD,,