zipoop 0.2.0__tar.gz → 0.2.1__tar.gz

{zipoop-0.2.0/zipoop.egg-info → zipoop-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zipoop
-Version: 0.2.0
+Version: 0.2.1
 Summary: Decoder and reader for Zipoop teacher shards (per-window neural compression of ENCODE signal tracks), v3 and v4 archives
 Author: zatumout
 License-Expression: MIT
@@ -48,6 +48,8 @@ zipoop show   /path/to/weights_npz chr21_10027008_10059776
 
 Lower level: `Dataset.read(window)` gives the parsed `Shard`, `Decoder(shard).decode(start, end, tracks)` decodes any slice or track subset. Evaluation helpers (`window_pearson`, `summarize`, `calibrate`, `restore_real`) are in `zipoop.evaluation`.
 
+`zipoop.evaluation.subwindow_metrics(pred, target, valid, subwindow=32768)` is the evaluator frozen in the D5 pipeline: it splits the length axis into contiguous sub-windows (4 x 32,768 bp inside a 131,072 bp segment) and returns `pearson` / `proj` / `nmse` / `total_err` / `eligible` arrays of shape (sub-windows, tracks), with the same clamps and the same eligibility rule (at least 2 observed positions and a non-constant target). The aggregation used by the frozen pipeline is the mean Pearson over eligible pairs and the median `proj` / `nmse`.
+
 Rules baked into `load_window` (see `zipoop/teacher.py`): RNA-seq tracks are 0 and valid where unrecorded; other tracks stay missing there. Opening a chromosome file parses its whole zip directory (chr1 about 3.6 s and 0.9 GB), so keep the `Dataset` open; forked DataLoader workers reopen their own handles.
 
 ## Supported formats

{zipoop-0.2.0 → zipoop-0.2.1}/README.md

@@ -28,6 +28,8 @@ zipoop show   /path/to/weights_npz chr21_10027008_10059776
 
 Lower level: `Dataset.read(window)` gives the parsed `Shard`, `Decoder(shard).decode(start, end, tracks)` decodes any slice or track subset. Evaluation helpers (`window_pearson`, `summarize`, `calibrate`, `restore_real`) are in `zipoop.evaluation`.
 
+`zipoop.evaluation.subwindow_metrics(pred, target, valid, subwindow=32768)` is the evaluator frozen in the D5 pipeline: it splits the length axis into contiguous sub-windows (4 x 32,768 bp inside a 131,072 bp segment) and returns `pearson` / `proj` / `nmse` / `total_err` / `eligible` arrays of shape (sub-windows, tracks), with the same clamps and the same eligibility rule (at least 2 observed positions and a non-constant target). The aggregation used by the frozen pipeline is the mean Pearson over eligible pairs and the median `proj` / `nmse`.
+
 Rules baked into `load_window` (see `zipoop/teacher.py`): RNA-seq tracks are 0 and valid where unrecorded; other tracks stay missing there. Opening a chromosome file parses its whole zip directory (chr1 about 3.6 s and 0.9 GB), so keep the `Dataset` open; forked DataLoader workers reopen their own handles.
 
 ## Supported formats

{zipoop-0.2.0 → zipoop-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "zipoop"
-version = "0.2.0"
+version = "0.2.1"
 description = "Decoder and reader for Zipoop teacher shards (per-window neural compression of ENCODE signal tracks), v3 and v4 archives"
 readme = "README.md"
 requires-python = ">=3.11"

zipoop-0.2.1/tests/test_eval_subwindow.py

@@ -0,0 +1,67 @@
+"""Parity tests for zipoop.evaluation.subwindow_metrics against the frozen D5 evaluator."""
+import numpy as np
+import torch
+
+from zipoop.evaluation import subwindow_metrics
+
+
+def frozen_subwindow_metrics(p, y, m, N, W):
+    """Verbatim copy of the evaluator frozen in zipoop_32k1885_010_128k2rd_D5_frozen_20261017/d5_genome.py."""
+    out = {k: [] for k in ("pearson", "proj", "nmse", "total_err", "eligible")}
+    for k in range(N):
+        s = slice(k * W, (k + 1) * W)
+        mf = m[s].float(); n = mf.sum(0).clamp_min(1)
+        yc = (y[s] - (y[s] * mf).sum(0) / n) * mf; pc = (p[s] - (p[s] * mf).sum(0) / n) * mf
+        vy = yc.square().sum(0); yy = (y[s].square() * mf).sum(0)
+        out["pearson"].append((pc * yc).sum(0) / (pc.square().sum(0) * vy).clamp_min(1e-24).sqrt())
+        out["proj"].append((p[s] * y[s] * mf).sum(0) / yy.clamp_min(1e-30))
+        out["nmse"].append(((p[s] - y[s]).square() * mf).sum(0) / yy.clamp_min(1e-30))
+        out["total_err"].append(((p[s] * mf).sum(0) - (y[s] * mf).sum(0)).abs() / (y[s] * mf).sum(0).abs().clamp_min(1e-30))
+        out["eligible"].append((n >= 2) & (vy > 1e-12))
+    return {k: torch.stack(v).cpu().numpy() for k, v in out.items()}
+
+
+def test_matches_frozen_evaluator():
+    torch.manual_seed(0)
+    L, T, W, N = 4 * 256, 7, 256, 4
+    target = torch.randn(L, T)
+    pred = target * 0.9 + torch.randn(L, T) * 0.3
+    valid = torch.rand(L, T) > 0.2
+    valid[:W] = False                     # first sub-window has no observations
+    target[:, 3] = 1.0                    # a constant track must be ineligible
+
+    want = frozen_subwindow_metrics(pred, target, valid, N, W)
+    got = subwindow_metrics(pred, target, valid, subwindow=W)
+
+    assert set(want) == set(got)
+    for k in want:
+        assert got[k].shape == (N, T), (k, got[k].shape)
+        assert np.array_equal(got[k], want[k]) if got[k].dtype == bool else np.allclose(got[k], want[k], rtol=0, atol=0), k
+    assert not got["eligible"][0].any()
+    assert not got["eligible"][:, 3].any()
+
+
+def test_identity_prediction():
+    torch.manual_seed(1)
+    L, T, W = 2 * 128, 5, 128
+    target = torch.randn(L, T)
+    valid = torch.ones(L, T, dtype=torch.bool)
+    m = subwindow_metrics(target.clone(), target, valid, subwindow=W)
+    assert np.allclose(m["pearson"], 1.0)
+    assert np.allclose(m["proj"], 1.0)
+    assert np.allclose(m["nmse"], 0.0)
+    assert np.allclose(m["total_err"], 0.0)
+    assert m["eligible"].all()
+
+
+def test_accepts_numpy_and_validates_shape():
+    t = np.random.RandomState(0).randn(2 * 64, 3).astype(np.float32)
+    v = np.ones_like(t, dtype=bool)
+    m = subwindow_metrics(t, t, v, subwindow=64)
+    assert m["pearson"].shape == (2, 3)
+    try:
+        subwindow_metrics(t, t[:100], v, subwindow=64)
+    except ValueError:
+        pass
+    else:
+        raise AssertionError("shape mismatch must raise")

{zipoop-0.2.0 → zipoop-0.2.1}/zipoop/__init__.py

@@ -1,11 +1,11 @@
 """Zipoop: decoder and reader for the per-window teacher shards (merged per-chromosome npz)."""
 from .dataset import Dataset, verify
 from .decoder import Decoder
-from .evaluation import calibrate, restore_real, summarize, window_pearson
+from .evaluation import calibrate, restore_real, subwindow_metrics, summarize, window_pearson
 from .panel import panel_tracks, zero_tracks
 from .shard import Shard, read_shard
 from .teacher import TeacherWindow, load_window
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 __all__ = ["Dataset", "verify", "Decoder", "Shard", "read_shard", "TeacherWindow", "load_window",
-           "panel_tracks", "zero_tracks", "calibrate", "restore_real", "summarize", "window_pearson"]
+           "panel_tracks", "zero_tracks", "calibrate", "restore_real", "subwindow_metrics", "summarize", "window_pearson"]

{zipoop-0.2.0 → zipoop-0.2.1}/zipoop/evaluation.py

@@ -61,6 +61,59 @@ def window_pearson(pred, target, valid, window=WINDOW, chunk=256):
     return torch.cat(cols, 1)
 
 
+def subwindow_metrics(pred, target, valid, subwindow=WINDOW):
+    """Per (sub-window, track) metrics, the convention of the frozen D5 evaluator.
+
+    ``pred`` and ``target`` are (L, T) signals, ``valid`` the (L, T) observed-position mask; the length
+    axis is split into ``L // subwindow`` contiguous blocks (the D5 pipeline uses 4 x 32,768 bp inside a
+    131,072 bp segment). Returns a dict of numpy arrays with shape (sub-windows, tracks):
+
+    ``pearson``    masked 1 bp Pearson
+    ``proj``       projection ratio  sum(pred * target) / sum(target ** 2)
+    ``nmse``       sum((pred - target) ** 2) / sum(target ** 2)
+    ``total_err``  |sum(pred) - sum(target)| / |sum(target)|
+    ``eligible``   at least 2 observed positions and a non-constant target inside that sub-window
+
+    The percentages and clamps (1e-24, 1e-30) are the frozen evaluator's, unchanged.
+    """
+    if torch.is_tensor(pred):
+        pred = pred.detach()
+    else:
+        pred = torch.as_tensor(np.asarray(pred))
+    if torch.is_tensor(target):
+        target = target.detach()
+    else:
+        target = torch.as_tensor(np.asarray(target))
+    if torch.is_tensor(valid):
+        valid = valid.detach()
+    else:
+        valid = torch.as_tensor(np.asarray(valid))
+    if pred.shape != target.shape or pred.shape != valid.shape:
+        raise ValueError(f"shape mismatch: pred {tuple(pred.shape)}, target {tuple(target.shape)}, valid {tuple(valid.shape)}")
+    length, tracks = target.shape
+    if not 0 < subwindow <= length or length % subwindow:
+        raise ValueError(f"length {length} is not a multiple of subwindow {subwindow}")
+
+    pred = pred.float()
+    target = target.float()
+    out = {k: [] for k in ("pearson", "proj", "nmse", "total_err", "eligible")}
+    for k in range(length // subwindow):
+        s = slice(k * subwindow, (k + 1) * subwindow)
+        mf = valid[s].float()
+        n = mf.sum(0).clamp_min(1)
+        yc = (target[s] - (target[s] * mf).sum(0) / n) * mf
+        pc = (pred[s] - (pred[s] * mf).sum(0) / n) * mf
+        vy = yc.square().sum(0)
+        yy = (target[s].square() * mf).sum(0)
+        out["pearson"].append((pc * yc).sum(0) / (pc.square().sum(0) * vy).clamp_min(1e-24).sqrt())
+        out["proj"].append((pred[s] * target[s] * mf).sum(0) / yy.clamp_min(1e-30))
+        out["nmse"].append(((pred[s] - target[s]).square() * mf).sum(0) / yy.clamp_min(1e-30))
+        out["total_err"].append(((pred[s] * mf).sum(0) - (target[s] * mf).sum(0)).abs()
+                                / (target[s] * mf).sum(0).abs().clamp_min(1e-30))
+        out["eligible"].append((n >= 2) & (vy > 1e-12))
+    return {k: torch.stack(v).cpu().numpy() for k, v in out.items()}
+
+
 def summarize(p, tracks=None):
     """Mean/median over evaluable pairs, plus per-modality and per-window means."""
     tracks = panel_tracks() if tracks is None else tracks

{zipoop-0.2.0 → zipoop-0.2.1/zipoop.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zipoop
-Version: 0.2.0
+Version: 0.2.1
 Summary: Decoder and reader for Zipoop teacher shards (per-window neural compression of ENCODE signal tracks), v3 and v4 archives
 Author: zatumout
 License-Expression: MIT
@@ -48,6 +48,8 @@ zipoop show   /path/to/weights_npz chr21_10027008_10059776
 
 Lower level: `Dataset.read(window)` gives the parsed `Shard`, `Decoder(shard).decode(start, end, tracks)` decodes any slice or track subset. Evaluation helpers (`window_pearson`, `summarize`, `calibrate`, `restore_real`) are in `zipoop.evaluation`.
 
+`zipoop.evaluation.subwindow_metrics(pred, target, valid, subwindow=32768)` is the evaluator frozen in the D5 pipeline: it splits the length axis into contiguous sub-windows (4 x 32,768 bp inside a 131,072 bp segment) and returns `pearson` / `proj` / `nmse` / `total_err` / `eligible` arrays of shape (sub-windows, tracks), with the same clamps and the same eligibility rule (at least 2 observed positions and a non-constant target). The aggregation used by the frozen pipeline is the mean Pearson over eligible pairs and the median `proj` / `nmse`.
+
 Rules baked into `load_window` (see `zipoop/teacher.py`): RNA-seq tracks are 0 and valid where unrecorded; other tracks stay missing there. Opening a chromosome file parses its whole zip directory (chr1 about 3.6 s and 0.9 GB), so keep the `Dataset` open; forked DataLoader workers reopen their own handles.
 
 ## Supported formats

{zipoop-0.2.0 → zipoop-0.2.1}/zipoop.egg-info/SOURCES.txt

@@ -1,6 +1,7 @@
 LICENSE
 README.md
 pyproject.toml
+tests/test_eval_subwindow.py
 tests/test_v4_format.py
 tests/test_zipoop.py
 zipoop/__init__.py