fdnkit 1.0.0__py3-none-any.whl

fdnkit/__init__.py

@@ -0,0 +1,94 @@
+"""FDNkit -- Fractional Dynamical Network & Multifractal toolkit for iEEG.
+
+Turn intracranial-EEG recordings into fractal / fractional-dynamical-network
+features and evaluate them honestly:
+
+* :mod:`fdnkit.dfa` -- monofractal DFA Hurst exponent.
+* :mod:`fdnkit.mfdfa` -- multifractal generalized Hurst ``h(q)`` and spectrum.
+* :mod:`fdnkit.fodn` -- fractional-order dynamical network (alpha, coupling A,
+  eigenvector hubs).
+* :mod:`fdnkit.features` -- tidy per-trial feature tables.
+* :mod:`fdnkit.classify` -- classification with subject-wise CV by default.
+* :mod:`fdnkit.io`, :mod:`fdnkit.preprocessing`, :mod:`fdnkit.viz`,
+  :mod:`fdnkit.synthetic` -- supporting IO, windowing, plots, and test signals.
+
+Quickstart
+----------
+>>> from fdnkit.synthetic import synthetic_ieeg
+>>> from fdnkit.features import extract_features
+>>> sig, names = synthetic_ieeg(n_channels=6, n_samples=2000, seed=0)
+>>> feats = extract_features(sig)
+>>> sorted(feats)[:3]
+['DFA_H_max', 'DFA_H_mean', 'DFA_H_min']
+"""
+
+from __future__ import annotations
+
+__version__ = "1.0.0"
+
+from .dfa import DFAResult, dfa, hurst
+from .features import (
+    CORE_FEATURES,
+    dfa_features,
+    extract_features,
+    feature_table,
+    fodn_features,
+    mfdfa_features,
+)
+from .fodn import FODN, FODNResult, fit_fodn
+from .mfdfa import (
+    MFDFAResult,
+    delta_hq,
+    generalized_hurst,
+    mfdfa,
+    multifractal_spectrum,
+)
+from .preprocessing import flag_bad_channels, segment, sliding_windows, zscore
+from .synthetic import binomial_cascade, fbm, fgn, synthetic_ieeg
+
+__all__ = [
+    "__version__",
+    # dfa
+    "dfa",
+    "hurst",
+    "DFAResult",
+    # mfdfa
+    "mfdfa",
+    "generalized_hurst",
+    "delta_hq",
+    "multifractal_spectrum",
+    "MFDFAResult",
+    # fodn
+    "FODN",
+    "FODNResult",
+    "fit_fodn",
+    # features
+    "extract_features",
+    "feature_table",
+    "dfa_features",
+    "mfdfa_features",
+    "fodn_features",
+    "CORE_FEATURES",
+    # preprocessing
+    "zscore",
+    "flag_bad_channels",
+    "segment",
+    "sliding_windows",
+    # synthetic
+    "fgn",
+    "fbm",
+    "binomial_cascade",
+    "synthetic_ieeg",
+]
+
+
+def __getattr__(name):
+    # Lazily expose the classification helpers to keep import light and
+    # optional-dependency-safe. Note: ``fdnkit.classify`` is the *module*
+    # (call ``fdnkit.classify.classify(...)`` or import the function directly);
+    # ``classify_dataframe`` and ``ClassificationResult`` are surfaced here.
+    if name in ("classify_dataframe", "ClassificationResult"):
+        from . import classify as _classify
+
+        return getattr(_classify, name)
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

fdnkit/classify.py

@@ -0,0 +1,310 @@
+"""Classification harness with honest, subject-wise cross-validation by default.
+
+The reference study behind FDNkit found that evaluating an iEEG classifier with
+row-wise splits leaked *patient identity* into the test set and inflated
+accuracy. This module bakes the fix in:
+
+* the default cross-validation is **leave-one-group-out** (subject-wise), and
+  ``groups`` is *required* for it;
+* trial-wise leave-one-out is available but must be requested explicitly and is
+  labeled *optimistic*;
+* every run can attach a **subject-level permutation test** and bootstrap
+  confidence intervals.
+
+Folds the honest-CV revalidation logic into a reusable API.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import (
+    accuracy_score,
+    balanced_accuracy_score,
+    roc_auc_score,
+)
+from sklearn.model_selection import (
+    LeaveOneGroupOut,
+    LeaveOneOut,
+    StratifiedGroupKFold,
+    permutation_test_score,
+)
+from sklearn.pipeline import make_pipeline
+from sklearn.preprocessing import StandardScaler
+
+__all__ = ["ClassificationResult", "make_classifier", "classify", "classify_dataframe"]
+
+
+@dataclass
+class ClassificationResult:
+    """Outcome of a cross-validated evaluation.
+
+    Attributes
+    ----------
+    cv : str
+        Which scheme ran (``"loso"``, ``"loo"``, ``"group_kfold"``).
+    honest : bool
+        True when the scheme holds out whole subjects (no identity leakage).
+    n : int
+        Number of trials.
+    accuracy, balanced_accuracy, auc : float
+        Pooled out-of-fold metrics.
+    majority_baseline : float
+        Accuracy of always predicting the majority class.
+    permutation_p : float | None
+        p-value from the subject-level permutation test (if run).
+    permutation_chance : float | None
+        Mean permuted score (empirical chance level).
+    ci95 : tuple | None
+        Bootstrap 95% CI on balanced accuracy (if requested).
+    per_group : dict
+        Per-group balanced accuracy (subject-wise schemes only).
+    notes : str
+        Human-readable caveats.
+    """
+
+    cv: str
+    honest: bool
+    n: int
+    accuracy: float
+    balanced_accuracy: float
+    auc: float
+    majority_baseline: float
+    permutation_p: float | None = None
+    permutation_chance: float | None = None
+    ci95: tuple | None = None
+    per_group: dict = field(default_factory=dict)
+    notes: str = ""
+
+    def summary(self) -> str:
+        """A one-block textual report."""
+        lines = [
+            f"FDNkit classification ({self.cv}{'' if self.honest else ', OPTIMISTIC'})",
+            f"  trials              : {self.n}",
+            f"  accuracy            : {self.accuracy:.3f}",
+            f"  balanced accuracy   : {self.balanced_accuracy:.3f}",
+            f"  ROC-AUC             : {self.auc:.3f}",
+            f"  majority baseline   : {self.majority_baseline:.3f}",
+        ]
+        if self.permutation_p is not None:
+            lines.append(
+                f"  permutation test    : chance={self.permutation_chance:.3f}, "
+                f"p={self.permutation_p:.4f}"
+            )
+        if self.ci95 is not None:
+            lines.append(f"  bal-acc 95% CI      : [{self.ci95[0]:.3f}, {self.ci95[1]:.3f}]")
+        if self.notes:
+            lines.append(f"  note: {self.notes}")
+        return "\n".join(lines)
+
+
+def make_classifier(C: float = 1.0, max_iter: int = 1000):
+    """Standard-scaler + logistic-regression pipeline used throughout."""
+    return make_pipeline(StandardScaler(), LogisticRegression(C=C, max_iter=max_iter))
+
+
+def _bootstrap_ci(y_true, y_pred, n_boot=1000, seed=0):
+    rng = np.random.default_rng(seed)
+    n = len(y_true)
+    scores = []
+    for _ in range(n_boot):
+        idx = rng.integers(0, n, n)
+        yt, yp = y_true[idx], y_pred[idx]
+        if len(np.unique(yt)) < 2:
+            continue
+        scores.append(balanced_accuracy_score(yt, yp))
+    if not scores:
+        return None
+    return float(np.percentile(scores, 2.5)), float(np.percentile(scores, 97.5))
+
+
+def classify(
+    X,
+    y,
+    groups=None,
+    *,
+    cv: str = "loso",
+    estimator=None,
+    n_splits: int = 5,
+    permutation: bool = True,
+    n_permutations: int = 1000,
+    bootstrap: bool = True,
+    random_state: int = 0,
+) -> ClassificationResult:
+    """Cross-validate a binary classifier with honest defaults.
+
+    Parameters
+    ----------
+    X : array-like, shape (n_trials, n_features)
+    y : array-like, shape (n_trials,)
+        Binary labels.
+    groups : array-like, optional
+        Group (e.g. subject) id per trial. **Required** for ``cv in
+        {"loso", "group_kfold"}``.
+    cv : {"loso", "group_kfold", "loo"}
+        Cross-validation scheme. ``"loso"`` (leave-one-subject-out) is the
+        default and the only fully honest single-holdout option. ``"loo"`` is
+        trial-wise and *optimistic* (same subject can appear in train and test).
+    estimator : sklearn estimator, optional
+        Defaults to :func:`make_classifier`.
+    n_splits : int
+        Folds for ``cv="group_kfold"``.
+    permutation : bool
+        Run a (group-aware) permutation test.
+    n_permutations : int
+        Permutation count.
+    bootstrap : bool
+        Compute a bootstrap 95% CI on balanced accuracy.
+    random_state : int
+        Seed for permutation/bootstrap reproducibility.
+
+    Returns
+    -------
+    ClassificationResult
+    """
+    X = np.asarray(X, dtype=float)
+    y = np.asarray(y).astype(int)
+    if X.ndim != 2:
+        raise ValueError("X must be 2-D (n_trials, n_features)")
+    if y.shape[0] != X.shape[0]:
+        raise ValueError("X and y length mismatch")
+    if len(np.unique(y)) < 2:
+        raise ValueError("need both classes present in y")
+
+    est = make_classifier() if estimator is None else estimator
+    cv = cv.lower()
+    honest = cv in ("loso", "group_kfold")
+
+    if cv in ("loso", "group_kfold") and groups is None:
+        raise ValueError(
+            f"cv='{cv}' is subject-wise and requires `groups` (one id per trial). "
+            "Pass groups=..., or use cv='loo' explicitly for an optimistic trial-wise estimate."
+        )
+    if groups is not None:
+        groups = np.asarray(groups)
+
+    if cv == "loso":
+        splitter = LeaveOneGroupOut()
+        split_iter = splitter.split(X, y, groups)
+        notes = ""
+    elif cv == "group_kfold":
+        n_groups = len(np.unique(groups))
+        k = min(n_splits, n_groups)
+        splitter = StratifiedGroupKFold(n_splits=k, shuffle=True, random_state=random_state)
+        split_iter = splitter.split(X, y, groups)
+        notes = f"stratified group {k}-fold"
+    elif cv == "loo":
+        splitter = LeaveOneOut()
+        split_iter = splitter.split(X)
+        notes = "trial-wise LOO ignores subject structure and is leakage-prone"
+    else:
+        raise ValueError(f"unknown cv scheme: {cv!r}")
+
+    preds = np.full(len(y), -1)
+    probs = np.full(len(y), np.nan)
+    for tr, te in split_iter:
+        if len(np.unique(y[tr])) < 2:
+            # a fold whose training set is single-class can't fit a classifier
+            preds[te] = int(round(np.mean(y[tr])))
+            probs[te] = np.mean(y[tr])
+            continue
+        model = est.fit(X[tr], y[tr])
+        preds[te] = model.predict(X[te])
+        if hasattr(model, "predict_proba"):
+            probs[te] = model.predict_proba(X[te])[:, 1]
+        else:
+            probs[te] = preds[te]
+
+    acc = accuracy_score(y, preds)
+    bal = balanced_accuracy_score(y, preds)
+    try:
+        auc = roc_auc_score(y, probs)
+    except ValueError:
+        auc = float("nan")
+    majority = max(np.mean(y), 1 - np.mean(y))
+
+    per_group: dict = {}
+    if honest and groups is not None:
+        for g in np.unique(groups):
+            m = groups == g
+            if m.sum() and len(np.unique(y[m])) >= 1:
+                per_group[str(g)] = float(balanced_accuracy_score(y[m], preds[m])) \
+                    if len(np.unique(y[m])) >= 2 else float(accuracy_score(y[m], preds[m]))
+
+    perm_p = perm_chance = None
+    if permutation:
+        if cv == "loso":
+            cv_obj = LeaveOneGroupOut()
+            score, perm_scores, perm_p = permutation_test_score(
+                est, X, y, groups=groups, cv=cv_obj, scoring="accuracy",
+                n_permutations=n_permutations, random_state=random_state, n_jobs=1,
+            )
+            perm_chance = float(np.mean(perm_scores))
+        elif cv == "group_kfold":
+            cv_obj = StratifiedGroupKFold(n_splits=min(n_splits, len(np.unique(groups))),
+                                          shuffle=True, random_state=random_state)
+            score, perm_scores, perm_p = permutation_test_score(
+                est, X, y, groups=groups, cv=cv_obj, scoring="accuracy",
+                n_permutations=n_permutations, random_state=random_state, n_jobs=1,
+            )
+            perm_chance = float(np.mean(perm_scores))
+        # LOO permutation is not group-aware; skip to avoid a misleading p-value.
+
+    ci = _bootstrap_ci(y, preds, seed=random_state) if bootstrap else None
+
+    return ClassificationResult(
+        cv=cv, honest=honest, n=len(y), accuracy=float(acc),
+        balanced_accuracy=float(bal), auc=float(auc), majority_baseline=float(majority),
+        permutation_p=None if perm_p is None else float(perm_p),
+        permutation_chance=perm_chance, ci95=ci, per_group=per_group, notes=notes,
+    )
+
+
+def classify_dataframe(
+    df: pd.DataFrame,
+    *,
+    feature_cols=None,
+    label_col: str = "label",
+    group_col: str = "group",
+    dropna: bool = True,
+    **kwargs,
+) -> ClassificationResult:
+    """Run :func:`classify` directly on a feature DataFrame.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        Must contain ``label_col``; ``group_col`` is used when present (and is
+        required for the default subject-wise CV).
+    feature_cols : sequence of str, optional
+        Columns to use as features. Defaults to all numeric columns except the
+        label/group/identifier columns.
+    label_col, group_col : str
+    dropna : bool
+        Drop rows with missing features or label.
+    **kwargs
+        Forwarded to :func:`classify` (e.g. ``cv``, ``permutation``).
+    """
+    if label_col not in df.columns:
+        raise KeyError(f"label column {label_col!r} not in DataFrame")
+
+    reserved = {label_col, group_col, "trial_id", "id"}
+    if feature_cols is None:
+        feature_cols = [
+            c for c in df.select_dtypes(include=[np.number]).columns if c not in reserved
+        ]
+    if not feature_cols:
+        raise ValueError("no feature columns found")
+
+    use = df.copy()
+    subset = list(feature_cols) + [label_col]
+    if dropna:
+        use = use.dropna(subset=subset)
+
+    X = use[feature_cols].to_numpy()
+    y = use[label_col].to_numpy()
+    groups = use[group_col].to_numpy() if group_col in use.columns else None
+    return classify(X, y, groups=groups, **kwargs)

fdnkit/cli.py

@@ -0,0 +1,175 @@
+"""Command-line interface: ``fdnkit extract`` and ``fdnkit classify``.
+
+Examples
+--------
+Extract features from an EDF or HDF5 recording into a one-row CSV::
+
+    fdnkit extract recording.edf --window 1.0 --out features.csv
+
+Run a self-contained demo on synthetic data (no files needed)::
+
+    fdnkit demo --out demo_features.csv
+
+Evaluate a feature CSV with honest subject-wise CV::
+
+    fdnkit classify features.csv --label label --group subject
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+
+import numpy as np
+import pandas as pd
+
+
+def _cmd_extract(args):
+    from .features import feature_table
+    from .io import Recording, load_edf, load_h5, save_features
+    from .preprocessing import flag_bad_channels, segment, zscore
+
+    path = args.input
+    if path.lower().endswith((".edf", ".edf+", ".bdf")):
+        rec = load_edf(path)
+    elif path.lower().endswith((".h5", ".hdf5")):
+        rec = load_h5(path, fs=args.fs)
+    else:
+        raise SystemExit(f"unsupported input extension: {path}")
+
+    assert isinstance(rec, Recording)
+    signals = rec.signals
+    if args.drop_bad:
+        bad = set(flag_bad_channels(signals, rec.channel_names))
+        keep = [i for i in range(signals.shape[0]) if i not in bad]
+        signals = signals[keep]
+        print(f"[fdnkit] dropped {len(bad)} bad channel(s); kept {len(keep)}")
+    if args.zscore:
+        signals = zscore(signals)
+
+    win = int(args.window * rec.fs)
+    trials = []
+    for k, (_start, _stop, chunk) in enumerate(segment(signals, win)):
+        trials.append({
+            "trial_id": f"win{k}",
+            "group": args.group or "unknown",
+            "signals": chunk,
+        })
+    if not trials:
+        # whole-recording single window fallback
+        trials = [{"trial_id": "full", "group": args.group or "unknown", "signals": signals}]
+
+    df = feature_table(
+        trials,
+        do_fodn=not args.no_fodn,
+        progress=True,
+        fodn_kwargs={"n_iter": args.fodn_iter},
+    )
+    save_features(df, args.out)
+    print(f"[fdnkit] wrote {len(df)} row(s) x {df.shape[1]} cols -> {args.out}")
+
+
+def _cmd_demo(args):
+    from .features import feature_table
+    from .io import save_features
+    from .synthetic import synthetic_ieeg
+
+    rng = np.random.default_rng(args.seed)
+    trials = []
+    for subj in range(args.subjects):
+        for t in range(args.trials_per_subject):
+            label = int(rng.random() < 0.5)
+            h = 0.7 + 0.06 * label  # a faint, learnable class signal
+            sig, _ = synthetic_ieeg(
+                n_channels=args.channels, n_samples=args.samples,
+                hurst=h, seed=rng,
+            )
+            trials.append({
+                "trial_id": f"S{subj}_T{t}",
+                "group": f"S{subj}",
+                "label": label,
+                "signals": sig,
+            })
+    df = feature_table(trials, do_fodn=not args.no_fodn,
+                       fodn_kwargs={"n_iter": args.fodn_iter}, progress=True)
+    save_features(df, args.out)
+    print(f"[fdnkit] demo wrote {len(df)} rows x {df.shape[1]} cols -> {args.out}")
+    print(f"[fdnkit] try: fdnkit classify {args.out} --label label --group group")
+
+
+def _cmd_classify(args):
+    from .classify import classify_dataframe
+
+    df = pd.read_csv(args.input)
+    res = classify_dataframe(
+        df,
+        label_col=args.label,
+        group_col=args.group,
+        cv=args.cv,
+        permutation=not args.no_permutation,
+        n_permutations=args.n_permutations,
+        bootstrap=not args.no_bootstrap,
+    )
+    print(res.summary())
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="fdnkit", description=__doc__.splitlines()[0])
+    p.add_argument("--version", action="store_true", help="print version and exit")
+    sub = p.add_subparsers(dest="command")
+
+    pe = sub.add_parser("extract", help="extract features from a recording")
+    pe.add_argument("input", help="EDF/BDF or HDF5 file")
+    pe.add_argument("--out", default="features.csv", help="output CSV path")
+    pe.add_argument("--window", type=float, default=1.0, help="window length (seconds)")
+    pe.add_argument("--fs", type=float, default=1000.0, help="sampling rate for HDF5 without a time vector")
+    pe.add_argument("--group", default=None, help="group/subject id to tag rows with")
+    pe.add_argument("--zscore", action="store_true", help="z-score channels before analysis")
+    pe.add_argument("--drop-bad", action="store_true", help="auto-drop flat/EKG/DC channels")
+    pe.add_argument("--no-fodn", action="store_true", help="skip the (slow) FODN features")
+    pe.add_argument("--fodn-iter", type=int, default=5, help="FODN ADMM iterations")
+    pe.set_defaults(func=_cmd_extract)
+
+    pd_ = sub.add_parser("demo", help="generate a synthetic feature table (no data needed)")
+    pd_.add_argument("--out", default="demo_features.csv")
+    pd_.add_argument("--subjects", type=int, default=6)
+    pd_.add_argument("--trials-per-subject", type=int, default=8)
+    pd_.add_argument("--channels", type=int, default=6)
+    pd_.add_argument("--samples", type=int, default=2000)
+    pd_.add_argument("--fodn-iter", type=int, default=3)
+    pd_.add_argument("--no-fodn", action="store_true")
+    pd_.add_argument("--seed", type=int, default=0)
+    pd_.set_defaults(func=_cmd_demo)
+
+    pc = sub.add_parser("classify", help="honest cross-validated classification of a feature CSV")
+    pc.add_argument("input", help="feature CSV")
+    pc.add_argument("--label", default="label", help="label column")
+    pc.add_argument("--group", default="group", help="group/subject column")
+    pc.add_argument("--cv", default="loso", choices=["loso", "group_kfold", "loo"])
+    pc.add_argument("--no-permutation", action="store_true")
+    pc.add_argument("--n-permutations", type=int, default=1000)
+    pc.add_argument("--no-bootstrap", action="store_true")
+    pc.set_defaults(func=_cmd_classify)
+
+    return p
+
+
+def main(argv=None):
+    argv = sys.argv[1:] if argv is None else argv
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if getattr(args, "version", False):
+        from . import __version__
+
+        print(f"fdnkit {__version__}")
+        return 0
+    if not getattr(args, "command", None):
+        parser.print_help()
+        return 1
+    args.func(args)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

fdnkit/dfa.py

@@ -0,0 +1,88 @@
+"""Monofractal detrended fluctuation analysis (DFA).
+
+DFA estimates the Hurst exponent ``H`` of a time series: the scaling exponent of
+its detrended root-mean-square fluctuation against window size. It is the
+``q = 2`` special case of :mod:`fdnkit.mfdfa`, exposed here as a lightweight,
+single-purpose entry point.
+
+Reference: Peng et al. (1994); the implementation matches the validated
+reference and MATLAB code.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from .mfdfa import DEFAULT_SCALES, _fluctuations, _loglog_slope
+
+__all__ = ["DFAResult", "dfa", "hurst"]
+
+
+@dataclass
+class DFAResult:
+    """Output of :func:`dfa`.
+
+    Attributes
+    ----------
+    hurst : float
+        Hurst exponent (log-log slope of fluctuation vs scale).
+    scales : numpy.ndarray
+        Window sizes used.
+    fluct : numpy.ndarray
+        Fluctuation function ``F`` per scale.
+    """
+
+    hurst: float
+    scales: np.ndarray
+    fluct: np.ndarray
+
+
+def dfa(signal, scales=None, order: int = 1, rel_floor: float = 1e-3) -> DFAResult:
+    """Estimate the Hurst exponent of a 1-D signal by DFA.
+
+    Parameters
+    ----------
+    signal : array-like
+        1-D time series.
+    scales : array-like, optional
+        Window sizes in samples. Defaults to the standard FDNkit grid.
+    order : int
+        Detrending polynomial order (1 = linear).
+    rel_floor : float
+        Scale-relative floor on per-segment fluctuations (see
+        :func:`fdnkit.mfdfa.mfdfa`). Has negligible effect on the (positive-moment)
+        Hurst estimate but keeps behaviour consistent with MFDFA.
+
+    Returns
+    -------
+    DFAResult
+
+    Examples
+    --------
+    >>> from fdnkit.synthetic import fgn
+    >>> from fdnkit.dfa import dfa
+    >>> H = dfa(fgn(8000, 0.7, seed=0)).hurst  # ~0.7
+    """
+    eps = np.finfo(float).eps
+    scales = DEFAULT_SCALES if scales is None else np.asarray(scales, dtype=int)
+    x = np.asarray(signal, dtype=float).ravel()
+    if x.size < int(scales.min()) * 2:
+        raise ValueError(
+            f"signal length {x.size} too short for smallest scale {int(scales.min())}"
+        )
+
+    rms_per_scale = _fluctuations(x, scales, order, rel_floor=rel_floor)
+    fluct = np.full(len(scales), np.nan)
+    for i, rms in enumerate(rms_per_scale):
+        if rms.size:
+            fluct[i] = np.sqrt(np.mean(rms**2))
+
+    H = _loglog_slope(scales, fluct + eps)
+    return DFAResult(hurst=H, scales=np.asarray(scales), fluct=fluct)
+
+
+def hurst(signal, scales=None, order: int = 1) -> float:
+    """Return just the Hurst exponent (shorthand for ``dfa(...).hurst``)."""
+    return dfa(signal, scales=scales, order=order).hurst