jeffy-classify 0.1.0a8__py3-none-any.whl

jeffy/__init__.py

@@ -0,0 +1,7 @@
+"""Jeffy: a pretrained local decision engine.
+
+Reusable embeddings + small classifiers, shipped with pretrained
+capabilities and reproducible benchmarks.
+"""
+
+__version__ = "0.1.0a7"

jeffy/benchmark_page.py

@@ -0,0 +1,200 @@
+"""Generate benchmark HTML page from evaluation results.
+
+Usage:
+    python -m jeffy.benchmark_page
+"""
+
+import json
+from pathlib import Path
+
+
+def generate_html(results_path: str = "data/eval_results/benchmark.json",
+                  jeff_path: str = "data/eval_results/jeff_comparison.json",
+                  output_path: str = "data/eval_results/benchmark.html"):
+    with open(results_path) as f:
+        data = json.load(f)
+
+    # Load Jeff results if available
+    jeff_data = {}
+    jeff_note = "not evaluated"
+    jeff_path = Path(jeff_path)
+    if jeff_path.exists():
+        with open(jeff_path) as f:
+            jeff_raw = json.load(f)
+        for r in jeff_raw.get("results", []):
+            jeff_data[r["task_id"]] = r
+        jeff_note = jeff_raw.get("note", "")
+
+    results = sorted(data["results"], key=lambda r: -r["accuracy"])
+    hw = data.get("hardware", {})
+
+    rows = ""
+    for r in results:
+        bl_maj = r["baselines"]["majority"]["accuracy"] if r.get("baselines") else None
+        bl_tfidf = r["baselines"]["tfidf_lr"]["accuracy"] if r.get("baselines") else None
+        lat = r["latency"]["total_p50_ms"] if r.get("latency") else None
+        emb_lat = r["latency"]["embed_p50_ms"] if r.get("latency") else None
+        clf_lat = r["latency"]["clf_p50_ms"] if r.get("latency") else None
+        notes = "; ".join(r.get("notes", []))
+        ci = f'[{r["accuracy_ci_lo"]:.3f}, {r["accuracy_ci_hi"]:.3f}]'
+
+        # Clinc detail
+        extra = ""
+        if r.get("clinc_detail"):
+            cd = r["clinc_detail"]
+            extra = f' (in-scope {cd["in_scope_acc"]:.1%}, OOS {cd["oos_acc"]:.1%})'
+
+        artifact_kb = {"banking77": 334, "clinc_oos": 632, "massive_intent": 271,
+                       "ag_news": 41, "dbpedia": 81, "emotion": 49, "imdb": 29,
+                       "sms_spam": 29, "snli": 37, "sst2": 29,
+                       "tweet_eval_emotion": 41, "tweet_eval_offensive": 29,
+                       "tweet_eval_sentiment": 37}.get(r["task_id"], "?")
+
+        rows += f"""<tr>
+<td><strong>{r['task_id']}</strong><br><small>{r['name']}</small></td>
+<td>{r['n_classes']}</td>
+<td>{r['test_examples']}</td>
+<td>{r['eval_split']}</td>
+<td><strong>{r['accuracy']:.1%}</strong><br><small>{ci}</small></td>
+<td>{r['macro_f1']:.1%}</td>
+<td>{f'{bl_maj:.1%}' if bl_maj is not None else '—'}</td>
+<td>{f'{bl_tfidf:.1%}' if bl_tfidf is not None else '—'}</td>
+<td>{f'{jeff_data[r["task_id"]]["jeff"]["accuracy_all"]:.1%}' if r['task_id'] in jeff_data and 'jeff' in jeff_data[r['task_id']] else (f'{jeff_data[r["task_id"]].get("jeff_accuracy",0):.1%}' if r['task_id'] in jeff_data and 'jeff_accuracy' in jeff_data[r['task_id']] else 'not evaluated')}</td>
+<td>{lat:.0f}ms<br><small>emb {emb_lat:.0f} + clf {clf_lat:.2f}</small></td>
+<td>{artifact_kb} KB</td>
+</tr>\n"""
+
+    avg_acc = sum(r["accuracy"] for r in results) / len(results)
+    avg_f1 = sum(r["macro_f1"] for r in results) / len(results)
+
+    html = f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Jeffy Benchmark</title>
+<style>
+:root{{--mono:ui-monospace,SFMono-Regular,Consolas,monospace;--accent:#2563eb}}
+*{{box-sizing:border-box}}
+body{{margin:0;font:14px/1.6 var(--mono);color:#111;background:#fff;padding:32px}}
+.container{{max-width:1400px;margin:auto}}
+h1{{font-size:28px;font-weight:700;margin:0 0 4px}}
+.sub{{color:#555;font-size:13px;margin-bottom:24px}}
+h2{{font-size:18px;margin:32px 0 12px;border-bottom:1px solid #e5e5e5;padding-bottom:8px}}
+table{{border-collapse:collapse;width:100%;font-size:12px}}
+th,td{{padding:8px 10px;text-align:left;border-bottom:1px solid #eee}}
+th{{background:#f8f8f8;font-weight:600;position:sticky;top:0}}
+tr:hover{{background:#f0f7ff}}
+small{{color:#777}}
+strong{{font-weight:600}}
+.meta{{font-size:12px;color:#555;margin:16px 0;line-height:1.8}}
+.meta dt{{font-weight:600;display:inline}}
+.meta dd{{display:inline;margin:0 16px 0 0}}
+.note{{background:#fffbeb;border:1px solid #fde68a;border-radius:6px;padding:12px;font-size:12px;margin:16px 0}}
+.arch{{background:#f0f7ff;border:1px solid #bfdbfe;border-radius:6px;padding:16px;font-size:13px;margin:16px 0}}
+code{{background:#f5f5f5;padding:2px 5px;border-radius:3px;font-size:12px}}
+a{{color:var(--accent)}}
+</style>
+</head>
+<body>
+<div class="container">
+<h1>Jeffy Benchmark</h1>
+<p class="sub">Frozen pretrained embeddings + task-specific logistic heads. Evaluated {data['evaluation_date']}.</p>
+
+<div class="arch">
+<strong>Architecture:</strong> BAAI/bge-large-en-v1.5 (1024d frozen encoder, ~1.2 GB) → StandardScaler → LogisticRegression (C=0.01, newton-cg)<br>
+<strong>Each head:</strong> 1 scaler + 1 linear classifier. No fine-tuning, no MLP, no generation.<br>
+<strong>Training regime:</strong> Each head trained on up to 10,000 examples from the dataset's training split (seed=42 for subsampling).<br>
+<strong>Comparison context:</strong> Jeffy heads are task-trained; Jeff and similar zero-shot models are not. This is a deployment comparison, not an equal-supervision experiment.<br>
+<strong>Baselines:</strong> TF-IDF+LR tuned via 3-fold CV over C in {{0.01, 0.1, 1, 10}}, analyzer in {{word, char_wb}}, ngram_range in {{(1,1), (1,2)}}, max_features in {{10000, 30000}}. Vectorizer fit inside each fold.
+</div>
+
+<h2>Results</h2>
+<table>
+<thead>
+<tr>
+<th>Task</th><th>Classes</th><th>Test N</th><th>Split</th>
+<th>Accuracy</th><th>Macro F1</th>
+<th>Majority</th><th>TF-IDF+LR</th><th>Jeff</th>
+<th>Latency (p50)</th><th>Head Size</th>
+</tr>
+</thead>
+<tbody>
+{rows}
+<tr style="font-weight:600;border-top:2px solid #333">
+<td>Average (13 tasks)</td><td></td><td></td><td></td>
+<td>{avg_acc:.1%}</td><td>{avg_f1:.1%}</td>
+<td></td><td></td><td></td><td></td><td></td>
+</tr>
+</tbody>
+</table>
+
+<div class="note">
+<strong>Jeff comparison:</strong> Not yet evaluated locally. Jeff is a zero-shot decision model (no per-task training).
+A fair comparison requires running Jeff on identical evaluation examples with the same label meanings.
+Jeffy's advantage comes from task-specific training; Jeff's advantage is generalization without training data.
+</div>
+
+<h2>Task-Specific Notes</h2>
+<dl class="meta">
+<dt>SST-2:</dt><dd>Evaluated on validation split; official test labels are not public.</dd>
+<dt>SMS Spam:</dt><dd>Random train/test split (test_size=0.2, seed=42); no standard benchmark split.</dd>
+<dt>SNLI:</dt><dd>Input encoded as "premise [SEP] hypothesis". Label -1 (unlabeled) filtered.</dd>
+<dt>CLINC-OOS:</dt><dd>151 classes including out-of-scope. In-scope accuracy {[r for r in results if r['task_id']=='clinc_oos'][0].get('clinc_detail',{}).get('in_scope_acc','?'):.1%}, OOS detection {[r for r in results if r['task_id']=='clinc_oos'][0].get('clinc_detail',{}).get('oos_acc','?'):.1%}.</dd>
+<dt>MASSIVE:</dt><dd>English subset only (config='en'). String labels used directly.</dd>
+</dl>
+
+<h2>Infrastructure</h2>
+<dl class="meta">
+<dt>Hardware:</dt><dd>{hw.get('platform','?')}, {hw.get('cpu_count','?')} cores, {hw.get('ram_gb','?')} GB RAM</dd>
+<dt>Encoder:</dt><dd>BAAI/bge-large-en-v1.5, ~1.2 GB on disk, {data.get('encoder_load_time_s','?')}s load time</dd>
+<dt>Total pack:</dt><dd>{data.get('pack_total_bytes',0)/1024:.0f} KB (13 heads, no encoder)</dd>
+<dt>Threads:</dt><dd>Recorded: device={hw.get('device','?')}, torch_threads={hw.get('torch_threads','?')}, OMP_NUM_THREADS={hw.get('omp_threads','?')}</dd>
+<dt>Batch size:</dt><dd>1 (single-example inference measured)</dd>
+<dt>Caching:</dt><dd>No embedding cache; each request embeds fresh</dd>
+<dt>Truncation:</dt><dd>Default sentence-transformers truncation (512 tokens)</dd>
+</dl>
+
+<h2>Reproduce</h2>
+<pre><code># Install
+pip install sentence-transformers scikit-learn fastapi uvicorn
+
+# Build model pack from source datasets
+python -m jeffy.build_pack --out data/model_pack
+
+# Run evaluation
+python -m jeffy.evaluate --baselines --latency
+
+# Start server with playground
+python -m jeffy.server
+# Open http://localhost:8400
+</code></pre>
+
+<h2>API</h2>
+<pre><code># Predict with a pretrained head
+curl -X POST http://localhost:8400/v1/predict \\
+  -H "Content-Type: application/json" \\
+  -d '{{"text": "I was charged twice", "task": "banking77"}}'
+
+# List capabilities
+curl http://localhost:8400/v1/capabilities
+
+# Jeff-compatible endpoint (matches criteria to pretrained heads)
+curl -X POST http://localhost:8400/v1/systemone \\
+  -H "Content-Type: application/json" \\
+  -d '{{"model":"jeffy","state":"I was charged twice",
+       "questions":{{"intent":{{"type":"choice","criteria":{{
+         "transaction_charged_twice":null,"request_refund":null,
+         "cancel_transfer":null}}}}}}}}'
+</code></pre>
+
+</div>
+</body>
+</html>"""
+
+    Path(output_path).write_text(html)
+    print(f"Benchmark page: {output_path}")
+
+
+if __name__ == "__main__":
+    generate_html()

jeffy/build_pack.py

@@ -0,0 +1,355 @@
+"""Build a verified model pack from source datasets.
+
+Trains each dataset independently, saves artifacts with explicit identity,
+recovers label mappings from the dataset features, and verifies roundtrip
+prediction fidelity.
+
+Usage:
+    python -m jeffy.build_pack
+    python -m jeffy.build_pack --datasets banking77 ag_news
+    python -m jeffy.build_pack --out data/model_pack
+"""
+
+import argparse
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+from sklearn.linear_model import LogisticRegression
+from sklearn.metrics import accuracy_score, f1_score
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+from .catalog import ENCODER, ENCODER_DIM, LICENSES
+from .model_pack import ArtifactManifest, coef_hash, save_artifact, scaler_hash
+
+# Dataset definitions with label recovery instructions
+DATASETS = {
+    "banking77": {
+        "hf": "legacy-datasets/banking77",
+        "text": "text", "label": "label",
+        "description": "Banking customer service intent detection",
+        "task_type": "choice",
+        "label_source": "features",  # labels from dataset.features['label'].names
+    },
+    "clinc_oos": {
+        "hf": "clinc_oos", "hf_config": "plus",
+        "text": "text", "label": "intent",
+        "description": "Intent detection with out-of-scope",
+        "task_type": "choice",
+        "label_source": "features",
+    },
+    "massive_intent": {
+        "hf": "mteb/amazon_massive_intent", "hf_config": "en",
+        "text": "text", "label": "label",
+        "description": "Amazon MASSIVE voice command intents",
+        "task_type": "choice",
+        "label_source": "string_values",  # labels ARE the string values
+    },
+    "ag_news": {
+        "hf": "fancyzhx/ag_news",
+        "text": "text", "label": "label",
+        "description": "News article topic classification",
+        "task_type": "choice",
+        "label_source": "features",
+    },
+    "dbpedia": {
+        "hf": "fancyzhx/dbpedia_14",
+        "text": "content", "label": "label",
+        "description": "Wikipedia article ontology classification",
+        "task_type": "choice",
+        "label_source": "features",
+    },
+    "sst2": {
+        "hf": "stanfordnlp/sst2",
+        "text": "sentence", "label": "label",
+        "split_test": "validation",
+        "description": "Movie review sentiment (positive/negative)",
+        "task_type": "noul",
+        "label_source": "manual",
+        "manual_labels": {"0": "negative", "1": "positive"},
+    },
+    "emotion": {
+        "hf": "dair-ai/emotion",
+        "text": "text", "label": "label",
+        "description": "Text emotion detection",
+        "task_type": "choice",
+        "label_source": "features",
+    },
+    "imdb": {
+        "hf": "stanfordnlp/imdb",
+        "text": "text", "label": "label",
+        "description": "Movie review sentiment (positive/negative)",
+        "task_type": "noul",
+        "label_source": "manual",
+        "manual_labels": {"0": "negative", "1": "positive"},
+    },
+    "sms_spam": {
+        "hf": "ucirvine/sms_spam",
+        "text": "sms", "label": "label",
+        "description": "SMS spam detection",
+        "task_type": "noul",
+        "label_source": "manual",
+        "manual_labels": {"0": "ham", "1": "spam"},
+    },
+    "snli": {
+        "hf": "stanfordnlp/snli",
+        "text": ["premise", "hypothesis"], "label": "label",
+        "filter_label": -1,
+        "description": "Natural language inference",
+        "task_type": "choice",
+        "label_source": "manual",
+        "manual_labels": {"0": "entailment", "1": "neutral", "2": "contradiction"},
+    },
+    "tweet_eval_sentiment": {
+        "hf": "cardiffnlp/tweet_eval", "hf_config": "sentiment",
+        "text": "text", "label": "label",
+        "description": "Tweet sentiment analysis",
+        "task_type": "choice",
+        "label_source": "manual",
+        "manual_labels": {"0": "negative", "1": "neutral", "2": "positive"},
+    },
+    "tweet_eval_emotion": {
+        "hf": "cardiffnlp/tweet_eval", "hf_config": "emotion",
+        "text": "text", "label": "label",
+        "description": "Tweet emotion detection",
+        "task_type": "choice",
+        "label_source": "manual",
+        "manual_labels": {"0": "anger", "1": "joy", "2": "optimism", "3": "sadness"},
+    },
+    "tweet_eval_offensive": {
+        "hf": "cardiffnlp/tweet_eval", "hf_config": "offensive",
+        "text": "text", "label": "label",
+        "description": "Offensive language detection",
+        "task_type": "noul",
+        "label_source": "manual",
+        "manual_labels": {"0": "not_offensive", "1": "offensive"},
+    },
+}
+
+
+def recover_labels(ds, config) -> dict[str, str]:
+    """Recover human-readable label mapping from the dataset source."""
+    source = config["label_source"]
+
+    if source == "manual":
+        return config["manual_labels"]
+
+    if source == "features":
+        label_col = config["label"]
+        feat = ds["train"].features[label_col]
+        if hasattr(feat, "names"):
+            return {str(i): name for i, name in enumerate(feat.names)}
+        raise ValueError(f"No .names on feature {label_col}")
+
+    if source == "string_values":
+        # Labels are the string values themselves
+        train_labels = sorted(set(ds["train"][config["label"]]))
+        return {label: label for label in train_labels}
+
+    raise ValueError(f"Unknown label_source: {source}")
+
+
+def load_and_split(ds_name, config, max_train=10000, max_test=2000):
+    """Load dataset, extract texts and string labels."""
+    from datasets import load_dataset
+    hf_config = config.get("hf_config")
+    ds = load_dataset(config["hf"], hf_config) if hf_config else load_dataset(config["hf"])
+
+    split_test = config.get("split_test", "test")
+    if split_test in ds:
+        train_ds, test_ds = ds["train"], ds[split_test]
+    elif "validation" in ds:
+        train_ds, test_ds = ds["train"], ds["validation"]
+    else:
+        split = ds["train"].train_test_split(test_size=0.2, seed=42)
+        train_ds, test_ds = split["train"], split["test"]
+
+    text_col = config["text"]
+    if isinstance(text_col, list):
+        train_texts = [" [SEP] ".join(train_ds[c][i] for c in text_col) for i in range(len(train_ds))]
+        test_texts = [" [SEP] ".join(test_ds[c][i] for c in text_col) for i in range(len(test_ds))]
+    else:
+        train_texts = list(train_ds[text_col])
+        test_texts = list(test_ds[text_col])
+
+    train_labels = [str(x) for x in train_ds[config["label"]]]
+    test_labels = [str(x) for x in test_ds[config["label"]]]
+
+    # Filter invalid
+    if "filter_label" in config:
+        fl = str(config["filter_label"])
+        mask = [l != fl for l in train_labels]
+        train_texts = [t for t, m in zip(train_texts, mask) if m]
+        train_labels = [l for l, m in zip(train_labels, mask) if m]
+        mask = [l != fl for l in test_labels]
+        test_texts = [t for t, m in zip(test_texts, mask) if m]
+        test_labels = [l for l, m in zip(test_labels, mask) if m]
+
+    # Cap sizes
+    if len(train_texts) > max_train:
+        np.random.seed(42)
+        idx = np.random.choice(len(train_texts), max_train, replace=False)
+        train_texts = [train_texts[i] for i in idx]
+        train_labels = [train_labels[i] for i in idx]
+
+    if len(test_texts) > max_test:
+        np.random.seed(42)
+        idx = np.random.choice(len(test_texts), max_test, replace=False)
+        test_texts = [test_texts[i] for i in idx]
+        test_labels = [test_labels[i] for i in idx]
+
+    labels = recover_labels(ds, config)
+    return train_texts, train_labels, test_texts, test_labels, labels
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Build verified model pack")
+    parser.add_argument("--datasets", nargs="+", default=list(DATASETS.keys()))
+    parser.add_argument("--out", default="data/model_pack")
+    parser.add_argument("--C", type=float, default=0.01)
+    parser.add_argument("--max-train", type=int, default=10000)
+    parser.add_argument("--max-test", type=int, default=2000)
+    args = parser.parse_args()
+
+    out_dir = Path(args.out)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    print(f"Building model pack: {len(args.datasets)} datasets")
+    print(f"Output: {out_dir}")
+    print(f"Encoder: {ENCODER}")
+    print()
+
+    from sentence_transformers import SentenceTransformer
+    encoder = SentenceTransformer(ENCODER)
+    results = []
+
+    for ds_name in args.datasets:
+        if ds_name not in DATASETS:
+            print(f"Unknown dataset: {ds_name}")
+            continue
+
+        config = DATASETS[ds_name]
+        print(f"{'='*60}")
+        print(f"{ds_name}: {config['description']}")
+
+        try:
+            train_texts, train_labels, test_texts, test_labels, labels = \
+                load_and_split(ds_name, config, args.max_train, args.max_test)
+        except Exception as e:
+            print(f"  FAILED to load: {e}")
+            continue
+
+        n_classes = len(set(train_labels))
+        print(f"  Train: {len(train_texts)}, Test: {len(test_texts)}, Classes: {n_classes}")
+        print(f"  Labels: {list(labels.items())[:5]}...")
+
+        # Embed
+        t0 = time.perf_counter()
+        train_emb = encoder.encode(train_texts, batch_size=256, show_progress_bar=False)
+        test_emb = encoder.encode(test_texts, batch_size=256, show_progress_bar=False)
+        t_embed = time.perf_counter() - t0
+
+        # Train
+        t1 = time.perf_counter()
+        scaler = StandardScaler()
+        X_train = scaler.fit_transform(train_emb)
+        X_test = scaler.transform(test_emb)
+
+        clf = LogisticRegression(C=args.C, max_iter=3000, solver="newton-cg", random_state=42)
+        clf.fit(X_train, train_labels)
+        t_train = time.perf_counter() - t1
+
+        # Evaluate
+        train_preds = clf.predict(X_train)
+        test_preds = clf.predict(X_test)
+        train_acc = accuracy_score(train_labels, train_preds)
+        test_acc = accuracy_score(test_labels, test_preds)
+        test_f1 = f1_score(test_labels, test_preds, average="macro", zero_division=0)
+
+        # Verify probability mapping roundtrip
+        probs = clf.predict_proba(X_test[:3])
+        for i in range(min(3, len(probs))):
+            pred_from_probs = clf.classes_[np.argmax(probs[i])]
+            pred_from_predict = test_preds[i]
+            assert pred_from_probs == pred_from_predict, \
+                f"Probability mapping mismatch at test[{i}]: {pred_from_probs} vs {pred_from_predict}"
+
+        # Verify all class IDs have label mappings
+        for cls_id in clf.classes_:
+            if str(cls_id) not in labels:
+                print(f"  WARNING: class {cls_id} has no label mapping")
+
+        manifest = ArtifactManifest(
+            dataset=ds_name,
+            description=config["description"],
+            n_classes=n_classes,
+            task_type=config["task_type"],
+            encoder=ENCODER,
+            encoder_dim=ENCODER_DIM,
+            labels=labels,
+            class_order=list(clf.classes_),
+            hf_source=config["hf"],
+            hf_config=config.get("hf_config"),
+            hf_revision=None,  # TODO: pin revision
+            license=LICENSES.get(ds_name, "see source"),
+            train_examples=len(train_texts),
+            train_accuracy=round(train_acc, 6),
+            test_examples=len(test_texts),
+            test_accuracy=round(test_acc, 6),
+            scaler_mean_hash=scaler_hash(scaler),
+            classifier_coef_hash=coef_hash(clf),
+        )
+
+        save_artifact(out_dir, ds_name, clf, scaler, manifest)
+
+        print(f"  Train acc: {train_acc:.4f}")
+        print(f"  Test acc:  {test_acc:.4f}")
+        print(f"  Test F1:   {test_f1:.4f}")
+        print(f"  Time: embed={t_embed:.1f}s train={t_train:.1f}s")
+        print(f"  Saved to {out_dir / ds_name}/")
+
+        results.append({
+            "dataset": ds_name,
+            "n_classes": n_classes,
+            "train_size": len(train_texts),
+            "test_size": len(test_texts),
+            "train_acc": round(train_acc, 6),
+            "test_acc": round(test_acc, 6),
+            "test_f1": round(test_f1, 6),
+            "embed_time": round(t_embed, 1),
+            "train_time": round(t_train, 1),
+        })
+        print()
+
+    # Summary
+    print(f"\n{'='*80}")
+    print("MODEL PACK SUMMARY")
+    print(f"{'='*80}")
+    print(f"{'Dataset':<25s} {'Classes':>7s} {'Train':>7s} {'Test':>7s} {'Test Acc':>9s} {'F1':>8s}")
+    print("-" * 67)
+    for r in sorted(results, key=lambda x: -x["test_acc"]):
+        print(f"{r['dataset']:<25s} {r['n_classes']:>7d} {r['train_size']:>7d} "
+              f"{r['test_size']:>7d} {r['test_acc']:>9.4f} {r['test_f1']:>8.4f}")
+
+    avg_acc = np.mean([r["test_acc"] for r in results])
+    avg_f1 = np.mean([r["test_f1"] for r in results])
+    print(f"\n{'Average':<25s} {'':>7s} {'':>7s} {'':>7s} {avg_acc:>9.4f} {avg_f1:>8.4f}")
+
+    # Save pack manifest
+    with open(out_dir / "pack_manifest.json", "w") as f:
+        json.dump({
+            "encoder": ENCODER,
+            "encoder_dim": ENCODER_DIM,
+            "classifier": "LogisticRegression(C=0.01, solver=newton-cg)",
+            "datasets": results,
+            "build_time": time.strftime("%Y-%m-%d %H:%M:%S"),
+            "schema_version": 1,
+        }, f, indent=2)
+
+    print(f"\nPack manifest: {out_dir / 'pack_manifest.json'}")
+    print(f"Total: {len(results)} artifacts")
+
+
+if __name__ == "__main__":
+    main()