quantred 2.4.0__py3-none-any.whl

quantred/__init__.py

@@ -0,0 +1,24 @@
+"""QuantRed — a layered, broker-agnostic algorithmic-trading research engine.
+
+The package root deliberately imports nothing. Every subpackage pulls in something
+heavy or optional (pandas, the Alpaca SDK, matplotlib, the MCP SDK), and a root that
+eagerly imported them would make ``quantred --help`` pay for capabilities the
+command is not using — and would make an absent optional extra an import error at
+startup rather than an actionable message at the point of use.
+
+The layers, in dependency order (each may import from below, never above):
+
+    brokers -> marketdata -> indicators -> strategies/scanners -> engine
+                                        -> alphas/risk/portfolio/analytics
+                                        -> services -> cli / mcp
+
+The one invariant that outranks all of them: **two clocks**. The research clock
+(backtest, optimize, walk-forward, the whole analytics stack) may be slow,
+exploratory, and LLM-assisted; it only ever *proposes*. The trade clock
+(``engine.live``) is deterministic and imports none of it. Promotion between them is
+a manual human step.
+"""
+
+#: The single source of truth for the version — packaging reads it from here, so a
+#: published artifact and what `quantred --version` reports cannot drift apart.
+__version__ = "2.4.0"

quantred/alphas/__init__.py

@@ -0,0 +1,53 @@
+"""Continuous alphas: turn a score column into a comparable residual-return forecast.
+
+The central active-management move: convert a raw, arbitrary-scale signal into an
+*alpha* - a forecast of residual return in annualized-return units, the same for
+every name - so views can be pooled, ranked, and sized by a mean-variance
+optimizer. Research-clock only: alphas forecast, they never trade.
+
+The refinement runs over a :class:`~quantred.data.panel.FeaturePanel`: a scorer
+(:mod:`quantred.alphas.scorers`) fills the ``score`` column, :func:`refine_alpha` adds
+``z`` and ``alpha`` via the identity ``alpha = sigma * IC * z``, and
+:func:`panel_to_alphas` exports the ranked :class:`Alpha` rows.
+"""
+
+from quantred.alphas.base import (
+    DEFAULT_IC,
+    DEFAULT_MIN_UNIVERSE,
+    Alpha,
+    AlphaContext,
+    panel_to_alphas,
+    refine_alpha,
+)
+from quantred.alphas.combine import (
+    SignalMeasurement,
+    combination_weights,
+    combine_scores,
+    combined_ic,
+    combined_score,
+    effective_ic,
+    measure_signals,
+    shrink_ic,
+)
+from quantred.alphas.scorers import Scorer, scanner_scorer, signal_scorer, strategy_scorer
+
+__all__ = [
+    "Alpha",
+    "AlphaContext",
+    "refine_alpha",
+    "panel_to_alphas",
+    "Scorer",
+    "strategy_scorer",
+    "signal_scorer",
+    "scanner_scorer",
+    "DEFAULT_IC",
+    "DEFAULT_MIN_UNIVERSE",
+    "SignalMeasurement",
+    "measure_signals",
+    "combined_score",
+    "combination_weights",
+    "combined_ic",
+    "effective_ic",
+    "shrink_ic",
+    "combine_scores",
+]

quantred/alphas/base.py

@@ -0,0 +1,221 @@
+"""Alpha types and the refinement that turns a score column into a forecast.
+
+An *alpha* is a forecast of **residual return** (return in excess of what beta to
+the benchmark explains), annualized and on the same scale for every name, so it is
+directly comparable across symbols and directly consumable by a mean-variance
+optimizer.
+
+The refinement runs over a :class:`~quantred.data.panel.FeaturePanel`: it reads the
+cross-section's ``score`` and ``residual_vol`` columns (and ``beta`` when
+neutralizing) and writes ``z`` and ``alpha`` columns back. One implementation, one
+place - whatever produced the score (a strategy, a scanner, a combination of
+signals) flows through the same pipeline.
+
+Research clock only: it forecasts, it never reads a realized forward return, it
+places no orders.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import List, Optional, Tuple
+
+import pandas as pd
+
+from quantred.alphas import refine
+from quantred.data.features import EXPOSURE_PREFIX
+from quantred.data.panel import FeaturePanel
+
+#: Conservative default information coefficient. The absolute scale of alphas is
+#: only as good as this prior until IC is measured from realized outcomes; the
+#: *relative* sizing across names is correct regardless (IC is a common scalar).
+DEFAULT_IC = 0.03
+
+#: Below this many names the cross-sectional z-score and winsorize quantiles are
+#: unstable, so the pipeline falls back to demean-only and flags low confidence.
+DEFAULT_MIN_UNIVERSE = 10
+
+
+def thin_universe_text(n_names: int, minimum: int = DEFAULT_MIN_UNIVERSE) -> str:
+    """Why a thin universe lowers confidence, for every surface that reports it."""
+    return (
+        f"thin universe ({n_names} names, fewer than {minimum}) - demean-only: no winsorizing or "
+        "unit-std scaling, so alpha magnitudes are not comparable to a full universe's"
+    )
+
+
+@dataclass
+class Alpha:
+    """A refined residual-return forecast: annualized, benchmark-relative."""
+
+    symbol: str
+    alpha: float  # expected annualized residual return, e.g. 0.04 = +4%/yr
+    as_of: datetime
+    residual_vol: float  # sigma used in scaling (annualized), for audit
+    ic: float  # information coefficient used in scaling
+    raw_z: float  # standardized score that produced it
+
+
+@dataclass
+class AlphaContext:
+    """Knobs for the refinement (everything that isn't a panel column)."""
+
+    ic: float = DEFAULT_IC
+    default_residual_vol: float = 0.20  # fallback when a name has no risk estimate
+    neutralize: bool = False  # regress out the benchmark-beta exposure
+    #: Risk-model factors to regress out (``exp_<name>`` panel columns, written by
+    #: :func:`quantred.data.features.add_factor_exposure_features`). ``"market"`` here
+    #: supersedes the plain-beta ``neutralize`` (same exposure, standardized).
+    #: Momentum is deliberately absent from the usual set — a momentum tilt is a
+    #: return bet the alphas may intend; market/volatility/size are risk-control.
+    neutralize_factors: tuple = ()
+    winsorize_limits: tuple = (0.025, 0.975)
+    alpha_cap_std: float = 3.0
+    min_universe: int = DEFAULT_MIN_UNIVERSE
+    #: Per-name scaling. ``"case1"`` = the standard rule ``ω·IC·z`` (the default,
+    #: correct when per-name signal vol is constant across names); ``"case2"`` =
+    #: ``IC·c_g·z`` with a constant :func:`~quantred.alphas.refine.case_scale_factor`, for
+    #: signals whose vol is ∝ the name's residual vol (multiplying by ``ω_n`` would
+    #: double-count it). :func:`~quantred.alphas.refine.case_test` picks the case empirically.
+    #: See the Continuous-alphas page in the engineering docs for the Case test.
+    scaling: str = "case1"
+    #: IC-uncertainty **level** shrink. When set to ``(measured_ic, t_eff)`` the refined
+    #: alpha is multiplied once by :func:`~quantred.alphas.refine.level_shrink_factor` — the
+    #: estimation-error haircut on the *level*. ``None`` = off (a measured IC hasn't been
+    #: supplied, e.g. an assumed prior, or the level shrink is owned upstream by the
+    #: multi-signal combination's per-signal Bayesian shrink).
+    level_shrink: Optional[Tuple[float, float]] = None
+
+
+def refine_alpha(
+    panel: FeaturePanel,
+    context: AlphaContext,
+    score_col: str = "score",
+) -> FeaturePanel:
+    """Refine a panel's ``score`` column into ``z`` and ``alpha`` columns.
+
+    Cross-sectional at this one rebalance: winsorize, z-score, optionally neutralize
+    against the ``beta`` exposure and/or the risk-model factor block
+    (``context.neutralize_factors`` reading ``exp_<factor>`` columns), scale by
+    ``sigma * IC``, then cap. On a thin
+    universe (``< context.min_universe`` scored names) winsorize and the unit-std
+    scaling are skipped in favor of demean-only, and ``panel.meta['low_confidence']``
+    is set. Reads ``residual_vol`` for ``sigma`` (falling back to the context default).
+    """
+    if not panel.has(score_col):
+        panel.meta["low_confidence"] = False
+        return panel
+
+    s = panel.get(score_col).dropna()
+    if s.empty:
+        panel.meta["low_confidence"] = False
+        return panel
+
+    thin = len(s) < context.min_universe
+    panel.meta["low_confidence"] = thin
+
+    # 1-2. Winsorize then standardize. On thin universes the quantiles and the
+    #      cross-sectional std are unreliable, so demean-only (no scaling).
+    if thin:
+        z = refine.demean(s)
+    else:
+        z = refine.zscore(refine.winsorize(s, *context.winsorize_limits))
+
+    # 3. Optional neutralization: benchmark beta and/or risk-model factor exposures
+    #    (one regression on the union, so the residual is orthogonal to all of it).
+    #    A factor column is used only if it actually varies across covered names —
+    #    an absent, all-NaN, or constant column must degrade to beta neutralization,
+    #    never silently to *no* neutralization. Names missing a factor value get the
+    #    cross-sectional mean (0 — exposures are standardized), which keeps them in
+    #    the regression instead of stripping their beta neutralization too.
+    if not thin:
+        columns = {}
+        imputed = 0
+        for factor in context.neutralize_factors:
+            col = f"{EXPOSURE_PREFIX}{factor}"
+            if not panel.has(col):
+                continue
+            series = panel.get(col).reindex(z.index)
+            if series.notna().sum() >= 2 and series.std(ddof=0) > 0:
+                imputed += int(series.isna().sum())
+                columns[col] = series.fillna(0.0)
+        market_col = f"{EXPOSURE_PREFIX}market"
+        if context.neutralize and panel.has("beta") and market_col not in columns:
+            columns["beta"] = panel.get("beta")
+        if columns:
+            z = refine.neutralize(z, pd.DataFrame(columns).reindex(z.index))
+        panel.meta["neutralized_against"] = [
+            c[len(EXPOSURE_PREFIX) :] if c.startswith(EXPOSURE_PREFIX) else c for c in columns
+        ]
+        panel.meta["neutralize_imputed"] = imputed
+
+    # 4. Scale to a residual-return forecast. Case 1: alpha_i = sigma_i * IC * z_i
+    #    (per-name vol). Case 2: alpha_i = IC * c_g * z_i (one constant c_g), which
+    #    avoids double-counting vol for signals whose per-name vol is ∝ sigma_i.
+    if panel.has("residual_vol"):
+        vol = panel.get("residual_vol").reindex(z.index).fillna(context.default_residual_vol)
+    else:
+        vol = pd.Series(context.default_residual_vol, index=z.index)
+
+    chain: List[dict] = []
+    if context.scaling == "case2" and not thin:
+        c_g = refine.case_scale_factor(s, vol, context.winsorize_limits)
+        if not (c_g == c_g):  # NaN fallback → a representative vol, so it never crashes
+            c_g = float(vol.mean())
+        alpha = refine.scale_to_alpha(z, pd.Series(c_g, index=z.index), context.ic)
+        chain.append({"step": "scale", "case": 2, "c_g": float(c_g), "multiplier": float(context.ic * c_g)})
+    else:
+        alpha = refine.scale_to_alpha(z, vol, context.ic)
+        chain.append({"step": "scale", "case": 1, "multiplier": float(context.ic)})
+
+    # 4b. IC-uncertainty level shrink, applied exactly once here — the single
+    #     application point for both the single-signal and combined paths.
+    if context.level_shrink is not None:
+        ic_measured, t_eff = context.level_shrink
+        factor = refine.level_shrink_factor(ic_measured, t_eff)
+        alpha = alpha * factor
+        chain.append(
+            {
+                "step": "ic_uncertainty",
+                "owner": "level_shrink",
+                "ic": float(ic_measured),
+                "t_eff": float(t_eff),
+                "multiplier": float(factor),
+            }
+        )
+    panel.meta["shrink_chain"] = chain
+
+    # 5. Final sanity cap (meaningless on a thin, unscaled vector).
+    if not thin:
+        alpha = refine.cap(alpha, context.alpha_cap_std)
+
+    panel.set("z", z)
+    panel.set("alpha", alpha)
+    return panel
+
+
+def panel_to_alphas(panel: FeaturePanel, context: AlphaContext) -> List[Alpha]:
+    """Export the refined panel rows as :class:`Alpha` records (alpha-ranked)."""
+    if not panel.has("alpha"):
+        return []
+    rows = []
+    for symbol in panel.symbols:
+        alpha = panel.get("alpha").get(symbol)
+        if alpha is None or pd.isna(alpha):
+            continue
+        z = panel.get("z").get(symbol) if panel.has("z") else float("nan")
+        vol = (
+            panel.get("residual_vol").get(symbol)
+            if panel.has("residual_vol")
+            else context.default_residual_vol
+        )
+        rows.append(
+            Alpha(
+                symbol=symbol,
+                alpha=float(alpha),
+                as_of=panel.as_of,
+                residual_vol=float(vol) if vol == vol else context.default_residual_vol,
+                ic=context.ic,
+                raw_z=float(z) if z == z else 0.0,
+            )
+        )
+    return sorted(rows, key=lambda a: a.alpha, reverse=True)

quantred/alphas/combine.py

@@ -0,0 +1,260 @@
+"""Multi-signal alpha combination & shrinkage.
+
+One signal becomes one alpha (:mod:`quantred.alphas`). Real research has several - a
+trend read, a volume read, a mean-reversion read - and they are **correlated**.
+Two mistakes follow if you ignore that:
+
+1. **Naive weighting double-counts.** Weighting by raw IC over-weights redundant
+   signals (three flavors of trend look like three bets but are one) and
+   under-weights a weak-but-independent signal that adds the most.
+2. **Estimated ICs are themselves uncertain**, and that uncertainty should shrink
+   the contribution toward zero - more for short histories and low ICs.
+
+This module adds both correctives: optimal combination via the signal
+**correlation matrix**, and **Bayesian IC-uncertainty shrinkage**. The output is a
+single combined score (with its combined IC), which flows through the same
+:func:`~quantred.alphas.base.refine_alpha` pipeline - so the per-signal assumed IC is
+replaced by one measured, shrunk, redundancy-aware number, never applied twice.
+
+The ICs and the correlation matrix must be **measured** (here, over a trailing
+window of realized residual returns), not assumed - in-sample/assumed ICs would let
+the combination over-fit its own weights.
+"""
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Callable, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from quantred.alphas import refine
+from quantred.indicators import indicators
+
+Scorer = Callable[[pd.DataFrame], float]
+
+#: Tiny ridge added to the signal correlation matrix before inverting it. Keeps the
+#: GLS combination finite when two signals are near-duplicates (ρ → 1 ⇒ singular).
+DEFAULT_RIDGE = 1e-4
+
+
+# --------------------------------------------------------------------------- #
+# The combination math (pure, closed-form)
+# --------------------------------------------------------------------------- #
+def shrink_ic(ic: float, n_obs: int) -> float:
+    """Bayesian IC-uncertainty shrinkage: ``ic' = ic · g/(g+1)``, ``g = n·ic²``.
+
+    Confidence grows with the number of observations ``n`` and the signal's own
+    explanatory power ``ic²``. So ``ic' → 0`` as ``n`` is small or ``ic → 0``, and
+    ``ic' → ic`` as ``n·ic² → ∞``. This is what stops a noisy, short-history IC from
+    being trusted at face value.
+    """
+    g = n_obs * ic * ic
+    return float(ic * g / (g + 1.0)) if g > 0 else 0.0
+
+
+def effective_ic(ic1: float, ic2: float, rho: float) -> float:
+    """Redundancy-corrected effective IC of signal 1 given signal 2 (two-signal).
+
+    ``IC₁' = (IC₁ − ρ·IC₂) / (1 − ρ²)`` - the part of signal 1's skill that is not
+    already explained by signal 2.
+    """
+    denom = 1.0 - rho * rho
+    if denom <= 0:
+        return 0.0
+    return (ic1 - rho * ic2) / denom
+
+
+def _regularized(corr: np.ndarray, ridge: float) -> np.ndarray:
+    c = np.asarray(corr, dtype=float)
+    return c + ridge * np.eye(c.shape[0])
+
+
+def combination_weights(ics: np.ndarray, corr: np.ndarray, ridge: float = DEFAULT_RIDGE) -> np.ndarray:
+    """Optimal signal weights ``w = Ω⁻¹ · IC`` (GLS on the signal correlation matrix).
+
+    These maximize the combined IC. Because ``Ω⁻¹`` accounts for correlation, two
+    redundant signals **split** a weight rather than each getting full credit - the
+    built-in defense against double-counting. A ridge regularizes the inverse so a
+    near-duplicate pair (ρ → 1) stays finite.
+    """
+    ic = np.asarray(ics, dtype=float)
+    return np.linalg.solve(_regularized(corr, ridge), ic)
+
+
+def combined_ic(ics: np.ndarray, corr: np.ndarray, ridge: float = DEFAULT_RIDGE) -> float:
+    """The combined information coefficient ``√(ICᵀ Ω⁻¹ IC)``.
+
+    For two signals this is exactly ``√((IC₁² + IC₂² − 2ρ·IC₁·IC₂)/(1 − ρ²))``.
+    Adding a weak *independent* signal raises it; adding a strong *redundant* one
+    barely does.
+    """
+    ic = np.asarray(ics, dtype=float)
+    val = float(ic @ np.linalg.solve(_regularized(corr, ridge), ic))
+    return float(np.sqrt(max(val, 0.0)))
+
+
+def combine_scores(score_frame: pd.DataFrame, weights: np.ndarray) -> pd.Series:
+    """Weighted sum of per-signal cross-sectional z-scores → one combined score.
+
+    Each signal column is standardized cross-sectionally first (so the weights act
+    on comparable units), then combined by ``weights``. The result's absolute scale
+    is irrelevant - :func:`refine_alpha` re-standardizes it - so only the relative
+    weights matter.
+    """
+    if score_frame.empty:
+        return pd.Series(dtype=float)
+    z = score_frame.apply(refine.zscore, axis=0)
+    combined = z.to_numpy() @ np.asarray(weights, dtype=float)
+    return pd.Series(combined, index=score_frame.index)
+
+
+# --------------------------------------------------------------------------- #
+# IC measurement (over a trailing window of realized residual returns)
+# --------------------------------------------------------------------------- #
+@dataclass
+class SignalMeasurement:
+    """Measured inputs for the combination, plus their provenance."""
+
+    signals: List[str]
+    ics: Dict[str, float]  # mean cross-sectional IC per signal
+    shrunk_ics: Dict[str, float]  # after Bayesian shrinkage
+    correlation: pd.DataFrame  # K×K signal correlation matrix
+    weights: Dict[str, float]  # Ω⁻¹ · shrunk_IC, per signal
+    combined_ic: float
+    n_periods: int  # rebalances measured (the shrinkage sample size)
+
+
+def measure_signals(
+    bars: Dict[str, pd.DataFrame],
+    scorers: Dict[str, Scorer],
+    benchmark_bars: pd.DataFrame,
+    as_of: datetime,
+    *,
+    horizon: int = 5,
+    n_points: int = 12,
+    warmup: int = 30,
+    min_names: int = 5,
+    ridge: float = DEFAULT_RIDGE,
+) -> SignalMeasurement:
+    """Measure each signal's IC and the signal correlation matrix over history.
+
+    At each of ``n_points`` rebalance dates within ``(warmup, as_of − horizon]``, score
+    every signal on the cross-section (using only bars ``≤ t``) and correlate it with
+    the subsequent ``horizon``-bar realized **residual** return (return minus
+    ``β·benchmark`` - rewarding skill, not beta). The mean over rebalances is the IC;
+    the mean cross-sectional correlation between signals is ``Ω``. ICs are then shrunk
+    and combined into GLS weights.
+    """
+    names = [s for s in bars if not bars[s].empty]
+    signal_names = list(scorers)
+    ref_index = benchmark_bars.index
+    usable = ref_index[ref_index <= _to_ts(as_of, ref_index)]
+    # Rebalance points: evenly spaced, leaving room for the forward horizon.
+    last = len(usable) - horizon - 1
+    if last <= warmup:
+        return _empty_measurement(signal_names)
+    points = np.linspace(warmup, last, num=min(n_points, last - warmup), dtype=int)
+
+    per_signal_ic: Dict[str, List[float]] = {s: [] for s in signal_names}
+    corr_accum: List[pd.DataFrame] = []
+
+    for j in points:
+        t = usable[j]
+        t_fwd = usable[j + horizon]
+        scores, fwd = _cross_section(bars, names, scorers, benchmark_bars, t, t_fwd, min_names)
+        if scores is None:
+            continue
+        for s in signal_names:
+            ic = scores[s].corr(fwd)
+            if pd.notna(ic):
+                per_signal_ic[s].append(float(ic))
+        corr_accum.append(scores.corr())
+
+    n_periods = len(corr_accum)
+    ics = {s: float(np.mean(v)) if v else 0.0 for s, v in per_signal_ic.items()}
+    if corr_accum:
+        correlation = sum(corr_accum) / n_periods
+    else:
+        correlation = pd.DataFrame(np.eye(len(signal_names)), index=signal_names, columns=signal_names)
+
+    shrunk = {s: shrink_ic(ics[s], n_periods) for s in signal_names}
+    ic_vec = np.array([shrunk[s] for s in signal_names])
+    corr_mat = correlation.loc[signal_names, signal_names].to_numpy()
+    w = combination_weights(ic_vec, corr_mat, ridge) if n_periods else np.zeros(len(signal_names))
+    ic_comb = combined_ic(ic_vec, corr_mat, ridge) if n_periods else 0.0
+
+    return SignalMeasurement(
+        signals=signal_names,
+        ics=ics,
+        shrunk_ics=shrunk,
+        correlation=correlation,
+        weights={s: float(w[i]) for i, s in enumerate(signal_names)},
+        combined_ic=ic_comb,
+        n_periods=n_periods,
+    )
+
+
+def _cross_section(bars, names, scorers, benchmark_bars, t, t_fwd, min_names):
+    """Per-signal score cross-section at ``t`` and the realized residual return to ``t_fwd``."""
+    bench_close = benchmark_bars["close"]
+    if t not in bench_close.index or t_fwd not in bench_close.index:
+        return None, None
+    bench_ret = bench_close.loc[t_fwd] / bench_close.loc[t] - 1.0
+
+    score_rows: Dict[str, Dict[str, float]] = {s: {} for s in scorers}
+    resid: Dict[str, float] = {}
+    for sym in names:
+        frame = bars[sym]
+        hist = frame.loc[frame.index <= t]
+        if len(hist) < 2 or t not in frame.index or t_fwd not in frame.index:
+            continue
+        for s, scorer in scorers.items():
+            val = scorer(hist)
+            if val is not None and not pd.isna(val):
+                score_rows[s][sym] = float(val)
+        r = frame["close"].loc[t_fwd] / frame["close"].loc[t] - 1.0
+        beta = indicators.calculate_beta(hist["close"], bench_close.loc[bench_close.index <= t])
+        resid[sym] = r - beta * bench_ret
+
+    scores = pd.DataFrame(score_rows)
+    fwd = pd.Series(resid)
+    common = scores.dropna().index.intersection(fwd.dropna().index)
+    if len(common) < min_names:
+        return None, None
+    return scores.loc[common], fwd.loc[common]
+
+
+def _to_ts(as_of: datetime, index: pd.Index) -> pd.Timestamp:
+    """Localize a possibly-naive ``as_of`` to a (possibly tz-aware) index's timezone."""
+    ts = pd.Timestamp(as_of)
+    if isinstance(index, pd.DatetimeIndex) and index.tz is not None:
+        ts = ts.tz_localize(index.tz) if ts.tzinfo is None else ts.tz_convert(index.tz)
+    return ts
+
+
+def _empty_measurement(signal_names: List[str]) -> SignalMeasurement:
+    return SignalMeasurement(
+        signals=signal_names,
+        ics={s: 0.0 for s in signal_names},
+        shrunk_ics={s: 0.0 for s in signal_names},
+        correlation=pd.DataFrame(np.eye(len(signal_names)), index=signal_names, columns=signal_names),
+        weights={s: 0.0 for s in signal_names},
+        combined_ic=0.0,
+        n_periods=0,
+    )
+
+
+def combined_score(bars, scorers, measurement: SignalMeasurement, as_of: datetime) -> pd.Series:
+    """Score each name with every signal at ``as_of`` and combine by the GLS weights."""
+    names = [s for s in bars if not bars[s].empty]
+    rows: Dict[str, Dict[str, float]] = {s: {} for s in scorers}
+    for sym in names:
+        frame = bars[sym]
+        for s, scorer in scorers.items():
+            val = scorer(frame)
+            if val is not None and not pd.isna(val):
+                rows[s][sym] = float(val)
+    score_frame = pd.DataFrame(rows).reindex(columns=measurement.signals)
+    weights = np.array([measurement.weights[s] for s in measurement.signals])
+    return combine_scores(score_frame.dropna(), weights)