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

scdesigner/minimal/standard_copula.py

@@ -1,383 +0,0 @@
-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/predictors/__init__.py

@@ -1,15 +0,0 @@
-from .bernoulli import bernoulli_predict
-from .negbin import negbin_predict
-from .poisson import poisson_predict
-from .gaussian import gaussian_predict
-from .zero_inflated_negbin import zero_inflated_negbin_predict
-from .zero_inflated_poisson import zero_inflated_poisson_predict
-
-__all__ = [
-    "bernoulli_predict",
-    "gaussian_predict",
-    "negbin_predict",
-    "poisson_predict",
-    "zero_inflated_negbin_predict",
-    "zero_inflated_poisson_predict",
-]

scdesigner/predictors/bernoulli.py

@@ -1,9 +0,0 @@
-import numpy as np
-import pandas as pd
-from ..format import format_matrix
-
-
-def bernoulli_predict(parameters: dict, obs: pd.DataFrame, formula: str):
-    x = format_matrix(obs, formula)
-    theta = np.exp(x @ parameters["coef_mean"])
-    return {"mean": theta}

scdesigner/predictors/gaussian.py

@@ -1,16 +0,0 @@
-import numpy as np
-import pandas as pd
-from ..format import format_matrix
-from typing import Union
-
-def gaussian_predict(parameters: dict, obs: pd.DataFrame, formula: Union[str, dict]):
-    # Standardize formula to dictionary format
-    if isinstance(formula, str):
-        formula = {'mean': formula, 'sdev': '~ 1'}
-    
-    x_mean = format_matrix(obs, formula["mean"]) 
-    x_dispersion = format_matrix(obs, formula["sdev"])
-    
-    sigma = np.exp(x_dispersion @ parameters["coef_sdev"])
-    mu = x_mean @ parameters["coef_mean"]
-    return {"mean": mu, "sdev": sigma}

scdesigner/predictors/negbin.py

@@ -1,17 +0,0 @@
-import numpy as np
-import pandas as pd
-from ..format import format_matrix
-from typing import Union
-
-def negbin_predict(parameters: dict, obs: pd.DataFrame, formula: Union[str, dict]):
-    # Standardize formula to dictionary format
-    if isinstance(formula, str):
-        formula = {'mean': formula, 'dispersion': '~ 1'}
-    
-    x_mean = format_matrix(obs, formula["mean"]) 
-    x_dispersion = format_matrix(obs, formula["dispersion"])
-    
-    r = np.exp(x_dispersion @ parameters["coef_dispersion"])
-    mu = np.exp(x_mean @ parameters["coef_mean"])
-    # r and mu are still dataframes with column names being the gene names
-    return {"mean": mu, "dispersion": r}

scdesigner/predictors/poisson.py

@@ -1,12 +0,0 @@
-import numpy as np
-import pandas as pd
-from ..format import format_matrix
-from typing import Union
-
-def poisson_predict(parameters: dict, obs: pd.DataFrame, formula: Union[str, dict]):
-    if isinstance(formula, dict):
-        formula = formula['mean']
-    x = format_matrix(obs, formula)
-    mu = np.exp(x @ parameters["coef_mean"])
-    return {"mean": mu}
-

scdesigner/predictors/zero_inflated_negbin.py

@@ -1,18 +0,0 @@
-import numpy as np
-import pandas as pd
-from ..format import format_matrix
-from scipy.special import expit
-from typing import Union
-
-def zero_inflated_negbin_predict(parameters: dict, obs: pd.DataFrame, formula: Union[str, dict]):
-    if isinstance(formula, str):
-        formula = {"mean": formula, "dispersion": "~ 1", "zero_inflation": "~ 1"}
-    x_mean = format_matrix(obs, formula["mean"])
-    x_dispersion = format_matrix(obs, formula["dispersion"])
-    x_zero_inflation = format_matrix(obs, formula["zero_inflation"])
-    r, mu, pi = (
-        np.exp(x_dispersion @ parameters["coef_dispersion"]),
-        np.exp(x_mean @ parameters["coef_mean"]),
-        expit(x_zero_inflation @ parameters["coef_zero_inflation"]),
-    )
-    return {"mean": mu, "dispersion": r, "zero_inflation": pi}

scdesigner/predictors/zero_inflated_poisson.py

@@ -1,18 +0,0 @@
-from ..format import format_matrix
-from typing import Union
-import numpy as np
-import pandas as pd
-
-
-def zero_inflated_poisson_predict(parameters: dict, obs: pd.DataFrame, formula: Union[str, dict]):
-    if isinstance(formula, str):
-        formula = {'beta': formula, 'pi': '~ 1'}
-    mu, pi = (
-        np.exp(format_matrix(obs, formula['mean']) @ parameters["coef_mean"]),
-        sigmoid(format_matrix(obs, formula['zero_inflation']) @ parameters["coef_zero_inflation"]),
-    )
-    return {"mean": mu, "zero_inflation": pi}
-
-
-def sigmoid(x):
-    return 1 / (1 + np.exp(-x))

scdesigner/samplers/__init__.py

@@ -1,23 +0,0 @@
-from .negbin import negbin_sample, negbin_copula_sample
-from .poisson import poisson_sample, poisson_copula_sample
-from .bernoulli import bernoulli_sample, bernoulli_copula_sample
-from .gaussian import gaussian_regression_sample, gaussian_copula_sample
-from .zero_inflated_negbin import (
-    zero_inflated_negbin_sample,
-    zero_inflated_negbin_copula_sample,
-)
-from .zero_inflated_poisson import zero_inflated_poisson_sample
-
-__all__ = [
-    "negbin_sample",
-    "negbin_copula_sample",
-    "poisson_sample",
-    "poisson_copula_sample",
-    "bernoulli_sample",
-    "bernoulli_copula_sample",
-    "gaussian_regression_sample",
-    "gaussian_copula_sample",
-    "zero_inflated_negbin_sample",
-    "zero_inflated_negbin_copula_sample",
-    "zero_inflated_poisson_sample",
-]

scdesigner/samplers/bernoulli.py

@@ -1,27 +0,0 @@
-from . import glm_factory as glm
-from scipy.stats import bernoulli
-from typing import Union
-import numpy as np
-
-
-def bernoulli_regression_sample_array(local_parameters: dict) -> np.array:
-    theta = local_parameters["mean"]
-    return bernoulli(theta).rvs()
-
-
-def bernoulli_copula_sample_array(
-    local_parameters: dict, covariance: Union[dict, np.array], groups: dict
-) -> np.array:
-    # initialize uniformized gaussian samples
-    N, G = local_parameters["mean"].shape
-    u = glm.gaussian_copula_pseudo_obs(N, G, covariance, groups)
-
-    theta = local_parameters["mean"]
-    return bernoulli(theta).ppf(u)
-
-
-bernoulli_sample = glm.glm_sample_factory(bernoulli_regression_sample_array)
-
-bernoulli_copula_sample = glm.gaussian_copula_sample_factory(
-    bernoulli_copula_sample_array
-)

scdesigner/samplers/gaussian.py

@@ -1,25 +0,0 @@
-from scipy.stats import norm
-from . import glm_factory as glm
-from typing import Union
-import numpy as np
-
-
-def gaussian_regression_sample_array(local_parameters: dict) -> np.array:
-    sigma, mu = local_parameters["sdev"], local_parameters["mean"] # dataframes of shape (n, g)
-    return norm(loc=mu, scale=sigma).rvs()
-
-
-def gaussian_copula_sample_array(
-    local_parameters: dict, covariance: Union[dict, np.array], groups: dict
-) -> np.array:
-    # initialize uniformized gaussian samples
-    N, G = local_parameters["mean"].shape
-    u = glm.gaussian_copula_pseudo_obs(N, G, covariance, groups)
-
-    # transform the correlated uniforms to NB space
-    sigma, mu = local_parameters["sdev"], local_parameters["mean"]
-    return norm(loc=mu, scale=sigma).ppf(u)
-
-
-gaussian_regression_sample = glm.glm_sample_factory(gaussian_regression_sample_array)
-gaussian_copula_sample = glm.gaussian_copula_sample_factory(gaussian_copula_sample_array)

scdesigner/samplers/glm_factory.py

@@ -1,103 +0,0 @@
-import numpy as np
-import pandas as pd
-import anndata as ad
-from typing import Union
-from scipy.stats import norm
-
-
-def glm_sample_factory(sample_array):
-    def sampler(local_parameters: dict, obs: pd.DataFrame) -> ad.AnnData:
-        samples = sample_array(local_parameters)
-        result = ad.AnnData(X=samples, obs=obs)
-        result.var_names = local_parameters["mean"].columns
-        return result
-    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
-
-
-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))
-        )
-        
-        # 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
-
-
-def gaussian_copula_sample_factory(copula_sample_array):
-    def sampler(
-        local_parameters: dict, covariance: Union[dict, np.array], groups: dict, obs: pd.DataFrame
-    ) -> ad.AnnData:
-        samples = copula_sample_array(local_parameters, covariance, groups)
-        result = ad.AnnData(X=samples, obs=obs)
-        result.var_names = local_parameters["mean"].columns
-        return result
-    return sampler
-