scCODA

https://sccoda.readthedocs.io/en/latest/
Admin
scCODA is a Bayesian statistical toolbox for analyzing changes in compositional data from...
Tokens:33,510
Snippets:249
Trust Score:9.6
Update:6 months ago
Show doc for...
Tokens:
Raw
### Setup Imports and Warnings

Source: https://sccoda.readthedocs.io/en/latest/getting_started.html

Imports necessary libraries and suppresses warnings for cleaner output. Ensure all listed packages are installed.

```python
import importlib
import warnings
warnings.filterwarnings("ignore")

import pandas as pd
import pickle as pkl
import matplotlib.pyplot as plt

from sccoda.util import comp_ana as mod
from sccoda.util import cell_composition_data as dat
from sccoda.util import data_visualization as viz

import sccoda.datasets as scd
```

--------------------------------

### Model Setup and Inference - Utility Functions

Source: https://sccoda.readthedocs.io/en/latest/api.html

Utility functions for model setup and inference.

```APIDOC
## Model Setup and Inference - Utility Functions

### Description
Utility functions that support model setup and inference processes.

### Functions
- `sccoda.util.helper_functions.sample_size_estimate(...)`: Calculates the estimated number of required samples for fixed MCC, absolute increase and log2-fold change using the fitted linear model.
```

--------------------------------

### Install scCODA from source

Source: https://sccoda.readthedocs.io/en/latest/installation.html

Commands to clone the repository and install required dependencies manually.

```bash
git clone https://github.com/theislab/scCODA
```

```bash
cd scCODA
```

```bash
pip install -r requirements.txt
```

--------------------------------

### Setup scCODA environment

Source: https://sccoda.readthedocs.io/en/latest/Modeling_options_and_result_analysis.html

Import necessary libraries and suppress warnings for the analysis.

```python
# Setup
import warnings
warnings.filterwarnings("ignore")

import pandas as pd
import matplotlib.pyplot as plt
import arviz as az

from sccoda.util import comp_ana as mod
from sccoda.util import cell_composition_data as dat
from sccoda.util import data_visualization as viz
```

--------------------------------

### Importing scCODA dependencies

Source: https://sccoda.readthedocs.io/en/latest/Data_import_and_visualization.html

Initial setup for importing necessary libraries and scCODA utility modules.

```python
# Imports
import pandas as pd
import matplotlib.pyplot as plt
import anndata as ad
import warnings

from sccoda.util import cell_composition_data as dat
from sccoda.util import data_visualization as viz

import sccoda.datasets as scd

warnings.filterwarnings("ignore")
```

--------------------------------

### Model Setup and Inference - Compositional Analysis

Source: https://sccoda.readthedocs.io/en/latest/api.html

Classes for setting up and performing compositional analysis using the scCODA model.

```APIDOC
## Model Setup and Inference - Compositional Analysis

### Description
Classes and functions for setting up and performing compositional analysis with the scCODA model.

### Classes
- `sccoda.util.comp_ana.CompositionalAnalysis(...)`: Initializer class for scCODA models. Allows specifying the formula via patsy syntax and the reference cell type.
- `sccoda.model.scCODA_model.CompositionalModel(...)`: Dynamical framework for formulation and inference of Bayesian models for compositional data analysis.
- `sccoda.model.scCODA_model.scCODAModel(...)`: Statistical model for single-cell differential composition analysis with specification of a reference cell type.
```

--------------------------------

### Install scCODA via pip

Source: https://sccoda.readthedocs.io/en/latest/installation.html

Use this command to install the package directly from the Python Package Index.

```bash
pip install sccoda
```

--------------------------------

### SCCoda Compositional Analysis Summary Example

Source: https://sccoda.readthedocs.io/en/latest/getting_started.html

An example of the output from the summary() method, showing data dimensions, reference index, formula, intercepts, and covariate effects on cell types. Pay attention to 'Final Parameter' and 'log2-fold change' for interpretation.

```text
Compositional Analysis summary:

Data: 6 samples, 8 cell types
Reference index: 3
Formula: Condition

Intercepts:
                       Final Parameter  Expected Sample
Cell Type
Endocrine                        1.109        34.615689
Enterocyte                       2.325       116.781775
Enterocyte.Progenitor            2.508       140.233238
Goblet                           1.739        64.994784
Stem                             2.693       168.731218
TA                               2.104        93.625897
TA.Early                         2.856       198.602834
Tuft                             0.422        17.414567


Effects:
                                         Final Parameter  Expected Sample  \
Covariate         Cell Type
Condition[T.Salm] Endocrine                     0.000000        24.744607
                  Enterocyte                    1.348671       321.590375
                  Enterocyte.Progenitor         0.000000       100.244037
                  Goblet                        0.000000        46.460736
                  Stem                          0.000000       120.615473
                  TA                            0.000000        66.927342
                  TA.Early                      0.000000       141.968837
                  Tuft                          0.000000        12.448593

                                         log2-fold change
Covariate         Cell Type
Condition[T.Salm] Endocrine                     -0.484312
                  Enterocyte                     1.461409
                  Enterocyte.Progenitor         -0.484312
                  Goblet                        -0.484312
                  Stem                          -0.484312
                  TA                            -0.484312
                  TA.Early                      -0.484312
                  Tuft                          -0.484312
```

```text
Compositional Analysis summary:

Data: 6 samples, 8 cell types
Reference index: 3
Formula: Condition

Intercepts:
                       Final Parameter  Expected Sample
Cell Type
Endocrine                        1.136        34.655473
Enterocyte                       2.358       117.619596
Enterocyte.Progenitor            2.539       140.957109
Goblet                           1.758        64.551003
Stem                             2.717       168.419124
TA                               2.129        93.546221
TA.Early                         2.877       197.641672
Tuft                             0.459        17.609802


Effects:
                                         Final Parameter  Expected Sample  \
Covariate         Cell Type
Condition[T.Salm] Endocrine                     0.000000        24.773668
                  Enterocyte                    1.343318       322.176411
                  Enterocyte.Progenitor         0.000000       100.764016
                  Goblet                        0.000000        46.144663
                  Stem                          0.000000       120.395398
                  TA                            0.000000        66.872065
                  TA.Early                      0.000000       141.285309
                  Tuft                          0.000000        12.588470

                                         log2-fold change
Covariate         Cell Type
Condition[T.Salm] Endocrine                     -0.484276
                  Enterocyte                     1.453722
                  Enterocyte.Progenitor         -0.484276
                  Goblet                        -0.484276
                  Stem                          -0.484276
                  TA                            -0.484276
                  TA.Early                      -0.484276
                  Tuft                          -0.484276
```

--------------------------------

### Configure R for ALDEx2

Source: https://sccoda.readthedocs.io/en/latest/using_other_compositional_methods.html

Specify the paths to your R installation for the ALDEx2 model. 'r_home' should point to the R resources directory and 'r_path' to the R executable.

```python
r_home = "/Library/Frameworks/R.framework/Resources"
r_path = "/Library/Frameworks/R.framework/Resources/bin/R"
```

--------------------------------

### Set Up Compositional Analysis Model

Source: https://sccoda.readthedocs.io/en/latest/getting_started.html

Initializes the CompositionalAnalysis model with filtered data, a specified formula, and a reference cell type. The 'automatic' option can be used if no prior knowledge of a stable cell type exists.

```python
model_salm = mod.CompositionalAnalysis(data_salm, formula="Condition", reference_cell_type="Goblet")
```

--------------------------------

### DirichRegModel.fit_model

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.DirichRegModel.fit_model.html

Fits the DirichReg model by specifying paths to the R installation and executable.

```APIDOC
## DirichRegModel.fit_model

### Description
Fits the DirichReg model.

### Method
`fit_model`

### Endpoint
`DirichRegModel.fit_model(r_home='', r_path='')`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
#### Path Parameters
- **r_home** (str) - Optional - path to R installation on your machine, e.g. “C:/Program Files/R/R-4.0.3”
- **r_path** (str) - Optional - path to R executable on your machine, e.g. “C:/Program Files/R/R-4.0.3/bin/x64”

### Request Example
```json
{
  "r_home": "C:/Program Files/R/R-4.0.3",
  "r_path": "C:/Program Files/R/R-4.0.3/bin/x64"
}
```

### Response
#### Success Response (200)
This method does not explicitly define a success response body in the documentation. It is assumed to return implicitly upon successful execution.

#### Response Example
```json
{
  "message": "Model fitted successfully"
}
```
```

--------------------------------

### Importing scCODA modules and dependencies

Source: https://sccoda.readthedocs.io/en/latest/using_other_compositional_methods.html

Initializes the environment by importing necessary libraries and the scCODA model wrappers.

```python
# Setup
import warnings
warnings.filterwarnings("ignore")

import pandas as pd
import patsy as pt
import numpy as np

from sccoda.model import other_models as om
from sccoda.util import cell_composition_data as dat
from sccoda.util import data_visualization as viz
```

--------------------------------

### BetaBinomialModel.fit_model

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.BetaBinomialModel.fit_model.html

Fits the Beta-Binomial model. This method requires paths to your R installation and executable.

```APIDOC
## BetaBinomialModel.fit_model

### Description
Fits Beta-Binomial model.

### Method
(Not specified, assumed to be a method call within a class instance)

### Endpoint
(Not applicable, this is a Python method)

### Parameters
#### Path Parameters
(None)

#### Query Parameters
(None)

#### Request Body
(None)

### Request Example
```python
model.fit_model(r_home="path/to/R", r_path="path/to/R/bin")
```

### Response
#### Success Response (200)
(No specific success response details provided, assumed to be model fitting completion)

#### Response Example
(No specific response example provided)
```

--------------------------------

### Initialize and analyze SCDC model

Source: https://sccoda.readthedocs.io/en/latest/using_other_compositional_methods.html

Configures the SCDC model using scdney and performs analysis with specified R paths.

```python
scdc_model = om.scdney_model(data_salm, covariate_column="Condition")
result, _ = scdc_model.analyze(r_home=r_home, r_path=r_path)
print(result)
```

--------------------------------

### Loading sample data from pandas

Source: https://sccoda.readthedocs.io/en/latest/Data_import_and_visualization.html

Load the Haber et al. dataset into a pandas DataFrame for demonstration.

```python
# Read data into pandas from csv

cell_counts = scd.haber()

print(cell_counts)
```

--------------------------------

### sccoda.util.data_generation.b_w_from_abs_change

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.data_generation.b_w_from_abs_change.html

Calculates intercepts and slopes from a starting count and an absolute change for the first cell type.

```APIDOC
## sccoda.util.data_generation.b_w_from_abs_change

### Description
Calculates intercepts and slopes from a starting count and an absolute change for the first cell type.

### Parameters
- **counts_before** (ndarray) - Optional - cell counts for control samples (default: array([200, 200, 200, 200, 200]))
- **abs_change** (ndarray) - Optional - change of first cell type in terms of cell counts (default: array([50, 0, 0, 0, 0]))
- **n_total** (int) - Optional - number of cells per sample. This stays constant over all samples (default: 1000)

### Response
- **intercepts** (ndarray) - intercept parameters
- **slopes** (ndarray) - slope parameters
```

--------------------------------

### CompositionalModel Constructor

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.scCODA_model.CompositionalModel.html

Initializes the CompositionalModel with covariate and data matrices.

```APIDOC
## CompositionalModel Constructor

### Description
Initializes the dynamical framework for Bayesian models for compositional data analysis.

### Parameters
- **covariate_matrix** (Numpy array) - Required - Independent variables (X).
- **data_matrix** (Numpy array) - Required - Dependent variable (Y) containing raw cell type counts.
- **cell_types** (list) - Required - Names of cell types.
- **covariate_names** (list) - Required - Names of covariates.
- **formula** (string) - Required - R-style formula for covariate inclusion and transformation.
```

--------------------------------

### sccoda.util.data_generation.counts_from_first

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.data_generation.counts_from_first.html

Calculates a count vector from a given first entry, length and sum. The entries 2…K will get the same value.

```APIDOC
## counts_from_first

### Description
Calculates a count vector from a given first entry, length and sum. The entries 2…K will get the same value.

### Method
N/A (This is a function, not an API endpoint)

### Endpoint
N/A

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A

### Response
#### Success Response (200)
- **b** (ndarray) - count vector (not necessarily integer), size K

#### Response Example
N/A

### Parameters
- **b_0** (int) - Optional - size of first entry (default: 200)
- **n_total** (int) - Optional - total sum of all entries (default: 1000)
- **K** (int) - Optional - length of output vector (number of cell types) (default: 5)
```

--------------------------------

### from_scanpy_dir

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.cell_composition_data.from_scanpy_dir.html

Creates a compositional analysis data set from all scanpy data sets in a directory.

```APIDOC
## from_scanpy_dir

### Description
Creates a compositional analysis data set from all scanpy data sets in a directory. All data sets must have an identically named column in adata.obs containing cell type assignments.

### Parameters
- **path** (str) - Required - Path to the directory containing scanpy data sets.
- **cell_type_identifier** (str) - Required - Column name in adata.obs that specifies the cell types.
- **covariate_key** (str) - Optional - Key for adata.uns where covariate values are stored (default: None).
- **covariate_df** (DataFrame) - Optional - DataFrame containing covariates (default: None).

### Request Example
```python
data = from_scanpy_dir("./path/to/directory", cell_type_identifier="Louvain", covariate_key="covariates")
```

### Response
- **Returns** (AnnData) - A compositional analysis data set.
```

--------------------------------

### DirichRegModel Initialization

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.DirichRegModel.html

Initializes the DirichRegModel, wrapping the DirichReg package from R.

```APIDOC
## DirichRegModel Initialization

### Description
Initializes the DirichRegModel, which acts as a wrapper for the DirichReg package in R, integrating it with scCODA's infrastructure.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **data** (type) - Required - The input data for the model.
- **covariate_column** (string) - Optional - Defaults to 'x_0'. Specifies the column to be used as a covariate.
```

--------------------------------

### Generate Extended Model Summary

Source: https://sccoda.readthedocs.io/en/latest/Modeling_options_and_result_analysis.html

Use `summary_extended()` to get detailed posterior inference and MCMC sampling information. You can customize the credible interval probability using the `hdi_prob` argument.

```python
salm_results.summary_extended(hdi_prob=0.9)
```

--------------------------------

### ANCOMBCModel.fit_model

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.ANCOMBCModel.fit_model.html

Fits the ANCOM with bias correction model. This method allows for customization of the p-value calculation method, library size threshold, R installation paths, nominal FDR value, and prevalence cutoff for cell types.

```APIDOC
## ANCOMBCModel.fit_model

### Description
Fits ANCOM with bias correction model.

### Method
`fit_model`

### Endpoint
`sccoda.model.other_models.ANCOMBCModel.fit_model`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body example provided"
}
```

### Response
#### Success Response (200)
- **None** (None) - Description not provided

#### Response Example
```json
{
  "example": "No response example provided"
}
```

### Parameters
- **method** (str) - Default: `'fdr'` - method that is used to calculate p-values
- **lib_cut** (int) - Default: `0` - threshold to filter out classes
- **r_home** (str) - Default: `''` - path to R installation on your machine, e.g. “C:/Program Files/R/R-4.0.3”
- **r_path** (str) - Default: `''` - path to R executable on your machine, e.g. “C:/Program Files/R/R-4.0.3/bin/x64”
- **alpha** (float) - Default: `0.05` - Nominal FDR value
- **zero_cut** (float) - Default: `0.9` - Prevalence cutoff for cell types (cell types with higher percentage of zero entries are dropped)
```

--------------------------------

### Import scCODA in Python

Source: https://sccoda.readthedocs.io/en/latest/installation.html

Standard command to load the library in a Python session.

```python
import sccoda
```

--------------------------------

### MCMC Sampling and Compositional Analysis Summary

Source: https://sccoda.readthedocs.io/en/latest/Modeling_options_and_result_analysis.html

This output shows the completion of MCMC sampling, including the duration and acceptance rate. It then presents a summary of the compositional analysis, detailing intercepts and effects for different cell types and conditions.

```log
MCMC sampling finished. (123.099 sec)
Acceptance rate: 78.2%
Compositional Analysis summary:

Data: 10 samples, 8 cell types
Reference index: 0
Formula: Condition

Intercepts:
                       Final Parameter  Expected Sample
Cell Type
Endocrine                        0.986        46.634633
Enterocyte                       1.905       116.902874
Enterocyte.Progenitor            2.348       182.061302
Goblet                           1.474        75.970374
Stem                             2.427       197.027528
TA                               1.878       113.788726
TA.Early                         2.534       219.278684
Tuft                             0.626        32.535879


Effects:
                                                 Final Parameter  \
Covariate                 Cell Type
Condition[T.H.poly.Day10] Endocrine                     0.000000
                          Enterocyte                    0.000000
                          Enterocyte.Progenitor         0.000000
                          Goblet                        0.000000
                          Stem                          0.000000
                          TA                            0.000000
                          TA.Early                      0.000000
                          Tuft                          0.000000
Condition[T.H.poly.Day3]  Endocrine                     0.000000
                          Enterocyte                    0.000000
                          Enterocyte.Progenitor         0.000000
                          Goblet                        0.000000
                          Stem                          0.000000
                          TA                            0.000000
                          TA.Early                      0.000000
                          Tuft                          0.000000
Condition[T.Salm]         Endocrine                     0.000000
                          Enterocyte                    1.554932
                          Enterocyte.Progenitor         0.000000
                          Goblet                        0.000000
                          Stem                          0.000000
                          TA                            0.000000
                          TA.Early                      0.000000
                          Tuft                          0.000000

                                                 Expected Sample  \
Covariate                 Cell Type
Condition[T.H.poly.Day10] Endocrine                    46.634633
                          Enterocyte                  116.902874
                          Enterocyte.Progenitor       182.061302
                          Goblet                       75.970374
                          Stem                        197.027528
                          TA                          113.788726
                          TA.Early                    219.278684
                          Tuft                         32.535879
Condition[T.H.poly.Day3]  Endocrine                    46.634633
                          Enterocyte                  116.902874
                          Enterocyte.Progenitor       182.061302
                          Goblet                       75.970374

```

--------------------------------

### CompositionalAnalysis Class Initialization

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.comp_ana.CompositionalAnalysis.html

Initializes the scCODA model for compositional analysis. Requires an AnnData object, a formula string, and optionally a reference cell type and threshold.

```APIDOC
## CompositionalAnalysis

### Description
Initializer class for scCODA models. This class is called when performing compositional analysis with scCODA.

### Method
__init__

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **data** (anndata._core.anndata.AnnData) - AnnData object with cell counts as data.X and covariates saved in data.obs
- **formula** (str) - Patsy-style formula for building the covariate matrix. Categorical covariates are handled automatically, with the covariate value of the first sample being used as the reference category. To set a different level as the base category for a categorical covariate, use "C(<CovariateName>, Treatment('<ReferenceLevelName>'))"
- **reference_cell_type** (Union[str, int]) - Optional. Column index that sets the reference cell type. Can either reference the name of a column or a column number (starting at 0). If "automatic", the cell type with the lowest dispersion in relative abundance that is present in at least 90% of samples will be chosen.
- **automatic_reference_absence_threshold** (float) - Optional. Default is 0.05. Threshold for automatic reference cell type selection.

### Request Example
```python
from sccoda.util.comp_ana import CompositionalAnalysis

# Assuming 'adata' is an AnnData object and 'formula_str' is a valid formula string
model = CompositionalAnalysis(data=adata, formula=formula_str, reference_cell_type='CellTypeA')
```

### Response
#### Success Response (200)
Initializes the CompositionalAnalysis object.

#### Response Example
```python
# No direct response example for initialization, object is created in memory
```
```

--------------------------------

### AncomModel Class

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.AncomModel.html

Initializes the AncomModel for compositional differentiation analysis.

```APIDOC
## Class: AncomModel

### Description
Wrapper for the ancom model for compositional differentiation analysis (Mandal et al., 2015).

### Parameters
- **data** (object) - Required - The input data for the model.
- **covariate_column** (string) - Optional - The column name for covariates (default: 'x_0').
```

--------------------------------

### Initialize simple Dirichlet-Multinomial model

Source: https://sccoda.readthedocs.io/en/latest/using_other_compositional_methods.html

Prepares count data and covariate matrices to initialize the SimpleModel for Dirichlet-Multinomial inference.

```python
K = data_salm.X.shape[1]
formula = "Condition"

cell_types = data_salm.var.index.to_list()

# Get count data
data_matrix = data_salm.X.astype("float32")

# Build covariate matrix from R-like formula
covariate_matrix = pt.dmatrix(formula, data_salm.obs)
covariate_names = covariate_matrix.design_info.column_names[1:]
covariate_matrix = covariate_matrix[:, 1:]

# Init model. Baseline index is always the last cell type
mod = om.SimpleModel(covariate_matrix=np.array(covariate_matrix), data_matrix=data_matrix,
                     cell_types=cell_types, covariate_names=covariate_names, formula=formula,
                     reference_cell_type=4)
```

--------------------------------

### POST /sccoda/model/simple_model/sample_nuts

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.SimpleModel.sample_nuts.html

Executes HMC with No-U-turn (NUTS) sampling for the SimpleModel.

```APIDOC
## POST /sccoda/model/simple_model/sample_nuts

### Description
Performs HMC with No-U-turn (NUTS) sampling. Note that this method is currently untested and may yield unexpected results. The spike-and-slab prior used in scCODA often leads to samples being flagged as diverging.

### Parameters
#### Request Body
- **num_results** (int) - Optional - MCMC chain length (default: 10000)
- **num_burnin** (int) - Optional - Number of burnin iterations (default: 5000)
- **num_adapt_steps** (int) - Optional - Length of step size adaptation procedure (default: None)
- **max_tree_depth** (int) - Optional - Maximum tree depth (default: 10)
- **step_size** (float) - Optional - Initial step size (default: 0.01)
- **verbose** (bool) - Optional - If true, a progress bar is printed during MCMC sampling (default: True)

### Response
#### Success Response (200)
- **result** (CAResult) - Compositional analysis result object containing diagnostic statistics such as target_log_prob, leapfrogs_taken, diverging, energy, log_accept_ratio, step_size, reached_max_depth, and is_accepted.
```

--------------------------------

### Data Acquisition - Compositional Data Visualization

Source: https://sccoda.readthedocs.io/en/latest/api.html

Functions for visualizing compositional datasets.

```APIDOC
## Data Acquisition - Compositional Data Visualization

### Description
Functions for plotting and visualizing compositional datasets.

### Functions
- `sccoda.util.data_visualization.stacked_barplot(...)`: Plots a stacked barplot for all levels of a covariate or all samples.
- `sccoda.util.data_visualization.boxplots(...)`: Grouped boxplot visualization.
- `sccoda.util.data_visualization.stackbar(y, ...)`: Plots a stacked barplot for one (discrete) covariate.
```

--------------------------------

### SimpleModel Class Methods

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.SimpleModel.html

Overview of the methods available for the SimpleModel class to perform MCMC sampling and result generation.

```APIDOC
## SimpleModel Class Methods

### Description
Methods for initializing and running MCMC sampling on the Simple Dirichlet-Multinomial model.

### Parameters
#### Constructor Parameters
- **reference_cell_type** (str) - Required - The reference cell type for the model.

### Methods
- **get_chains_after_burnin(samples, is_nuts)**: Application of burn-in after MCMC sampling.
- **get_y_hat(states_burnin, num_results, num_burnin)**: Calculate posterior mode of cell counts and add intermediate parameters.
- **make_result(states_burnin, sample_stats)**: Result object generating function.
- **sample_hmc(num_results, num_burnin)**: Hamiltonian Monte Carlo (HMC) sampling in tensorflow 2.
- **sample_hmc_da(num_results, num_burnin)**: HMC sampling with dual-averaging step size adaptation.
- **sample_nuts(num_results, num_burnin)**: HMC with No-U-turn (NUTS) sampling.
- **sampling(num_results, num_burnin, kernel)**: MCMC sampling process (tensorflow 2).
```

--------------------------------

### BetaBinomialModel Class

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.BetaBinomialModel.html

Initializes the BetaBinomialModel wrapper for the corncob package.

```APIDOC
## Class: sccoda.model.other_models.BetaBinomialModel

### Description
Wrapper for using the corncob package for R (Martin et al., 2020).

### Parameters
- **data** (object) - Required - The input data object.
- **covariate_column** (string) - Optional - The column name for covariates (default: 'x_0').
```

--------------------------------

### Model Comparison Module

Source: https://sccoda.readthedocs.io/en/latest/api.html

Overview of available models in sccoda.models.other_models for compositional differentiation analysis.

```APIDOC
## Model Comparison Module

### Description
Provides implementations of compositional methods and non-compositional tests for benchmarking and comparison against scCODA.

### Available Models
- **SimpleModel**: Simple Dirichlet-Multinomial model with normal priors.
- **scdney_model**: Wrapper for the scdney R package.
- **HaberModel**: Poisson regression model (Haber et al.).
- **CLRModel**: CLR transform followed by linear model.
- **TTest**: T-test on each cell type.
- **CLRModel_ttest**: CLR transform followed by t-test.
- **ALDEx2Model**: Wrapper for the ALDEx2 R package.
- **ALRModel_ttest**: ALR transform followed by t-test.
- **ALRModel_wilcoxon**: ALR transform followed by Wilcoxon rank-sum test.
- **AncomModel**: Wrapper for the ANCOM model.
- **DirichRegModel**: Wrapper for the DirichReg R package.
- **BetaBinomialModel**: Wrapper for the corncob R package.
- **ANCOMBCModel**: Wrapper for the ANCOMBC R package.
```

--------------------------------

### ALRModel_wilcoxon Class Initialization

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.ALRModel_wilcoxon.html

Initializes the ALRModel_wilcoxon class with data and a specified covariate column.

```APIDOC
## ALRModel_wilcoxon Initialization

### Description
Initializes the ALRModel_wilcoxon class to perform ALR transformation and Wilcoxon rank-sum tests.

### Parameters
- **data** (object) - Required - The input data object.
- **covariate_column** (string) - Optional - The column name for covariates (default: 'x_0').
```

--------------------------------

### Import scCODA modules

Source: https://sccoda.readthedocs.io/en/latest/api.html

Standard import pattern for accessing scCODA utilities and analysis tools.

```python
import sccoda
dat = sccoda.util.cell_composition_data
ana = sccoda.util.compositional_analysis
viz = sccoda.util.data_visualization
```

--------------------------------

### SimpleModel.sampling

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.SimpleModel.sampling.html

Executes the MCMC sampling process using TensorFlow 2.

```APIDOC
## SimpleModel.sampling

### Description
Performs the MCMC sampling process using TensorFlow 2.

### Parameters
- **num_results** (int) - Optional - MCMC chain length (default 20000)
- **num_burnin** (int) - Optional - Number of burnin iterations (default 5000)
- **kernel** (object) - Required - tensorflow MCMC kernel object
- **init_state** (dict) - Required - Starting parameters
- **trace_fn** (function) - Required - Tracing function

### Response
- **states** (List[any]) - States of MCMC chain
- **kernel_results** (List[any]) - Sampling meta-information
- **duration** (float) - Duration of MCMC sampling process
```

--------------------------------

### Run HMC Sampling

Source: https://sccoda.readthedocs.io/en/latest/using_other_compositional_methods.html

Initiates HMC sampling for the model. The result object contains methods for summarizing the sampling output.

```python
result_simple = mod.sample_hmc()
```

```python
result_simple.summary_extended()
```

--------------------------------

### from_scanpy_list

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.cell_composition_data.from_scanpy_list.html

Creates a compositional analysis data set from a list of scanpy data sets.

```APIDOC
## from_scanpy_list

### Description
Creates a compositional analysis data set from a list of scanpy data sets. All data sets must have an identically named column in adata.obs containing cell type assignments.

### Parameters
#### Arguments
- **samples** (List[AnnData]) - Required - List of scanpy data sets.
- **cell_type_identifier** (str) - Required - Column name in adata.obs that specifies the cell types.
- **covariate_key** (str) - Optional - Key for adata.uns where covariate values are stored. Default: None.
- **covariate_df** (DataFrame) - Optional - DataFrame with covariates. Default: None.

### Request Example
```python
data = from_scanpy_list([adata1, adata2, adata3], cell_type_identifier="Louvain", covariate_df="covariates")
```

### Response
- **Returns** (AnnData) - A compositional analysis data set.
```

--------------------------------

### CAResult.summary_prepare

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.result_classes.CAResult.summary_prepare.html

Generates summary dataframes for intercepts and slopes. This function builds on and supports all functionalities from az.summary.

```APIDOC
## CAResult.summary_prepare

### Description
Generates summary dataframes for intercepts and slopes. This function builds on and supports all functionalities from `az.summary`.

### Method
`summary_prepare`

### Endpoint
`CAResult.summary_prepare(est_fdr = 0.05, *args, **kwargs)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "No request body example available"
}
```

### Response
#### Success Response (200)
- **intercept_df** (pandas df) - Summary of intercept parameters. Contains one row per cell type.
- **effect_df** (pandas df) - Summary of effect (slope) parameters. Contains one row per covariate/cell type combination.

#### Response Example
```json
{
  "intercept_df": {
    "Final Parameter": "string",
    "HDI X%": "string",
    "SD": "float",
    "Expected sample": "float"
  },
  "effect_df": {
    "Final Parameter": "string",
    "HDI X%": "string",
    "SD": "float",
    "Expected sample": "float",
    "log2-fold change": "float",
    "Inclusion probability": "float"
  }
}
```
```

--------------------------------

### MLIR Optimization and XLA Compilation

Source: https://sccoda.readthedocs.io/en/latest/Modeling_options_and_result_analysis.html

These log messages indicate that no MLIR Optimization Passes are enabled and that the XLA service has been initialized for the Host platform. It also logs that an XLA compilation cache has been successfully used.

```log
2021-11-28 19:15:23.943628: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
  0%|          | 0/20000 [00:00<?, ?it/s]2021-11-28 19:15:25.649198: I tensorflow/compiler/xla/service/service.cc:169] XLA service 0x7fd21d1c63a0 initialized for platform Host (this does not guarantee that XLA will be used). Devices:
2021-11-28 19:15:25.649348: I tensorflow/compiler/xla/service/service.cc:177]   StreamExecutor device (0): Host, Default Version
2021-11-28 19:15:28.022894: I tensorflow/compiler/jit/xla_compilation_cache.cc:337] Compiled cluster using XLA!  This line is logged at most once for the lifetime of the process.
100%|██████████| 20000/20000 [01:38<00:00, 203.36it/s]
```

--------------------------------

### Load and preprocess data

Source: https://sccoda.readthedocs.io/en/latest/Modeling_options_and_result_analysis.html

Load cell counts from CSV, convert to AnnData, and filter for specific conditions.

```python
# Load data
cell_counts = pd.read_csv("../data/haber_counts.csv")

# Convert data to anndata object
data_all = dat.from_pandas(cell_counts, covariate_columns=["Mouse"])

# Extract condition from mouse name and add it as an extra column to the covariates
data_all.obs["Condition"] = data_all.obs["Mouse"].str.replace(r"_[0-9]", "")
print(f"Entire dataset: {data_all}")

# Select control and salmonella data
data_salm = data_all[data_all.obs["Condition"].isin(["Control", "Salm"])].copy()
print(f"Salmonella dataset: {data_salm}")

viz.boxplots(data_all, feature_name="Condition")
plt.show()
```

--------------------------------

### Switch Reference Cell Type with HMC Sampling

Source: https://sccoda.readthedocs.io/en/latest/Modeling_options_and_result_analysis.html

Demonstrates how to set a different reference cell type (e.g., 'Enterocyte') and perform HMC sampling for compositional analysis. This can lead to different credible effects compared to other reference choices.

```python
model_salm_ref = mod.CompositionalAnalysis(data_salm, formula="Condition", reference_cell_type="Enterocyte")
reference_results = model_salm_ref.sample_hmc()
reference_results.summary()
```

--------------------------------

### Method: sample_nuts

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.scCODA_model.scCODAModel.sample_nuts.html

Performs HMC with No-U-turn (NUTS) sampling for the scCODA model.

```APIDOC
## sample_nuts

### Description
Performs HMC with No-U-turn (NUTS) sampling. Note that this method is currently untested and may yield unexpected results. The spike-and-slab prior often leads to samples being flagged as diverging.

### Parameters
- **num_results** (int) - Optional - MCMC chain length (default: 10000)
- **num_burnin** (int) - Optional - Number of burnin iterations (default: 5000)
- **num_adapt_steps** (int) - Optional - Length of step size adaptation procedure (default: None)
- **max_tree_depth** (int) - Optional - Maximum tree depth (default: 10)
- **step_size** (float) - Optional - Initial step size (default: 0.01)
- **verbose** (float) - Optional - If true, a progress bar is printed during MCMC sampling (default: True)

### Response
- **result** (CAResult) - Compositional analysis result object
```

--------------------------------

### ALRModel_ttest Class Initialization

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.ALRModel_ttest.html

Initializes the ALRModel_ttest class with data and a specified covariate column.

```APIDOC
## Class: ALRModel_ttest

### Description
Implements an ALR transform and subsequent t-test on each cell type.

### Parameters
- **data** (object) - Required - The input data for the model.
- **covariate_column** (string) - Optional - The column name for the covariate (default: 'x_0').
```

--------------------------------

### Save Analysis Results

Source: https://sccoda.readthedocs.io/en/latest/getting_started.html

Save the compositional analysis results as a pickle object to a specified file path. This allows for later retrieval and further analysis.

```python
# saving
path = "test"
sim_results.save(path)
```

--------------------------------

### Create Compositional Data from Scanpy Directory

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.cell_composition_data.from_scanpy_dir.html

Use this function to create a compositional analysis dataset from multiple scanpy datasets in a directory. Ensure all datasets have an identical column for cell type assignment. Covariates can be provided via adata.uns or a separate DataFrame.

```python
data = from_scanpy_dir("./path/to/directory", cell_type_identifier="Louvain", covariate_key="covariates")
```

--------------------------------

### sccoda.util.cell_composition_data.from_scanpy

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.cell_composition_data.from_scanpy.html

Creates a compositional analysis dataset from a single AnnData object.

```APIDOC
## sccoda.util.cell_composition_data.from_scanpy

### Description
Creates a compositional analysis dataset from a single anndata object, as it is produced by e.g. scanpy. The anndata object needs to have a column in adata.obs that contains the cell type assignment, and one column that specifies the grouping into samples.

### Parameters
- **adata** (AnnData) - Required - List of scanpy data sets
- **cell_type_identifier** (str) - Required - Column name in adata.obs that specifies the cell types
- **sample_identifier** (str) - Required - Column name in adata.obs that specifies the sample
- **covariate_key** (str) - Optional - Key for adata.uns, where covariate values are stored
- **covariate_df** (DataFrame) - Optional - DataFrame with covariates

### Response
- **data** (AnnData) - A compositional analysis data set
```

--------------------------------

### CompositionalModel.sample_nuts

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.scCODA_model.CompositionalModel.sample_nuts.html

Performs HMC with No-U-turn (NUTS) sampling. This method is untested and might yield different results than expected. It tracks diagnostic statistics such as target_log_prob, leapfrogs_taken, diverging, energy, log_accept_ratio, step_size, reached_max_depth, and is_accepted.

```APIDOC
## CompositionalModel.sample_nuts

### Description
HMC with No-U-turn (NUTS) sampling. This method is untested and might yield different results than expected. It tracks diagnostic statistics.

### Method
POST

### Endpoint
/CompositionalModel/sample_nuts

### Parameters
#### Query Parameters
- **num_results** (int) - Optional - MCMC chain length (default 10000)
- **num_burnin** (int) - Optional - Number of burnin iterations (default 5000)
- **num_adapt_steps** (Optional[int]) - Optional - Length of step size adaptation procedure
- **max_tree_depth** (int) - Optional - Maximum tree depth (default 10)
- **step_size** (float) - Optional - Initial step size (default 0.01)
- **verbose** (float) - Optional - If true, a progress bar is printed during MCMC sampling (default True)

### Response
#### Success Response (200)
- **result** (CAResult) - Compositional analysis result
```

--------------------------------

### POST /sccoda.model.scCODA_model.scCODAModel.sampling

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.scCODA_model.scCODAModel.sampling.html

Executes the MCMC sampling process using TensorFlow 2.

```APIDOC
## POST sccoda.model.scCODA_model.scCODAModel.sampling

### Description
Performs the MCMC sampling process for the scCODA model using TensorFlow 2.

### Parameters
#### Request Body
- **num_results** (int) - Optional - MCMC chain length (default 20000)
- **num_burnin** (int) - Optional - Number of burnin iterations (default 5000)
- **kernel** (object) - Required - tensorflow MCMC kernel object
- **init_state** (dict) - Required - Starting parameters
- **trace_fn** (function) - Required - Tracing function

### Response
#### Success Response (200)
- **states** (List[any]) - States of MCMC chain
- **kernel_results** (List[any]) - Sampling meta-information
- **duration** (float) - Duration of MCMC sampling process
```

--------------------------------

### Perform HMC Sampling with Custom Results Count

Source: https://sccoda.readthedocs.io/en/latest/Modeling_options_and_result_analysis.html

Initializes a compositional analysis model with 'Goblet' as the reference cell type and performs HMC sampling, specifying a custom number of results (20000).

```python
model_salm = mod.CompositionalAnalysis(data_salm, formula="Condition", reference_cell_type="Goblet")
salm_results = model_salm.sample_hmc(num_results=20000)
```

--------------------------------

### MCMC Sampling Methods

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.scCODA_model.CompositionalModel.html

Methods for performing MCMC sampling on the compositional model.

```APIDOC
## MCMC Sampling Methods

### Description
Methods to perform inference using various MCMC algorithms.

### Methods
- **sample_hmc**: Hamiltonian Monte Carlo (HMC) sampling.
- **sample_hmc_da**: HMC sampling with dual-averaging step size adaptation.
- **sample_nuts**: HMC with No-U-turn (NUTS) sampling.
- **sampling**: General MCMC sampling process using a transition kernel.

### Parameters
- **num_results** (int) - Required - Number of MCMC samples to generate.
- **num_burnin** (int) - Required - Number of burn-in steps.
```

--------------------------------

### Method: complete_beta_df

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.result_classes.CAResult.complete_beta_df.html

Evaluates MCMC results for effect parameters and calculates posterior inclusion probabilities.

```APIDOC
## complete_beta_df

### Description
Evaluation of MCMC results for effect parameters. This function is used to calculate the posterior inclusion probability for each effect and decide whether effects are significant.

### Parameters
- **intercept_df** (DataFrame) - Required - Intercept summary.
- **effect_df** (DataFrame) - Required - Effect summary.
- **target_fdr** (float) - Optional - Desired FDR value (default: 0.05).

### Returns
- **effect_df** (DataFrame) - DataFrame with inclusion probability, final parameters, and expected sample.
```

--------------------------------

### CAResult.summary()

Source: https://sccoda.readthedocs.io/en/latest/sccoda.util.result_classes.CAResult.summary.html

Provides a printing method for scCODA's summary, passing arguments to az.summary.

```APIDOC
## CAResult.summary()

### Description
Printing method for scCODA’s summary.

### Method
`summary`

### Endpoint
`CAResult.summary()`

### Parameters
#### Positional Arguments
- **args** - Passed to az.summary

#### Keyword Arguments
- **kwargs** - Passed to az.summary

### Request Example
```python
result.summary()
```

### Response
#### Success Response (200)
- **Output**: prints to console
```

--------------------------------

### Visualize compositional data with stacked barplots

Source: https://sccoda.readthedocs.io/en/latest/Data_import_and_visualization.html

Generate stacked barplots to visualize cell count distributions per sample or per covariate level.

```python
# Stacked barplot for each sample
viz.stacked_barplot(data_mouse, feature_name="samples")
plt.show()

# Stacked barplot for the levels of "Condition"
viz.stacked_barplot(data_mouse, feature_name="Condition")
plt.show()
```

--------------------------------

### TTest Class Initialization

Source: https://sccoda.readthedocs.io/en/latest/sccoda.model.other_models.TTest.html

Initializes the TTest model with data and a specified covariate column.

```APIDOC
## TTest Initialization

### Description
Initializes the TTest class to perform a t-test on each cell type.

### Parameters
- **data** (object) - Required - The input data for the model.
- **covariate_column** (string) - Optional - The column name representing the covariate (default: 'x_0').
```

--------------------------------

### Utility Functions

Source: https://sccoda.readthedocs.io/en/latest/genindex.html

Helper functions for data generation and other utility tasks.

```APIDOC
## Utility Functions

### Description
Provides utility functions for various tasks within the sccoda library.

### Functions

- **sparse_effect_matrix()**: Generates a sparse effect matrix.
```

--------------------------------

### Fit ANCOM Model

Source: https://sccoda.readthedocs.io/en/latest/using_other_compositional_methods.html

Use this snippet to fit the ANCOM model to your data. Ensure 'data_salm' and 'covariate_column' are correctly defined. The output 'ancom_out' contains results for differential abundance testing.

```python
ancom_model = om.AncomModel(data_salm, covariate_column="Condition")
ancom_model.fit_model()
print(ancom_model.ancom_out)
```
Tokens:
Raw