cellrank.kernels.PseudotimeKernel#

class cellrank.kernels.PseudotimeKernel(adata, time_key, backward=False, **kwargs)[source]#

Kernel which computes directed transition probabilities based on a k-NN graph and pseudotime.

See also

The k-NN graph contains information about the (undirected) connectivities among cells, reflecting their similarity. Pseudotime can be used to either remove edges that point against the direction of increasing pseudotime [Setty et al., 2019] or to down-weight them [Stassen et al., 2021].

Parameters
  • adata (AnnData) – Annotated data object.

  • backward (bool) – Direction of the process. If True, the pseudotime will be set to max(pseudotime) - pseudotime.

  • time_key (str) – Key in obs where the pseudotime is stored.

  • kwargs (Any) – Keyword arguments for the ConnectivityKernel.

Attributes table#

adata

Annotated data object.

backward

Direction of the process.

connectivities

Underlying connectivity matrix.

kernels

Underlying base kernels.

params

Parameters which are used to compute the transition matrix.

pseudotime

Pseudotemporal ordering of cells.

shape

(n_cells, n_cells).

transition_matrix

Row-normalized transition matrix.

Methods table#

compute_transition_matrix([...])

Compute transition matrix based on k-NN graph and pseudotemporal ordering.

copy(*[, deep])

Return a copy of self.

from_adata(adata, key[, copy])

Read the kernel saved using write_to_adata().

plot_projection([basis, key_added, ...])

Plot transition_matrix as a stream or a grid plot.

plot_random_walks([n_sims, max_iter, seed, ...])

Plot random walks in an embedding.

plot_single_flow(cluster, cluster_key, time_key)

Visualize outgoing flow from a cluster of cells [Mittnenzweig et al., 2021].

read(fname[, adata, copy])

De-serialize self from a file.

write(fname[, write_adata])

Serialize self to a file using pickle.

write_to_adata([key, copy])

Write the transition matrix and parameters used for computation to the underlying adata object.

Attributes#

adata#

PseudotimeKernel.adata#

Annotated data object.

backward#

PseudotimeKernel.backward#

Direction of the process.

connectivities#

PseudotimeKernel.connectivities#

Underlying connectivity matrix.

kernels#

PseudotimeKernel.kernels#

Underlying base kernels.

params#

PseudotimeKernel.params#

Parameters which are used to compute the transition matrix.

pseudotime#

PseudotimeKernel.pseudotime#

Pseudotemporal ordering of cells.

shape#

PseudotimeKernel.shape#

(n_cells, n_cells).

transition_matrix#

PseudotimeKernel.transition_matrix#

Row-normalized transition matrix.

Methods#

compute_transition_matrix#

PseudotimeKernel.compute_transition_matrix(threshold_scheme='hard', frac_to_keep=0.3, b=10.0, nu=0.5, check_irreducibility=False, n_jobs=None, backend='loky', show_progress_bar=True, **kwargs)[source]#

Compute transition matrix based on k-NN graph and pseudotemporal ordering.

Depending on the choice of the threshold_scheme, it is based on ideas by either Palantir [Setty et al., 2019] or VIA [Stassen et al., 2021].

Parameters
  • threshold_scheme (Union[Literal['soft', 'hard'], Callable[[float, ndarray, ndarray], ndarray]]) –

    Which method to use when biasing the graph. Valid options are:

    • 'hard' - based on Palantir [Setty et al., 2019] which removes some edges that point against the direction of increasing pseudotime. To avoid disconnecting the graph, it does not remove all edges that point against the direction of increasing pseudotime, but keeps the ones that point to cells inside a close radius. This radius is chosen according to the local cell density.

    • 'soft' - based on VIA [Stassen et al., 2021] which down-weights edges that points against the direction of increasing pseudotime. Essentially, the further “behind” a query cell is in pseudotime with respect to the current reference cell, the more penalized will be its graph-connectivity.

    • callable - any function conforming to the signature of cellrank.kernels.utils.ThresholdSchemeABC.__call__().

  • frac_to_keep (float) – Fraction of the closest neighbors (according to graph connectivities) are kept, no matter whether they lie in the pseudotemporal past or future. This is done to ensure that the graph remains connected. Only used when threshold_scheme = 'hard'. Must be in \([0, 1]\).

  • b (float) – The growth rate of generalized logistic function. Only used when threshold_scheme = 'soft'.

  • nu (float) – Affects near which asymptote maximum growth occurs. Only used when threshold_scheme = 'soft'.

  • check_irreducibility (bool) – Optional check for irreducibility of the final transition matrix.

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

  • n_jobs (Optional[int]) – Number of parallel jobs. If -1, use all available cores. If None or 1, the execution is sequential.

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

  • kwargs (Any) – Keyword arguments for threshold_scheme.

Return type

PseudotimeKernel

Returns

: Returns self and updates transition_matrix and params.

copy#

PseudotimeKernel.copy(*, deep=False)#

Return a copy of self.

Parameters

deep (bool) – Whether to use deepcopy().

Return type

Kernel

Returns

: Copy of self.

from_adata#

classmethod PseudotimeKernel.from_adata(adata, key, copy=False)#

Read the kernel saved using write_to_adata().

Parameters
  • adata (AnnData) – Annotated data object.

  • key (str) – Key in obsp where the transition matrix is stored. The parameters should be stored in adata.uns['{key}_params'].

  • copy (bool) – Whether to copy the transition matrix.

Return type

Kernel

Returns

: The kernel with explicitly initialized properties:

plot_projection#

PseudotimeKernel.plot_projection(basis='umap', key_added=None, recompute=False, stream=True, connectivities=None, **kwargs)#

Plot transition_matrix as a stream or a grid plot.

Parameters
Return type

None

Returns

: Nothing, just plots and modifies obsm with a key based on the key_added.

plot_random_walks#

PseudotimeKernel.plot_random_walks(n_sims=100, max_iter=0.25, seed=None, successive_hits=0, start_ixs=None, stop_ixs=None, basis='umap', cmap='gnuplot', linewidth=1.0, linealpha=0.3, ixs_legend_loc=None, n_jobs=None, backend='loky', show_progress_bar=True, figsize=None, dpi=None, save=None, **kwargs)#

Plot random walks in an embedding.

This method simulates random walks on the Markov chain defined though the corresponding transition matrix. The method is intended to give qualitative rather than quantitative insights into the transition matrix. Random walks are simulated by iteratively choosing the next cell based on the current cell’s transition probabilities.

Parameters
  • n_sims (int) – Number of random walks to simulate.

  • max_iter (Union[int, float]) – Maximum number of steps of a random walk. If a float, it can be specified as a fraction of the number of cells.

  • seed (Optional[int]) – Random seed.

  • successive_hits (int) – Number of successive hits in the stop_ixs required to stop prematurely.

  • start_ixs (Union[Sequence[str], Mapping[str, Union[str, Sequence[str], Tuple[float, float]]], None]) –

    Cells from which to sample the starting points. If None, use all cells. Can be specified as:

    • dict - dictionary with 1 key in obs with values corresponding to either 1 or more clusters (if the column is categorical) or a tuple specifying \([min, max]\) interval from which to select the indices.

    • Sequence - sequence of cell ids in obs_names.

    For example {'dpt_pseudotime': [0, 0.1]} means that starting points for random walks will be sampled uniformly from cells whose pseudotime is in \([0, 0.1]\).

  • stop_ixs (Union[Sequence[str], Mapping[str, Union[str, Sequence[str], Tuple[float, float]]], None]) –

    Cells which when hit, the random walk is terminated. If None, terminate after max_iters. Can be specified as:

    • dict - dictionary with 1 key in obs with values corresponding to either 1 or more clusters (if the column is categorical) or a tuple specifying \([min, max]\) interval from which to select the indices.

    • Sequence - sequence of cell ids in obs_names.

    For example {'clusters': ['Alpha', 'Beta']} and successive_hits = 3 means that the random walk will stop prematurely after cells in the above specified clusters have been visited successively 3 times in a row.

  • basis (str) – Basis in obsm to use as an embedding.

  • cmap (Union[str, LinearSegmentedColormap]) – Colormap for the random walk lines.

  • linewidth (float) – Width of the random walk lines.

  • linealpha (float) – Alpha value of the random walk lines.

  • ixs_legend_loc (Optional[str]) – Legend location for the start/top indices.

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

  • n_jobs (Optional[int]) – Number of parallel jobs. If -1, use all available cores. If None or 1, the execution is sequential.

  • backend (str) – Which backend to use for parallelization. See Parallel for valid options.

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

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

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

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

Return type

None

Returns

: Nothing, just plots the figure. Optionally saves it based on save. For each random walk, the first/last cell is marked by the start/end colors of cmap.

plot_single_flow#

PseudotimeKernel.plot_single_flow(cluster, cluster_key, time_key, clusters=None, time_points=None, min_flow=0, remove_empty_clusters=True, ascending=False, legend_loc='upper right out', alpha=0.8, xticks_step_size=1, figsize=None, dpi=None, save=None, show=True)#

Visualize outgoing flow from a cluster of cells [Mittnenzweig et al., 2021].

Parameters
  • cluster (str) – Cluster for which to visualize outgoing flow.

  • cluster_key (str) – Key in obs where clustering is stored.

  • time_key (str) – Key in obs where experimental time is stored.

  • clusters (Optional[Sequence[Any]]) – Visualize flow only for these clusters. If None, use all clusters.

  • time_points (Optional[Sequence[Union[float, int]]]) – Visualize flow only for these time points. If None, use all time points.

  • min_flow (float) – Only show flow edges with flow greater than this value. Flow values are always in \([0, 1]\).

  • remove_empty_clusters (bool) – Whether to remove clusters with no incoming flow edges.

  • ascending (Optional[bool]) – Whether to sort the cluster by ascending or descending incoming flow. If None, use the order as in defined by clusters.

  • alpha (Optional[float]) – Alpha value for cell proportions.

  • xticks_step_size (Optional[int]) – Show only every other n-th tick on the x-axis. If None, don’t show any ticks.

  • legend_loc (Optional[str]) – Position of the legend. If None, do not show the legend.

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

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

  • figsize – Size of the figure.

  • dpi – Dots per inch.

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

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

Return type

Optional[Axes]

Returns

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

Notes

This function is a Python re-implementation of the following original R function with some minor stylistic differences. This function will not recreate the results from [Mittnenzweig et al., 2021], because there, the Metacell model [Baran et al., 2019] was used to compute the flow, whereas here the transition matrix is used.

read#

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

De-serialize self from a file.

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

  • adata (Optional[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. If adata is a view, it is always copied.

Return type

IOMixin

Returns

: The de-serialized object.

write#

PseudotimeKernel.write(fname, write_adata=True)#

Serialize self to a file using pickle.

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

  • write_adata (bool) – Whether to save adata object.

Return type

None

Returns

: Nothing, just writes itself to a file.

write_to_adata#

PseudotimeKernel.write_to_adata(key=None, copy=False)#

Write the transition matrix and parameters used for computation to the underlying adata object.

Parameters
Return type

None

Returns

: Updates the adata with the following fields: