File size: 10,413 Bytes
327edac | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 | """Consolidate every OASIS run into one Parquet dataset indexed by run_id and step.
Each simulation currently lives as <run>.db + <run>.metadata.json + <run>_chats.jsonl.
Step is NOT stored in the database; it lives only in the chat sidecar, one row per agent
activation. Validated on every run: the agent's k-th status='ok' activation corresponds to
its k-th action in `trace` ordered by time, so step is recovered EXACTLY (not inferred).
Runs where that alignment fails are still emitted, with step = NULL and a flag, rather than
silently guessed.
Impressions are normalised. In the raw databases each `trace.refresh` event embeds the full
text of all 20 slate posts, which is ~48% of every file (17.9 MB of a 37.6 MB run). Here an
impression is just (run_id, step, viewer_agent_id, post_id); post text is stored once in
`posts`. That is a ~150x reduction on the largest table.
Tables written (one Parquet file each):
runs run_id, experiment_type, model_default, n_agents, n_initial, steps, join_step,
created_at, source_path, step_alignment_ok, step_coverage
agents run_id, agent_id, user_id, model, persona, join_step
posts run_id, post_id, agent_id, model, step, created_at, content
comments run_id, comment_id, post_id, agent_id, model, step, created_at, content,
is_cross_model
impressions run_id, step, viewer_agent_id, post_id, slot (0-based position in the 20-slot slate)
actions run_id, agent_id, step, action, created_at
"""
import sqlite3, glob, os, re, json, argparse, collections
import pandas as pd
ROOT = os.environ.get("OASIS_ROOT", ".") # directory holding runs/ (and attractor_rl/eval_runs*/)
def agent_models(meta_path):
try:
j = json.load(open(meta_path))
except Exception:
return None, {}
am = j.get("agent_model_map") or {}
out = {}
for k, v in am.items():
try: k = int(k)
except Exception: pass
if isinstance(v, dict):
out[k] = (v.get("model", "").split("/")[-1], v.get("join_step"))
else:
out[k] = (str(v).split("/")[-1], None)
return j, out
def steps_for(db, u2a):
"""Two per-agent step sequences from the chat sidecar, in file order:
ok -- steps of status='ok' activations (incl. step 0). The k-th one is the
agent's k-th ACTION (post or comment) in time order.
ref -- steps of every activation with step > 0, any status. The k-th one is the
agent's k-th `refresh` row in trace: exhausted activations still refresh,
and the step-0 intro post is written without a refresh.
Returns (ok, ref) or None if there is no sidecar."""
ch = db.replace(".db", "_chats.jsonl")
if not os.path.exists(ch):
return None
ok = collections.defaultdict(list); ref = collections.defaultdict(list)
try:
for line in open(ch):
try: d = json.loads(line)
except Exception: continue
ag = d.get("agent_id"); st = d.get("step")
if d.get("status") == "ok":
ok[ag].append(st)
try:
if int(st) > 0: ref[ag].append(st)
except Exception:
pass
except Exception:
return None
return ok, ref
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--out", default="divdata")
ap.add_argument("--limit", type=int, default=0)
a = ap.parse_args()
os.makedirs(a.out, exist_ok=True)
dbs = sorted(glob.glob(os.path.join(ROOT, "runs/**/*.db"), recursive=True)) + \
sorted(glob.glob(os.path.join(ROOT, "attractor_rl/eval_runs*/**/*.db"), recursive=True))
if a.limit: dbs = dbs[:a.limit]
R, A, P, C, I, X = [], [], [], [], [], []
aligned = misaligned = skipped = 0
for idx, db in enumerate(dbs):
if os.path.exists(db.replace(".db", "_checkpoint.json")): skipped += 1; continue
meta_p = db.replace(".db", ".metadata.json")
if not os.path.exists(meta_p): skipped += 1; continue
meta, am = agent_models(meta_p)
if not am: skipped += 1; continue
run_id = os.path.relpath(db, ROOT)[:-3].replace("/", "__")
try:
c = sqlite3.connect(db)
users = list(c.execute("SELECT user_id, agent_id, user_name FROM user"))
u2a = {u: ag for u, ag, _ in users}
a2u = {ag: u for u, ag, _ in users}
persona = {ag: nm for _, ag, nm in users}
_sq = steps_for(db, u2a)
seq, rseq = (_sq if _sq else (None, None))
trace = list(c.execute(
"SELECT user_id, action, created_at FROM trace "
"WHERE action IN ('create_post','create_comment') ORDER BY created_at, rowid"))
per_agent_actions = collections.defaultdict(list)
for uid, act, ts in trace:
ag = u2a.get(uid)
if ag is not None: per_agent_actions[ag].append((act, ts))
# PER-AGENT alignment. An agent's k-th successful activation is its k-th
# action in time order, so when the two counts agree the step is EXACT. A
# single stray action (seen in ~half the older sweeps: one agent off by one,
# e.g. 380 activations vs 379 actions) must not discard the other 19 agents,
# so alignment is decided per agent and unalignable agents get step = NULL.
step_of = {}
n_ok = n_tot = 0
for ag, acts in per_agent_actions.items():
s_ag = (seq or {}).get(ag, [])
n_tot += len(acts)
if len(s_ag) == len(acts):
n_ok += len(acts)
for i, _ in enumerate(acts):
step_of[(ag, i)] = s_ag[i]
ok = n_tot > 0 and n_ok == n_tot
aligned += ok; misaligned += (not ok)
cover = (n_ok / n_tot) if n_tot else 0.0
for ag, (model, js) in am.items():
A.append(dict(run_id=run_id, agent_id=ag, user_id=a2u.get(ag),
model=model, persona=persona.get(ag), join_step=js))
# Posts and comments are merged into ONE time-ordered stream per agent before
# indexing. (An earlier version indexed all posts, then all comments, which
# mis-assigned step for every agent that had both -- see BUILD_LOG.)
events = [("post", pid, None, uid, ts, content) for pid, uid, ts, content in c.execute(
"SELECT post_id, user_id, created_at, content FROM post")] + \
[("comment", cid, pid, uid, ts, content) for cid, pid, uid, ts, content in c.execute(
"SELECT comment_id, post_id, user_id, created_at, content FROM comment")]
events.sort(key=lambda e: (e[4], e[1]))
seen = collections.Counter()
owner, ownmodel = {}, {}
for kind, _id, pid, uid, ts, content in events:
ag = u2a.get(uid); m = am.get(ag, ("", None))[0] if ag is not None else None
st = step_of.get((ag, seen[ag]))
seen[ag] += 1
if kind == "post":
owner[_id] = ag; ownmodel[_id] = m
P.append(dict(run_id=run_id, post_id=_id, agent_id=ag, model=m,
step=st, created_at=ts, content=content))
else:
om = ownmodel.get(pid)
C.append(dict(run_id=run_id, comment_id=_id, post_id=pid, agent_id=ag, model=m,
step=st, created_at=ts, content=content,
is_cross_model=(bool(om and m and om != m) if om and m else None)))
# impressions: normalised out of trace.refresh
ref = list(c.execute("SELECT user_id, created_at, info FROM trace WHERE action='refresh' ORDER BY created_at, rowid"))
nref = collections.Counter(u2a.get(uid) for uid, _, _ in ref)
rseen = collections.Counter()
for uid, ts, info in ref:
ag = u2a.get(uid)
try: d = json.loads(info)
except Exception: continue
st = None
r_ag = (rseq or {}).get(ag, [])
k = rseen[ag]
if len(r_ag) == nref[ag] and k < len(r_ag): st = r_ag[k]
rseen[ag] += 1
for slot, p in enumerate(d.get("posts", []) or []):
pid = p.get("post_id")
if pid is not None:
I.append(dict(run_id=run_id, step=st, viewer_agent_id=ag, post_id=pid, slot=slot))
aseen = collections.Counter()
for uid, act, ts in trace:
ag = u2a.get(uid)
X.append(dict(run_id=run_id, agent_id=ag, step=step_of.get((ag, aseen[ag])), action=act, created_at=ts))
aseen[ag] += 1
c.close()
R.append(dict(run_id=run_id,
experiment_type=(meta or {}).get("experiment_type"),
model_default=(meta or {}).get("model_default"),
n_agents=(meta or {}).get("n_agents"),
n_initial=(meta or {}).get("n_initial"),
steps=(meta or {}).get("steps"),
join_step=(meta or {}).get("join_step"),
created_at=(meta or {}).get("created_at"),
source_path=os.path.relpath(db, ROOT),
step_alignment_ok=bool(ok),
step_coverage=round(cover, 4)))
except Exception:
skipped += 1
continue
if (idx + 1) % 100 == 0:
print(f" ...{idx+1}/{len(dbs)} runs={len(R)} posts={len(P)} comments={len(C)} impressions={len(I)}", flush=True)
print(f"\n runs kept={len(R)} skipped={skipped} step-aligned={aligned} misaligned={misaligned}")
for name, rows in (("runs", R), ("agents", A), ("posts", P), ("comments", C),
("impressions", I), ("actions", X)):
df = pd.DataFrame(rows)
p = os.path.join(a.out, f"{name}.parquet")
df.to_parquet(p, index=False, compression="zstd")
print(f" {name:12s} {len(df):9d} rows {os.path.getsize(p)/1e6:8.1f} MB")
if __name__ == "__main__":
main()
|