sclab 0.1.7__py3-none-any.whl → 0.3.4__py3-none-any.whl

sclab/tools/cellflow/utils/interpolate.py

@@ -0,0 +1,334 @@
+import logging
+from typing import Callable
+
+import numpy as np
+from numpy import asarray, ascontiguousarray, floating, prod
+from numpy import empty as np_empty
+from numpy import float64 as np_float64
+from numpy.typing import NDArray
+from scipy.fft import fft, fftfreq
+from scipy.interpolate import BSpline, _fitpack_impl, make_smoothing_spline
+from tqdm.auto import tqdm
+
+from .smoothen import choose_grid_size, count_data_in_intervals, smoothen_data
+
+try:
+    from scipy.interpolate._dierckx import evaluate_spline
+except ImportError:
+    from scipy.interpolate._bspl import evaluate_spline
+
+
+logger = logging.getLogger(__name__)
+PIX2 = 2 * np.pi
+
+
+def fit_smoothing_spline(
+    x: NDArray[floating],
+    y: NDArray[floating],
+    t_range: tuple[float, float],
+    w: NDArray[floating] | None = None,
+    lam: float | None = None,
+    periodic: bool = False,
+    n_reps: int = 3,
+) -> BSpline:
+    if periodic:
+        assert n_reps % 2 == 1
+
+    o = np.argsort(x)
+    x, y = x[o], y[o]
+    if w is not None:
+        w = w[o]
+
+    tmin, tmax = t_range
+    tspan = tmax - tmin
+
+    if periodic:
+        mask = np.logical_and((x >= tmin), (x < tmax))
+    else:
+        mask = np.logical_and((x >= tmin), (x <= tmax))
+
+    x, y = x[mask], y[mask]
+    if w is not None:
+        w = w[mask]
+    n = x.size
+
+    if periodic:
+        xx = np.concatenate([x + i * tspan for i in range(n_reps)])
+        yy = np.tile(y, n_reps)
+        ww = np.tile(w, n_reps) if w is not None else None
+    else:
+        xx = x
+        yy = y
+        ww = w
+
+    bspl = make_smoothing_spline(xx, yy, ww, lam)
+    t, c, k = bspl.tck
+
+    if periodic:
+        N = n_reps // 2
+        t = t - tspan * N
+        t = t[n * N : -n * N + 1]
+        c = c[n * N : -n * N + 1]
+
+    return BSpline(t, c, k)
+
+
+class NDFourier:
+    def __init__(
+        self,
+        xh: NDArray[floating] | None = None,
+        freq: NDArray[floating] | None = None,
+        t_range: tuple[float, float] | None = None,
+        grid_size: int | None = None,
+        periodic: bool = True,
+        largest_harmonic: int = 5,
+        d: int = 0,
+        zero_weight: float = 1.0,
+        smoothing_fn: Callable = np.average,
+    ) -> None:
+        assert periodic
+        assert t_range is not None
+        assert t_range[0] == 0
+
+        self.tmin, self.tmax = self.t_range = t_range
+        self.tscale = PIX2 / self.tmax
+
+        if xh is not None:
+            assert freq is not None
+            self.n = grid_size + 1
+            self.xh = xh.reshape((xh.shape[0], -1, 1)).copy()
+            self.freq = freq.reshape((freq.shape[0], -1, 1)).copy()
+            self.scaled_freq = 1j * self.freq * self.tscale
+
+        self.grid_size = grid_size
+        self.periodic = periodic
+        self.largest_harmonic = largest_harmonic
+        self.d = d
+        self.zero_weight = zero_weight
+        self.smoothing_fn = smoothing_fn
+
+    def fit(
+        self,
+        t: NDArray[floating],
+        X: NDArray[floating],
+    ) -> "NDFourier":
+        if self.grid_size is None:
+            self.grid_size = choose_grid_size(t, self.t_range)
+
+        t_grid = np.linspace(*self.t_range, self.grid_size + 1)
+        self.X_smooth = smoothen_data(
+            t,
+            X,
+            t_range=self.t_range,
+            t_grid=t_grid,
+            periodic=self.periodic,
+            zero_weight=self.zero_weight,
+            fn=self.smoothing_fn,
+        )
+
+        self.n = n = self.X_smooth.shape[0]
+        self.X_smooth = self.X_smooth.reshape((n, -1))
+
+        xh: NDArray[floating] = fft(self.X_smooth, axis=0)
+        freq: NDArray[floating] = fftfreq(n, d=1 / n)
+
+        mask = np.abs(freq) <= self.largest_harmonic
+        xh = xh[mask]
+        freq = freq[mask]
+
+        self.xh = xh.reshape((xh.shape[0], -1, 1))
+        self.freq = freq.reshape((freq.shape[0], -1, 1))
+        self.scaled_freq = 1j * self.freq * self.tscale
+
+        return self
+
+    def derivative(self, d=1) -> "NDFourier":
+        return NDFourier(
+            self.xh,
+            self.freq,
+            self.t_range,
+            self.grid_size,
+            self.periodic,
+            self.largest_harmonic,
+            d + self.d,
+        )
+
+    def __getitem__(self, key) -> "NDFourier":
+        return NDFourier(
+            self.xh[:, key],
+            self.freq,
+            self.t_range,
+            self.grid_size,
+            self.periodic,
+            self.largest_harmonic,
+            self.d,
+        )
+
+    def __call__(self, x: NDArray[floating], d=0) -> NDArray[floating]:
+        x = asarray(x)
+        x_shape = x.shape
+
+        x = ascontiguousarray(x.ravel(), dtype=np_float64)
+
+        d = d + self.d
+        out: NDArray[floating] = np.real(
+            (self.xh * self.scaled_freq**d * np.exp(self.scaled_freq * x)).sum(axis=0)
+            / self.n
+        )
+        out = out.T
+        out = out.reshape(x_shape + (self.xh.shape[1],))
+
+        return out
+
+
+class NDBSpline:
+    def __init__(
+        self,
+        t: NDArray[floating] | None = None,
+        C: NDArray[floating] | None = None,
+        k: int | None = None,
+        t_range: tuple[float, float] | None = None,
+        grid_size: int | None = None,
+        periodic: bool = False,
+        roughness: float | None = None,
+        zero_weight: float = 1.0,
+        window_width: float | None = None,
+        use_grid: bool = True,
+        weight_grid: bool = False,
+        smoothing_fn: Callable = np.average,
+    ) -> None:
+        if periodic:
+            assert t_range is not None
+            assert t_range[0] == 0
+
+        if t is not None or C is not None or k is not None:
+            assert t is not None
+            assert C is not None
+            assert k is not None
+            self.t = t.copy()
+            self.C = C.reshape((C.shape[0], -1)).copy()
+            self.k = k
+
+        if t_range is not None:
+            self.tmin, self.tmax = self.t_range = t_range
+
+        self.grid_size = grid_size
+        self.periodic = periodic
+        self.window_width = window_width
+        self.use_grid = use_grid
+        self.weight_grid = weight_grid
+        self.roughness = roughness
+        self.zero_weight = zero_weight
+        self.smoothing_fn = smoothing_fn
+
+    def fit(
+        self,
+        t: NDArray[floating],
+        X: NDArray[floating],
+        progress: bool = False,
+    ) -> "NDBSpline":
+        X = X.reshape((X.shape[0], -1))
+        if self.t_range is None:
+            self.tmin, self.tmax = self.t_range = t.min(), t.max()
+
+        if self.grid_size is None:
+            self.grid_size = choose_grid_size(t, self.t_range)
+
+        if self.roughness is None:
+            self.roughness = 1
+
+        if self.use_grid:
+            t_grid: NDArray[floating] = np.linspace(*self.t_range, self.grid_size + 1)
+            self.lam = 1 / self.grid_size / 10**self.roughness
+        else:
+            t_grid = None
+            self.lam = 1 / 10**self.roughness
+        self.X_smooth = smoothen_data(
+            t,
+            X,
+            t_range=self.t_range,
+            t_grid=t_grid,
+            periodic=self.periodic,
+            window_width=self.window_width,
+            zero_weight=self.zero_weight,
+            progress=progress,
+            fn=self.smoothing_fn,
+        )
+
+        if t_grid is not None and self.weight_grid:
+            w = np.zeros(self.X_smooth.shape[0], dtype=float)
+            n = count_data_in_intervals(t, t_grid) + 1
+            if self.periodic:
+                n = np.append(n, n[0])
+            else:
+                n = np.append(n, n[-1])
+            w[n > 1] = 1 / np.log1p(n[n > 1])
+        else:
+            w = None
+
+        iterator = self.X_smooth.T
+        if progress:
+            iterator = tqdm(
+                iterator,
+                bar_format="{desc} {percentage:3.0f}%|{bar}|",
+                desc="Fitting bsplines",
+            )
+
+        fit_t_range = (0, 1)
+        fit_t_grid = np.linspace(0, 1, self.grid_size + 1)
+        fit_t = (t - self.tmin) / (self.tmax - self.tmin)
+        C = []
+        for x in iterator:
+            f = fit_smoothing_spline(
+                fit_t_grid if self.use_grid else fit_t,
+                x,
+                t_range=fit_t_range,
+                w=w,
+                lam=self.lam,
+                periodic=self.periodic,
+            )
+
+            C.append(f.c)
+
+        self.t = f.t.copy()
+        self.t *= self.tmax - self.tmin
+        self.t += self.tmin
+        self.C = np.array(C).T.copy()
+        self.k = 3
+
+        return self
+
+    def derivative(self, d: int = 1) -> "NDBSpline":
+        # pad the c array if needed
+        ct = len(self.t) - len(self.C)
+        if ct > 0:
+            self.C = np.r_[self.C, np.zeros((ct, self.C.shape[1]))]
+        t, C, k = _fitpack_impl.splder((self.t, self.C, self.k), d)
+        return NDBSpline(t, C, k, self.t_range, self.grid_size, self.periodic)
+
+    def __getitem__(self, key) -> "NDBSpline":
+        t = self.t
+        C = self.C[:, key]
+        k = self.k
+        return NDBSpline(t, C, k, self.t_range, self.grid_size, self.periodic)
+
+    def __call__(self, x: NDArray[floating], d: int = 0) -> NDArray[floating]:
+        x = asarray(x)
+        x_shape = x.shape
+
+        x = ascontiguousarray(x.ravel(), dtype=np_float64)
+        if self.periodic:
+            n = self.t.size - self.k - 1
+            x = self.t[self.k] + (x - self.t[self.k]) % (self.t[n] - self.t[self.k])
+
+        out = np_empty((len(x), prod(self.C.shape[1:])), dtype=self.C.dtype)
+
+        if not self.t.flags.c_contiguous:
+            self.t = self.t.copy()
+        if not self.C.flags.c_contiguous:
+            self.C = self.C.copy()
+
+        evaluate_spline(self.t, self.C, self.k, x, d, False, out)
+        out = out.reshape(x_shape + (self.C.shape[1],))
+
+        return out

sclab/tools/cellflow/utils/periodic_genes.py

@@ -0,0 +1,106 @@
+import numpy as np
+import pandas as pd
+from anndata import AnnData
+from numpy.typing import NDArray
+from scipy.signal import get_window, periodogram
+from scipy.sparse import spmatrix
+
+from sclab.tools.utils import aggregate_and_filter
+
+
+def periodic_genes(
+    adata: AnnData,
+    time_key: str,
+    tmin: float,
+    tmax: float,
+    period: float,
+    n: int,
+    min_pct_power_below: float = 0.75,
+    layer: str | None = None,
+):
+    times = adata.obs[time_key].values.copy()
+    if layer is None or layer == "X":
+        X = adata.X
+    else:
+        X = adata.layers[layer]
+
+    _assert_integer_counts(X)
+
+    tmp_adata = AnnData(X, obs=adata.obs[[time_key]], var=adata.var[[]])
+
+    w = (tmax - tmin) / n
+    bins = np.arange(-w / 2 + tmin, tmax, w)
+    labels = list(map(lambda x: f"{x:.2f}", bins[:-1] + w / 2))
+
+    times[times >= bins.max()] = times[times >= bins.max()] - tmax
+    tmp_adata.obs["timepoint"] = pd.cut(times, bins=bins, labels=labels)
+    aggregated = aggregate_and_filter(
+        tmp_adata,
+        "timepoint",
+        replicas_per_group=1,
+        make_stats=False,
+        make_dummies=False,
+    )
+    log_cnts = np.log1p(aggregated.X)
+    profiles = pd.DataFrame(log_cnts, index=labels, columns=aggregated.var_names)
+    ps = power_spectrum_df(profiles)
+    pp = pct_power_below(ps, 1 / period)
+
+    adata.varm["profile"] = profiles.T
+    adata.varm["periodogram"] = ps.T
+    adata.var["pct_power_below"] = pp
+    adata.var["periodic"] = pp > min_pct_power_below
+
+
+def _assert_integer_counts(X: spmatrix | NDArray):
+    message = "Periodic genes requires raw integer counts. E.g. `layer = 'counts'`."
+    if isinstance(X, spmatrix):
+        assert all(X.data % 1 == 0), message
+    else:
+        assert all(X % 1 == 0), message
+
+
+def infer_dt_from_index(idx: pd.Index) -> float:
+    # Works for numeric or datetime indexes
+    if isinstance(idx, pd.DatetimeIndex):
+        dt = np.median(np.diff(idx.view("i8"))) / 1e9  # seconds
+    else:
+        dt = float(np.median(np.diff(idx.values.astype(float))))
+    return dt
+
+
+def power_spectrum_df(X: pd.DataFrame, window: str = "hann", detrend: str = "constant"):
+    # X: rows=timepoints, columns=variables
+    Xd = X - X.mean()  # remove DC so percent computations are stable
+    dt = infer_dt_from_index(X.index) if X.index.size > 1 else 1.0
+    fs = 1.0 / dt
+    win = get_window(window, X.shape[0], fftbins=True)
+
+    # Build a tidy dataframe of periodograms for all columns
+    out = {}
+    for c in Xd.columns:
+        f, Pxx = periodogram(
+            Xd[c].values,
+            fs=fs,
+            window=win,
+            detrend=detrend,
+            scaling="spectrum",  # integrates to variance
+            return_onesided=True,
+        )
+        out[c] = Pxx
+    ps = pd.DataFrame(out, index=pd.Index(f, name="frequency"))
+    return ps  # units: (data units)^2, integrates (sum * df) to variance per column
+
+
+def pct_power_below(ps: pd.DataFrame, max_freq: float) -> pd.Series:
+    # ps is spectrum from power_spectrum_df (one-sided, DC included but we demeaned)
+    # Compute integrals via the rectangle rule: sum * df (df = freq spacing)
+    if len(ps.index) < 2:
+        return pd.Series({c: np.nan for c in ps.columns}, name="pct_power_at_low_freq")
+    df = ps.index[1] - ps.index[0]
+    mask_low = ps.index <= max_freq
+    num: pd.Series = ps.loc[mask_low].sum() * df
+    den: pd.Series = ps.sum() * df
+    s = num / den
+    s.name = "pct_power_at_low_freq"
+    return s

sclab/tools/cellflow/utils/smoothen.py

@@ -0,0 +1,124 @@
+import logging
+from typing import Callable
+
+import numpy as np
+from numpy import bool_, floating, integer
+from numpy.typing import NDArray
+from tqdm.auto import tqdm
+
+logger = logging.getLogger(__name__)
+PIX2 = 2 * np.pi
+
+
+def count_empty_intervals(t: NDArray[floating], t_grid: NDArray[floating]) -> int:
+    n_data_in_intervals = count_data_in_intervals(t, t_grid)
+    empty_intervals_count = np.sum(n_data_in_intervals == 0)
+    return empty_intervals_count
+
+
+def count_data_in_intervals(
+    t: NDArray[floating], t_grid: NDArray[floating]
+) -> NDArray[integer]:
+    t = t.reshape(-1, 1)
+    return np.logical_and(t_grid[:-1] <= t, t <= t_grid[1:]).sum(axis=0)
+
+
+def choose_grid_size(t: NDArray[floating], t_range: tuple[float, float]) -> int:
+    grid_size = 2**10
+    for _ in range(10):
+        t_grid: NDArray[floating] = np.linspace(*t_range, grid_size + 1)
+        empty_intervals = count_empty_intervals(t, t_grid)
+        if empty_intervals == 0:
+            break
+        grid_size //= 2
+    else:
+        raise ValueError("Could not find a suitable grid size")
+
+    return grid_size
+
+
+def smoothen_data(
+    t: NDArray[floating],
+    X: NDArray[floating],
+    t_range: tuple[float, float] | None = None,
+    t_grid: NDArray[floating] | None = None,
+    fn: Callable[[NDArray[floating]], NDArray[floating]] = np.average,
+    window_width: float | None = None,
+    weights: NDArray[floating] | None = None,
+    zero_weight: float = 1,
+    periodic: bool = False,
+    quiet: bool = False,
+    progress: bool = False,
+) -> NDArray[floating]:
+    if t_grid is None:
+        # no grid provided. We will have one output point for each input point
+        t_grid = t
+        is_grid = False
+    else:
+        # grid is provided
+        is_grid = True
+        empty_intervals = count_empty_intervals(t, t_grid)
+        if empty_intervals > 0 and not quiet:
+            logger.warning(f"Provided grid has {empty_intervals} empty intervals")
+
+    if t_range is not None:
+        # we used a specific t values range
+        tmin, tmax = t_range
+    else:
+        tmin, tmax = t_grid.min(), t_grid.max()
+
+    # full time window size
+    tspan = tmax - tmin
+
+    if window_width is None and not is_grid:
+        window_width = tspan * 0.05
+    elif window_width is None and is_grid:
+        window_width = tspan / (t_grid.size - 1) * 2
+
+    # initialize the output matrix with NaNs
+    X_smooth: NDArray[floating] = np.full((t_grid.size,) + X.shape[1:], np.nan)
+
+    generator = enumerate(t_grid)
+    if progress:
+        generator = tqdm(
+            generator,
+            total=t_grid.size,
+            bar_format="{desc} {percentage:3.0f}%|{bar}|",
+            desc="Smoothing data",
+        )
+
+    X = X.astype(float)
+    eps = np.finfo(float).eps
+    for i, m in generator:
+        low = m - window_width / 2
+        hig = m + window_width / 2
+
+        mask: NDArray[bool_] = (t >= low) & (t <= hig)
+        if periodic:
+            # include points beyond the periodic boundaries
+            mask = (
+                mask
+                | (t >= low + tspan) & (t <= hig + tspan)
+                | (t >= low - tspan) & (t <= hig - tspan)
+            )
+
+        if mask.sum() == 0:
+            continue
+
+        x = X[mask] + eps
+        if fn == np.average and weights is not None:
+            w = weights[mask]
+            X_smooth[i] = np.average(x, axis=0, weights=w)
+
+        elif fn == np.average and zero_weight == 1:
+            X_smooth[i] = np.mean(x, axis=0)
+
+        elif fn == np.average and zero_weight != 1:
+            w = np.ones_like(x)
+            w[x == eps] = zero_weight + eps
+            X_smooth[i] = fn(x, axis=0, weights=w)
+
+        else:
+            X_smooth[i] = fn(x, axis=0)
+
+    return X_smooth - eps

sclab/tools/cellflow/utils/times.py

@@ -0,0 +1,55 @@
+import itertools
+
+import numpy as np
+from numpy import floating
+from numpy.typing import NDArray
+
+
+def guess_trange(
+    times: NDArray[floating], verbose: bool = False
+) -> tuple[float, float]:
+    tmin, tmax = times.min(), times.max()
+    tspan = tmax - tmin
+
+    scale = 10.0 ** np.ceil(np.log10(tspan)) / 100
+    tspan = np.ceil(tspan / scale) * scale
+
+    scale = 10.0 ** np.ceil(np.log10(tspan)) / 100
+    g_tmin = np.floor(tmin / scale) * scale
+    g_tmax = np.ceil(tmax / scale) * scale
+
+    g_tmin = 0.0 if g_tmin == -0.0 else g_tmin
+    g_tmax = 0.0 if g_tmax == -0.0 else g_tmax
+
+    if verbose:
+        print(
+            f"tspan: {tspan:10.4f}    min-max: {tmin:10.4f} - {tmax:10.4f} | {g_tmin:>8} - {g_tmax:>8}"
+        )
+
+    return g_tmin, g_tmax
+
+
+def test_guess_trange(N: int = 1000, verbose: bool = False) -> None:
+    def _test1(trange: tuple[float, float]) -> bool:
+        tmin, tmax = trange
+        tspan = tmax - tmin
+        g_tmin, g_tmax = guess_trange(np.random.uniform(*trange, N))
+        err_min = np.abs(g_tmin - tmin) / tspan
+        err_max = np.abs(g_tmax - tmax) / tspan
+        return err_min <= 0.01 and err_max <= 0.01
+
+    scales1 = [0.001, 0.01, 0.1, 1, 10, 100, 1000]
+    scales2 = [1, 2, 3, 5, 7]
+    for s1, s2 in itertools.product(scales1, scales2):
+        scale = s1 * s2
+        for lw, hg in [(-2, -1), (-1 / 2, 1 / 2), (1, 2)]:
+            trange = lw * scale, hg * scale
+            acc1 = np.mean([_test1(trange) for _ in range(500)])
+            if verbose:
+                print(
+                    f"scale: {scale: 9.3f} | lw-hg: {lw: 5.1f} - {hg: 5.1f} | {acc1: 8.2%}"
+                )
+            else:
+                assert acc1 > 0.95, (
+                    f"scale: {scale: 9.3f} | lw-hg: {lw: 5.1f} - {hg: 5.1f} | {acc1: 8.2%}"
+                )

sclab/tools/differential_expression/__init__.py

@@ -0,0 +1,7 @@
+from ._pseudobulk_edger import pseudobulk_edger
+from ._pseudobulk_limma import pseudobulk_limma
+
+__all__ = [
+    "pseudobulk_edger",
+    "pseudobulk_limma",
+]