codegreen 0.4.0__tar.gz → 0.4.2__tar.gz

{codegreen-0.4.0 → codegreen-0.4.2}/CMakeLists.txt

@@ -1,5 +1,14 @@
 cmake_minimum_required(VERSION 3.16)
-project(CodeGreen VERSION 0.3.0 LANGUAGES CXX)
+
+# Single source of truth: pyproject.toml [project].version
+file(READ "${CMAKE_CURRENT_SOURCE_DIR}/pyproject.toml" _PYPROJECT_TOML)
+string(REGEX MATCH "version *= *\"([0-9]+\\.[0-9]+\\.[0-9]+)\"" _VERSION_MATCH "${_PYPROJECT_TOML}")
+if(NOT CMAKE_MATCH_1)
+    message(FATAL_ERROR "Could not parse [project].version from pyproject.toml")
+endif()
+set(_CODEGREEN_VERSION "${CMAKE_MATCH_1}")
+
+project(CodeGreen VERSION ${_CODEGREEN_VERSION} LANGUAGES CXX)
 
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)

{codegreen-0.4.0/codegreen.egg-info → codegreen-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegreen
-Version: 0.4.0
+Version: 0.4.2
 Summary: Know the true energy cost of your code
 Author-email: Saurabhsingh Rajput <saurabh@dal.ca>
 Maintainer-email: Saurabhsingh Rajput <saurabh@dal.ca>

codegreen-0.4.2/benchmark/_workload_gpt2.py

@@ -0,0 +1,31 @@
+"""GPT-2 generation workload. Same script is used unchanged across modes."""
+import os, time
+os.environ.setdefault("TRANSFORMERS_VERBOSITY", "error")
+
+import torch
+from transformers import GPT2LMHeadModel, GPT2Tokenizer
+
+PROMPTS = [
+    "Energy-aware computing is",
+    "The cheapest way to train a model is",
+    "Hardware energy counters report",
+    "Modern transformers can be optimized by",
+] * 8  # 32 prompts -> dominates total runtime over import cost
+
+
+def main():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    tok = GPT2Tokenizer.from_pretrained("gpt2")
+    tok.pad_token = tok.eos_token
+    tok.padding_side = "left"
+    model = GPT2LMHeadModel.from_pretrained("gpt2").to(device).eval()
+    batch = tok(PROMPTS, padding=True, return_tensors="pt").to(device)
+    t0 = time.perf_counter()
+    with torch.no_grad():
+        out = model.generate(**batch, max_new_tokens=128, do_sample=False)
+    dt = time.perf_counter() - t0
+    print(f"workload done: device={device} prompts={len(PROMPTS)} gen_s={dt:.2f}")
+
+
+if __name__ == "__main__":
+    main()

codegreen-0.4.2/benchmark/_workload_gpt2_session.py

@@ -0,0 +1,30 @@
+"""Same workload as cg_workload.py but bracketed under codegreen.Session.
+Measures the same wall-clock span codegreen run measures."""
+import os, time
+os.environ.setdefault("TRANSFORMERS_VERBOSITY", "error")
+
+import codegreen
+
+with codegreen.Session("whole-script", output_file=os.environ.get("CG_OUT", "/tmp/cg_session_run.json")) as s:
+    with s.task("everything"):
+        import torch
+        from transformers import GPT2LMHeadModel, GPT2Tokenizer
+
+        PROMPTS = [
+            "Energy-aware computing is",
+            "The cheapest way to train a model is",
+            "Hardware energy counters report",
+            "Modern transformers can be optimized by",
+        ] * 8
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        tok = GPT2Tokenizer.from_pretrained("gpt2")
+        tok.pad_token = tok.eos_token
+        tok.padding_side = "left"
+        model = GPT2LMHeadModel.from_pretrained("gpt2").to(device).eval()
+        batch = tok(PROMPTS, padding=True, return_tensors="pt").to(device)
+        t0 = time.perf_counter()
+        with torch.no_grad():
+            out = model.generate(**batch, max_new_tokens=128, do_sample=False)
+        dt = time.perf_counter() - t0
+        print(f"workload done: device={device} prompts={len(PROMPTS)} gen_s={dt:.2f}")

codegreen-0.4.2/benchmark/cg_modes_compare.py

@@ -0,0 +1,109 @@
+"""Run identical GPT-2 workload through CodeGreen access modes and compare totals.
+
+  Mode A: `codegreen run`   -- whole-program energy via the CLI
+  Mode B: `codegreen.Session` (manual span around the entire script body)
+
+Both bracket the same wall-clock span, so the readings should agree within
+small noise (no instrumentation overhead from extra checkpoints).
+
+A third reference is bare wall-clock (no codegreen) to check timing parity."""
+import json, os, statistics, subprocess, sys, time
+
+REPEAT = int(os.environ.get("CG_REPEAT", "3"))
+HERE = os.path.dirname(os.path.abspath(__file__))
+WORKLOAD = os.path.join(HERE, "_workload_gpt2.py")
+WORKLOAD_SESSION = os.path.join(HERE, "_workload_gpt2_session.py")
+
+
+def _parse_json_blob(stdout: str) -> dict:
+    """codegreen --json prints multi-line JSON; find the outermost {...} block."""
+    s = stdout
+    start = s.find("{")
+    end = s.rfind("}")
+    if start < 0 or end < 0 or end <= start:
+        raise RuntimeError(f"no JSON block found in stdout (last 300 chars):\n{s[-300:]}")
+    return json.loads(s[start:end + 1])
+
+
+def mode_cli_run():
+    cmd = ["codegreen", "run", "python", WORKLOAD, "--repeat", "1", "--warmup", "0", "--json"]
+    res = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+    if res.returncode != 0:
+        raise RuntimeError(f"codegreen run failed:\n{res.stderr[-400:]}")
+    d = _parse_json_blob(res.stdout)
+    e = d.get("energy_joules", {})
+    t = d.get("time_seconds", {})
+    energy = e.get("mean") if isinstance(e, dict) else e
+    secs = t.get("mean") if isinstance(t, dict) else t
+    return {"energy_j": energy, "power_w": d.get("power_watts"), "wall_s": secs,
+            "domains": d.get("domains") or {}}
+
+
+def mode_session():
+    out = f"/tmp/_session_{os.getpid()}_{time.time()}.json"
+    env = dict(os.environ); env["CG_OUT"] = out
+    res = subprocess.run([sys.executable, WORKLOAD_SESSION], env=env, capture_output=True, text=True, timeout=600)
+    if res.returncode != 0:
+        raise RuntimeError(f"session script failed:\n{res.stderr[-400:]}")
+    rep = json.load(open(out))
+    task = rep["tasks"][0]
+    return {"energy_j": task["energy_j"], "power_w": task["avg_power_w"],
+            "wall_s": task["duration_s"], "domains": task["domains"]}
+
+
+def mode_bare():
+    t0 = time.perf_counter()
+    res = subprocess.run([sys.executable, WORKLOAD], capture_output=True, text=True, timeout=600)
+    dt = time.perf_counter() - t0
+    if res.returncode != 0:
+        raise RuntimeError(f"bare run failed:\n{res.stderr[-400:]}")
+    return {"energy_j": None, "power_w": None, "wall_s": dt, "domains": {}}
+
+
+def repeat_run(label, fn):
+    rows = []
+    for _ in range(REPEAT):
+        try: rows.append(fn())
+        except Exception as e: rows.append({"error": str(e)})
+    return label, rows
+
+
+def stat(rows, key):
+    vs = [r[key] for r in rows if "error" not in r and r.get(key) is not None]
+    if not vs: return None
+    return statistics.mean(vs), (statistics.stdev(vs) if len(vs) > 1 else 0.0)
+
+
+def main():
+    print(f"GPT-2 workload, {REPEAT} repeats per mode\n")
+    rs = []
+    for label, fn in [("Bare (timing only)", mode_bare),
+                      ("CLI: codegreen run", mode_cli_run),
+                      ("Session (manual)",   mode_session)]:
+        print(f"-- running {label}")
+        rs.append(repeat_run(label, fn))
+
+    print(f"\n{'mode':<22} {'energy_j (mean +/- std)':<28} {'power_w':<10} {'wall_s':<14} runs")
+    print("-" * 92)
+    base_e = base_w = None
+    for label, rows in rs:
+        ok = [r for r in rows if "error" not in r]
+        e = stat(rows, "energy_j"); p = stat(rows, "power_w"); w = stat(rows, "wall_s")
+        if not ok:
+            print(f"{label:<22} ERROR")
+            continue
+        if e and base_e is None and "Session" not in label and "CLI" in label:
+            base_e = e[0]
+        if w and base_w is None: base_w = w[0]
+        e_str = f"{e[0]:>9.2f} +/- {e[1]:<6.2f}" if e else "      n/a            "
+        e_pct = f"({100*(e[0]-base_e)/base_e:+5.2f}%)" if (e and base_e) else "        "
+        p_str = f"{p[0]:>5.1f} W" if p else "  n/a "
+        w_str = f"{w[0]:>4.2f} s ({100*(w[0]-base_w)/base_w:+4.1f}%)" if (w and base_w) else f"{w[0]:>4.2f} s"
+        print(f"{label:<22} {e_str} J {e_pct}  {p_str:<10} {w_str:<14} {len(ok)}/{REPEAT}")
+
+    json.dump({"repeat": REPEAT, "results": rs}, open("/tmp/cg_modes_compare.json", "w"), indent=2, default=str)
+    print(f"\nraw JSON: /tmp/cg_modes_compare.json")
+
+
+if __name__ == "__main__":
+    main()

{codegreen-0.4.0 → codegreen-0.4.2}/codegreen/__init__.py

@@ -12,7 +12,7 @@ try:
     from importlib.metadata import version as _pkg_version
     __version__ = _pkg_version("codegreen")
 except Exception:
-    __version__ = "0.4.0"  # fallback for dev/editable installs
+    __version__ = "0.4.2"  # fallback for dev/editable installs
 __author__ = "Saurabhsingh Rajput"
 __email__ = "saurabh@dal.ca"
 __description__ = "Know the true energy cost of your code"

{codegreen-0.4.0 → codegreen-0.4.2}/codegreen/analyzer/plot.py

@@ -272,11 +272,11 @@ def _render_session_plotly(tasks: list, path: Path) -> None:
     except ImportError:
         return
     fig = go.Figure()
-    t0_ns = min(s["t"] for t in tasks for s in t["timeseries"])
+    t0_ns = min(s["t_ns"] for t in tasks for s in t["timeseries"])
     for t in tasks:
         ts = t["timeseries"]
-        x = [(s["t"] - t0_ns) / 1e9 for s in ts]
-        y = [s["w"] for s in ts]
+        x = [(s["t_ns"] - t0_ns) / 1e9 for s in ts]
+        y = [s["power_w"] for s in ts]
         fig.add_trace(go.Scatter(
             x=x, y=y, mode="lines", name=t["name"],
             line=dict(width=1),
@@ -302,11 +302,11 @@ def _render_session_matplotlib(tasks: list, path: Path) -> None:
         return
     fig, ax = plt.subplots(figsize=(10, 4), facecolor=BG)
     ax.set_facecolor(CARD)
-    t0_ns = min(s["t"] for t in tasks for s in t["timeseries"])
+    t0_ns = min(s["t_ns"] for t in tasks for s in t["timeseries"])
     for t in tasks:
         ts = t["timeseries"]
-        x = [(s["t"] - t0_ns) / 1e9 for s in ts]
-        y = [s["w"] for s in ts]
+        x = [(s["t_ns"] - t0_ns) / 1e9 for s in ts]
+        y = [s["power_w"] for s in ts]
         ax.plot(x, y, lw=0.8, label=t["name"])
     ax.set_xlabel("Time (s)", color=TXT)
     ax.set_ylabel("Power (W)", color=TXT)

{codegreen-0.4.0 → codegreen-0.4.2}/codegreen/config.json

@@ -1,5 +1,4 @@
 {
-  "version": "0.3.16",
   "paths": {
     "runtime_modules": {
       "python": "runtime/codegreen_runtime.py",
@@ -165,7 +164,6 @@
     "completed": false,
     "timestamp": null,
     "environment_type": "unknown",
-    "detected_sensors": [],
-    "version": "0.3.16"
+    "detected_sensors": []
   }
 }

{codegreen-0.4.0 → codegreen-0.4.2}/codegreen/instrumentation/language_runtimes/python/codegreen_runtime.py

@@ -255,6 +255,7 @@ import functools
 import os as _os
 import sys as _sys
 import warnings as _warnings
+import statistics as _statistics
 from contextlib import contextmanager as _contextmanager
 
 _active_session: Optional["Session"] = None
@@ -332,6 +333,7 @@ class TaskResult:
     parent: Optional[str]
     domains: Dict[str, float]
     timeseries: Optional[List[Dict[str, float]]] = None  # [{t_ns,j,w,d:{...}}]
+    noise: Optional[Dict[str, float]] = None             # populated when timeseries present
 
 
 # Sample size estimate (matches SynchronizedReading on 64-bit) for buffer sizing
@@ -339,6 +341,52 @@ _BYTES_PER_SAMPLE_EST = 800
 _DEFAULT_SAMPLE_INTERVAL_MS = 10  # NEMB default; mirror in Session for sizing math
 
 
+def _bundled_sample_interval_ms() -> int:
+    """Read the C++ NEMB default sample interval from bundled config.json."""
+    cfg = Path(__file__).resolve().parents[3] / "config.json"
+    try:
+        with open(cfg) as f:
+            d = json.load(f)
+        return int(d.get("coordinator", {}).get("measurement_interval_ms", 1))
+    except Exception:
+        return 1
+
+
+def _quality_label(cv_percent: float) -> str:
+    if cv_percent < 2.0:  return "excellent"
+    if cv_percent < 5.0:  return "good"
+    if cv_percent < 10.0: return "moderate"
+    return "high-noise"
+
+
+def _compute_task_noise(task: "TaskResult", sample_interval_ms: int) -> Optional[Dict]:
+    """Power-CV + sample-drop summary for one task. None if no time-series."""
+    ts = task.timeseries
+    if not ts:
+        return None
+    powers = [s.get("power_w", 0.0) for s in ts if s.get("power_w") is not None]
+    n = len(powers)
+    if n >= 2:
+        mean_w = _statistics.fmean(powers)
+        std_w  = _statistics.pstdev(powers, mean_w) if mean_w > 0 else 0.0
+    else:
+        mean_w = powers[0] if n == 1 else 0.0
+        std_w = 0.0
+    cv = (100.0 * std_w / mean_w) if mean_w > 0 else 0.0
+    expected = max(1, int(round(task.duration_s * 1000.0 / max(1, sample_interval_ms))))
+    drop_ratio = max(0.0, 1.0 - n / expected)
+    return {
+        "samples_captured":  n,
+        "samples_expected":  expected,
+        "drop_ratio":        round(drop_ratio, 4),
+        "power_mean_w":      round(mean_w, 4),
+        "power_std_w":       round(std_w,  4),
+        "power_cv_percent":  round(cv,     3),
+        "sample_interval_ms": sample_interval_ms,
+        "quality":           _quality_label(cv),
+    }
+
+
 class Session:
     """Manual span-based energy measurement.
 
@@ -455,6 +503,9 @@ class Session:
                         )
                     except Exception:
                         pass
+        # Effective sample interval for noise / drop-ratio math.
+        self._sample_interval_ms = int(sample_interval_ms) if sample_interval_ms is not None \
+                                   else _bundled_sample_interval_ms()
         self._sampling_mode = sampling_mode  # "adaptive" reserved for future
 
     def start(self) -> "Session":
@@ -498,7 +549,7 @@ class Session:
             return 0
         with self._ts_lock:
             self._ts_samples.extend(samples)
-        self._ts_last_ts = samples[-1]["t"]
+        self._ts_last_ts = samples[-1]["t_ns"]
         return len(samples)
 
     def _drain_loop(self):
@@ -608,7 +659,7 @@ class Session:
             self._drain_once()  # ensure latest samples are pulled before filtering
             with self._ts_lock:
                 ts = [s for s in self._ts_samples
-                      if t_mono_ns <= s["t"] <= t_end_mono_ns]
+                      if t_mono_ns <= s["t_ns"] <= t_end_mono_ns]
         result = TaskResult(
             name=name, energy_j=e.value, avg_power_w=p.value,
             duration_s=dur.value if dur.value > 0 else (t_end - t_start),
@@ -650,14 +701,32 @@ class Session:
             return self._finalized_report
         total_e = sum(t.energy_j for t in self._tasks if t.depth == 0)
         total_d = (time.time() - self._t0_wall) if self._started else 0.0
+        warnings_list: List[str] = []
+        worst_cv = 0.0
+        for t in self._tasks:
+            if t.timeseries:
+                t.noise = _compute_task_noise(t, self._sample_interval_ms)
+                if t.noise:
+                    cv = t.noise["power_cv_percent"]
+                    drop = t.noise["drop_ratio"]
+                    if cv > worst_cv: worst_cv = cv
+                    if cv >= 10.0 or drop >= 0.20:
+                        msg = (f"task '{t.name}': noisy reading "
+                               f"(power CV={cv:.1f}%, sample drop={drop*100:.1f}%, "
+                               f"quality={t.noise['quality']})")
+                        warnings_list.append(msg)
+                        _warnings.warn("codegreen: " + msg, RuntimeWarning, stacklevel=4)
+        totals = {
+            "energy_j": total_e,
+            "duration_s": total_d,
+            "n_tasks": len(self._tasks),
+            "worst_power_cv_percent": round(worst_cv, 3) if self._record_ts else None,
+            "noise_warnings": warnings_list,
+        }
         report = {
             "session_name": self.name,
             "tasks": [t.__dict__ for t in self._tasks],
-            "totals": {
-                "energy_j": total_e,
-                "duration_s": total_d,
-                "n_tasks": len(self._tasks),
-            },
+            "totals": totals,
             "providers": [],
             "abi_version": self._client.lib.nemb_abi_version() if not self._noop else 0,
         }
@@ -707,13 +776,19 @@ class Session:
                     "session", "task", "depth", "parent",
                     "energy_j", "avg_power_w", "duration_s",
                     "started_at", "ended_at", "domains_json",
+                    "power_cv_percent", "samples_captured", "samples_expected",
+                    "drop_ratio", "quality",
                 ])
             for t in self._tasks:
+                n = t.noise or {}
                 w.writerow([
                     self.name, t.name, t.depth, t.parent or "",
                     f"{t.energy_j:.9f}", f"{t.avg_power_w:.6f}", f"{t.duration_s:.6f}",
                     f"{t.started_at:.6f}", f"{t.ended_at:.6f}",
                     json.dumps(t.domains, separators=(",", ":")),
+                    n.get("power_cv_percent", ""), n.get("samples_captured", ""),
+                    n.get("samples_expected", ""), n.get("drop_ratio", ""),
+                    n.get("quality", ""),
                 ])
 
     @property

{codegreen-0.4.0 → codegreen-0.4.2/codegreen.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegreen
-Version: 0.4.0
+Version: 0.4.2
 Summary: Know the true energy cost of your code
 Author-email: Saurabhsingh Rajput <saurabh@dal.ca>
 Maintainer-email: Saurabhsingh Rajput <saurabh@dal.ca>

{codegreen-0.4.0 → codegreen-0.4.2}/codegreen.egg-info/SOURCES.txt

@@ -7,7 +7,9 @@ requirements.txt
 setup.py
 benchmark/__init__.py
 benchmark/__main__.py
-benchmark/cg_vs_codecarbon_transformers.py
+benchmark/_workload_gpt2.py
+benchmark/_workload_gpt2_session.py
+benchmark/cg_modes_compare.py
 benchmark/compilers.py
 benchmark/config.py
 benchmark/harness.py

{codegreen-0.4.0 → codegreen-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codegreen"
-version = "0.4.0"
+version = "0.4.2"
 description = "Know the true energy cost of your code"
 readme = "README.md"
 license = {file = "LICENSE"}

codegreen-0.4.0/benchmark/cg_vs_codecarbon_transformers.py

@@ -1,109 +0,0 @@
-"""Verify codegreen.Session against CodeCarbon EmissionsTracker on a transformers
-fine-tune (mirrors https://docs.codecarbon.io/latest/how-to/transformers/).
-
-Trackers run **sequentially** (not concurrent) to avoid double-instrumentation noise:
-
-  Phase 1: CodeCarbon-only  -> 1 fine-tune  (baseline reference)
-  Phase 2: CodeGreen-only   -> 3 fine-tunes inside one Session, one per API form:
-             explicit start_task / stop_task
-             `with sess.task(...)` context manager
-             `@codegreen.task(...)` decorator
-
-Each fine-tune trains on the same IMDB slice with the same TrainingArguments,
-so per-task CG energy / time / power are directly comparable to the CC baseline.
-
-Run: python -m benchmark.cg_vs_codecarbon_transformers [--n 128] [--epochs 1] [--batch 8]
-"""
-import argparse, json, os, time
-
-os.environ.setdefault("TOKENIZERS_PARALLELISM", "false")
-os.environ.setdefault("TRANSFORMERS_VERBOSITY", "error")
-
-
-def _build_dataset_and_model_factory(model_name, n):
-    from transformers import AutoTokenizer, AutoModelForSequenceClassification
-    from datasets import load_dataset
-    tok = AutoTokenizer.from_pretrained(model_name)
-    ds = load_dataset("imdb", split=f"train[:{n}]")
-    ds = ds.map(lambda b: tok(b["text"], truncation=True, padding="max_length", max_length=128), batched=True)
-    ds = ds.rename_column("label", "labels")
-    ds.set_format("torch", columns=["input_ids", "attention_mask", "labels"])
-    return ds, lambda: AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)
-
-
-def _train_args(out, epochs, batch):
-    from transformers import TrainingArguments
-    return TrainingArguments(output_dir=out, num_train_epochs=epochs,
-                             per_device_train_batch_size=batch, save_strategy="no",
-                             report_to=[], disable_tqdm=True, logging_strategy="no", use_cpu=True)
-
-
-def _do_train(new_model, ds, out, epochs, batch):
-    from transformers import Trainer
-    Trainer(model=new_model(), args=_train_args(out, epochs, batch), train_dataset=ds).train()
-
-
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument("--n", type=int, default=128)
-    p.add_argument("--epochs", type=int, default=1)
-    p.add_argument("--batch", type=int, default=8)
-    p.add_argument("--out", default="/tmp/cg_session.json")
-    p.add_argument("--model", default="distilbert-base-uncased")
-    args = p.parse_args()
-
-    ds, new_model = _build_dataset_and_model_factory(args.model, args.n)
-
-    # ---- Phase 1: CodeCarbon-only baseline ----
-    from codecarbon import EmissionsTracker
-    cc = EmissionsTracker(project_name="cg_vs_cc", output_dir="/tmp",
-                          log_level="error", save_to_file=False)
-    cc.start()
-    t0 = time.perf_counter()
-    _do_train(new_model, ds, "/tmp/_cc", args.epochs, args.batch)
-    cc_wall = time.perf_counter() - t0
-    co2 = cc.stop()
-    cc_j = (cc.final_emissions_data.energy_consumed or 0.0) * 3.6e6
-
-    # ---- Phase 2: CodeGreen Session (3 forms in one session, sequential) ----
-    import codegreen
-    sess = codegreen.Session(output_file=args.out, record_time_series=True)
-    sess.start()
-    t0 = time.perf_counter()
-
-    sess.start_task("explicit_train")
-    _do_train(new_model, ds, "/tmp/_t1", args.epochs, args.batch)
-    sess.stop_task("explicit_train")
-
-    with sess.task("context_train"):
-        _do_train(new_model, ds, "/tmp/_t2", args.epochs, args.batch)
-
-    @codegreen.task("decorator_train")
-    def fine_tune():
-        _do_train(new_model, ds, "/tmp/_t3", args.epochs, args.batch)
-    fine_tune()
-
-    cg_wall = time.perf_counter() - t0
-    sess.stop()
-
-    rep = json.load(open(args.out))
-    tasks = {t["name"]: t for t in rep["tasks"]}
-    cg_total_tasks = sum(t["energy_j"] for t in rep["tasks"])
-
-    # Per-task delta vs CC baseline (CC ran 1 train; each CG task ran 1 train)
-    print(f"\n{args.model} | IMDB[:{args.n}] | {args.epochs} ep | batch={args.batch}\n")
-    print(f"Phase 1 (CodeCarbon, 1 train)")
-    print(f"  wall {cc_wall:.2f} s   energy {cc_j:.2f} J   power {cc_j/cc_wall:.2f} W   CO2 {co2*1000:.4f} g")
-    print(f"\nPhase 2 (CodeGreen Session, 3 trains sequential)")
-    print(f"  total span energy {rep['total']['energy_j']:.2f} J   power {rep['total']['power_w']:.2f} W   wall {cg_wall:.2f} s")
-    print(f"\n  task                 energy(J)  dur(s)  power(W)   ts   delta-vs-CC")
-    for name in ("explicit_train", "context_train", "decorator_train"):
-        t = tasks[name]
-        ts = len(t.get("time_series", []))
-        d = 100 * (t["energy_j"] - cc_j) / cc_j if cc_j else float("nan")
-        print(f"  {name:<18}  {t['energy_j']:>8.2f}  {t['duration_s']:>6.2f}  {t['power_w']:>7.2f}  {ts:>5}   {d:+7.2f}%")
-    print(f"\n  domains captured: {list(tasks['explicit_train'].get('per_domain', {}).keys())}")
-
-
-if __name__ == "__main__":
-    main()