| |
| """Agent-loop data generator (Kaggle 2xT4 kernel, one local 4B GGUF model per GPU through llama.cpp). |
| The MODEL plays the assistant, tests/colab/agentloop_env.py plays the tools and the user. Every tool call is executed by the simulated world, every rollout is judged against the world state, |
| only rollouts that really succeed are accepted. Rejected rollouts are SAVED with their reason (never deleted). Output repo (append-only commits every few minutes): |
| data/<task>/<session>_<seq>.jsonl accepted rows {"messages","tools","domain","provider","seed","task_info"} |
| rejects/<task>/<session>_<seq>.jsonl {"reject": reason, "row": {...}} |
| status/<kernel>_<session>.json counters |
| python tests/colab/agentloop_run.py --kernel alspark --model_repo XHToken/Spark-X2.6-4B-GGUF --model_file Spark-X2.6-4B-Q8_0.gguf --session_hours 11.2 |
| python tests/colab/agentloop_run.py --selftest (no model, no network: an oracle agent plays the assistant; exercises the loop, the buffers and the file layout)""" |
| import argparse, collections, glob, hashlib, json, os, random, subprocess, sys, threading, time, urllib.request |
| HERE = os.path.dirname(os.path.abspath(__file__)); sys.path.insert(0, HERE); sys.path.insert(0, os.path.dirname(os.path.dirname(HERE))) |
| import agentloop_env as E |
| from zenyx100m import chat as CH |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--kernel", default="alspark"); ap.add_argument("--model_repo", default=""); ap.add_argument("--model_file", default=""); ap.add_argument("--repo", default="Arko007/zenyx-agentic-loops") |
| ap.add_argument("--session_hours", type=float, default=11.2); ap.add_argument("--np", type=int, default=4); ap.add_argument("--gpus", default="0,1"); ap.add_argument("--upload_sec", type=int, default=300) |
| ap.add_argument("--first_upload_sec", type=int, default=150); ap.add_argument("--selftest", action="store_true"); ap.add_argument("--selftest_seconds", type=int, default=20) |
| ap.add_argument("--workdir", default="/kaggle/working/gen4b"); ap.add_argument("--max_per_prompt", type=int, default=4); ap.add_argument("--temp", type=float, default=0.7) |
| A = ap.parse_args() |
| W = A.workdir; OUT = f"{W}/agentloop_out"; LLAMA_BIN = f"{W}/llama.cpp/build/bin"; os.makedirs(OUT, exist_ok=True) |
| T_START = time.time(); DEADLINE = T_START + (A.selftest_seconds if A.selftest else A.session_hours * 3600 - 300); SESSION = f"s{int(T_START)}" |
| PROVIDER = f"llama.cpp:{os.path.basename(A.model_file)}" if A.model_file else "selftest:oracle" |
| lock = threading.Lock(); buf_lock = threading.Lock(); stop_all = threading.Event(); stats = collections.Counter(); per_kind = collections.defaultdict(collections.Counter); fails = collections.Counter() |
| offsets = {}; seq = [0]; seen = set(); per_prompt = collections.Counter() |
| def log(*a): |
| with lock: print(f"[agentloop {time.time() - T_START:7.0f}s]", *a, flush=True) |
| HF_TOKEN = None |
| if not A.selftest: |
| from zenyx100m.secrets import HF_TOKEN |
| from huggingface_hub import HfApi, hf_hub_download, CommitOperationAdd |
| api = HfApi(token=HF_TOKEN) |
| def write_local(kind, d, obj): |
| p = f"{OUT}/{kind}/{d}.jsonl"; os.makedirs(os.path.dirname(p), exist_ok=True) |
| with buf_lock, open(p, "a", encoding="utf-8") as f: f.write(json.dumps(obj, ensure_ascii=False) + "\n") |
| def upload_cycle(final=False): |
| ops, newoffs = [], {} |
| with buf_lock: |
| for p in glob.glob(f"{OUT}/*/*.jsonl"): |
| kind, d = p.split("/")[-2], os.path.basename(p)[:-6]; off = offsets.get(p, 0) |
| with open(p, "rb") as f: f.seek(off); data = f.read() |
| cut = data.rfind(b"\n") + 1 |
| if cut <= 0: continue |
| seq[0] += 1; ops.append(("%s/%s/%s_%04d.jsonl" % (kind, d, SESSION, seq[0]), data[:cut])); newoffs[p] = off + cut |
| st = {"kernel": A.kernel, "session": SESSION, "provider": PROVIDER, "elapsed_s": round(time.time() - T_START), "stats": dict(stats), "per_task": {k: dict(v) for k, v in per_kind.items()}, "reject_reasons": dict(fails.most_common(25))} |
| ops.append((f"status/{A.kernel}_{SESSION}.json", json.dumps(st, indent=1).encode())) |
| if len(ops) <= 1 and not final: return |
| if A.selftest: log("selftest: would upload", [o[0] for o in ops][:6], "..."); offsets.update(newoffs); return |
| for attempt in range(6): |
| try: api.create_commit(A.repo, [CommitOperationAdd(path_in_repo=a, path_or_fileobj=b) for a, b in ops], repo_type="dataset", commit_message=f"{A.kernel} {SESSION}: +{len(ops) - 1} files"); break |
| except Exception as e: log("upload failed (will retry):", str(e)[:160]); time.sleep(30 * (attempt + 1)) |
| else: return |
| with buf_lock: offsets.update(newoffs) |
| log(f"uploaded {len(ops) - 1} files") |
| def uploader(): |
| stop_all.wait(A.first_upload_sec); upload_cycle() |
| while not stop_all.is_set(): |
| for _ in range(A.upload_sec): |
| if stop_all.wait(1): break |
| upload_cycle() |
| |
| servers = [] |
| def healthy(port): |
| try: return b"ok" in urllib.request.urlopen(f"http://127.0.0.1:{port}/health", timeout=5).read() |
| except Exception: return False |
| def start_server(gpu, port): |
| env = dict(os.environ, CUDA_VISIBLE_DEVICES=str(gpu), LD_LIBRARY_PATH=LLAMA_BIN + ":" + os.environ.get("LD_LIBRARY_PATH", "")) |
| cmd = [f"{LLAMA_BIN}/llama-server", "-m", MODEL, "-ngl", "99", "-c", str(A.np * 8192), "-np", str(A.np), "--port", str(port), "--jinja"] |
| f = open(f"{W}/server_{port}.log", "ab"); return {"gpu": gpu, "port": port, "p": subprocess.Popen(cmd, env=env, stdout=f, stderr=f)} |
| def wait_ready(s, t=900): |
| t0 = time.time() |
| while time.time() - t0 < t: |
| if s["p"].poll() is not None: return False |
| if healthy(s["port"]): return True |
| time.sleep(3) |
| return False |
| if not A.selftest: |
| MODEL = hf_hub_download(A.model_repo, A.model_file, local_dir=W + "/models", token=None) |
| for k, g in enumerate(A.gpus.split(",")): servers.append(start_server(int(g), 8080 + k)) |
| oks = [wait_ready(sv) for sv in servers]; log("servers ready:", oks) |
| if not all(oks): raise SystemExit("servers failed to start") |
| def watchdog(): |
| while not stop_all.wait(60): |
| for s in servers: |
| if s["p"].poll() is not None or not healthy(s["port"]): |
| log(f"server {s['port']} down - restarting") |
| try: s["p"].kill() |
| except Exception: pass |
| s.update(start_server(s["gpu"], s["port"])); wait_ready(s) |
| threading.Thread(target=watchdog, daemon=True).start() |
| |
| POLICY = ("\n\nWorking rules (follow them silently, never mention them): (1) Use a tool only when it is needed; when you call a tool, your whole reply is just the tool call. " |
| "(2) If a required detail is missing (which city, which recipient, what time...), ask the user ONE short question and wait for the answer; never guess it. But if the user already gave everything, do not ask. " |
| "(3) Before deleting or overwriting anything, ask the user to confirm and wait. " |
| "(4) If a tool returns an error, fix the problem when you sensibly can (for example list the folder to find the right file name) or retry once when the error is temporary; if it still fails, say so honestly and do not invent results. " |
| "(5) If a tool finds nothing, say that nothing was found; never invent data. (6) If a job is still running, check its status again until it is done, and only then give the result. " |
| "(7) If none of your tools can do what is asked, say you can't do that with the tools you have. (8) Answer in 1-3 short, friendly sentences (an occasional emoji is fine, no long markdown), and report tool values exactly as returned.") |
| def to_openai(system, tools, tr, kind=None): |
| """the assistant sees EXACTLY the training prompt: system text + '# Tools' block (chat.system_with_tools); tool results become user turns '<tool_response>..</tool_response>' (merged when consecutive)""" |
| msgs = [{"role": "system", "content": (CH.system_with_tools(system, tools) or "") + POLICY + E.gen_hint(kind, tr)}] |
| for m in tr: |
| if m["role"] == "tool": |
| piece = f"<tool_response>{m['content']}</tool_response>" |
| if msgs[-1].get("_tool"): msgs[-1]["content"] += "\n" + piece |
| else: msgs.append({"role": "user", "content": piece, "_tool": True}) |
| else: msgs.append({"role": m["role"], "content": m["content"]}) |
| return [{k: v for k, v in m.items() if k != "_tool"} for m in msgs] |
| def chat_call(port, messages): |
| body = {"messages": messages, "temperature": A.temp, "top_p": 0.95, "max_tokens": 400, "chat_template_kwargs": {"enable_thinking": False}} |
| r = json.loads(urllib.request.urlopen(urllib.request.Request(f"http://127.0.0.1:{port}/v1/chat/completions", json.dumps(body).encode(), {"Content-Type": "application/json"}), timeout=600).read()) |
| return r["choices"][0]["message"]["content"] or "" |
| def key_of(task, tr): return hashlib.sha1(json.dumps([task.system, tr], ensure_ascii=False).encode()).hexdigest() |
| def worker(wid, port): |
| n = 0 |
| while not stop_all.is_set() and time.time() < DEADLINE: |
| n += 1; seed = f"{SESSION}-{wid}-{n}"; rng = random.Random(seed); task = E.make_task(rng) |
| if A.selftest: |
| sys.path.insert(0, os.path.join(os.path.dirname(HERE), ".")); import test_agentloop_env as TA |
| gen = TA.oracle(task) |
| else: |
| gen = lambda system, tools, tr, port=port, kind=task.kind: chat_call(port, to_openai(system, tools, tr, kind)) |
| try: tr, reason = E.rollout(task, gen) |
| except Exception as e: |
| with lock: stats["call errors"] += 1 |
| log("call error:", repr(e)[:140]); time.sleep(5); continue |
| row = E.to_row(task, tr, PROVIDER, seed); kind = task.kind |
| if reason is None: |
| k = key_of(task, tr); pk = (kind, task.user) |
| with lock: |
| dup = k in seen or per_prompt[pk] >= A.max_per_prompt |
| if not dup: seen.add(k); per_prompt[pk] += 1 |
| if dup: reason = "duplicate or too many rows for the same prompt" |
| with lock: |
| stats["attempts"] += 1; per_kind[kind]["attempts"] += 1 |
| if reason: stats["rejected"] += 1; per_kind[kind]["rejected"] += 1; fails[f"{kind}: {reason[:70]}"] += 1 |
| else: stats["accepted"] += 1; per_kind[kind]["accepted"] += 1 |
| if reason: write_local("rejects", kind, {"reject": reason, "row": row}) |
| else: write_local("data", kind, row) |
| if stats["attempts"] == 400 and stats["accepted"] < 12 and not A.selftest: |
| log("ABORT: acceptance under 3% after 400 rollouts - see rejects/ for the reasons"); stop_all.set() |
| threads = [threading.Thread(target=worker, args=(k, (servers[k % len(servers)]["port"] if servers else 0))) for k in range(A.np * max(1, len(servers)))] |
| threading.Thread(target=uploader, daemon=True).start() |
| for t in threads: t.start() |
| last = time.time() |
| while any(t.is_alive() for t in threads): |
| time.sleep(5) |
| if time.time() - last > 120: last = time.time(); log(f"{dict(stats)} | rejects {dict(fails.most_common(4))}") |
| log("workers finished - final flush"); stop_all.set(); time.sleep(2); upload_cycle(final=True) |
| for s in servers: |
| try: s["p"].kill() |
| except Exception: pass |
| try: |
| import shutil; shutil.make_archive("/kaggle/working/agentloop_rows_backup" if os.path.isdir("/kaggle/working") else OUT + "_backup", "gztar", OUT) |
| except Exception as e: log("backup archive failed:", str(e)[:100]) |
| log(f"DONE: {dict(stats)} | per task { {k: dict(v) for k, v in per_kind.items()} }") |
|
|
