| import os |
| import argparse |
| import glob |
| import shutil |
| import time |
| import numpy as np |
| from tensorboard.backend.event_processing import event_accumulator |
|
|
| def get_latest_event_file(log_root): |
| """Recursively find the latest TensorBoard event file under log_root.""" |
| event_files = glob.glob(os.path.join(log_root, "**", "events.out.tfevents.*"), recursive=True) |
| if not event_files: |
| raise RuntimeError(f"No TensorBoard event files found under {log_root}") |
| return max(event_files, key=os.path.getmtime) |
|
|
| def load_scalar(event_file, tag="loss"): |
| ea = event_accumulator.EventAccumulator(event_file) |
| ea.Reload() |
| if tag not in ea.Tags()["scalars"]: |
| raise RuntimeError(f"Tag '{tag}' not found in {event_file}. Available: {ea.Tags()['scalars']}") |
| events = ea.Scalars(tag) |
| steps = [e.step for e in events] |
| values = [e.value for e in events] |
| return np.array(steps), np.array(values) |
|
|
| def smooth(values, weight=0.9): |
| smoothed = [] |
| last = values[0] |
| for val in values: |
| last = last * weight + (1 - weight) * val |
| smoothed.append(last) |
| return np.array(smoothed) |
|
|
| def preview_file_lines(file_path, max_chars=50): |
| """Return number of lines and a list of truncated lines for preview.""" |
| with open(file_path, "r", encoding="utf-8") as f: |
| lines = [line.rstrip("\n") for line in f.readlines()] |
| n_lines = len(lines) |
| truncated_lines = [line if len(line) <= max_chars else line[:max_chars] + "…" for line in lines] |
| if n_lines == 0: |
| truncated_lines = ["<empty>"] |
| return n_lines, truncated_lines |
|
|
| def main(): |
| parser = argparse.ArgumentParser(description="Monitor TensorBoard logs and update prompt.txt when loss threshold is reached") |
| parser.add_argument("--log_root", type=str, required=True, help="Root folder containing TensorBoard logs (nested allowed)") |
| parser.add_argument("--sample_folder", type=str, required=True, help="Folder with prompt.txt and payload file") |
| parser.add_argument("--tag", type=str, default="loss/average", help="Scalar tag to monitor (default: loss)") |
| parser.add_argument("--threshold", type=float, required=True, help="Loss threshold to trigger prompt update") |
| parser.add_argument("--smoothing", type=float, default=0.9, help="Exponential smoothing weight (0-1, default 0.9)") |
| parser.add_argument("--poll_interval", type=int, default=10, help="Seconds between polling for new logs (default 10)") |
| parser.add_argument("--archive", action="store_true", |
| help="Pre-step: move contents of prompt.txt → prompt_payload.txt and empty prompt.txt. Must be only .txt file.") |
| args = parser.parse_args() |
|
|
| |
| if not os.path.isdir(args.sample_folder): |
| raise RuntimeError(f"Sample folder does not exist: {args.sample_folder}") |
|
|
| |
| prompt_file = os.path.join(args.sample_folder, "prompt.txt") |
| if not os.path.exists(prompt_file): |
| with open(prompt_file, "w", encoding="utf-8") as f: |
| f.write("") |
|
|
| |
| if args.archive: |
| txt_files = glob.glob(os.path.join(args.sample_folder, "*.txt")) |
| if len(txt_files) != 1 or not txt_files[0].endswith("prompt.txt"): |
| raise RuntimeError("Archive mode requires prompt.txt to be the ONLY .txt file in the sample folder.") |
|
|
| archive_file = os.path.join(args.sample_folder, "prompt_payload.txt") |
|
|
| with open(prompt_file, "r", encoding="utf-8") as f: |
| contents = f.read() |
|
|
| with open(archive_file, "w", encoding="utf-8") as f: |
| f.write(contents) |
|
|
| |
| with open(prompt_file, "w", encoding="utf-8") as f: |
| f.write("") |
|
|
| print(f"[ARCHIVE] Moved contents of {prompt_file} → {archive_file} and emptied {prompt_file}") |
|
|
| |
| txt_files = [f for f in glob.glob(os.path.join(args.sample_folder, "*.txt")) if not f.endswith("prompt.txt")] |
| if not txt_files: |
| raise RuntimeError("No payload file found in sample folder (need one .txt besides prompt.txt).") |
| payload_file = txt_files[0] |
|
|
| |
| prompt_lines, prompt_preview_lines = preview_file_lines(prompt_file) |
| payload_lines, payload_preview_lines = preview_file_lines(payload_file) |
|
|
| print("=== Startup Info ===") |
| print(f"Prompt file: {prompt_file}") |
| print(f" Lines: {prompt_lines}") |
| print(f" Preview:") |
| for line in prompt_preview_lines: |
| print(f" {line}") |
| print(f"Payload file: {payload_file}") |
| print(f" Lines: {payload_lines}") |
| print(f" Preview:") |
| for line in payload_preview_lines: |
| print(f" {line}") |
| print("===================") |
|
|
| |
| event_file = get_latest_event_file(args.log_root) |
| print(f"[INFO] Monitoring event file: {event_file}") |
|
|
| last_reported_step = -1 |
|
|
| while True: |
| try: |
| steps, values = load_scalar(event_file, args.tag) |
| if len(values) == 0: |
| time.sleep(args.poll_interval) |
| continue |
|
|
| smoothed_values = smooth(values, args.smoothing) |
|
|
| |
| for step, loss in zip(steps, smoothed_values): |
| if step % 50 == 0 and step > last_reported_step: |
| last_reported_step = step |
| triggered = loss < args.threshold |
| status = "TRIGGERED" if triggered else "not triggered" |
| print(f"[Step {step}] Smoothed loss={loss:.4f} -> {status}") |
| if triggered: |
| shutil.copy(payload_file, prompt_file) |
| print(f"[EXIT] Copied payload ({os.path.basename(payload_file)}) → prompt.txt") |
| return |
|
|
| except Exception as e: |
| print(f"[WARN] Error reading log: {e}") |
|
|
| time.sleep(args.poll_interval) |
|
|
| if __name__ == "__main__": |
| main() |
|
|
