From 01274c13c46fdac539fbf05a5400b9a146eb9af7 Mon Sep 17 00:00:00 2001
From: malteos
Date: Fri, 29 May 2026 10:08:04 +0200
Subject: [PATCH 1/3] feat: multi-model multi-label classify-warc output
`classify-warc` now scores each record against any number of fasttext
models in one pass, and any number of labels per model, instead of one
label from one model. `--model-repo`/`--model-file`/`--labels` are
parallel-list flags; `*` (the default for `--labels`) expands to every
label of that model via `model.get_labels()`. Output columns are
`score_` for a single model and `score_m_` for
multiple, so two models can share a label name (e.g. both GneissWeb
classifiers emit `__label__cc`) without colliding.
Also: `--overwrite` to replace an existing output instead of failing;
`--resume-from-output` validates the prior CSV's header is byte-equal
to the new run's schema (with a structured added/removed diff on
mismatch); per-label stats land in the sidecar as `score..*`.
---
README.md | 62 +++-
notebooks/compare_classifier_scores.ipynb | 120 ++++---
src/ccoa/classifier/fasttext.py | 25 +-
src/ccoa/commands/classify_warc.py | 321 +++++++++++++-----
src/ccoa/utils/reporting/summary.py | 103 +++---
tests/test_classify_warc.py | 377 ++++++++++++++++++++--
6 files changed, 786 insertions(+), 222 deletions(-)
diff --git a/README.md b/README.md
index 9d83065..134198b 100644
--- a/README.md
+++ b/README.md
@@ -31,9 +31,17 @@ uv run ccoa --help
`ccoa classify-warc` streams WARC files from S3 (or any fsspec URL),
extracts plain text from each response record with trafilatura, and
-applies a HuggingFace-hosted fasttext classifier. Per-record output is a
-CSV `URL,prediction_score,warc_filename,warc_record_index`; a one-shot score-distribution summary is
-logged at the end and written to a `.summary.csv` file.
+applies one or more HuggingFace-hosted fasttext classifiers in a single
+pass. Per-record output is a CSV with one `score_` column per
+requested label, between `URL` and the `warc_filename`/`warc_record_index`
+tail:
+
+```
+URL,score_,...,score_,warc_filename,warc_record_index
+```
+
+A per-column score-distribution summary is logged at the end and written
+to a `.summary.csv` file.
```bash
uv run ccoa classify-warc \
@@ -86,10 +94,37 @@ HTTPS gateway URL
(`https://data.commoncrawl.org/...`) with no credentials.
The default classifier is
-[`ibm-granite/GneissWeb.Sci_classifier`](https://huggingface.co/ibm-granite/GneissWeb.Sci_classifier)
-(`__label__science`). The first run downloads the ~4 GB model into the
-HuggingFace cache. Override with `--model-repo`, `--model-file`, and
-`--target-label`.
+[`ibm-granite/GneissWeb.Sci_classifier`](https://huggingface.co/ibm-granite/GneissWeb.Sci_classifier).
+Without `--labels` it emits both of the model's labels —
+`score___label__science` and `score___label__cc`, which sum to 1.0 per
+record. The first run downloads the ~4 GB model into the HuggingFace
+cache. Override with `--model-repo`, `--model-file`, and `--labels`.
+
+`--model-repo` and `--model-file` are list-valued and zipped positionally,
+so you can score against multiple classifiers in one pass:
+
+```bash
+uv run ccoa classify-warc \
+ --warc-paths 's3://commoncrawl/.../*.warc.gz' \
+ --model-repo ibm-granite/GneissWeb.Sci_classifier ibm-granite/GneissWeb.Quality_annotator \
+ --model-file fasttext_science.bin \
+ --output data/classified.csv
+```
+
+`--labels` is also list-valued (one entry per model). Each entry is a
+comma-separated list of labels (`"__label__science,__label__cc"`) or the
+literal `*` to use all of that model's labels (the default when `--labels`
+is omitted). Output columns are emitted in the order: models in CLI order,
+labels in the order given (or model-internal order for `*`).
+
+Column naming depends on whether the run has one model or many:
+
+- **Single model**: `score_` (e.g. `score___label__science`).
+- **Multiple models**: `score_m_`, where `` is the 0-based
+ CLI position of the model (e.g. `score_m0___label__science`,
+ `score_m1___label__hq`). This namespacing means two models can share a
+ label name — Sci_classifier and Quality_annotator both emit
+ `__label__cc` — without colliding.
`--output` accepts `-` for stdout, any local path, or any fsspec URL —
including `s3://bucket/key.csv`. S3 outputs use the same `--anonymous-s3`
@@ -133,11 +168,14 @@ uv run ccoa classify-warc \
--output data/classified__resume-2.csv
```
-The resume CSV must include the `warc_filename` and `warc_record_index`
-columns (the current output schema always does). Records matching that
-`(warc_filename, record_index)` pair are skipped on the new run; the
-new `--output` contains only the missing rows. Concatenate the two
-CSVs (drop the second header) to get a complete result.
+The resume CSV's header must match the new run's output schema
+**exactly** — same `score_` columns in the same order, between
+the leading `URL` and the trailing `warc_filename`/`warc_record_index`.
+Any drift (reorder, missing, extra) is rejected fast with a structured
+diff so a concatenation (drop the second header) yields a well-formed
+CSV. Records matching that `(warc_filename, record_index)` pair are
+skipped on the new run; the new `--output` contains only the missing
+rows.
With `--records-per-file-limit N` the limit is interpreted as the
**target total** per file (resumed + new). Files already at the target
diff --git a/notebooks/compare_classifier_scores.ipynb b/notebooks/compare_classifier_scores.ipynb
index b3558d2..caa0a5a 100644
--- a/notebooks/compare_classifier_scores.ipynb
+++ b/notebooks/compare_classifier_scores.ipynb
@@ -35,10 +35,10 @@
"id": "cell-01-imports",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:21.594052Z",
- "iopub.status.busy": "2026-05-26T10:15:21.593943Z",
- "iopub.status.idle": "2026-05-26T10:15:41.227039Z",
- "shell.execute_reply": "2026-05-26T10:15:41.226661Z"
+ "iopub.execute_input": "2026-05-28T19:40:08.502488Z",
+ "iopub.status.busy": "2026-05-28T19:40:08.502328Z",
+ "iopub.status.idle": "2026-05-28T19:40:19.488256Z",
+ "shell.execute_reply": "2026-05-28T19:40:19.487890Z"
}
},
"outputs": [
@@ -98,7 +98,7 @@
"source": [
"## 1. Load the score data\n",
"\n",
- "The output CSV schema is `URL,prediction_score,warc_filename,warc_record_index`; we only need `prediction_score` for distribution analysis.\n",
+ "The output CSV schema is `URL,score_,...,score_,warc_filename,warc_record_index` — one score column per model label. The cell below auto-detects available `score_*` columns and picks the first as `SCORE_COL`; change it (or extend `load_scores`) to compare other labels. Older single-column outputs (`prediction_score`) are accepted as a fallback so existing CSVs in `data/` still work.\n",
"\n",
"The focus crawl can be split across **multiple parts** when `--resume-from-output` was used to recover from a crash (e.g. `…_1m_scores.csv` for the first run plus `…_1m_scores__resume-2.csv` for the continuation). We auto-discover all parts matching `{focus name}_1m_scores*.csv` (filtering out the `.summary.csv` sidecars) and concatenate them into a single distribution.\n",
"\n",
@@ -113,13 +113,21 @@
"id": "cell-03-load",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:41.228341Z",
- "iopub.status.busy": "2026-05-26T10:15:41.228232Z",
- "iopub.status.idle": "2026-05-26T10:15:41.973842Z",
- "shell.execute_reply": "2026-05-26T10:15:41.973414Z"
+ "iopub.execute_input": "2026-05-28T19:40:19.489927Z",
+ "iopub.status.busy": "2026-05-28T19:40:19.489801Z",
+ "iopub.status.idle": "2026-05-28T19:40:20.224124Z",
+ "shell.execute_reply": "2026-05-28T19:40:20.223694Z"
}
},
"outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Score columns in baseline: ['prediction_score (legacy)']\n",
+ "Analysing: prediction_score\n"
+ ]
+ },
{
"name": "stdout",
"output_type": "stream",
@@ -136,9 +144,19 @@
}
],
"source": [
+ "# Auto-detect the score column to analyse. classify-warc now emits one\n",
+ "# `score_` column per model label; older outputs had a single\n",
+ "# `prediction_score`. Edit SCORE_COL to compare other labels.\n",
+ "_baseline_columns = pd.read_csv(BASELINE_CSV, nrows=0).columns.tolist()\n",
+ "SCORE_COLUMNS = [c for c in _baseline_columns if c.startswith(\"score_\")]\n",
+ "SCORE_COL = SCORE_COLUMNS[0] if SCORE_COLUMNS else \"prediction_score\"\n",
+ "print(f\"Score columns in baseline: {SCORE_COLUMNS or [SCORE_COL + ' (legacy)']}\")\n",
+ "print(f\"Analysing: {SCORE_COL}\")\n",
+ "\n",
+ "\n",
"def load_scores(csv_path: Path) -> pd.Series:\n",
- " \"\"\"Read the prediction_score column from a classify-warc output CSV.\"\"\"\n",
- " series = pd.read_csv(csv_path, usecols=[\"prediction_score\"])[\"prediction_score\"]\n",
+ " \"\"\"Read the `SCORE_COL` column from a classify-warc output CSV.\"\"\"\n",
+ " series = pd.read_csv(csv_path, usecols=[SCORE_COL])[SCORE_COL]\n",
" return series.astype(float)\n",
"\n",
"\n",
@@ -151,7 +169,9 @@
" is_toy = False\n",
" ratio = len(focus_scores) / max(len(baseline_scores), 1)\n",
" is_partial = ratio < 0.95\n",
- " per_part = \", \".join(f\"{p.name}: {len(s):,}\" for p, s in zip(FOCUS_CSVS, parts))\n",
+ " per_part = \", \".join(\n",
+ " f\"{p.name}: {len(s):,}\" for p, s in zip(FOCUS_CSVS, parts, strict=True)\n",
+ " )\n",
" print(\n",
" f\"{FOCUS_NAME}: {len(focus_scores):,} scores loaded from {len(FOCUS_CSVS)} \"\n",
" f\"file(s) ({ratio:.0%} of baseline size). Parts → {per_part}\"\n",
@@ -164,7 +184,7 @@
"else:\n",
" rng = np.random.default_rng(42)\n",
" noisy = baseline_scores.to_numpy() + 0.05 + rng.normal(0.0, 0.10, size=len(baseline_scores))\n",
- " focus_scores = pd.Series(np.clip(noisy, 0.0, 1.0), name=\"prediction_score\")\n",
+ " focus_scores = pd.Series(np.clip(noisy, 0.0, 1.0), name=SCORE_COL)\n",
" is_toy = True\n",
" is_partial = False\n",
" print(\n",
@@ -195,10 +215,10 @@
"id": "cell-05-stats",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:41.974946Z",
- "iopub.status.busy": "2026-05-26T10:15:41.974894Z",
- "iopub.status.idle": "2026-05-26T10:15:42.081238Z",
- "shell.execute_reply": "2026-05-26T10:15:42.080957Z"
+ "iopub.execute_input": "2026-05-28T19:40:20.225163Z",
+ "iopub.status.busy": "2026-05-28T19:40:20.225105Z",
+ "iopub.status.idle": "2026-05-28T19:40:20.333180Z",
+ "shell.execute_reply": "2026-05-28T19:40:20.332861Z"
}
},
"outputs": [
@@ -381,10 +401,10 @@
"id": "cell-07-hist",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:42.082323Z",
- "iopub.status.busy": "2026-05-26T10:15:42.082276Z",
- "iopub.status.idle": "2026-05-26T10:15:42.642052Z",
- "shell.execute_reply": "2026-05-26T10:15:42.641716Z"
+ "iopub.execute_input": "2026-05-28T19:40:20.334135Z",
+ "iopub.status.busy": "2026-05-28T19:40:20.334086Z",
+ "iopub.status.idle": "2026-05-28T19:40:20.602002Z",
+ "shell.execute_reply": "2026-05-28T19:40:20.601654Z"
}
},
"outputs": [
@@ -403,7 +423,7 @@
"fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharex=True)\n",
"bins = np.linspace(0.0, 1.0, 81)\n",
"\n",
- "for ax, log_scale in zip(axes, [False, True]):\n",
+ "for ax, log_scale in zip(axes, [False, True], strict=True):\n",
" ax.hist(baseline_scores, bins=bins, alpha=0.5, label=BASELINE_NAME, color=\"C0\", density=True)\n",
" ax.hist(focus_scores, bins=bins, alpha=0.5, label=FOCUS_NAME, color=\"C1\", density=True)\n",
" if log_scale:\n",
@@ -411,7 +431,7 @@
" ax.set_title(\"Histogram (log y, density-normalised)\")\n",
" else:\n",
" ax.set_title(\"Histogram (linear y, density-normalised)\")\n",
- " ax.set_xlabel(\"prediction_score\")\n",
+ " ax.set_xlabel(SCORE_COL)\n",
" ax.set_ylabel(\"density\")\n",
" ax.legend()\n",
" ax.grid(True, alpha=0.3)\n",
@@ -436,10 +456,10 @@
"id": "cell-09-ecdf",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:42.643283Z",
- "iopub.status.busy": "2026-05-26T10:15:42.643203Z",
- "iopub.status.idle": "2026-05-26T10:15:43.228237Z",
- "shell.execute_reply": "2026-05-26T10:15:43.227857Z"
+ "iopub.execute_input": "2026-05-28T19:40:20.602921Z",
+ "iopub.status.busy": "2026-05-28T19:40:20.602874Z",
+ "iopub.status.idle": "2026-05-28T19:40:21.206119Z",
+ "shell.execute_reply": "2026-05-28T19:40:21.205709Z"
}
},
"outputs": [
@@ -469,7 +489,7 @@
"]:\n",
" x, y = ecdf(series)\n",
" plt.plot(x, y, label=name, color=color)\n",
- "plt.xlabel(\"prediction_score\")\n",
+ "plt.xlabel(SCORE_COL)\n",
"plt.ylabel(\"ECDF P(score ≤ x)\")\n",
"plt.title(\"Empirical CDF of classifier scores\")\n",
"plt.legend()\n",
@@ -494,10 +514,10 @@
"id": "cell-11-box",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:43.229226Z",
- "iopub.status.busy": "2026-05-26T10:15:43.229167Z",
- "iopub.status.idle": "2026-05-26T10:15:43.929555Z",
- "shell.execute_reply": "2026-05-26T10:15:43.929175Z"
+ "iopub.execute_input": "2026-05-28T19:40:21.207200Z",
+ "iopub.status.busy": "2026-05-28T19:40:21.207147Z",
+ "iopub.status.idle": "2026-05-28T19:40:21.891974Z",
+ "shell.execute_reply": "2026-05-28T19:40:21.891665Z"
}
},
"outputs": [
@@ -519,14 +539,14 @@
"labels = [BASELINE_NAME, FOCUS_NAME]\n",
"\n",
"axes[0].boxplot(data, tick_labels=labels, showfliers=False)\n",
- "axes[0].set_ylabel(\"prediction_score\")\n",
+ "axes[0].set_ylabel(SCORE_COL)\n",
"axes[0].set_title(\"Box plot (outliers hidden)\")\n",
"axes[0].grid(True, alpha=0.3)\n",
"\n",
"axes[1].violinplot(data, showmedians=True)\n",
"axes[1].set_xticks([1, 2])\n",
"axes[1].set_xticklabels(labels)\n",
- "axes[1].set_ylabel(\"prediction_score\")\n",
+ "axes[1].set_ylabel(SCORE_COL)\n",
"axes[1].set_title(\"Violin plot\")\n",
"axes[1].grid(True, alpha=0.3)\n",
"\n",
@@ -552,10 +572,10 @@
"id": "cell-13-qq",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:43.930547Z",
- "iopub.status.busy": "2026-05-26T10:15:43.930496Z",
- "iopub.status.idle": "2026-05-26T10:15:44.006062Z",
- "shell.execute_reply": "2026-05-26T10:15:44.005773Z"
+ "iopub.execute_input": "2026-05-28T19:40:21.893014Z",
+ "iopub.status.busy": "2026-05-28T19:40:21.892965Z",
+ "iopub.status.idle": "2026-05-28T19:40:21.973772Z",
+ "shell.execute_reply": "2026-05-28T19:40:21.973431Z"
}
},
"outputs": [
@@ -611,10 +631,10 @@
"id": "cell-15-tests",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:44.007069Z",
- "iopub.status.busy": "2026-05-26T10:15:44.007022Z",
- "iopub.status.idle": "2026-05-26T10:15:44.240328Z",
- "shell.execute_reply": "2026-05-26T10:15:44.239994Z"
+ "iopub.execute_input": "2026-05-28T19:40:21.974787Z",
+ "iopub.status.busy": "2026-05-28T19:40:21.974737Z",
+ "iopub.status.idle": "2026-05-28T19:40:22.210867Z",
+ "shell.execute_reply": "2026-05-28T19:40:22.210554Z"
}
},
"outputs": [
@@ -714,10 +734,10 @@
"id": "cell-17-effect",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:44.241419Z",
- "iopub.status.busy": "2026-05-26T10:15:44.241371Z",
- "iopub.status.idle": "2026-05-26T10:15:44.262566Z",
- "shell.execute_reply": "2026-05-26T10:15:44.262191Z"
+ "iopub.execute_input": "2026-05-28T19:40:22.211857Z",
+ "iopub.status.busy": "2026-05-28T19:40:22.211810Z",
+ "iopub.status.idle": "2026-05-28T19:40:22.233262Z",
+ "shell.execute_reply": "2026-05-28T19:40:22.232953Z"
}
},
"outputs": [
@@ -831,10 +851,10 @@
"id": "cell-19-verdict",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-05-26T10:15:44.263522Z",
- "iopub.status.busy": "2026-05-26T10:15:44.263466Z",
- "iopub.status.idle": "2026-05-26T10:15:44.283675Z",
- "shell.execute_reply": "2026-05-26T10:15:44.283399Z"
+ "iopub.execute_input": "2026-05-28T19:40:22.234289Z",
+ "iopub.status.busy": "2026-05-28T19:40:22.234236Z",
+ "iopub.status.idle": "2026-05-28T19:40:22.254388Z",
+ "shell.execute_reply": "2026-05-28T19:40:22.254084Z"
}
},
"outputs": [
diff --git a/src/ccoa/classifier/fasttext.py b/src/ccoa/classifier/fasttext.py
index bc22c28..7ce3825 100644
--- a/src/ccoa/classifier/fasttext.py
+++ b/src/ccoa/classifier/fasttext.py
@@ -2,12 +2,13 @@
from __future__ import annotations
+from collections.abc import Sequence
+
import fasttext as _fasttext
from huggingface_hub import hf_hub_download
DEFAULT_MODEL_REPO = "ibm-granite/GneissWeb.Sci_classifier"
DEFAULT_MODEL_FILE = "fasttext_science.bin"
-DEFAULT_TARGET_LABEL = "__label__science"
FASTTEXT_MAX_INPUT_CHARS = 100_000
@@ -36,17 +37,19 @@ def clean_for_fasttext(text: str, max_len: int = FASTTEXT_MAX_INPUT_CHARS) -> st
return cleaned
-def predict_target(model, text: str, target_label: str) -> float:
- """Return the probability the model assigns to `target_label`.
+def predict_targets(model, text: str, target_labels: Sequence[str]) -> list[float]:
+ """Return probabilities for `target_labels` in the order given.
- Cleans the input via `clean_for_fasttext` (strip newlines + NULs, clamp
- length), then asks the model for probabilities over all labels and
- returns the probability of `target_label` (0.0 if the model emits no
- such label).
+ `model.predict(..., k=-1)` returns labels in descending probability order
+ (data-dependent), so we resolve scores by label name. Missing labels
+ yield 0.0.
"""
cleaned = clean_for_fasttext(text)
labels, probs = model.predict(cleaned, k=-1)
- for lbl, prob in zip(labels, probs, strict=False):
- if lbl == target_label:
- return float(prob)
- return 0.0
+ label_to_prob = dict(zip(labels, probs, strict=False))
+ return [float(label_to_prob.get(lbl, 0.0)) for lbl in target_labels]
+
+
+def get_model_labels(model) -> tuple[str, ...]:
+ """Return all labels the model can emit, in model-internal order."""
+ return tuple(model.get_labels())
diff --git a/src/ccoa/commands/classify_warc.py b/src/ccoa/commands/classify_warc.py
index 2e67d0e..067573d 100644
--- a/src/ccoa/commands/classify_warc.py
+++ b/src/ccoa/commands/classify_warc.py
@@ -1,12 +1,13 @@
-"""Classify WARC response records with a fasttext model.
+"""Classify WARC response records with one or more fasttext models.
-Streams one or more WARC files from S3 (or any fsspec URL), extracts
-plain text from each `response` record with trafilatura, and applies
-a HuggingFace-hosted fasttext classifier. Per-record output is a CSV
-`URL,prediction_score,warc_filename,warc_record_index` written to
-stdout, a local path, or an `s3://` URL (anything `fsspec.open`
-understands); a one-shot summary of the score distribution is logged
-at the end and written to a `.summary.csv` sidecar.
+Streams WARC files from S3 (or any fsspec URL), extracts plain text from
+each `response` record with trafilatura, and applies one or more
+HuggingFace-hosted fasttext classifiers in a single pass. Per-record
+output is a CSV `URL,score_,...,score_,warc_filename,
+warc_record_index` written to stdout, a local path, or an `s3://` URL
+(anything `fsspec.open` understands). A one-shot per-column summary of
+each score distribution is logged at the end and written to a
+`.summary.csv` sidecar.
Example:
```bash
@@ -19,7 +20,9 @@
```
The default model (`ibm-granite/GneissWeb.Sci_classifier`) is ~4 GB;
-the first run will download it into the HuggingFace cache.
+the first run will download it into the HuggingFace cache. Without
+`--labels`, all labels of each model are emitted (the science model
+contributes `score___label__science` and `score___label__cc`).
"""
from __future__ import annotations
@@ -40,9 +43,9 @@
from ccoa.classifier.fasttext import (
DEFAULT_MODEL_FILE,
DEFAULT_MODEL_REPO,
- DEFAULT_TARGET_LABEL,
+ get_model_labels,
load_classifier,
- predict_target,
+ predict_targets,
)
from ccoa.commands import BaseCommand
from ccoa.extraction.cache import (
@@ -70,33 +73,98 @@
logger = logging.getLogger(__name__)
-_WORKER_MODEL: object = None
+# Per-process state. In thread mode, the parent populates `_WORKER_MODELS`
+# directly. In process mode, each worker's initializer rebuilds it from the
+# spec the parent pickled into the pool's `initargs`.
+_WORKER_MODELS: list[tuple[object, list[str]]] = []
_WORKER_LOCK = threading.Lock()
+_LABELS_ALL = "*"
+
+
+def _resolve_model_slots(
+ model_repos: list[str],
+ model_files: list[str],
+ labels: list[str],
+) -> list[tuple[str, str, list[str]]]:
+ """Pair `--model-repo`/`--model-file`/`--labels` into `(repo, file, label_spec)` slots.
+
+ `label_spec` is either `["*"]` (resolve to all of the model's labels at
+ load time) or an explicit ordered list. Raises `ValueError` for mismatched
+ list lengths or empty CLI input without a default fallback.
+ """
+ if not model_repos and not model_files:
+ model_repos = [DEFAULT_MODEL_REPO]
+ model_files = [DEFAULT_MODEL_FILE]
+ if len(model_repos) != len(model_files):
+ raise ValueError(
+ f"--model-repo and --model-file must have the same length; "
+ f"got {len(model_repos)} repo(s) and {len(model_files)} file(s)."
+ )
+ if not labels:
+ labels = [_LABELS_ALL] * len(model_repos)
+ if len(labels) != len(model_repos):
+ raise ValueError(
+ f"--labels must have one entry per --model-repo (or be omitted "
+ f"to default to '*' for every model); got {len(labels)} entries "
+ f"for {len(model_repos)} model(s)."
+ )
+
+ slots: list[tuple[str, str, list[str]]] = []
+ for repo, file, label_spec in zip(model_repos, model_files, labels, strict=True):
+ if label_spec == _LABELS_ALL:
+ resolved = [_LABELS_ALL]
+ else:
+ resolved = [s.strip() for s in label_spec.split(",") if s.strip()]
+ if not resolved:
+ raise ValueError(
+ f"--labels entry for model {repo}/{file} is empty; "
+ f"use '*' (all labels) or a comma-separated list."
+ )
+ slots.append((repo, file, resolved))
+ return slots
+
+
def load_resume_skipset(
path: str,
storage_options: dict[str, object],
+ expected_header: list[str],
) -> dict[str, frozenset[int]]:
"""Build `{warc_filename: frozenset(record_indices)}` from a prior output CSV.
Used by `--resume-from-output` to skip records already classified. The
- input must have `warc_filename` and `warc_record_index` columns (which
- the current output schema always emits); a `ValueError` is raised
- otherwise to flag stale outputs from the pre-resume schema.
+ file's header MUST equal `expected_header` exactly — same columns in the
+ same order — so a concatenation of the prior CSV and the new `--output`
+ yields a well-formed file. Any drift (added columns, removed columns,
+ reorder) raises `ValueError` with a structured diff.
"""
- required = {"warc_filename", "warc_record_index"}
- buckets: dict[str, set[int]] = {}
with fsspec.open(path, "r", encoding="utf-8", **storage_options) as fh:
reader = csv.DictReader(fh)
- fields = set(reader.fieldnames or [])
- if not required.issubset(fields):
- missing = required - fields
+ actual = list(reader.fieldnames or [])
+ if actual != expected_header:
+ actual_set = set(actual)
+ expected_set = set(expected_header)
+ missing = expected_set - actual_set
+ extra = actual_set - expected_set
+ score_cols = [c for c in actual if c.startswith("score_")]
+ if not score_cols:
+ raise ValueError(
+ f"{path} has no `score_*` columns; this looks like a "
+ f"pre-multi-label CSV and is not resumable with the "
+ f"current --model-repo/--model-file/--labels selection. "
+ f"Found header: {actual}; expected: {expected_header}."
+ )
raise ValueError(
- f"{path} is missing required columns for --resume-from-output: "
- f"need {sorted(required)}, missing {sorted(missing)} "
- f"(found {sorted(fields)})."
+ f"{path} header does not match the planned output schema. "
+ f"Pass --model-repo/--model-file/--labels so the new run "
+ f"produces the same columns in the same order.\n"
+ f" expected: {expected_header}\n"
+ f" actual: {actual}\n"
+ f" missing: {sorted(missing)}\n"
+ f" extra: {sorted(extra)}"
)
+ buckets: dict[str, set[int]] = {}
for row in reader:
warc = row["warc_filename"]
try:
@@ -111,12 +179,13 @@ def load_resume_skipset(
class FileResult:
"""Aggregated per-file outcome returned by `process_one_file`.
- Each entry in `rows` is `(url, score, warc_filename, warc_record_index)`,
- matching the output CSV schema.
+ Each entry in `rows` is `(url, scores, warc_filename, warc_record_index)`,
+ where `scores` is a list of probabilities matching `args.score_columns`
+ in order (one entry per `score_` column).
"""
uri: str
- rows: list[tuple[str, float, str, int]]
+ rows: list[tuple[str, list[float], str, int]]
processed: int
skipped_empty: int
skipped_homepage: int
@@ -130,7 +199,7 @@ class FileResult:
def process_one_file(
uri: str,
- model,
+ models_spec: list[tuple[object, list[str]]],
model_lock: threading.Lock,
args: argparse.Namespace,
skip_indices: frozenset[int] = frozenset(),
@@ -139,11 +208,11 @@ def process_one_file(
Owns its own fsspec input stream, its own per-WARC cache load/save
(when `--cache-dir` is set), and its own `--records-per-file-limit`
- counter. Calls `predict_target` under `model_lock` since fasttext
- makes no thread-safety guarantees; the lock cost is sub-ms
- compared to the per-record extract cost.
+ counter. Holds `model_lock` across every `predict_targets` call (one
+ per model) since fasttext makes no thread-safety guarantees; the lock
+ cost is sub-ms compared to the per-record extract cost.
"""
- rows: list[tuple[str, float, str, int]] = []
+ rows: list[tuple[str, list[float], str, int]] = []
processed = 0
skipped_empty = 0
skipped_homepage = 0
@@ -245,11 +314,13 @@ def process_one_file(
continue
t0 = time.perf_counter()
+ scores: list[float] = []
with model_lock:
- score = predict_target(model, cleaned, args.target_label)
+ for model, target_labels in models_spec:
+ scores.extend(predict_targets(model, cleaned, target_labels))
t_predict += time.perf_counter() - t0
- rows.append((url, score, uri, record_index))
+ rows.append((url, scores, uri, record_index))
processed += 1
if progress_every and processed % progress_every == 0:
@@ -293,15 +364,21 @@ def process_one_file(
)
-def _process_pool_initializer(model_repo: str, model_file: str) -> None:
- """Per-worker setup for `ProcessPoolExecutor`: load the model once.
+def _process_pool_initializer(
+ spec: list[tuple[str, str, list[str]]],
+) -> None:
+ """Per-worker setup for `ProcessPoolExecutor`: load every model once.
+
+ `spec` is `[(repo, file, resolved_labels), ...]` in CLI order. The parent
+ resolved any `'*'` placeholders to actual label lists before pickling, so
+ workers reuse that exact label vocabulary and column ordering.
Also silences trafilatura's chatty per-page WARN/ERROR logs in this
worker. Each worker process has its own lxml + fasttext state, so a
heap-corruption abort here cannot tear down the parent or its peers.
"""
- global _WORKER_MODEL # noqa: PLW0603
- _WORKER_MODEL = load_classifier(model_repo, model_file)
+ global _WORKER_MODELS # noqa: PLW0603
+ _WORKER_MODELS = [(load_classifier(repo, file), labels) for repo, file, labels in spec]
logging.getLogger("trafilatura").setLevel(logging.CRITICAL)
@@ -310,7 +387,7 @@ def _process_pool_worker(
) -> FileResult:
"""Top-level pickleable adapter that runs `process_one_file` in a worker."""
uri, args, skip_indices = payload
- return process_one_file(uri, _WORKER_MODEL, _WORKER_LOCK, args, skip_indices)
+ return process_one_file(uri, _WORKER_MODELS, _WORKER_LOCK, args, skip_indices)
class ClassifyWarcCommand(BaseCommand):
@@ -382,20 +459,39 @@ def add_arguments(self, parser: argparse.ArgumentParser) -> None:
)
parser.add_argument(
"--model-repo",
- default=DEFAULT_MODEL_REPO,
- help=f"HuggingFace repo id of the fasttext model (default: {DEFAULT_MODEL_REPO}).",
+ nargs="*",
+ default=[],
+ metavar="REPO",
+ help=(
+ "HuggingFace repo id(s) of the fasttext model(s). Repeatable; "
+ "must have the same length as --model-file. When both --model-repo "
+ "and --model-file are omitted, falls back to "
+ f"{DEFAULT_MODEL_REPO}/{DEFAULT_MODEL_FILE}."
+ ),
)
parser.add_argument(
"--model-file",
- default=DEFAULT_MODEL_FILE,
- help=f"Filename of the .bin model inside the repo (default: {DEFAULT_MODEL_FILE}).",
+ nargs="*",
+ default=[],
+ metavar="FILE",
+ help=(
+ "Filename(s) of the .bin model inside each repo, positionally "
+ "paired with --model-repo (same length)."
+ ),
)
parser.add_argument(
- "--target-label",
- default=DEFAULT_TARGET_LABEL,
+ "--labels",
+ nargs="*",
+ default=[],
+ metavar="LABELS",
help=(
- "Label whose probability is written as 'prediction_score' "
- f"(default: {DEFAULT_TARGET_LABEL})."
+ "Per-model label filter, positionally paired with --model-repo. "
+ "Each entry is a comma-separated list of fasttext labels "
+ "(e.g. '__label__science,__label__cc'), or the literal '*' to "
+ "use all labels of that model (the default when --labels is "
+ "omitted entirely). Output columns are `score_` in the "
+ "order: models in CLI order, labels in the order given (or in "
+ "model-internal order for '*')."
),
)
parser.add_argument(
@@ -481,6 +577,14 @@ def add_arguments(self, parser: argparse.ArgumentParser) -> None:
"throughput this is roughly one line per ~40s of CPU work."
),
)
+ parser.add_argument(
+ "--overwrite",
+ action="store_true",
+ help=(
+ "Overwrite an existing --output (and its `.summary` sidecar) "
+ "instead of failing fast. Off by default to protect prior runs."
+ ),
+ )
parser.add_argument(
"--anonymous-s3",
action="store_true",
@@ -507,6 +611,12 @@ def run(self, args: argparse.Namespace) -> int:
)
return 2
+ try:
+ model_slots = _resolve_model_slots(args.model_repo, args.model_file, args.labels)
+ except ValueError as exc:
+ logger.error("%s", exc)
+ return 2
+
output_storage_options = s3_storage_options(
args.output, args.anonymous_s3, args.s3_requester_pays
)
@@ -522,12 +632,16 @@ def run(self, args: argparse.Namespace) -> int:
(summary_uri, summary_storage_options),
):
if output_exists(path, opts):
- logger.error(
- "Output already exists: %s. Refusing to overwrite; "
- "delete the file(s) or pick a fresh --output path.",
- path,
- )
- return 2
+ if args.overwrite:
+ logger.warning("Overwriting existing output: %s", path)
+ else:
+ logger.error(
+ "Output already exists: %s. Refusing to overwrite; "
+ "delete the file(s), pick a fresh --output path, or "
+ "pass --overwrite to replace them.",
+ path,
+ )
+ return 2
logger.info("Resolving WARC paths: %s", args.warc_paths)
@@ -550,16 +664,70 @@ def run(self, args: argparse.Namespace) -> int:
if not resolved:
logger.warning("No WARC files matched --warc-paths; nothing to classify.")
- log_summary([])
+ log_summary({})
return 0
+ # Load each model once in the parent so we can resolve `*` label slots
+ # via `get_model_labels` and freeze the global column order BEFORE any
+ # workers start. In thread mode and --workers 1 the parent's models are
+ # reused for scoring; in process mode they're freed and each worker
+ # reloads them from the same `resolved_spec`.
+ runtime_models: list[tuple[object, list[str]]] = []
+ resolved_spec: list[tuple[str, str, list[str]]] = []
+ for repo, file, label_spec in model_slots:
+ logger.info("Loading model %s/%s", repo, file)
+ model_obj = load_classifier(repo, file)
+ if label_spec == [_LABELS_ALL]:
+ labels = list(get_model_labels(model_obj))
+ else:
+ labels = list(label_spec)
+ resolved_spec.append((repo, file, labels))
+ runtime_models.append((model_obj, labels))
+ logger.info(" resolved labels for %s/%s: %s", repo, file, labels)
+
+ # Single model: `score_` keeps the CSV clean. Multiple models:
+ # `score_m_` so each model's labels live in their own
+ # namespace (e.g. both Sci_classifier and Quality_annotator emit
+ # `__label__cc`, which would otherwise collide).
+ score_columns: list[str] = []
+ seen_columns: dict[str, tuple[str, str]] = {}
+ multi_model = len(resolved_spec) > 1
+ for idx, (repo, file, labels) in enumerate(resolved_spec):
+ prefix = f"score_m{idx}_" if multi_model else "score_"
+ for lbl in labels:
+ col = f"{prefix}{lbl}"
+ if col in seen_columns:
+ prev_repo, prev_file = seen_columns[col]
+ logger.error(
+ "Column %s would come from both %s/%s and %s/%s. "
+ "Same model+label listed twice?",
+ col,
+ prev_repo,
+ prev_file,
+ repo,
+ file,
+ )
+ return 2
+ seen_columns[col] = (repo, file)
+ score_columns.append(col)
+ args.score_columns = score_columns
+ logger.info("Output score columns (%d): %s", len(score_columns), score_columns)
+
+ expected_header = ["URL", *score_columns, "warc_filename", "warc_record_index"]
+
skip_by_warc: dict[str, frozenset[int]] = {}
if args.resume_from_output:
resume_storage_options = s3_storage_options(
args.resume_from_output, args.anonymous_s3, args.s3_requester_pays
)
logger.info("Loading resume skip-set from %s", args.resume_from_output)
- skip_by_warc = load_resume_skipset(args.resume_from_output, resume_storage_options)
+ try:
+ skip_by_warc = load_resume_skipset(
+ args.resume_from_output, resume_storage_options, expected_header
+ )
+ except ValueError as exc:
+ logger.error("%s", exc)
+ return 2
total_skips = sum(len(v) for v in skip_by_warc.values())
logger.info(
"Resume skip-set: %d records across %d distinct WARCs.",
@@ -568,20 +736,14 @@ def run(self, args: argparse.Namespace) -> int:
)
use_process_pool = args.workers > 1 and args.workers_mode == "process"
+ model_lock = threading.Lock()
if use_process_pool:
logger.info(
- "Worker mode 'process'; deferring model load to each of "
- "%d worker processes (model: %s/%s).",
+ "Worker mode 'process'; freeing parent-side models and deferring "
+ "load to each of %d worker processes.",
args.workers,
- args.model_repo,
- args.model_file,
)
- model = None
- model_lock = threading.Lock()
- else:
- logger.info("Loading model %s/%s", args.model_repo, args.model_file)
- model = load_classifier(args.model_repo, args.model_file)
- model_lock = threading.Lock()
+ runtime_models = []
# Silence trafilatura's per-page WARN/ERROR noise (empty / non-HTML /
# bad-encoding pages) — these outcomes already land in `skipped_empty`.
@@ -592,7 +754,7 @@ def run(self, args: argparse.Namespace) -> int:
traf_prev_propagate = traf_logger.propagate
traf_logger.propagate = False
- scores: list[float] = []
+ scores_by_column: dict[str, list[float]] = {col: [] for col in score_columns}
processed = 0
skipped_empty = 0
skipped_homepage = 0
@@ -614,7 +776,7 @@ def run(self, args: argparse.Namespace) -> int:
t_processing_start = time.perf_counter()
with open_output_sink(args.output, output_storage_options) as sink:
writer = csv.writer(sink)
- writer.writerow(["URL", "prediction_score", "warc_filename", "warc_record_index"])
+ writer.writerow(expected_header)
def _aggregate(result: FileResult) -> None:
"""Write `result` rows to the CSV and fold its counters into the totals."""
@@ -622,9 +784,12 @@ def _aggregate(result: FileResult) -> None:
nonlocal skipped_resume_total, extract_errors_total
nonlocal cache_hits_total, cache_misses_total
nonlocal t_extract_total, t_predict_total, files_done
- for url, score, warc_filename, record_index in result.rows:
- writer.writerow([url, f"{score:.6f}", warc_filename, record_index])
- scores.append(score)
+ for url, scores, warc_filename, record_index in result.rows:
+ writer.writerow(
+ [url, *(f"{s:.6f}" for s in scores), warc_filename, record_index]
+ )
+ for col, s in zip(score_columns, scores, strict=True):
+ scores_by_column[col].append(s)
if sink is sys.stdout:
sink.flush()
processed += result.processed
@@ -663,7 +828,11 @@ def _aggregate(result: FileResult) -> None:
for uri in resolved:
_aggregate(
process_one_file(
- uri, model, model_lock, args, skip_by_warc.get(uri, empty_skip)
+ uri,
+ runtime_models,
+ model_lock,
+ args,
+ skip_by_warc.get(uri, empty_skip),
)
)
if limit and processed >= limit:
@@ -679,7 +848,7 @@ def _aggregate(result: FileResult) -> None:
with ProcessPoolExecutor(
max_workers=args.workers,
initializer=_process_pool_initializer,
- initargs=(args.model_repo, args.model_file),
+ initargs=(resolved_spec,),
) as pool:
payloads = [
(u, args, skip_by_warc.get(u, empty_skip)) for u in remaining_uris
@@ -723,7 +892,11 @@ def _aggregate(result: FileResult) -> None:
with ThreadPoolExecutor(max_workers=args.workers) as pool:
for result in pool.map(
lambda u: process_one_file(
- u, model, model_lock, args, skip_by_warc.get(u, empty_skip)
+ u,
+ runtime_models,
+ model_lock,
+ args,
+ skip_by_warc.get(u, empty_skip),
),
resolved,
):
@@ -746,7 +919,7 @@ def _aggregate(result: FileResult) -> None:
cache_hits_total,
cache_misses_total,
)
- log_summary(scores)
+ log_summary(scores_by_column)
log_timing(processed, t_processing, t_extract_total, t_predict_total)
if traf_counter.warnings or traf_counter.errors:
@@ -763,7 +936,7 @@ def _aggregate(result: FileResult) -> None:
summary_storage_options,
args=args,
resolved_count=len(resolved),
- scores=scores,
+ scores_by_column=scores_by_column,
processed=processed,
skipped_empty=skipped_empty,
skipped_homepage=skipped_homepage,
diff --git a/src/ccoa/utils/reporting/summary.py b/src/ccoa/utils/reporting/summary.py
index 8aafb00..05d1008 100644
--- a/src/ccoa/utils/reporting/summary.py
+++ b/src/ccoa/utils/reporting/summary.py
@@ -103,29 +103,39 @@ def compute_score_stats(scores: list[float]) -> dict[str, float | int | str]:
return stats
-def log_summary(scores: list[float]) -> None:
- """Log a one-line summary of the score distribution (count, percentiles, etc.)."""
- if not scores:
+def log_summary(scores_by_column: dict[str, list[float]]) -> None:
+ """Log one INFO line per score column with count/percentiles/mean.
+
+ `scores_by_column` is keyed by output column name (e.g. `score___label__science`)
+ and preserves insertion order. An empty dict, or one whose every value list
+ is empty, logs a single warning instead.
+ """
+ if not scores_by_column or not any(scores_by_column.values()):
logger.warning("No records classified.")
return
- stats = compute_score_stats(scores)
- logger.info(
- "score stats — count=%d min=%s p10=%s p25=%s p50=%s p75=%s p90=%s p95=%s p99=%s max=%s mean=%s median=%s stdev=%s",
- stats["count"],
- format_score(stats["min"]),
- format_score(stats["p10"]),
- format_score(stats["p25"]),
- format_score(stats["p50"]),
- format_score(stats["p75"]),
- format_score(stats["p90"]),
- format_score(stats["p95"]),
- format_score(stats["p99"]),
- format_score(stats["max"]),
- format_score(stats["mean"]),
- format_score(stats["median"]),
- format_score(stats["stdev"]),
- )
+ for column, scores in scores_by_column.items():
+ if not scores:
+ logger.warning("No scores collected for %s.", column)
+ continue
+ stats = compute_score_stats(scores)
+ logger.info(
+ "score stats [%s] — count=%d min=%s p10=%s p25=%s p50=%s p75=%s p90=%s p95=%s p99=%s max=%s mean=%s median=%s stdev=%s",
+ column,
+ stats["count"],
+ format_score(stats["min"]),
+ format_score(stats["p10"]),
+ format_score(stats["p25"]),
+ format_score(stats["p50"]),
+ format_score(stats["p75"]),
+ format_score(stats["p90"]),
+ format_score(stats["p95"]),
+ format_score(stats["p99"]),
+ format_score(stats["max"]),
+ format_score(stats["mean"]),
+ format_score(stats["median"]),
+ format_score(stats["stdev"]),
+ )
def write_run_summary(
@@ -134,7 +144,7 @@ def write_run_summary(
*,
args: argparse.Namespace,
resolved_count: int,
- scores: list[float],
+ scores_by_column: dict[str, list[float]],
processed: int,
skipped_empty: int,
skipped_homepage: int,
@@ -153,9 +163,10 @@ def write_run_summary(
"""Write a sidecar two-column CSV (`key,value`) capturing inputs + results.
Sections (by key prefix): `run.*` (cli + timestamps), `arg.*` (every CLI flag),
- `input.*` (resolved files), `count.*` (record counters), `score.*` (stats from
- `compute_score_stats`), `time.*` (wall-clock / extract / predict). Designed to
- be parsed back with `csv.reader` or `pandas.read_csv`.
+ `input.*` (resolved files), `count.*` (record counters),
+ `score..*` (per-column stats from `compute_score_stats`),
+ `time.*` (wall-clock / extract / predict). Designed to be parsed back with
+ `csv.reader` or `pandas.read_csv`.
"""
rows: list[tuple[str, str]] = []
@@ -178,25 +189,31 @@ def write_run_summary(
rows.append(("count.trafilatura_warnings", str(trafilatura_warnings)))
rows.append(("count.trafilatura_errors", str(trafilatura_errors)))
- stats = compute_score_stats(scores)
- for key in (
- "count",
- "min",
- "p10",
- "p25",
- "p50",
- "p75",
- "p90",
- "p95",
- "p99",
- "max",
- "mean",
- "median",
- "stdev",
- ):
- if key in stats:
- value = stats[key]
- rows.append((f"score.{key}", format_score(value) if key != "count" else str(value)))
+ for column, scores in scores_by_column.items():
+ stats = compute_score_stats(scores)
+ for key in (
+ "count",
+ "min",
+ "p10",
+ "p25",
+ "p50",
+ "p75",
+ "p90",
+ "p95",
+ "p99",
+ "max",
+ "mean",
+ "median",
+ "stdev",
+ ):
+ if key in stats:
+ value = stats[key]
+ rows.append(
+ (
+ f"score.{column}.{key}",
+ format_score(value) if key != "count" else str(value),
+ )
+ )
rows.append(("time.total_seconds", f"{t_processing:.6f}"))
rows.append(("time.extract_total_seconds", f"{t_extract_total:.6f}"))
diff --git a/tests/test_classify_warc.py b/tests/test_classify_warc.py
index 27f5226..e05acb8 100644
--- a/tests/test_classify_warc.py
+++ b/tests/test_classify_warc.py
@@ -9,7 +9,11 @@
import pytest
from ccoa.classifier.fasttext import FASTTEXT_MAX_INPUT_CHARS, clean_for_fasttext
-from ccoa.commands.classify_warc import ClassifyWarcCommand, load_resume_skipset
+from ccoa.commands.classify_warc import (
+ ClassifyWarcCommand,
+ _resolve_model_slots,
+ load_resume_skipset,
+)
from ccoa.extraction.cache import (
cache_path_for_warc,
load_extraction_cache,
@@ -38,25 +42,32 @@ def _make_warcs(tmp_path, names):
def test_summary_handles_empty(caplog):
- """An empty score list logs a single warning and returns cleanly."""
+ """An empty mapping logs a single warning and returns cleanly."""
caplog.set_level(logging.WARNING, logger="ccoa.utils.reporting.summary")
- log_summary([])
+ log_summary({})
warnings = [r for r in caplog.records if r.levelno == logging.WARNING]
assert len(warnings) == 1
assert "No records classified" in warnings[0].getMessage()
def test_summary_computes_stats(caplog):
- """A non-empty score list emits an INFO line containing count/min/max/mean."""
+ """Each column emits an INFO line containing count/min/max/mean for its scores."""
caplog.set_level(logging.INFO, logger="ccoa.utils.reporting.summary")
- log_summary([0.1, 0.5, 0.9])
+ log_summary(
+ {
+ "score___label__science": [0.1, 0.5, 0.9],
+ "score___label__cc": [0.9, 0.5, 0.1],
+ }
+ )
messages = [r.getMessage() for r in caplog.records if r.levelno == logging.INFO]
- assert messages, "expected an INFO summary line"
- line = "\n".join(messages)
- assert "count=3" in line
- assert "min=0.100000" in line
- assert "max=0.900000" in line
- assert "mean=0.500000" in line
+ assert messages, "expected INFO summary lines"
+ text = "\n".join(messages)
+ assert "[score___label__science]" in text
+ assert "[score___label__cc]" in text
+ assert text.count("count=3") == 2
+ assert "min=0.100000" in text
+ assert "max=0.900000" in text
+ assert "mean=0.500000" in text
def test_timing_zero_processed(caplog):
@@ -211,9 +222,9 @@ def _default_args(**overrides) -> argparse.Namespace:
"files_limit": 0,
"shuffle_files": False,
"seed": 42,
- "model_repo": "ibm-granite/GneissWeb.Sci_classifier",
- "model_file": "fasttext_science.bin",
- "target_label": "__label__science",
+ "model_repo": [],
+ "model_file": [],
+ "labels": [],
"output": "-",
"cache_dir": None,
"anonymous_s3": False,
@@ -222,6 +233,7 @@ def _default_args(**overrides) -> argparse.Namespace:
"workers_mode": "thread",
"max_pool_restarts": 10,
"resume_from_output": None,
+ "overwrite": False,
}
base.update(overrides)
return argparse.Namespace(**base)
@@ -275,6 +287,36 @@ def test_run_aborts_when_summary_exists(tmp_path, caplog):
assert any("already exists" in r.getMessage() for r in caplog.records)
+def test_run_overwrite_replaces_existing_output(monkeypatch, tmp_path, caplog):
+ """`--overwrite` skips the exists-guard and warns; the run proceeds and rewrites the file."""
+ warc_path = tmp_path / "empty.warc.gz"
+ _write_synthetic_warc(warc_path, "http://example.com/", b"")
+ output_path = tmp_path / "out.csv"
+ output_path.write_text("STALE,DATA\n") # pre-existing
+ summary_path = tmp_path / "out.summary.csv"
+ summary_path.write_text("stale,summary\n")
+
+ fake = _FakeModel(("__label__a",))
+ _patch_models(monkeypatch, {("r/x", "x.bin"): fake})
+
+ args = _default_args(
+ warc_paths=[str(warc_path)],
+ output=str(output_path),
+ model_repo=["r/x"],
+ model_file=["x.bin"],
+ overwrite=True,
+ )
+ caplog.set_level(logging.WARNING, logger="ccoa.commands.classify_warc")
+ rc = ClassifyWarcCommand().run(args)
+ assert rc == 0
+ warnings = [r.getMessage() for r in caplog.records if r.levelno == logging.WARNING]
+ assert any("Overwriting existing output" in m for m in warnings)
+ # The stale content must be replaced — fresh header on the first line.
+ assert output_path.read_text().splitlines()[0] == (
+ "URL,score___label__a,warc_filename,warc_record_index"
+ )
+
+
def test_compute_score_stats_empty_and_singleton() -> None:
"""Empty -> {count: 0}; singleton -> n/a percentiles + stdev."""
assert compute_score_stats([]) == {"count": 0}
@@ -286,7 +328,7 @@ def test_compute_score_stats_empty_and_singleton() -> None:
def test_write_run_summary_round_trip(tmp_path):
- """The sidecar CSV captures args, counters, score stats, and timings as key/value rows."""
+ """The sidecar CSV captures args, counters, per-column score stats, and timings."""
summary_path = tmp_path / "out.summary.csv"
args = _default_args(
warc_paths=["s3://bucket/a.warc.gz", "s3://bucket/b.warc.gz"],
@@ -299,7 +341,10 @@ def test_write_run_summary_round_trip(tmp_path):
{},
args=args,
resolved_count=2,
- scores=[0.1, 0.5, 0.9],
+ scores_by_column={
+ "score___label__science": [0.1, 0.5, 0.9],
+ "score___label__cc": [0.9, 0.5, 0.1],
+ },
processed=3,
skipped_empty=1,
skipped_homepage=2,
@@ -330,10 +375,12 @@ def test_write_run_summary_round_trip(tmp_path):
assert rows["count.cache_hits"] == "4"
assert rows["count.trafilatura_warnings"] == "17"
assert rows["count.trafilatura_errors"] == "6"
- assert rows["score.count"] == "3"
- assert rows["score.min"] == "0.100000"
- assert rows["score.max"] == "0.900000"
- assert rows["score.mean"] == "0.500000"
+ assert rows["score.score___label__science.count"] == "3"
+ assert rows["score.score___label__science.min"] == "0.100000"
+ assert rows["score.score___label__science.max"] == "0.900000"
+ assert rows["score.score___label__science.mean"] == "0.500000"
+ assert rows["score.score___label__cc.count"] == "3"
+ assert rows["score.score___label__cc.mean"] == "0.500000"
assert rows["time.total_seconds"] == "1.500000"
assert rows["time.throughput_docs_per_sec"] == "2.000000"
assert rows["run.started_at"] == "2026-05-24T00:00:00+00:00"
@@ -475,27 +522,52 @@ def test_clean_for_fasttext_clamps_length() -> None:
def test_load_resume_skipset_groups_by_warc(tmp_path):
- """A prior output CSV is grouped into {warc_filename: frozenset(record_indices)}."""
+ """A prior output CSV with the expected header is grouped by warc_filename."""
csv_path = tmp_path / "prior.csv"
csv_path.write_text(
- "URL,prediction_score,warc_filename,warc_record_index\n"
+ "URL,score___label__science,warc_filename,warc_record_index\n"
"http://a/,0.1,s3://bucket/a.warc.gz,0\n"
"http://a/x,0.2,s3://bucket/a.warc.gz,3\n"
"http://b/,0.3,s3://bucket/b.warc.gz,7\n"
)
- skipset = load_resume_skipset(str(csv_path), {})
+ expected = ["URL", "score___label__science", "warc_filename", "warc_record_index"]
+ skipset = load_resume_skipset(str(csv_path), {}, expected)
assert skipset == {
"s3://bucket/a.warc.gz": frozenset({0, 3}),
"s3://bucket/b.warc.gz": frozenset({7}),
}
-def test_load_resume_skipset_rejects_old_schema(tmp_path):
- """CSV without warc_filename/warc_record_index raises a clear error."""
+def test_load_resume_skipset_rejects_pre_multi_label_csv(tmp_path):
+ """A pre-multi-label CSV (no `score_*` columns) is rejected with a clear message."""
csv_path = tmp_path / "old.csv"
- csv_path.write_text("URL,prediction_score\nhttp://a/,0.1\n")
- with pytest.raises(ValueError, match="missing required columns"):
- load_resume_skipset(str(csv_path), {})
+ csv_path.write_text("URL,prediction_score,warc_filename,warc_record_index\nhttp://a/,0.1,x,0\n")
+ expected = ["URL", "score___label__science", "warc_filename", "warc_record_index"]
+ with pytest.raises(ValueError, match="pre-multi-label"):
+ load_resume_skipset(str(csv_path), {}, expected)
+
+
+def test_load_resume_skipset_rejects_column_reorder(tmp_path):
+ """Same columns in a different order: rejected (concat-friendliness)."""
+ csv_path = tmp_path / "reordered.csv"
+ csv_path.write_text(
+ "URL,warc_filename,warc_record_index,score___label__science\nhttp://a/,x,0,0.1\n"
+ )
+ expected = ["URL", "score___label__science", "warc_filename", "warc_record_index"]
+ with pytest.raises(ValueError, match="header does not match"):
+ load_resume_skipset(str(csv_path), {}, expected)
+
+
+def test_load_resume_skipset_rejects_extra_columns(tmp_path):
+ """Prior CSV has columns the new run doesn't produce: rejected with named diff."""
+ csv_path = tmp_path / "extra.csv"
+ csv_path.write_text(
+ "URL,score___label__science,score___label__cc,warc_filename,warc_record_index\n"
+ "http://a/,0.1,0.9,x,0\n"
+ )
+ expected = ["URL", "score___label__science", "warc_filename", "warc_record_index"]
+ with pytest.raises(ValueError, match="score___label__cc"):
+ load_resume_skipset(str(csv_path), {}, expected)
def _write_synthetic_warc(warc_path, url: str, body: bytes) -> None:
@@ -549,16 +621,21 @@ def test_classify_warc_end_to_end(tmp_path):
args = _default_args(
warc_paths=[str(warc_path)],
output=str(output_path),
- model_repo="facebook/fasttext-language-identification",
- model_file="model.bin",
- target_label="__label__eng_Latn",
+ model_repo=["facebook/fasttext-language-identification"],
+ model_file=["model.bin"],
+ labels=["__label__eng_Latn"],
)
rc = ClassifyWarcCommand().run(args)
assert rc == 0
with output_path.open(newline="", encoding="utf-8") as fh:
rows = list(csv.reader(fh))
- assert rows[0] == ["URL", "prediction_score", "warc_filename", "warc_record_index"]
+ assert rows[0] == [
+ "URL",
+ "score___label__eng_Latn",
+ "warc_filename",
+ "warc_record_index",
+ ]
assert len(rows) == 2, f"expected 1 data row, got {len(rows) - 1}"
url, score, warc_filename, record_index = rows[1]
@@ -573,3 +650,239 @@ def test_classify_warc_end_to_end(tmp_path):
summary_rows = dict(list(csv.reader(fh))[1:])
assert summary_rows["count.processed"] == "1"
assert summary_rows["input.resolved_count"] == "1"
+ assert summary_rows["score.score___label__eng_Latn.count"] == "1"
+
+
+def test_resolve_model_slots_defaults_when_both_empty():
+ """No CLI input → falls back to the default science model with '*' labels."""
+ slots = _resolve_model_slots([], [], [])
+ assert slots == [
+ ("ibm-granite/GneissWeb.Sci_classifier", "fasttext_science.bin", ["*"]),
+ ]
+
+
+def test_resolve_model_slots_zips_parallel_lists():
+ """Parallel `--model-repo`/`--model-file`/`--labels` lists are zipped positionally."""
+ slots = _resolve_model_slots(
+ ["r1/m", "r2/m"],
+ ["f1.bin", "f2.bin"],
+ ["__label__a,__label__b", "*"],
+ )
+ assert slots == [
+ ("r1/m", "f1.bin", ["__label__a", "__label__b"]),
+ ("r2/m", "f2.bin", ["*"]),
+ ]
+
+
+def test_resolve_model_slots_broadcasts_missing_labels():
+ """Omitted `--labels` defaults to '*' for every model slot."""
+ slots = _resolve_model_slots(["r1/m", "r2/m"], ["f1.bin", "f2.bin"], [])
+ assert slots == [
+ ("r1/m", "f1.bin", ["*"]),
+ ("r2/m", "f2.bin", ["*"]),
+ ]
+
+
+def test_resolve_model_slots_rejects_length_mismatch():
+ """`--model-repo` and `--model-file` of different lengths fails."""
+ with pytest.raises(ValueError, match="same length"):
+ _resolve_model_slots(["r1", "r2"], ["f1.bin"], [])
+
+
+def test_resolve_model_slots_rejects_label_length_mismatch():
+ """A `--labels` list whose length doesn't match the number of models fails."""
+ with pytest.raises(ValueError, match="one entry per --model-repo"):
+ _resolve_model_slots(["r1", "r2"], ["f1.bin", "f2.bin"], ["only_one"])
+
+
+class _FakeModel:
+ """Stand-in for a loaded fasttext model.
+
+ `get_labels` returns the labels we want exposed to '*' expansion; `predict`
+ deterministically returns a 1.0 for the first label and 0.0 for the rest,
+ so the test can assert on output values without depending on the real model.
+ """
+
+ def __init__(self, labels: tuple[str, ...]):
+ self._labels = labels
+
+ def get_labels(self) -> tuple[str, ...]:
+ return self._labels
+
+ def predict(self, _text: str, k: int = -1):
+ import numpy as np
+
+ probs = np.zeros(len(self._labels), dtype=float)
+ if probs.size:
+ probs[0] = 1.0
+ return (tuple(self._labels), probs)
+
+
+def _patch_models(monkeypatch, model_for: dict[tuple[str, str], _FakeModel]) -> None:
+ """Patch `load_classifier`/`get_model_labels` to return `_FakeModel`s by (repo, file)."""
+
+ def fake_load(repo: str, file: str):
+ try:
+ return model_for[(repo, file)]
+ except KeyError as exc:
+ raise AssertionError(f"unexpected load_classifier({repo!r}, {file!r})") from exc
+
+ def fake_get_labels(model):
+ return tuple(model.get_labels())
+
+ monkeypatch.setattr("ccoa.commands.classify_warc.load_classifier", fake_load)
+ monkeypatch.setattr("ccoa.commands.classify_warc.get_model_labels", fake_get_labels)
+
+
+def test_run_expands_star_labels_from_model(monkeypatch, tmp_path):
+ """'*' expands to the model's full label set via `get_model_labels`."""
+ warc_path = tmp_path / "empty.warc.gz"
+ _write_synthetic_warc(warc_path, "http://example.com/", b"")
+ fake = _FakeModel(("__label__alpha", "__label__beta"))
+ _patch_models(monkeypatch, {("r/x", "x.bin"): fake})
+
+ output_path = tmp_path / "out.csv"
+ args = _default_args(
+ warc_paths=[str(warc_path)],
+ output=str(output_path),
+ model_repo=["r/x"],
+ model_file=["x.bin"],
+ )
+ rc = ClassifyWarcCommand().run(args)
+ assert rc == 0
+
+ with output_path.open(newline="", encoding="utf-8") as fh:
+ rows = list(csv.reader(fh))
+ assert rows[0] == [
+ "URL",
+ "score___label__alpha",
+ "score___label__beta",
+ "warc_filename",
+ "warc_record_index",
+ ]
+
+
+def test_run_writes_multi_model_header(monkeypatch, tmp_path):
+ """Two models: columns get a `m_` prefix so per-model labels never collide."""
+ warc_path = tmp_path / "empty.warc.gz"
+ _write_synthetic_warc(warc_path, "http://example.com/", b"")
+ fake_a = _FakeModel(("__label__sci", "__label__cc"))
+ fake_b = _FakeModel(("__label__hq", "__label__lq"))
+ _patch_models(
+ monkeypatch,
+ {
+ ("rA/sci", "sci.bin"): fake_a,
+ ("rB/q", "q.bin"): fake_b,
+ },
+ )
+
+ output_path = tmp_path / "out.csv"
+ args = _default_args(
+ warc_paths=[str(warc_path)],
+ output=str(output_path),
+ model_repo=["rA/sci", "rB/q"],
+ model_file=["sci.bin", "q.bin"],
+ )
+ rc = ClassifyWarcCommand().run(args)
+ assert rc == 0
+
+ with output_path.open(newline="", encoding="utf-8") as fh:
+ rows = list(csv.reader(fh))
+ assert rows[0] == [
+ "URL",
+ "score_m0___label__sci",
+ "score_m0___label__cc",
+ "score_m1___label__hq",
+ "score_m1___label__lq",
+ "warc_filename",
+ "warc_record_index",
+ ]
+
+
+def test_run_disambiguates_shared_label_across_models(monkeypatch, tmp_path):
+ """Two models sharing a label name (e.g. `__label__cc`) coexist via the `m_` prefix."""
+ warc_path = tmp_path / "empty.warc.gz"
+ _write_synthetic_warc(warc_path, "http://example.com/", b"")
+ fake_a = _FakeModel(("__label__shared",))
+ fake_b = _FakeModel(("__label__shared",))
+ _patch_models(
+ monkeypatch,
+ {
+ ("rA/m", "a.bin"): fake_a,
+ ("rB/m", "b.bin"): fake_b,
+ },
+ )
+
+ output_path = tmp_path / "out.csv"
+ args = _default_args(
+ warc_paths=[str(warc_path)],
+ output=str(output_path),
+ model_repo=["rA/m", "rB/m"],
+ model_file=["a.bin", "b.bin"],
+ )
+ rc = ClassifyWarcCommand().run(args)
+ assert rc == 0
+
+ with output_path.open(newline="", encoding="utf-8") as fh:
+ rows = list(csv.reader(fh))
+ assert rows[0] == [
+ "URL",
+ "score_m0___label__shared",
+ "score_m1___label__shared",
+ "warc_filename",
+ "warc_record_index",
+ ]
+
+
+def test_run_rejects_mismatched_model_lengths(caplog):
+ """--model-repo and --model-file of different lengths: rc=2, no work done."""
+ caplog.set_level(logging.ERROR, logger="ccoa.commands.classify_warc")
+ args = _default_args(
+ model_repo=["r1/m", "r2/m"],
+ model_file=["only_one.bin"],
+ output="-",
+ )
+ rc = ClassifyWarcCommand().run(args)
+ assert rc == 2
+
+
+def test_run_scores_all_resolved_labels(monkeypatch, tmp_path):
+ """Each record is scored against every requested label; outputs land in column order."""
+ warc_path = tmp_path / "doc.warc.gz"
+ html = (
+ b"T "
+ b"Long enough body to survive trafilatura's minimum-content gates. "
+ b"We just need a single response record to flow through the pipeline.
"
+ b""
+ )
+ _write_synthetic_warc(warc_path, "http://example.com/doc", html)
+ fake = _FakeModel(("__label__alpha", "__label__beta"))
+ _patch_models(monkeypatch, {("r/x", "x.bin"): fake})
+
+ output_path = tmp_path / "out.csv"
+ args = _default_args(
+ warc_paths=[str(warc_path)],
+ output=str(output_path),
+ model_repo=["r/x"],
+ model_file=["x.bin"],
+ )
+ rc = ClassifyWarcCommand().run(args)
+ assert rc == 0
+
+ with output_path.open(newline="", encoding="utf-8") as fh:
+ rows = list(csv.reader(fh))
+ assert rows[0] == [
+ "URL",
+ "score___label__alpha",
+ "score___label__beta",
+ "warc_filename",
+ "warc_record_index",
+ ]
+ assert len(rows) == 2
+ url, alpha, beta, warc_filename, record_index = rows[1]
+ assert url == "http://example.com/doc"
+ # `_FakeModel.predict` is rigged: 1.0 for the first label, 0.0 for the rest.
+ assert float(alpha) == 1.0
+ assert float(beta) == 0.0
+ assert warc_filename == str(warc_path)
+ assert record_index == "0"
From 9d3cf9c9dd2db428963cad0bf1e2b739b633edcf Mon Sep 17 00:00:00 2001
From: malteos
Date: Mon, 1 Jun 2026 16:21:31 +0200
Subject: [PATCH 2/3] added notebook for multi label eval
---
notebooks/compare_multi_label_scores.ipynb | 980 +++++++++++++++++++++
1 file changed, 980 insertions(+)
create mode 100644 notebooks/compare_multi_label_scores.ipynb
diff --git a/notebooks/compare_multi_label_scores.ipynb b/notebooks/compare_multi_label_scores.ipynb
new file mode 100644
index 0000000..333e033
--- /dev/null
+++ b/notebooks/compare_multi_label_scores.ipynb
@@ -0,0 +1,980 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "mlc-00-title",
+ "metadata": {},
+ "source": [
+ "# Multi-classifier comparison: Science + Quality, Baseline vs Focus\n",
+ "\n",
+ "This notebook compares `ccoa classify-warc` **multi-model** output for two Common Crawl runs:\n",
+ "\n",
+ "- **CC-MAIN-2024-18** — baseline\n",
+ "- **CC-SUPPLEMENTAL-2026-22** — focus (Open Athena project)\n",
+ "\n",
+ "Each row has four score columns produced in a single pass:\n",
+ "\n",
+ "| Column | Source | Meaning |\n",
+ "|------------------------------|---------------------------------------------|----------------------------------|\n",
+ "| `score_m0___label__science` | `ibm-granite/GneissWeb.Sci_classifier` | P(page is science) |\n",
+ "| `score_m0___label__cc` | `ibm-granite/GneissWeb.Sci_classifier` | P(page is generic Common Crawl) |\n",
+ "| `score_m1___label__hq` | `ibm-granite/GneissWeb.Quality_annotator` | P(page is high quality) |\n",
+ "| `score_m1___label__cc` | `ibm-granite/GneissWeb.Quality_annotator` | P(page is generic Common Crawl) |\n",
+ "\n",
+ "The two scores from each model sum to 1.0 per row by construction (softmax).\n",
+ "\n",
+ "We analyse the data along two axes:\n",
+ "\n",
+ "1. **Continuous scores** — how each crawl's distribution sits in `[0, 1]` for each label.\n",
+ "2. **Binary labels** — pick the larger score of each pair (`is_science = score_science > score_cc`, same for `is_hq`); then look at the **joint** label `is_science AND is_hq` — pages both classifiers agree are *high-quality science*. The headline question is whether the focus crawl produces more such pages, both in absolute count and as a share of the crawl.\n",
+ "\n",
+ "## Setup\n",
+ "\n",
+ "First-time install of notebook extras:\n",
+ "\n",
+ "```bash\n",
+ "uv pip install -e .[notebooks]\n",
+ "```\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "mlc-01-imports",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:13.835417Z",
+ "iopub.status.busy": "2026-06-01T14:17:13.835268Z",
+ "iopub.status.idle": "2026-06-01T14:17:15.214316Z",
+ "shell.execute_reply": "2026-06-01T14:17:15.213944Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Baseline CSV: ../data/gneissweb-science-top-10k/CC-MAIN-2024-18_1m_scores_sci-hq.csv (exists=True)\n",
+ "Focus CSV: ../data/gneissweb-science-top-10k/CC-SUPPLEMENTAL-2026-22_1m_scores_sci-hq.csv (exists=True)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from __future__ import annotations\n",
+ "\n",
+ "from pathlib import Path\n",
+ "\n",
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "import pandas as pd\n",
+ "from scipy import stats\n",
+ "\n",
+ "# Run from repo root or from inside notebooks/.\n",
+ "DATA_DIR = Path(\"data\") if Path(\"data\").exists() else Path(\"..\") / \"data\"\n",
+ "SCORES_DIR = DATA_DIR / \"gneissweb-science-top-10k\"\n",
+ "\n",
+ "BASELINE_NAME = \"CC-MAIN-2024-18\"\n",
+ "FOCUS_NAME = \"CC-SUPPLEMENTAL-2026-22\"\n",
+ "\n",
+ "# Download from S3:\n",
+ "# aws s3 sync s3://commoncrawl-dev/cc-focus-tools/experiments/open-athena/gneissweb-science-top-10k/ ./data/gneissweb-science-top-10k/\n",
+ "BASELINE_CSV = SCORES_DIR / f\"{BASELINE_NAME}_1m_scores_sci-hq.csv\"\n",
+ "FOCUS_CSV = SCORES_DIR / f\"{FOCUS_NAME}_1m_scores_sci-hq.csv\"\n",
+ "\n",
+ "# The four score columns produced by the dual-model classify-warc run.\n",
+ "SCI_SCIENCE = \"score_m0___label__science\"\n",
+ "SCI_CC = \"score_m0___label__cc\"\n",
+ "HQ_HQ = \"score_m1___label__hq\"\n",
+ "HQ_CC = \"score_m1___label__cc\"\n",
+ "SCORE_COLS = [SCI_SCIENCE, SCI_CC, HQ_HQ, HQ_CC]\n",
+ "\n",
+ "print(f\"Baseline CSV: {BASELINE_CSV} (exists={BASELINE_CSV.exists()})\")\n",
+ "print(f\"Focus CSV: {FOCUS_CSV} (exists={FOCUS_CSV.exists()})\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-02-load-md",
+ "metadata": {},
+ "source": [
+ "## 1. Load the score data\n",
+ "\n",
+ "Read just the four score columns from each CSV (URL/warc-filename/warc-record-index aren't needed for distribution analysis)."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "mlc-03-load",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:15.215422Z",
+ "iopub.status.busy": "2026-06-01T14:17:15.215336Z",
+ "iopub.status.idle": "2026-06-01T14:17:16.112684Z",
+ "shell.execute_reply": "2026-06-01T14:17:16.112294Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "CC-MAIN-2024-18: 1,000,000 rows\n",
+ "CC-SUPPLEMENTAL-2026-22: 999,774 rows\n",
+ "m0 row sum (baseline, top values): {1.0: np.int64(1000000)}\n",
+ "m1 row sum (baseline, top values): {1.0: np.int64(1000000)}\n"
+ ]
+ }
+ ],
+ "source": [
+ "def load_scores(csv_path: Path) -> pd.DataFrame:\n",
+ " \"\"\"Load the four score columns from a multi-model classify-warc CSV.\"\"\"\n",
+ " return pd.read_csv(csv_path, usecols=SCORE_COLS, dtype=float)\n",
+ "\n",
+ "\n",
+ "baseline = load_scores(BASELINE_CSV)\n",
+ "focus = load_scores(FOCUS_CSV)\n",
+ "\n",
+ "# Quick softmax sanity check — m0 and m1 each sum to 1.0 per row.\n",
+ "m0_sum = (baseline[SCI_SCIENCE] + baseline[SCI_CC]).round(4).value_counts().head(3)\n",
+ "m1_sum = (baseline[HQ_HQ] + baseline[HQ_CC]).round(4).value_counts().head(3)\n",
+ "print(f\"{BASELINE_NAME}: {len(baseline):,} rows\")\n",
+ "print(f\"{FOCUS_NAME}: {len(focus):,} rows\")\n",
+ "print(f\"m0 row sum (baseline, top values): {dict(m0_sum)}\")\n",
+ "print(f\"m1 row sum (baseline, top values): {dict(m1_sum)}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-04-stats-md",
+ "metadata": {},
+ "source": [
+ "## 2. Continuous-score summary\n",
+ "\n",
+ "Where does each score sit per crawl? `delta` is `focus - baseline`."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "mlc-05-stats",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:16.113688Z",
+ "iopub.status.busy": "2026-06-01T14:17:16.113638Z",
+ "iopub.status.idle": "2026-06-01T14:17:16.362014Z",
+ "shell.execute_reply": "2026-06-01T14:17:16.361615Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " CC-MAIN-2024-18 \n",
+ " CC-SUPPLEMENTAL-2026-22 \n",
+ " delta \n",
+ " \n",
+ " \n",
+ " column \n",
+ " stat \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " score_m0___label__science \n",
+ " mean \n",
+ " 0.142090 \n",
+ " 0.517199 \n",
+ " 0.375109 \n",
+ " \n",
+ " \n",
+ " median \n",
+ " 0.006990 \n",
+ " 0.576132 \n",
+ " 0.569142 \n",
+ " \n",
+ " \n",
+ " p25 \n",
+ " 0.000052 \n",
+ " 0.019895 \n",
+ " 0.019843 \n",
+ " \n",
+ " \n",
+ " p75 \n",
+ " 0.179258 \n",
+ " 0.989210 \n",
+ " 0.809953 \n",
+ " \n",
+ " \n",
+ " p95 \n",
+ " 0.731946 \n",
+ " 1.000009 \n",
+ " 0.268063 \n",
+ " \n",
+ " \n",
+ " p99 \n",
+ " 0.988988 \n",
+ " 1.000010 \n",
+ " 0.011022 \n",
+ " \n",
+ " \n",
+ " score_m0___label__cc \n",
+ " mean \n",
+ " 0.857930 \n",
+ " 0.482821 \n",
+ " -0.375109 \n",
+ " \n",
+ " \n",
+ " median \n",
+ " 0.993030 \n",
+ " 0.423888 \n",
+ " -0.569142 \n",
+ " \n",
+ " \n",
+ " p25 \n",
+ " 0.820763 \n",
+ " 0.010810 \n",
+ " -0.809953 \n",
+ " \n",
+ " \n",
+ " p75 \n",
+ " 0.999968 \n",
+ " 0.980125 \n",
+ " -0.019843 \n",
+ " \n",
+ " \n",
+ " p95 \n",
+ " 1.000010 \n",
+ " 0.999974 \n",
+ " -0.000036 \n",
+ " \n",
+ " \n",
+ " p99 \n",
+ " 1.000010 \n",
+ " 1.000010 \n",
+ " 0.000000 \n",
+ " \n",
+ " \n",
+ " score_m1___label__hq \n",
+ " mean \n",
+ " 0.106053 \n",
+ " 0.174356 \n",
+ " 0.068303 \n",
+ " \n",
+ " \n",
+ " median \n",
+ " 0.000295 \n",
+ " 0.019288 \n",
+ " 0.018993 \n",
+ " \n",
+ " \n",
+ " p25 \n",
+ " 0.000010 \n",
+ " 0.000082 \n",
+ " 0.000072 \n",
+ " \n",
+ " \n",
+ " p75 \n",
+ " 0.048318 \n",
+ " 0.230062 \n",
+ " 0.181744 \n",
+ " \n",
+ " \n",
+ " p95 \n",
+ " 0.834057 \n",
+ " 0.882294 \n",
+ " 0.048237 \n",
+ " \n",
+ " \n",
+ " p99 \n",
+ " 0.999977 \n",
+ " 0.997152 \n",
+ " -0.002825 \n",
+ " \n",
+ " \n",
+ " score_m1___label__cc \n",
+ " mean \n",
+ " 0.893967 \n",
+ " 0.825664 \n",
+ " -0.068303 \n",
+ " \n",
+ " \n",
+ " median \n",
+ " 0.999725 \n",
+ " 0.980732 \n",
+ " -0.018993 \n",
+ " \n",
+ " \n",
+ " p25 \n",
+ " 0.951702 \n",
+ " 0.769958 \n",
+ " -0.181744 \n",
+ " \n",
+ " \n",
+ " p75 \n",
+ " 1.000010 \n",
+ " 0.999938 \n",
+ " -0.000072 \n",
+ " \n",
+ " \n",
+ " p95 \n",
+ " 1.000010 \n",
+ " 1.000010 \n",
+ " 0.000000 \n",
+ " \n",
+ " \n",
+ " p99 \n",
+ " 1.000010 \n",
+ " 1.000010 \n",
+ " 0.000000 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " CC-MAIN-2024-18 CC-SUPPLEMENTAL-2026-22 \\\n",
+ "column stat \n",
+ "score_m0___label__science mean 0.142090 0.517199 \n",
+ " median 0.006990 0.576132 \n",
+ " p25 0.000052 0.019895 \n",
+ " p75 0.179258 0.989210 \n",
+ " p95 0.731946 1.000009 \n",
+ " p99 0.988988 1.000010 \n",
+ "score_m0___label__cc mean 0.857930 0.482821 \n",
+ " median 0.993030 0.423888 \n",
+ " p25 0.820763 0.010810 \n",
+ " p75 0.999968 0.980125 \n",
+ " p95 1.000010 0.999974 \n",
+ " p99 1.000010 1.000010 \n",
+ "score_m1___label__hq mean 0.106053 0.174356 \n",
+ " median 0.000295 0.019288 \n",
+ " p25 0.000010 0.000082 \n",
+ " p75 0.048318 0.230062 \n",
+ " p95 0.834057 0.882294 \n",
+ " p99 0.999977 0.997152 \n",
+ "score_m1___label__cc mean 0.893967 0.825664 \n",
+ " median 0.999725 0.980732 \n",
+ " p25 0.951702 0.769958 \n",
+ " p75 1.000010 0.999938 \n",
+ " p95 1.000010 1.000010 \n",
+ " p99 1.000010 1.000010 \n",
+ "\n",
+ " delta \n",
+ "column stat \n",
+ "score_m0___label__science mean 0.375109 \n",
+ " median 0.569142 \n",
+ " p25 0.019843 \n",
+ " p75 0.809953 \n",
+ " p95 0.268063 \n",
+ " p99 0.011022 \n",
+ "score_m0___label__cc mean -0.375109 \n",
+ " median -0.569142 \n",
+ " p25 -0.809953 \n",
+ " p75 -0.019843 \n",
+ " p95 -0.000036 \n",
+ " p99 0.000000 \n",
+ "score_m1___label__hq mean 0.068303 \n",
+ " median 0.018993 \n",
+ " p25 0.000072 \n",
+ " p75 0.181744 \n",
+ " p95 0.048237 \n",
+ " p99 -0.002825 \n",
+ "score_m1___label__cc mean -0.068303 \n",
+ " median -0.018993 \n",
+ " p25 -0.181744 \n",
+ " p75 -0.000072 \n",
+ " p95 0.000000 \n",
+ " p99 0.000000 "
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def describe_one(s: pd.Series) -> dict:\n",
+ " return {\n",
+ " \"n\": len(s),\n",
+ " \"mean\": s.mean(),\n",
+ " \"median\": s.median(),\n",
+ " \"p25\": s.quantile(0.25),\n",
+ " \"p75\": s.quantile(0.75),\n",
+ " \"p95\": s.quantile(0.95),\n",
+ " \"p99\": s.quantile(0.99),\n",
+ " }\n",
+ "\n",
+ "\n",
+ "rows = []\n",
+ "for col in SCORE_COLS:\n",
+ " base_d = describe_one(baseline[col])\n",
+ " focus_d = describe_one(focus[col])\n",
+ " for stat in (\"mean\", \"median\", \"p25\", \"p75\", \"p95\", \"p99\"):\n",
+ " rows.append(\n",
+ " {\n",
+ " \"column\": col,\n",
+ " \"stat\": stat,\n",
+ " BASELINE_NAME: base_d[stat],\n",
+ " FOCUS_NAME: focus_d[stat],\n",
+ " \"delta\": focus_d[stat] - base_d[stat],\n",
+ " }\n",
+ " )\n",
+ "stats_df = pd.DataFrame(rows).set_index([\"column\", \"stat\"])\n",
+ "stats_df.round(6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-06-dist-md",
+ "metadata": {},
+ "source": [
+ "## 3. Distribution shapes\n",
+ "\n",
+ "One column per score, log-y histogram on top, ECDF below. The science model's two columns mirror each other (softmax pair); same for the quality model — but it's still useful to plot all four so the absolute score levels are visible."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "mlc-07-dist",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:16.363090Z",
+ "iopub.status.busy": "2026-06-01T14:17:16.363040Z",
+ "iopub.status.idle": "2026-06-01T14:17:19.225361Z",
+ "shell.execute_reply": "2026-06-01T14:17:19.225049Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "fig, axes = plt.subplots(2, 4, figsize=(20, 8), sharey=\"row\")\n",
+ "bins = np.linspace(0.0, 1.0, 81)\n",
+ "\n",
+ "for col_idx, col in enumerate(SCORE_COLS):\n",
+ " ax = axes[0, col_idx]\n",
+ " ax.hist(baseline[col], bins=bins, alpha=0.5, label=BASELINE_NAME, color=\"C0\", density=True)\n",
+ " ax.hist(focus[col], bins=bins, alpha=0.5, label=FOCUS_NAME, color=\"C1\", density=True)\n",
+ " ax.set_yscale(\"log\")\n",
+ " ax.set_title(col, fontsize=9)\n",
+ " ax.set_xlabel(\"score\")\n",
+ " if col_idx == 0:\n",
+ " ax.set_ylabel(\"density (log)\")\n",
+ " ax.legend(fontsize=8)\n",
+ " ax.grid(True, alpha=0.3)\n",
+ "\n",
+ " ax = axes[1, col_idx]\n",
+ " for series, label, color in [\n",
+ " (baseline[col], BASELINE_NAME, \"C0\"),\n",
+ " (focus[col], FOCUS_NAME, \"C1\"),\n",
+ " ]:\n",
+ " x = np.sort(series.to_numpy())\n",
+ " y = np.arange(1, len(x) + 1) / len(x)\n",
+ " ax.plot(x, y, label=label, color=color)\n",
+ " ax.set_title(f\"ECDF — {col}\", fontsize=9)\n",
+ " ax.set_xlabel(\"score\")\n",
+ " if col_idx == 0:\n",
+ " ax.set_ylabel(\"P(score \\u2264 x)\")\n",
+ " ax.legend(fontsize=8)\n",
+ " ax.grid(True, alpha=0.3)\n",
+ "\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-08-binary-md",
+ "metadata": {},
+ "source": [
+ "## 4. Binary labels from the score pairs\n",
+ "\n",
+ "We collapse each classifier's two scores into a single boolean by picking the larger one:\n",
+ "\n",
+ "- `is_science = score_m0___label__science > score_m0___label__cc`\n",
+ "- `is_hq = score_m1___label__hq > score_m1___label__cc`\n",
+ "\n",
+ "And then the joint label that interests us most:\n",
+ "\n",
+ "- `is_sci_and_hq = is_science AND is_hq`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "mlc-09-binary",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:19.226495Z",
+ "iopub.status.busy": "2026-06-01T14:17:19.226421Z",
+ "iopub.status.idle": "2026-06-01T14:17:19.240514Z",
+ "shell.execute_reply": "2026-06-01T14:17:19.240141Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " CC-MAIN-2024-18 \n",
+ " CC-SUPPLEMENTAL-2026-22 \n",
+ " lift (focus / baseline) \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " n \n",
+ " 1000000.000000 \n",
+ " 999774.000000 \n",
+ " 0.999774 \n",
+ " \n",
+ " \n",
+ " is_science_count \n",
+ " 113543.000000 \n",
+ " 521658.000000 \n",
+ " 4.594365 \n",
+ " \n",
+ " \n",
+ " is_science_share \n",
+ " 0.113543 \n",
+ " 0.521776 \n",
+ " 4.595404 \n",
+ " \n",
+ " \n",
+ " is_hq_count \n",
+ " 85984.000000 \n",
+ " 149159.000000 \n",
+ " 1.734730 \n",
+ " \n",
+ " \n",
+ " is_hq_share \n",
+ " 0.085984 \n",
+ " 0.149193 \n",
+ " 1.735122 \n",
+ " \n",
+ " \n",
+ " is_sci_and_hq_count \n",
+ " 21508.000000 \n",
+ " 118576.000000 \n",
+ " 5.513111 \n",
+ " \n",
+ " \n",
+ " is_sci_and_hq_share \n",
+ " 0.021508 \n",
+ " 0.118603 \n",
+ " 5.514358 \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " CC-MAIN-2024-18 CC-SUPPLEMENTAL-2026-22 \\\n",
+ "n 1000000.000000 999774.000000 \n",
+ "is_science_count 113543.000000 521658.000000 \n",
+ "is_science_share 0.113543 0.521776 \n",
+ "is_hq_count 85984.000000 149159.000000 \n",
+ "is_hq_share 0.085984 0.149193 \n",
+ "is_sci_and_hq_count 21508.000000 118576.000000 \n",
+ "is_sci_and_hq_share 0.021508 0.118603 \n",
+ "\n",
+ " lift (focus / baseline) \n",
+ "n 0.999774 \n",
+ "is_science_count 4.594365 \n",
+ "is_science_share 4.595404 \n",
+ "is_hq_count 1.734730 \n",
+ "is_hq_share 1.735122 \n",
+ "is_sci_and_hq_count 5.513111 \n",
+ "is_sci_and_hq_share 5.514358 "
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "def add_binary_labels(df: pd.DataFrame) -> pd.DataFrame:\n",
+ " out = df.copy()\n",
+ " out[\"is_science\"] = out[SCI_SCIENCE] > out[SCI_CC]\n",
+ " out[\"is_hq\"] = out[HQ_HQ] > out[HQ_CC]\n",
+ " out[\"is_sci_and_hq\"] = out[\"is_science\"] & out[\"is_hq\"]\n",
+ " return out\n",
+ "\n",
+ "\n",
+ "baseline_lbl = add_binary_labels(baseline)\n",
+ "focus_lbl = add_binary_labels(focus)\n",
+ "\n",
+ "\n",
+ "def prevalence(df: pd.DataFrame) -> dict:\n",
+ " n = len(df)\n",
+ " return {\n",
+ " \"n\": n,\n",
+ " \"is_science_count\": int(df[\"is_science\"].sum()),\n",
+ " \"is_science_share\": df[\"is_science\"].mean(),\n",
+ " \"is_hq_count\": int(df[\"is_hq\"].sum()),\n",
+ " \"is_hq_share\": df[\"is_hq\"].mean(),\n",
+ " \"is_sci_and_hq_count\": int(df[\"is_sci_and_hq\"].sum()),\n",
+ " \"is_sci_and_hq_share\": df[\"is_sci_and_hq\"].mean(),\n",
+ " }\n",
+ "\n",
+ "\n",
+ "prev = pd.DataFrame({BASELINE_NAME: prevalence(baseline_lbl), FOCUS_NAME: prevalence(focus_lbl)})\n",
+ "prev[\"lift (focus / baseline)\"] = prev[FOCUS_NAME] / prev[BASELINE_NAME].replace({0: np.nan})\n",
+ "prev.round(6)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-10-confusion-md",
+ "metadata": {},
+ "source": [
+ "## 5. How do the two classifiers agree?\n",
+ "\n",
+ "A 2×2 contingency table between `is_science` and `is_hq`, separately for each crawl. The bottom-right cell (`science=True, hq=True`) is the joint label we care most about."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "mlc-11-confusion",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:19.241427Z",
+ "iopub.status.busy": "2026-06-01T14:17:19.241378Z",
+ "iopub.status.idle": "2026-06-01T14:17:19.327576Z",
+ "shell.execute_reply": "2026-06-01T14:17:19.327137Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "\n",
+ "=== CC-MAIN-2024-18 ===\n",
+ "is_hq False True total\n",
+ "is_science \n",
+ "False 821981 64476 886457\n",
+ "True 92035 21508 113543\n",
+ "total 914016 85984 1000000\n",
+ "\n",
+ "=== CC-SUPPLEMENTAL-2026-22 ===\n",
+ "is_hq False True total\n",
+ "is_science \n",
+ "False 447533 30583 478116\n",
+ "True 403082 118576 521658\n",
+ "total 850615 149159 999774\n"
+ ]
+ }
+ ],
+ "source": [
+ "def crosstab(df: pd.DataFrame) -> pd.DataFrame:\n",
+ " return pd.crosstab(df[\"is_science\"], df[\"is_hq\"], margins=True, margins_name=\"total\")\n",
+ "\n",
+ "\n",
+ "print(f\"\\n=== {BASELINE_NAME} ===\")\n",
+ "print(crosstab(baseline_lbl))\n",
+ "print(f\"\\n=== {FOCUS_NAME} ===\")\n",
+ "print(crosstab(focus_lbl))"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-12-bar-md",
+ "metadata": {},
+ "source": [
+ "## 6. Joint label — baseline vs focus\n",
+ "\n",
+ "Absolute counts on the left, share-of-crawl on the right. The third group of bars (`is_science AND is_hq`) is the headline."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "mlc-13-bar",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:19.328638Z",
+ "iopub.status.busy": "2026-06-01T14:17:19.328570Z",
+ "iopub.status.idle": "2026-06-01T14:17:19.384612Z",
+ "shell.execute_reply": "2026-06-01T14:17:19.384302Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "labels = [\"is_science\", \"is_hq\", \"is_science AND is_hq\"]\n",
+ "baseline_counts = [\n",
+ " int(baseline_lbl[\"is_science\"].sum()),\n",
+ " int(baseline_lbl[\"is_hq\"].sum()),\n",
+ " int(baseline_lbl[\"is_sci_and_hq\"].sum()),\n",
+ "]\n",
+ "focus_counts = [\n",
+ " int(focus_lbl[\"is_science\"].sum()),\n",
+ " int(focus_lbl[\"is_hq\"].sum()),\n",
+ " int(focus_lbl[\"is_sci_and_hq\"].sum()),\n",
+ "]\n",
+ "baseline_shares = [c / len(baseline_lbl) for c in baseline_counts]\n",
+ "focus_shares = [c / len(focus_lbl) for c in focus_counts]\n",
+ "\n",
+ "fig, axes = plt.subplots(1, 2, figsize=(13, 5))\n",
+ "x = np.arange(len(labels))\n",
+ "w = 0.4\n",
+ "\n",
+ "axes[0].bar(x - w / 2, baseline_counts, w, label=BASELINE_NAME, color=\"C0\")\n",
+ "axes[0].bar(x + w / 2, focus_counts, w, label=FOCUS_NAME, color=\"C1\")\n",
+ "for i, (b, f) in enumerate(zip(baseline_counts, focus_counts, strict=True)):\n",
+ " axes[0].text(i - w / 2, b, f\"{b:,}\", ha=\"center\", va=\"bottom\", fontsize=8)\n",
+ " axes[0].text(i + w / 2, f, f\"{f:,}\", ha=\"center\", va=\"bottom\", fontsize=8)\n",
+ "axes[0].set_xticks(x)\n",
+ "axes[0].set_xticklabels(labels)\n",
+ "axes[0].set_ylabel(\"page count\")\n",
+ "axes[0].set_title(\"Absolute counts\")\n",
+ "axes[0].legend()\n",
+ "axes[0].grid(axis=\"y\", alpha=0.3)\n",
+ "\n",
+ "axes[1].bar(x - w / 2, baseline_shares, w, label=BASELINE_NAME, color=\"C0\")\n",
+ "axes[1].bar(x + w / 2, focus_shares, w, label=FOCUS_NAME, color=\"C1\")\n",
+ "for i, (b, f) in enumerate(zip(baseline_shares, focus_shares, strict=True)):\n",
+ " axes[1].text(i - w / 2, b, f\"{b:.3f}\", ha=\"center\", va=\"bottom\", fontsize=8)\n",
+ " axes[1].text(i + w / 2, f, f\"{f:.3f}\", ha=\"center\", va=\"bottom\", fontsize=8)\n",
+ "axes[1].set_xticks(x)\n",
+ "axes[1].set_xticklabels(labels)\n",
+ "axes[1].set_ylabel(\"share of crawl\")\n",
+ "axes[1].set_title(\"Share of crawl\")\n",
+ "axes[1].legend()\n",
+ "axes[1].grid(axis=\"y\", alpha=0.3)\n",
+ "\n",
+ "plt.tight_layout()\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-14-tests-md",
+ "metadata": {},
+ "source": [
+ "## 7. Significance and effect size on the binary labels\n",
+ "\n",
+ "For each binary label we run a 2×2 chi-square test on the (focus vs baseline) × (label vs not-label) contingency table. With ~1M rows per crawl, p-values will be effectively 0 for any non-trivial difference, so the **rate ratio** (focus rate / baseline rate) is the substantive answer.\n",
+ "\n",
+ "We complement the chi-square with a **two-sample Kolmogorov–Smirnov test** on the underlying continuous scores (`score___label__science` and `score___label__hq`) so the comparison is grounded in distributional differences, not just thresholded labels."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "mlc-15-tests",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:19.385657Z",
+ "iopub.status.busy": "2026-06-01T14:17:19.385608Z",
+ "iopub.status.idle": "2026-06-01T14:17:19.560335Z",
+ "shell.execute_reply": "2026-06-01T14:17:19.559969Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Chi-square on binary labels:\n",
+ " CC-MAIN-2024-18 rate CC-SUPPLEMENTAL-2026-22 rate rate ratio (focus / baseline) chi2 p\n",
+ "label \n",
+ "is_science 0.113543 0.521776 4.595404 384404.736904 0.0\n",
+ "is_hq 0.085984 0.149193 1.735122 19250.278261 0.0\n",
+ "is_sci_and_hq 0.021508 0.118603 5.514358 72349.694228 0.0\n",
+ "\n",
+ "Kolmogorov–Smirnov on continuous scores:\n",
+ " name KS statistic KS p\n",
+ "column \n",
+ "score_m0___label__science science prob. 0.409693 0.0\n",
+ "score_m1___label__hq HQ prob. 0.213082 0.0\n"
+ ]
+ }
+ ],
+ "source": [
+ "rows = []\n",
+ "for label in (\"is_science\", \"is_hq\", \"is_sci_and_hq\"):\n",
+ " f_pos = int(focus_lbl[label].sum())\n",
+ " f_neg = len(focus_lbl) - f_pos\n",
+ " b_pos = int(baseline_lbl[label].sum())\n",
+ " b_neg = len(baseline_lbl) - b_pos\n",
+ " table = np.array([[f_pos, f_neg], [b_pos, b_neg]])\n",
+ " chi2, p, _dof, _ = stats.chi2_contingency(table)\n",
+ " p_focus = f_pos / len(focus_lbl)\n",
+ " p_base = b_pos / len(baseline_lbl) if len(baseline_lbl) else 0.0\n",
+ " ratio = p_focus / p_base if p_base else float(\"inf\")\n",
+ " rows.append(\n",
+ " {\n",
+ " \"label\": label,\n",
+ " f\"{BASELINE_NAME} rate\": p_base,\n",
+ " f\"{FOCUS_NAME} rate\": p_focus,\n",
+ " \"rate ratio (focus / baseline)\": ratio,\n",
+ " \"chi2\": chi2,\n",
+ " \"p\": p,\n",
+ " }\n",
+ " )\n",
+ "chi_df = pd.DataFrame(rows).set_index(\"label\")\n",
+ "\n",
+ "ks_rows = []\n",
+ "for col, friendly in [(SCI_SCIENCE, \"science prob.\"), (HQ_HQ, \"HQ prob.\")]:\n",
+ " ks = stats.ks_2samp(baseline[col], focus[col], method=\"auto\")\n",
+ " ks_rows.append(\n",
+ " {\n",
+ " \"column\": col,\n",
+ " \"name\": friendly,\n",
+ " \"KS statistic\": ks.statistic,\n",
+ " \"KS p\": ks.pvalue,\n",
+ " }\n",
+ " )\n",
+ "ks_df = pd.DataFrame(ks_rows).set_index(\"column\")\n",
+ "\n",
+ "print(\"Chi-square on binary labels:\")\n",
+ "print(chi_df.round(6).to_string())\n",
+ "print(\"\\nKolmogorov\\u2013Smirnov on continuous scores:\")\n",
+ "print(ks_df.round(6).to_string())"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "mlc-16-verdict-md",
+ "metadata": {},
+ "source": [
+ "## 8. Verdict\n",
+ "\n",
+ "One-paragraph summary computed from the cells above."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "mlc-17-verdict",
+ "metadata": {
+ "execution": {
+ "iopub.execute_input": "2026-06-01T14:17:19.561253Z",
+ "iopub.status.busy": "2026-06-01T14:17:19.561203Z",
+ "iopub.status.idle": "2026-06-01T14:17:19.565547Z",
+ "shell.execute_reply": "2026-06-01T14:17:19.565300Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Comparison: CC-SUPPLEMENTAL-2026-22 vs CC-MAIN-2024-18\n",
+ " is_science focus=0.5218 baseline=0.1135 lift=4.60x\n",
+ " is_hq focus=0.1492 baseline=0.0860 lift=1.74x\n",
+ " is_sci_and_hq focus=0.1186 baseline=0.0215 lift=5.51x\n",
+ "\n",
+ "Joint pages (science AND high quality):\n",
+ " CC-MAIN-2024-18: 21,508 of 1,000,000\n",
+ " CC-SUPPLEMENTAL-2026-22: 118,576 of 999,774\n",
+ " absolute delta: +97,068 (focus has 5.51x the rate of the baseline)\n"
+ ]
+ }
+ ],
+ "source": [
+ "sci_lift = focus_lbl[\"is_science\"].mean() / max(baseline_lbl[\"is_science\"].mean(), 1e-12)\n",
+ "hq_lift = focus_lbl[\"is_hq\"].mean() / max(baseline_lbl[\"is_hq\"].mean(), 1e-12)\n",
+ "joint_lift = focus_lbl[\"is_sci_and_hq\"].mean() / max(baseline_lbl[\"is_sci_and_hq\"].mean(), 1e-12)\n",
+ "\n",
+ "b_joint = int(baseline_lbl[\"is_sci_and_hq\"].sum())\n",
+ "f_joint = int(focus_lbl[\"is_sci_and_hq\"].sum())\n",
+ "\n",
+ "print(f\"Comparison: {FOCUS_NAME} vs {BASELINE_NAME}\")\n",
+ "print(f\" is_science focus={focus_lbl['is_science'].mean():.4f} baseline={baseline_lbl['is_science'].mean():.4f} lift={sci_lift:.2f}x\")\n",
+ "print(f\" is_hq focus={focus_lbl['is_hq'].mean():.4f} baseline={baseline_lbl['is_hq'].mean():.4f} lift={hq_lift:.2f}x\")\n",
+ "print(f\" is_sci_and_hq focus={focus_lbl['is_sci_and_hq'].mean():.4f} baseline={baseline_lbl['is_sci_and_hq'].mean():.4f} lift={joint_lift:.2f}x\")\n",
+ "print()\n",
+ "print(\"Joint pages (science AND high quality):\")\n",
+ "print(f\" {BASELINE_NAME}: {b_joint:,} of {len(baseline_lbl):,}\")\n",
+ "print(f\" {FOCUS_NAME}: {f_joint:,} of {len(focus_lbl):,}\")\n",
+ "print(f\" absolute delta: {f_joint - b_joint:+,d} (focus has {joint_lift:.2f}x the rate of the baseline)\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.12.13"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
From 6a67460d20c5363a42614bd0a3ac3277b782bf1b Mon Sep 17 00:00:00 2001
From: malteos
Date: Mon, 1 Jun 2026 16:30:47 +0200
Subject: [PATCH 3/3] fixed notebook
---
notebooks/compare_multi_label_scores.ipynb | 470 ++++-----------------
1 file changed, 85 insertions(+), 385 deletions(-)
diff --git a/notebooks/compare_multi_label_scores.ipynb b/notebooks/compare_multi_label_scores.ipynb
index 333e033..bbbea50 100644
--- a/notebooks/compare_multi_label_scores.ipynb
+++ b/notebooks/compare_multi_label_scores.ipynb
@@ -12,14 +12,12 @@
"- **CC-MAIN-2024-18** — baseline\n",
"- **CC-SUPPLEMENTAL-2026-22** — focus (Open Athena project)\n",
"\n",
- "Each row has four score columns produced in a single pass:\n",
+ "Each row of the input CSVs has four score columns produced in a single pass:\n",
"\n",
- "| Column | Source | Meaning |\n",
- "|------------------------------|---------------------------------------------|----------------------------------|\n",
- "| `score_m0___label__science` | `ibm-granite/GneissWeb.Sci_classifier` | P(page is science) |\n",
- "| `score_m0___label__cc` | `ibm-granite/GneissWeb.Sci_classifier` | P(page is generic Common Crawl) |\n",
- "| `score_m1___label__hq` | `ibm-granite/GneissWeb.Quality_annotator` | P(page is high quality) |\n",
- "| `score_m1___label__cc` | `ibm-granite/GneissWeb.Quality_annotator` | P(page is generic Common Crawl) |\n",
+ "- `score_m0___label__science` — `ibm-granite/GneissWeb.Sci_classifier`, P(page is science)\n",
+ "- `score_m0___label__cc` — same model, P(page is generic Common Crawl)\n",
+ "- `score_m1___label__hq` — `ibm-granite/GneissWeb.Quality_annotator`, P(page is high quality)\n",
+ "- `score_m1___label__cc` — same model, P(page is generic Common Crawl)\n",
"\n",
"The two scores from each model sum to 1.0 per row by construction (softmax).\n",
"\n",
@@ -43,10 +41,10 @@
"id": "mlc-01-imports",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:13.835417Z",
- "iopub.status.busy": "2026-06-01T14:17:13.835268Z",
- "iopub.status.idle": "2026-06-01T14:17:15.214316Z",
- "shell.execute_reply": "2026-06-01T14:17:15.213944Z"
+ "iopub.execute_input": "2026-06-01T14:26:01.911346Z",
+ "iopub.status.busy": "2026-06-01T14:26:01.911221Z",
+ "iopub.status.idle": "2026-06-01T14:26:02.772015Z",
+ "shell.execute_reply": "2026-06-01T14:26:02.771662Z"
}
},
"outputs": [
@@ -108,10 +106,10 @@
"id": "mlc-03-load",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:15.215422Z",
- "iopub.status.busy": "2026-06-01T14:17:15.215336Z",
- "iopub.status.idle": "2026-06-01T14:17:16.112684Z",
- "shell.execute_reply": "2026-06-01T14:17:16.112294Z"
+ "iopub.execute_input": "2026-06-01T14:26:02.773165Z",
+ "iopub.status.busy": "2026-06-01T14:26:02.773067Z",
+ "iopub.status.idle": "2026-06-01T14:26:03.721906Z",
+ "shell.execute_reply": "2026-06-01T14:26:03.721445Z"
}
},
"outputs": [
@@ -160,259 +158,44 @@
"id": "mlc-05-stats",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:16.113688Z",
- "iopub.status.busy": "2026-06-01T14:17:16.113638Z",
- "iopub.status.idle": "2026-06-01T14:17:16.362014Z",
- "shell.execute_reply": "2026-06-01T14:17:16.361615Z"
+ "iopub.execute_input": "2026-06-01T14:26:03.722891Z",
+ "iopub.status.busy": "2026-06-01T14:26:03.722832Z",
+ "iopub.status.idle": "2026-06-01T14:26:03.963331Z",
+ "shell.execute_reply": "2026-06-01T14:26:03.962976Z"
}
},
"outputs": [
{
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " \n",
- " CC-MAIN-2024-18 \n",
- " CC-SUPPLEMENTAL-2026-22 \n",
- " delta \n",
- " \n",
- " \n",
- " column \n",
- " stat \n",
- " \n",
- " \n",
- " \n",
- " \n",
- " \n",
- " \n",
- " \n",
- " score_m0___label__science \n",
- " mean \n",
- " 0.142090 \n",
- " 0.517199 \n",
- " 0.375109 \n",
- " \n",
- " \n",
- " median \n",
- " 0.006990 \n",
- " 0.576132 \n",
- " 0.569142 \n",
- " \n",
- " \n",
- " p25 \n",
- " 0.000052 \n",
- " 0.019895 \n",
- " 0.019843 \n",
- " \n",
- " \n",
- " p75 \n",
- " 0.179258 \n",
- " 0.989210 \n",
- " 0.809953 \n",
- " \n",
- " \n",
- " p95 \n",
- " 0.731946 \n",
- " 1.000009 \n",
- " 0.268063 \n",
- " \n",
- " \n",
- " p99 \n",
- " 0.988988 \n",
- " 1.000010 \n",
- " 0.011022 \n",
- " \n",
- " \n",
- " score_m0___label__cc \n",
- " mean \n",
- " 0.857930 \n",
- " 0.482821 \n",
- " -0.375109 \n",
- " \n",
- " \n",
- " median \n",
- " 0.993030 \n",
- " 0.423888 \n",
- " -0.569142 \n",
- " \n",
- " \n",
- " p25 \n",
- " 0.820763 \n",
- " 0.010810 \n",
- " -0.809953 \n",
- " \n",
- " \n",
- " p75 \n",
- " 0.999968 \n",
- " 0.980125 \n",
- " -0.019843 \n",
- " \n",
- " \n",
- " p95 \n",
- " 1.000010 \n",
- " 0.999974 \n",
- " -0.000036 \n",
- " \n",
- " \n",
- " p99 \n",
- " 1.000010 \n",
- " 1.000010 \n",
- " 0.000000 \n",
- " \n",
- " \n",
- " score_m1___label__hq \n",
- " mean \n",
- " 0.106053 \n",
- " 0.174356 \n",
- " 0.068303 \n",
- " \n",
- " \n",
- " median \n",
- " 0.000295 \n",
- " 0.019288 \n",
- " 0.018993 \n",
- " \n",
- " \n",
- " p25 \n",
- " 0.000010 \n",
- " 0.000082 \n",
- " 0.000072 \n",
- " \n",
- " \n",
- " p75 \n",
- " 0.048318 \n",
- " 0.230062 \n",
- " 0.181744 \n",
- " \n",
- " \n",
- " p95 \n",
- " 0.834057 \n",
- " 0.882294 \n",
- " 0.048237 \n",
- " \n",
- " \n",
- " p99 \n",
- " 0.999977 \n",
- " 0.997152 \n",
- " -0.002825 \n",
- " \n",
- " \n",
- " score_m1___label__cc \n",
- " mean \n",
- " 0.893967 \n",
- " 0.825664 \n",
- " -0.068303 \n",
- " \n",
- " \n",
- " median \n",
- " 0.999725 \n",
- " 0.980732 \n",
- " -0.018993 \n",
- " \n",
- " \n",
- " p25 \n",
- " 0.951702 \n",
- " 0.769958 \n",
- " -0.181744 \n",
- " \n",
- " \n",
- " p75 \n",
- " 1.000010 \n",
- " 0.999938 \n",
- " -0.000072 \n",
- " \n",
- " \n",
- " p95 \n",
- " 1.000010 \n",
- " 1.000010 \n",
- " 0.000000 \n",
- " \n",
- " \n",
- " p99 \n",
- " 1.000010 \n",
- " 1.000010 \n",
- " 0.000000 \n",
- " \n",
- " \n",
- "
\n",
- "
"
- ],
- "text/plain": [
- " CC-MAIN-2024-18 CC-SUPPLEMENTAL-2026-22 \\\n",
- "column stat \n",
- "score_m0___label__science mean 0.142090 0.517199 \n",
- " median 0.006990 0.576132 \n",
- " p25 0.000052 0.019895 \n",
- " p75 0.179258 0.989210 \n",
- " p95 0.731946 1.000009 \n",
- " p99 0.988988 1.000010 \n",
- "score_m0___label__cc mean 0.857930 0.482821 \n",
- " median 0.993030 0.423888 \n",
- " p25 0.820763 0.010810 \n",
- " p75 0.999968 0.980125 \n",
- " p95 1.000010 0.999974 \n",
- " p99 1.000010 1.000010 \n",
- "score_m1___label__hq mean 0.106053 0.174356 \n",
- " median 0.000295 0.019288 \n",
- " p25 0.000010 0.000082 \n",
- " p75 0.048318 0.230062 \n",
- " p95 0.834057 0.882294 \n",
- " p99 0.999977 0.997152 \n",
- "score_m1___label__cc mean 0.893967 0.825664 \n",
- " median 0.999725 0.980732 \n",
- " p25 0.951702 0.769958 \n",
- " p75 1.000010 0.999938 \n",
- " p95 1.000010 1.000010 \n",
- " p99 1.000010 1.000010 \n",
- "\n",
- " delta \n",
- "column stat \n",
- "score_m0___label__science mean 0.375109 \n",
- " median 0.569142 \n",
- " p25 0.019843 \n",
- " p75 0.809953 \n",
- " p95 0.268063 \n",
- " p99 0.011022 \n",
- "score_m0___label__cc mean -0.375109 \n",
- " median -0.569142 \n",
- " p25 -0.809953 \n",
- " p75 -0.019843 \n",
- " p95 -0.000036 \n",
- " p99 0.000000 \n",
- "score_m1___label__hq mean 0.068303 \n",
- " median 0.018993 \n",
- " p25 0.000072 \n",
- " p75 0.181744 \n",
- " p95 0.048237 \n",
- " p99 -0.002825 \n",
- "score_m1___label__cc mean -0.068303 \n",
- " median -0.018993 \n",
- " p25 -0.181744 \n",
- " p75 -0.000072 \n",
- " p95 0.000000 \n",
- " p99 0.000000 "
- ]
- },
- "execution_count": 3,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " CC-MAIN-2024-18 CC-SUPPLEMENTAL-2026-22 delta\n",
+ "column stat \n",
+ "score_m0___label__science mean 0.142090 0.517199 0.375109\n",
+ " median 0.006990 0.576132 0.569142\n",
+ " p25 0.000052 0.019895 0.019843\n",
+ " p75 0.179258 0.989210 0.809953\n",
+ " p95 0.731946 1.000009 0.268063\n",
+ " p99 0.988988 1.000010 0.011022\n",
+ "score_m0___label__cc mean 0.857930 0.482821 -0.375109\n",
+ " median 0.993030 0.423888 -0.569142\n",
+ " p25 0.820763 0.010810 -0.809953\n",
+ " p75 0.999968 0.980125 -0.019843\n",
+ " p95 1.000010 0.999974 -0.000036\n",
+ " p99 1.000010 1.000010 0.000000\n",
+ "score_m1___label__hq mean 0.106053 0.174356 0.068303\n",
+ " median 0.000295 0.019288 0.018993\n",
+ " p25 0.000010 0.000082 0.000072\n",
+ " p75 0.048318 0.230062 0.181744\n",
+ " p95 0.834057 0.882294 0.048237\n",
+ " p99 0.999977 0.997152 -0.002825\n",
+ "score_m1___label__cc mean 0.893967 0.825664 -0.068303\n",
+ " median 0.999725 0.980732 -0.018993\n",
+ " p25 0.951702 0.769958 -0.181744\n",
+ " p75 1.000010 0.999938 -0.000072\n",
+ " p95 1.000010 1.000010 0.000000\n",
+ " p99 1.000010 1.000010 0.000000\n"
+ ]
}
],
"source": [
@@ -443,7 +226,7 @@
" }\n",
" )\n",
"stats_df = pd.DataFrame(rows).set_index([\"column\", \"stat\"])\n",
- "stats_df.round(6)"
+ "print(stats_df.round(6).to_string())"
]
},
{
@@ -462,10 +245,10 @@
"id": "mlc-07-dist",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:16.363090Z",
- "iopub.status.busy": "2026-06-01T14:17:16.363040Z",
- "iopub.status.idle": "2026-06-01T14:17:19.225361Z",
- "shell.execute_reply": "2026-06-01T14:17:19.225049Z"
+ "iopub.execute_input": "2026-06-01T14:26:03.964377Z",
+ "iopub.status.busy": "2026-06-01T14:26:03.964328Z",
+ "iopub.status.idle": "2026-06-01T14:26:06.843207Z",
+ "shell.execute_reply": "2026-06-01T14:26:06.842810Z"
}
},
"outputs": [
@@ -538,109 +321,26 @@
"id": "mlc-09-binary",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:19.226495Z",
- "iopub.status.busy": "2026-06-01T14:17:19.226421Z",
- "iopub.status.idle": "2026-06-01T14:17:19.240514Z",
- "shell.execute_reply": "2026-06-01T14:17:19.240141Z"
+ "iopub.execute_input": "2026-06-01T14:26:06.844315Z",
+ "iopub.status.busy": "2026-06-01T14:26:06.844245Z",
+ "iopub.status.idle": "2026-06-01T14:26:06.860865Z",
+ "shell.execute_reply": "2026-06-01T14:26:06.860475Z"
}
},
"outputs": [
{
- "data": {
- "text/html": [
- "\n",
- "\n",
- "
\n",
- " \n",
- " \n",
- " \n",
- " CC-MAIN-2024-18 \n",
- " CC-SUPPLEMENTAL-2026-22 \n",
- " lift (focus / baseline) \n",
- " \n",
- " \n",
- " \n",
- " \n",
- " n \n",
- " 1000000.000000 \n",
- " 999774.000000 \n",
- " 0.999774 \n",
- " \n",
- " \n",
- " is_science_count \n",
- " 113543.000000 \n",
- " 521658.000000 \n",
- " 4.594365 \n",
- " \n",
- " \n",
- " is_science_share \n",
- " 0.113543 \n",
- " 0.521776 \n",
- " 4.595404 \n",
- " \n",
- " \n",
- " is_hq_count \n",
- " 85984.000000 \n",
- " 149159.000000 \n",
- " 1.734730 \n",
- " \n",
- " \n",
- " is_hq_share \n",
- " 0.085984 \n",
- " 0.149193 \n",
- " 1.735122 \n",
- " \n",
- " \n",
- " is_sci_and_hq_count \n",
- " 21508.000000 \n",
- " 118576.000000 \n",
- " 5.513111 \n",
- " \n",
- " \n",
- " is_sci_and_hq_share \n",
- " 0.021508 \n",
- " 0.118603 \n",
- " 5.514358 \n",
- " \n",
- " \n",
- "
\n",
- "
"
- ],
- "text/plain": [
- " CC-MAIN-2024-18 CC-SUPPLEMENTAL-2026-22 \\\n",
- "n 1000000.000000 999774.000000 \n",
- "is_science_count 113543.000000 521658.000000 \n",
- "is_science_share 0.113543 0.521776 \n",
- "is_hq_count 85984.000000 149159.000000 \n",
- "is_hq_share 0.085984 0.149193 \n",
- "is_sci_and_hq_count 21508.000000 118576.000000 \n",
- "is_sci_and_hq_share 0.021508 0.118603 \n",
- "\n",
- " lift (focus / baseline) \n",
- "n 0.999774 \n",
- "is_science_count 4.594365 \n",
- "is_science_share 4.595404 \n",
- "is_hq_count 1.734730 \n",
- "is_hq_share 1.735122 \n",
- "is_sci_and_hq_count 5.513111 \n",
- "is_sci_and_hq_share 5.514358 "
- ]
- },
- "execution_count": 5,
- "metadata": {},
- "output_type": "execute_result"
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ " CC-MAIN-2024-18 CC-SUPPLEMENTAL-2026-22 lift (focus / baseline)\n",
+ "n 1000000.000000 999774.000000 0.999774\n",
+ "is_science_count 113543.000000 521658.000000 4.594365\n",
+ "is_science_share 0.113543 0.521776 4.595404\n",
+ "is_hq_count 85984.000000 149159.000000 1.734730\n",
+ "is_hq_share 0.085984 0.149193 1.735122\n",
+ "is_sci_and_hq_count 21508.000000 118576.000000 5.513111\n",
+ "is_sci_and_hq_share 0.021508 0.118603 5.514358\n"
+ ]
}
],
"source": [
@@ -671,7 +371,7 @@
"\n",
"prev = pd.DataFrame({BASELINE_NAME: prevalence(baseline_lbl), FOCUS_NAME: prevalence(focus_lbl)})\n",
"prev[\"lift (focus / baseline)\"] = prev[FOCUS_NAME] / prev[BASELINE_NAME].replace({0: np.nan})\n",
- "prev.round(6)"
+ "print(prev.round(6).to_string())"
]
},
{
@@ -690,10 +390,10 @@
"id": "mlc-11-confusion",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:19.241427Z",
- "iopub.status.busy": "2026-06-01T14:17:19.241378Z",
- "iopub.status.idle": "2026-06-01T14:17:19.327576Z",
- "shell.execute_reply": "2026-06-01T14:17:19.327137Z"
+ "iopub.execute_input": "2026-06-01T14:26:06.861987Z",
+ "iopub.status.busy": "2026-06-01T14:26:06.861929Z",
+ "iopub.status.idle": "2026-06-01T14:26:06.947902Z",
+ "shell.execute_reply": "2026-06-01T14:26:06.947592Z"
}
},
"outputs": [
@@ -745,10 +445,10 @@
"id": "mlc-13-bar",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:19.328638Z",
- "iopub.status.busy": "2026-06-01T14:17:19.328570Z",
- "iopub.status.idle": "2026-06-01T14:17:19.384612Z",
- "shell.execute_reply": "2026-06-01T14:17:19.384302Z"
+ "iopub.execute_input": "2026-06-01T14:26:06.949015Z",
+ "iopub.status.busy": "2026-06-01T14:26:06.948947Z",
+ "iopub.status.idle": "2026-06-01T14:26:07.009880Z",
+ "shell.execute_reply": "2026-06-01T14:26:07.009539Z"
}
},
"outputs": [
@@ -828,10 +528,10 @@
"id": "mlc-15-tests",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:19.385657Z",
- "iopub.status.busy": "2026-06-01T14:17:19.385608Z",
- "iopub.status.idle": "2026-06-01T14:17:19.560335Z",
- "shell.execute_reply": "2026-06-01T14:17:19.559969Z"
+ "iopub.execute_input": "2026-06-01T14:26:07.010875Z",
+ "iopub.status.busy": "2026-06-01T14:26:07.010822Z",
+ "iopub.status.idle": "2026-06-01T14:26:07.194180Z",
+ "shell.execute_reply": "2026-06-01T14:26:07.193843Z"
}
},
"outputs": [
@@ -913,10 +613,10 @@
"id": "mlc-17-verdict",
"metadata": {
"execution": {
- "iopub.execute_input": "2026-06-01T14:17:19.561253Z",
- "iopub.status.busy": "2026-06-01T14:17:19.561203Z",
- "iopub.status.idle": "2026-06-01T14:17:19.565547Z",
- "shell.execute_reply": "2026-06-01T14:17:19.565300Z"
+ "iopub.execute_input": "2026-06-01T14:26:07.195262Z",
+ "iopub.status.busy": "2026-06-01T14:26:07.195196Z",
+ "iopub.status.idle": "2026-06-01T14:26:07.199547Z",
+ "shell.execute_reply": "2026-06-01T14:26:07.199268Z"
}
},
"outputs": [