Upload 15 files

gguf.py

@@ -15,6 +15,7 @@ packed by an external GGUF writer.
 from __future__ import annotations
 
 import struct
+import time
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -422,11 +423,13 @@ def write_quantized_gguf(
 
     out_infos = []
     data_offset = 0
+    total_planned_blocks = 0
     for ti, want in zip(reader.tensors, plan):
         if want:
             n_blocks = ti.n_elements // QK_K
             out_type = GGML_TYPE_Q2_K
             out_size = n_blocks * 84
+            total_planned_blocks += n_blocks
         else:
             out_type = ti.type
             out_size = ti.n_bytes
@@ -446,6 +449,8 @@ def write_quantized_gguf(
     total_rmse = 0.0
     total_quantized = 0
     total_elements = 0
+    completed_planned_blocks = 0
+    model_t0 = time.time()
     with output_path.open("wb") as fout:
         fout.write(struct.pack("<IIQQ", GGUF_MAGIC, reader.version, len(out_infos), len(kv_pairs)))
         for key, vtype, raw in kv_pairs:
@@ -470,19 +475,52 @@ def write_quantized_gguf(
             if target > fout.tell():
                 fout.write(b"\x00" * (target - fout.tell()))
             if plan[idx]:
+                t_blocks = ti.n_elements // QK_K
                 has_imat = imat is not None and lookup_imatrix(imat, ti.name) is not None
-                if stage_callback is not None:
+
+                def _emit_stage(ev: dict, _i=idx + 1, _ti=ti, _base=completed_planned_blocks, _tb=t_blocks):
+                    if stage_callback is None:
+                        return
+                    phase_name = ev.get("phase", "")
+                    done_b = int(ev.get("done", 0))
+                    tot_b = max(int(ev.get("total", _tb)), 1)
+                    if phase_name.startswith("Phase 2b"):
+                        frac = 0.80 * (done_b / tot_b)
+                    elif phase_name.startswith("Phase 3"):
+                        frac = 0.82
+                    elif phase_name.startswith("Phase 4:"):
+                        frac = 0.82 + 0.17 * (done_b / tot_b)
+                    elif phase_name.startswith("Phase 4.8") or phase_name.startswith("Phase 5"):
+                        frac = 1.0
+                    else:
+                        frac = 0.0
+                    eff_blocks = _base + frac * _tb
+                    elapsed_model = max(time.time() - model_t0, 1.0e-6)
+                    model_rate = eff_blocks / elapsed_model
+                    rem_blocks = max(total_planned_blocks - eff_blocks, 0.0)
+                    model_eta = rem_blocks / model_rate if model_rate > 1.0e-6 else 0.0
+                    model_pct = 100.0 * eff_blocks / max(total_planned_blocks, 1)
                     stage_callback(
-                        idx + 1,
+                        _i,
                         len(out_infos),
-                        ti,
+                        _ti,
                         {
-                            "phase": f"Reading & Dequantizing Source ({ti.type_name})",
-                            "done": 0,
-                            "total": ti.n_elements // QK_K,
-                            "detail": f"dims={ti.dims} elements={ti.n_elements:,} ({ti.n_bytes / 1048576:.2f} MB) imatrix={'yes' if has_imat else 'no'}",
+                            **ev,
+                            "model_pct": model_pct,
+                            "model_eta": model_eta,
+                            "model_done_blocks": int(eff_blocks),
+                            "model_total_blocks": total_planned_blocks,
                         },
                     )
+
+                _emit_stage(
+                    {
+                        "phase": f"Reading & Dequantizing Source ({ti.type_name})",
+                        "done": 0,
+                        "total": t_blocks,
+                        "detail": f"dims={ti.dims} elements={ti.n_elements:,} ({ti.n_bytes / 1048576:.2f} MB) imatrix={'yes' if has_imat else 'no'}",
+                    }
+                )
                 x, row = reader.read_tensor(ti.name)
                 imp = None
                 if imat is not None:
@@ -493,13 +531,10 @@ def write_quantized_gguf(
                     x,
                     importance=imp,
                     row_width=row,
-                    status_callback=(
-                        (lambda ev, _i=idx + 1, _ti=ti: stage_callback(_i, len(out_infos), _ti, ev))
-                        if stage_callback is not None
-                        else None
-                    ),
+                    status_callback=_emit_stage if stage_callback is not None else None,
                     stop_event=stop_event,
                 )
+                completed_planned_blocks += t_blocks
                 payload = blocks_to_bytes(res.scales, res.qs, res.dm)
                 if len(payload) != out_size:
                     raise RuntimeError(f"{ti.name}: Q2_K payload size mismatch")

gui.py

@@ -47,6 +47,19 @@ def _ts() -> str:
     return dt.datetime.now().strftime("%H:%M:%S.%f")[:-3]
 
 
+def _fmt_eta(seconds: float) -> str:
+    if not np.isfinite(seconds) or seconds <= 0.0:
+        return "0s"
+    s = int(round(seconds))
+    if s < 60:
+        return f"{seconds:.1f}s"
+    m, sec = divmod(s, 60)
+    if m < 60:
+        return f"{m}m{sec:02d}s"
+    h, m = divmod(m, 60)
+    return f"{h}h{m:02d}m{sec:02d}s"
+
+
 class HPCQuantizeGUI:
     def __init__(self, root: tk.Tk) -> None:
         self.root = root
@@ -803,16 +816,28 @@ class HPCQuantizeGUI:
                 tot_blk = max(int(ev.get("total", 1)), 1)
                 detail = ev.get("detail", "")
                 blk_pct = 100.0 * done / tot_blk
-                overall_pct = 100.0 * ((idx - 1) + (done / tot_blk)) / max(total, 1)
+                overall_pct = float(
+                    ev.get("model_pct", 100.0 * ((idx - 1) + (done / tot_blk)) / max(total, 1))
+                )
 
                 self.model_progress_var.set(overall_pct)
                 self.tensor_progress_var.set(blk_pct)
                 self.tele_tensor_var.set(f"[{idx}/{total}] {ti.name} ({ti.type_name}, dims={ti.dims})")
                 self.tele_phase_var.set(phase)
-                self.tele_blocks_var.set(f"{done:,} / {tot_blk:,} ({blk_pct:.1f}%)")
+                if "model_total_blocks" in ev and ev["model_total_blocks"] > 0:
+                    self.tele_blocks_var.set(
+                        f"Tensor: {done:,}/{tot_blk:,} ({blk_pct:.1f}%) | "
+                        f"Model: {ev['model_done_blocks']:,}/{ev['model_total_blocks']:,} ({overall_pct:.1f}%)"
+                    )
+                else:
+                    self.tele_blocks_var.set(f"{done:,} / {tot_blk:,} ({blk_pct:.1f}%)")
 
                 if "rate" in ev and "eta" in ev:
-                    self.tele_speed_var.set(f"{ev['rate']:.1f} blk/s (ETA {ev['eta']:.1f}s)")
+                    t_eta = _fmt_eta(float(ev["eta"]))
+                    m_eta = _fmt_eta(float(ev.get("model_eta", ev["eta"])))
+                    self.tele_speed_var.set(
+                        f"{ev['rate']:.1f} blk/s | Tensor ETA: {t_eta} | Model ETA: {m_eta}"
+                    )
                 if "rmse" in ev and "sigma" in ev:
                     r, s = float(ev["rmse"]), float(ev["sigma"])
                     self.tele_rmse_var.set(f"{r:.6e} (r/σ={r/max(s, 1e-15):.4f})")