cellrank.estimators.CFLARE#

class cellrank.estimators.CFLARE(object, **kwargs)[source]#

Clustering and filtering of left and right eigenvectors (CFLARE).

This estimator computes initial and terminal states, as well as fate probabilities. It uses the left eigenvectors of the transition matrix to filter to a set of (approximately) recurrent cells and the right eigenvectors to cluster this set of cells into discrete groups. CFLARE exists mostly for legacy reasons, we recommend using the cellrank.estimators.GPCCA estimator, which is mathematically more principled.

Parameters:

Attributes table#

absorption_probabilities

Absorption probabilities.

absorption_times

Mean and variance of the time until absorption.

adata

Annotated data object.

backward

Direction of kernel.

eigendecomposition

Eigendecomposition of transition_matrix.

initial_states

Categorical annotation of initial states.

initial_states_probabilities

Probability to be an initial state.

kernel

Underlying kernel expression.

lineage_drivers

Potential lineage drivers.

params

Estimator parameters.

priming_degree

Priming degree.

shape

Shape of the kernel.

terminal_states

Categorical annotation of terminal states.

terminal_states_probabilities

Probability to be a terminal state.

transition_matrix

Transition matrix of kernel.

Methods table#

compute_absorption_probabilities([keys, ...])

Compute absorption probabilities.

compute_absorption_times([keys, ...])

Compute the mean time to absorption and optionally its variance.

compute_eigendecomposition([k, which, ...])

Compute eigendecomposition of transition_matrix.

compute_lineage_drivers([lineages, method, ...])

Compute driver genes per lineage.

compute_lineage_priming([method, early_cells])

Compute the degree of lineage priming.

copy(*[, deep])

Return a copy of self.

fit([k])

Prepare self for terminal states prediction.

from_adata(adata, obsp_key)

De-serialize self from anndata.AnnData.

plot_absorption_probabilities([states, ...])

Plot absorption probabilities.

plot_lineage_drivers(lineage[, n_genes, ...])

Plot lineage drivers discovered by compute_lineage_drivers().

plot_lineage_drivers_correlation(lineage_x, ...)

Show scatter plot of gene-correlations between two lineages.

plot_macrostates(which[, states, color, ...])

Plot macrostates on an embedding or along pseudotime.

plot_spectrum([n, real_only, show_eigengap, ...])

Plot the top eigenvalues in real or complex plane.

predict([use, percentile, method, ...])

Find approximate recurrent classes of the Markov chain.

read(fname[, adata, copy])

De-serialize self from a file.

rename_initial_states(old_new)

Rename initial_states.

rename_terminal_states(old_new)

Rename terminal_states.

set_initial_states(states[, cluster_key, ...])

Set initial_states.

set_terminal_states(states[, cluster_key, ...])

Set terminal_states.

to_adata([keep, copy])

Serialize self to anndata.Anndata.

write(fname[, write_adata, ext])

Serialize self to a file.

Attributes#

absorption_probabilities#

CFLARE.absorption_probabilities#

Absorption probabilities.

Informally, given a (finite, discrete) Markov chain with a set of transient states \(T\) and a set of absorbing states \(A\), the absorption probability for cell \(i\) from \(T\) to reach cell \(j\) from \(R\) is the probability that a random walk initialized in \(i\) will reach absorbing state \(j\).

In our context, states correspond to cells, in particular, absorbing states correspond to cells in terminal states.

absorption_times#

CFLARE.absorption_times#

Mean and variance of the time until absorption.

Related to conditional mean first passage times. Corresponds to the expectation of the time until absorption, depending on initialization, and the variance.

adata#

CFLARE.adata#

Annotated data object.

backward#

CFLARE.backward#

Direction of kernel.

eigendecomposition#

CFLARE.eigendecomposition#

Eigendecomposition of transition_matrix.

For non-symmetric real matrices, left and right eigenvectors will in general be different and complex. We compute both left and right eigenvectors.

Returns:

A dictionary with the following keys:

  • ’D’ - the eigenvalues.

  • ’eigengap’ - the eigengap.

  • ’params’ - parameters used for the computation.

  • ’V_l’ - left eigenvectors (optional).

  • ’V_r’ - right eigenvectors (optional).

  • ’stationary_dist’ - stationary distribution of transition_matrix, if present.

initial_states#

CFLARE.initial_states#

Categorical annotation of initial states.

By default, all transient cells will be labeled as NaN.

initial_states_probabilities#

CFLARE.initial_states_probabilities#

Probability to be an initial state.

kernel#

CFLARE.kernel#

Underlying kernel expression.

lineage_drivers#

CFLARE.lineage_drivers#

Potential lineage drivers.

Computes Pearson correlation of each gene with fate probabilities for every terminal state. High Pearson correlation indicates potential lineage drivers. Also computes p-values and confidence intervals.

Returns:

Dataframe of shape (n_genes, n_lineages * 5) containing the following columns, one for each lineage:

  • {lineage}_corr - correlation between the gene expression and absorption probabilities.

  • {lineage}_pval - calculated p-values for double-sided test.

  • {lineage}_qval - corrected p-values using Benjamini-Hochberg method at level 0.05.

  • {lineage}_ci_low - lower bound of the confidence_level correlation confidence interval.

  • {lineage}_ci_high - upper bound of the confidence_level correlation confidence interval.

params#

CFLARE.params#

Estimator parameters.

priming_degree#

CFLARE.priming_degree#

Priming degree.

Given a cell \(i\) and a set of terminal states, this quantifies how committed vs. naive cell \(i\) is, i.e. its degree of pluripotency. Low values correspond to naive cells (high degree of pluripotency), high values correspond to committed cells (low degree of pluripotency).

shape#

CFLARE.shape#

Shape of the kernel.

terminal_states#

CFLARE.terminal_states#

Categorical annotation of terminal states.

By default, all transient cells will be labeled as NaN.

terminal_states_probabilities#

CFLARE.terminal_states_probabilities#

Probability to be a terminal state.

transition_matrix#

CFLARE.transition_matrix#

Transition matrix of kernel.

Methods#

compute_absorption_probabilities#

CFLARE.compute_absorption_probabilities(keys=None, solver='gmres', use_petsc=True, n_jobs=None, backend='loky', show_progress_bar=True, tol=1e-06, preconditioner=None)#

Compute absorption probabilities.

For each cell, this computes the probability of being absorbed in any of the terminal_states. In particular, this corresponds to the probability that a random walk initialized in transient cell \(i\) will reach any cell from a fixed transient state before reaching a cell from any other transient state.

Parameters:

  • keys (Optional[Sequence[str]]) – Terminal states for which to compute the absorption probabilities. If None, use all states defined in terminal_states.

  • solver (Union[str, Literal['direct', 'gmres', 'lgmres', 'bicgstab', 'gcrotmk']]) –

    Solver to use for the linear problem. Options are ‘direct’, ‘gmres’, ‘lgmres’, ‘bicgstab’ or ‘gcrotmk’ when use_petsc = False or one of petsc4py.PETSc.KPS.Type otherwise.

    Information on the scipy iterative solvers can be found in scipy.sparse.linalg() or for petsc4py solver here.

  • use_petsc (bool) – Whether to use solvers from petsc4py or scipy. Recommended for large problems. If no installation is found, defaults to scipy.sparse.linalg.gmres().

  • n_jobs (Optional[int]) – Number of parallel jobs to use when using an iterative solver.

  • backend (Literal['loky', 'multiprocessing', 'threading']) – Which backend to use for multiprocessing. See joblib.Parallel for valid options.

  • show_progress_bar (bool) – Whether to show progress bar. Only used when solver != 'direct'.

  • tol (float) – Convergence tolerance for the iterative solver. The default is fine for most cases, only consider decreasing this for severely ill-conditioned matrices.

  • preconditioner (Optional[str]) – Preconditioner to use, only available when use_petsc = True. For valid options, see here. We recommend the ‘ilu’ preconditioner for badly conditioned problems.

Return type:

None

Returns:

: Nothing, just updates the following field:

compute_absorption_times#

CFLARE.compute_absorption_times(keys=None, calculate_variance=False, solver='gmres', use_petsc=True, n_jobs=None, backend='loky', show_progress_bar=None, tol=1e-06, preconditioner=None)#

Compute the mean time to absorption and optionally its variance.

Parameters:

  • keys (Optional[Sequence[str]]) – Terminal states for which to compute the absorption probabilities. If None, use all states defined in terminal_states.

  • calculate_variance (bool) – Whether to calculate the variance.

  • solver (Union[str, Literal['direct', 'gmres', 'lgmres', 'bicgstab', 'gcrotmk']]) –

    Solver to use for the linear problem. Options are ‘direct’, ‘gmres’, ‘lgmres’, ‘bicgstab’ or ‘gcrotmk’ when use_petsc = False or one of petsc4py.PETSc.KPS.Type otherwise.

    Information on the scipy iterative solvers can be found in scipy.sparse.linalg() or for petsc4py solver here.

  • use_petsc (bool) – Whether to use solvers from petsc4py or scipy. Recommended for large problems. If no installation is found, defaults to scipy.sparse.linalg.gmres().

  • n_jobs (Optional[int]) – Number of parallel jobs to use when using an iterative solver.

  • backend (Literal['loky', 'multiprocessing', 'threading']) – Which backend to use for multiprocessing. See joblib.Parallel for valid options.

  • show_progress_bar (Optional[bool]) – Whether to show progress bar. Only used when solver != 'direct'.

  • tol (float) – Convergence tolerance for the iterative solver. The default is fine for most cases, only consider decreasing this for severely ill-conditioned matrices.

  • preconditioner (Optional[str]) – Preconditioner to use, only available when use_petsc = True. For valid options, see here. We recommend the ‘ilu’ preconditioner for badly conditioned problems.

Return type:

None

Returns:

: Nothing, just updates the following field:

compute_eigendecomposition#

CFLARE.compute_eigendecomposition(k=20, which='LR', alpha=1.0, only_evals=False, ncv=None)#

Compute eigendecomposition of transition_matrix.

Uses a sparse implementation, if possible, and only computes the top \(k\) eigenvectors to speed up the computation. Computes both left and right eigenvectors.

Parameters:

  • k (int) – Number of eigenvectors or eigenvalues to compute.

  • which (Literal['LR', 'LM']) –

    How to sort the eigenvalues. Valid option are:

    • ’LR’ - the largest real part.

    • ’LM’ - the largest magnitude.

  • alpha (float) – Used to compute the eigengap. alpha is the weight given to the deviation of an eigenvalue from one.

  • only_evals (bool) – Whether to compute only eigenvalues.

  • ncv (Optional[int]) – Number of Lanczos vectors generated.

Return type:

EigenMixin

Returns:

: Self and updates the following field:

compute_lineage_drivers#

CFLARE.compute_lineage_drivers(lineages=None, method=TestMethod.FISHER, cluster_key=None, clusters=None, layer=None, use_raw=False, confidence_level=0.95, n_perms=1000, seed=None, **kwargs)#

Compute driver genes per lineage.

Correlates gene expression with lineage probabilities, for a given lineage and set of clusters. Often, it makes sense to restrict this to a set of clusters which are relevant for the specified lineages.

Parameters:

  • lineages (Union[str, Sequence, None]) – Lineage names from absorption_probabilities. If None, use all lineages.

  • method (Literal['fisher', 'perm_test']) –

    Mode to use when calculating p-values and confidence intervals. Valid options are:

    • ’fisher’ - use Fisher transformation [Fisher, 1921].

    • ’perm_test’ - use permutation test.

  • cluster_key (Optional[str]) – Key from anndata.AnnData.obs to obtain cluster annotations. These are considered for clusters.

  • clusters (Union[str, Sequence, None]) – Restrict the correlations to these clusters.

  • layer (Optional[str]) – Key from anndata.AnnData.layers from which to get the expression. If None or ‘X’, use anndata.AnnData.X.

  • use_raw (bool) – Whether or not to use anndata.AnnData.raw to correlate gene expression.

  • confidence_level (float) – Confidence level for the confidence interval calculation. Must be in interval [0, 1].

  • n_perms (int) – Number of permutations to use when method = 'perm_test'.

  • seed (Optional[int]) – Random seed when method = 'perm_test'.

  • show_progress_bar – Whether to show a progress bar. Disabling it may slightly improve performance.

  • n_jobs – Number of parallel jobs. If -1, use all available cores. If None or 1, the execution is sequential.

  • backend – Which backend to use for parallelization. See joblib.Parallel for valid options.

Return type:

DataFrame

Returns:

: Dataframe of shape (n_genes, n_lineages * 5) containing the following columns, one for each lineage:

  • {lineage}_corr - correlation between the gene expression and absorption probabilities.

  • {lineage}_pval - calculated p-values for double-sided test.

  • {lineage}_qval - corrected p-values using Benjamini-Hochberg method at level 0.05.

  • {lineage}_ci_low - lower bound of the confidence_level correlation confidence interval.

  • {lineage}_ci_high - upper bound of the confidence_level correlation confidence interval.

Also updates the following field:

compute_lineage_priming#

CFLARE.compute_lineage_priming(method='kl_divergence', early_cells=None)#

Compute the degree of lineage priming.

It returns a score in [0, 1] where 0 stands for naive and 1 stands for committed.

Parameters:

  • method (Literal['kl_divergence', 'entropy']) –

    The method used to compute the degree of lineage priming. Valid options are:

    • ’kl_divergence’ - as in [Velten et al., 2017], computes KL-divergence between the fate probabilities of a cell and the average fate probabilities. Computation of average fate probabilities can be restricted to a set of user-defined early_cells.

    • ’entropy’ - as in [Setty et al., 2019], computes entropy over a cell’s fate probabilities.

  • early_cells (Union[Mapping[str, Sequence[str]], Sequence[str], None]) – Cell IDs or a mask marking early cells. If None, use all cells. Only used when method = 'kl_divergence'. If a dict, the key specifies a cluster key in anndata.AnnData.obs and the values specify cluster labels containing early cells.

Return type:

Series

Returns:

: The priming degree.

Also updates the following field:

copy#

CFLARE.copy(*, deep=False)#

Return a copy of self.

Parameters:

deep (bool) – Whether to return a deep copy or not. If True, this also copies the adata.

Return type:

BaseEstimator

Returns:

: A copy of self.

fit#

CFLARE.fit(k=20, **kwargs)[source]#

Prepare self for terminal states prediction.

Parameters:
Return type:

TermStatesEstimator

Returns:

: Returns self and modifies the following field:

from_adata#

classmethod CFLARE.from_adata(adata, obsp_key)#

De-serialize self from anndata.AnnData.

Parameters:
Return type:

BaseEstimator

Returns:

: The de-serialized object.

plot_absorption_probabilities#

CFLARE.plot_absorption_probabilities(states=None, color=None, mode=PlotMode.EMBEDDING, time_key='latent_time', same_plot=True, title=None, cmap='viridis', **kwargs)#

Plot absorption probabilities.

Parameters:
Return type:

None

Returns:

: Nothing, just plots the figure. Optionally saves it based on save.

plot_lineage_drivers#

CFLARE.plot_lineage_drivers(lineage, n_genes=8, use_raw=False, ascending=False, ncols=None, title_fmt='{gene} qval={qval:.4e}', figsize=None, dpi=None, save=None, **kwargs)#

Plot lineage drivers discovered by compute_lineage_drivers().

Parameters:

  • lineage (str) – Lineage for which to plot the driver genes.

  • n_genes (int) – Top most correlated genes to plot.

  • use_raw (bool) – Whether to access in anndata.AnnData.raw or not.

  • ascending (bool) – Whether to sort the genes in ascending order.

  • ncols (Optional[int]) – Number of columns.

  • title_fmt (str) – Title format. Can include {gene}, {pval}, {qval} or {corr}, which will be substituted with the actual values.

  • figsize (Optional[Tuple[float, float]]) – Size of the figure.

  • dpi (Optional[int]) – Dots per inch.

  • save (Union[str, Path, None]) – Filename where to save the plot.

  • kwargs (Any) – Keyword arguments for scvelo.pl.scatter().

Return type:

None

Returns:

: Nothing, just plots the figure. Optionally saves it based on save.

plot_lineage_drivers_correlation#

CFLARE.plot_lineage_drivers_correlation(lineage_x, lineage_y, color=None, gene_sets=None, gene_sets_colors=None, use_raw=False, cmap='RdYlBu_r', fontsize=12, adjust_text=False, legend_loc='best', figsize=(4, 4), dpi=None, save=None, show=True, **kwargs)#

Show scatter plot of gene-correlations between two lineages.

Optionally, you can pass a dict of gene names that will be annotated in the plot.

Parameters:

  • lineage_x (str) – Name of the lineage on the x-axis.

  • lineage_y (str) – Name of the lineage on the y-axis.

  • color (Optional[str]) – Key in anndata.AnnData.var or anndata.AnnData.varm, preferring for the former.

  • gene_sets (Optional[Dict[str, Sequence[str]]]) – Gene sets annotations of the form {‘gene_set_name’: [‘gene_1’, ‘gene_2’], …}.

  • gene_sets_colors (Optional[Sequence[str]]) – List of colors where each entry corresponds to a gene set from genes_sets. If None and keys in gene_sets correspond to lineage names, use the lineage colors. Otherwise, use default colors.

  • use_raw (bool) – Whether to access anndata.AnnData.raw or not.

  • cmap (str) – Colormap to use.

  • fontsize (int) – Size of the text when plotting gene_sets.

  • adjust_text (bool) – Whether to automatically adjust text in order to reduce overlap.

  • legend_loc (Optional[str]) – Position of the legend. If None, don’t show the legend. Only used when gene_sets != None.

  • figsize (Optional[Tuple[float, float]]) – Size of the figure.

  • dpi (Optional[int]) – Dots per inch.

  • save (Union[str, Path, None]) – Filename where to save the plot.

  • show (bool) – If False, return matplotlib.pyplot.Axes.

  • kwargs (Any) – Keyword arguments for scanpy.pl.scatter().

Return type:

Optional[Axes]

Returns:

: The axes object, if show = False. Nothing, just plots the figure. Optionally saves it based on save.

Notes

This plot is based on the following notebook by Maren Büttner.

plot_macrostates#

CFLARE.plot_macrostates(which, states=None, color=None, discrete=True, mode=PlotMode.EMBEDDING, time_key='latent_time', same_plot=True, title=None, cmap='viridis', **kwargs)#

Plot macrostates on an embedding or along pseudotime.

Parameters:

  • which (Literal['all', 'initial', 'terminal']) –

    Which macrostates to plot. Valid options are:

  • states (Union[str, Sequence[str], None]) – Subset of the macrostates to show. If obj:None, plot all macrostates.

  • color (Optional[str]) – Key in anndata.AnnData.obs or anndata.AnnData.var used to color the observations.

  • discrete (bool) – Whether to plot the data as continuous or discrete observations. If the data cannot be plotted as continuous observations, it will be plotted as discrete.

  • time_key (str) – Key in anndata.AnnData.obs where pseudotime is stored. Only used when mode = 'time'.

  • title (Union[str, Sequence[str], None]) – Title of the plot.

  • same_plot (bool) – Whether to plot the data on the same plot or not. Only use when mode = 'embedding'. If True and discrete = False, color is ignored.

  • cmap (str) – Colormap for continuous annotations.

  • kwargs (Any) – Keyword arguments for scvelo.pl.scatter().

Return type:

None

Returns:

: Nothing, just plots the figure. Optionally saves it based on save.

plot_spectrum#

CFLARE.plot_spectrum(n=None, real_only=None, show_eigengap=True, show_all_xticks=True, legend_loc=None, title=None, marker='.', figsize=(5, 5), dpi=100, save=None, **kwargs)#

Plot the top eigenvalues in real or complex plane.

Parameters:

  • n (Optional[int]) – Number of eigenvalues to show. If None, show all that have been computed.

  • real_only (Optional[bool]) – Whether to plot only the real part of the spectrum. If None, plot real spectrum if no complex eigenvalues are present.

  • show_eigengap (bool) – When real_only = True, this determines whether to show the inferred eigengap as a dotted line.

  • show_all_xticks (bool) – When real_only = True, this determines whether to show the indices of all eigenvalues on the x-axis.

  • legend_loc (Optional[str]) – Location parameter for the legend.

  • title (Optional[str]) – Title of the figure.

  • marker (str) – Marker symbol used, valid options can be found in matplotlib.markers.

  • figsize (Optional[Tuple[float, float]]) – Size of the figure.

  • dpi (int) – Dots per inch.

  • save (Union[str, Path, None]) – Filename where to save the plot.

  • kwargs (Any) – Keyword arguments for matplotlib.pyplot.scatter().

Return type:

None

Returns:

: Nothing, just plots the figure. Optionally saves it based on save.

predict#

CFLARE.predict(use=None, percentile=98, method='leiden', cluster_key=None, n_clusters_kmeans=None, n_neighbors=20, resolution=0.1, n_matches_min=0, n_neighbors_filtering=15, basis=None, n_comps=5, scale=None)[source]#

Find approximate recurrent classes of the Markov chain.

Filter to obtain recurrent states from left eigenvectors. Cluster to obtain approximate recurrent classes from right eigenvectors.

Parameters:

  • use (Union[int, Sequence[int], None]) – Which or how many first eigenvectors to use as features for filtering and clustering. If None, use the eigengap statistic.

  • percentile (Optional[int]) – Threshold used for filtering out cells which are most likely transient states. Cells which are in the lower percentile percent of each eigenvector will be removed from the data matrix.

  • method (Literal['leiden', 'kmeans']) –

    Method to be used for clustering. Valid option are:

  • cluster_key (Optional[str]) – Key in anndata.AnnData.obs in order to associate names and colors with terminal_states.

  • n_clusters_kmeans (Optional[int]) – If None, this is set to use + 1.

  • n_neighbors (int) – Number of neighbors in a kNN graph. This is the \(K\) parameter for that, the number of neighbors for each cell. Only used when method = 'leiden'.

  • resolution (float) – Resolution parameter for scanpy.tl.leiden(). Should be chosen relatively small.

  • n_matches_min (int) – Filters out cells which don’t have at least n_matches_min neighbors from the same category. This filters out some cells which are transient but have been misassigned.

  • n_neighbors_filtering (int) – Parameter for filtering cells. Cells are filtered out if they don’t have at least n_matches_min neighbors among their n_neighbors_filtering nearest cells.

  • basis (Optional[str]) – Key from anndata.AnnData.obsm as additional features for clustering. If None, use only the right eigenvectors.

  • n_comps (int) – Number of embedding components to be use when basis != None.

  • scale (Optional[bool]) – Scale the values to z-scores. If None, scale the values if basis != None.

Return type:

CFLARE

Returns:

: Returns self and just updates the following fields:

read#

static CFLARE.read(fname, adata=None, copy=False)#

De-serialize self from a file.

Parameters:

  • fname (Union[str, Path]) – Filename from which to read the object.

  • adata (Optional[AnnData]) – anndata.AnnData object to assign to the saved object. Only used when the saved object has adata and it was saved without it.

  • copy (bool) – Whether to copy adata before assigning it or not. If adata is a view, it is always copied.

Return type:

IOMixin

Returns:

: The de-serialized object.

rename_initial_states#

CFLARE.rename_initial_states(old_new)#

Rename initial_states.

Parameters:

old_new (Dict[str, str]) – Dictionary that maps old names to unique new names.

Return type:

TermStatesEstimator

Returns:

: Returns self and updates the following field:

rename_terminal_states#

CFLARE.rename_terminal_states(old_new)#

Rename terminal_states.

Parameters:

old_new (Dict[str, str]) – Dictionary that maps old names to unique new names.

Return type:

TermStatesEstimator

Returns:

: Returns self and updates the following field:

set_initial_states#

CFLARE.set_initial_states(states, cluster_key=None, allow_overlap=False, **kwargs)#

Set initial_states.

Parameters:

  • states (Union[Series, Dict[str, Sequence[Any]]]) –

    Which states to select. Valid options are:

    • categorical Series where each category corresponds to an individual state. NaN entries denote cells that do not belong to any state, i.e., transient cells.

    • dict where keys are states and values are lists of cell barcodes corresponding to annotations in anndata.AnnData.obs_names. If only 1 key is provided, values should correspond to clusters if a categorical Series can be found in anndata.AnnData.obs.

  • cluster_key (Optional[str]) – Key in anndata.AnnData.obs to associate names and colors initial_states. Each state will be given the name and color corresponding to the cluster it mostly overlaps with.

  • allow_overlap (bool) – Whether to allow overlapping names between initial and terminal states.

  • kwargs (Any) – Additional keyword arguments.

Return type:

TermStatesEstimator

Returns:

: Returns self and updates the following fields:

set_terminal_states#

CFLARE.set_terminal_states(states, cluster_key=None, allow_overlap=False, **kwargs)#

Set terminal_states.

Parameters:

  • states (Union[Series, Dict[str, Sequence[Any]]]) –

    States to select. Valid options are:

    • categorical Series where each category corresponds to an individual state. NaN entries denote cells that do not belong to any state, i.e., transient cells.

    • dict where keys are states and values are lists of cell barcodes corresponding to annotations in anndata.AnnData.obs_names. If only 1 key is provided, values should correspond to clusters if a categorical Series can be found in anndata.AnnData.obs.

  • cluster_key (Optional[str]) – Key in anndata.AnnData.obs to associate names and colors with terminal_states. Each state will be given the name and color corresponding to the cluster it mostly overlaps with.

  • allow_overlap (bool) – Whether to allow overlapping names between initial and terminal states.

  • kwargs (Any) – Additional keyword arguments.

Return type:

TermStatesEstimator

Returns:

: Returns self and updates the following fields:

to_adata#

CFLARE.to_adata(keep=('X', 'raw'), *, copy=True)#

Serialize self to anndata.Anndata.

Parameters:

  • keep (Union[Literal['all'], Sequence[Literal['X', 'raw', 'layers', 'obs', 'var', 'obsm', 'varm', 'obsp', 'varp', 'uns']]]) –

    Which attributes to keep from the underlying adata. Valid options are:

    • ’all’ - keep all attributes specified in the signature.

    • typing.Sequence - keep only subset of these attributes.

    • dict - the keys correspond the attribute names and values to a subset of keys which to keep from this attribute. If the values are specified either as True or ‘all’, everything from this attribute will be kept.

  • copy (Union[bool, Sequence[Literal['X', 'raw', 'layers', 'obs', 'var', 'obsm', 'varm', 'obsp', 'varp', 'uns']]]) – Whether to copy the data. Can be specified on per-attribute basis. Useful for attributes that are array-like.

Return type:

AnnData

Returns:

: Annotated data object.

write#

CFLARE.write(fname, write_adata=True, ext='pickle')#

Serialize self to a file.

Parameters:

  • fname (Union[str, Path]) – Filename where to save the object.

  • write_adata (bool) – Whether to save adata object or not, if present.

  • ext (Optional[str]) – Filename extension to use. If None, don’t append any extension.

Return type:

None

Returns:

: Nothing, just writes itself to a file using pickle.