| import json |
| import os |
| import threading |
| import time |
| from typing import Any, Optional |
|
|
| import pyarrow as pa |
| import pyarrow.parquet as pq |
|
|
|
|
| SCHEMA = pa.schema( |
| [ |
| ("step", pa.int64()), |
| ("epoch", pa.int32()), |
| ("loss", pa.float32()), |
| ("avr_loss", pa.float32()), |
| ("loss_v", pa.float32()), |
| ("loss_a", pa.float32()), |
| ("lr", pa.float64()), |
| ("step_time", pa.float32()), |
| ] |
| ) |
|
|
|
|
| class MetricsWriter: |
| """Buffered Parquet writer for training metrics. |
| |
| Accumulates rows in memory and flushes to a Parquet file periodically |
| via a background daemon thread. Also manages status.json and events.json. |
| """ |
|
|
| def __init__(self, run_dir: str, flush_every: int = 10): |
| self.run_dir = run_dir |
| self.flush_every = flush_every |
|
|
| self.metrics_path = os.path.join(run_dir, "dashboard", "metrics.parquet") |
| self.status_path = os.path.join(run_dir, "dashboard", "status.json") |
| self.events_path = os.path.join(run_dir, "dashboard", "events.json") |
|
|
| os.makedirs(os.path.join(run_dir, "dashboard"), exist_ok=True) |
|
|
| self._buffer: list[dict[str, Any]] = [] |
| self._lock = threading.Lock() |
| self._start_time = time.monotonic() |
| self._step_count = 0 |
|
|
| |
| if not os.path.exists(self.events_path): |
| self._write_json(self.events_path, []) |
|
|
| |
| self.update_status(step=0, max_steps=0, epoch=0, max_epochs=0, status="initializing") |
|
|
| |
|
|
| def log( |
| self, |
| step: int, |
| epoch: int = 0, |
| loss: float = 0.0, |
| avr_loss: float = 0.0, |
| loss_v: Optional[float] = None, |
| loss_a: Optional[float] = None, |
| lr: float = 0.0, |
| step_time: float = 0.0, |
| ): |
| row = { |
| "step": step, |
| "epoch": epoch, |
| "loss": loss, |
| "avr_loss": avr_loss, |
| "loss_v": loss_v if loss_v is not None else float("nan"), |
| "loss_a": loss_a if loss_a is not None else float("nan"), |
| "lr": lr, |
| "step_time": step_time, |
| } |
| with self._lock: |
| self._buffer.append(row) |
| self._step_count += 1 |
| if len(self._buffer) >= self.flush_every: |
| self._flush_background() |
|
|
| def log_event(self, event_type: str, step: int, **extra): |
| entry = {"type": event_type, "step": step, "time": time.time(), **extra} |
| t = threading.Thread(target=self._append_event, args=(entry,), daemon=True) |
| t.start() |
|
|
| def update_status(self, **kw): |
| elapsed = time.monotonic() - self._start_time |
| speed = self._step_count / elapsed if elapsed > 0 and self._step_count > 0 else 0.0 |
| status = { |
| "elapsed_sec": round(elapsed, 1), |
| "speed_steps_per_sec": round(speed, 4), |
| "time": time.time(), |
| } |
| status.update(kw) |
| t = threading.Thread(target=self._write_json, args=(self.status_path, status), daemon=True) |
| t.start() |
|
|
| def flush(self): |
| with self._lock: |
| if self._buffer: |
| self._do_flush(list(self._buffer)) |
| self._buffer.clear() |
|
|
| def close(self): |
| self.flush() |
|
|
| |
|
|
| def _flush_background(self): |
| rows = list(self._buffer) |
| self._buffer.clear() |
| t = threading.Thread(target=self._do_flush, args=(rows,), daemon=True) |
| t.start() |
|
|
| def _do_flush(self, rows: list[dict]): |
| table = pa.table({col: [r[col] for r in rows] for col in SCHEMA.names}, schema=SCHEMA) |
| try: |
| if os.path.exists(self.metrics_path): |
| existing = pq.read_table(self.metrics_path, schema=SCHEMA) |
| table = pa.concat_tables([existing, table]) |
| pq.write_table(table, self.metrics_path) |
| except Exception: |
| |
| pq.write_table(table, self.metrics_path) |
|
|
| def _append_event(self, entry: dict): |
| try: |
| events = [] |
| if os.path.exists(self.events_path): |
| with open(self.events_path, "r") as f: |
| events = json.load(f) |
| events.append(entry) |
| self._write_json(self.events_path, events) |
| except Exception: |
| pass |
|
|
| @staticmethod |
| def _write_json(path: str, data): |
| tmp = path + ".tmp" |
| with open(tmp, "w") as f: |
| json.dump(data, f) |
| os.replace(tmp, path) |
|
|
