diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_model.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_model.py new file mode 100644 index 0000000000000000000000000000000000000000..9c8e5da864f18f673c829d8b68db641d728ca437 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_model.py @@ -0,0 +1,339 @@ +"""FP32 Qwen adapter. All CE/KL reductions preserve per-sequence weighting.""" + +from __future__ import annotations + +import copy +import hashlib +import os +import time + +import numpy as np +import torch +import torch.nn.functional as F +from transformers import AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList + +from .hebbian_data import TEMPLATE, score_answer +from .hebbian_learning import ARTIFACTS, DATA, config, now, read_json, write_json + + +def tensor_hash(tensor): + return hashlib.sha256(tensor.detach().cpu().contiguous().numpy().tobytes()).hexdigest() + + +def state_hashes(model): + return {name: tensor_hash(p) for name, p in model.state_dict().items()} + + +def aggregate_hash(hashes): + return hashlib.sha256( + "\n".join(f"{k}:{v}" for k, v in sorted(hashes.items())).encode() + ).hexdigest() + + +def set_determinism(seed=0): + os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8") + torch.set_num_threads(4) + torch.manual_seed(seed) + np.random.seed(seed) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.backends.cudnn.benchmark = False + torch.use_deterministic_algorithms(True) + + +class QwenExperiment: + def __init__(self, device="cuda:3"): + set_determinism() + self.cfg = config() + self.device = torch.device(device) + source = DATA / "source/qwen3-0.6b-base" + self.tokenizer = AutoTokenizer.from_pretrained(source, local_files_only=True) + self.tokenizer.pad_token = self.tokenizer.eos_token + self.model = ( + AutoModelForCausalLM.from_pretrained( + source, + local_files_only=True, + torch_dtype=torch.float32, + attn_implementation=self.cfg["model"]["attention"], + ) + .to(self.device) + .eval() + ) + self.model.requires_grad_(False) + self.layer = self.model.model.layers[self.cfg["model"]["layer"]] + self.mlp = self.layer.mlp + assert self.mlp.down_proj.weight.shape == (1024, 3072) + assert self.mlp.up_proj.weight.numel() + self.mlp.gate_proj.weight.numel() == 6291456 + self.base_local = {n: p.detach().clone() for n, p in self.mlp.named_parameters()} + self.reference = None + + def restore_base(self): + with torch.no_grad(): + for n, p in self.mlp.named_parameters(): + p.copy_(self.base_local[n]) + + def configure_trainable(self, phase): + self.model.requires_grad_(False) + names = ["down_proj.weight"] if phase == "adapt" else ["up_proj.weight", "gate_proj.weight"] + for name, p in self.mlp.named_parameters(): + p.requires_grad_(name in names) + return [p for p in self.model.parameters() if p.requires_grad] + + def make_reference(self): + self.reference = copy.deepcopy(self.model).eval().requires_grad_(False) + + def rows(self, records, views=(0,)): + return [(r, v, r["encoded"][v]) for r in records for v in views] + + def batch(self, encoded, prompt_only=False): + sequences = [ + x["input_ids"][: x["answer_start"]] if prompt_only else x["input_ids"] for x in encoded + ] + width = max(map(len, sequences)) + ids = torch.full( + (len(sequences), width), + self.tokenizer.pad_token_id, + dtype=torch.long, + device=self.device, + ) + attention = torch.zeros_like(ids) + answer = torch.zeros_like(ids, dtype=torch.bool) + for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)): + ids[i, : len(seq)] = torch.tensor(seq, device=self.device) + attention[i, : len(seq)] = 1 + if not prompt_only: + answer[i, : len(seq)] = torch.tensor(enc["loss_mask"], device=self.device).bool() + return ids, attention, answer + + def hidden(self, ids, attention, model=None): + return ( + (model or self.model) + .model(input_ids=ids, attention_mask=attention, use_cache=False) + .last_hidden_state + ) + + def ce(self, encoded, model=None): + ids, attention, mask = self.batch(encoded) + hidden = self.hidden(ids, attention, model) + b, t = torch.where(mask[:, 1:]) + logits = (model or self.model).lm_head(hidden[b, t]) + losses = F.cross_entropy(logits, ids[b, t + 1], reduction="none") + sums = torch.zeros(len(encoded), device=self.device).scatter_add_(0, b, losses) + counts = torch.bincount(b, minlength=len(encoded)) + return sums / counts + + def kl(self, encoded): + if self.reference is None: + raise RuntimeError("An episode-specific parent reference is required") + ids, attention, mask = self.batch(encoded) + b, t = torch.where(mask[:, 1:]) + with torch.no_grad(): + ref_hidden = self.hidden(ids, attention, self.reference) + ref_log = F.log_softmax(self.reference.lm_head(ref_hidden[b, t]), dim=-1) + logits = self.model.lm_head(self.hidden(ids, attention)[b, t]) + losses = F.kl_div( + F.log_softmax(logits, dim=-1), ref_log, reduction="none", log_target=True + ).sum(-1) + sums = torch.zeros(len(encoded), device=self.device).scatter_add_(0, b, losses) + return sums / torch.bincount(b, minlength=len(encoded)) + + def features(self, encoded, detach=True): + captured = {} + + def capture(module, args): + captured["phi"] = args[0] + + def capture_input(module, args): + captured["x"] = args[0] + + handle = self.mlp.down_proj.register_forward_pre_hook(capture) + input_handle = self.mlp.register_forward_pre_hook(capture_input) + try: + ids, attention, _ = self.batch(encoded, prompt_only=True) + if detach: + with torch.no_grad(): + hidden = self.hidden(ids, attention) + positions = attention.sum(1) - 1 + self.last_prompt_logits = self.model.lm_head( + hidden[torch.arange(len(encoded), device=self.device), positions] + ).detach() + x = captured["x"][torch.arange(len(encoded), device=self.device), positions] + self.last_layer_inputs = x.detach() + self.original_features = ( + F.linear(x, self.base_local["up_proj.weight"]) + * F.silu(F.linear(x, self.base_local["gate_proj.weight"])) + ).detach() + else: + self.hidden(ids, attention) + phi = captured["phi"][ + torch.arange(len(encoded), device=self.device), attention.sum(1) - 1 + ] + return phi.detach() if detach else phi + finally: + handle.remove() + input_handle.remove() + + @torch.no_grad() + def generate(self, prompts, max_new_tokens=24): + # Left-padding generation; positions are computed from the attention mask. + self.tokenizer.padding_side = "left" + inputs = self.tokenizer( + prompts, padding=True, return_tensors="pt", add_special_tokens=False + ).to(self.device) + prompt_width = inputs.input_ids.shape[1] + tokenizer = self.tokenizer + + class StopAtNewline(StoppingCriteria): + def __call__(self, input_ids, scores, **kwargs): + texts = tokenizer.batch_decode( + input_ids[:, prompt_width:], skip_special_tokens=True + ) + return torch.tensor(["\n" in text for text in texts], device=input_ids.device) + + output = self.model.generate( + **inputs, + do_sample=False, + max_new_tokens=max_new_tokens, + pad_token_id=self.tokenizer.pad_token_id, + eos_token_id=self.tokenizer.eos_token_id, + use_cache=True, + logits_to_keep=1, + stopping_criteria=StoppingCriteriaList([StopAtNewline()]), + ) + tail = output[:, inputs.input_ids.shape[1] :] + predictions = self.tokenizer.batch_decode(tail, skip_special_tokens=True) + # Padding after a newline stop is not evidence of the model emitting EOS. + eos_emitted = [] + for row in tail: + emitted = False + for length, token in enumerate(row, 1): + if int(token) == self.tokenizer.eos_token_id: + emitted = True + break + if "\n" in self.tokenizer.decode(row[:length], skip_special_tokens=True): + break + eos_emitted.append(emitted) + return predictions, eos_emitted + + @torch.no_grad() + def evaluate(self, records, views=(0, 1, 2), batch_size=24): + rows = self.rows(records, views) + result = [] + for start in range(0, len(rows), batch_size): + chunk = rows[start : start + batch_size] + encoded = [x[2] for x in chunk] + losses = self.ce(encoded).tolist() + predictions, eos = self.generate([TEMPLATE.format(r["views"][v]) for r, v, _ in chunk]) + phi = self.features(encoded) + for i, (r, v, enc) in enumerate(chunk): + prediction = predictions[i] + first_token = enc["input_ids"][enc["answer_start"]] + logits = self.last_prompt_logits[i] + competitor_logits = logits.clone() + competitor_logits[first_token] = -torch.inf + competitor = int(competitor_logits.argmax()) + result.append( + { + "case_id": r["case_id"], + "relation_id": r["relation_id"], + "subject_group": r["subject_group"], + "view_id": v, + "answer_nll": losses[i], + "prediction": prediction, + "answer_em": score_answer(prediction, r.get("aliases", [r["answer"]])), + "eos_emitted": eos[i], + "feature_norm": float(phi[i].norm()), + "first_answer_nll": float(-logits.log_softmax(-1)[first_token]), + "first_answer_margin": float(logits[first_token] - logits[competitor]), + "current_competitor_token": competitor, + "answer_tokens": enc["answer_tokens"], + "prompt_tokens": enc["prompt_tokens"], + } + ) + return result + + def gradient(self, encoded): + loss = self.ce([encoded]).mean() + grad = torch.autograd.grad(loss, self.mlp.down_proj.weight)[0] + return grad.detach(), float(loss.detach()) + + def verify_hooks_and_gradients(self, encoded): + self.configure_trainable("adapt") + captured = {} + + def capture_input(module, args): + captured["x"] = args[0].detach() + + def capture_down(module, args, output): + captured["phi"] = args[0].detach() + output.retain_grad() + captured["output"] = output + + handles = [ + self.mlp.register_forward_pre_hook(capture_input), + self.mlp.down_proj.register_forward_hook(capture_down), + ] + try: + self.model.zero_grad(set_to_none=True) + self.ce([encoded]).mean().backward() + with torch.no_grad(): + expected_phi = self.mlp.up_proj(captured["x"]) * F.silu( + self.mlp.gate_proj(captured["x"]) + ) + phi_error = float((expected_phi - captured["phi"]).abs().max()) + delta = captured["output"].grad.double().flatten(0, 1) + phi = captured["phi"].double().flatten(0, 1) + reconstructed = delta.T @ phi + actual = self.mlp.down_proj.weight.grad.double() + grad_error = float((reconstructed - actual).norm() / actual.norm()) + nonanswer_positions = encoded["answer_start"] - 1 + prompt_grad_norm = float(delta[:nonanswer_positions].norm()) + assert phi_error == 0.0 + assert grad_error < 1e-5 + return { + "phi_max_absolute_error": phi_error, + "gradient_relative_error": grad_error, + "earlier_prompt_delta_norm": prompt_grad_norm, + "all_positions_used": True, + "trainable_parameters": sum( + p.numel() for p in self.model.parameters() if p.requires_grad + ), + "pass": True, + } + finally: + for handle in handles: + handle.remove() + self.model.zero_grad(set_to_none=True) + + +def run_baseline(device, shard=0, shards=1): + engine = QwenExperiment(device) + candidates = read_json(DATA / "candidates.json")[shard::shards] + out = DATA / f"baseline-shard-{shard}.jsonl" + finished = {} + if out.exists(): + for line in out.read_text().splitlines(): + row = __import__("json").loads(line) + finished[row["case_id"]] = row + candidates = [r for r in candidates if r["case_id"] not in finished] + start_time = time.monotonic() + for start in range(0, len(candidates), 8): + chunk = candidates[start : start + 8] + rows = engine.evaluate(chunk) + with out.open("a") as f: + for record in chunk: + item = { + "case_id": record["case_id"], + "views": [r for r in rows if r["case_id"] == record["case_id"]], + } + f.write(__import__("json").dumps(item, ensure_ascii=False) + "\n") + if start % 80 == 0: + print( + f"baseline shard={shard} {start + len(chunk)}/{len(candidates)} " + f"elapsed={time.monotonic() - start_time:.1f}s", + flush=True, + ) + write_json( + ARTIFACTS / f"baseline-shard-{shard}-complete.json", + {"time": now(), "rows": len(candidates) + len(finished), "shards": shards}, + ) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_statistics.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_statistics.py new file mode 100644 index 0000000000000000000000000000000000000000..52bcc965886f86bf20041ec40ce6aa95b96a725f --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_statistics.py @@ -0,0 +1,168 @@ +"""Development-only predictor fitting and episode-cluster paired inference.""" + +from __future__ import annotations + +import itertools + +import numpy as np + +from .hebbian_learning import ( + ARTIFACTS, + DATA, + RESULTS, + config, + now, + q_auc, + read_json, + sha256, + write_json, +) + + +def fit_ridge(x, y, alpha): + mean, scale = x.mean(0), x.std(0) + scale = np.where(scale > 1e-12, scale, 1) + z = (x - mean) / scale + intercept = float(y.mean()) + coef = np.linalg.solve(z.T @ z + alpha * np.eye(z.shape[1]), z.T @ (y - intercept)) + return { + "mean": mean.tolist(), + "scale": scale.tolist(), + "coefficients": coef.tolist(), + "intercept": intercept, + "alpha": alpha, + "n_features": x.shape[1], + } + + +def predict(model, x): + x = x[:, : model["n_features"]] + return ((x - model["mean"]) / model["scale"]) @ np.array(model["coefficients"]) + model[ + "intercept" + ] + + +def fact_trajectories(path): + evaluations = [read_json(p) for p in sorted(path.glob("evaluation-*.json"))] + nodes = [e["rows"][0]["step"] for e in evaluations] + by_node = [{(r["case_id"], r["view_id"]): r for r in e["rows"]} for e in evaluations] + cases = sorted({r["case_id"] for r in evaluations[0]["rows"]}) + result = [] + for case in cases: + rewrite = [np.mean([rows[case, v]["answer_em"] for v in [1, 2]]) for rows in by_node] + standard = [rows[case, 0]["answer_em"] for rows in by_node] + all_correct = [all(rows[case, v]["answer_em"] for v in range(3)) for rows in by_node] + sustained = next( + (i for i in range(len(nodes) - 1) if all_correct[i] and all_correct[i + 1]), None + ) + first = by_node[0][case, 0] + result.append( + { + "case_id": case, + "q_auc": float(q_auc(rewrite, nodes)), + "q_gain_auc": float(q_auc(np.array(rewrite) - rewrite[0], nodes)), + "standard_auc": float(q_auc(standard, nodes)), + "nodes": nodes, + "rewrite_accuracy": rewrite, + "standard_accuracy": standard, + "sustained_step": nodes[sustained] if sustained is not None else None, + "sustained_exposures": by_node[sustained][case, 0]["exposures"] + if sustained is not None + else None, + "endpoint_first_success": sustained is None and all_correct[-1], + "right_censored": sustained is None, + "relation_id": first["relation_id"], + } + ) + return result + + +def freeze_b(): + from .hebbian_train import frozen_training_sources, run_summary, select_config + + episodes = read_json(DATA / "episodes.json")["B_dev"] + candidates = [] + for lr in config()["adapt"]["learning_rates"]: + summaries = [run_summary(RESULTS / f"B/dev-lr{lr:g}-e{i}") for i in range(len(episodes))] + candidates.append( + { + "learning_rate": lr, + "q_auc": float(np.mean([s["q_auc"] for s in summaries])), + "keep_damage": float(np.mean([s["keep_damage"] for s in summaries])), + "episodes": summaries, + } + ) + chosen = select_config(candidates, "q_auc", True) + lr = chosen["learning_rate"] + x, y, groups = [], [], [] + for episode in range(len(episodes)): + path = RESULTS / f"B/dev-lr{lr:g}-e{episode}" + if not (path / "complete.json").exists(): + raise RuntimeError("All B_dev runs must have completion receipts") + outcomes = {r["case_id"]: r["q_auc"] for r in fact_trajectories(path)} + for row in read_json(path / "prospective-features.json")["rows"]: + x.append(row["features"]) + y.append(outcomes[row["case_id"]]) + groups.append(episode) + x, y, groups = np.array(x), np.array(y), np.array(groups) + predictors = {} + for name, width in [("P0", 4), ("P1", 8), ("P2", 10)]: + scores = {} + for alpha in config()["statistics"]["ridge_grid"]: + errors = [] + for group in np.unique(groups): + train = groups != group + model = fit_ridge(x[train, :width], y[train], alpha) + errors.append(np.mean(np.abs(predict(model, x[~train]) - y[~train]))) + scores[alpha] = float(np.mean(errors)) + best_alpha = min(scores, key=scores.get) + predictors[name] = {**fit_ridge(x[:, :width], y, best_alpha), "cv_mae": scores} + write_json( + ARTIFACTS / "B-lock.json", + { + "time": now(), + "status": "locked", + "learning_rate": lr, + "lr_candidates": candidates, + "predictors": predictors, + "source_hashes": frozen_training_sources(), + "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"), + "fitting_scope": "B_dev only; fold-specific training standardization in episode CV", + }, + ) + + +def paired_inference(differences): + differences = np.asarray(differences, dtype=np.float64) + rng = np.random.default_rng(config()["statistics"]["seed"]) + n = len(differences) + samples = differences[rng.integers(0, n, (10000, n))].mean(1) + observed = float(differences.mean()) + signs = np.array(list(itertools.product([-1, 1], repeat=n))) + p = float(np.mean(np.abs((signs * differences).mean(1)) >= abs(observed) - 1e-14)) + return { + "mean": observed, + "ci95": np.quantile(samples, [0.025, 0.975]).tolist(), + "exact_two_sided_sign_p": p, + "episode_differences": differences.tolist(), + "n_episodes": n, + } + + +def rankdata(values): + values = np.asarray(values) + order = np.argsort(values, kind="stable") + ranked = np.empty(len(values), dtype=float) + i = 0 + while i < len(values): + j = i + 1 + while j < len(values) and values[order[j]] == values[order[i]]: + j += 1 + ranked[order[i:j]] = (i + j - 1) / 2 + i = j + return ranked + + +def spearman(x, y): + a, b = rankdata(x), rankdata(y) + return float(np.corrcoef(a, b)[0, 1]) if a.std() and b.std() else None diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_train.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_train.py new file mode 100644 index 0000000000000000000000000000000000000000..f70905fa1648aeba1d7bad8aca55a77bbcadd72f --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_train.py @@ -0,0 +1,811 @@ +"""Paired formation/adaptation, prospective diagnostics and exact state resumption.""" + +from __future__ import annotations + +import itertools +import json +import random +import time + +import numpy as np +import torch +import torch.nn.functional as F + +from .hebbian_learning import ( + ARTIFACTS, + CONFIG_PATH, + DATA, + RESULTS, + ROOT, + config, + effective_rank, + now, + q_auc, + read_json, + sha256, + write_json, +) +from .hebbian_model import ( + QwenExperiment, + aggregate_hash, + set_determinism, + state_hashes, +) + + +def grouping(records, seed): + """Exact minimum-cost derangements; random seeded ties, real CE labels unchanged.""" + n = len(records) + rng = np.random.default_rng(seed) + permutations = [ + p for p in itertools.permutations(range(n)) if all(i != j for i, j in enumerate(p)) + ] + + def cost(p): + return sum( + 10 * (records[i]["target_id"] == records[j]["target_id"]) + + (records[i]["relation_id"] != records[j]["relation_id"]) + for i, j in enumerate(p) + ) + + costs = np.array([cost(p) for p in permutations]) + best = np.flatnonzero(costs == costs.min()) + p1, p2 = [permutations[int(rng.choice(best))] for _ in range(2)] + groups = [(3 * i, 3 * p1[i] + 1, 3 * p2[i] + 2) for i in range(n)] + return groups + + +def contrastive_loss(features, target_ids, groups, tau=0.1): + z = F.normalize(features, dim=-1, eps=1e-8) + similarities = z @ z.T / tau + positive = torch.zeros_like(similarities, dtype=torch.bool) + for group in groups: + for i in group: + for j in group: + if i != j: + positive[i, j] = True + negative = torch.tensor([[a != b for b in target_ids] for a in target_ids], device=z.device) + negative &= ~positive + negative.fill_diagonal_(False) + assert torch.all(positive.sum(1) == 2) + assert torch.all(negative.sum(1) >= 1) + allowed = positive | negative + log_denominator = similarities.masked_fill(~allowed, -torch.inf).logsumexp(1) + loss = (log_denominator - (similarities * positive).sum(1) / positive.sum(1)).mean() + return loss, {"positive_pairs": int(positive.sum()), "negative_pairs": int(negative.sum())} + + +def optimizer(parameters, lr): + cfg = config()["optimizer"] + return torch.optim.AdamW( + parameters, + lr=lr, + betas=tuple(cfg["betas"]), + eps=cfg["eps"], + weight_decay=cfg["weight_decay"], + ) + + +def replay_batch(pools, texts, step): + facts = pools["R_keep"] + return [facts[(step * 6 + i) % len(facts)]["encoded"][0] for i in range(6)] + [ + texts["train"][(step * 2 + i) % len(texts["train"])] for i in range(2) + ] + + +def frozen_training_sources(): + paths = [CONFIG_PATH] + sorted((ROOT / "src/llm_memory_editability").glob("hebbian*.py")) + paths += [ROOT / "scripts/run_hebbian_learning.py"] + return {str(p.relative_to(ROOT)): sha256(p) for p in paths} + + +def save_checkpoint(path, engine, opt, step, meta, ledger): + state = { + "parameters": {n: p.detach().cpu().clone() for n, p in engine.mlp.named_parameters()}, + "optimizer": opt.state_dict(), + "step": step, + "data_cursor": step, + "torch_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(engine.device) + if engine.device.type == "cuda" + else None, + "numpy_rng": np.random.get_state(), + "python_rng": random.getstate(), + "meta": meta, + "ledger": ledger, + } + tmp = path.with_name(path.name + ".tmp") + torch.save(state, tmp) + tmp.replace(path) + + +def restore_checkpoint(path, engine, opt, meta): + state = torch.load(path, map_location="cpu", weights_only=False) + if state["meta"] != meta: + raise RuntimeError(f"Checkpoint contract differs: {path}") + with torch.no_grad(): + for n, p in engine.mlp.named_parameters(): + p.copy_(state["parameters"][n]) + opt.load_state_dict(state["optimizer"]) + torch.set_rng_state(state["torch_rng"]) + if state["cuda_rng"] is not None: + torch.cuda.set_rng_state(state["cuda_rng"], engine.device) + np.random.set_state(state["numpy_rng"]) + random.setstate(state["python_rng"]) + return state["step"], state["ledger"] + + +def load_parent(engine, parent_path=None): + engine.restore_base() + if parent_path is not None: + state = torch.load(parent_path, map_location="cpu", weights_only=False) + with torch.no_grad(): + for n, p in engine.mlp.named_parameters(): + p.copy_(state["parameters"][n]) + + +def gradient_cos(a, b): + a, b = a.double(), b.double() + return float((a * b).sum() / (a.norm() * b.norm()).clamp_min(1e-30)) + + +def diagnose_episode(engine, records, replay, lr, out): + """Saved before the learning trajectory; Adam candidate uses training data only.""" + engine.configure_trainable("adapt") + p = engine.mlp.down_proj.weight + original = p.detach().clone() + encoded = [r["encoded"][v] for r in records for v in range(3)] + features = engine.features(encoded).double().cpu().numpy().reshape(len(records), 3, -1) + unit = features / np.maximum(np.linalg.norm(features, axis=-1, keepdims=True), 1e-8) + p0_gram = unit[:, 0] @ unit[:, 0].T + rank = effective_rank(features[:, 0]) + opt = optimizer([p], lr) + opt.zero_grad(set_to_none=True) + (engine.ce([r["encoded"][0] for r in records[:8]]).mean() + engine.kl(replay).mean()).backward() + torch.nn.utils.clip_grad_norm_([p], 1.0) + opt.step() + delta = (p.detach() - original).clone() + with torch.no_grad(): + p.copy_(original) + torch.save( + {"delta_B": delta.cpu(), "phi": torch.from_numpy(features)}, out / "initial-diagnostics.pt" + ) + diagnostic = [] + for i, record in enumerate(records): + grads, losses = zip(*(engine.gradient(enc) for enc in record["encoded"]), strict=True) + other = [ + p0_gram[i, j] for j, r in enumerate(records) if r["target_id"] != record["target_id"] + ] + if not other: + raise ValueError("Each episode needs different-answer facts") + norms = np.linalg.norm(features[i], axis=1) + feature_values = [ + losses[0], + record["encoded"][0]["answer_tokens"], + record["encoded"][0]["prompt_tokens"], + float(grads[0].double().norm()), + float(np.mean(unit[i, 1:] @ unit[i, 0])), + float(max(other)), + float(norms[1:].mean() / norms[0]), + rank, + float(np.mean([gradient_cos(grads[0], g) for g in grads[1:]])), + float(np.mean([float((g.double() * delta.double()).sum()) for g in grads[1:]])), + ] + diagnostic.append( + { + "case_id": record["case_id"], + "features": feature_values, + "p0_p1_cos": float(unit[i, 0] @ unit[i, 1]), + "p0_p2_cos": float(unit[i, 0] @ unit[i, 2]), + "feature_norms": norms.tolist(), + "initial_nll": list(losses), + } + ) + engine.model.zero_grad(set_to_none=True) + assert torch.equal(p, original) + write_json( + out / "prospective-features.json", + { + "saved_at": now(), + "rows": diagnostic, + "information": { + "P0": "initial answer NLL, lengths, labeled training gradient norm", + "P1": "P0 plus prompt-only phi geometry", + "P2": "P1 plus labeled evaluation gradients and training-only Adam candidate", + }, + }, + ) + return diagnostic + + +def first_order_calibration(engine, record, out): + parameter = engine.mlp.down_proj.weight + initial = parameter.detach().clone() + source_grad, _ = engine.gradient(record["encoded"][0]) + rows = [] + for view in [1, 2]: + encoded = record["encoded"][view] + grad, nll0 = engine.gradient(encoded) + ids, attention, _ = engine.batch([encoded], prompt_only=True) + answer_token = encoded["input_ids"][encoded["answer_start"]] + logits = engine.model.lm_head(engine.hidden(ids, attention)[0, -1]) + competitor_logits = logits.detach().clone() + competitor_logits[answer_token] = -torch.inf + competitor = int(competitor_logits.argmax()) + margin = logits[answer_token] - logits[competitor] + margin_grad = torch.autograd.grad(margin, parameter)[0].detach() + margin0 = float(margin.detach()) + for relative_step in [1e-5, 1e-4]: + proposal = ( + -source_grad + * (relative_step * initial.double().norm() / source_grad.double().norm()).float() + ) + with torch.no_grad(): + parameter.copy_(initial + proposal) + actual_delta = parameter - initial + actual_nll = float(engine.ce([encoded])[0]) - nll0 + new_logits = engine.model.lm_head(engine.hidden(ids, attention)[0, -1]) + actual_margin = float(new_logits[answer_token] - new_logits[competitor]) - margin0 + predicted_nll = float((grad.double() * actual_delta.double()).sum()) + predicted_margin = float((margin_grad.double() * actual_delta.double()).sum()) + parameter.copy_(initial) + entry = { + "case_id": record["case_id"], + "view_id": view, + "relative_step": relative_step, + "competitor_token": competitor, + "actual_nll_change": actual_nll, + "predicted_nll_change": predicted_nll, + "actual_margin_change": actual_margin, + "predicted_margin_change": predicted_margin, + } + for name, actual, predicted in [ + ("nll", actual_nll, predicted_nll), + ("margin", actual_margin, predicted_margin), + ]: + entry[name + "_absolute_error"] = abs(actual - predicted) + entry[name + "_relative_error"] = abs(actual - predicted) / max( + abs(predicted), 1e-6 + ) + entry[name + "_sign_match"] = bool(np.sign(actual) == np.sign(predicted)) + rows.append(entry) + assert torch.equal(parameter, initial) + write_json(out / "first-order-calibration.json", rows) + + +def geometry_rows(engine, records): + encoded = [r["encoded"][v] for r in records for v in range(3)] + features, originals = [], [] + for start in range(0, len(encoded), 24): + features.append(engine.features(encoded[start : start + 24]).double().cpu()) + originals.append(engine.original_features.double().cpu()) + phi = torch.cat(features).reshape(len(records), 3, -1) + unit = F.normalize(phi, dim=-1) + original = torch.cat(originals).reshape(len(records), 3, -1) + original_cos = (unit * F.normalize(original, dim=-1)).sum(-1) + gram = unit[:, 0] @ unit[:, 0].T + rank = float(gram.trace().square() / gram.square().sum()) + result = {} + for i, r in enumerate(records): + others = [ + float(gram[i, j]) + for j, other in enumerate(records) + if other["target_id"] != r["target_id"] + ] + result[r["case_id"]] = { + "same_fact_cos": float((unit[i, 1:] @ unit[i, 0]).mean()), + "other_fact_cos": max(others) if others else None, + "effective_rank": rank, + "cosine_to_original_phi": float(original_cos[i].mean()), + "dimension_variance": float(phi[:, 0].var(0, unbiased=False).mean()), + } + return result + + +def evaluate_node(engine, records, keep, texts, step, metadata, out, exposures, full_keep): + rows = engine.evaluate(records) + geometry = geometry_rows(engine, records) + for row in rows: + row.update( + metadata, + step=step, + exposures=exposures.get(row["case_id"], 0), + **geometry[row["case_id"]], + ) + payload = {"rows": rows} + if full_keep: + payload["keep"] = engine.evaluate(keep, views=(0,)) + with torch.no_grad(): + text_losses = [] + for i in range(0, len(texts["test"]), 8): + text_losses.extend(engine.ce(texts["test"][i : i + 8]).tolist()) + payload["text_nll"] = float(np.mean(text_losses)) + payload["text_ppl"] = float(np.exp(payload["text_nll"])) + write_json(out / f"evaluation-{step:04d}.json", payload) + return payload + + +def train_run( + engine, + phase, + records, + pools, + texts, + condition, + seed, + episode_id, + split, + lr, + steps, + run_id, + lambda_geo=0.0, + parent_path=None, + diagnostics=False, +): + cfg = config() + out = RESULTS / run_id + out.mkdir(parents=True, exist_ok=True) + load_parent(engine, parent_path) + parent_hashes = state_hashes(engine.model) + parent_hash = aggregate_hash(parent_hashes) + parameters = engine.configure_trainable(phase) + trainable = [n for n, p in engine.model.named_parameters() if p.requires_grad] + meta = { + "phase": phase, + "split": split, + "condition": condition, + "seed": seed, + "episode_id": episode_id, + "parent_hash": parent_hash, + "parent_path": str(parent_path) if parent_path else None, + "source_hashes": frozen_training_sources(), + "config_sha256": sha256(CONFIG_PATH), + "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"), + "trainable_names": trainable, + "lr": lr, + "lambda_geo": lambda_geo, + "steps": steps, + "case_ids": [r["case_id"] for r in records], + } + if (out / "complete.json").exists(): + receipt = read_json(out / "complete.json") + if receipt["meta"] != meta: + raise RuntimeError(f"Completed run contract changed: {run_id}") + return receipt + engine.make_reference() + set_determinism(seed) + random.seed(seed) + opt = optimizer(parameters, lr) + write_json(out / "contract.json", meta) + ledger = { + "answer_tokens": 0, + "answer_input_tokens": 0, + "replay_tokens": 0, + "replay_input_tokens": 0, + "geometry_input_tokens": 0, + "forward_sequences": 0, + "backward_sequences": 0, + "optimizer_steps": 0, + "wall_seconds": 0.0, + } + nodes = [n for n in cfg["form" if phase == "form" else "adapt"]["nodes"] if n <= steps] + if steps not in nodes: + nodes.append(steps) + keep = pools["V_keep" if split == "dev" else "U_keep"] + evaluate_records = pools["V_form"] if phase == "form" and split == "dev" else records + rng = np.random.default_rng(seed) + order = rng.permutation(len(records)).tolist() if phase == "form" else list(range(len(records))) + exposures = {r["case_id"]: 0 for r in records} + batch_table = [] + for step in range(steps): + batch = [records[order[(step * 8 + i) % len(order)]] for i in range(8)] + groups = ( + grouping(batch, seed * 100000 + step) + if condition == "C2" + else [tuple(range(3 * i, 3 * i + 3)) for i in range(8)] + ) + batch_table.append({"case_ids": [r["case_id"] for r in batch], "groups": groups}) + write_json(out / "batch-manifest.json", batch_table) + checkpoints = sorted(out.glob("checkpoint-*.pt")) + start = 0 + if checkpoints: + start, ledger = restore_checkpoint(checkpoints[-1], engine, opt, meta) + for item in batch_table[:start]: + for case_id in item["case_ids"]: + exposures[case_id] += 1 + elif diagnostics: + diagnostic = diagnose_episode(engine, records, replay_batch(pools, texts, 0), lr, out) + if split == "eval": + from .hebbian_statistics import predict + + predictors = read_json(ARTIFACTS / "B-lock.json")["predictors"] + write_json( + out / "prospective-predictions.json", + { + "saved_at": now(), + "parent_hash": parent_hash, + "predictions": [ + { + "case_id": r["case_id"], + "values": { + name: float(predict(model, np.array(r["features"])[None])[0]) + for name, model in predictors.items() + }, + } + for r in diagnostic + ], + }, + ) + first_order_calibration(engine, min(records, key=lambda r: r["case_id"]), out) + metadata = { + k: meta[k] for k in ["phase", "split", "condition", "seed", "episode_id", "parent_hash"] + } + if start == 0: + save_checkpoint(out / "checkpoint-0000.pt", engine, opt, 0, meta, ledger) + for step in range(start, steps + 1): + if step in nodes: + evaluate_node( + engine, + evaluate_records, + keep, + texts, + step, + metadata, + out, + exposures, + full_keep=(phase == "form" or step in [0, 16, 64, 128]), + ) + if phase == "adapt" and condition.startswith("C") and step in [0, 16, 128]: + gradients = [] + for r in sorted(records, key=lambda r: r["case_id"])[:4]: + grads = [engine.gradient(e)[0] for e in r["encoded"]] + gradients.append( + { + "case_id": r["case_id"], + "p0_p1_gradient_cos": gradient_cos(grads[0], grads[1]), + "p0_p2_gradient_cos": gradient_cos(grads[0], grads[2]), + } + ) + write_json(out / f"gradients-{step:04d}.json", gradients) + if step in [0, 16, 64, 128, 256]: + save_checkpoint(out / f"checkpoint-{step:04d}.pt", engine, opt, step, meta, ledger) + if step == steps: + break + batch = [records[order[(step * 8 + i) % len(order)]] for i in range(8)] + encoded = [r["encoded"][v] for r in batch for v in (range(3) if phase == "form" else [0])] + replay = replay_batch(pools, texts, step) + torch.cuda.synchronize(engine.device) + begin = time.monotonic() + opt.zero_grad(set_to_none=True) + ce = engine.ce(encoded).mean() + ce.backward() + kl = engine.kl(replay).mean() + kl.backward() + geo_value, pair_counts = 0.0, None + if phase == "form": + features = engine.features(encoded, detach=False) + targets = [r["target_id"] for r in batch for _ in range(3)] + geo, pair_counts = contrastive_loss(features, targets, batch_table[step]["groups"]) + if lambda_geo: + (lambda_geo * geo).backward() + geo_value = float(geo.detach()) + norm = torch.nn.utils.clip_grad_norm_(parameters, cfg["optimizer"]["clip"]) + opt.step() + torch.cuda.synchronize(engine.device) + ledger["wall_seconds"] += time.monotonic() - begin + ledger["answer_tokens"] += sum(sum(e["loss_mask"]) for e in encoded) + ledger["answer_input_tokens"] += sum(len(e["input_ids"]) for e in encoded) + ledger["replay_tokens"] += sum(sum(e["loss_mask"]) for e in replay) + ledger["replay_input_tokens"] += sum(len(e["input_ids"]) for e in replay) + if phase == "form": + ledger["geometry_input_tokens"] += sum(e["answer_start"] for e in encoded) + ledger["forward_sequences"] += ( + len(encoded) + 2 * len(replay) + (len(encoded) if phase == "form" else 0) + ) + ledger["backward_sequences"] += ( + len(encoded) + len(replay) + (len(encoded) if lambda_geo else 0) + ) + ledger["optimizer_steps"] += 1 + for r in batch: + exposures[r["case_id"]] += 1 + with (out / "training.jsonl").open("a") as f: + f.write( + json.dumps( + { + "step": step + 1, + "ce": float(ce.detach()), + "kl": float(kl.detach()), + "geo": geo_value, + "gradient_norm": float(norm), + "pairs": pair_counts, + } + ) + + "\n" + ) + write_json( + out / "status.json", {"step": step + 1, "steps": steps, "time": now(), "ledger": ledger} + ) + if (step + 1) % 16 == 0: + print( + run_id, + step + 1, + "ce", + float(ce.detach()), + "wall", + ledger["wall_seconds"], + flush=True, + ) + final_hashes = state_hashes(engine.model) + unchanged = all( + final_hashes[n] == digest for n, digest in parent_hashes.items() if n not in trainable + ) + assert unchanged, "A parameter outside the intervention scope changed" + receipt = { + "meta": meta, + "completed_at": now(), + "ledger": ledger, + "unchanged_outside_scope": unchanged, + "final_hashes": final_hashes, + "final_model_hash": aggregate_hash(final_hashes), + "exposures": exposures, + "trainable_parameters": sum(p.numel() for p in parameters), + "estimated_dense_full_backprop_flops_upper_bound": ( + sum(p.numel() for p in engine.model.parameters()) + * ( + 6 * ledger["answer_input_tokens"] + + 8 * ledger["replay_input_tokens"] + + (6 if lambda_geo else 2) * ledger["geometry_input_tokens"] + ) + ), + } + write_json(out / "complete.json", receipt) + return receipt + + +def run_summary(path): + evaluations = [read_json(p) for p in sorted(path.glob("evaluation-*.json"))] + nodes = [e["rows"][0]["step"] for e in evaluations] + rewrite = [ + np.mean([r["answer_em"] for r in e["rows"] if r["view_id"] in [1, 2]]) for e in evaluations + ] + keep0 = np.mean([r["answer_em"] for r in evaluations[0]["keep"]]) + keep1 = np.mean([r["answer_em"] for r in evaluations[-1]["keep"]]) + return { + "q_auc": float(q_auc(rewrite, nodes)), + "keep_damage": float(keep0 - keep1), + "answer_nll": float(np.mean([r["answer_nll"] for r in evaluations[-1]["rows"]])), + } + + +def select_config(candidates, metric, maximize): + safe = [ + r for r in candidates if r["keep_damage"] <= config()["statistics"]["keep_damage_reference"] + ] + if safe: + return sorted(safe, key=lambda r: (-1 if maximize else 1) * r[metric])[0] + return sorted( + candidates, key=lambda r: (r["keep_damage"], (-1 if maximize else 1) * r[metric]) + )[0] + + +def preflight(engine, pools, texts): + records = pools["B_dev"][:8] + audit = engine.verify_hooks_and_gradients(records[0]["encoded"][0]) + before = state_hashes(engine.model) + parameters = engine.configure_trainable("adapt") + engine.make_reference() + opt = optimizer(parameters, 1e-5) + torch.cuda.reset_peak_memory_stats(engine.device) + torch.cuda.synchronize(engine.device) + start = time.monotonic() + for step in range(3): + opt.zero_grad(set_to_none=True) + engine.ce([r["encoded"][0] for r in records]).mean().backward() + engine.kl(replay_batch(pools, texts, step)).mean().backward() + torch.nn.utils.clip_grad_norm_(parameters, 1.0) + opt.step() + torch.cuda.synchronize(engine.device) + seconds = (time.monotonic() - start) / 3 + engine.restore_base() + assert before == state_hashes(engine.model) + estimate = { + "time": now(), + "device": str(engine.device), + "adapt_step_seconds": seconds, + "peak_memory_bytes": torch.cuda.max_memory_allocated(engine.device), + "formal_adapt_steps": 11264, + "formal_adapt_gpu_hours": seconds * 11264 / 3600, + "formation_estimate_factor": 3, + "formal_formation_gpu_hours_estimate": seconds * 3 * 2304 / 3600, + "excludes": [ + "generation and NLL evaluation", + "gradient diagnostics", + "development", + "disk IO", + ], + "microbatch_answer": 8, + "microbatch_replay": 8, + "reference_parent_restored": True, + } + write_json(ARTIFACTS / "estimate.json", estimate) + write_json(ARTIFACTS / "qwen-interface-audit.json", audit) + print(estimate, flush=True) + + +def dispatch(args): + if not (ARTIFACTS / "data-lock.json").exists(): + raise RuntimeError("data-lock is required before development or evaluation") + data_lock = read_json(ARTIFACTS / "data-lock.json") + for name, digest in data_lock["files"].items(): + if sha256(DATA / name) != digest: + raise RuntimeError(f"Frozen data changed: {name}") + if not read_json(ARTIFACTS / "A/audit.json")["pass"]: + raise RuntimeError("Stage A must pass before model training") + pools = read_json(DATA / "pools.json") + texts = read_json(DATA / "text.json") + episodes = read_json(DATA / "episodes.json") + by_id = {r["case_id"]: r for rows in pools.values() for r in rows} + engine = QwenExperiment(args.device) + if args.command == "preflight": + return preflight(engine, pools, texts) + if args.command == "diagnose": + if args.split == "dev": + learning_rates = config()["adapt"]["learning_rates"] + else: + learning_rates = [read_json(ARTIFACTS / "B-lock.json")["learning_rate"]] + tasks = list(itertools.product(learning_rates, enumerate(episodes["B_" + args.split]))) + for lr, (episode, ids) in tasks[args.shard :: args.shards]: + run_id = f"B/{args.split}-lr{lr:g}-e{episode}" + train_run( + engine, + "adapt", + [by_id[i] for i in ids], + pools, + texts, + "B", + 0, + episode, + args.split, + lr, + 128, + run_id, + diagnostics=True, + ) + return + b_lr = read_json(ARTIFACTS / "B-lock.json")["learning_rate"] + if args.command == "form" and args.split == "dev": + candidates = [] + for lr in config()["form"]["learning_rates"]: + run_id = f"C/dev-C0-lr{lr:g}" + train_run( + engine, "form", pools["F_form"], pools, texts, "C0", 10, -1, "dev", lr, 256, run_id + ) + candidates.append( + {"learning_rate": lr, "run_id": run_id, **run_summary(RESULTS / run_id)} + ) + chosen = select_config(candidates, "answer_nll", False) + lr = chosen["learning_rate"] + formation_candidates = [{"condition": "C0", "lambda_geo": 0.0, **chosen}] + for lam in config()["form"]["lambdas"]: + run_id = f"C/dev-C1-lambda{lam:g}" + train_run( + engine, + "form", + pools["F_form"], + pools, + texts, + "C1", + 10, + -1, + "dev", + lr, + 256, + run_id, + lambda_geo=lam, + ) + formation_candidates.append( + { + "condition": "C1", + "lambda_geo": lam, + "run_id": run_id, + **run_summary(RESULTS / run_id), + } + ) + for item in formation_candidates: + adapt_results = [] + for episode, ids in enumerate(episodes["C_dev"]): + run_id = f"C/adapt-dev-{item['condition']}-lambda{item['lambda_geo']:g}-e{episode}" + train_run( + engine, + "adapt", + [by_id[i] for i in ids], + pools, + texts, + item["condition"], + 10, + episode, + "dev", + b_lr, + 64, + run_id, + parent_path=RESULTS / item["run_id"] / "checkpoint-0256.pt", + ) + adapt_results.append(run_summary(RESULTS / run_id)) + item["future_q_auc"] = float(np.mean([r["q_auc"] for r in adapt_results])) + item["adapt_results"] = adapt_results + best = select_config( + [r for r in formation_candidates if r["condition"] == "C1"], "future_q_auc", True + ) + lam = best["lambda_geo"] + train_run( + engine, + "form", + pools["F_form"], + pools, + texts, + "C2", + 10, + -1, + "dev", + lr, + 256, + "C/dev-C2-engineering", + lambda_geo=lam, + ) + write_json( + ARTIFACTS / "C-lock.json", + { + "time": now(), + "learning_rate": lr, + "lambda_geo": lam, + "adapt_learning_rate": b_lr, + "lr_candidates": candidates, + "formation_candidates": formation_candidates, + "source_hashes": frozen_training_sources(), + "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"), + "seeds": [0, 1, 2], + "conditions": ["C0", "C1", "C2"], + "episodes": episodes["C_eval"], + "status": "locked", + }, + ) + return + c_lock = read_json(ARTIFACTS / "C-lock.json") + if args.command == "form": + tasks = list(itertools.product(["C0", "C1", "C2"], [0, 1, 2])) + for condition, seed in tasks[args.shard :: args.shards]: + train_run( + engine, + "form", + pools["F_form"], + pools, + texts, + condition, + seed, + -1, + "eval", + c_lock["learning_rate"], + 256, + f"C/form-{condition}-s{seed}", + lambda_geo=0.0 if condition == "C0" else c_lock["lambda_geo"], + ) + elif args.command == "adapt": + tasks = list( + itertools.product(["C0", "C1", "C2"], [0, 1, 2], enumerate(episodes["C_eval"])) + ) + for condition, seed, (episode, ids) in tasks[args.shard :: args.shards]: + train_run( + engine, + "adapt", + [by_id[i] for i in ids], + pools, + texts, + condition, + seed, + episode, + "eval", + b_lr, + 128, + f"C/adapt-{condition}-s{seed}-e{episode}", + parent_path=RESULTS / f"C/form-{condition}-s{seed}/checkpoint-0256.pt", + ) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_editing.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_editing.py new file mode 100644 index 0000000000000000000000000000000000000000..7065e910e82f4aa54e312af63f4f99925c4e1269 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_editing.py @@ -0,0 +1,759 @@ +"""Local factual updates and downstream composition in existing aligned GPTs. + +Cases are selected from the graph alone, before loading any model predictions. +Every edit has a same-budget old-fact sham, fresh optimizer, and frozen parent +replay reference. No composition labels or intermediate-state targets enter +optimization. Finite replay KL is a regularizer, not exact preservation. +""" + +from __future__ import annotations + +import copy +import hashlib +import json +import os +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import utc, write_json +from .latent_scaling import build_world, model_digest +from .representation_alignment import new_model +from .storage_composition import data_digest, file_hash, generate_rows, pack_sentences + +ROLES = ("first", "second") +STRATA = ("familiar", "strict") +DEFAULT_NODES = (0, 32, 128, 512) + + +def _rows(values, width): + return np.asarray(values, dtype=np.int64).reshape(-1, width) + + +def _unique(values, width): + return _rows(sorted(set(map(tuple, _rows(values, width)))), width) + + +def _hash_json(value): + return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest() + + +def _batch_hash(batch): + digest = hashlib.sha256() + for tensor in batch: + array = tensor.detach().cpu().numpy() + digest.update(str(array.dtype).encode()) + digest.update(str(array.shape).encode()) + digest.update(array.tobytes()) + return digest.hexdigest() + + +def learned_atoms(world): + """Only atomics actually supervised in the representation parent.""" + return _unique(np.concatenate([world["common_atomic"], world["anchor_atomic"]]), 3) + + +def composition_pools(world): + """All legal untrained queries, plus the original holdout and training sets.""" + trained = set(map(tuple, world["train_composite"])) + full = _unique(np.concatenate([world["available_composite"], world["familiar_test"]]), 5) + familiar = _rows([r for r in full if tuple(r) not in trained], 5) + return { + "familiar": familiar, + "strict": world["strict_test"].copy(), + "registered_familiar": world["familiar_test"].copy(), + "train": world["train_composite"].copy(), + } + + +def affected(rows, fact, role): + """Whether a query uses this factual address, independently of its answer.""" + columns = (0, 1) if role == "first" else (2, 3) + return (rows[:, columns[0]] == fact[0]) & (rows[:, columns[1]] == fact[1]) + + +def rewrite(rows, old_fact, new_fact, role, lookup): + result = rows.copy() + mask = affected(rows, old_fact, role) + if role == "first": + result[mask, 2] = new_fact[2] + for index in np.flatnonzero(mask): + result[index, 4] = lookup[int(new_fact[2]), int(rows[index, 3])] + else: + result[mask, 4] = new_fact[2] + return result + + +def graph_cases(parent_spec, *, seed=780011, per_cell=2, replay_n=32): + """Return JSON-compatible selected cases and graph-only eligibility counts. + + Each distinct atomic address receives at most one counterfactual per role. + First-hop replacements stay in the original familiar/strict bridge group and + change at least one affected untrained composition answer. Strict cases never + borrow a bridge with composition experience from the familiar group. + """ + if per_cell < 1 or replay_n < 1: + raise ValueError("Positive case and replay counts are required") + world = build_world(parent_spec) + atoms = learned_atoms(world) + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + pools = composition_pools(world) + rng = np.random.default_rng(seed + int(parent_spec["world"])) + candidates, qualification = [], {} + for role in ROLES: + for stratum in STRATA: + rows = pools[stratum] + addresses = _unique(rows[:, [0, 1, 2] if role == "first" else [2, 3, 4]], 3) + bridges = np.unique(rows[:, 2]) + # Include all trained bridges in that group, even if the holdout + # happens not to visit them (strict rows enumerate all chains). + group = world["background_atomic"] if stratum == "familiar" else world["common_atomic"] + group_bridges = np.unique(group[group[:, 1] >= 17, 0]) + if stratum == "strict": + familiar_bridges = world["background_atomic"] + familiar_bridges = familiar_bridges[familiar_bridges[:, 1] >= 17, 0] + group_bridges = np.setdiff1d(group_bridges, familiar_bridges) + bridges = np.union1d(bridges, group_bridges) + tails = np.unique(atoms[atoms[:, 1] >= 17, 2]) + eligible, replacement_count = [], 0 + for old in addresses: + impacted = rows[affected(rows, old, role)] + choices = [] + for value in bridges if role == "first" else tails: + if value == old[2]: + continue + new = [int(old[0]), int(old[1]), int(value)] + updated = rewrite(impacted, old, new, role, lookup) + if np.any(updated[:, -1] != impacted[:, -1]): + choices.append(new) + replacement_count += len(choices) + if choices: + eligible.append((old.tolist(), choices)) + key = f"{role}_{stratum}" + qualification[key] = { + "candidate_addresses": len(addresses), + "eligible_addresses": len(eligible), + "eligible_replacements": replacement_count, + "untrained_queries": len(rows), + } + if len(eligible) < per_cell: + raise ValueError(f"Insufficient graph-qualified {key} cases: {qualification[key]}") + order = rng.permutation(len(eligible))[:per_cell] + for serial, index in enumerate(order): + old, choices = eligible[index] + new = choices[int(rng.integers(len(choices)))] + candidates.append( + { + "case_id": f"{key}-{serial:02d}", + "role": role, + "stratum": stratum, + "old_fact": old, + "new_fact": new, + } + ) + for case in candidates: + tasks, originals = case_tasks(world, case, replay_indices=None) + necessary = set(map(tuple, tasks["necessary_atomic"])) + allowed = [ + i + for i, row in enumerate(atoms) + if tuple(row) != tuple(case["old_fact"]) and tuple(row) not in necessary + ] + if len(allowed) < replay_n: + raise ValueError("Insufficient independent replay atomics") + case["replay_indices"] = sorted(map(int, rng.choice(allowed, replay_n, replace=False))) + case["affected_untrained_n"] = {name: len(rows) for name, rows in originals.items()} + return candidates, qualification + + +def case_tasks(world, case, replay_indices=None): + """Construct E/R/U/D with address-based exclusions and recomputed truth.""" + atoms = learned_atoms(world) + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + old, new, role = case["old_fact"], case["new_fact"], case["role"] + if lookup[tuple(old[:2])] != old[2] or old[:2] != new[:2] or old[2] == new[2]: + raise ValueError("An edit must replace one existing factual value") + tasks = {"E_old": _rows([old], 3), "E_new": _rows([new], 3)} + originals, necessary = {}, [] + for stratum, rows in composition_pools(world).items(): + mask = affected(rows, old, role) + tasks[f"U_{stratum}"] = rows[~mask].copy() + old_rows = rows[mask].copy() + new_rows = rewrite(old_rows, old, new, role, lookup) + changed = old_rows[:, -1] != new_rows[:, -1] + if stratum == "train": + # Training-query transfer is reported separately from held-out D. + name = f"T_{role}_train" + originals[name] = old_rows + tasks[name] = new_rows + else: + name = f"D_{role}_{stratum}" + originals[name] = old_rows[changed] + tasks[name] = new_rows[changed] + same = f"S_same_answer_{role}_{stratum}" + originals[same] = old_rows[~changed] + tasks[same] = new_rows[~changed] + if stratum in STRATA: + for h, r1, b, r2, t in tasks[name]: + prerequisite = (b, r2, t) if role == "first" else (h, r1, b) + necessary.append(prerequisite) + tasks["necessary_atomic"] = _unique(necessary, 3) + replay = case.get("replay_indices", []) if replay_indices is None else replay_indices + if len(set(replay)) != len(replay): + raise ValueError("Replay indices must be unique") + target = np.flatnonzero(np.all(atoms == np.asarray(old), axis=1)) + if len(target) != 1 or int(target[0]) in replay: + raise ValueError("Replay cannot contain the edited address") + tasks["R_atomic"] = atoms[replay].copy() + tasks["U_atomic"] = np.delete(atoms, [int(target[0]), *replay], axis=0) + return tasks, originals + + +def answer_batch(rows, device): + """Only answer, punctuation and EOS labels; no prefix or bridge labels.""" + tokens, labels = pack_sentences(_rows(rows, 3)) + positions = np.tile([4, 5, 6], (len(rows), 1)) + targets = labels[np.arange(len(rows))[:, None], positions] + expected = np.column_stack([np.asarray(rows)[:, 2], np.full(len(rows), 5), np.ones(len(rows))]) + np.testing.assert_array_equal(targets, expected) + return tuple(torch.as_tensor(x, device=device) for x in (tokens, positions, targets)) + + +def edit_objective(model, target_batch, replay_batch, parent_log, replay_weight=1.0): + target = model(target_batch[0], positions=target_batch[1]) + ce = F.cross_entropy(target.flatten(0, 1), target_batch[2].flatten()) + replay = model(replay_batch[0], positions=replay_batch[1]).log_softmax(-1) + if parent_log.requires_grad: + raise ValueError("Replay reference must be detached") + kl = F.kl_div(replay, parent_log, log_target=True, reduction="none").sum(-1).mean() + return ce + replay_weight * kl, ce, kl + + +def _generate(model, rows, device, batch_size): + if len(rows): + return generate_rows(model, rows, device, batch_size=batch_size) + return ( + {"n": 0, "accuracy": None, "answer_accuracy": None, "answer_nll": None}, + { + "generated": np.empty((0, 3), dtype=np.int64), + "correct": np.empty(0, dtype=bool), + "answer_nll": np.empty(0), + }, + ) + + +def evaluate_case(model, tasks, originals, parent_correct, role, device, batch_size=512): + """Full-pool scores and separately labelled prerequisite/parent subsets.""" + metrics, raw = {}, {} + for name, rows in tasks.items(): + values, predictions = _generate(model, rows, device, batch_size) + raw.update({f"{name}__{k}": v for k, v in predictions.items()}) + if name in originals: + old = originals[name] + generated = predictions["generated"] + changed = old[:, -1] != rows[:, -1] + old_correct = (generated[:, 0] == old[:, -1]) & np.all( + generated[:, 1:] == [5, 1], axis=1 + ) + prerequisite = rows[:, [2, 3, 4] if role == "first" else [0, 1, 2]] + _m, needed = _generate(model, prerequisite, device, batch_size) + edited_ok = metrics["E_new"]["accuracy"] == 1.0 + covered = needed["correct"] & edited_ok + baseline = parent_correct[name] + valid_parent = baseline & changed + correct = predictions["correct"] + values.update( + { + "changed_answer_n": int(changed.sum()), + "old_answer_accuracy": float(old_correct.mean()) if len(rows) else None, + "parent_correct_n": int(baseline.sum()), + "parent_correct_coverage": float(baseline.mean()) if len(rows) else None, + "new_following_parent_correct": float(correct[valid_parent].mean()) + if valid_parent.any() + else None, + "old_retained_parent_correct": float(old_correct[valid_parent].mean()) + if valid_parent.any() + else None, + "direct_edit_success": edited_ok, + "necessary_atomic_correct_n": int(needed["correct"].sum()), + "operation_correct_n": int(covered.sum()), + "operation_correct_coverage": float(covered.mean()) if len(rows) else None, + "new_following_operation_correct": float(correct[covered].mean()) + if covered.any() + else None, + } + ) + raw[f"{name}__parent_correct"] = baseline + raw[f"{name}__operation_correct"] = covered + raw[f"{name}__old_correct"] = old_correct + raw[f"{name}__necessary_generated"] = needed["generated"] + raw[f"{name}__new_rows"] = rows + raw[f"{name}__old_rows"] = old + metrics[name] = values + return metrics, raw + + +def editable_parameters(model, scope="mlp", block_index=0): + prefix = f"blocks.{block_index}.mlp." + selected = [ + name + for name, _ in model.named_parameters() + if name.startswith(prefix) and (scope == "mlp" or name == prefix + "down.weight") + ] + if scope not in {"mlp", "down"} or not selected: + raise ValueError("Unknown or empty local parameter scope") + for name, parameter in model.named_parameters(): + parameter.requires_grad_(name in selected) + parameter.grad = None + return selected + + +def _configure(device): + device = torch.device(device) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + if device.type == "cuda": + torch.cuda.set_device(device) + return device + + +def _load_parent(parent_dir, device): + path = Path(parent_dir) / "model.pt" + payload = torch.load(path, map_location="cpu", weights_only=False) + model = new_model(payload["spec"], device).eval() + model.load_state_dict(payload["model"]) + world = build_world(payload["spec"]) + if (Path(parent_dir) / "world.npz").exists(): + with np.load(Path(parent_dir) / "world.npz") as saved: + for name, rows in world.items(): + np.testing.assert_array_equal(rows, saved[name]) + return model, world, payload["spec"] + + +def _parent_masks(parent, originals, device, batch_size): + return { + name: _generate(parent, rows, device, batch_size)[1]["correct"] + for name, rows in originals.items() + } + + +def run(spec, out, device="cuda:0"): + """Execute one parent, a graph-selected case set and optional development lr grid. + + The caller owns source freezing, resource allocation and W&B startup. Each + branch has run/learning/complete artifacts. Root ``step`` is a strictly + increasing evaluation index, including every branch's unchanged node zero; + ``optimizer_updates`` separately records cumulative optimization work. + Target labels and replay KL positions have separate exposure counters. + ``status.json`` retains completed-branch progress, explicitly labelled in + the manifest; it does not define the tracking series' step axis. + """ + device = _configure(device) + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "run.json").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite an existing attempt: {out}") + nodes = spec.get("nodes", list(DEFAULT_NODES)) + if not nodes or nodes[0] != 0 or nodes != sorted(set(nodes)) or nodes[-1] <= 0: + raise ValueError("Nodes must increase from zero to a positive fixed endpoint") + rates = spec.get("learning_rates", [spec.get("lr", 1e-4)]) + if not rates or any(lr <= 0 for lr in rates) or len(set(rates)) != len(rates): + raise ValueError("Learning rates must be positive and unique") + if spec.get("phase") not in {"development", "engineering"} and len(rates) > 1: + raise ValueError("Learning-rate grids are development-only") + arms = spec.get("arms", ["edit", "sham"]) + if sorted(arms) != ["edit", "sham"]: + raise ValueError("Every case requires paired edit and sham branches") + parent, world, parent_spec = _load_parent(spec["parent_dir"], device) + parent_hash = model_digest(parent) + cases, qualification = graph_cases( + parent_spec, + seed=spec.get("candidate_seed", 780011), + per_cell=spec.get("per_cell", 2), + replay_n=spec.get("replay_n", 32), + ) + if "case_ids" in spec: + requested = set(spec["case_ids"]) + if not requested or not requested <= {c["case_id"] for c in cases}: + raise ValueError("Unknown/empty fixed graph-selected case subset") + cases = [c for c in cases if c["case_id"] in requested] + manifest = { + "spec": spec, + "parent_spec": parent_spec, + "cases": cases, + "qualification": qualification, + "case_sha256": _hash_json(cases), + "parent_file_sha256": file_hash(Path(spec["parent_dir"]) / "model.pt"), + "parent_model_sha256": parent_hash, + "world_sha256": data_digest(world), + "created_utc": utc(), + "dtype": "float32", + "allow_tf32": True, + "pid": os.getpid(), + "gpu": device.index if device.type == "cuda" else None, + "branches": len(cases) * len(rates) * len(arms), + "planned_updates": len(cases) * len(rates) * len(arms) * nodes[-1], + "planned_evaluations": len(cases) * len(rates) * len(arms) * len(nodes), + "learning_step_unit": "evaluation_index", + "status_step_unit": "completed_branches", + "scope_warning": "The selected MLP is shared across all repeated executions", + } + write_json(out / "run.json", manifest) + write_json(out / "cases.json", cases) + np.savez_compressed(out / "world.npz", **world) + root_learning, branch_summaries, completed_steps = [], [], 0 + started = time.perf_counter() + training_seconds = 0.0 + batch_size = spec.get("eval_batch_size", 512) + for case in cases: + tasks, originals = case_tasks(world, case) + parent_correct = _parent_masks(parent, originals, device, batch_size) + parent_metrics, parent_predictions = evaluate_case( + parent, + tasks, + originals, + parent_correct, + case["role"], + device, + batch_size, + ) + case_out = out / case["case_id"] + case_out.mkdir() + np.savez_compressed(case_out / "parent-predictions.npz", **parent_predictions) + write_json(case_out / "parent-metrics.json", parent_metrics) + np.savez_compressed(case_out / "tasks.npz", **tasks) + replay_batch = answer_batch(tasks["R_atomic"], device) + with torch.no_grad(): + parent_log = parent(replay_batch[0], positions=replay_batch[1]).log_softmax(-1).detach() + for lr in rates: + for arm in arms: + branch_name = f"lr{lr:.8g}-{arm}" + branch_out = case_out / branch_name + branch_out.mkdir() + model = copy.deepcopy(parent).eval() + selected = editable_parameters( + model, + spec.get("parameter_scope", "mlp"), + spec.get("block_index", 0), + ) + parameters = dict(model.named_parameters()) + optimizer = torch.optim.Adam([parameters[n] for n in selected], lr=lr) + target = tasks["E_new" if arm == "edit" else "E_old"] + target_batch = answer_batch(target, device) + write_json( + branch_out / "run.json", + { + "case_id": case["case_id"], + "arm": arm, + "lr": lr, + "parent_model_sha256": parent_hash, + "editable_parameters": selected, + "optimizer": "Adam, fresh state, zero weight decay", + "sampling": "same fixed full replay batch on every update; no dropout", + "old_fact_sha256": _hash_json(case["old_fact"]), + "new_fact_sha256": _hash_json(case["new_fact"]), + "target_batch_sha256": _batch_hash(target_batch), + "replay_batch_sha256": _batch_hash(replay_batch), + "parent_reference_sha256": _batch_hash((parent_log,)), + "nodes": nodes, + }, + ) + np.savez_compressed( + branch_out / "replay-reference.npz", log_probabilities=parent_log.cpu().numpy() + ) + step, losses, history = 0, [], [] + for node in nodes: + if device.type == "cuda": + torch.cuda.synchronize(device) + began = time.perf_counter() + while step < node: + optimizer.zero_grad(set_to_none=True) + loss, ce, kl = edit_objective( + model, + target_batch, + replay_batch, + parent_log, + spec.get("replay_weight", 1.0), + ) + if not torch.isfinite(loss): + raise FloatingPointError(f"Nonfinite edit loss at {step}") + loss.backward() + gradient_norm = torch.nn.utils.clip_grad_norm_( + [parameters[n] for n in selected], + spec.get("clip_norm", 1.0), + ) + optimizer.step() + step += 1 + losses.append( + { + "step": step, + "loss": float(loss.detach()), + "target_ce": float(ce.detach()), + "replay_kl": float(kl.detach()), + "gradient_norm": float(gradient_norm), + } + ) + if device.type == "cuda": + torch.cuda.synchronize(device) + training_seconds += time.perf_counter() - began + metrics, predictions = evaluate_case( + model, + tasks, + originals, + parent_correct, + case["role"], + device, + batch_size, + ) + current_hash = model_digest(model) + record = { + "step": step, + "metrics": metrics, + "model_sha256": current_hash, + "target_success": metrics["E_new" if arm == "edit" else "E_old"]["accuracy"] + == 1, + "U_atomic_at_least_95": metrics["U_atomic"]["accuracy"] >= 0.95, + "loss": losses[-1] if losses else None, + } + history.append(record) + write_json(branch_out / "learning.json", history) + write_json(branch_out / "losses.json", losses) + np.savez_compressed(branch_out / f"predictions-{step:06d}.npz", **predictions) + torch.save( + { + "edited_tensors": { + n: parameters[n].detach().cpu().clone() for n in selected + }, + "model_sha256": current_hash, + "step": step, + }, + branch_out / f"tensors-{step:06d}.pt", + ) + root_learning.append( + { + "step": len(root_learning), + "branch_step": step, + "completed_branches": len(branch_summaries) + int(step == nodes[-1]), + "optimizer_updates": completed_steps + step, + "case_id": case["case_id"], + "arm": arm, + "lr": lr, + "metrics": metrics, + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "examples": (completed_steps + step) * (1 + len(tasks["R_atomic"])), + "target_supervised_tokens": (completed_steps + step) * 3, + "replay_distillation_positions": (completed_steps + step) + * len(tasks["R_atomic"]) + * 3, + } + ) + write_json(out / "learning.json", root_learning) + write_json( + out / "status.json", + { + "state": "running", + "step": len(branch_summaries), + "optimizer_updates": completed_steps + step, + "budget": manifest["branches"], + "case_id": case["case_id"], + "arm": arm, + "lr": lr, + }, + ) + changed = [ + n + for n, t in model.state_dict().items() + if not torch.equal(t, parent.state_dict()[n]) + ] + if set(changed) - set(selected) or model_digest(parent) != parent_hash: + raise AssertionError("A frozen parameter or the parent changed") + complete = { + "case_id": case["case_id"], + "role": case["role"], + "stratum": case["stratum"], + "lr": lr, + "arm": arm, + "path": str(branch_out.relative_to(out)), + "metrics": metrics, + "steps": step, + "changed_tensors": changed, + "parent_model_sha256": parent_hash, + "final_model_sha256": current_hash, + "delta_l2": float( + torch.sqrt( + sum( + (parameters[n] - dict(parent.named_parameters())[n]).square().sum() + for n in selected + ) + ).detach() + ), + "tensor_file_sha256": file_hash(branch_out / f"tensors-{step:06d}.pt"), + } + write_json(branch_out / "complete.json", complete) + branch_summaries.append(complete) + completed_steps += step + result = { + "status": "complete", + "branches": branch_summaries, + "updates": completed_steps, + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "finished_utc": utc(), + "case_sha256": manifest["case_sha256"], + } + write_json(out / "complete.json", result) + write_json( + out / "status.json", + { + "state": "complete", + "step": len(branch_summaries), + "optimizer_updates": completed_steps, + "budget": manifest["branches"], + }, + ) + return result + + +def audit(out, device="cuda:0"): + """Reload every saved node from parent plus exact tensors and re-score it.""" + device, out = _configure(device), Path(out) + manifest = json.loads((out / "run.json").read_text()) + spec = manifest["spec"] + if file_hash(Path(spec["parent_dir"]) / "model.pt") != manifest["parent_file_sha256"]: + raise AssertionError("Parent checkpoint hash changed") + parent, world, parent_spec = _load_parent(spec["parent_dir"], device) + if model_digest(parent) != manifest["parent_model_sha256"]: + raise AssertionError("Parent model digest changed") + cases, qualification = graph_cases( + parent_spec, + seed=spec.get("candidate_seed", 780011), + per_cell=spec.get("per_cell", 2), + replay_n=spec.get("replay_n", 32), + ) + if "case_ids" in spec: + cases = [c for c in cases if c["case_id"] in spec["case_ids"]] + if cases != manifest["cases"] or _hash_json(cases) != manifest["case_sha256"]: + raise AssertionError("Graph-selected cases changed") + if qualification != manifest["qualification"] or data_digest(world) != manifest["world_sha256"]: + raise AssertionError("World qualification changed") + summary = json.loads((out / "complete.json").read_text()) + rates = spec.get("learning_rates", [spec.get("lr", 1e-4)]) + expected_branches = { + (c["case_id"], lr, arm) for c in cases for lr in rates for arm in ("edit", "sham") + } + actual_branches = [(b["case_id"], b["lr"], b["arm"]) for b in summary["branches"]] + if len(actual_branches) != len(expected_branches) or set(actual_branches) != expected_branches: + raise AssertionError("The fixed paired branch matrix is incomplete") + root_learning = json.loads((out / "learning.json").read_text()) + nodes = spec.get("nodes", list(DEFAULT_NODES)) + expected_evaluations = len(actual_branches) * len(nodes) + if len(root_learning) != expected_evaluations or [row["step"] for row in root_learning] != list( + range(expected_evaluations) + ): + raise AssertionError("Root learning evaluation indices are incomplete or repeated") + for index, row in enumerate(root_learning): + branch_index, node_index = divmod(index, len(nodes)) + updates = branch_index * nodes[-1] + nodes[node_index] + if ( + (row["case_id"], row["lr"], row["arm"]) != actual_branches[branch_index] + or row["branch_step"] != nodes[node_index] + or row["optimizer_updates"] != updates + or row["target_supervised_tokens"] != updates * 3 + or row["replay_distillation_positions"] != updates * spec.get("replay_n", 32) * 3 + or "supervised_tokens" in row + ): + raise AssertionError("Root learning optimizer or exposure accounting changed") + batch_size = spec.get("eval_batch_size", 512) + checked_nodes, checked_predictions, max_error = 0, 0, 0.0 + for case in cases: + tasks, originals = case_tasks(world, case) + parent_correct = _parent_masks(parent, originals, device, batch_size) + for branch in summary["branches"]: + if branch["case_id"] != case["case_id"]: + continue + directory = out / branch["path"] + branch_spec = json.loads((directory / "run.json").read_text()) + target = tasks["E_new" if branch["arm"] == "edit" else "E_old"] + target_batch = answer_batch(target, device) + replay_batch = answer_batch(tasks["R_atomic"], device) + with torch.no_grad(): + reference = parent(replay_batch[0], positions=replay_batch[1]).log_softmax(-1) + expected_hashes = { + "old_fact_sha256": _hash_json(case["old_fact"]), + "new_fact_sha256": _hash_json(case["new_fact"]), + "target_batch_sha256": _batch_hash(target_batch), + "replay_batch_sha256": _batch_hash(replay_batch), + "parent_reference_sha256": _batch_hash((reference,)), + } + if any(branch_spec[key] != value for key, value in expected_hashes.items()): + raise AssertionError("Target or paired replay provenance changed") + history = json.loads((directory / "learning.json").read_text()) + if [record["step"] for record in history] != spec.get("nodes", list(DEFAULT_NODES)): + raise AssertionError("Saved edit node matrix is incomplete") + if ( + file_hash(directory / f"tensors-{history[-1]['step']:06d}.pt") + != branch["tensor_file_sha256"] + ): + raise AssertionError("Final exact tensor file hash changed") + for record in history: + state = torch.load( + directory / f"tensors-{record['step']:06d}.pt", + map_location="cpu", + weights_only=True, + ) + model = copy.deepcopy(parent).eval() + selected = editable_parameters( + model, spec.get("parameter_scope", "mlp"), spec.get("block_index", 0) + ) + if set(state["edited_tensors"]) != set(selected): + raise AssertionError("Unexpected edited tensor scope") + merged = model.state_dict() + merged.update(state["edited_tensors"]) + model.load_state_dict(merged) + if model_digest(model) != record["model_sha256"]: + raise AssertionError("Exact saved tensors did not reconstruct the model") + metrics, predictions = evaluate_case( + model, + tasks, + originals, + parent_correct, + case["role"], + device, + batch_size, + ) + with np.load(directory / f"predictions-{record['step']:06d}.npz") as saved: + if set(saved.files) != set(predictions): + raise AssertionError("Prediction keys changed") + for name, actual in predictions.items(): + if name.endswith("answer_nll"): + np.testing.assert_allclose(actual, saved[name], rtol=1e-5, atol=1e-5) + if len(actual): + max_error = max( + max_error, float(np.max(np.abs(actual - saved[name]))) + ) + else: + np.testing.assert_array_equal(actual, saved[name]) + checked_predictions += actual.size + for name, values in metrics.items(): + for key, value in values.items(): + expected = record["metrics"][name][key] + if key == "answer_nll" and value is not None: + np.testing.assert_allclose(value, expected, rtol=1e-5, atol=1e-5) + elif value != expected: + raise AssertionError(f"Re-scoring mismatch: {name}/{key}") + checked_nodes += 1 + result = { + "passed": True, + "nodes": checked_nodes, + "array_elements": checked_predictions, + "max_nll_error": max_error, + "case_sha256": manifest["case_sha256"], + "finished_utc": utc(), + } + write_json(out / "audit.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_tracking.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_tracking.py new file mode 100644 index 0000000000000000000000000000000000000000..16c66de277e2f35fd69f931dc2b4b21b70ec3df4 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_tracking.py @@ -0,0 +1,199 @@ +"""Use the existing W&B sidecar, finishing only after the independent audit.""" + +import argparse +import fcntl +import importlib +import json +import os +import time +from pathlib import Path + +from . import experiment_tracking as tracking + + +class ContainerSDK: + def __init__(self, sdk, runtime): + self.sdk, self.runtime = sdk, runtime + + def __getattr__(self, name): + return getattr(self.sdk, name) + + def Settings(self, **options): + options.pop("x_stats_pid", None) + if self.runtime: + options["x_stats_pid"] = self.runtime["host_pid"] + options["x_stats_gpu_device_ids"] = (self.runtime["physical_gpu"],) + return self.sdk.Settings(**options) + + +class AuditedRunTracker(tracking.ArtifactRunTracker): + def __init__(self, sdk, batch, path, settings): + runtime_path = path / "container-runtime.json" + runtime = tracking.read_json(runtime_path) + super().__init__(ContainerSDK(sdk, runtime), batch, path, settings) + self.run.config.update( + { + key: self.metadata[key] + for key in ( + "parent_spec", + "cases", + "learning_step_unit", + "status_step_unit", + ) + if key in self.metadata + } + ) + if runtime: + self.run.config.update({"container_runtime": runtime}) + + def poll(self): + history = tracking.read_json(self.path / "learning.json") + previous = None + for record in history: + step = int(record["step"]) + if step > self.cursor: + metrics = tracking.learning_metrics(record, previous) + for key in ("case", "case_id", "condition", "variant", "arm"): + if key in record: + metrics["condition/" + key] = record[key] + if "optimizer_updates" in record: + metrics["evaluation/index"] = step + metrics["condition/step_unit"] = "evaluation_index" + metrics.pop("perf/updates_per_second", None) + metrics.pop("perf/training_ms_per_update", None) + if previous is not None: + seconds = record.get("wall_seconds", 0) - previous.get("wall_seconds", 0) + updates = record["optimizer_updates"] - previous.get("optimizer_updates", 0) + if seconds > 0: + metrics["perf/updates_per_second"] = updates / seconds + self.run.log(metrics, step=step) + self.cursor = step + self.state["last_logged_step"] = step + tracking.write_json(self.state_path, self.state) + previous = record + status_path = self.path / "status.json" + if status_path.exists(): + self.run.summary["training_state"] = tracking.read_json(status_path).get("state") + failed = (self.path / "failure.json").exists() + audit_path = self.path / "audit.json" + audit = tracking.read_json(audit_path) if audit_path.exists() else {} + audited = audit.get("passed") is True + complete = (self.path / "complete.json").exists() and audited + self.run.summary["has_failure_record"] = failed + self.run.summary["independently_reloaded"] = audited + if complete or failed: + self.run.summary["scientific_final_step"] = self.cursor + self.run.finish(exit_code=1 if failed else 0) + # Preserve the authoritative resume cursor even when every point + # was already on the server and this process logged no new points. + self.state["last_logged_step"] = self.cursor + tracking.write_json(self.state_path, self.state) + return True + return False + + +def discover_runs(runs_dir): + return { + path + for path in Path(runs_dir).glob("*") + if (path / "run.json").exists() and (path / "learning.json").exists() + } + + +def final_step(path): + history = tracking.read_json(path / "learning.json") + return max((int(record["step"]) for record in history), default=-1) + + +def drain_runs(sdk, root, runs_dir, settings, *, once=False, tracker_factory=None): + """Drain late-created runs and late final nodes before terminal exit. + + SDK initialization and uploads may take longer than an entire scientific + run. Consequently, a scan made before those calls is never an exit proof. + Finished runs stay in this process's cursor map and are reopened only if + their saved learning trajectory acquired an unlogged final node. + """ + root, runs_dir = Path(root), Path(runs_dir) + tracker_factory = tracker_factory or AuditedRunTracker + active, finished = {}, {} + try: + while True: + for path in sorted(discover_runs(runs_dir)): + if path in active or path in finished: + continue + active[path] = tracker_factory(sdk, root, path, settings) + print(json.dumps({"run": path.name, "url": active[path].run.url}), flush=True) + for path, tracker in list(active.items()): + current = tracking.read_json(path / "run.json") + if current.get("pid") != tracker.metadata.get("pid"): + tracker.close() + tracker = tracker_factory(sdk, root, path, settings) + active[path] = tracker + if tracker.poll(): + finished[path] = tracker.cursor + del active[path] + if once: + return {str(path): cursor for path, cursor in finished.items()} + manifest = root / "controller-state.json" + state = tracking.read_json(manifest) if manifest.exists() else {} + terminal = state.get("state") in {"complete", "finished_with_failures"} + # Rescan AFTER all SDK calls and after reading the controller's + # terminal state, so runs born during initialization cannot vanish. + fresh = discover_runs(runs_dir) + stale = {path for path, cursor in finished.items() if final_step(path) > cursor} + for path in stale: + del finished[path] + if terminal and not active: + expected = {runs_dir / name for name in state.get("completed", [])} + if missing := expected - fresh: + raise RuntimeError(f"Completed runs lack logging artifacts: {sorted(missing)}") + if fresh <= finished.keys(): + result = { + "passed": True, + "registered_runs": len(finished), + "runs": { + path.name: { + "last_logged_step": finished[path], + "final_step": final_step(path), + } + for path in sorted(fresh) + }, + } + tracking.write_json(root / "tracking-completion.json", result) + return result + if fresh - (active.keys() | finished.keys()): + continue + time.sleep(settings["poll_seconds"]) + finally: + for tracker in active.values(): + tracker.close() + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, required=True) + parser.add_argument("--runs-dir", type=Path) + parser.add_argument("--defaults", type=Path, default=tracking.DEFAULTS) + parser.add_argument("--entity") + parser.add_argument("--project") + parser.add_argument("--mode", choices=("online", "offline")) + parser.add_argument("--once", action="store_true") + args = parser.parse_args() + settings = tracking.read_json(args.defaults) + for key in ("entity", "project", "mode"): + settings[key] = ( + getattr(args, key) or os.environ.get(f"WANDB_{key.upper()}") or settings[key] + ) + if not settings["enabled"]: + raise SystemExit("Experiment tracking is disabled in the selected defaults") + local = args.root / "tracking-wandb" + local.mkdir(parents=True, exist_ok=True) + sdk = importlib.import_module("wandb") + with (local / "tracker.lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + tracking.write_json(args.root / "tracking-ready.json", {"sdk_version": sdk.__version__}) + drain_runs(sdk, args.root, args.runs_dir or args.root / "runs", settings, once=args.once) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_scaling.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_scaling.py new file mode 100644 index 0000000000000000000000000000000000000000..7abd21f4255e3f7de35ecee337ed09d32da707ff --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_scaling.py @@ -0,0 +1,311 @@ +"""Scaling knowledge use in ordinary GPT blocks with fixed facts and tests. + +Independent composition examples and optimization time are separate axes. All +blocks retain learned embeddings, causal attention, residuals and 4x GELU MLPs. +Historical experiments and their frozen implementations are left untouched. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_model import ModelConfig +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .storage_composition import FullTokenStep, data_digest, evaluate, file_hash, pack_sentences +from .storage_composition import build_world as historical_world +from .storage_frontier import SOURCE_FILES as STABILITY_SOURCES +from .storage_frontier import learning_rate +from .text_pretrain import WORDS + +SOURCE_FILES = [ + *STABILITY_SOURCES, + "src/llm_memory_editability/latent_scaling.py", + "scripts/run_latent_scaling.py", + "tests/test_latent_scaling.py", +] + + +def build_world(spec): + world = historical_world(spec) + pool = world["train_composite"] + order = np.random.default_rng(spec["world"] + 880000).permutation(len(pool)) + count = spec["composition_count"] + count = len(pool) if count == "all" else count + if isinstance(count, bool) or not isinstance(count, int) or not 0 < count <= len(pool): + raise ValueError("Composition count must be a positive prefix of the fixed pool") + world["available_composite"] = pool[order] + world["train_composite"] = world["available_composite"][:count].copy() + return world + + +def construct(spec, device): + config = ModelConfig( + vocab_size=len(WORDS) + spec["heads_n"] + spec["bridges_n"] + spec["tails_n"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=16, + ) + torch.manual_seed(spec["initialization"]) + # R=1 is ordinary GPT. The wrapper permits the same trained single block to + # be evaluated at other R, including the R=1 training baseline. + return LoopGPT(config, spec["repeats"], spec["dropout"], "legacy_unique").to(device) + + +def model_digest(model): + digest = hashlib.sha256() + for key, value in sorted(model.state_dict().items()): + digest.update(key.encode()) + digest.update(value.detach().cpu().numpy().tobytes()) + return digest.hexdigest() + + +def run_name(spec): + return ( + f"w{spec['world']}-i{spec['initialization']}-d{spec['width']}" + f"-l{spec['layers']}-r{spec['repeats']}-n{spec['composition_count']}-s{spec['steps']}" + ) + + +def role_coverage(world): + first = {(int(h), int(r)) for h, r, _b, _r2, _t in world["train_composite"]} + second = {(int(b), int(r)) for _h, _r1, b, r, _t in world["train_composite"]} + rows = world["familiar_test"] + return { + "first_atoms_used": len(first), + "second_atoms_used": len(second), + "familiar_both_composition_roles": float( + np.mean( + [ + (int(h), int(r1)) in first and (int(b), int(r2)) in second + for h, r1, b, r2, _t in rows + ] + ) + ), + } + + +def train(spec, out, source, device="cuda:0"): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "latest.pt").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite a training attempt: {out}") + if spec["nodes"][0] != 0 or spec["nodes"][-1] != spec["steps"]: + raise ValueError("Nodes must include initialization and the fixed endpoint") + if spec["nodes"] != sorted(set(spec["nodes"])) or spec["batch_size"] % 3: + raise ValueError("Nodes must increase and the batch must divide into three streams") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + process_start = time.perf_counter() + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + digest = data_digest(world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_digest = model_digest(model) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + strata = [world["common_atomic"], world["train_composite"], world["anchor_atomic"]] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + graph = FullTokenStep(model, optimizer, table, batch) + flop_step = flops(model.config, spec["repeats"], batch, 9, output_positions=9) + history, repeat_metrics, training_seconds, step = [], {}, 0.0, 0 + + def measure(loss=None): + metrics, predictions = evaluate(model, world, "low", device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0.0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + "composition_epochs": step * batch / 3 / sizes[1], + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + if step in spec["repeat_nodes"]: + repeat_metrics[str(step)] = {} + for repeat in spec["test_repeats"]: + m, p = evaluate(model, world, "low", device, repeat) + repeat_metrics[str(step)][str(repeat)] = m + np.savez_compressed(out / f"repeat-{step:06d}-r{repeat:02d}.npz", **p) + write_json(out / "repeat-metrics.json", repeat_metrics) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["checkpoint_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"model-{step:06d}.pt", + ) + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["common_atomic"]["accuracy"], + "train": metrics["train_composite"]["accuracy"], + "test": metrics["familiar_test"]["accuracy"], + } + ), + flush=True, + ) + return row + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize() + started = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - started + loss = float(loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite training loss at {step}") + endpoint = measure(loss) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + result = { + "spec": spec, + "source": source, + "data_sha256": digest, + "initial_model_sha256": initial_digest, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "independent_facts": sizes[0] + sizes[2], + "composition_examples": sizes[1], + "role_coverage": role_coverage(world), + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "training_seconds": training_seconds, + "process_seconds": time.perf_counter() - process_start, + "supervised_tokens": step * batch * 23 // 3, + "padded_input_tokens": step * batch * 9, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device), + "tf32": True, + }, + } + write_json(out / "complete.json", result) + return result + + +def compare_predictions(actual, saved): + maximum = 0.0 + assert set(actual) == set(saved.files) + for key, value in actual.items(): + if key.endswith("answer_nll"): + maximum = max(maximum, float(np.abs(value - saved[key]).max())) + np.testing.assert_allclose(value, saved[key], rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(value, saved[key]) + return maximum + + +def compare_metrics(actual, saved): + for task, values in actual.items(): + for key, value in values.items(): + if key == "answer_nll": + np.testing.assert_allclose(value, saved[task][key], rtol=1e-5, atol=1e-5) + else: + assert value == saved[task][key] + + +def audit(out, device="cuda:0"): + out = Path(out) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + result = json.loads((out / "complete.json").read_text()) + assert file_hash(out / "latest.pt") == result["checkpoint_sha256"] + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + spec = saved["spec"] + world = build_world(spec) + assert data_digest(world) == result["data_sha256"] == saved["data_sha256"] + assert saved["step"] == spec["steps"] + model = construct(spec, device) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, "low", device) + compare_metrics(metrics, result["endpoint"]["metrics"]) + maximum = compare_predictions( + predictions, np.load(out / f"predictions-{spec['steps']:06d}.npz") + ) + repeat_checks = 0 + for node, repeats in result["repeat_metrics"].items(): + checkpoint = torch.load( + out / f"model-{int(node):06d}.pt", map_location=device, weights_only=False + ) + model.load_state_dict(checkpoint["model"]) + for repeat, expected in repeats.items(): + actual, pred = evaluate(model, world, "low", device, int(repeat)) + compare_metrics(actual, expected) + maximum = max( + maximum, + compare_predictions( + pred, np.load(out / f"repeat-{int(node):06d}-r{int(repeat):02d}.npz") + ), + ) + repeat_checks += 1 + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == spec["steps"] * spec["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + checked = { + "passed": True, + "endpoint_tokens_exact": True, + "repeat_checks": repeat_checks, + "max_nll_difference": maximum, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "utc": utc(), + } + write_json(out / "audit.json", checked) + return checked diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_support.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_support.py new file mode 100644 index 0000000000000000000000000000000000000000..4b307c09f7a1fe633c634ae39b3a83e964675355 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_support.py @@ -0,0 +1,363 @@ +"""Degree-matched support follow-up with isolated training and audit entry points. + +The train/audit bodies are copied from latent_scaling.py at batch creation so +historical sources retain their frozen hashes. Architecture, optimizer, sentence +packing, evaluation and streams are reused; only build_world selects support. +""" + +from __future__ import annotations + +import json +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch + +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import flops +from .latent_scaling import ( + SOURCE_FILES as HISTORICAL_SOURCES, +) +from .latent_scaling import ( + build_world as scaling_world, +) +from .latent_scaling import ( + compare_metrics, + compare_predictions, + construct, + model_digest, + role_coverage, +) +from .latent_scaling import ( + run_name as scaling_run_name, +) +from .storage_composition import ( + FullTokenStep, + audit_world, + data_digest, + evaluate, + file_hash, + pack_sentences, +) +from .storage_frontier import learning_rate + +SOURCE_FILES = [*HISTORICAL_SOURCES, "src/llm_memory_editability/latent_support.py"] + + +def run_name(spec): + return scaling_run_name(spec) + "-support-" + spec["support"] + + +def build_world(spec): + """Select frozen legal edges; never use model scores or test pairs to choose.""" + if spec.get("support") not in ("connected", "split"): + raise ValueError("Unknown frozen support arm") + indices = spec.get("composition_indices", []) + if ( + len(indices) != 512 + or any(isinstance(i, bool) or not isinstance(i, int) for i in indices) + or len(set(indices)) != 512 + or indices != sorted(indices) + or spec.get("composition_count") != 512 + ): + raise ValueError("Support must contain 512 unique sorted integer indices") + world = scaling_world(dict(spec, composition_count="all")) + pool = world["available_composite"] + if indices[0] < 0 or indices[-1] >= len(pool): + raise ValueError("Support index outside the fixed available pool") + world["train_composite"] = pool[indices].copy() + if len(set(map(tuple, world["train_composite"]))) != 512: + raise ValueError("Support contains duplicate training chains") + audit_world(world) + expected = spec.get("frozen_data_sha256") + if expected is not None and data_digest(world) != expected: + raise RuntimeError("Rebuilt support data differ from the frozen digest") + return world + + +def exposure_signature(world, counts=None): + """Count actual sampled roles and column marginals, independently of streams.""" + rows = world["train_composite"] + if counts is None: + counts = np.ones(len(rows), dtype=np.int64) + if len(counts) != len(rows): + raise ValueError("Exposure counter does not match the support") + first, second = Counter(), Counter() + columns = [Counter() for _ in range(5)] + for row, count in zip(rows, counts, strict=True): + h, r1, b, r2, _t = map(int, row) + first[f"{h}:{r1}"] += int(count) + second[f"{b}:{r2}"] += int(count) + for col, value in enumerate(row): + columns[col][str(int(value))] += int(count) + return { + "first_roles": dict(sorted(first.items())), + "second_roles": dict(sorted(second.items())), + "columns": [dict(sorted(c.items())) for c in columns], + } + + +def support_components(world): + """Independent adjacency traversal, including all available training roles.""" + adjacency = {} + for h, r1, b, r2, _t in world["available_composite"]: + adjacency.setdefault(("l", int(h), int(r1)), set()) + adjacency.setdefault(("r", int(b), int(r2)), set()) + for h, r1, b, r2, _t in world["train_composite"]: + left, right = ("l", int(h), int(r1)), ("r", int(b), int(r2)) + adjacency[left].add(right) + adjacency[right].add(left) + seen, components = set(), 0 + for root in adjacency: + if root in seen: + continue + components += 1 + stack = [root] + seen.add(root) + while stack: + for neighbour in adjacency[stack.pop()]: + if neighbour not in seen: + seen.add(neighbour) + stack.append(neighbour) + return { + "roles": len(adjacency), + "components": components, + "isolated_roles": sum(not neighbours for neighbours in adjacency.values()), + } + + +def validate_nodes(spec): + if spec["batch_size"] != 192 or any(node % 8 for node in spec["nodes"]): + raise ValueError("Every measurement must complete the 512-chain epochs") + if not set(spec["repeat_nodes"]) <= set(spec["checkpoint_nodes"]) <= set(spec["nodes"]): + raise ValueError("Scans and checkpoints must use recorded learning nodes") + + +def train(spec, out, source, device="cuda:0"): + validate_nodes(spec) + if "frozen_data_sha256" not in spec: + raise ValueError("Training requires a frozen data digest") + if any(file_hash(path) != digest for path, digest in source.items()): + raise RuntimeError("Training source differs from its frozen digest") + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "latest.pt").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite a training attempt: {out}") + if spec["nodes"][0] != 0 or spec["nodes"][-1] != spec["steps"]: + raise ValueError("Nodes must include initialization and the fixed endpoint") + if spec["nodes"] != sorted(set(spec["nodes"])) or spec["batch_size"] % 3: + raise ValueError("Nodes must increase and the batch must divide into three streams") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + process_start = time.perf_counter() + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + digest = data_digest(world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_digest = model_digest(model) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + strata = [world["common_atomic"], world["train_composite"], world["anchor_atomic"]] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + graph = FullTokenStep(model, optimizer, table, batch) + flop_step = flops(model.config, spec["repeats"], batch, 9, output_positions=9) + history, repeat_metrics, training_seconds, step = [], {}, 0.0, 0 + + def measure(loss=None): + if step and not np.all(counts[1] == step * batch // 3 // 512): + raise RuntimeError("Composition exposures must be exact complete epochs") + metrics, predictions = evaluate(model, world, "low", device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0.0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + "composition_epochs": step * batch / 3 / sizes[1], + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + if step in spec["repeat_nodes"]: + repeat_metrics[str(step)] = {} + for repeat in spec["test_repeats"]: + m, p = evaluate(model, world, "low", device, repeat) + repeat_metrics[str(step)][str(repeat)] = m + np.savez_compressed(out / f"repeat-{step:06d}-r{repeat:02d}.npz", **p) + write_json(out / "repeat-metrics.json", repeat_metrics) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["checkpoint_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"model-{step:06d}.pt", + ) + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["common_atomic"]["accuracy"], + "train": metrics["train_composite"]["accuracy"], + "test": metrics["familiar_test"]["accuracy"], + } + ), + flush=True, + ) + return row + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize() + started = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - started + loss = float(loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite training loss at {step}") + endpoint = measure(loss) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + result = { + "spec": spec, + "source": source, + "data_sha256": digest, + "initial_model_sha256": initial_digest, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "independent_facts": sizes[0] + sizes[2], + "composition_examples": sizes[1], + "role_coverage": role_coverage(world), + "support_components": support_components(world), + "support_exposures": exposure_signature(world, counts[1]), + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "training_seconds": training_seconds, + "process_seconds": time.perf_counter() - process_start, + "supervised_tokens": step * batch * 23 // 3, + "padded_input_tokens": step * batch * 9, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device), + "tf32": True, + }, + } + write_json(out / "complete.json", result) + return result + + +def audit(out, device="cuda:0"): + out = Path(out) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + result = json.loads((out / "complete.json").read_text()) + assert file_hash(out / "latest.pt") == result["checkpoint_sha256"] + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + recorded = json.loads((out / "spec.json").read_text()) + assert saved["spec"] == result["spec"] == recorded["spec"] + assert saved["source"] == result["source"] == recorded["source"] + assert all(file_hash(path) == digest for path, digest in result["source"].items()) + spec = saved["spec"] + validate_nodes(spec) + assert "frozen_data_sha256" in spec + world = build_world(spec) + assert data_digest(world) == result["data_sha256"] == saved["data_sha256"] + assert data_digest(world) == recorded["data_sha256"] == spec["frozen_data_sha256"] + with np.load(out / "world.npz") as archived: + assert set(archived.files) == set(world) + for key, rows in world.items(): + np.testing.assert_array_equal(rows, archived[key]) + assert saved["step"] == spec["steps"] + model = construct(spec, device) + assert model_digest(model) == result["initial_model_sha256"] + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, "low", device) + compare_metrics(metrics, result["endpoint"]["metrics"]) + maximum = compare_predictions( + predictions, np.load(out / f"predictions-{spec['steps']:06d}.npz") + ) + repeat_checks = 0 + for node, repeats in result["repeat_metrics"].items(): + checkpoint = torch.load( + out / f"model-{int(node):06d}.pt", map_location=device, weights_only=False + ) + assert checkpoint["spec"] == spec and checkpoint["step"] == int(node) + model.load_state_dict(checkpoint["model"]) + for repeat, expected in repeats.items(): + actual, pred = evaluate(model, world, "low", device, int(repeat)) + compare_metrics(actual, expected) + maximum = max( + maximum, + compare_predictions( + pred, np.load(out / f"repeat-{int(node):06d}-r{int(repeat):02d}.npz") + ), + ) + repeat_checks += 1 + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == spec["steps"] * spec["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + composition_counts = exposures["stratum1"] + assert np.all(composition_counts == spec["steps"] * spec["batch_size"] // 3 // 512) + assert exposure_signature(world, composition_counts) == result["support_exposures"] + assert support_components(world) == result["support_components"] + checked = { + "frozen_data_exact": True, + "archived_world_exact": True, + "composition_complete_epochs": True, + "role_exposures_exact": True, + "passed": True, + "endpoint_tokens_exact": True, + "repeat_checks": repeat_checks, + "max_nll_difference": maximum, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "utc": utc(), + } + write_json(out / "audit.json", checked) + return checked diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/low_rank.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/low_rank.py new file mode 100644 index 0000000000000000000000000000000000000000..3a58bee0d460cb3ae042e17d22b7132b2035bd4b --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/low_rank.py @@ -0,0 +1,138 @@ +"""Fully observed matrix representability; no training or editing algorithm. + +The best approximation minimizes unweighted Frobenius error over *all* entries. +It need not preserve unchanged facts exactly or prioritize requested edits. +Numerical rank uses an absolute singular-value threshold, not an exact-rank proof. +""" + +from numbers import Integral, Real +from typing import Any + +import numpy as np + + +def _matrix(value: Any, name: str = "matrix") -> np.ndarray: + """Convert a nonempty, finite, real numeric matrix to float64.""" + try: + raw = np.asarray(value) + except (TypeError, ValueError) as exc: + raise ValueError(f"{name} must be a rectangular real numeric matrix") from exc + if raw.ndim != 2 or 0 in raw.shape: + raise ValueError(f"{name} must be a nonempty two-dimensional matrix") + if raw.dtype.kind not in "iuf": + raise ValueError(f"{name} must contain real numeric values") + with np.errstate(over="ignore", invalid="ignore"): + result = raw.astype(np.float64) + if not np.isfinite(result).all(): + raise ValueError(f"{name} must contain finite float64 values") + return result + + +def _rank(value: Any, shape: tuple[int, int]) -> int: + if isinstance(value, (bool, np.bool_)) or not isinstance(value, Integral): + raise ValueError("rank must be a nonnegative integer") + if not 0 <= value <= min(shape): + raise ValueError(f"rank must be between 0 and {min(shape)}") + return int(value) + + +def _tolerance(value: Any) -> float: + if isinstance(value, (bool, np.bool_)) or not isinstance(value, Real): + raise ValueError("atol must be a finite positive real number") + value = float(value) + if not np.isfinite(value) or value <= 0: + raise ValueError("atol must be a finite positive real number") + return value + + +def numerical_rank(matrix: Any, atol: float = 1e-10) -> int: + """Count singular values strictly greater than the absolute tolerance.""" + array = _matrix(matrix) + tolerance = _tolerance(atol) + return int(np.count_nonzero(np.linalg.svd(array, compute_uv=False) > tolerance)) + + +def best_rank_approximation(matrix: Any, rank: int) -> np.ndarray: + """Return a best rank-at-most-``rank`` Frobenius approximation using SVD. + + ``rank`` may be zero and may not exceed the smaller matrix dimension. + The returned matrix is independent of the input. Tied singular values can + make the optimum nonunique; NumPy's SVD selects one such optimum. + """ + array = _matrix(matrix) + budget = _rank(rank, array.shape) + left, values, right = np.linalg.svd(array, full_matrices=False) + return (left[:, :budget] * values[:budget]) @ right[:budget, :] + + +def representation_gap(matrix: Any, rank: int, atol: float = 1e-10) -> int: + """Return max(0, numerical target rank minus the available rank budget).""" + array = _matrix(matrix) + budget = _rank(rank, array.shape) + return max(0, numerical_rank(array, atol=atol) - budget) + + +def evaluate_update(original: Any, target: Any, rank: int, atol: float = 1e-10) -> dict[str, Any]: + """Report an update's analytical optimum under a fixed total rank budget. + + ``original`` and ``target`` must have identical shapes. The target is fitted + directly, with no optimization path or restriction on the update rank. + ``squared_error_lower_bound`` is the sum of discarded squared singular + values (Eckart–Young–Mirsky); floating-point residuals may differ slightly. + + Edited entries are exactly those where original and target differ. ``atol`` + affects rank estimates only. RMSE is measured against the target separately + on edited and retained entries; an empty group is represented by ``None``. + The retained-entry metric measures collateral error at this global optimum, + not the side effects of a learned editing algorithm. + """ + before = _matrix(original, "original") + after = _matrix(target, "target") + if before.shape != after.shape: + raise ValueError("original and target must have identical shapes") + budget = _rank(rank, after.shape) + tolerance = _tolerance(atol) + with np.errstate(over="ignore", invalid="ignore"): + delta = _matrix(after - before, "target - original") + left, values, right = np.linalg.svd(after, full_matrices=False) + reconstruction = (left[:, :budget] * values[:budget]) @ right[:budget, :] + residual = reconstruction - after + edited = before != after + target_rank = int(np.count_nonzero(values > tolerance)) + gap = max(0, target_rank - budget) + error = float(np.linalg.norm(residual, ord="fro")) + lower_bound = float(np.sum(values[budget:] ** 2)) + + def group_rmse(mask: np.ndarray) -> float | None: + return float(np.linalg.norm(residual[mask]) / np.sqrt(mask.sum())) if mask.any() else None + + report = { + "rank_budget": budget, + "atol": tolerance, + "original_rank": numerical_rank(before, tolerance), + "target_rank": target_rank, + "delta_rank": numerical_rank(delta, tolerance), + "representation_gap": gap, + "representable_within_rank_tolerance": gap == 0, + "edit_count": int(edited.sum()), + "original": before.tolist(), + "target": after.tolist(), + "delta": delta.tolist(), + "reconstruction": reconstruction.tolist(), + "singular_values": values.tolist(), + "frobenius_error": error, + "squared_frobenius_error": error**2, + "squared_error_lower_bound": lower_bound, + "edited_entry_rmse": group_rmse(edited), + "retained_entry_rmse": group_rmse(~edited), + } + metrics = [ + error, + error**2, + lower_bound, + report["edited_entry_rmse"], + report["retained_entry_rmse"], + ] + if not all(value is None or np.isfinite(value) for value in metrics): + raise ValueError("matrix scale exceeds finite float64 error metrics; rescale the inputs") + return report diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/memory_reuse.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/memory_reuse.py new file mode 100644 index 0000000000000000000000000000000000000000..89520ed7649557ad7e4cfc2611ac85b8d9db8396 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/memory_reuse.py @@ -0,0 +1,469 @@ +"""Learned two-hop retrieval followed by an independently fitted memory swap. + +The pinned author implementation supplies the SwiGLU memory and GPT blocks. +Only attention Q/K are learned by the reader. Replacement facts are never used +by its optimizer, and all evaluation uses continuous intermediate states. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from llm_memory_editability import hebbian_interface as interface + +ARMS = ("ce", "aligned") + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n") + temporary.replace(path) + + +def cpu_state(model): + return {k: v.detach().cpu().clone() for k, v in model.state_dict().items()} + + +def hash_state(model, *, reader_only=False): + return interface.tensor_hash( + {k: v for k, v in model.state_dict().items() if not reader_only or ".mlp." not in k} + ) + + +def build_world(spec, seed): + """Geometry, content and held-out heads use independent local random streams.""" + n, d, j = spec["num_entities"], spec["d_model"], spec["junk_vocab_size"] + rng = np.random.default_rng(seed) + embeddings = rng.standard_normal((n + j + 1, d)).astype(np.float32) + embeddings /= np.linalg.norm(embeddings, axis=-1, keepdims=True) + mapping_a = np.arange(n + j + 1, dtype=np.int64) + mapping_b = mapping_a.copy() + mapping_a[:n] = rng.permutation(n) + for _ in range(10000): + candidate = rng.permutation(n) + if np.all(candidate != mapping_a[:n]): + mapping_b[:n] = candidate + break + else: + raise RuntimeError("Failed to draw a changed independent permutation") + order = np.random.default_rng(seed + 20000).permutation(n) + n_train = int(n * spec["train_head_fraction"]) + if not 0 < n_train <= n: + raise ValueError("Composition-training head fraction must lie in (0, 1]") + train_mask = np.zeros(n, dtype=bool) + train_mask[order[:n_train]] = True + return { + "embeddings": embeddings, + "mapping_A": mapping_a, + "mapping_B": mapping_b, + "train_mask": train_mask, + "seed": np.asarray(seed), + } + + +def data_audit(spec, world): + n, j = spec["num_entities"], spec["junk_vocab_size"] + for name in ("A", "B"): + mapping = world[f"mapping_{name}"] + assert np.array_equal(np.sort(mapping[:n]), np.arange(n)) + assert np.array_equal(mapping[n:], np.arange(n, n + j + 1)) + assert np.all(world["mapping_A"][:n] != world["mapping_B"][:n]) + np.testing.assert_allclose(np.linalg.norm(world["embeddings"], axis=-1), 1, atol=2e-7) + assert world["train_mask"].sum() == int(n * spec["train_head_fraction"]) + a, b = world["mapping_A"], world["mapping_B"] + return { + "entities": n, + "neutral_tokens": j + 1, + "A_composition_training_heads": int(world["train_mask"].sum()), + "A_composition_heldout_heads": int((~world["train_mask"]).sum()), + "changed_atomic_facts": int((a[:n] != b[:n]).sum()), + "changed_composite_answers": int((a[a[:n]] != b[b[:n]]).sum()), + "passed": True, + } + + +def make_inputs(spec, repeats, seed): + """Each head occurs once per repeat; contexts contain only neutral tokens.""" + n, j, length = spec["num_entities"], spec["junk_vocab_size"], spec["junk_length"] + rng = np.random.default_rng(seed) + keys = np.tile(np.arange(n, dtype=np.int64), repeats) + inputs = rng.integers(n, n + j, (len(keys), length + 2), dtype=np.int64) + positions = rng.integers(0, length + 1, len(keys)) + inputs[np.arange(len(keys)), positions] = keys + inputs[:, -1] = n + j + return inputs, keys + + +def new_memory(spec, init, device): + cfg = {**interface.DEFAULT_SPEC, **spec} + interface._source(cfg) + torch.manual_seed(init) + return interface._new_memory(cfg, device) + + +class TwoHopReader(torch.nn.Module): + """Two causal attention blocks with one shared, frozen fact MLP.""" + + def __init__(self, spec, embeddings, memory, init, device): + super().__init__() + interface._source(spec) + from hebbian.transformer.model import GPT, GPTConfig + + torch.manual_seed(init + 100000) + cfg = GPTConfig( + block_size=spec["junk_length"] + 2, + vocab_size=len(embeddings), + n_layer=2, + n_head=1, + n_embd=spec["d_model"], + dropout=0.0, + bias=False, + mlp_residual=False, + attn_residual=False, + use_rope=False, + no_positional_encoding=True, + mlp_norm_type="unit_rmsnorm", + attn_norm_type="rmsnorm", + lm_head_norm_type="unit_rmsnorm", + tie_embeddings=True, + freeze_value_dense_identity=True, + use_identity_mlp=True, + ) + self.gpt = GPT(cfg).to(device) + with torch.no_grad(): + self.gpt.transformer.wte.weight.copy_(torch.as_tensor(embeddings, device=device)) + self.install(memory) + self.gpt.requires_grad_(False) + for block in self.gpt.transformer.h: + block.attn.c_q.requires_grad_(True) + block.attn.c_k.requires_grad_(True) + self.scale = spec["readout_scale"] + + def install(self, memory): + memory.requires_grad_(False) + for block in self.gpt.transformer.h: + block.mlp = memory + + def forward(self, inputs): + x = self.gpt.transformer.wte(inputs) + logits = [] + for block in self.gpt.transformer.h: + x = block(x) + z = self.gpt.transformer.ln_f(x[:, -1]) + logits.append(self.scale * self.gpt.lm_head(z)) + return torch.stack(logits, dim=1) + + +def memory_objective(output, embeddings, labels, arm, alignment_weight): + ce = F.cross_entropy(output @ embeddings.T, labels) + alignment = (output - embeddings[labels]).square().sum(-1).mean() + return ce + (alignment_weight if arm == "aligned" else 0.0) * alignment + + +@torch.no_grad() +def clean_memory(memory, embeddings, mapping, n): + output = memory(embeddings) + cosine = F.normalize(output, dim=-1) @ embeddings.T + pred = cosine.argmax(-1) + return { + "atomic_accuracy": float(pred[:n].eq(mapping[:n]).float().mean()), + "neutral_accuracy": float(pred[n:].eq(mapping[n:]).float().mean()), + "target_cosine": float(cosine[torch.arange(n, device=mapping.device), mapping[:n]].mean()), + "output_norm": float(output[:n].norm(dim=-1).mean()), + "vector_squared_error": float( + (output[:n] - embeddings[mapping[:n]]).square().sum(-1).mean() + ), + } + + +def fit_memory(spec, world, mapping_name, arm, init, device, output_dir): + """Only atomic labels appear here, including for the replacement memory.""" + path = output_dir / f"memory-{mapping_name}.pt" + if path.exists(): + payload = torch.load(path, map_location="cpu", weights_only=True) + model = new_memory(spec, init, device) + model.load_state_dict(payload["state_dict"]) + record = dict(payload["record"], reused_checkpoint=True) + return model.requires_grad_(False).eval(), record + memory = new_memory(spec, init, device) + embeddings = torch.as_tensor(world["embeddings"], device=device) + labels = torch.as_tensor(world[f"mapping_{mapping_name}"], device=device) + optimizer = torch.optim.Adam(memory.parameters(), lr=spec["memory_lr"], foreach=False) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( + optimizer, spec["memory_steps"], eta_min=spec["memory_min_lr"] + ) + initial_hash = hash_state(memory) + curve = [] + began = time.perf_counter() + for step in range(spec["memory_steps"] + 1): + if step in spec["memory_nodes"]: + metrics = clean_memory(memory, embeddings, labels, spec["num_entities"]) + metrics.update(step=step, seconds=time.perf_counter() - began) + curve.append(metrics) + write_json(output_dir / f"memory-{mapping_name}-curve.json", curve) + print(json.dumps(dict(stage=f"memory-{mapping_name}", arm=arm, **metrics)), flush=True) + if step == spec["memory_steps"]: + break + memory.train() + optimizer.zero_grad(set_to_none=True) + loss = memory_objective( + memory(embeddings), embeddings, labels, arm, spec["alignment_weight"] + ) + loss.backward() + optimizer.step() + scheduler.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + memory.eval().requires_grad_(False) + record = dict( + initial_hash=initial_hash, + final_hash=hash_state(memory), + steps=spec["memory_steps"], + seconds=time.perf_counter() - began, + metrics=clean_memory(memory, embeddings, labels, spec["num_entities"]), + ) + torch.save(dict(state_dict=cpu_state(memory), record=record), path) + return memory, record + + +@torch.no_grad() +def evaluate(reader, inputs, device, batch_size): + reader.eval() + return np.concatenate( + [ + reader(torch.as_tensor(inputs[start : start + batch_size], device=device)).cpu().numpy() + for start in range(0, len(inputs), batch_size) + ] + ) + + +def accuracy(pred, target, mask=None): + correct = pred == target + if mask is not None: + correct = correct[mask] + return float(correct.mean()) if len(correct) else None + + +def score_logits(logits, world, keys, mapping_name): + """Full-pool scores and explicitly labelled prerequisite/changed subsets.""" + pred = logits.argmax(-1) + mapping = world[f"mapping_{mapping_name}"] + y1, y2 = mapping[keys], mapping[mapping[keys]] + train = world["train_mask"][keys] + a, b = world["mapping_A"], world["mapping_B"] + changed = a[a[keys]] != b[b[keys]] + n = len(world["train_mask"]) + # Inputs are arranged as complete n-head repeats; find each actual successor. + successor_row = np.arange(len(keys)) // n * n + mapping[keys] + assert np.array_equal(keys[successor_row], mapping[keys]) + known = (pred[:, 0] == y1) & (pred[successor_row, 0] == mapping[mapping[keys]]) + return { + "n": len(keys), + "one_hop": accuracy(pred[:, 0], y1), + "two_hop": accuracy(pred[:, 1], y2), + "two_hop_A_training_heads": accuracy(pred[:, 1], y2, train), + "two_hop_A_heldout_heads": accuracy(pred[:, 1], y2, ~train), + "two_hop_changed": accuracy(pred[:, 1], y2, changed), + "changed_n": int(changed.sum()), + "two_hop_both_atoms_correct": accuracy(pred[:, 1], y2, known), + "both_atoms_correct_n": int(known.sum()), + "both_atoms_correct_coverage": float(known.mean()), + } + + +def reader_loss(logits, targets, train_mask): + return ( + F.cross_entropy(logits[:, 0], targets[:, 0]) + + F.cross_entropy(logits[train_mask, 1], targets[train_mask, 1]) + ) / 2 + + +def fit_reader(spec, world, memory, init, device, output_dir): + reader = TwoHopReader(spec, world["embeddings"], memory, init, device) + path = output_dir / "reader-A.pt" + if path.exists(): + payload = torch.load(path, map_location="cpu", weights_only=True) + reader.load_state_dict(payload["state_dict"]) + return reader.eval(), payload["record"] + initial_hash = hash_state(reader, reader_only=True) + frozen_before = interface.tensor_hash( + {k: p for k, p in reader.named_parameters() if not p.requires_grad} + ) + n = spec["num_entities"] + seed = int(world["seed"]) + train_inputs, _ = make_inputs(spec, spec["reader_steps"], seed + 30000) + stream_hash = hashlib.sha256(train_inputs.tobytes()).hexdigest() + train_inputs = torch.as_tensor( + train_inputs.reshape(-1, n, spec["junk_length"] + 2), device=device + ) + mapping = torch.as_tensor(world["mapping_A"], device=device) + targets = torch.stack((mapping[:n], mapping[mapping[:n]]), dim=1) + train_mask = torch.as_tensor(world["train_mask"], device=device) + eval_inputs, eval_keys = make_inputs(spec, spec["eval_repeats"], seed + 40000) + parameters = [p for p in reader.parameters() if p.requires_grad] + optimizer = torch.optim.AdamW( + parameters, lr=spec["reader_lr"], weight_decay=spec["reader_weight_decay"], foreach=False + ) + curve = [] + began = time.perf_counter() + for step in range(spec["reader_steps"] + 1): + if step in spec["reader_nodes"]: + logits = evaluate(reader, eval_inputs, device, n) + metrics = score_logits(logits, world, eval_keys, "A") + curve.append(dict(step=step, seconds=time.perf_counter() - began, **metrics)) + np.savez_compressed(output_dir / f"reader-node-{step:05d}.npz", logits=logits) + torch.save(cpu_state(reader), output_dir / f"reader-node-{step:05d}.pt") + write_json(output_dir / "reader-curve.json", curve) + print(json.dumps(dict(stage="reader", step=step, **metrics)), flush=True) + if step == spec["reader_steps"]: + break + reader.train() + optimizer.zero_grad(set_to_none=True) + loss = reader_loss(reader(train_inputs[step]), targets, train_mask) + loss.backward() + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + frozen_after = interface.tensor_hash( + {k: p for k, p in reader.named_parameters() if not p.requires_grad} + ) + assert frozen_before == frozen_after, "Frozen facts or embeddings changed" + record = dict( + initial_hash=initial_hash, + final_hash=hash_state(reader, reader_only=True), + frozen_hash=frozen_after, + stream_hash=stream_hash, + steps=spec["reader_steps"], + seconds=time.perf_counter() - began, + trainable_names=[k for k, p in reader.named_parameters() if p.requires_grad], + trainable_parameters=sum(p.numel() for p in parameters), + total_parameters=sum(p.numel() for p in reader.parameters()), + metrics=curve[-1], + ) + torch.save(dict(state_dict=cpu_state(reader), record=record), path) + return reader.eval(), record + + +def run(spec, world_seed, init, arm, output_dir, device): + if arm not in ARMS: + raise ValueError(arm) + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + device = torch.device(device) + torch.set_num_threads(spec["cpu_threads"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + if device.type == "cuda": + torch.cuda.set_device(device) + torch.cuda.reset_peak_memory_stats(device) + world = build_world(spec, world_seed) + np.savez_compressed(output_dir / "world.npz", **world) + write_json(output_dir / "spec.json", spec) + audit = data_audit(spec, world) + started = time.perf_counter() + result = dict( + world=world_seed, init=init, arm=arm, spec=spec, data_audit=audit, status="running" + ) + write_json(output_dir / "status.json", result) + memory_a, a_record = fit_memory(spec, world, "A", arm, init, device, output_dir) + reader, reader_record = fit_reader(spec, world, memory_a, init, device, output_dir) + # Replacement fitting happens only after the A reader has finished. + memory_b, b_record = fit_memory(spec, world, "B", arm, init, device, output_dir) + inputs, keys = make_inputs(spec, spec["eval_repeats"], world_seed + 40000) + logits_a = evaluate(reader, inputs, device, spec["num_entities"]) + non_memory_hash = hash_state(reader, reader_only=True) + reader.requires_grad_(False) + reader.install(memory_b) + logits_b = evaluate(reader, inputs, device, spec["num_entities"]) + assert hash_state(reader, reader_only=True) == non_memory_hash + assert reader.gpt.transformer.h[0].mlp is reader.gpt.transformer.h[1].mlp + assert hash_state(memory_b) == b_record["final_hash"] + embeddings = torch.as_tensor(world["embeddings"], device=device) + with torch.no_grad(): + memory_arrays = { + f"memory_{name}_output": mem(embeddings).cpu().numpy() + for name, mem in (("A", memory_a), ("B", memory_b)) + } + np.savez_compressed( + output_dir / "endpoints.npz", + inputs=inputs, + keys=keys, + logits_A=logits_a, + logits_B=logits_b, + **memory_arrays, + ) + # Store a full swapped endpoint to permit a genuinely independent reload. + torch.save(dict(state_dict=cpu_state(reader)), output_dir / "reader-B.pt") + endpoints = { + "A": score_logits(logits_a, world, keys, "A"), + "B": score_logits(logits_b, world, keys, "B"), + "wrong_A_on_B": score_logits(logits_a, world, keys, "B"), + } + length, d, h, vocab = ( + spec["junk_length"] + 2, + spec["d_model"], + spec["hidden_dim"], + len(embeddings), + ) + # Approximate multiply-add FLOPs. Backprop through frozen MLP still costs work. + memory_flops = 2 * spec["memory_steps"] * (18 * vocab * d * h + 6 * vocab**2 * d) + reader_flops = spec["reader_steps"] * ( + 2 + * ( + 24 * spec["num_entities"] * length * d**2 + + 12 * spec["num_entities"] * length**2 * d + + 12 * spec["num_entities"] * length * d * h + ) + ) + result.update( + status="complete", + memories=dict(A=a_record, B=b_record), + reader=reader_record, + endpoints=endpoints, + assertions=dict( + frozen_reader_after_swap=True, shared_memory=True, no_B_reader_training=True + ), + seconds=time.perf_counter() - started, + budget=dict( + memory_updates=sum( + spec["memory_steps"] + for r in (a_record, b_record) + if not r.get("reused_checkpoint", False) + ), + reused_memory_updates=sum( + spec["memory_steps"] + for r in (a_record, b_record) + if r.get("reused_checkpoint", False) + ), + reader_updates=spec["reader_steps"], + atomic_exposures=sum( + spec["memory_steps"] * spec["num_entities"] + for r in (a_record, b_record) + if not r.get("reused_checkpoint", False) + ), + reader_input_tokens=spec["reader_steps"] * spec["num_entities"] * length, + reader_supervised_answers=spec["reader_steps"] + * (spec["num_entities"] + int(world["train_mask"].sum())), + approximate_matmul_flops=reader_flops + + memory_flops + * sum(not r.get("reused_checkpoint", False) for r in (a_record, b_record)) + / 2, + peak_gpu_bytes=torch.cuda.max_memory_allocated(device) if device.type == "cuda" else 0, + ), + ) + write_json(output_dir / "summary.json", result) + write_json(output_dir / "status.json", dict(status="complete", seconds=result["seconds"])) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/multihop_scaling.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/multihop_scaling.py new file mode 100644 index 0000000000000000000000000000000000000000..64b5a3d67ef6bab20c60904e626e811876d72279 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/multihop_scaling.py @@ -0,0 +1,518 @@ +"""Width, composition experience and compute depth in complete causal GPT models. + +The data, full-token objective and generation scoring extend ``depth_step``. +Support arms use nested training paths and identical held-out evaluation pools; +four independent streams keep atomics and each hop length at 32 draws per step. +""" + +from __future__ import annotations + +import copy +import hashlib +import json +import time +from functools import lru_cache +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from . import depth_step +from .depth_step import ( # noqa: F401 -- public interface reused by checkpoint analysis + BOS, + DATA_DEFAULTS, + ENTITY_OFFSET, + EOS, + EVALUATION_SPLITS, + HOPS, + PAD, + TRAIN_SPLITS, + compare_metrics, + compare_predictions, + construct, + data_digest, + evaluate, + generate_rows, + pack_rows, + prompt_rows, + truth_path_details, +) +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import flops +from .latent_scaling import model_digest +from .storage_composition import FullTokenStep, file_hash +from .storage_frontier import learning_rate + +SUPPORT_LEVELS = (1.0, 4.0) +ARCHITECTURES = ((2, 1), (4, 1), (1, 2), (1, 4)) +COMMON_SPLITS = ("atomic",) + tuple( + f"{split}_{hop}" for hop in HOPS for split in ("familiar", "strict") +) +SOURCE_FILES = [ + *depth_step.SOURCE_FILES, + "src/llm_memory_editability/multihop_scaling.py", + "scripts/run_multihop_scaling.py", + "scripts/execute_multihop_scaling.py", + "tests/test_multihop_scaling.py", +] + + +@lru_cache(maxsize=16) +def _reference_world(seed, settings): + return depth_step.build_world({"world_seed": seed, **dict(settings), "phi": 4.0}) + + +def _reference(spec): + seed = spec.get("world_seed", spec.get("world")) + if seed is None: + raise ValueError("A fixed world_seed is required") + settings = tuple( + (key, spec.get(key, value)) for key, value in DATA_DEFAULTS.items() if key != "phi" + ) + return _reference_world(int(seed), settings) + + +def common_evaluation_digest(world): + digest = hashlib.sha256() + for name in COMMON_SPLITS: + rows = world[name] + digest.update(name.encode()) + digest.update(np.asarray(rows.shape, dtype=" len(reference[name]), + "prefix_indices": list(range(count)), + } + # Preserve source lineage without duplicating descriptive source statistics. + metadata["source_worlds"] = { + hop: { + key: values[key] + for key in ( + "seed", + "hops", + "dataset_sha256", + "counts", + "phi_requested", + "phi_actual", + "train_composite_capped", + "id_paths_total", + "all_paths_total", + "source_url", + "source_commit", + "source_file", + "source_license", + ) + } + for hop, values in metadata["source_worlds"].items() + } + metadata.update( + phi=phi, + reference_phi=4.0, + reference_dataset_sha256=reference["metadata"]["dataset_sha256"], + composition_support=selections, + support_selection="Prefix of each phi=4 training array; no resampling of facts or tests", + exposure_contract="32 atomic + 32 each of 2/3/4-hop examples per step", + training_objective="All nonpadding next tokens including EOS; no intermediate targets", + ) + world["metadata"] = metadata + metadata["common_evaluation_sha256"] = common_evaluation_digest(world) + checked = audit_world(world) + metadata["dataset_sha256"] = checked["dataset_sha256"] + metadata["independent_audit"] = checked + expected = spec.get("frozen_data_sha256") + if expected is not None and expected != checked["dataset_sha256"]: + raise ValueError("Rebuilt data differ from the frozen specification") + expected_common = spec.get("common_evaluation_sha256") + if expected_common is not None and expected_common != metadata["common_evaluation_sha256"]: + raise ValueError("Common evaluation pools differ from the frozen specification") + return world + + +def audit_world(world): + checked = depth_step.audit_world(world) + metadata = world["metadata"] + phi = metadata["phi"] + if phi not in SUPPORT_LEVELS or metadata.get("reference_phi") != 4.0: + raise ValueError("Invalid nested support contract") + reference = _reference(metadata) + ids = sum(metadata["id_mask"]) + for name in EVALUATION_SPLITS: + expected = reference[name] + if name.startswith("train_"): + expected = expected[: min(round(phi * ids), len(expected))] + if not np.array_equal(world[name], expected): + raise ValueError("Common pools/nested support differ from reference: " + name) + common = common_evaluation_digest(world) + if common != metadata["common_evaluation_sha256"]: + raise ValueError("Common evaluation digest differs") + if reference["metadata"]["dataset_sha256"] != metadata["reference_dataset_sha256"]: + raise ValueError("High-support reference differs") + return { + **checked, + "low_support_is_high_support_prefix": True, + "same_atomic_id_ood_and_heldout_pools_across_support": True, + "common_evaluation_sha256": common, + } + + +def run_name(spec): + seed = spec.get("world_seed", spec.get("world")) + return ( + f"w{seed}-i{spec['initialization']}-d{spec['width']}-phi{spec['phi']:g}" + f"-l{spec['layers']}-r{spec['repeats']}-s{spec['steps']}" + ) + + +def _validate_spec(spec): + depth_step._validate_spec(spec) + if float(spec["phi"]) not in SUPPORT_LEVELS: + raise ValueError("Unsupported composition support") + if (spec["layers"], spec["repeats"]) not in ARCHITECTURES: + raise ValueError("Unsupported architecture") + + +def _check_source(source): + depth_step._check_source(source) + required = {"src/llm_memory_editability/multihop_scaling.py", *depth_step.SOURCE_FILES} + if not required <= set(source): + raise RuntimeError("Source lock omits experiment dependencies") + + +def _validate_output(out): + depth_step._validate_output(out) + + +def _device_setup(device): + device = torch.device(device) + torch.set_num_threads(1) + # Standalone workers call this once; CPU integration checks may call twice. + try: + torch.set_num_interop_threads(1) + except RuntimeError: + pass + if device.type == "cuda": + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + return device + + +class _CpuStep: + """Same objective and optimizer groups for inexpensive engineering checks.""" + + def __init__(self, model, optimizer, table, clip): + self.model, self.optimizer, self.table, self.clip = model, optimizer, table, clip + + def __call__(self, indices): + self.optimizer.zero_grad(set_to_none=True) + tokens, labels = (part[indices] for part in self.table) + logits = self.model(tokens) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + loss.backward() + torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss.detach() + + +def _synchronize(device): + if device.type == "cuda": + torch.cuda.synchronize(device) + + +def train(spec, out, source, device="cuda:0"): + _validate_spec(spec) + _check_source(source) + if "frozen_data_sha256" not in spec or "common_evaluation_sha256" not in spec: + raise ValueError("Training requires frozen data and common evaluation hashes") + out = Path(out) + _validate_output(out) + out.mkdir(parents=True, exist_ok=True) + device = _device_setup(device) + started_process = time.perf_counter() + world = build_world(spec) + digest = data_digest(world) + depth_step._save_world(out, world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_digest = model_digest(model) + if spec.get("initial_model_sha256", initial_digest) != initial_digest: + raise AssertionError("Frozen initialization differs") + lr = torch.tensor(spec["lr"], device=device) + if device.type == "cuda": + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + else: + optimizer = torch.optim.AdamW( + [ + { + "params": [p for p in model.parameters() if p.ndim >= 2], + "weight_decay": spec["weight_decay"], + }, + {"params": [p for p in model.parameters() if p.ndim < 2], "weight_decay": 0.0}, + ], + lr=lr, + betas=(0.9, 0.999), + eps=1e-8, + ) + sizes = [len(world[name]) for name in TRAIN_SPLITS] + if any(size == 0 for size in sizes): + raise ValueError("Do not reroll a world with an empty sampled training stratum") + packed = [ + pack_rows(world[name], separator=world["metadata"]["separator_token"]) + for name in TRAIN_SPLITS + ] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) for parts in zip(*packed, strict=True) + ) + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + if device.type == "cuda": + graph = FullTokenStep( + model, optimizer, table, spec["batch_size"], clip=spec.get("clip", 1.0) + ) + else: + graph = _CpuStep(model, optimizer, table, spec.get("clip", 1.0)) + flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 8, output_positions=8) + token_step = 32 * sum(int((labels[0] >= 0).sum()) for _, labels in packed) + history, step, training_seconds = [], 0, 0.0 + + def measure(loss=None): + metrics, predictions = evaluate(model, world, device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0.0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + "supervised_tokens": step * token_step, + "padded_input_tokens": step * spec["batch_size"] * 8, + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + np.savez_compressed( + out / f"exposures-{step:06d}.npz", + **dict(zip(TRAIN_SPLITS, counts, strict=True)), + ) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device) if device.type == "cuda" else None, + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["checkpoint_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"model-{step:06d}.pt", + ) + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["atomic"]["accuracy"], + "familiar": {str(hop): metrics[f"familiar_{hop}"]["accuracy"] for hop in HOPS}, + } + ), + flush=True, + ) + return row + + measure() + endpoint = history[0] + for end in spec["nodes"][1:]: + _synchronize(device) + started = time.perf_counter() + while step < end: + updates = min(128, end - step) + indices = [] + for i, stream in enumerate(streams): + draws = stream.take(updates * 32).reshape(updates, 32) + counts[i] += np.bincount(draws.ravel(), minlength=sizes[i]) + indices.append(draws + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(updates): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += updates + _synchronize(device) + training_seconds += time.perf_counter() - started + loss_value = float(loss) + if not np.isfinite(loss_value): + raise FloatingPointError("Nonfinite loss at step " + str(step)) + endpoint = measure(loss_value) + np.savez_compressed(out / "exposures.npz", **dict(zip(TRAIN_SPLITS, counts, strict=True))) + result = { + "spec": spec, + "source": source, + "data_sha256": digest, + "common_evaluation_sha256": world["metadata"]["common_evaluation_sha256"], + "initial_model_sha256": initial_digest, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "architecture": "loop" if spec["repeats"] > 1 else "standard", + "effective_depth": spec["layers"] * spec["repeats"], + "strata_counts": dict(zip(TRAIN_SPLITS, sizes, strict=True)), + "endpoint": endpoint, + "supervised_tokens": step * token_step, + "padded_input_tokens": step * spec["batch_size"] * 8, + "estimated_training_flops": step * flop_step, + "training_seconds": training_seconds, + "process_seconds": time.perf_counter() - started_process, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "device": str(device), + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "tf32": device.type == "cuda", + }, + } + write_json(out / "complete.json", result) + return result + + +def audit(out, device="cuda:0"): + out = Path(out) + if (out / "audit.json").exists(): + raise FileExistsError(out / "audit.json") + device = _device_setup(device) + result = json.loads((out / "complete.json").read_text()) + recorded = json.loads((out / "spec.json").read_text()) + source, spec = result["source"], result["spec"] + _check_source(source) + _validate_spec(spec) + if recorded["spec"] != spec or recorded["source"] != source: + raise AssertionError("Recorded specification/source differ") + if file_hash(out / "latest.pt") != result["checkpoint_sha256"]: + raise AssertionError("Latest checkpoint hash differs") + world = build_world(spec) + digest = data_digest(world) + if digest != result["data_sha256"] or digest != recorded["data_sha256"]: + raise AssertionError("Rebuilt data differ from records") + if result["common_evaluation_sha256"] != common_evaluation_digest(world): + raise AssertionError("Common evaluation identity differs") + if json.loads((out / "world-metadata.json").read_text()) != world["metadata"]: + raise AssertionError("Archived world metadata differ") + with np.load(out / "world.npz") as archived: + if set(archived.files) != set(EVALUATION_SPLITS): + raise AssertionError("Archived world keys differ") + for name in EVALUATION_SPLITS: + np.testing.assert_array_equal(archived[name], world[name]) + model = construct(spec, device) + if model_digest(model) != result["initial_model_sha256"]: + raise AssertionError("Paired initialization differs") + history = json.loads((out / "learning.json").read_text()) + if [row["step"] for row in history] != spec["nodes"]: + raise AssertionError("Recorded learning nodes differ") + by_node = {row["step"]: row for row in history} + if by_node[spec["steps"]] != result["endpoint"]: + raise AssertionError("Endpoint differs from the learning curve") + maximum = 0.0 + for node in spec["checkpoint_nodes"]: + checkpoint = torch.load( + out / f"model-{node:06d}.pt", map_location=device, weights_only=False + ) + if checkpoint["spec"] != spec or checkpoint["step"] != node: + raise AssertionError("Checkpoint specification/node differ") + model.load_state_dict(checkpoint["model"]) + metrics, predictions = evaluate(model, world, device) + compare_metrics(metrics, by_node[node]["metrics"]) + maximum = max( + maximum, compare_predictions(predictions, out / f"predictions-{node:06d}.npz") + ) + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + if ( + saved["spec"] != spec + or saved["source"] != source + or saved["step"] != spec["steps"] + or saved["data_sha256"] != digest + ): + raise AssertionError("Latest state identity differs") + sizes = [len(world[name]) for name in TRAIN_SPLITS] + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + previous = 0 + for node in spec["nodes"]: + for i, stream in enumerate(streams): + draws = ( + stream.take((node - previous) * 32) + if node > previous + else np.empty(0, dtype=np.int64) + ) + counts[i] += np.bincount(draws, minlength=sizes[i]) + with np.load(out / f"exposures-{node:06d}.npz") as actual: + if set(actual.files) != set(TRAIN_SPLITS): + raise AssertionError("Exposure strata differ") + for name, count in zip(TRAIN_SPLITS, counts, strict=True): + np.testing.assert_array_equal(actual[name], count) + row = by_node[node] + if row["supervised_tokens"] != node * 832 or row["padded_input_tokens"] != node * 1024: + raise AssertionError("Token accounting differs") + previous = node + with np.load(out / "exposures.npz") as actual: + for i, (name, count) in enumerate(zip(TRAIN_SPLITS, counts, strict=True)): + np.testing.assert_array_equal(actual[name], count) + np.testing.assert_array_equal(saved["counts"][i], count) + if count.sum() != spec["steps"] * 32 or np.ptp(count) > 1: + raise AssertionError("EpochStream actual exposures are unbalanced") + stream = EpochStream(sizes[i], spec["stream_seed"] + i) + stream.load_state_dict(saved["streams"][i]) + np.testing.assert_array_equal(stream.take(32), streams[i].take(32)) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, device) + compare_metrics(metrics, result["endpoint"]["metrics"]) + maximum = max( + maximum, compare_predictions(predictions, out / f"predictions-{spec['steps']:06d}.npz") + ) + checked = { + "passed": True, + "dataset_rebuilt_and_archived_exact": True, + "nested_support_and_common_pools_checked": True, + "initial_model_exact": True, + "checkpoint_nodes": spec["checkpoint_nodes"], + "endpoint_tokens_exact": True, + "all_nodes_exposure_counters_exact": True, + "stream_state_continuation_exact": True, + "max_nll_difference": maximum, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "utc": utc(), + } + write_json(out / "audit.json", checked) + return checked diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation.py new file mode 100644 index 0000000000000000000000000000000000000000..dc9608e59339683c91de69b2f1f392b93b8f0171 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation.py @@ -0,0 +1,687 @@ +"""Full-Qwen, nested compositional support with matched atomic supervision.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import platform +import shutil +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch +import torch.nn.functional as F +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +from . import small_lm_composition as base + +FIRST = ("mentor", "advisor") +SECOND = ("live", "birth") +STRICT_CITIES = ( + "Athens Prague Havana Tunis Perth Zurich Bristol Munich " + "Tallinn Riga Quito Dakar Nairobi Accra Calgary Warsaw" +).split() +ROOT = Path("docs/development-artifacts/natural-composition-confirmation-v1") + + +def sha(path): + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def write(path, value): + base.write(path, value) + + +def build_world(seed): + rng = np.random.default_rng(seed) + first_names = ( + "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo" + ).split() + names = [ + f"{a} {b}" + for a in first_names + for b in "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split() + ] + names = rng.permutation(names).tolist() + atoms, chains = [], [] + for pool, offset, cities in (("familiar", 0, base.CITIES), ("strict", 32, STRICT_CITIES)): + heads, bridges = names[offset : offset + 16], names[offset + 16 : offset + 32] + mappings = [rng.permutation(16).tolist()] + mappings.append(np.roll(mappings[0], int(rng.integers(1, 16))).tolist()) + city_maps = [rng.permutation(cities).tolist()] + city_maps.append(np.roll(city_maps[0], int(rng.integers(1, 16))).tolist()) + ids = {} + for j, head in enumerate(heads): + for r, relation in enumerate(FIRST): + atom = dict( + id=len(atoms), + pool=pool, + role="first", + subject=head, + relation=relation, + answer=bridges[mappings[r][j]], + ) + atoms.append(atom) + ids["first", j, r] = atom["id"] + for j, bridge in enumerate(bridges): + for s, relation in enumerate(SECOND): + atom = dict( + id=len(atoms), + pool=pool, + role="second", + subject=bridge, + relation=relation, + answer=city_maps[s][j], + ) + atoms.append(atom) + ids["second", j, s] = atom["id"] + for j, head in enumerate(heads): + for r, first in enumerate(FIRST): + for s, second in enumerate(SECOND): + bridge_index = mappings[r][j] + chains.append( + dict( + id=len(chains), + pool=pool, + head_index=j, + head=head, + bridge=bridges[bridge_index], + first=first, + second=second, + answer=city_maps[s][bridge_index], + atom_ids=[ids["first", j, r], ids["second", bridge_index, s]], + split="strict" + if pool == "strict" + else ("support" if r == s else "heldout"), + ) + ) + return dict( + seed=seed, + atoms=atoms, + chains=chains, + high_support=[c["id"] for c in chains if c["split"] == "support"], + low_support=[c["id"] for c in chains if c["split"] == "support" and c["head_index"] < 4], + ) + + +def question(row, variant=0, atomic=False): + if atomic: + subject, relation = row["subject"], row["relation"] + if row["role"] == "first": + templates = ( + "Who is {subject}'s {relation}?", + "Who is the {relation} of {subject}?", + "Name the {relation} of {subject}.", + "Give the name of {subject}'s {relation}.", + "Give the name of the person serving as {subject}'s {relation}.", + ) + elif relation == "live": + templates = ( + "Which city does {subject} live in?", + "What city is {subject}'s home?", + "Where does {subject} live?", + "Name the city where {subject} lives.", + "In which city is {subject} living?", + ) + else: + templates = ( + "Which city was {subject} born in?", + "What is {subject}'s birth city?", + "Where was {subject} born?", + "Name the city where {subject} was born.", + "In which city did {subject}'s birth take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + subject = row["head"] + relation = row["first"] + if row["second"] == "live": + templates = ( + "Which city does {subject}'s {relation} live in?", + "What city is home to {subject}'s {relation}?", + "Where does the {relation} of {subject} live?", + "Name the city where {subject}'s {relation} lives.", + "In which city is the person serving as {subject}'s {relation} living?", + ) + else: + templates = ( + "Which city was {subject}'s {relation} born in?", + "What is the birth city of {subject}'s {relation}?", + "Where was the {relation} of {subject} born?", + "Name the city where {subject}'s {relation} was born.", + "In which city did the birth of {subject}'s {relation} take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + + +def prompt(row, variant=0, atomic=False): + return "Fictional registry.\nQuestion: " + question(row, variant, atomic) + "\nAnswer:" + + +def record(tokenizer, row, variant, atomic): + # Joint text tokenization, exactly as in the calibrated full-Qwen v2 recipe. + ids = tokenizer.encode( + prompt(row, variant, atomic) + " " + row["answer"] + ".", add_special_tokens=False + ) + [tokenizer.eos_token_id] + return dict( + ids=ids, + labels=[-100, *ids[1:]], + id=row["id"], + kind="atomic" if atomic else "composition", + variant=variant, + ) + + +def streams(world, cfg): + rng = np.random.default_rng(cfg["training_seed"]) + atomic_order, comp_order = [], {a: [] for a in cfg["arms"]} + batches = {a: [] for a in cfg["arms"]} + for _ in range(cfg["steps"]): + if len(atomic_order) < cfg["atomic_per_step"]: + atomic_order.extend(rng.permutation(len(world["atoms"])).tolist()) + atomic = [ + [int(atomic_order.pop(0)), int(rng.integers(4))] for _ in range(cfg["atomic_per_step"]) + ] + variants = rng.integers(4, size=cfg["compositions_per_step"]).tolist() + for arm in cfg["arms"]: + support = world[arm + "_support"] + if len(comp_order[arm]) < cfg["compositions_per_step"]: + comp_order[arm].extend(rng.permutation(support).tolist()) + comp = [[int(comp_order[arm].pop(0)), int(v)] for v in variants] + batches[arm].append(dict(atomic=atomic, composition=comp)) + return batches + + +def records(tokenizer, world): + return { + kind: { + (r["id"], v): record(tokenizer, r, v, kind == "atomic") + for r in world["atoms" if kind == "atomic" else "chains"] + for v in range(4) + } + for kind in ("atomic", "composition") + } + + +def docs_for(rec, batch): + return [rec[kind][tuple(spec)] for kind in ("atomic", "composition") for spec in batch[kind]] + + +def audit(world, batches, rec): + assert ( + len(world["atoms"]) == 128 + and len(world["high_support"]) == 32 + and len(world["low_support"]) == 8 + ) + assert set(world["low_support"]) < set(world["high_support"]) + familiar_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "familiar"} + covered = {i for j in world["high_support"] for i in world["chains"][j]["atom_ids"]} + assert covered == familiar_atoms + strict_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "strict"} + assert not covered & strict_atoms + support = [world["chains"][i] for i in world["high_support"]] + heldout = [c for c in world["chains"] if c["split"] == "heldout"] + strict = [c for c in world["chains"] if c["split"] == "strict"] + assert len(heldout) == 32 and len(strict) == 64 + # No alternate trained query gives the same head/answer endpoint as a held-out chain. + assert not {(c["head"], c["answer"]) for c in support} & { + (c["head"], c["answer"]) for c in heldout + } + + def people(pool): + return {a["subject"] for a in world["atoms"] if a["pool"] == pool} + + assert not people("familiar") & people("strict") + assert not {c["answer"] for c in support} & {c["answer"] for c in strict} + budgets, exposure = {}, {} + for arm, stream in batches.items(): + budget, atomic_counts, comp_counts = Counter(), Counter(), Counter() + for batch in stream: + docs = docs_for(rec, batch) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + atomic_counts.update(i for i, _ in batch["atomic"]) + comp_counts.update(i for i, _ in batch["composition"]) + assert set(comp_counts) <= set(world[arm + "_support"]) + budgets[arm] = dict(budget) + exposure[arm] = dict( + atomic=sorted(atomic_counts.items()), composition=sorted(comp_counts.items()) + ) + if "low" in batches and "high" in batches: + assert [b["atomic"] for b in batches["low"]] == [b["atomic"] for b in batches["high"]] + assert exposure["low"]["atomic"] == exposure["high"]["atomic"] + return dict( + status="passed", + budgets=budgets, + exposures=exposure, + familiar_fact_role_coverage_high=len(covered), + familiar_fact_role_coverage_low=len( + {i for j in world["low_support"] for i in world["chains"][j]["atom_ids"]} + ), + heldout_queries=len(heldout), + strict_queries=len(strict), + target_endpoint_leakage=0, + exact_common_atomic_sequence=True, + exact_atomic_stream_loss_weight=True, + composition_slots_equal=True, + ) + + +def freeze(config_path): + cfg = base.read(config_path) + art = Path(cfg["artifact_root"]) + assert not (art / "lock.json").exists(), "Preserve frozen batch." + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + sources = [ + str(config_path), + "src/llm_memory_editability/natural_composition_confirmation.py", + "src/llm_memory_editability/small_lm_composition.py", + "scripts/run_natural_composition_confirmation.py", + "tests/test_natural_composition_confirmation.py", + "docs/development-artifacts/natural-composition-confirmation-v1/design.md", + ] + source_hashes = {} + for source in sources: + dest = art / "source" / source + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, dest) + source_hashes[source] = sha(source) + data_files = {} + for seed in cfg["world_seeds"]: + world = build_world(seed) + batch = streams(world, cfg) + report = audit(world, batch, records(tokenizer, world)) + for filename, obj in ( + ("world.json", world), + ("streams.json", batch), + ("data-audit.json", report), + ): + path = art / f"w{seed}" / filename + write(path, obj) + data_files[str(path)] = sha(path) + model_files = { + str(p): sha(p) + for p in Path(cfg["model_path"]).iterdir() + if p.suffix in (".json", ".safetensors") or p.name in ("LICENSE", "README.md") + } + write( + art / "environment.json", + dict( + python=platform.python_version(), + executable=str(Path(__import__("sys").executable)), + torch=torch.__version__, + transformers=transformers.__version__, + gpu_inventory=__import__("subprocess").check_output( + ["nvidia-smi", "--query-gpu=index,name,memory.used,memory.total", "--format=csv"], + text=True, + ), + ), + ) + write( + art / "lock.json", + dict( + status="locked_before_training", + utc=base.now(), + sources=source_hashes, + data_files=data_files, + model_files=model_files, + config=cfg, + ), + ) + print( + json.dumps(dict(status="frozen", worlds=cfg["world_seeds"], arms=cfg["arms"])), flush=True + ) + + +def check_lock(cfg): + lock = base.read(Path(cfg["artifact_root"]) / "lock.json") + for group in ("sources", "data_files", "model_files"): + for path, digest in lock[group].items(): + assert sha(path) == digest, path + + +def evaluation_rows(world, extras=False): + rows = [] + for view in (0, 4) if extras else (0,): + for atom in world["atoms"]: + rows.append(dict(atom, mode="atomic", view=view, prompt=prompt(atom, view, True))) + for chain in world["chains"]: + rows.append(dict(chain, mode="direct", view=view, prompt=prompt(chain, view))) + return rows + + +@torch.inference_mode() +def generate(model, tokenizer, rows, cfg): + model.eval() + tokenizer.padding_side = "left" + output = [] + for start in range(0, len(rows), cfg["eval_batch"]): + chunk = rows[start : start + cfg["eval_batch"]] + inputs = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(cfg["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + tokens = model.generate( + **inputs, + do_sample=False, + max_new_tokens=cfg["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, inputs.input_ids.shape[1] :] + for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True): + if tokenizer.eos_token_id in tok: + tok = tok[: tok.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tok, skip_special_tokens=True) + output.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"]))) + return output + + +def evaluate(model, tokenizer, world, cfg, extras=False): + direct = generate(model, tokenizer, evaluation_rows(world, extras), cfg) + if not extras: + return direct + atoms = {a["id"]: a for a in world["atoms"]} + lookup = {(r["id"], r["view"]): r for r in direct if r["mode"] == "atomic"} + second_calls = [] + for row in direct: + if row["mode"] != "direct": + continue + first = lookup[row["atom_ids"][0], row["view"]] + generated_bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip() + second = dict(atoms[row["atom_ids"][1]], subject=generated_bridge) + second_calls.append( + dict( + row, + mode="autonomous", + prompt=prompt(second, row["view"], True), + generated_bridge=generated_bridge, + first_tokens=first["tokens"], + first_correct=first["correct"], + ) + ) + return direct + generate(model, tokenizer, second_calls, cfg) + + +def metrics(rows, world, arm): + result = {} + for view in sorted({r["view"] for r in rows}): + atomic = {r["id"]: r for r in rows if r["view"] == view and r["mode"] == "atomic"} + for pool in ("familiar", "strict"): + for role in ("first", "second"): + selected = [r for r in atomic.values() if r["pool"] == pool and r["role"] == role] + result[f"v{view}_{pool}_{role}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + for split in ("heldout", "strict", "training"): + ids = ( + set(world[arm + "_support"]) + if split == "training" + else {c["id"] for c in world["chains"] if c["split"] == split} + ) + for mode in ("direct", "autonomous"): + selected = [ + r for r in rows if r["view"] == view and r["mode"] == mode and r["id"] in ids + ] + if selected: + result[f"v{view}_{split}_{mode}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + mastered = [ + r for r in selected if all(atomic[i]["correct"] for i in r["atom_ids"]) + ] + result[f"v{view}_{split}_{mode}_both_atomic"] = dict( + correct=sum(r["correct"] for r in mastered), + n=len(mastered), + full_n=len(selected), + ) + return result + + +def stream_loss(model, inputs, atomic_count, atomic_weight): + logits = model( + input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], use_cache=False + ).logits[:, :-1] + labels = inputs["labels"][:, 1:] + losses = F.cross_entropy( + logits.float().reshape(-1, logits.shape[-1]), + labels.reshape(-1), + reduction="none", + ignore_index=-100, + ).reshape_as(labels) + atomic = losses[:atomic_count].sum() / (labels[:atomic_count] != -100).sum() + comp = losses[atomic_count:].sum() / (labels[atomic_count:] != -100).sum() + return atomic_weight * atomic + (1 - atomic_weight) * comp + + +def run(config_path, seed, arm): + cfg = base.read(config_path) + check_lock(cfg) + assert seed in cfg["world_seeds"] and arm in cfg["arms"] + art = Path(cfg["artifact_root"]) / f"w{seed}" + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + assert not (out / "status.json").exists(), "Preserve existing execution." + world, batches = base.read(art / "world.json"), base.read(art / "streams.json")[arm] + write(out / "status.json", dict(status="running", utc=base.now())) + started = time.perf_counter() + torch.set_num_threads(cfg["cpu_threads"]) + torch.manual_seed(cfg["training_seed"]) + torch.cuda.set_device(cfg["device"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + + def load(path): + return AutoModelForCausalLM.from_pretrained( + path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True + ).to(cfg["device"]) + + model = load(cfg["model_path"]) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + model.requires_grad_(True) + samples = base.parameter_samples(model) + parameter_count = sum(p.numel() for p in model.parameters()) + rec = records(tokenizer, world) + optimizer = torch.optim.AdamW( + model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"], fused=True + ) + curve, budget, train_seconds = [], Counter(), 0.0 + for step in range(cfg["steps"] + 1): + if step in cfg["nodes"]: + rows = evaluate(model, tokenizer, world, cfg, extras=step == cfg["steps"]) + write(out / f"predictions-{step:05d}.json", rows) + point = dict(step=step, metrics=metrics(rows, world, arm)) + curve.append(point) + write(out / "curve.json", curve) + print(json.dumps(dict(seed=seed, arm=arm, **point)), flush=True) + if step == cfg["steps"]: + break + decay = 0.5 * ( + 1 + + math.cos( + math.pi * max(0, step - cfg["warmup_steps"]) / (cfg["steps"] - cfg["warmup_steps"]) + ) + ) + lr = ( + cfg["minimum_learning_rate"] + + (cfg["learning_rate"] - cfg["minimum_learning_rate"]) * decay + ) * min(1.0, (step + 1) / cfg["warmup_steps"]) + for group in optimizer.param_groups: + group["lr"] = lr + docs = docs_for(rec, batches[step]) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + inputs = base.batch_tensors(docs, tokenizer.pad_token_id, cfg["device"]) + model.train() + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = stream_loss(model, inputs, cfg["atomic_per_step"], cfg["atomic_loss_weight"]) + assert torch.isfinite(loss) + loss.backward() + if step == 0: + assert all( + p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all() + for p in model.parameters() + ) + torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 64 == 0: + print( + json.dumps( + dict( + seed=seed, + arm=arm, + step=step + 1, + loss=float(loss.detach()), + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + name: not torch.equal(before, base.parameter_samples(model)[name]) + for name, before in samples.items() + } + assert all(changed.values()) + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + architecture = model.config.to_dict() + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + again = evaluate(load(out / "model"), tokenizer, world, cfg, extras=True) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again] + assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again] + write( + out / "reload-audit.json", + dict( + status="passed", + predictions=len(again), + exact_generated_tokens=True, + exact_autonomous_prompts=True, + ), + ) + assert dict(budget) == base.read(art / "data-audit.json")["budgets"][arm] + d, layers = architecture["hidden_size"], architecture["num_hidden_layers"] + query_width = architecture["num_attention_heads"] * architecture["head_dim"] + kv = architecture["num_key_value_heads"] * architecture["head_dim"] + per_token = ( + layers * (2 * d * query_width + 2 * d * kv + 3 * d * architecture["intermediate_size"]) + + d * architecture["vocab_size"] + ) + flops = ( + 6 * per_token * budget["padded_tokens"] + + 12 * layers * query_width * budget["attention_cells"] + ) + summary = dict( + status="complete", + phase=cfg["phase"], + utc=base.now(), + world_seed=seed, + arm=arm, + metrics=metrics(final_rows, world, arm), + updates=cfg["steps"], + budget=dict(budget), + train_seconds=train_seconds, + process_seconds=time.perf_counter() - started, + estimated_training_matrix_flops=flops, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + parameter_count=parameter_count, + sampled_parameters_changed=changed, + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + tf32=False, + lock_sha256=sha(Path(cfg["artifact_root"]) / "lock.json"), + checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + write(out / "summary.json", summary) + write(out / "status.json", dict(status="complete", utc=base.now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + cfg = base.read(config_path) + check_lock(cfg) + runs, checks = {}, 0 + for seed in cfg["world_seeds"]: + world = base.read(Path(cfg["artifact_root"]) / f"w{seed}" / "world.json") + for arm in cfg["arms"]: + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + summary = base.read(out / "summary.json") + assert base.read(out / "reload-audit.json")["status"] == "passed" + for point in base.read(out / "curve.json"): + rows = base.read(out / f"predictions-{point['step']:05d}.json") + assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows) + assert point["metrics"] == metrics(rows, world, arm) + checks += len(rows) + assert summary["metrics"] == metrics(rows, world, arm) + runs[f"w{seed}-{arm}"] = summary + differences = {} + if len(cfg["arms"]) == 2: + for seed in cfg["world_seeds"]: + diff = {} + for key in runs[f"w{seed}-high"]["metrics"]: + high, low = [runs[f"w{seed}-{a}"]["metrics"][key] for a in ("high", "low")] + if key.endswith("both_atomic") or "training" in key: + continue + diff[key] = high["correct"] / high["n"] - low["correct"] / low["n"] + differences[str(seed)] = diff + write( + Path(cfg["artifact_root"]) / "summary.json", + dict( + status="complete", + phase=cfg["phase"], + independent_worlds=len(cfg["world_seeds"]), + training_initializations=1, + runs=runs, + per_world_high_minus_low=differences, + independent_node_prediction_checks=checks, + total_updates=sum(r["updates"] for r in runs.values()), + total_train_seconds=sum(r["train_seconds"] for r in runs.values()), + total_process_seconds=sum(r["process_seconds"] for r in runs.values()), + ), + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("action", choices=("freeze", "run", "report")) + parser.add_argument("--config", required=True) + parser.add_argument("--world", type=int) + parser.add_argument("--arm", choices=("low", "high")) + args = parser.parse_args() + if args.action == "run": + run(args.config, args.world, args.arm) + elif args.action == "freeze": + freeze(args.config) + else: + report(args.config) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py new file mode 100644 index 0000000000000000000000000000000000000000..d8e949ff27eac75a758644d6a7ffd81f2a9477ea --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py @@ -0,0 +1,687 @@ +"""Full-Qwen, nested compositional support with matched atomic supervision.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import platform +import shutil +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch +import torch.nn.functional as F +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +from . import small_lm_composition as base + +FIRST = ("mentor", "advisor") +SECOND = ("live", "birth") +STRICT_CITIES = ( + "Athens Prague Havana Tunis Perth Zurich Bristol Munich " + "Tallinn Riga Quito Dakar Nairobi Accra Calgary Warsaw" +).split() +ROOT = Path("docs/development-artifacts/natural-composition-confirmation-v1") + + +def sha(path): + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def write(path, value): + base.write(path, value) + + +def build_world(seed): + rng = np.random.default_rng(seed) + first_names = ( + "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo" + ).split() + names = [ + f"{a} {b}" + for a in first_names + for b in "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split() + ] + names = rng.permutation(names).tolist() + atoms, chains = [], [] + for pool, offset, cities in (("familiar", 0, base.CITIES), ("strict", 32, STRICT_CITIES)): + heads, bridges = names[offset : offset + 16], names[offset + 16 : offset + 32] + mappings = [rng.permutation(16).tolist()] + mappings.append(np.roll(mappings[0], int(rng.choice(np.arange(2, 16, 2)))).tolist()) + city_maps = [rng.permutation(cities).tolist()] + city_maps.append(np.roll(city_maps[0], int(rng.integers(1, 16))).tolist()) + ids = {} + for j, head in enumerate(heads): + for r, relation in enumerate(FIRST): + atom = dict( + id=len(atoms), + pool=pool, + role="first", + subject=head, + relation=relation, + answer=bridges[mappings[r][j]], + ) + atoms.append(atom) + ids["first", j, r] = atom["id"] + for j, bridge in enumerate(bridges): + for s, relation in enumerate(SECOND): + atom = dict( + id=len(atoms), + pool=pool, + role="second", + subject=bridge, + relation=relation, + answer=city_maps[s][j], + ) + atoms.append(atom) + ids["second", j, s] = atom["id"] + for j, head in enumerate(heads): + for r, first in enumerate(FIRST): + for s, second in enumerate(SECOND): + bridge_index = mappings[r][j] + chains.append( + dict( + id=len(chains), + pool=pool, + head_index=j, + head=head, + bridge=bridges[bridge_index], + first=first, + second=second, + answer=city_maps[s][bridge_index], + atom_ids=[ids["first", j, r], ids["second", bridge_index, s]], + split="strict" + if pool == "strict" + else ("support" if s == (r ^ (j % 2)) else "heldout"), + ) + ) + return dict( + seed=seed, + atoms=atoms, + chains=chains, + high_support=[c["id"] for c in chains if c["split"] == "support"], + low_support=[c["id"] for c in chains if c["split"] == "support" and c["head_index"] < 4], + ) + + +def question(row, variant=0, atomic=False): + if atomic: + subject, relation = row["subject"], row["relation"] + if row["role"] == "first": + templates = ( + "Who is {subject}'s {relation}?", + "Who is the {relation} of {subject}?", + "Name the {relation} of {subject}.", + "Give the name of {subject}'s {relation}.", + "Give the name of the person serving as {subject}'s {relation}.", + ) + elif relation == "live": + templates = ( + "Which city does {subject} live in?", + "What city is {subject}'s home?", + "Where does {subject} live?", + "Name the city where {subject} lives.", + "In which city is {subject} living?", + ) + else: + templates = ( + "Which city was {subject} born in?", + "What is {subject}'s birth city?", + "Where was {subject} born?", + "Name the city where {subject} was born.", + "In which city did {subject}'s birth take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + subject = row["head"] + relation = row["first"] + if row["second"] == "live": + templates = ( + "Which city does {subject}'s {relation} live in?", + "What city is home to {subject}'s {relation}?", + "Where does the {relation} of {subject} live?", + "Name the city where {subject}'s {relation} lives.", + "In which city is the person serving as {subject}'s {relation} living?", + ) + else: + templates = ( + "Which city was {subject}'s {relation} born in?", + "What is the birth city of {subject}'s {relation}?", + "Where was the {relation} of {subject} born?", + "Name the city where {subject}'s {relation} was born.", + "In which city did the birth of {subject}'s {relation} take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + + +def prompt(row, variant=0, atomic=False): + return "Fictional registry.\nQuestion: " + question(row, variant, atomic) + "\nAnswer:" + + +def record(tokenizer, row, variant, atomic): + # Joint text tokenization, exactly as in the calibrated full-Qwen v2 recipe. + ids = tokenizer.encode( + prompt(row, variant, atomic) + " " + row["answer"] + ".", add_special_tokens=False + ) + [tokenizer.eos_token_id] + return dict( + ids=ids, + labels=[-100, *ids[1:]], + id=row["id"], + kind="atomic" if atomic else "composition", + variant=variant, + ) + + +def streams(world, cfg): + rng = np.random.default_rng(cfg["training_seed"]) + atomic_order, comp_order = [], {a: [] for a in cfg["arms"]} + batches = {a: [] for a in cfg["arms"]} + for _ in range(cfg["steps"]): + if len(atomic_order) < cfg["atomic_per_step"]: + atomic_order.extend(rng.permutation(len(world["atoms"])).tolist()) + atomic = [ + [int(atomic_order.pop(0)), int(rng.integers(4))] for _ in range(cfg["atomic_per_step"]) + ] + variants = rng.integers(4, size=cfg["compositions_per_step"]).tolist() + for arm in cfg["arms"]: + support = world[arm + "_support"] + if len(comp_order[arm]) < cfg["compositions_per_step"]: + comp_order[arm].extend(rng.permutation(support).tolist()) + comp = [[int(comp_order[arm].pop(0)), int(v)] for v in variants] + batches[arm].append(dict(atomic=atomic, composition=comp)) + return batches + + +def records(tokenizer, world): + return { + kind: { + (r["id"], v): record(tokenizer, r, v, kind == "atomic") + for r in world["atoms" if kind == "atomic" else "chains"] + for v in range(4) + } + for kind in ("atomic", "composition") + } + + +def docs_for(rec, batch): + return [rec[kind][tuple(spec)] for kind in ("atomic", "composition") for spec in batch[kind]] + + +def audit(world, batches, rec): + assert ( + len(world["atoms"]) == 128 + and len(world["high_support"]) == 32 + and len(world["low_support"]) == 8 + ) + assert set(world["low_support"]) < set(world["high_support"]) + familiar_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "familiar"} + covered = {i for j in world["high_support"] for i in world["chains"][j]["atom_ids"]} + assert covered == familiar_atoms + strict_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "strict"} + assert not covered & strict_atoms + support = [world["chains"][i] for i in world["high_support"]] + heldout = [c for c in world["chains"] if c["split"] == "heldout"] + strict = [c for c in world["chains"] if c["split"] == "strict"] + assert len(heldout) == 32 and len(strict) == 64 + # No alternate trained query gives the same head/answer endpoint as a held-out chain. + assert not {(c["head"], c["answer"]) for c in support} & { + (c["head"], c["answer"]) for c in heldout + } + + def people(pool): + return {a["subject"] for a in world["atoms"] if a["pool"] == pool} + + assert not people("familiar") & people("strict") + assert not {c["answer"] for c in support} & {c["answer"] for c in strict} + budgets, exposure = {}, {} + for arm, stream in batches.items(): + budget, atomic_counts, comp_counts = Counter(), Counter(), Counter() + for batch in stream: + docs = docs_for(rec, batch) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + atomic_counts.update(i for i, _ in batch["atomic"]) + comp_counts.update(i for i, _ in batch["composition"]) + assert set(comp_counts) <= set(world[arm + "_support"]) + budgets[arm] = dict(budget) + exposure[arm] = dict( + atomic=sorted(atomic_counts.items()), composition=sorted(comp_counts.items()) + ) + if "low" in batches and "high" in batches: + assert [b["atomic"] for b in batches["low"]] == [b["atomic"] for b in batches["high"]] + assert exposure["low"]["atomic"] == exposure["high"]["atomic"] + return dict( + status="passed", + budgets=budgets, + exposures=exposure, + familiar_fact_role_coverage_high=len(covered), + familiar_fact_role_coverage_low=len( + {i for j in world["low_support"] for i in world["chains"][j]["atom_ids"]} + ), + heldout_queries=len(heldout), + strict_queries=len(strict), + target_endpoint_leakage=0, + exact_common_atomic_sequence=True, + exact_atomic_stream_loss_weight=True, + composition_slots_equal=True, + ) + + +def freeze(config_path): + cfg = base.read(config_path) + art = Path(cfg["artifact_root"]) + assert not (art / "lock.json").exists(), "Preserve frozen batch." + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + sources = [ + str(config_path), + "src/llm_memory_editability/natural_composition_confirmation_v2.py", + "src/llm_memory_editability/small_lm_composition.py", + "scripts/run_natural_composition_confirmation_v2.py", + "tests/test_natural_composition_confirmation_v2.py", + "docs/development-artifacts/natural-composition-confirmation-v1/amendment-v2.md", + ] + source_hashes = {} + for source in sources: + dest = art / "source" / source + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, dest) + source_hashes[source] = sha(source) + data_files = {} + for seed in cfg["world_seeds"]: + world = build_world(seed) + batch = streams(world, cfg) + report = audit(world, batch, records(tokenizer, world)) + for filename, obj in ( + ("world.json", world), + ("streams.json", batch), + ("data-audit.json", report), + ): + path = art / f"w{seed}" / filename + write(path, obj) + data_files[str(path)] = sha(path) + model_files = { + str(p): sha(p) + for p in Path(cfg["model_path"]).iterdir() + if p.suffix in (".json", ".safetensors") or p.name in ("LICENSE", "README.md") + } + write( + art / "environment.json", + dict( + python=platform.python_version(), + executable=str(Path(__import__("sys").executable)), + torch=torch.__version__, + transformers=transformers.__version__, + gpu_inventory=__import__("subprocess").check_output( + ["nvidia-smi", "--query-gpu=index,name,memory.used,memory.total", "--format=csv"], + text=True, + ), + ), + ) + write( + art / "lock.json", + dict( + status="locked_before_training", + utc=base.now(), + sources=source_hashes, + data_files=data_files, + model_files=model_files, + config=cfg, + ), + ) + print( + json.dumps(dict(status="frozen", worlds=cfg["world_seeds"], arms=cfg["arms"])), flush=True + ) + + +def check_lock(cfg): + lock = base.read(Path(cfg["artifact_root"]) / "lock.json") + for group in ("sources", "data_files", "model_files"): + for path, digest in lock[group].items(): + assert sha(path) == digest, path + + +def evaluation_rows(world, extras=False): + rows = [] + for view in (0, 4) if extras else (0,): + for atom in world["atoms"]: + rows.append(dict(atom, mode="atomic", view=view, prompt=prompt(atom, view, True))) + for chain in world["chains"]: + rows.append(dict(chain, mode="direct", view=view, prompt=prompt(chain, view))) + return rows + + +@torch.inference_mode() +def generate(model, tokenizer, rows, cfg): + model.eval() + tokenizer.padding_side = "left" + output = [] + for start in range(0, len(rows), cfg["eval_batch"]): + chunk = rows[start : start + cfg["eval_batch"]] + inputs = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(cfg["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + tokens = model.generate( + **inputs, + do_sample=False, + max_new_tokens=cfg["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, inputs.input_ids.shape[1] :] + for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True): + if tokenizer.eos_token_id in tok: + tok = tok[: tok.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tok, skip_special_tokens=True) + output.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"]))) + return output + + +def evaluate(model, tokenizer, world, cfg, extras=False): + direct = generate(model, tokenizer, evaluation_rows(world, extras), cfg) + if not extras: + return direct + atoms = {a["id"]: a for a in world["atoms"]} + lookup = {(r["id"], r["view"]): r for r in direct if r["mode"] == "atomic"} + second_calls = [] + for row in direct: + if row["mode"] != "direct": + continue + first = lookup[row["atom_ids"][0], row["view"]] + generated_bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip() + second = dict(atoms[row["atom_ids"][1]], subject=generated_bridge) + second_calls.append( + dict( + row, + mode="autonomous", + prompt=prompt(second, row["view"], True), + generated_bridge=generated_bridge, + first_tokens=first["tokens"], + first_correct=first["correct"], + ) + ) + return direct + generate(model, tokenizer, second_calls, cfg) + + +def metrics(rows, world, arm): + result = {} + for view in sorted({r["view"] for r in rows}): + atomic = {r["id"]: r for r in rows if r["view"] == view and r["mode"] == "atomic"} + for pool in ("familiar", "strict"): + for role in ("first", "second"): + selected = [r for r in atomic.values() if r["pool"] == pool and r["role"] == role] + result[f"v{view}_{pool}_{role}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + for split in ("heldout", "strict", "training"): + ids = ( + set(world[arm + "_support"]) + if split == "training" + else {c["id"] for c in world["chains"] if c["split"] == split} + ) + for mode in ("direct", "autonomous"): + selected = [ + r for r in rows if r["view"] == view and r["mode"] == mode and r["id"] in ids + ] + if selected: + result[f"v{view}_{split}_{mode}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + mastered = [ + r for r in selected if all(atomic[i]["correct"] for i in r["atom_ids"]) + ] + result[f"v{view}_{split}_{mode}_both_atomic"] = dict( + correct=sum(r["correct"] for r in mastered), + n=len(mastered), + full_n=len(selected), + ) + return result + + +def stream_loss(model, inputs, atomic_count, atomic_weight): + logits = model( + input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], use_cache=False + ).logits[:, :-1] + labels = inputs["labels"][:, 1:] + losses = F.cross_entropy( + logits.float().reshape(-1, logits.shape[-1]), + labels.reshape(-1), + reduction="none", + ignore_index=-100, + ).reshape_as(labels) + atomic = losses[:atomic_count].sum() / (labels[:atomic_count] != -100).sum() + comp = losses[atomic_count:].sum() / (labels[atomic_count:] != -100).sum() + return atomic_weight * atomic + (1 - atomic_weight) * comp + + +def run(config_path, seed, arm): + cfg = base.read(config_path) + check_lock(cfg) + assert seed in cfg["world_seeds"] and arm in cfg["arms"] + art = Path(cfg["artifact_root"]) / f"w{seed}" + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + assert not (out / "status.json").exists(), "Preserve existing execution." + world, batches = base.read(art / "world.json"), base.read(art / "streams.json")[arm] + write(out / "status.json", dict(status="running", utc=base.now())) + started = time.perf_counter() + torch.set_num_threads(cfg["cpu_threads"]) + torch.manual_seed(cfg["training_seed"]) + torch.cuda.set_device(cfg["device"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + + def load(path): + return AutoModelForCausalLM.from_pretrained( + path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True + ).to(cfg["device"]) + + model = load(cfg["model_path"]) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + model.requires_grad_(True) + samples = base.parameter_samples(model) + parameter_count = sum(p.numel() for p in model.parameters()) + rec = records(tokenizer, world) + optimizer = torch.optim.AdamW( + model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"], fused=True + ) + curve, budget, train_seconds = [], Counter(), 0.0 + for step in range(cfg["steps"] + 1): + if step in cfg["nodes"]: + rows = evaluate(model, tokenizer, world, cfg, extras=step == cfg["steps"]) + write(out / f"predictions-{step:05d}.json", rows) + point = dict(step=step, metrics=metrics(rows, world, arm)) + curve.append(point) + write(out / "curve.json", curve) + print(json.dumps(dict(seed=seed, arm=arm, **point)), flush=True) + if step == cfg["steps"]: + break + decay = 0.5 * ( + 1 + + math.cos( + math.pi * max(0, step - cfg["warmup_steps"]) / (cfg["steps"] - cfg["warmup_steps"]) + ) + ) + lr = ( + cfg["minimum_learning_rate"] + + (cfg["learning_rate"] - cfg["minimum_learning_rate"]) * decay + ) * min(1.0, (step + 1) / cfg["warmup_steps"]) + for group in optimizer.param_groups: + group["lr"] = lr + docs = docs_for(rec, batches[step]) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + inputs = base.batch_tensors(docs, tokenizer.pad_token_id, cfg["device"]) + model.train() + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = stream_loss(model, inputs, cfg["atomic_per_step"], cfg["atomic_loss_weight"]) + assert torch.isfinite(loss) + loss.backward() + if step == 0: + assert all( + p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all() + for p in model.parameters() + ) + torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 64 == 0: + print( + json.dumps( + dict( + seed=seed, + arm=arm, + step=step + 1, + loss=float(loss.detach()), + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + name: not torch.equal(before, base.parameter_samples(model)[name]) + for name, before in samples.items() + } + assert all(changed.values()) + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + architecture = model.config.to_dict() + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + again = evaluate(load(out / "model"), tokenizer, world, cfg, extras=True) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again] + assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again] + write( + out / "reload-audit.json", + dict( + status="passed", + predictions=len(again), + exact_generated_tokens=True, + exact_autonomous_prompts=True, + ), + ) + assert dict(budget) == base.read(art / "data-audit.json")["budgets"][arm] + d, layers = architecture["hidden_size"], architecture["num_hidden_layers"] + query_width = architecture["num_attention_heads"] * architecture["head_dim"] + kv = architecture["num_key_value_heads"] * architecture["head_dim"] + per_token = ( + layers * (2 * d * query_width + 2 * d * kv + 3 * d * architecture["intermediate_size"]) + + d * architecture["vocab_size"] + ) + flops = ( + 6 * per_token * budget["padded_tokens"] + + 12 * layers * query_width * budget["attention_cells"] + ) + summary = dict( + status="complete", + phase=cfg["phase"], + utc=base.now(), + world_seed=seed, + arm=arm, + metrics=metrics(final_rows, world, arm), + updates=cfg["steps"], + budget=dict(budget), + train_seconds=train_seconds, + process_seconds=time.perf_counter() - started, + estimated_training_matrix_flops=flops, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + parameter_count=parameter_count, + sampled_parameters_changed=changed, + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + tf32=False, + lock_sha256=sha(Path(cfg["artifact_root"]) / "lock.json"), + checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + write(out / "summary.json", summary) + write(out / "status.json", dict(status="complete", utc=base.now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + cfg = base.read(config_path) + check_lock(cfg) + runs, checks = {}, 0 + for seed in cfg["world_seeds"]: + world = base.read(Path(cfg["artifact_root"]) / f"w{seed}" / "world.json") + for arm in cfg["arms"]: + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + summary = base.read(out / "summary.json") + assert base.read(out / "reload-audit.json")["status"] == "passed" + for point in base.read(out / "curve.json"): + rows = base.read(out / f"predictions-{point['step']:05d}.json") + assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows) + assert point["metrics"] == metrics(rows, world, arm) + checks += len(rows) + assert summary["metrics"] == metrics(rows, world, arm) + runs[f"w{seed}-{arm}"] = summary + differences = {} + if len(cfg["arms"]) == 2: + for seed in cfg["world_seeds"]: + diff = {} + for key in runs[f"w{seed}-high"]["metrics"]: + high, low = [runs[f"w{seed}-{a}"]["metrics"][key] for a in ("high", "low")] + if key.endswith("both_atomic") or "training" in key: + continue + diff[key] = high["correct"] / high["n"] - low["correct"] / low["n"] + differences[str(seed)] = diff + write( + Path(cfg["artifact_root"]) / "summary.json", + dict( + status="complete", + phase=cfg["phase"], + independent_worlds=len(cfg["world_seeds"]), + training_initializations=1, + runs=runs, + per_world_high_minus_low=differences, + independent_node_prediction_checks=checks, + total_updates=sum(r["updates"] for r in runs.values()), + total_train_seconds=sum(r["train_seconds"] for r in runs.values()), + total_process_seconds=sum(r["process_seconds"] for r in runs.values()), + ), + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("action", choices=("freeze", "run", "report")) + parser.add_argument("--config", required=True) + parser.add_argument("--world", type=int) + parser.add_argument("--arm", choices=("low", "high")) + args = parser.parse_args() + if args.action == "run": + run(args.config, args.world, args.arm) + elif args.action == "freeze": + freeze(args.config) + else: + report(args.config) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural.py new file mode 100644 index 0000000000000000000000000000000000000000..ce1f02e8195f4e583817b3781b044f021a41fbfb --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural.py @@ -0,0 +1,328 @@ +"""Controlled nonlinear memory editing with full old-fact replay on CPU. + +This measures finite-budget optimization, not minimum representational capacity. +The data generator's shared rule does not establish the model's internal mechanism. +""" + +import argparse +import copy +import json +import math +import platform +import statistics +import subprocess +import time +from dataclasses import asdict, dataclass +from pathlib import Path + +import numpy as np + +try: + import torch + from torch import nn + from torch.nn import functional as F +except ModuleNotFoundError as exc: + raise SystemExit("Neural experiments require PyTorch: pip install '.[neural]'") from exc + +from .neural_data import make_world +from .neural_models import build_model, edit_parameters + + +@dataclass(frozen=True) +class NeuralConfig: + model: str = "mlp" + seeds: tuple[int, ...] = (0, 1, 2) + data_seed: int = 0 + entities: int = 24 + attributes: int = 8 + groups: int = 3 + answers: int = 4 + width: int = 32 + hidden: int = 64 + layers: int = 2 + heads: int = 4 + pretrain_steps: int = 400 + edit_steps: int = 100 + scratch_steps: int = 400 + lr: float = 0.01 + retention_weight: float = 1.0 + edit_scope: str = "ffn" + eval_every: int = 10 + success_threshold: float = 0.95 + threads: int = 1 + + def validate(self) -> None: + if self.model not in {"mlp", "transformer"} or self.edit_scope not in {"ffn", "all"}: + raise ValueError("unsupported model or edit scope") + for name in ("pretrain_steps", "edit_steps", "scratch_steps", "eval_every", "threads"): + value = getattr(self, name) + if isinstance(value, bool) or not isinstance(value, int) or value < 1: + raise ValueError(f"{name} must be a positive integer") + if not self.seeds or len(set(self.seeds)) != len(self.seeds): + raise ValueError("seeds must be nonempty and unique") + if any(isinstance(s, bool) or not isinstance(s, int) or s < 0 for s in self.seeds): + raise ValueError("seeds must be nonnegative integers") + if not math.isfinite(self.lr) or self.lr <= 0: + raise ValueError("lr must be finite and positive") + if not math.isfinite(self.retention_weight) or self.retention_weight < 0: + raise ValueError("retention_weight must be finite and nonnegative") + if not 0 < self.success_threshold <= 1: + raise ValueError("success_threshold must be in (0, 1]") + + +@torch.no_grad() +def evaluate(model: nn.Module, x: torch.Tensor, y: torch.Tensor, mask: torch.Tensor) -> dict: + """Evaluate answers against a target world, separating edits and retained facts.""" + model.eval() + logits = model(x) + if not torch.isfinite(logits).all(): + raise ValueError("non-finite model outputs") + correct = logits.argmax(dim=-1).eq(y).float() + target_logits = logits.gather(1, y[:, None]).squeeze(1) + competitors = logits.clone().scatter_(1, y[:, None], float("-inf")).max(dim=1).values + margins = target_logits - competitors + return { + "all_accuracy": correct.mean().item(), + "edit_accuracy": correct[mask].mean().item(), + "retain_accuracy": correct[~mask].mean().item(), + "edit_target_nll": F.cross_entropy(logits[mask], y[mask]).item(), + "edit_margin": margins[mask].mean().item(), + "retain_margin": margins[~mask].mean().item(), + } + + +def fit( + model: nn.Module, + x: torch.Tensor, + y: torch.Tensor, + mask: torch.Tensor, + *, + steps: int, + config: NeuralConfig, + is_edit: bool = False, +) -> dict: + """Use a fresh optimizer, fixed steps, and a documented full-batch objective.""" + parameters = [p for p in model.parameters() if p.requires_grad] + optimizer = torch.optim.Adam(parameters, lr=config.lr) + history = [] + first_success = None + started = time.perf_counter() + for step in range(steps + 1): + if step % config.eval_every == 0 or step == steps: + metrics = evaluate(model, x, y, mask) + history.append({"step": step, **metrics}) + if ( + first_success is None + and min(metrics["edit_accuracy"], metrics["retain_accuracy"]) + >= config.success_threshold + ): + first_success = step + if step == steps: + break + model.train() + optimizer.zero_grad(set_to_none=True) + logits = model(x) + if is_edit: + loss = F.cross_entropy(logits[mask], y[mask]) + if config.retention_weight: + loss = loss + config.retention_weight * F.cross_entropy(logits[~mask], y[~mask]) + else: + loss = F.cross_entropy(logits, y) + if not torch.isfinite(loss): + raise ValueError("training diverged to a non-finite loss") + loss.backward() + optimizer.step() + return { + "steps": steps, + "trainable_parameters": sum(p.numel() for p in parameters), + "first_success_step": first_success, + "elapsed_seconds": time.perf_counter() - started, + "history": history, + "objective": "edit_ce + retention_weight * retained_ce" if is_edit else "full_world_ce", + } + + +def _summary(runs: list[dict]) -> dict: + eligible = [run for run in runs if run["baseline_quality_passed"]] + result = {"eligible_seeds": [run["seed"] for run in eligible], "cases": {}} + for name in ("rule", "exception"): + result["cases"][name] = {} + for metric in ("edit_accuracy", "retain_accuracy"): + values = [run["cases"][name]["after"][metric] for run in eligible] + result["cases"][name][metric] = { + "mean": statistics.mean(values) if values else None, + "sample_std": statistics.stdev(values) if len(values) > 1 else None, + "n": len(values), + } + return result + + +def _revision() -> str | None: + """Best-effort source revision; an installed wheel may not have a checkout.""" + source_root = Path(__file__).resolve().parents[2] + if not (source_root / ".git").exists(): + return None + try: + revision = subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=source_root, text=True, stderr=subprocess.DEVNULL + ).strip() + dirty = subprocess.check_output( + ["git", "status", "--porcelain"], cwd=source_root, text=True + ).strip() + return revision + ("+dirty" if dirty else "") + except (OSError, subprocess.CalledProcessError): + return None + + +def run_experiment(config: NeuralConfig) -> dict: + config.validate() + world = make_world( + n_entities=config.entities, + n_attributes=config.attributes, + n_groups=config.groups, + n_answers=config.answers, + seed=config.data_seed, + ) + torch.set_num_threads(config.threads) + torch.use_deterministic_algorithms(True) + x = torch.as_tensor(world.x, dtype=torch.long) + original = torch.as_tensor(world.original, dtype=torch.long) + mask = torch.as_tensor(world.edit_mask, dtype=torch.bool) + runs = [] + for seed in config.seeds: + torch.manual_seed(seed) + initial = build_model( + config.model, + config.entities, + config.attributes, + config.answers, + width=config.width, + hidden=config.hidden, + layers=config.layers, + heads=config.heads, + ) + base = copy.deepcopy(initial) + baseline_training = fit( + base, + x, + original, + mask, + steps=config.pretrain_steps, + config=config, + ) + baseline = evaluate(base, x, original, mask) + run = { + "seed": seed, + "parameter_count": sum(p.numel() for p in base.parameters()), + "baseline": baseline, + "baseline_quality_passed": min(baseline["edit_accuracy"], baseline["retain_accuracy"]) + >= config.success_threshold, + "baseline_training": baseline_training, + "cases": {}, + } + for name in ("rule", "exception"): + target = torch.as_tensor(getattr(world, name), dtype=torch.long) + edited = copy.deepcopy(base) + edit_parameters(edited, scope=config.edit_scope) + before = evaluate(edited, x, target, mask) + edit_training = fit( + edited, + x, + target, + mask, + steps=config.edit_steps, + config=config, + is_edit=True, + ) + scratch = copy.deepcopy(initial) + scratch_training = fit( + scratch, + x, + target, + mask, + steps=config.scratch_steps, + config=config, + ) + run["cases"][name] = { + "before": before, + "after": evaluate(edited, x, target, mask), + "scratch": evaluate(scratch, x, target, mask), + "edit_training": edit_training, + "scratch_training": scratch_training, + } + runs.append(run) + return { + "experiment": "nonlinear_synthetic_memory_editing", + "config": asdict(config), + "versions": { + "python": platform.python_version(), + "numpy": np.__version__, + "torch": torch.__version__, + }, + "revision": _revision(), + "device": "cpu", + "world": world.to_metadata(), + "protocol": { + "paired_edit_initialization": "identical trained checkpoint; fresh Adam per case", + "paired_scratch_initialization": "identical untrained initialization; all parameters", + "replay": "all retained facts available; uniform CE within each edit/retain subset", + "success": "both edit and retain accuracy >= threshold at evaluation checkpoints", + "summary_filter": "only seeds passing baseline threshold on both subsets", + "limits": [ + "Target surprisal is measured, not matched.", + "Generator structure is not a measure of learned neural degrees of freedom.", + "Scratch failure at finite budget is not an impossibility result.", + "Scratch trains all parameters; FFN-only edit failures may reflect " + "a restricted update space.", + "No natural-language paraphrases or pretrained LLM are evaluated.", + "Cross-platform and cross-version bitwise reproducibility is not guaranteed.", + ], + }, + "runs": runs, + "summary": _summary(runs), + } + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--model", choices=("mlp", "transformer"), default="mlp") + parser.add_argument("--seeds", type=int, nargs="+", default=[0, 1, 2]) + parser.add_argument("--edit-scope", choices=("ffn", "all"), default="ffn") + defaults = asdict(NeuralConfig()) + for name in ( + "data_seed", + "entities", + "attributes", + "groups", + "answers", + "width", + "hidden", + "layers", + "heads", + "pretrain_steps", + "edit_steps", + "scratch_steps", + "eval_every", + "threads", + ): + parser.add_argument("--" + name.replace("_", "-"), type=int, default=defaults[name]) + for name in ("lr", "retention_weight", "success_threshold"): + parser.add_argument("--" + name.replace("_", "-"), type=float, default=defaults[name]) + parser.add_argument("--output", type=Path, help="save the same JSON printed to stdout") + args = vars(parser.parse_args(argv)) + output = args.pop("output") + args["seeds"] = tuple(args["seeds"]) + try: + report = run_experiment(NeuralConfig(**args)) + serialized = json.dumps(report, ensure_ascii=False, indent=2, allow_nan=False) + if output: + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text(serialized + "\n", encoding="utf-8") + except (ValueError, OSError) as exc: + parser.error(str(exc)) + print(serialized) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_data.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_data.py new file mode 100644 index 0000000000000000000000000000000000000000..555b2a06a7db0805d441a3f8f89bc2100deaa72a --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_data.py @@ -0,0 +1,147 @@ +"""Balanced fact-table interventions, defined independently of model training.""" + +from dataclasses import dataclass +from typing import Any + +import numpy as np + + +@dataclass(frozen=True) +class SyntheticWorld: + """All entity/attribute queries and two interventions on identical support.""" + + x: np.ndarray + original: np.ndarray + rule: np.ndarray + exception: np.ndarray + edit_mask: np.ndarray + group_ids: np.ndarray + n_entities: int + n_attributes: int + n_groups: int + n_answers: int + seed: int + + def task_exceptions(self, labels: np.ndarray) -> int: + """Minimum overrides of a group+attribute table; not neural model degrees of freedom.""" + labels = np.asarray(labels) + if labels.shape != self.original.shape: + raise ValueError("labels must contain one answer per fact") + exceptions = 0 + for group in range(self.n_groups): + for attribute in range(self.n_attributes): + cell = labels[(self.group_ids[self.x[:, 0]] == group) & (self.x[:, 1] == attribute)] + exceptions += cell.size - int(np.bincount(cell, minlength=self.n_answers).max()) + return exceptions + + def to_metadata(self) -> dict[str, Any]: + """JSON-compatible task diagnostics, available before training or editing.""" + return { + "n_entities": self.n_entities, + "n_attributes": self.n_attributes, + "n_groups": self.n_groups, + "n_answers": self.n_answers, + "seed": self.seed, + "n_facts": len(self.x), + "n_edited": int(self.edit_mask.sum()), + "edited_entities": np.unique(self.x[self.edit_mask, 0]).tolist(), + "edited_attributes": np.unique(self.x[self.edit_mask, 1]).tolist(), + "matched_controls": [ + "edit support", + "edited fact count", + "entity and attribute coverage", + "per-entity target-answer histograms", + ], + "task_side_group_attribute_exceptions": { + name: self.task_exceptions(getattr(self, name)) + for name in ("original", "rule", "exception") + }, + "structure_metric_scope": ( + "Minimum label overrides of a deterministic group+attribute answer table. " + "This is a task-side generator property, not neural degrees of freedom " + "or evidence that a trained network learned these groups." + ), + } + + +def make_world( + n_entities: int = 24, + n_attributes: int = 8, + n_groups: int = 3, + n_answers: int = 4, + seed: int = 0, +) -> SyntheticWorld: + """Generate balanced labels and conflicting exception patterns in edited group 0. + + Entity targets are independently shuffled, conditioned on changing every edited + fact. The final row is resampled if all entities happen to share one pattern. + Rejection sampling is bounded, including for long attribute tables. + """ + for name, value in { + "n_entities": n_entities, + "n_attributes": n_attributes, + "n_groups": n_groups, + "n_answers": n_answers, + "seed": seed, + }.items(): + if isinstance(value, bool) or not isinstance(value, (int, np.integer)): + raise ValueError(f"{name} must be an integer") + if value < (0 if name == "seed" else 1): + raise ValueError(f"{name} is outside its valid range") + n_entities, n_attributes, n_groups, n_answers, seed = map( + int, + (n_entities, n_attributes, n_groups, n_answers, seed), + ) + if n_groups < 2: + raise ValueError("n_groups must be >= 2 to leave retained facts outside the edit support") + if n_entities % n_groups or n_entities // n_groups < 2: + raise ValueError("n_entities must be divisible by n_groups, with >= 2 entities per group") + if n_answers < 3 or n_attributes % n_answers: + raise ValueError("n_answers must be >= 3 and divide n_attributes") + + rng = np.random.default_rng(seed) + group_ids = np.repeat(np.arange(n_groups), n_entities // n_groups).astype(np.int64) + x = np.column_stack( + ( + np.repeat(np.arange(n_entities), n_attributes), + np.tile(np.arange(n_attributes), n_entities), + ) + ).astype(np.int64) + original = (group_ids[x[:, 0]] + x[:, 1]) % n_answers + edit_mask = group_ids[x[:, 0]] == 0 + rule = original.copy() + rule[edit_mask] = (rule[edit_mask] + 1) % n_answers + exception = original.copy() + # Every edited entity has the same balanced original labels and rule targets. + old_row = original[:n_attributes] + edited_entities = np.flatnonzero(group_ids == 0) + sampled_rows = [] + for row_index, entity in enumerate(edited_entities): + for _ in range(10_000): + candidate = rng.permutation(old_row) + shared_pattern = row_index == len(edited_entities) - 1 and all( + np.array_equal(row, candidate) for row in sampled_rows + ) + if np.all(candidate != old_row) and not shared_pattern: + sampled_rows.append(candidate) + start = entity * n_attributes + exception[start : start + n_attributes] = candidate + break + else: + raise ValueError( + "Could not sample balanced exception patterns in 10,000 attempts; " + "use more answers or fewer attributes to make rejection sampling practical." + ) + return SyntheticWorld( + x, + original, + rule, + exception, + edit_mask, + group_ids, + n_entities, + n_attributes, + n_groups, + n_answers, + seed, + ) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_models.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_models.py new file mode 100644 index 0000000000000000000000000000000000000000..448b3499cdce6fac7d4bcac1e60883f4c383df82 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_models.py @@ -0,0 +1,157 @@ +"""Trainable nonlinear fact models; importing this module requires PyTorch.""" + +import torch +from torch import nn + + +class FactMLP(nn.Module): + """Separate entity/attribute embeddings followed by a nonlinear MLP.""" + + def __init__( + self, + n_entities: int, + n_attributes: int, + n_answers: int, + width: int, + hidden: int, + layers: int, + ) -> None: + super().__init__() + self.entity_embedding = nn.Embedding(n_entities, width) + self.attribute_embedding = nn.Embedding(n_attributes, width) + blocks = [] + for layer in range(layers): + blocks.extend((nn.Linear(2 * width if layer == 0 else hidden, hidden), nn.GELU())) + self.hidden = nn.Sequential(*blocks) + self.answer_head = nn.Linear(hidden, n_answers) + + def forward(self, facts: torch.Tensor) -> torch.Tensor: + _validate_facts(facts) + embedded = torch.cat( + ( + self.entity_embedding(facts[:, 0]), + self.attribute_embedding(facts[:, 1]), + ), + dim=-1, + ) + return self.answer_head(self.hidden(embedded)) + + +class FactTransformer(nn.Module): + """Causal [ENTITY, ATTRIBUTE, QUERY] transformer with an answer classification head.""" + + def __init__( + self, + n_entities: int, + n_attributes: int, + n_answers: int, + width: int, + hidden: int, + layers: int, + heads: int, + ) -> None: + super().__init__() + self.n_entities = n_entities + self.query_id = n_entities + n_attributes + self.token_embedding = nn.Embedding(self.query_id + 1, width) + self.position_embedding = nn.Embedding(3, width) + encoder_layer = nn.TransformerEncoderLayer( + d_model=width, + nhead=heads, + dim_feedforward=hidden, + dropout=0.0, + activation="gelu", + batch_first=True, + norm_first=True, + ) + self.encoder = nn.TransformerEncoder( + encoder_layer, + num_layers=layers, + norm=nn.LayerNorm(width), + enable_nested_tensor=False, + ) + # TransformerEncoder clones its prototype; initialize each layer independently. + for layer in self.encoder.layers: + nn.init.xavier_uniform_(layer.self_attn.in_proj_weight) + for module in layer.modules(): + if isinstance(module, nn.Linear): + nn.init.xavier_uniform_(module.weight) + if module.bias is not None: + nn.init.zeros_(module.bias) + self.answer_head = nn.Linear(width, n_answers) + self.register_buffer("causal_mask", torch.triu(torch.ones(3, 3, dtype=torch.bool), 1)) + + def forward(self, facts: torch.Tensor) -> torch.Tensor: + _validate_facts(facts) + tokens = torch.stack( + ( + facts[:, 0], + facts[:, 1] + self.n_entities, + torch.full_like(facts[:, 0], self.query_id), + ), + dim=1, + ) + embedded = self.token_embedding(tokens) + embedded = embedded + self.position_embedding(torch.arange(3, device=facts.device)) + encoded = self.encoder(embedded, mask=self.causal_mask) + return self.answer_head(encoded[:, -1]) + + +def _validate_facts(facts: torch.Tensor) -> None: + if facts.ndim != 2 or facts.shape[1] != 2 or facts.dtype != torch.long: + raise ValueError("facts must be an int64 tensor with shape (n_facts, 2)") + + +def build_model( + model_type: str, + n_entities: int, + n_attributes: int, + n_answers: int, + width: int = 32, + hidden: int = 64, + layers: int = 2, + heads: int = 4, +) -> nn.Module: + """Construct an MLP or a causal transformer; initialization uses the torch RNG.""" + for name, value in { + "n_entities": n_entities, + "n_attributes": n_attributes, + "n_answers": n_answers, + "width": width, + "hidden": hidden, + "layers": layers, + "heads": heads, + }.items(): + if isinstance(value, bool) or not isinstance(value, int) or value <= 0: + raise ValueError(f"{name} must be a positive integer") + if model_type == "mlp": + return FactMLP(n_entities, n_attributes, n_answers, width, hidden, layers) + if model_type == "transformer": + if width % heads: + raise ValueError("transformer width must be divisible by heads") + return FactTransformer(n_entities, n_attributes, n_answers, width, hidden, layers, heads) + raise ValueError("model_type must be 'mlp' or 'transformer'") + + +def edit_parameters(model: nn.Module, scope: str = "ffn") -> list[nn.Parameter]: + """Freeze outside the chosen edit scope, returning the exact optimizer parameters.""" + if scope not in {"ffn", "all"}: + raise ValueError("scope must be 'ffn' or 'all'") + if scope == "all": + selected = list(model.parameters()) + elif isinstance(model, FactMLP): + selected = list(model.hidden.parameters()) + elif isinstance(model, FactTransformer): + selected = [ + parameter + for layer in model.encoder.layers + for linear in (layer.linear1, layer.linear2) + for parameter in linear.parameters() + ] + else: + raise ValueError("ffn scope requires a FactMLP or FactTransformer") + selected_ids = {id(parameter) for parameter in selected} + for parameter in model.parameters(): + parameter.requires_grad_(id(parameter) in selected_ids) + parameter.grad = None + return selected diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture.py new file mode 100644 index 0000000000000000000000000000000000000000..a254bf6f90931d21d80c57972a6770ad6665c13a --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture.py @@ -0,0 +1,443 @@ +"""Paired GPT-2 architecture extensions for the closed-book memory experiment. + +Dense execution delegates to the historical ReproductionGPT without changing +its numerical path. New modules use an independent, checkpointed initialization +seed; the eight-block reference is always constructed before taking a prefix. +The mHC residual convention is ``output[n] = sum_m H_res[m,n] * input[m]``. +""" + +from __future__ import annotations + +import hashlib +import math +from collections.abc import Sequence + +import torch +from torch import nn +from torch.nn import functional as F +from transformers import GPT2Config +from transformers.models.gpt2.modeling_gpt2 import GPT2MLP + +from .grokking_reproduction import ReproductionGPT + +ARMS = { + "D4": (4, 1, "dense"), + "D8": (8, 1, "dense"), + "L4R2": (4, 2, "dense"), + "M8": (8, 1, "moe"), + "W8": (8, 1, "wide"), + "IHC8": (8, 1, "identity_mhc"), + "HC8": (8, 1, "mhc"), + "M4": (4, 1, "moe"), + "LM4R2": (4, 2, "moe"), +} + + +def sinkhorn(logits: torch.Tensor, iterations: int = 20, eps: float = 1e-6): + """Accepted mHC A.6: initial row softmax, then 20 column normalizations. + + There are 19 intervening row normalizations. This is a finite-iteration + approximation, not an exact doubly stochastic projection. + """ + if iterations < 1: + raise ValueError("Sinkhorn requires at least one iteration") + with torch.autocast(logits.device.type, enabled=False): + matrix = logits.float().softmax(dim=-1) + eps + matrix = matrix / (matrix.sum(dim=-2, keepdim=True) + eps) + for _ in range(iterations - 1): + matrix = matrix / (matrix.sum(dim=-1, keepdim=True) + eps) + matrix = matrix / (matrix.sum(dim=-2, keepdim=True) + eps) + return matrix + + +def residual_mix(streams, matrix): + """Rows are source streams and columns are destination streams.""" + return torch.einsum("...mn,...mc->...nc", matrix, streams) + + +class ControllerRMSNorm(nn.Module): + def __init__(self, width): + super().__init__() + self.weight = nn.Parameter(torch.ones(width)) + + def forward(self, x): + return x * torch.rsqrt(x.square().mean(dim=-1, keepdim=True) + 1e-20) * self.weight + + +class HyperConnection(nn.Module): + """Four-stream pre/post controller with optional constrained residual map.""" + + def __init__(self, width, sublayer_id, streams=4, identity=False): + super().__init__() + self.streams, self.identity = streams, identity + count = 2 * streams + (0 if identity else streams * streams) + self.norm = ControllerRMSNorm(streams * width) + self.projection = nn.Linear(streams * width, count, bias=False) + nn.init.zeros_(self.projection.weight) + self.pre_bias = nn.Parameter(torch.full((streams,), -3.0)) + with torch.no_grad(): + self.pre_bias[sublayer_id % streams] = 3.0 + self.post_bias = nn.Parameter(torch.zeros(streams)) + self.alpha_pre = nn.Parameter(torch.tensor(0.01)) + self.alpha_post = nn.Parameter(torch.tensor(0.01)) + if not identity: + self.res_bias = nn.Parameter(6 * torch.eye(streams) - 3) + self.alpha_res = nn.Parameter(torch.tensor(0.01)) + + def coefficients(self, x): + n = self.streams + with torch.autocast(x.device.type, enabled=False): + dynamic = self.projection(self.norm(x.float().flatten(-2))) + pre = torch.sigmoid(dynamic[..., :n] * self.alpha_pre + self.pre_bias) + 1e-6 + post = 2 * torch.sigmoid(dynamic[..., n : 2 * n] * self.alpha_post + self.post_bias) + res = None + if not self.identity: + logits = dynamic[..., 2 * n :].reshape(*x.shape[:-2], n, n) + res = sinkhorn(logits * self.alpha_res + self.res_bias) + return pre, post, res + + def forward(self, x, sublayer): + pre, post, res = self.coefficients(x) + with torch.autocast(x.device.type, enabled=False): + contracted = (pre[..., None] * x.float()).sum(dim=-2) + y = sublayer(contracted.to(x.dtype)) + with torch.autocast(x.device.type, enabled=False): + residual = x.float() if res is None else residual_mix(x.float(), res) + output = residual + post[..., None] * y.float().unsqueeze(-2) + return output.to(x.dtype) + + +def _initialize_mlp(mlp, initializer_range): + # Eight-block GPT-2 reference residual projection scale, also for loops. + nn.init.normal_(mlp.c_fc.weight, std=initializer_range) + nn.init.normal_(mlp.c_proj.weight, std=initializer_range / math.sqrt(2 * 8)) + nn.init.zeros_(mlp.c_fc.bias) + nn.init.zeros_(mlp.c_proj.bias) + + +class DroplessMoE(nn.Module): + """Top-2 normalized routing, one output dropout, no capacity/token drops.""" + + def __init__(self, config, experts=8, top_k=2): + super().__init__() + self.expert_count, self.top_k = experts, top_k + self.router = nn.Linear(config.n_embd, experts, bias=False) + nn.init.normal_(self.router.weight, std=config.initializer_range) + self.experts = nn.ModuleList() + for _ in range(experts): + expert = GPT2MLP(2 * config.n_embd, config) + expert.dropout = nn.Identity() + _initialize_mlp(expert, config.initializer_range) + self.experts.append(expert) + self.dropout = nn.Dropout(config.resid_pdrop) + + def forward(self, x, valid_mask=None): + flat = x.reshape(-1, x.shape[-1]) + if valid_mask is None: + selected_tokens = torch.arange(len(flat), device=x.device) + else: + selected_tokens = valid_mask.flatten().nonzero(as_tuple=True)[0] + valid = flat.index_select(0, selected_tokens) + with torch.autocast(x.device.type, enabled=False): + probabilities = F.linear(valid.float(), self.router.weight.float()).softmax(-1) + top_weights, expert_ids = probabilities.topk(self.top_k, dim=-1) + weights = top_weights / top_weights.sum(dim=-1, keepdim=True) + # Accumulate selected expert outputs in FP32 for consistent BF16 routing. + combined = torch.zeros_like(valid, dtype=torch.float32) + for expert_id, expert in enumerate(self.experts): + token_ids, slots = (expert_ids == expert_id).nonzero(as_tuple=True) + if token_ids.numel(): + values = expert(valid.index_select(0, token_ids)) + weighted = values.float() * weights[token_ids, slots, None] + combined = combined.index_add(0, token_ids, weighted) + output = torch.zeros_like(flat).index_copy(0, selected_tokens, combined.to(flat.dtype)) + counts = torch.bincount(expert_ids.flatten(), minlength=self.expert_count).detach() + n_valid = probabilities.new_tensor(len(valid)) + stats = { + "assignment_counts": counts, + "probability_sum": probabilities.sum(dim=0), + "valid_tokens": n_valid, + "top_k": self.top_k, + "processed_assignments": counts.sum(), + "dropped_assignments": counts.new_zeros(()), + "entropy_sum": -(probabilities * probabilities.clamp_min(1e-30).log()).sum().detach(), + "selected_mass_sum": top_weights.sum().detach(), + } + return self.dropout(output.view_as(x)), stats + + +def combine_router_fractions(stats_by_microbatch: Sequence[Sequence[dict]]): + """Combine detached counts before a replay that computes exact batch aux. + + Counts are per executed block (thus distinguish Loop passes). Replay must + restore dropout RNG state, so its hard routes equal the counting pass. + """ + if not stats_by_microbatch or not stats_by_microbatch[0]: + return [], 0 + layers = len(stats_by_microbatch[0]) + if any(len(stats) != layers for stats in stats_by_microbatch): + raise ValueError("All microbatches must have the same executed routing layers") + total = sum(stats[0]["valid_tokens"] for stats in stats_by_microbatch) + fractions = [] + for layer in range(layers): + counts = sum(stats[layer]["assignment_counts"] for stats in stats_by_microbatch) + fractions.append( + counts.float() / (total * stats_by_microbatch[0][layer]["top_k"]).clamp_min(1) + ) + return fractions, total + + +def router_balance_loss(stats, assignment_fractions=None, total_valid_tokens=None): + """N * sum(f * p), averaged over executed layers. + + With externally supplied whole-batch fractions and denominator, this returns + the current microbatch's additive contribution to the exact batch objective. + Assignment fractions are discrete and intentionally detached. + """ + if not stats: + return torch.tensor(0.0) + if assignment_fractions is not None and len(assignment_fractions) != len(stats): + raise ValueError("One assignment-fraction vector is required per executed layer") + losses = [] + for index, record in enumerate(stats): + count = record["valid_tokens"] + denominator = count if total_valid_tokens is None else total_valid_tokens + denominator = torch.as_tensor(denominator, device=count.device).clamp_min(1) + fractions = ( + record["assignment_counts"].float() / (count * record["top_k"]).clamp_min(1) + if assignment_fractions is None + else assignment_fractions[index].detach() + ) + probabilities = record["probability_sum"] / denominator + losses.append(probabilities.numel() * (fractions * probabilities).sum()) + return torch.stack(losses).mean() + + +class ParametricGPT(ReproductionGPT): + def __init__(self, config, architecture="D8", module_seed=0): + blocks, repeats, kind = ARMS[architecture] + # Always initialize the same independent eight blocks before slicing. + config.n_layer = 8 + super().__init__(config, repeats=repeats) + self.transformer.h = nn.ModuleList(list(self.transformer.h)[:blocks]) + self.config.n_layer = blocks + self.architecture, self.kind, self.module_seed = architecture, kind, module_seed + with torch.random.fork_rng(devices=[]): + torch.manual_seed(module_seed) + if kind in {"wide", "moe"}: + for block in self.transformer.h: + if kind == "moe": + block.mlp = DroplessMoE(config) + else: + block.mlp = GPT2MLP(16 * config.n_embd, config) + _initialize_mlp(block.mlp, config.initializer_range) + elif kind in {"mhc", "identity_mhc"}: + self.connections = nn.ModuleList( + HyperConnection(config.n_embd, index, identity=kind == "identity_mhc") + for index in range(2 * blocks) + ) + + def _attention(self, block, x): + cfg = self.config + batch, length = x.shape[:2] + q, k, v = block.attn.c_attn(block.ln_1(x)).split(cfg.n_embd, dim=2) + shape = (batch, length, cfg.n_head, cfg.n_embd // cfg.n_head) + q, k, v = (a.view(shape).transpose(1, 2) for a in (q, k, v)) + y = F.scaled_dot_product_attention( + q, k, v, is_causal=True, dropout_p=cfg.attn_pdrop if self.training else 0.0 + ) + y = block.attn.c_proj(y.transpose(1, 2).reshape(batch, length, cfg.n_embd)) + return F.dropout(y, cfg.resid_pdrop, self.training) + + def forward(self, tokens, positions=None, *, valid_mask=None, return_aux=False): + if valid_mask is not None and ( + valid_mask.shape != tokens.shape or valid_mask.dtype != torch.bool + ): + raise ValueError("valid_mask must be boolean and have the tokens' shape") + if self.kind in {"dense", "wide"}: + logits = super().forward(tokens, positions) + if return_aux: + return logits, {"balance_loss": logits.new_zeros(()), "router_stats": []} + return logits + cfg, t = self.config, self.transformer + length = tokens.shape[1] + x = t.wte(tokens) + t.wpe(torch.arange(length, device=tokens.device)) + x = F.dropout(x, cfg.embd_pdrop, self.training) + stats = [] + if self.kind in {"mhc", "identity_mhc"}: + x = x.unsqueeze(-2).expand(-1, -1, 4, -1) + for _ in range(self.repeats): + for index, block in enumerate(t.h): + if self.kind == "moe": + x = x + self._attention(block, x) + y, layer_stats = block.mlp(block.ln_2(x), valid_mask) + x = x + y + stats.append(layer_stats) + else: + x = self.connections[2 * index](x, lambda z, b=block: self._attention(b, z)) + x = self.connections[2 * index + 1](x, lambda z, b=block: b.mlp(b.ln_2(z))) + if self.kind in {"mhc", "identity_mhc"}: + x = x.mean(dim=-2) + x = t.ln_f(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + logits = F.linear(x, t.wte.weight) + if return_aux: + loss = router_balance_loss(stats) if stats else logits.new_zeros(()) + return logits, {"balance_loss": loss, "router_stats": stats} + return logits + + +def construct(config, spec, device): + """Historical config/spec convention, extended by ``spec['architecture']``.""" + architecture = spec["architecture"] + if architecture not in ARMS: + raise ValueError(f"Unknown architecture: {architecture}") + torch.manual_seed(spec["initialization"]) + cfg = GPT2Config( + vocab_size=config["vocab_size"], + n_positions=config.get("positions", 1024), + n_embd=config["hidden_size"], + n_head=config.get("attention_heads", config.get("heads", 12)), + n_layer=8, + resid_pdrop=config["dropout"], + embd_pdrop=config["dropout"], + attn_pdrop=config["dropout"], + activation_function="gelu_new", + use_cache=False, + ) + # Separate reproducible new-shape RNG, explicitly recorded in the manifest. + module_seed = spec.get("module_initialization", spec["initialization"] + 1_000_003) + model = ParametricGPT(cfg, architecture, module_seed) + model.initialization_seed = spec["initialization"] + return model.to(device) + + +def optimizer_for(model, lr, decay): + groups = [{"params": [], "weight_decay": decay}, {"params": [], "weight_decay": 0.0}] + for name, parameter in model.named_parameters(): + if not parameter.requires_grad: + continue + exempt = any(part in name for part in ("bias", "ln")) + exempt |= name.startswith("connections.") and (".norm." in name or ".alpha_" in name) + groups[int(exempt)]["params"].append(parameter) + return torch.optim.AdamW( + groups, lr=lr, betas=(0.9, 0.999), eps=1e-8, fused=next(model.parameters()).is_cuda + ) + + +def parameter_ledger(model): + d, layers = model.config.n_embd, len(model.transformer.h) + total = sum(parameter.numel() for parameter in model.parameters()) + expert = sum(p.numel() for n, p in model.named_parameters() if ".experts." in n) + controller = sum(p.numel() for n, p in model.named_parameters() if n.startswith("connections.")) + router = sum(p.numel() for n, p in model.named_parameters() if ".router." in n) + fixed = (model.config.vocab_size + model.config.n_positions) * d + 2 * d + attention_and_norms = 4 * d * d + 8 * d + if model.kind == "moe": + per_block = attention_and_norms + 8 * (4 * d * d + 3 * d) + 8 * d + else: + width = (16 if model.kind == "wide" else 4) * d + per_block = attention_and_norms + 2 * d * width + width + d + expected_controller = 0 + if model.kind in {"mhc", "identity_mhc"}: + n = 4 + count = 2 * n + (n * n if model.kind == "mhc" else 0) + alphas = 3 if model.kind == "mhc" else 2 + expected_controller = 2 * layers * (n * d * count + n * d + count + alphas) + if controller != expected_controller: + raise AssertionError( + f"Controller parameter mismatch: {controller} != {expected_controller}" + ) + expected = fixed + layers * per_block + expected_controller + if total != expected: + raise AssertionError(f"Parameter ledger mismatch: {total} != {expected}") + return { + "architecture": model.architecture, + "total_parameters": total, + "trainable_parameters": sum(p.numel() for p in model.parameters() if p.requires_grad), + "expected_parameters": expected, + "expert_parameters": expert, + "router_parameters": router, + "controller_parameters": controller, + "nominal_parameters_selected_per_token": total - expert + expert // 4, + "active_parameter_convention": ( + "All nonexpert parameters (including whole embedding table) plus two of eight " + "experts; not FLOPs or touched embedding rows." + ), + "unique_blocks": layers, + "repeats": model.repeats, + "executed_blocks": layers * model.repeats, + "residual_streams": 4 if controller else 1, + "parameter_dtype": str(next(model.parameters()).dtype), + "residual_dtype_under_bf16_autocast": "torch.float32 with FP32 parameters", + "controller_dtype": "torch.float32", + } + + +def flop_ledger(model, *, executed_tokens, projected_positions, attention_pairs, valid_tokens=None): + """Leading forward matmuls with actual padding/dispatch/readout counts. + + ``attention_pairs`` is sum(B*T*T) over microbatches, before block count. + Training 3x is explicitly an approximation; Sinkhorn autograd, scalar ops, + and a counting/replay pass are not silently folded into this estimate. + """ + d, blocks = model.config.n_embd, len(model.transformer.h) * model.repeats + valid_tokens = executed_tokens if valid_tokens is None else valid_tokens + attention = blocks * (8 * executed_tokens * d * d + 4 * attention_pairs * d) + readout = 2 * projected_positions * d * model.config.vocab_size + router = controller = 0 + if model.kind == "moe": + ffn = blocks * 4 * valid_tokens * d * (2 * 2 * d) + router = blocks * 2 * valid_tokens * d * 8 + else: + inner = (16 if model.kind == "wide" else 4) * d + ffn = blocks * 4 * executed_tokens * d * inner + if model.kind in {"mhc", "identity_mhc"}: + n = 4 + count = 2 * n + (n * n if model.kind == "mhc" else 0) + controller = ( + 2 * blocks * (2 * executed_tokens * n * d * count + 2 * executed_tokens * d * count) + ) + forward = attention + readout + ffn + router + controller + return { + "forward_attention_matmul_flops": attention, + "forward_ffn_matmul_flops": ffn, + "forward_readout_matmul_flops": readout, + "forward_router_matmul_flops": router, + "forward_controller_matmul_flops": controller, + "forward_leading_matmul_flops": forward, + "estimated_matmul_training_flops": 3 * forward, + "sinkhorn_normalization_passes": 39 if model.kind == "mhc" else 0, + "sinkhorn_matrix_elements_per_forward": 2 * blocks * executed_tokens * 16 + if model.kind == "mhc" + else 0, + "selected_expert_assignments": blocks * valid_tokens * 2 if model.kind == "moe" else 0, + "executed_input_tokens": executed_tokens, + "effective_input_tokens": valid_tokens, + "projected_positions": projected_positions, + "excluded_ops": ( + "Nonlinearities, normalization, dropout, dispatch/index-add, softmax, Sinkhorn " + "scalar arithmetic/autograd, final mean, counting/replay and optimizer; " + "3x is approximate." + ), + } + + +def initialization_manifest(model): + """CPU-byte hashes of each actual initialized tensor; no sampled hash.""" + shared, introduced = {}, {} + for name, tensor in model.state_dict().items(): + is_new = name.startswith("connections.") or ( + model.kind in {"moe", "wide"} and ".mlp." in name + ) + raw = tensor.detach().cpu().contiguous().reshape(-1).view(torch.uint8).numpy().tobytes() + (introduced if is_new else shared)[name] = hashlib.sha256(raw).hexdigest() + return { + "architecture": model.architecture, + "reference_initialization": getattr(model, "initialization_seed", None), + "module_initialization": model.module_seed, + "reference_blocks_before_slicing": 8, + "shared_tensor_sha256": shared, + "introduced_tensor_sha256": introduced, + } diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture_train.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture_train.py new file mode 100644 index 0000000000000000000000000000000000000000..55c77a2f48a116b87a2159b90bb2ab76a6730887 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture_train.py @@ -0,0 +1,626 @@ +"""Resumable, exposure-matched training for the parametric architecture study. + +The ordinary data stream, answer-plus-EOS objective and generated evaluator are +shared with the historical experiment. MoE balancing is computed over the true +effective batch using an RNG-replayed routing pass, not a sum of local products. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import os +import random +import time +from pathlib import Path + +import numpy as np +import torch +import transformers +from transformers import GPT2TokenizerFast + +from . import realworld_composition as historical +from .grok_depth import utc +from .grokking_reproduction import model_digest +from .realworld_composition_data import sha256, write_json + + +def _architecture(): + from . import parametric_architecture + + return parametric_architecture + + +def rng_state(device): + state = { + "python": random.getstate(), + "numpy": np.random.get_state(), + "cpu": torch.get_rng_state(), + } + if torch.device(device).type == "cuda": + state["cuda"] = torch.cuda.get_rng_state(device) + return state + + +def restore_rng(state, device): + random.setstate(state["python"]) + np.random.set_state(state["numpy"]) + torch.set_rng_state(state["cpu"].cpu()) + if "cuda" in state: + torch.cuda.set_rng_state(state["cuda"].cpu(), device) + + +def pack(records, pad, device): + """EOS is a valid input token; validity comes from lengths, never token IDs.""" + tokens, positions, labels = historical.pack(records, pad, device) + lengths = torch.tensor([len(r["encoded"]["input"]) for r in records], device=device) + valid = torch.arange(tokens.shape[1], device=device)[None] < lengths[:, None] + return tokens, positions, labels, valid + + +def _synchronize(device): + if torch.device(device).type == "cuda": + torch.cuda.synchronize(device) + + +def _finite(value, name): + if not math.isfinite(float(value)): + raise FloatingPointError(f"Nonfinite {name}; this candidate must retain its failure") + + +def update(model, optimizer, records, spec, device, pad): + """One historical effective batch, with exact full-batch routing gradients. + + Hard assignment fractions have no gradient. A no-grad pass collects their + global values when there are multiple microbatches; replaying the same + dropout RNG realizes the same routing in the differentiable pass. One + microbatch already contains the full objective and needs no prepass. + """ + if not records: + raise ValueError("An update requires at least one example") + microbatch = int(spec["microbatch_size"]) + if microbatch < 1: + raise ValueError("microbatch_size must be positive") + api = _architecture() + model.train() + optimizer.zero_grad(set_to_none=True) + chunks = [records[i : i + microbatch] for i in range(0, len(records), microbatch)] + is_moe = spec["architecture"] in {"M8", "M4", "LM4R2"} + needs_prepass = is_moe and len(chunks) > 1 + coefficient = float(spec.get("balance_coefficient", 0.01)) if is_moe else 0.0 + global_fractions, total_tokens, collected = None, None, [] + if needs_prepass: + before = rng_state(device) + try: + with torch.no_grad(): + for chunk in chunks: + tokens, positions, _, valid = pack(chunk, pad, device) + with historical.autocast(device): + _, aux = model(tokens, positions, valid_mask=valid, return_aux=True) + collected.append(aux["router_stats"]) + global_fractions, total_tokens = api.combine_router_fractions(collected) + finally: + restore_rng(before, device) + answer_loss, balance_loss = 0.0, 0.0 + executed, readout, attention = 0, 0, 0 + replay_count_error = torch.zeros((), dtype=torch.int64, device=device) + for chunk_index, chunk in enumerate(chunks): + tokens, positions, labels, valid = pack(chunk, pad, device) + with historical.autocast(device): + logits, aux = model(tokens, positions, valid_mask=valid, return_aux=True) + answer = historical.example_losses(logits, labels).sum() / len(records) + balance = ( + api.router_balance_loss( + aux["router_stats"], + assignment_fractions=global_fractions, + total_valid_tokens=total_tokens, + ) + if is_moe + else answer.new_zeros(()) + ) + loss = answer + coefficient * balance + if needs_prepass: + replay_count_error += sum( + (left["assignment_counts"] - right["assignment_counts"]).abs().sum() + for left, right in zip(collected[chunk_index], aux["router_stats"], strict=True) + ) + elif is_moe: + collected = [aux["router_stats"]] + global_fractions, total_tokens = api.combine_router_fractions(collected) + _finite(loss.detach(), "objective") + loss.backward() + answer_loss += float(answer.detach()) + balance_loss += float(balance.detach()) + executed += tokens.numel() + readout += positions.numel() + attention += len(chunk) * tokens.shape[1] ** 2 + if int(replay_count_error) != 0: + raise RuntimeError("MoE RNG replay did not reproduce routing assignment counts") + norm = torch.nn.utils.clip_grad_norm_( + model.parameters(), float(spec.get("clip_grad_norm", 1.0)), error_if_nonfinite=True + ) + _finite(norm, "gradient norm") + optimizer.step() + effective = sum(len(r["encoded"]["input"]) for r in records) + result = { + "loss": answer_loss, + "answer_ce": answer_loss, + "balance_loss": balance_loss, + "balance_coefficient": coefficient, + "objective": answer_loss + coefficient * balance_loss, + "gradient_norm": float(norm), + "executed_input_tokens": executed, + "effective_input_tokens": effective, + "padding_input_tokens": executed - effective, + "readout_positions": readout, + "attention_token_pairs": attention, + "routing_prepass_executed_input_tokens": executed if needs_prepass else 0, + "routing_prepass_effective_input_tokens": effective if needs_prepass else 0, + } + result["compute"] = api.flop_ledger( + model, + executed_tokens=executed, + valid_tokens=effective, + projected_positions=readout, + attention_pairs=attention, + ) + prepass = result["compute"]["forward_leading_matmul_flops"] if needs_prepass else 0 + result["compute"]["routing_prepass_matmul_flops"] = prepass + result["estimated_matmul_training_flops"] = ( + result["compute"]["estimated_matmul_training_flops"] + prepass + ) + result["compute"]["estimated_total_training_matmul_flops"] = result[ + "estimated_matmul_training_flops" + ] + if is_moe: + layer_count = len(global_fractions) + assignments = torch.stack( + [sum(c[layer]["assignment_counts"] for c in collected) for layer in range(layer_count)] + ) + processed = torch.stack( + [ + sum(c[layer]["processed_assignments"] for c in collected) + for layer in range(layer_count) + ] + ) + dropped = sum(s["dropped_assignments"] for c in collected for s in c) + if int(dropped) != 0 or not torch.equal(processed, assignments.sum(-1)): + raise AssertionError("Dropless routing lost selected token assignments") + result["router"] = { + "assignment_fractions": torch.stack(global_fractions).detach().cpu().tolist(), + "assignment_counts": assignments.detach().cpu().tolist(), + "valid_tokens_per_layer": effective, + "selected_assignments_per_layer": assignments.sum(-1).detach().cpu().tolist(), + "processed_assignments_per_layer": processed.detach().cpu().tolist(), + "router_entropy_per_layer": torch.stack( + [ + sum(c[layer]["entropy_sum"] for c in collected) / effective + for layer in range(layer_count) + ] + ) + .detach() + .cpu() + .tolist(), + "selected_probability_mass_per_layer": torch.stack( + [ + sum(c[layer]["selected_mass_sum"] for c in collected) / effective + for layer in range(layer_count) + ] + ) + .detach() + .cpu() + .tolist(), + "dropped_assignments": int(dropped), + "replay_assignment_count_error": int(replay_count_error), + "replay_checked": needs_prepass, + "balance_scope": ( + "full_effective_batch_two_pass_rng_replay" + if needs_prepass + else "full_effective_batch_single_forward" + ), + } + return result + + +def selection_score(metrics): + """Frozen development panels only; no held-out-composition selection.""" + atomic, composition = metrics["atomic"]["nll"], metrics["train_composition"]["nll"] + if atomic is None or composition is None: + raise ValueError("Both fixed development panels need answer NLL measurements") + value = 0.5 * atomic + 0.5 * composition + _finite(value, "development selection NLL") + return value + + +def _routing_metrics(router): + """Expose numeric dictionaries to the existing W&B sidecar's flattening.""" + if not router: + return {} + return { + "dropped_assignments": router["dropped_assignments"], + "replay_assignment_count_error": router["replay_assignment_count_error"], + "layers": { + str(layer): { + "entropy": router["router_entropy_per_layer"][layer], + "selected_probability_mass": router["selected_probability_mass_per_layer"][layer], + "expert_fraction": {str(i): value for i, value in enumerate(fractions)}, + } + for layer, fractions in enumerate(router["assignment_fractions"]) + }, + } + + +def save_checkpoint(path, model, optimizer, stream, counts, step, counters, device, **extra): + path = Path(path) + temporary = path.with_suffix(".tmp") + torch.save( + { + "format_version": 1, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "step": step, + "counters": counters, + "rng": rng_state(device), + **extra, + }, + temporary, + ) + temporary.replace(path) + + +def load_checkpoint(path, model, optimizer, stream, device): + state = torch.load(path, map_location="cpu", weights_only=False) + model.load_state_dict(state["model"]) + optimizer.load_state_dict(state["optimizer"]) + stream.load_state_dict(state["stream"]) + restore_rng(state["rng"], device) + return state + + +def _identity(config, spec): + payload = { + "model": config["model"], + "spec": spec, + "data_sha256": config["data_sha256"], + "tokenizer_sha256": config.get("tokenizer_sha256", config.get("tokenizer_files", {})), + "source_files": config.get("source_files", {}), + } + return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest() + + +def verify(config, config_path=None): + """Check the concrete execution freeze; the historical design is not mutated.""" + if config.get("launch_enabled") is False: + raise ValueError("This configuration explicitly disables execution") + if sha256(config["data_file"]) != config["data_sha256"]: + raise ValueError("Frozen data changed") + for name, expected in config.get("tokenizer_sha256", {}).items(): + path = Path(config["tokenizer"]) / name + if sha256(path) != expected: + raise ValueError(f"Frozen tokenizer changed: {path}") + for group in ("tokenizer_files", "source_files"): + for path, expected in config.get(group, {}).items(): + if sha256(path) != expected: + raise ValueError(f"Frozen {group} changed: {path}") + if config.get("source_root"): + root = Path(config["source_root"]).resolve() + for module in (Path(__file__), Path(_architecture().__file__), Path(historical.__file__)): + if not module.resolve().is_relative_to(root): + raise ValueError(f"Imported code is outside the frozen source_root: {module}") + if config_path is not None: + if not config.get("execution_lock"): + raise ValueError("CLI requires an execution_lock with the frozen config hash") + lock = json.loads(Path(config["execution_lock"]).read_text()) + if lock["config_sha256"] != sha256(config_path): + raise ValueError("Frozen configuration changed") + if "torch" in lock.get("environment", {}): + if str(torch.__version__) != lock["environment"]["torch"]: + raise ValueError("Frozen torch version changed") + if "transformers" in lock.get("environment", {}): + if transformers.__version__ != lock["environment"]["transformers"]: + raise ValueError("Frozen transformers version changed") + + +def _setup(device, config): + torch.set_num_threads(int(config.get("cpu_threads", 4))) + if torch.device(device).type == "cuda": + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.cuda.reset_peak_memory_stats(device) + + +def _resources(device): + if torch.device(device).type != "cuda": + return {"peak_gpu_memory_bytes": 0, "peak_gpu_reserved_bytes": 0} + return { + "peak_gpu_memory_bytes": torch.cuda.max_memory_allocated(device), + "peak_gpu_reserved_bytes": torch.cuda.max_memory_reserved(device), + } + + +def _process_identity(): + """Different containers can both run Python as PID 1; identify the namespace.""" + identity = {"pid": os.getpid()} + if Path("/proc/self/stat").exists(): + identity["pid_namespace"] = os.readlink("/proc/self/ns/pid") + identity["start_ticks"] = Path("/proc/self/stat").read_text().rsplit(")", 1)[1].split()[19] + return identity + + +def run(config, spec, out, device="cuda:0"): + """Train one frozen candidate. An independent process must subsequently audit.""" + verify(config) + _setup(device, config) + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "trained.json").exists(): + trained = json.loads((out / "trained.json").read_text()) + if trained["identity"] != _identity(config, spec): + raise ValueError("Existing output belongs to a different frozen training recipe") + return trained + api = _architecture() + data = json.loads(Path(config["data_file"]).read_text()) + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + records = data["atoms"] + data["train_compositions"] + model = api.construct(config["model"], spec, device) + optimizer = api.optimizer_for(model, spec["learning_rate"], spec["weight_decay"]) + stream = historical.BatchStream(len(records), spec["sampling_seed"]) + identity = _identity(config, spec) + counts = np.zeros(len(records), dtype=np.int64) + counters = { + "training_seconds": 0.0, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "effective_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "routing_prepass_executed_input_tokens": 0, + } + initial_step, wall_offset, history, last = 0, 0.0, [], {} + if (out / "latest.pt").exists(): + saved = load_checkpoint(out / "latest.pt", model, optimizer, stream, device) + if saved["identity"] != identity: + raise ValueError("Checkpoint belongs to a different frozen training recipe") + counts, initial_step, counters = saved["counts"], saved["step"], saved["counters"] + wall_offset, last = saved.get("wall_seconds", 0.0), saved.get("last_update", {}) + learning = out / "learning.json" + history = [r for r in json.loads(learning.read_text()) if r["step"] <= initial_step] + metadata = json.loads((out / "run.json").read_text()) + metadata.update(pid=os.getpid(), resumed_from_step=initial_step) + del saved + else: + torch.manual_seed(spec["dropout_seed"]) + random.seed(spec["dropout_seed"]) + np.random.seed(spec["dropout_seed"]) + metadata = { + "spec": spec, + "model": config["model"], + "phase": config.get("phase", "development"), + "evaluation_nodes": config["evaluation_nodes"], + "world_sha256": config["data_sha256"], + "initial_model_sha256": model_digest(model), + "initial_tensor_sha256": historical.tensor_digests(model), + "initialization_manifest": api.initialization_manifest(model), + "parameters": sum(p.numel() for p in model.parameters()), + "parameter_ledger": api.parameter_ledger(model), + "atomic_examples": len(data["atoms"]), + "composition_examples": len(data["train_compositions"]), + "vocab_size": len(tokenizer), + "dtype": "BF16 AMP; FP32 parameters and Adam states", + "device": str(device), + "gpu": torch.device(device).index or 0, + "gpu_name": torch.cuda.get_device_name(device) + if torch.device(device).type == "cuda" + else "cpu", + "pid": os.getpid(), + "job_type": config.get("phase", "development") + "-training", + "tracking_group": config.get("tracking", {}).get("group", config.get("experiment")), + "learning_step_unit": "optimizer_updates", + "identity": identity, + "selection": "0.5 atomic + 0.5 train-composition NLL on original fixed panels", + "selection_panel_sizes": { + key: len(data["panels"][key]) for key in ("atomic", "train_composition") + }, + "moe_balance": ( + "full-effective-batch; single forward when one microbatch, otherwise two-pass " + "RNG replay; actual prepass compute included" + ), + "learning_rate_schedule": "historical lr * min((step - 1) / warmup_steps, 1)", + } + if config.get("execution_lock"): + metadata["execution_lock_sha256"] = sha256(config["execution_lock"]) + write_json(out / "run.json", metadata) + write_json(out / "learning.json", history) + nodes = set(config["evaluation_nodes"]) | {int(spec["steps"])} + log_interval = int(config.get("log_interval", 100)) + checkpoint_interval = int(config.get("resume_checkpoint_interval", 1000)) + started = time.perf_counter() + + def checkpoint(step): + save_checkpoint( + out / "latest.pt", + model, + optimizer, + stream, + counts, + step, + counters, + device, + identity=identity, + wall_seconds=wall_offset + time.perf_counter() - started, + last_update=last, + ) + + for step in range(initial_step, spec["steps"] + 1): + if step > initial_step: + warmup = int(spec["warmup_steps"]) + lr = spec["learning_rate"] * (min((step - 1) / warmup, 1.0) if warmup else 1.0) + for group in optimizer.param_groups: + group["lr"] = lr + ids = stream.batch(spec["batch_size"]) + selected = [records[i] for i in ids] + _synchronize(device) + begin = time.perf_counter() + last = update(model, optimizer, selected, spec, device, tokenizer.eos_token_id) + _synchronize(device) + counters["training_seconds"] += time.perf_counter() - begin + counts[ids] += 1 + counters["examples"] += len(ids) + counters["supervised_tokens"] += sum(len(r["encoded"]["target"]) for r in selected) + for key in ( + "executed_input_tokens", + "effective_input_tokens", + "estimated_matmul_training_flops", + "routing_prepass_executed_input_tokens", + ): + counters[key] += last[key] + if step in nodes or step % log_interval == 0: + if not any(r["step"] == step for r in history): + metrics = {} + if step in nodes: + metrics, predictions = historical.evaluate_dataset( + model, data, tokenizer, device + ) + write_json(out / f"predictions-{step:07d}.json", predictions) + metrics["selection"] = { + "mixed_answer_nll": selection_score(metrics), + "atomic_n": metrics["atomic"]["nll_n"], + "train_composition_n": metrics["train_composition"]["nll_n"], + } + if last.get("router"): + metrics["routing"] = _routing_metrics(last["router"]) + record = { + "step": step, + "metrics": metrics, + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "loss": last.get("answer_ce"), + "answer_ce": last.get("answer_ce"), + "balance_loss": last.get("balance_loss"), + "objective": last.get("objective"), + "gradient_norm": last.get("gradient_norm"), + "learning_rate": optimizer.param_groups[0]["lr"], + "atomic_epochs": float(counts[: len(data["atoms"])].mean()), + "composition_epochs": float(counts[len(data["atoms"]) :].mean()), + "router": last.get("router", {}), + "compute_per_update": last.get("compute", {}), + **_resources(device), + "created_utc": utc(), + } + history.append(record) + write_json(out / "learning.json", history) + print( + json.dumps({"step": step, "loss": record["loss"], "metrics": metrics}), + flush=True, + ) + write_json( + out / "status.json", + { + "state": "training", + "step": step, + "target_step": spec["steps"], + "loss": last.get("answer_ce"), + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "pid": os.getpid(), + "updated_utc": utc(), + }, + ) + if step in nodes or (step > initial_step and step % checkpoint_interval == 0): + checkpoint(step) + if step in nodes: + target = out / f"checkpoint-{step:07d}.pt" + temporary = target.with_suffix(".tmp") + torch.save( + {"model": model.state_dict(), "step": step, "identity": identity}, temporary + ) + temporary.replace(target) + np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=counts) + metrics, predictions = historical.evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + write_json(out / "endpoint-predictions.json", predictions) + write_json(out / "endpoint.json", metrics) + result = { + "state": "trained_pending_independent_reload", + "step": spec["steps"], + "pid": os.getpid(), + "process_identity": _process_identity(), + "identity": identity, + "model_sha256": model_digest(model), + "checkpoint_sha256": sha256(out / "latest.pt"), + **counters, + "selection_mixed_answer_nll": next( + r["metrics"]["selection"]["mixed_answer_nll"] + for r in reversed(history) + if r["step"] == spec["steps"] + ), + "wall_seconds": wall_offset + time.perf_counter() - started, + "completed_utc": utc(), + } + write_json(out / "trained.json", result) + write_json(out / "status.json", result) + return result + + +def audit(config, spec, out, device="cuda:0"): + """Reconstruct and regenerate the full endpoint in an independent process.""" + verify(config) + _setup(device, config) + out = Path(out) + trained = json.loads((out / "trained.json").read_text()) + same_process = ( + trained["process_identity"] == _process_identity() + if "process_identity" in trained + else trained["pid"] == os.getpid() + ) + if same_process: + raise ValueError("Independent audit must run in a different process") + if trained["identity"] != _identity(config, spec): + raise ValueError("Audit recipe differs from the training freeze") + if sha256(out / "latest.pt") != trained["checkpoint_sha256"]: + raise ValueError("Training checkpoint changed") + model = _architecture().construct(config["model"], spec, device) + checkpoint = torch.load(out / "latest.pt", map_location="cpu", weights_only=False) + if checkpoint["step"] != spec["steps"]: + raise ValueError("Final checkpoint does not contain the requested endpoint") + model.load_state_dict(checkpoint["model"]) + del checkpoint + if model_digest(model) != trained["model_sha256"]: + raise ValueError("Reloaded model does not match the trained endpoint") + data = json.loads(Path(config["data_file"]).read_text()) + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + metrics, predictions = historical.evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + if predictions != json.loads((out / "endpoint-predictions.json").read_text()): + raise AssertionError("Independent endpoint generation or NLL failed exact reproduction") + if metrics != json.loads((out / "endpoint.json").read_text()): + raise AssertionError("Independent endpoint metric recount failed") + result = { + "passed": True, + "pid": os.getpid(), + "source_training_pid": trained["pid"], + "process_identity": _process_identity(), + "source_process_identity": trained.get("process_identity"), + "checkpoint_sha256": trained["checkpoint_sha256"], + "model_sha256": trained["model_sha256"], + "predictions_recomputed": sum(len(p) for p in predictions.values()), + "completed_utc": utc(), + } + write_json(out / "audit.json", result) + write_json( + out / "complete.json", {**trained, "state": "complete", "independently_reloaded": True} + ) + write_json( + out / "status.json", + { + "state": "complete", + "step": spec["steps"], + "independently_reloaded": True, + }, + ) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_constraints.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_constraints.py new file mode 100644 index 0000000000000000000000000000000000000000..6181f6dad22ab1a99443ffddb19f67c7c6ad701b --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_constraints.py @@ -0,0 +1,94 @@ +"""Constrained response primitives; empirical scopes are recorded by the runner.""" + +from __future__ import annotations + +import hashlib + +import torch + + +def select_records(records, count, seed, role): + """Select before diagnostics, independently of accuracy or measured geometry.""" + if len(records) < count: + raise ValueError(f"Insufficient records for {role}") + return sorted( + records, + key=lambda row: hashlib.sha256(f"{seed}:{role}:{row['case_id']}".encode()).hexdigest(), + )[:count] + + +def psd_solve(gram, rhs, rtol): + values, vectors = torch.linalg.eigh(gram.double()) + eligible = values > values.max().clamp_min(1e-30) * rtol + projected = vectors[:, eligible].T @ rhs.double() + result = vectors[:, eligible] @ (projected / values[eligible]) + return result, int(eligible.sum()) + + +def functional_projection(target, keep, rtol): + """Orthogonal projection onto the numerical null space of keep gradients.""" + g, r = target.double(), keep.double() + coefficients, rank = psd_solve(r @ r.T, r @ g, rtol) + result = g - coefficients @ r + denominator = g.square().sum().clamp_min(1e-30) + return result.to(target.dtype), { + "rank": rank, + "retained_energy": float(result.square().sum() / denominator), + "relative_keep_residual": float( + (r @ result).norm() / (r.norm() * result.norm()).clamp_min(1e-30) + ), + } + + +def feature_basis(features, rtol): + """Rows are real token features; right singular vectors span protected keys.""" + _, singular, vh = torch.linalg.svd(features.double(), full_matrices=False) + selected = singular > singular[0] * rtol + return vh[selected], singular + + +def module_projection(gradient, basis): + g = gradient.double() + return (g - (g @ basis.T) @ basis).to(gradient.dtype) + + +def local_gradients(x, up, gate, down_weight, output_derivative): + """All-position exact SwiGLU chain rule; no replacement of the forward model.""" + sigmoid = torch.sigmoid(gate) + activated = gate * sigmoid + derivative = sigmoid + gate * sigmoid * (1 - sigmoid) + value_derivative = output_derivative @ down_weight + return { + "down": output_derivative.T @ (up * activated), + "up": (value_derivative * activated).T @ x, + "gate": (value_derivative * up * derivative).T @ x, + } + + +def route_output(current, original, attention, route): + """Forward activation intervention; baseline function is identical at zero update.""" + if route == "all": + return current + mask = torch.zeros_like(attention, dtype=torch.bool) + mask[torch.arange(len(mask), device=mask.device), attention.sum(1) - 1] = True + if route == "earlier": + mask = attention.bool() & ~mask + elif route != "last": + raise ValueError(route) + return torch.where(mask.unsqueeze(-1), current, original) + + +def update_scale(direction, target_gradient, step, parameter_norm, cap, metric): + d_norm = direction.double().norm() + g_norm = target_gradient.double().norm() + response = target_gradient.double() @ direction.double() + if d_norm == 0 or response <= 0: + return 0.0, True + if metric == "equal_norm": + scale = step / (g_norm * d_norm) + elif metric == "equal_target": + scale = step / response + else: + raise ValueError(metric) + maximum = cap * parameter_norm / d_norm + return float(torch.minimum(scale, maximum)), bool(scale > maximum) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_learning.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_learning.py new file mode 100644 index 0000000000000000000000000000000000000000..bc113a47da9c9fc22e346812c7f48f5ae7bc8b92 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_learning.py @@ -0,0 +1,416 @@ +"""Position-routed down updates, complete-answer objectives, and audited data helpers.""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import time +from datetime import datetime, timezone +from pathlib import Path + +os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8") +os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") + +import numpy as np +import torch +import torch.nn.functional as F +from transformers import AutoModelForCausalLM, AutoTokenizer + +from .hebbian_data import TEMPLATE, encode_answer, score_answer +from .hebbian_model import set_determinism, tensor_hash + +ROOT = Path(__file__).resolve().parents[2] +DATA = ROOT / "data/qwen-path-learning-v1" +ART = ROOT / "docs/development-artifacts/qwen-path-learning-v1" +RESULTS = ROOT / "results/qwen-path-learning-v1" +CONFIG = ROOT / "configs/qwen-path-learning-v1.json" +GROUPS = ("S_end", "S_other", "C", "W", "L", "A") + +# All views ask the same original CounterFact relation; no generated answer labels. +RELATIONS = { + "P19": ("{} was born in", "The birthplace of {} is", "{}'s birthplace is"), + "P20": ("{} died in", "The place of death of {} is", "{}'s place of death is"), + "P103": ( + "The native language of {} is", + "The mother tongue of {} is", + "{}'s native language is", + ), + "P176": ("The manufacturer of {} is", "{} was manufactured by", "{}'s manufacturer is"), + "P178": ("The developer of {} is", "{} was developed by", "{}'s developer is"), + "P495": ( + "The country of origin of {} is", + "{} originated in the country of", + "{}'s country of origin is", + ), + "P740": ( + "{} was founded in", + "The place where {} was founded is", + "{}'s place of formation is", + ), + "P364": ( + "The original language of {} is", + "{} was originally in the language", + "{}'s original language is", + ), + "P407": ("The language of {} is", "{} is in the language", "{}'s language is"), +} + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, obj): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(f".{os.getpid()}.tmp") + temporary.write_text(json.dumps(obj, ensure_ascii=False, indent=2, allow_nan=False) + "\n") + temporary.replace(path) + + +def digest(path): + h = hashlib.sha256() + with Path(path).open("rb") as stream: + for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def stable(value): + return hashlib.sha256(str(value).encode()).hexdigest() + + +def encode_fact(tokenizer, subject, statement, answer, view=0, plain=False): + prompt = statement if plain else TEMPLATE.format(statement) + enc = encode_answer(tokenizer, prompt, answer) + offset = 0 if plain else prompt.index(statement) + subject_start = statement.index(subject) + offset + subject_end = subject_start + len(subject) + offsets = tokenizer(prompt, add_special_tokens=False, return_offsets_mapping=True)[ + "offset_mapping" + ] + subject_tokens = [ + i for i, (a, b) in enumerate(offsets) if b > subject_start and a < subject_end + ] + if not subject_tokens: + raise ValueError("Subject has no tokens") + roles = [] + for i, (a, b) in enumerate(offsets): + if i == len(offsets) - 1: + role = "L" + elif i == subject_tokens[-1]: + role = "S_end" + elif i in subject_tokens: + role = "S_other" + elif b > offset and a < offset + len(statement): + role = "C" + else: + role = "W" + roles.append(role) + roles += ["A"] * (len(enc["input_ids"]) - len(roles)) + return {**enc, "prompt": prompt, "roles": roles, "view": view, "plain": plain} + + +def random_positions(roles, group, key, seed, bins=2, draws=16, energies=None): + """Disjoint count/bin-matched controls; optional local-energy matching only.""" + n = roles.index("L") + 1 + target = [i for i, role in enumerate(roles[: n - 1]) if role == group] + if not target: + return [], {"valid": False, "reason": "empty_group"} + + def strata(i): + return min(bins - 1, i * bins // max(n - 1, 1)) + + eligible = { + b: [i for i in range(n - 1) if i not in target and strata(i) == b] for b in range(bins) + } + counts = {b: sum(strata(i) == b for i in target) for b in range(bins)} + if any(len(eligible[b]) < counts[b] for b in range(bins)): + return [], {"valid": False, "reason": "insufficient_disjoint_positions"} + rng = np.random.default_rng(int(stable(f"{key}:{group}:{seed}")[:16], 16)) + options = [] + for _ in range(draws if energies is not None else 1): + positions = sorted( + int(i) for b in range(bins) for i in rng.choice(eligible[b], counts[b], replace=False) + ) + error = ( + 0.0 + if energies is None + else abs(sum(energies[i] for i in positions) - sum(energies[i] for i in target)) + / max(sum(energies[i] for i in target), 1e-30) + ) + options.append((error, positions)) + error, selected = min(options, key=lambda x: (x[0], x[1])) + return selected, {"valid": True, "relative_energy_error": error, "count": len(target)} + + +def sequence_mean(values, batch_indices, count): + sums = values.new_zeros(count).scatter_add_(0, batch_indices, values) + return sums / torch.bincount(batch_indices, minlength=count).clamp_min(1) + + +def fisher_quadratic(logp, response): + p = logp.exp() + return 0.5 * ((p * response.square()).sum(-1) - (p * response).sum(-1).square()) + + +class PathEngine: + def __init__(self, device, layer=None): + self.cfg = read(CONFIG) + set_determinism(self.cfg["seed"]) + self.device = torch.device(device) + self.tokenizer = AutoTokenizer.from_pretrained( + ROOT / self.cfg["model_source"], local_files_only=True + ) + self.tokenizer.pad_token = self.tokenizer.eos_token + self.model = ( + AutoModelForCausalLM.from_pretrained( + ROOT / self.cfg["model_source"], + local_files_only=True, + dtype=torch.float32, + attn_implementation="eager", + ) + .to(self.device) + .eval() + .requires_grad_(False) + ) + self.layer_index = self.cfg["layer"] if layer is None else layer + self.down = self.model.model.layers[self.layer_index].mlp.down_proj + self.base_hash = tensor_hash(self.down.weight) + self.delta = torch.nn.Parameter(torch.zeros_like(self.down.weight)) + self.route = "all" + self.route_seed = 0 + self.route_group = None + self.route_positions = {} + self.mask = None + self.capture = None + self.handle = self.down.register_forward_hook(self._hook) + self.reference = {} + self.forward_tokens = 0 + self.started = time.time() + + def _hook(self, module, args, output): + increment = F.linear(args[0], self.delta) + if self.capture is not None: + self.capture.append(increment.detach().square().sum(-1).cpu()) + if self.mask is not None: + increment = increment * self.mask[:, -increment.shape[1] :, None] + return output + increment + + def mask_for(self, enc): + roles = enc["roles"] + mask = [1.0] * len(roles) + if self.route == "all": + return mask + if "L" not in roles: # Unannotated natural text has no fact-position groups. + return mask + if self.route == "group": + positions = [i for i, x in enumerate(roles) if x == self.route_group] + elif self.route == "random": + positions, _ = random_positions(roles, self.route_group, enc["key"], self.route_seed) + elif self.route == "positions": + positions = self.route_positions.get(enc["key"], []) + elif self.route == "zero": + positions = list(range(len(roles))) + else: + raise ValueError(self.route) + for i in positions: + mask[i] = 0.0 + return mask + + def batch(self, encoded, prompt_only=False): + sequences = [ + e["input_ids"][: e["answer_start"]] if prompt_only else e["input_ids"] for e in encoded + ] + width = max(map(len, sequences)) + ids = torch.full( + (len(sequences), width), + self.tokenizer.pad_token_id, + device=self.device, + dtype=torch.long, + ) + attention = torch.zeros_like(ids) + loss = torch.zeros_like(ids, dtype=torch.bool) + masks = torch.ones_like(ids, dtype=torch.float32) + for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)): + ids[i, : len(seq)] = torch.tensor(seq, device=self.device) + attention[i, : len(seq)] = 1 + if not prompt_only: + loss[i, : len(seq)] = torch.tensor( + enc["loss_mask"], device=self.device, dtype=torch.bool + ) + masks[i, : len(seq)] = torch.tensor(self.mask_for(enc)[: len(seq)], device=self.device) + self.mask = masks + return ids, attention, loss + + def hidden(self, ids, attention): + self.forward_tokens += ids.numel() + return self.model.model( + input_ids=ids, attention_mask=attention, use_cache=False + ).last_hidden_state + + def objectives(self, encoded, include_kl=True): + ids, attention, mask = self.batch(encoded) + b, t = torch.where(mask[:, 1:]) + hidden = self.hidden(ids, attention) + logits = self.model.lm_head(hidden[b, t]) + ce = sequence_mean( + F.cross_entropy(logits, ids[b, t + 1], reduction="none"), b, len(encoded) + ) + if not include_kl: + return ce, None + with torch.no_grad(): + ref_hidden = torch.cat([self.reference[e["key"]] for e in encoded]).to(self.device) + ref_log = F.log_softmax(self.model.lm_head(ref_hidden), dim=-1) + divergence = (ref_log.exp() * (ref_log - F.log_softmax(logits, dim=-1))).sum(-1) + return ce, sequence_mean(divergence, b, len(encoded)) + + @torch.no_grad() + def cache_reference(self, encoded, batch_size=8): + if self.delta.count_nonzero().item(): + raise ValueError("Reference must be cached at the parent") + for start in range(0, len(encoded), batch_size): + chunk = encoded[start : start + batch_size] + ids, attention, mask = self.batch(chunk) + b, t = torch.where(mask[:, 1:]) + hidden = self.hidden(ids, attention) + for i, enc in enumerate(chunk): + self.reference[enc["key"]] = hidden[b[b == i], t[b == i]].detach().cpu() + + @torch.no_grad() + def generate(self, encoded): + # Cached greedy decoding; routing is built from the input prompt alone. + sequences = [e["input_ids"][: e["answer_start"]] for e in encoded] + width = max(map(len, sequences)) + ids = torch.full( + (len(sequences), width), + self.tokenizer.pad_token_id, + device=self.device, + dtype=torch.long, + ) + attention = torch.zeros_like(ids) + route_mask = torch.ones_like(ids, dtype=torch.float32) + for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)): + ids[i, -len(seq) :] = torch.tensor(seq, device=self.device) + attention[i, -len(seq) :] = 1 + route_mask[i, -len(seq) :] = torch.tensor( + self.mask_for(enc)[: len(seq)], device=self.device + ) + tails = [[] for _ in encoded] + done = [False] * len(encoded) + cache = None + for step in range(self.cfg["max_new_tokens"]): + position = attention.cumsum(-1) - 1 + position.masked_fill_(attention == 0, 0) + self.mask = ( + route_mask + if step == 0 + else torch.full( + (len(encoded), 1), + 0.0 + if self.route == "zero" or (self.route == "group" and self.route_group == "A") + else 1.0, + device=self.device, + ) + ) + out = self.model.model( + input_ids=ids, + attention_mask=attention, + position_ids=position if step == 0 else position[:, -1:], + past_key_values=cache, + use_cache=True, + ) + self.forward_tokens += ids.numel() + cache = out.past_key_values + next_ids = self.model.lm_head(out.last_hidden_state[:, -1]).argmax(-1) + for i, token in enumerate(next_ids.tolist()): + if not done[i]: + tails[i].append(token) + decoded = self.tokenizer.decode(tails[i], skip_special_tokens=True) + done[i] = token == self.tokenizer.eos_token_id or "\n" in decoded + if all(done): + break + ids = next_ids[:, None] + attention = torch.cat([attention, torch.ones_like(ids)], dim=1) + return [ + { + "prediction": self.tokenizer.decode(tail, skip_special_tokens=True), + "tokens": tail, + "eos": self.tokenizer.eos_token_id in tail, + } + for tail in tails + ] + + @torch.no_grad() + def evaluate(self, records, views=(0,), batch_size=16, with_kl=True, generate=True): + entries = [(r, r["encoded"][v]) for r in records for v in views] + output = [] + for start in range(0, len(entries), batch_size): + chunk = entries[start : start + batch_size] + encs = [e for _, e in chunk] + ce, kl = self.objectives(encs, include_kl=with_kl) + predictions = self.generate(encs) if generate else [None] * len(chunk) + for i, ((record, enc), prediction) in enumerate(zip(chunk, predictions, strict=True)): + item = { + "case_id": record["case_id"], + "view": enc["view"], + "ce": float(ce[i]), + "kl": None if kl is None else float(kl[i]), + } + if prediction is not None: + item.update(prediction) + item["correct"] = score_answer(prediction["prediction"], record["aliases"]) + output.append(item) + return output + + @torch.no_grad() + def evaluate_text(self, encoded): + result = [] + for start in range(0, len(encoded), 2): + chunk = encoded[start : start + 2] + ce, kl = self.objectives(chunk) + result.extend( + {"key": e["key"], "ce": float(c), "kl": float(k)} + for e, c, k in zip(chunk, ce, kl, strict=True) + ) + return result + + def restore(self): + with torch.no_grad(): + self.delta.zero_() + self.route = "all" + self.mask = None + assert tensor_hash(self.down.weight) == self.base_hash + + +def mean(rows, key): + return float(np.mean([r[key] for r in rows])) if rows else None + + +def valid_aliases(raw): + by_id = {} + for row in raw: + target = row["requested_rewrite"]["target_true"] + by_id.setdefault(target["id"], set()).add(target["str"].strip()) + return {k: sorted(v) for k, v in by_id.items()} + + +def articles_from_lines(lines): + articles = [] + title, parts = None, [] + for line in lines: + if re.fullmatch(r"\s*= [^=]+ =\s*", line): + if title and parts: + articles.append((title, "".join(parts))) + title, parts = line.strip(), [] + elif title: + parts.append(line) + if title and parts: + articles.append((title, "".join(parts))) + return articles diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_train.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_train.py new file mode 100644 index 0000000000000000000000000000000000000000..fabb31112396100c708fafd83993acdb8c46f918 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_train.py @@ -0,0 +1,627 @@ +"""Frozen-matrix execution and development-only selection for path learning.""" + +from __future__ import annotations + +import json +import os +import platform +import shutil +import time + +import numpy as np +import torch +import transformers + +from .qwen_path_learning import ( + ART, + CONFIG, + DATA, + RESULTS, + ROOT, + PathEngine, + digest, + encode_fact, + mean, + now, + random_positions, + read, + write, +) + + +def preflight(device): + from .hebbian_model import aggregate_hash, state_hashes + + cfg = read(CONFIG) + old_records = read(ROOT / "data/hebbian-learning-v1/pools.json")["B_dev"][:2] + engine = PathEngine(device) + encs = [] + for r in old_records: + enc = encode_fact(engine.tokenizer, r["subject"], r["views"][0], r["answer"]) + enc["key"] = f"preflight-{r['case_id']}" + encs.append(enc) + before_hash = aggregate_hash(state_hashes(engine.model)) + assert all(not p.requires_grad for p in engine.model.parameters()) + assert engine.delta.numel() == 3145728 + engine.cache_reference(encs) + baseline_ce, zero_kl = engine.objectives(encs) + baseline_ce = baseline_ce.detach() + checks = { + "parameter_count": engine.delta.numel(), + "zero_kl_max": float(zero_kl.detach().abs().max()), + } + assert checks["zero_kl_max"] < 1e-5 + for group in cfg["groups"]: + engine.route, engine.route_group = "group", group + ce, _ = engine.objectives(encs) + assert torch.equal(ce.detach(), baseline_ce) + engine.route = "all" + with torch.no_grad(): + engine.delta.normal_(std=1e-5) + ids, attention, _ = engine.batch(encs) + with torch.no_grad(): + separate = engine.hidden(ids, attention) + delta = engine.delta.clone() + original_weight = engine.down.weight.clone() + engine.down.weight.add_(delta) + engine.delta.zero_() + fused = engine.hidden(ids, attention) + engine.down.weight.copy_(original_weight) + engine.delta.copy_(delta) + checks["all_vs_fused_hidden_max_error"] = float((separate - fused).abs().max()) + assert checks["all_vs_fused_hidden_max_error"] < 1e-3 + engine.restore() + opt = optimizer(engine, 1e-5) + begun = time.time() + ce, _ = engine.objectives(encs, include_kl=False) + ce.mean().backward() + checks["delta_gradient_norm"] = float(engine.delta.grad.norm()) + torch.nn.utils.clip_grad_norm_([engine.delta], cfg["optimizer"]["clip"]) + opt.step() + checks["single_old_episode_step_seconds"] = time.time() - begun + assert checks["delta_gradient_norm"] > 0 and torch.isfinite(engine.delta).all() + engine.restore() + assert aggregate_hash(state_hashes(engine.model)) == before_hash + ce, _ = engine.objectives(encs) + checks["restore_ce_max_error"] = float((ce.detach() - baseline_ce).abs().max()) + assert checks["restore_ce_max_error"] == 0 + del engine + torch.cuda.empty_cache() + final = PathEngine(device, layer=27) + with torch.no_grad(): + final.delta.normal_(std=1e-4) + final.route = "zero" + parent_ce, _ = final.objectives(encs, include_kl=False) + # Enable only earlier-prompt increments, and disable all readout positions. + final.route = "positions" + final.route_positions = { + e["key"]: list(range(e["answer_start"] - 1, len(e["roles"]))) for e in encs + } + early_ce, _ = final.objectives(encs, include_kl=False) + checks["final_layer_earlier_ce_max_error"] = float((early_ce - parent_ce).abs().max()) + assert checks["final_layer_earlier_ce_max_error"] == 0 + final.restore() + checks["passed"] = True + checks["time"] = now() + checks["training_cases"] = "two old B_dev facts; no new developmental outcome selection" + checks["parent_model_sha256"] = before_hash + write(ART / "preflight.json", checks) + print(json.dumps(checks), flush=True) + + +def jobs(): + cfg = read(CONFIG) + return [ + { + "id": f"dev-e{episode}-lr{lr:g}-b{beta}", + "episode": episode, + "lr": lr, + "beta": beta, + "seed": 0, + "phase": "dev", + "condition": "ordinary", + } + for episode in range(4) + for lr in cfg["learning_rates"] + for beta in cfg["betas_replay"] + ] + + +def sources(): + return [ + "configs/qwen-path-learning-v1.json", + "scripts/run_qwen_path_learning.py", + "src/llm_memory_editability/qwen_path_learning.py", + "src/llm_memory_editability/qwen_path_train.py", + "src/llm_memory_editability/hebbian_data.py", + "src/llm_memory_editability/hebbian_model.py", + "src/llm_memory_editability/hebbian_learning.py", + "tests/test_qwen_path_learning.py", + ] + + +def freeze(): + if (ART / "execution-lock.json").exists(): + raise RuntimeError("Execution lock exists") + assert read(ART / "preflight.json")["passed"] + assert read(ART / "selection-lock.json")["selection_sha256"] == digest(DATA / "selection.json") + frozen = {} + for relative in sources() + [ + "docs/hebbian-learning-plan-v1.md", + "docs/experimental-protocol.md", + ]: + path = ROOT / relative + target = ART / "execution-source" / relative + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, target) + frozen[relative] = digest(path) + cfg = read(CONFIG) + model = ROOT / cfg["model_source"] / "model.safetensors" + write( + ART / "execution-lock.json", + { + "time": now(), + "status": "locked_before_development_updates", + "sources": frozen, + "inputs": { + str(p.relative_to(ROOT)): digest(p) + for p in [DATA / "selection.json", DATA / "text.json", model] + }, + "matrix": jobs(), + "environment": { + "python": platform.python_version(), + "torch": torch.__version__, + "transformers": transformers.__version__, + "numpy": np.__version__, + }, + "config": cfg, + }, + ) + + +def check_lock(): + lock = read(ART / "execution-lock.json") + for relative in sources(): + assert digest(ROOT / relative) == lock["sources"][relative], relative + for relative in ( + "data/qwen-path-learning-v1/selection.json", + "data/qwen-path-learning-v1/text.json", + ): + assert digest(ROOT / relative) == lock["inputs"][relative] + + +def optimizer(engine, lr): + cfg = engine.cfg["optimizer"] + return torch.optim.AdamW( + [engine.delta], + lr=lr, + betas=tuple(cfg["betas"]), + eps=cfg["eps"], + weight_decay=cfg["weight_decay"], + ) + + +def schedule(cfg, episode, seed, n_r=64, n_text=64): + rng = np.random.default_rng(cfg["seed"] + 1000 * episode + seed) + # Fixed cyclic shuffled decks give exactly equal aggregate exposure across jobs. + replay, text = rng.permutation(n_r), rng.permutation(n_text) + return [ + { + "R": [int(replay[(step * 8 + i) % n_r]) for i in range(8)], + "text": [int(text[(step * 2 + i) % n_text]) for i in range(2)], + } + for step in range(cfg["steps"]) + ] + + +def save_checkpoint(path, engine, opt, job, step, history, ledger): + temporary = path.with_suffix(f".{os.getpid()}.tmp") + torch.save( + { + "delta": engine.delta.detach().cpu(), + "optimizer": opt.state_dict(), + "job": job, + "step": step, + "history": history, + "ledger": ledger, + "execution_lock": digest(ART / "execution-lock.json"), + }, + temporary, + ) + temporary.replace(path) + + +def evaluate_node(engine, episode, selection, texts, step, output, full_test=False): + result = { + "step": step, + "time": now(), + "E": engine.evaluate(episode, views=(0, 1, 2, 3), with_kl=False), + "R": engine.evaluate(selection["R"]), + "V": engine.evaluate(selection["V"]), + "text_dev": engine.evaluate_text(texts["dev"]), + "delta_norm": float(engine.delta.norm()), + "relative_delta_norm": float(engine.delta.norm() / engine.down.weight.norm()), + } + if full_test: + result["U"] = engine.evaluate(selection["U"], views=(0, 1, 2, 3)) + result["text_test"] = engine.evaluate_text(texts["test"]) + write(output / f"node-{step:03d}.json", result) + return result + + +def train_job(engine, job): + check_lock() + cfg = engine.cfg + out = RESULTS / job["id"] + out.mkdir(parents=True, exist_ok=True) + if (out / "complete.json").exists(): + return + engine.restore() + selection, texts = read(DATA / "selection.json"), read(DATA / "text.json") + phase = job["phase"] + records = selection["E_dev" if phase == "dev" else "E_confirm"] + episode = records[job["episode"] * 4 : (job["episode"] + 1) * 4] + training_enc = [r["encoded"][0] for r in episode] + reference_enc = ( + [r["encoded"][0] for role in ("R", "V") for r in selection[role]] + + texts["train"] + + texts["dev"] + ) + if phase == "confirm": + reference_enc += [enc for r in selection["U"] for enc in r["encoded"]] + texts["test"] + missing = [e for e in reference_enc if e["key"] not in engine.reference] + engine.cache_reference(missing) + if job["condition"] != "ordinary": + engine.route = "group" if job["condition"] == "candidate" else "random" + engine.route_group = job["group"] + engine.route_seed = job["seed"] + opt = optimizer(engine, job["lr"]) + batches = schedule(cfg, job["episode"], job["seed"]) + write(out / "schedule.json", batches) + history, ledger, start = ( + [], + { + "E_sequences": 0, + "R_sequences": 0, + "text_sequences": 0, + "supervised_E_tokens": 0, + "R_prediction_tokens": 0, + "text_prediction_tokens": 0, + "padded_training_tokens": 0, + }, + 0, + ) + checkpoint = out / "latest.pt" + if checkpoint.exists(): + ck = torch.load(checkpoint, map_location=engine.device, weights_only=False) + assert ck["job"] == job and ck["execution_lock"] == digest(ART / "execution-lock.json") + with torch.no_grad(): + engine.delta.copy_(ck["delta"]) + opt.load_state_dict(ck["optimizer"]) + history, ledger, start = ck["history"], ck["ledger"], ck["step"] + else: + evaluate_node(engine, episode, selection, texts, 0, out, phase == "confirm") + save_checkpoint(out / "step-000.pt", engine, opt, job, 0, history, ledger) + begun = time.time() + torch.cuda.reset_peak_memory_stats(engine.device) + for index in range(start, cfg["steps"]): + plan = batches[index] + replay = [selection["R"][i]["encoded"][0] for i in plan["R"]] + text = [texts["train"][i] for i in plan["text"]] + opt.zero_grad(set_to_none=True) + ce, _ = engine.objectives(training_enc, include_kl=False) + ce.mean().backward() + _, rkl = engine.objectives(replay) + (job["beta"] * rkl.mean() / 2).backward() + _, tkl = engine.objectives(text) + (job["beta"] * tkl.mean() / 2).backward() + gradient_norm = torch.nn.utils.clip_grad_norm_([engine.delta], cfg["optimizer"]["clip"]) + if not torch.isfinite(gradient_norm): + raise RuntimeError(f"Non-finite gradient in {job['id']} step {index + 1}") + opt.step() + history.append( + { + "step": index + 1, + "ce": float(ce.detach().mean()), + "r_kl": float(rkl.detach().mean()), + "text_kl": float(tkl.detach().mean()), + "gradient_norm_before_clip": float(gradient_norm), + } + ) + ledger["E_sequences"] += len(training_enc) + ledger["R_sequences"] += len(replay) + ledger["text_sequences"] += len(text) + ledger["supervised_E_tokens"] += sum(sum(e["loss_mask"]) for e in training_enc) + ledger["R_prediction_tokens"] += sum(sum(e["loss_mask"]) for e in replay) + ledger["text_prediction_tokens"] += sum(sum(e["loss_mask"]) for e in text) + ledger["padded_training_tokens"] += sum( + len(es) * max(len(e["input_ids"]) for e in es) for es in (training_enc, replay, text) + ) + step = index + 1 + if step in cfg["nodes"]: + evaluate_node(engine, episode, selection, texts, step, out, phase == "confirm") + save_checkpoint(out / f"step-{step:03d}.pt", engine, opt, job, step, history, ledger) + if step % 16 == 0 or step in cfg["nodes"]: + save_checkpoint(checkpoint, engine, opt, job, step, history, ledger) + write( + out / "status.json", + { + "time": now(), + "state": "training", + "step": step, + "job": job, + "device": str(engine.device), + "seconds_this_attempt": time.time() - begun, + }, + ) + print(json.dumps({"job": job["id"], "step": step, "ce": history[-1]["ce"]}), flush=True) + write(out / "history.json", history) + write( + out / "complete.json", + { + "time": now(), + "job": job, + "steps": cfg["steps"], + "ledger": ledger, + "schedule_sha256": digest(out / "schedule.json"), + "seconds_this_attempt": time.time() - begun, + "peak_gpu_bytes": torch.cuda.max_memory_allocated(engine.device), + "device": str(engine.device), + "trainable_parameters": engine.delta.numel(), + "parent_down_hash": engine.base_hash, + "forward_tokens_engine_cumulative": engine.forward_tokens, + "flops_estimate": { + "convention": "Approximate dense 2*N per forward token plus backward through " + "downstream half and head; padding included, attention term omitted; " + "reference/evaluation costs recorded separately", + "value": 4 + * sum(p.numel() for p in engine.model.parameters()) + * ledger["padded_training_tokens"], + "not_hardware_counter": True, + }, + }, + ) + engine.restore() + + +def train_shard(device, shard, shards): + engine = PathEngine(device) + for index, job in enumerate(jobs()): + if index % shards == shard: + train_job(engine, job) + + +def select_learning_rates(): + cfg = read(CONFIG) + summaries, chosen = [], {} + for beta in cfg["betas_replay"]: + options = [] + for lr in cfg["learning_rates"]: + records = [] + for job in jobs(): + if job["beta"] == beta and job["lr"] == lr: + assert (RESULTS / job["id"] / "complete.json").exists() + node = read(RESULTS / job["id"] / "node-128.json") + base = read(RESULTS / job["id"] / "node-000.json") + records.append( + { + "E": mean([r for r in node["E"] if r["view"] == 0], "correct"), + "V_loss": mean(base["V"], "correct") - mean(node["V"], "correct"), + "text_kl": mean(node["text_dev"], "kl"), + } + ) + option = { + "beta": beta, + "lr": lr, + **{k: mean(records, k) for k in ("E", "V_loss", "text_kl")}, + } + options.append(option) + eligible = [r for r in options if r["V_loss"] <= 0.05] + if eligible: + choice = min(eligible, key=lambda r: (-r["E"], r["text_kl"], r["lr"])) + else: + choice = min(options, key=lambda r: (r["V_loss"], r["text_kl"], r["lr"])) + chosen[str(beta)] = {**choice, "retention_condition_passed": bool(eligible)} + summaries.extend(options) + write( + ART / "learning-rate-selection.json", + {"time": now(), "node": 128, "rows": summaries, "chosen": chosen, "used_U": False}, + ) + return chosen + + +@torch.no_grad() +def diagnose(device, episode_index): + check_lock() + cfg = read(CONFIG) + chosen = read(ART / "learning-rate-selection.json")["chosen"]["1"] + job = next( + j + for j in jobs() + if j["episode"] == episode_index and j["beta"] == 1 and j["lr"] == chosen["lr"] + ) + engine = PathEngine(device) + selection = read(DATA / "selection.json") + episode = selection["E_dev"][episode_index * 4 : (episode_index + 1) * 4] + records = episode + selection["R"] + encs = [r["encoded"][0] for r in records] + engine.cache_reference(encs) + output = RESULTS / job["id"] / "diagnostics" + output.mkdir(exist_ok=True) + base_E = engine.evaluate(episode) + zero_R = engine.evaluate(selection["R"], generate=False) + for step in cfg["nodes"][1:]: + if (output / f"step-{step:03d}.json").exists(): + continue + ck = torch.load( + RESULTS / job["id"] / f"step-{step:03d}.pt", + map_location=engine.device, + weights_only=False, + ) + engine.delta.copy_(ck["delta"]) + engine.route = "all" + full_E = engine.evaluate(episode) + full_R = engine.evaluate(selection["R"], generate=False) + energies = {} + for start in range(0, len(encs), 8): + chunk = encs[start : start + 8] + engine.capture = [] + engine.objectives(chunk, include_kl=False) + captured = engine.capture[0] + for i, enc in enumerate(chunk): + energies[enc["key"]] = captured[i, : len(enc["roles"])].tolist() + engine.capture = None + result = { + "step": step, + "episode": episode_index, + "job": job, + "base_E": base_E, + "zero_R": zero_R, + "all_E": full_E, + "all_R": full_R, + "groups": {}, + } + for group in cfg["groups"] + ["L", "A"]: + engine.route, engine.route_group = "group", group + group_E = engine.evaluate(episode) + group_R = engine.evaluate(selection["R"], generate=False) + group_result = {"E": group_E, "R": group_R, "random": []} + if group in cfg["groups"]: + for seed in cfg["matching"]["diagnostic_seeds"]: + positions, matches = {}, {} + for enc in encs: + selected, info = random_positions( + enc["roles"], + group, + enc["key"], + seed, + cfg["matching"]["position_bins"], + cfg["matching"]["draws"], + energies[enc["key"]], + ) + info["energy_matched"] = ( + info["valid"] + and info["relative_energy_error"] + <= cfg["matching"]["norm_relative_tolerance"] + ) + matches[enc["key"]] = info + positions[enc["key"]] = selected + engine.route, engine.route_positions = "positions", positions + group_result["random"].append( + { + "seed": seed, + "matches": matches, + "positions": positions, + "E": engine.evaluate(episode), + "R": engine.evaluate(selection["R"], generate=False), + } + ) + result["groups"][group] = group_result + engine.route = "all" + recovered = engine.evaluate(episode, generate=False) + result["restore_max_ce_error"] = max( + abs(a["ce"] - b["ce"]) for a, b in zip(full_E, recovered, strict=True) + ) + result["position_energy"] = energies + write(output / f"step-{step:03d}.json", result) + print(json.dumps({"diagnostic_episode": episode_index, "step": step}), flush=True) + engine.restore() + + +def candidate_decision(): + cfg = read(CONFIG) + chosen = read(ART / "learning-rate-selection.json")["chosen"]["1"] + rows = [] + for job in jobs(): + if job["beta"] != 1 or job["lr"] != chosen["lr"]: + continue + d = read(RESULTS / job["id"] / "diagnostics/step-128.json") + gain = mean(d["base_E"], "ce") - mean(d["all_E"], "ce") + risk = mean(d["all_R"], "kl") + noise = max(abs(r["kl"]) for r in d["zero_R"]) + for group in cfg["groups"]: + g = d["groups"][group] + retained = None if gain <= 0 else (mean(d["base_E"], "ce") - mean(g["E"], "ce")) / gain + reduction = None if risk <= 0 else 1 - mean(g["R"], "kl") / risk + matching = [] + for control in g["random"]: + matched_ids = { + int(key.split("-")[1]) + for key, m in control["matches"].items() + if m["energy_matched"] + } + e_fraction = sum(r["case_id"] in matched_ids for r in d["all_E"]) / len(d["all_E"]) + r_fraction = sum(r["case_id"] in matched_ids for r in d["all_R"]) / len(d["all_R"]) + all_r = [r for r in d["all_R"] if r["case_id"] in matched_ids] + cand_r = [r for r in g["R"] if r["case_id"] in matched_ids] + random_r = [r for r in control["R"] if r["case_id"] in matched_ids] + difference = None if not all_r else mean(random_r, "kl") - mean(cand_r, "kl") + matching.append( + { + "seed": control["seed"], + "E_coverage": e_fraction, + "R_coverage": r_fraction, + "candidate_minus_random_improvement": difference, + "valid": e_fraction >= cfg["matching"]["minimum_coverage"] + and r_fraction >= cfg["matching"]["minimum_coverage"], + } + ) + valid = [m for m in matching if m["valid"]] + beats_random = ( + bool(valid) + and float(np.median([m["candidate_minus_random_improvement"] for m in valid])) + > cfg["gate"]["noise_multiplier"] * noise + ) + passes = bool( + gain > 0 + and mean(d["all_E"], "correct") > mean(d["base_E"], "correct") + and retained >= cfg["gate"]["learning_retained"] + and mean(g["E"], "correct") >= mean(d["all_E"], "correct") + and risk >= max(cfg["gate"]["kl_floor"], cfg["gate"]["noise_multiplier"] * noise) + and reduction >= cfg["gate"]["kl_reduction"] + and beats_random + ) + rows.append( + { + "episode": job["episode"], + "group": group, + "E_gain": gain, + "learning_retained": retained, + "R_kl": risk, + "R_kl_reduction": reduction, + "E_correct_all": mean(d["all_E"], "correct"), + "E_correct_candidate": mean(g["E"], "correct"), + "noise": noise, + "matching": matching, + "beats_random": beats_random, + "passes": passes, + } + ) + eligible = [ + g + for g in cfg["groups"] + if sum(r["passes"] for r in rows if r["group"] == g) >= cfg["gate"]["units_required"] + ] + winner = ( + min( + eligible, + key=lambda g: ( + -float(np.mean([r["R_kl_reduction"] for r in rows if r["group"] == g])), + cfg["groups"].index(g), + ), + ) + if eligible + else None + ) + result = { + "time": now(), + "rows": rows, + "candidate": winner, + "status": "eligible_for_confirmation" if winner else "stop_after_development", + "confirmation_started": False, + "selection_uses_U": False, + "coverage_rule": "At least 80% of E and R must have disjoint count/bin/energy matches " + "in a fixed random seed; compare candidate/random on identical matched records", + } + write(ART / "candidate-decision.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition.py new file mode 100644 index 0000000000000000000000000000000000000000..a05d1c9d956093315cedab365228e2fce72b6022 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition.py @@ -0,0 +1,629 @@ +"""Complete GPT/Loop training on original 2Wiki questions and atomic facts.""" + +from __future__ import annotations + +import copy +import hashlib +import json +import math +import os +import time +from contextlib import nullcontext +from pathlib import Path + +import numpy as np +import torch +import torch.nn.functional as F +from transformers import GPT2Config, GPT2TokenizerFast + +from .grok_depth import utc +from .grokking_reproduction import ReproductionGPT, model_digest +from .realworld_composition_data import ( + answer_scores, + atomic_question, + encode_example, + sha256, + write_json, +) + + +def construct(config, spec, device): + """Build the same eight-block reference before taking a shared prefix.""" + torch.manual_seed(spec["initialization"]) + options = { + "vocab_size": config["vocab_size"], + "n_positions": config.get("positions", 1024), + "n_embd": config["hidden_size"], + "n_head": config["attention_heads"], + "n_layer": 8, + "resid_pdrop": config["dropout"], + "embd_pdrop": config["dropout"], + "attn_pdrop": config["dropout"], + "activation_function": "gelu_new", + "use_cache": False, + } + model = ReproductionGPT(GPT2Config(**options), repeats=spec["repeats"]) + model.transformer.h = torch.nn.ModuleList(list(model.transformer.h)[: spec["unique_layers"]]) + model.config.n_layer = spec["unique_layers"] + return model.to(device) + + +def shared_prefix_digest(model): + digest = hashlib.sha256() + for name, tensor in model.state_dict().items(): + if name.startswith("transformer.h.") and int(name.split(".")[2]) >= 4: + continue + digest.update(name.encode()) + digest.update(tensor.detach().cpu().contiguous().numpy().tobytes()) + return digest.hexdigest() + + +def tensor_digests(model): + return { + name: hashlib.sha256(tensor.detach().cpu().contiguous().numpy().tobytes()).hexdigest() + for name, tensor in model.state_dict().items() + } + + +class BatchStream: + """Keep actual incomplete epoch batches, with a complete restore state.""" + + def __init__(self, size, seed): + self.size = size + self.rng = np.random.default_rng(seed) + self.remaining = np.empty(0, dtype=np.int64) + + def batch(self, size): + if not len(self.remaining): + self.remaining = self.rng.permutation(self.size) + chosen, self.remaining = self.remaining[:size], self.remaining[size:] + return chosen + + def state_dict(self): + return { + "remaining": self.remaining.copy(), + "rng": copy.deepcopy(self.rng.bit_generator.state), + } + + def load_state_dict(self, state): + self.remaining = state["remaining"].copy() + self.rng.bit_generator.state = copy.deepcopy(state["rng"]) + + +def pack(records, pad, device): + length = math.ceil(max(len(r["encoded"]["input"]) for r in records) / 8) * 8 + targets = max(len(r["encoded"]["target"]) for r in records) + tokens = np.full((len(records), length), pad, dtype=np.int64) + positions = np.zeros((len(records), targets), dtype=np.int64) + labels = np.full((len(records), targets), -100, dtype=np.int64) + for i, record in enumerate(records): + encoded = record["encoded"] + tokens[i, : len(encoded["input"])] = encoded["input"] + n = len(encoded["target"]) + positions[i, :n] = np.arange(len(encoded["prefix"]) - 1, len(encoded["prefix"]) - 1 + n) + labels[i, :n] = encoded["target"] + return tuple(torch.as_tensor(a, device=device) for a in (tokens, positions, labels)) + + +def example_losses(logits, labels): + valid = labels != -100 + if not bool(valid.any(dim=1).all()): + raise ValueError("Every example must supervise its answer and EOS") + losses = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), reduction="none").view_as( + labels + ) + return losses.sum(dim=1) / valid.sum(dim=1) + + +def optimizer_for(model, lr, decay): + params = list(model.named_parameters()) + groups = [ + { + "params": [p for n, p in params if not any(s in n for s in ["bias", "ln"])], + "weight_decay": decay, + }, + { + "params": [p for n, p in params if any(s in n for s in ["bias", "ln"])], + "weight_decay": 0.0, + }, + ] + return torch.optim.AdamW( + groups, lr=lr, betas=(0.9, 0.999), eps=1e-8, fused=next(model.parameters()).is_cuda + ) + + +def autocast(device): + return ( + torch.autocast("cuda", dtype=torch.bfloat16) + if torch.device(device).type == "cuda" + else nullcontext() + ) + + +def update(model, optimizer, records, spec, device, pad): + model.train() + optimizer.zero_grad(set_to_none=True) + loss_total, executed, readout, attention = 0.0, 0, 0, 0 + for start in range(0, len(records), spec["microbatch_size"]): + chunk = records[start : start + spec["microbatch_size"]] + tokens, positions, labels = pack(chunk, pad, device) + with autocast(device): + loss = example_losses(model(tokens, positions), labels).sum() / len(records) + loss.backward() + loss_total += float(loss.detach()) + executed += tokens.numel() + readout += positions.numel() + attention += len(chunk) * tokens.shape[1] ** 2 + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) + if not math.isfinite(loss_total) or not math.isfinite(float(norm)): + raise FloatingPointError("Nonfinite loss or gradient; preserve this failure") + optimizer.step() + d, blocks = model.config.n_embd, len(model.transformer.h) * model.repeats + flops = ( + 6 * 12 * d * d * blocks * executed + + 6 * d * model.config.vocab_size * readout + + 12 * blocks * d * attention + ) + return { + "loss": loss_total, + "gradient_norm": float(norm), + "executed_input_tokens": executed, + "effective_input_tokens": sum(len(r["encoded"]["input"]) for r in records), + "estimated_matmul_training_flops": flops, + } + + +@torch.no_grad() +def generate(model, prefixes, tokenizer, device, limit=64, sequence_limit=256): + """Right-padded greedy generation; only the question prefix enters the model.""" + model.eval() + sizes = np.array([len(p) for p in prefixes], dtype=np.int64) + if not len(sizes) or not (sizes > 0).all() or not (sizes <= sequence_limit).all(): + raise ValueError("Generation requires nonempty prefixes within the sequence limit") + budgets = np.minimum(limit, sequence_limit - sizes) + tokens = torch.full( + (len(prefixes), min(sequence_limit, int(sizes.max()) + limit)), + tokenizer.eos_token_id, + device=device, + dtype=torch.long, + ) + for i, prefix in enumerate(prefixes): + tokens[i, : len(prefix)] = torch.as_tensor(prefix, device=device) + output, ended = [[] for _ in prefixes], np.zeros(len(prefixes), dtype=bool) + for offset in range(limit): + active = ~ended & (offset < budgets) + if not active.any(): + break + length = min(sequence_limit, int(sizes.max()) + offset) + positions = torch.as_tensor(np.minimum(sizes + offset - 1, length - 1), device=device)[ + :, None + ] + with autocast(device): + selected = model(tokens[:, :length], positions)[:, 0].argmax(-1) + chosen = selected.cpu().tolist() + for i, token in enumerate(chosen): + if active[i]: + output[i].append(token) + ended[i] = token == tokenizer.eos_token_id + indices = torch.as_tensor(np.flatnonzero(active), device=device) + tokens[indices, torch.as_tensor(sizes[active] + offset, device=device)] = selected[indices] + model.train() + return [ + { + "prediction": tokenizer.decode( + ids[:-1] if stop else ids, skip_special_tokens=True + ).strip(), + "generated_tokens": ids, + "eos": bool(stop), + "truncated": not bool(stop), + "context_limit_reached": not bool(stop) and bool(len(ids) >= sequence_limit - size), + "generation_limit_reached": not bool(stop) and len(ids) >= limit, + } + for ids, stop, size in zip(output, ended, sizes, strict=True) + ] + + +def aggregate(predictions): + fields = ["canonical_em", "alias_em", "unambiguous_alias_em", "f1", "nll", "eos", "truncated"] + result = {"n": len(predictions)} + for key in fields: + values = [float(p[key]) for p in predictions if p[key] is not None] + result[key] = sum(values) / len(values) if values else None + if key == "nll": + result["nll_n"] = len(values) + eligible = [p for p in predictions if p.get("has_unambiguous_answer", True)] + result["unambiguous_answer_coverage"] = ( + len(eligible) / len(predictions) if predictions else None + ) + result["unambiguous_alias_em_eligible"] = ( + sum(float(p["unambiguous_alias_em"]) for p in eligible) / len(eligible) + if eligible + else None + ) + result["answer_accuracy"] = result["alias_em"] + return result + + +@torch.no_grad() +def evaluate(model, records, tokenizer, device, batch_size=32): + predictions = [] + for start in range(0, len(records), batch_size): + chunk = records[start : start + batch_size] + generated = generate(model, [r["encoded"]["prefix"] for r in chunk], tokenizer, device) + model.eval() + tokens, positions, labels = pack(chunk, tokenizer.eos_token_id, device) + with autocast(device): + losses = example_losses(model(tokens, positions), labels).float().cpu().tolist() + for row, result, loss in zip(chunk, generated, losses, strict=True): + em, f1 = answer_scores(result["prediction"], [row["answer"], *row.get("aliases", [])]) + unique_answers = row.get( + "unambiguous_answers", [row["answer"], *row.get("unambiguous_aliases", [])] + ) + result.update( + id=row["id"], + canonical_em=answer_scores(result["prediction"], [row["answer"]])[0], + alias_em=em, + f1=f1, + nll=loss, + unambiguous_alias_em=answer_scores(result["prediction"], unique_answers)[0], + has_unambiguous_answer=bool(unique_answers), + canonical_answer_globally_unambiguous=row.get( + "canonical_answer_globally_unambiguous", True + ), + gold=row["answer"], + role=row.get("role"), + required_role=row.get("required_role"), + ) + predictions.append(result) + model.train() + return aggregate(predictions), predictions + + +def evaluate_dataset(model, data, tokenizer, device, full=False, autonomous=False): + atoms = {r["id"]: r for r in data["atoms"]} + chains = {r["id"]: r for r in data["train_compositions"] + data["evaluation_compositions"]} + panels = data["panels"] + groups = { + "atomic": list(atoms.values()) if full else [atoms[i] for i in panels["atomic"]], + "train_composition": data["train_compositions"] + if full + else [chains[i] for i in panels["train_composition"]], + } + selected = ( + data["evaluation_compositions"] + if full + else [chains[i] for name, ids in panels.items() if name.startswith("test_") for i in ids] + ) + groups["test_all"] = selected + metrics, raw = {}, {} + for name, records in groups.items(): + metrics[name], raw[name] = ( + evaluate(model, records, tokenizer, device) if records else (aggregate([]), []) + ) + lookup = {p["id"]: p for p in raw["atomic"]} + for role in ["II", "IO", "OI", "OO"]: + metrics["test_" + role.lower()] = aggregate( + [p for p in raw["test_all"] if p["role"] == role] + ) + metrics["test_required_role_" + role.lower()] = aggregate( + [p for p in raw["test_all"] if p["required_role"] == role] + ) + filters = { + "test_unambiguous_canonical_answers": lambda r: r.get( + "canonical_answer_globally_unambiguous", True + ), + "test_no_known_shortcut": lambda r: not r.get("known_direct_shortcut", False), + "test_head_tail_unseen": lambda r: not r.get( + "head_tail_seen_in_combination_training", False + ), + "test_seen_operation": lambda r: r.get("operation_seen", False), + "test_no_shortcut_seen_operation": lambda r: not r.get("known_direct_shortcut", False) + and r.get("operation_seen", False), + } + for name, include in filters.items(): + ids = {r["id"] for r in selected if include(r)} + metrics[name] = aggregate([p for p in raw["test_all"] if p["id"] in ids]) + metrics[name]["coverage"] = len(ids) / len(selected) if selected else None + for index, name in enumerate(["test_first_atom", "test_second_atom"]): + metrics[name] = aggregate([lookup[r["atom_ids"][index]] for r in selected]) + metrics["gold_bridge_second"] = metrics["test_second_atom"].copy() + prerequisite = {r["id"] for r in selected if all(lookup[a]["alias_em"] for a in r["atom_ids"])} + metrics["test_prerequisites_correct"] = aggregate( + [p for p in raw["test_all"] if p["id"] in prerequisite] + ) + metrics["test_prerequisites_correct"]["coverage"] = ( + len(prerequisite) / len(selected) if selected else None + ) + if autonomous: + second_calls = [] + invalid = [] + for row in selected: + bridge_prediction = lookup[row["atom_ids"][0]]["prediction"] + q = atomic_question(bridge_prediction, row["edges"][1][1]) + try: + encoded = encode_example(tokenizer, q, row["answer"]) + except ValueError: + invalid.append(row) + continue + second_calls.append( + {**row, "question": q, "encoded": encoded, "autonomous_bridge": bridge_prediction} + ) + _, predictions = ( + evaluate(model, second_calls, tokenizer, device) if second_calls else (None, []) + ) + for row, result in zip(second_calls, predictions, strict=True): + result["bridge_prediction"] = row["autonomous_bridge"] + result["second_question"] = row["question"] + predictions.extend( + { + "id": row["id"], + "canonical_em": 0.0, + "alias_em": 0.0, + "unambiguous_alias_em": 0.0, + "f1": 0.0, + "nll": None, + "eos": False, + "truncated": True, + "has_unambiguous_answer": bool(row.get("unambiguous_answers", [])), + "canonical_answer_globally_unambiguous": row.get( + "canonical_answer_globally_unambiguous", True + ), + "invalid_generated_bridge_length": True, + } + for row in invalid + ) + raw["autonomous"] = predictions + metrics["autonomous"] = aggregate(predictions) + metrics["autonomous"]["invalid_bridge_prompts"] = len(invalid) + return metrics, raw + + +def save_checkpoint(path, model, optimizer, stream, counts, step, counters, wall_seconds=None): + temporary = Path(path).with_suffix(".tmp") + torch.save( + { + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "step": step, + "counters": counters, + "wall_seconds": wall_seconds, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(), + }, + temporary, + ) + temporary.replace(path) + + +def worker(config, spec, gpu): + torch.set_num_threads(4) + torch.set_num_interop_threads(1) + torch.cuda.set_device(gpu) + torch.backends.cuda.matmul.allow_tf32 = True + device = f"cuda:{gpu}" + data = json.loads(Path(config["data_file"]).read_text()) + assert sha256(config["data_file"]) == config["data_sha256"] + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + phase = config.get("phase", "development") + out = Path(config["results_root"]) / phase / spec["name"] + out.mkdir(parents=True, exist_ok=True) + model = construct(config["model"], spec, device) + optimizer = optimizer_for(model, spec["learning_rate"], spec["weight_decay"]) + records = data["atoms"] + data["train_compositions"] + stream = BatchStream(len(records), spec["sampling_seed"]) + counts = np.zeros(len(records), dtype=np.int64) + counters = dict( + training_seconds=0.0, + examples=0, + supervised_tokens=0, + executed_input_tokens=0, + effective_input_tokens=0, + estimated_matmul_training_flops=0, + ) + history, initial_step, wall_offset = [], 0, 0.0 + started = time.perf_counter() + if (out / "latest.pt").exists(): + checkpoint = torch.load(out / "latest.pt", map_location=device, weights_only=False) + model.load_state_dict(checkpoint["model"]) + optimizer.load_state_dict(checkpoint["optimizer"]) + stream.load_state_dict(checkpoint["stream"]) + counts, initial_step, counters = ( + checkpoint["counts"], + checkpoint["step"], + checkpoint["counters"], + ) + torch.set_rng_state(checkpoint["cpu_rng"].cpu()) + torch.cuda.set_rng_state(checkpoint["cuda_rng"].cpu()) + history = [ + r for r in json.loads((out / "learning.json").read_text()) if r["step"] <= initial_step + ] + wall_offset = checkpoint.get("wall_seconds") + if wall_offset is None: + wall_offset = history[-1]["wall_seconds"] if history else 0.0 + metadata = json.loads((out / "run.json").read_text()) + metadata.update(pid=os.getpid(), gpu=gpu, resumed_from_step=initial_step) + write_json(out / "run.json", metadata) + del checkpoint + else: + torch.manual_seed(spec["dropout_seed"]) + metadata = { + "spec": spec, + "model": config["model"], + "phase": phase, + "evaluation_nodes": config["evaluation_nodes"], + "execution_lock_sha256": sha256(config["execution_lock"]), + "world_sha256": config["data_sha256"], + "initial_model_sha256": model_digest(model), + "initial_tensor_sha256": tensor_digests(model), + "common_four_block_initial_sha256": shared_prefix_digest(model), + "parameters": sum(p.numel() for p in model.parameters()), + "atomic_examples": len(data["atoms"]), + "composition_examples": len(data["train_compositions"]), + "vocab_size": len(tokenizer), + "dtype": "BF16 AMP; FP32 parameters and Adam states", + "gpu": gpu, + "gpu_name": torch.cuda.get_device_name(gpu), + "pid": os.getpid(), + "job_type": phase + "-training", + "tracking_group": config["tracking"]["group"], + } + write_json(out / "run.json", metadata) + write_json(out / "learning.json", []) + nodes = set(config["evaluation_nodes"]) + last_loss = None + for step in range(initial_step, spec["steps"] + 1): + if step > initial_step: + for group in optimizer.param_groups: + group["lr"] = spec["learning_rate"] * min((step - 1) / spec["warmup_steps"], 1.0) + ids = stream.batch(spec["batch_size"]) + selected = [records[i] for i in ids] + torch.cuda.synchronize() + began = time.perf_counter() + values = update(model, optimizer, selected, spec, device, tokenizer.eos_token_id) + torch.cuda.synchronize() + counters["training_seconds"] += time.perf_counter() - began + last_loss = values["loss"] + counts[ids] += 1 + counters["examples"] += len(ids) + counters["supervised_tokens"] += sum(len(r["encoded"]["target"]) for r in selected) + for key in [ + "executed_input_tokens", + "effective_input_tokens", + "estimated_matmul_training_flops", + ]: + counters[key] += values[key] + if step % 50 == 0: + write_json( + out / "status.json", + { + "state": "training", + "step": step, + "target_step": spec["steps"], + "loss": last_loss, + "training_seconds": counters["training_seconds"], + "examples": counters["examples"], + "wall_seconds": wall_offset + time.perf_counter() - started, + "pid": os.getpid(), + "updated_utc": utc(), + }, + ) + if step in nodes and not any(r["step"] == step for r in history): + metrics, predictions = evaluate_dataset(model, data, tokenizer, device) + write_json(out / f"predictions-{step:07d}.json", predictions) + history.append( + { + "step": step, + "metrics": metrics, + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "loss": last_loss, + "atomic_epochs": float(counts[: len(data["atoms"])].mean()), + "composition_epochs": float(counts[len(data["atoms"]) :].mean()), + "peak_gpu_memory_bytes": torch.cuda.max_memory_allocated(), + "created_utc": utc(), + } + ) + write_json(out / "learning.json", history) + save_checkpoint( + out / "latest.pt", + model, + optimizer, + stream, + counts, + step, + counters, + wall_offset + time.perf_counter() - started, + ) + torch.save( + {"model": model.state_dict(), "step": step}, out / f"checkpoint-{step:07d}.pt" + ) + np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=counts) + print( + json.dumps( + { + "step": step, + "loss": last_loss, + "metrics": metrics, + "training_seconds": counters["training_seconds"], + } + ), + flush=True, + ) + elif ( + step > initial_step and step % config.get("resume_checkpoint_interval", 1000000000) == 0 + ): + save_checkpoint( + out / "latest.pt", + model, + optimizer, + stream, + counts, + step, + counters, + wall_offset + time.perf_counter() - started, + ) + metrics, predictions = evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + write_json(out / "endpoint-predictions.json", predictions) + write_json(out / "endpoint.json", metrics) + result = { + "state": "trained_pending_independent_reload", + "step": spec["steps"], + "pid": os.getpid(), + "model_sha256": model_digest(model), + "checkpoint_sha256": sha256(out / "latest.pt"), + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "completed_utc": utc(), + } + write_json(out / "trained.json", result) + write_json(out / "status.json", result) + + +def audit(config, spec, gpu): + torch.set_num_threads(4) + torch.set_num_interop_threads(1) + torch.cuda.set_device(gpu) + torch.backends.cuda.matmul.allow_tf32 = True + device = f"cuda:{gpu}" + out = Path(config["results_root"]) / config.get("phase", "development") / spec["name"] + trained = json.loads((out / "trained.json").read_text()) + assert trained["pid"] != os.getpid() + assert sha256(out / "latest.pt") == trained["checkpoint_sha256"] + assert sha256(config["data_file"]) == config["data_sha256"] + data = json.loads(Path(config["data_file"]).read_text()) + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + model = construct(config["model"], spec, device) + state = torch.load(out / "latest.pt", map_location="cpu", weights_only=False) + model.load_state_dict(state["model"]) + assert state["step"] == spec["steps"] + del state + assert model_digest(model) == trained["model_sha256"] + metrics, predictions = evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + expected = json.loads((out / "endpoint-predictions.json").read_text()) + assert predictions == expected, ( + "Endpoint generation or teacher-forced scores do not independently reproduce" + ) + assert metrics == json.loads((out / "endpoint.json").read_text()) + result = { + "passed": True, + "pid": os.getpid(), + "source_training_pid": trained["pid"], + "checkpoint_sha256": trained["checkpoint_sha256"], + "model_sha256": trained["model_sha256"], + "predictions_recomputed": sum(len(p) for p in predictions.values()), + "completed_utc": utc(), + } + write_json(out / "audit.json", result) + write_json( + out / "complete.json", {**trained, "state": "complete", "independently_reloaded": True} + ) + write_json( + out / "status.json", + {"state": "complete", "step": spec["steps"], "independently_reloaded": True}, + ) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition_data.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition_data.py new file mode 100644 index 0000000000000000000000000000000000000000..e907ece415c9c6e027e965818c1b8e6f82a2462e --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition_data.py @@ -0,0 +1,270 @@ +"""Source-grounded 2Wiki closed-book data preparation, without model access. + +Answer normalization and alias scoring follow the pinned author's v1.1 scorer. +The original questions and facts are retained; this is an adapted task in which +evaluation facts may be learned separately, never with evaluation chain labels. +""" + +from __future__ import annotations + +import hashlib +import json +import re +import string +import zipfile +from collections import Counter, defaultdict +from pathlib import Path + +ARCHIVE_SHA = "95df2bf56fdabe034e27aebc580e02264232203cf52552f9efe8a919e5529eef" +SPLIT_SALT = "2wiki-realworld-v1:" +QUESTION_TEMPLATES = { + "father": "Who is the father of {subject}?", + "mother": "Who is the mother of {subject}?", + "child": "Who is the child of {subject}?", + "spouse": "Who is the spouse of {subject}?", + "director": "Who directed {subject}?", + "performer": "Who performed {subject}?", + "composer": "Who composed {subject}?", + "creator": "Who created {subject}?", + "editor": "Who edited {subject}?", + "presenter": "Who presented {subject}?", + "manufacturer": "Who manufactured {subject}?", + "publisher": "Who published {subject}?", + "founded by": "Who founded {subject}?", + "student of": "Who was the teacher of {subject}?", + "educated at": "Where was {subject} educated?", + "employer": "Who employed {subject}?", + "date of birth": "On what date was {subject} born?", + "date of death": "On what date did {subject} die?", + "place of birth": "Where was {subject} born?", + "place of death": "Where did {subject} die?", + "place of burial": "Where was {subject} buried?", + "place of detention": "Where was {subject} detained?", + "cause of death": "What was the cause of death of {subject}?", + "country of citizenship": "What is the country of citizenship of {subject}?", + "country": "In which country is {subject}?", + "inception": "On what date was {subject} established?", + "award received": "What award did {subject} receive?", + "has part": "What is a part of {subject}?", +} + + +def sha256(path): + result = hashlib.sha256() + with Path(path).open("rb") as handle: + for block in iter(lambda: handle.read(8 * 1024 * 1024), b""): + result.update(block) + return result.hexdigest() + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n") + temporary.replace(path) + + +def order(value, salt=SPLIT_SALT): + return hashlib.sha256((salt + str(value)).encode()).hexdigest() + + +def normalize_answer(value): + value = "".join(c for c in value.lower() if c not in string.punctuation) + return " ".join(re.sub(r"\b(a|an|the)\b", " ", value).split()) + + +def answer_scores(prediction, answers): + """Max EM/F1 across the author's canonical answer and entity aliases.""" + p = normalize_answer(prediction) + scores = [] + for answer in answers: + a = normalize_answer(answer) + if (p in {"yes", "no", "noanswer"} or a in {"yes", "no", "noanswer"}) and p != a: + f1 = 0.0 + else: + common = sum((Counter(p.split()) & Counter(a.split())).values()) + f1 = 2 * common / (len(p.split()) + len(a.split())) if common else 0.0 + scores.append((float(p == a), f1)) + return max((s[0] for s in scores), default=0.0), max((s[1] for s in scores), default=0.0) + + +def entity_id(identifier, surface): + if re.fullmatch(r"Q\d+", str(identifier)): + return identifier + return "literal:" + " ".join(str(surface).casefold().split()) + + +def extract_chain(row): + edges, surfaces = row.get("evidences_id", []), row.get("evidences", []) + if row.get("type") != "compositional" or len(edges) != 2 or len(surfaces) != 2: + return None + if any(len(e) != 3 for e in edges + surfaces): + return None + converted = [ + (entity_id(e[0], s[0]), str(e[1]), entity_id(e[2], s[2])) + for e, s in zip(edges, surfaces, strict=True) + ] + for indices in [(0, 1), (1, 0)]: + first, second = [converted[i] for i in indices] + if first[2] == second[0] and first[0] != second[2]: + return (first, second), [surfaces[i] for i in indices] + return None + + +class Components: + def __init__(self): + self.parent = {} + + def find(self, node): + self.parent.setdefault(node, node) + while self.parent[node] != node: + self.parent[node] = self.parent[self.parent[node]] + node = self.parent[node] + return node + + def union(self, first, second): + first, second = self.find(first), self.find(second) + if first != second: + self.parent[max(first, second)] = min(first, second) + + +def support_sentences(row): + context = {title: sentences for title, sentences in row["context"]} + result = [] + for title, index in row["supporting_facts"]: + if title not in context or not 0 <= index < len(context[title]): + result.append( + {"title": title, "index": index, "sentence": "", "invalid_support_reference": True} + ) + continue + result.append({"title": title, "index": index, "sentence": context[title][index]}) + return result + + +def prior_cases(project): + path = Path(project) / "docs/development-artifacts/twohop-frozen-v1/case-manifest.json" + if not path.exists(): + return set() + return {r["id"] for r in json.loads(path.read_text()) if r["dataset"] == "2wiki"} + + +def extract_archive(archive, project): + if sha256(archive) != ARCHIVE_SHA: + raise ValueError("2Wiki archive differs from the pinned author data") + records, aliases, labels = [], {}, defaultdict(Counter) + groups = Components() + with zipfile.ZipFile(archive) as source: + for line in source.read("id_aliases.json").decode().splitlines(): + entry = json.loads(line) + aliases[entry["Q_id"]] = entry["aliases"] + entry.get("demonyms", []) + for split in ("train", "dev"): + for row in json.loads(source.read(split + ".json")): + parsed = extract_chain(row) + if parsed is None: + continue + edges, surfaces = parsed + groups.union(edges[0][0], edges[0][2]) + for edge, surface in zip(edges, surfaces, strict=True): + labels[edge[0]][surface[0]] += 1 + labels[edge[2]][surface[2]] += 1 + records.append( + { + "id": row["_id"], + "source_split": split, + "question": row["question"], + "answer": row["answer"], + "answer_id": row.get("answer_id"), + "edges": edges, + "surfaces": surfaces, + "support": support_sentences(row), + } + ) + canonical = { + key: sorted(counts, key=lambda s: (-counts[s], s))[0] for key, counts in labels.items() + } + alias_owners = defaultdict(set) + for identifier, names in aliases.items(): + for name in names: + alias_owners[normalize_answer(name)].add(identifier) + old = prior_cases(project) + subject_relation = defaultdict(set) + for row in records: + for edge in row["edges"]: + subject_relation[edge[:2]].add(edge[2]) + ambiguous = {key for key, values in subject_relation.items() if len(values) > 1} + for row in records: + row["group"] = groups.find(row["edges"][0][0]) + row["development_group"] = int(order(row["group"])[:8], 16) % 5 == 0 + row["known_prior_case"] = row["id"] in old + row["aliases"] = aliases.get(row["answer_id"], []) + row["unambiguous_aliases"] = [ + a for a in row["aliases"] if len(alias_owners[normalize_answer(a)]) == 1 + ] + row["structural_errors"] = [] + if any(s.get("invalid_support_reference") for s in row["support"]): + row["structural_errors"].append("invalid_support_sentence_reference") + if any(edge[:2] in ambiguous for edge in row["edges"]): + row["structural_errors"].append("multiple_objects_for_subject_relation") + if row["answer_id"] and row["answer_id"] != row["edges"][1][2]: + row["structural_errors"].append("answer_id_does_not_match_chain") + if not row["answer_id"] and normalize_answer(row["answer"]) != normalize_answer( + row["surfaces"][1][2] + ): + row["structural_errors"].append("literal_answer_does_not_match_chain") + if any(edge[1] not in QUESTION_TEMPLATES for edge in row["edges"]): + row["structural_errors"].append("unreviewed_relation_template") + row["support_surface_flags"] = [] + text = normalize_answer(" ".join(s["title"] + " " + s["sentence"] for s in row["support"])) + for i, (edge, surface) in enumerate(zip(row["edges"], row["surfaces"], strict=True)): + for j in [0, 2]: + choices = [surface[j], *aliases.get(edge[j], [])] + if not any(normalize_answer(c) in text for c in choices if normalize_answer(c)): + row["support_surface_flags"].append( + f"edge{i}_position{j}_not_literal_in_support" + ) + return records, aliases, canonical + + +def review_sample(records, size=200): + """Round-robin relation pairs, then fixed hashes; independent of model scores.""" + result = [] + for split in ("train", "dev"): + by_pair = defaultdict(list) + for row in records: + if row["source_split"] == split: + by_pair[tuple(e[1] for e in row["edges"])].append(row) + for rows in by_pair.values(): + rows.sort(key=lambda r: order(r["id"], "2wiki-semantic-review-v1:")) + chosen = [] + while len(chosen) < size: + added = False + for pair in sorted(by_pair, key=lambda p: order(p, "relation-review:")): + if by_pair[pair]: + chosen.append(by_pair[pair].pop(0)) + added = True + if len(chosen) == size: + break + if not added: + break + result.extend(chosen) + return result + + +def atomic_question(subject, relation): + return QUESTION_TEMPLATES[relation].format(subject=subject) + + +def prompt(question): + return "Question: " + question + "\nAnswer:" + + +def encode_example(tokenizer, question, answer, limit=256, generation_limit=64): + prefix = tokenizer.encode(prompt(question), add_special_tokens=False) + target = tokenizer.encode(" " + answer, add_special_tokens=False) + [tokenizer.eos_token_id] + joint = tokenizer.encode(prompt(question) + " " + answer, add_special_tokens=False) + if joint != prefix + target[:-1]: + raise ValueError("Answer boundary changes joint tokenization") + if len(prefix) + len(target) > limit or len(target) > generation_limit: + raise ValueError("Example exceeds the frozen length limits; never truncate an answer") + return {"prefix": prefix, "target": target, "input": (prefix + target)[:-1]} diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation.py new file mode 100644 index 0000000000000000000000000000000000000000..5cfed1010e1cc6f386e54d10c69675d34f4bed4a --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation.py @@ -0,0 +1,322 @@ +"""Data-only confirmation isolation and independent endpoint recounting.""" + +from __future__ import annotations + +import ast +import copy +import json +import re +import statistics +import string +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from .realworld_composition_data import normalize_answer, order, sha256, write_json + + +def head_bridge_names(data, canonical, aliases): + names = defaultdict(set) + for row in data["train_compositions"] + data["evaluation_compositions"]: + for index in (0, 2): + identifier = row["edges"][0][index] + labels = [canonical[identifier], row["surfaces"][0][index]] + for label in labels + aliases.get(identifier, []): + normalized = normalize_answer(label) + if normalized: + names[identifier].add(normalized) + return names + + +def answer_owners(canonical, aliases): + owners = defaultdict(set) + for identifier in set(canonical) | set(aliases): + for name in [canonical.get(identifier, ""), *aliases.get(identifier, [])]: + normalized = normalize_answer(name) + if normalized: + owners[normalized].add(identifier) + return owners + + +def isolate_confirmation(candidate, development, canonical, aliases): + """Exclude every chain touching a development head/bridge name, then rebuild.""" + dev_names = set().union(*head_bridge_names(development, canonical, aliases).values()) + formal_names = head_bridge_names(candidate, canonical, aliases) + excluded_entities = {e for e, names in formal_names.items() if names & dev_names} + excluded = {} + parts = {} + for key in ("train_compositions", "evaluation_compositions"): + excluded[key] = [ + r["id"] + for r in candidate[key] + if {r["edges"][0][0], r["edges"][0][2]} & excluded_entities + ] + excluded_ids = set(excluded[key]) + parts[key] = [copy.deepcopy(r) for r in candidate[key] if r["id"] not in excluded_ids] + all_chains = parts["train_compositions"] + parts["evaluation_compositions"] + used = {a for r in all_chains for a in r["atom_ids"]} + atoms = [copy.deepcopy(r) for r in candidate["atoms"] if r["id"] in used] + first, second = ({r["atom_ids"][i] for r in parts["train_compositions"]} for i in (0, 1)) + seen = first | second + direct = {(r["edge"][0], r["edge"][2]) for r in atoms} + pairs = {(r["edges"][0][0], r["edges"][1][2]) for r in parts["train_compositions"]} + operations = {tuple(e[1] for e in r["edges"]) for r in parts["train_compositions"]} + owners = answer_owners(canonical, aliases) + for row in atoms + all_chains: + identifier = row["edge"][2] if "edge" in row else row["edges"][1][2] + row["canonical_answer_globally_unambiguous"] = owners[normalize_answer(row["answer"])] == { + identifier + } + for row in all_chains: + a, b = row["atom_ids"] + row["role"] = ("I" if a in seen else "O") + ("I" if b in seen else "O") + row["required_role"] = ("I" if a in first else "O") + ("I" if b in second else "O") + pair = row["edges"][0][0], row["edges"][1][2] + row["known_direct_shortcut"] = pair in direct + row["head_tail_seen_in_combination_training"] = pair in pairs + row["operation_seen"] = tuple(e[1] for e in row["edges"]) in operations + panels = { + "test_" + role.lower(): [ + r["id"] + for r in sorted( + [r for r in parts["evaluation_compositions"] if r["role"] == role], + key=lambda r: order(r["id"], "panel:"), + )[:64] + ] + for role in ("II", "IO", "OI", "OO") + } + panels["train_composition"] = [ + r["id"] + for r in sorted(parts["train_compositions"], key=lambda r: order(r["id"], "panel:"))[:128] + ] + selected = {i for ids in panels.values() for i in ids} + required = {a for r in all_chains if r["id"] in selected for a in r["atom_ids"]} + panels["atomic"] = sorted( + required + | {r["id"] for r in sorted(atoms, key=lambda r: order(r["id"], "atom-panel:"))[:128]} + ) + data = {"atoms": atoms, **parts, "panels": panels} + report = { + "rule": ( + "Exclude chains whose head/bridge canonical, annotated surface or official alias " + "name overlaps development head/bridge names after author normalization; " + "retain shared tails." + ), + "excluded_entities": sorted(excluded_entities), + "excluded_case_ids": excluded, + "excluded_counts": {key: len(ids) for key, ids in excluded.items()}, + "colliding_names": sorted(dev_names & set().union(*formal_names.values())), + "model_results_used": False, + } + return data, report + + +def audit_confirmation(data, development, canonical, aliases): + """Recount from the selected records rather than selection bookkeeping.""" + atoms = {r["id"]: r for r in data["atoms"]} + train, held = data["train_compositions"], data["evaluation_compositions"] + rows = train + held + dev_names = head_bridge_names(development, canonical, aliases) + formal_names = head_bridge_names(data, canonical, aliases) + assert not set(dev_names) & set(formal_names) + assert not set().union(*dev_names.values()) & set().union(*formal_names.values()) + assert len(atoms) == len(data["atoms"]) + assert len({r["id"] for r in rows}) == len(rows) + + def chain(row): + return tuple(tuple(e) for e in row["edges"]) + + assert not {chain(r) for r in train} & {chain(r) for r in held} + held_questions = {normalize_answer(r["question"]) for r in held} + assert not {normalize_answer(r["question"]) for r in train} & held_questions + assert not {normalize_answer(r["question"]) for r in atoms.values()} & held_questions + assert not {normalize_answer(r["question"]) for r in atoms.values()} & { + normalize_answer(r["question"]) for r in development["atoms"] + } + seen = {a for r in train for a in r["atom_ids"]} + first, second = ({r["atom_ids"][i] for r in train} for i in (0, 1)) + owners = answer_owners(canonical, aliases) + for row in rows: + a, b = row["atom_ids"] + assert [atoms[a]["edge"], atoms[b]["edge"]] == row["edges"] + assert row["edges"][0][2] == row["edges"][1][0] + assert row["role"] == ("I" if a in seen else "O") + ("I" if b in seen else "O") + assert row["required_role"] == ("I" if a in first else "O") + ("I" if b in second else "O") + assert not row["structural_errors"] + assert not any(r["known_prior_case"] for r in held) + for pool in (list(atoms.values()), train, held): + prompt_answers = defaultdict(set) + for row in pool: + prompt_answers[normalize_answer(row["question"])].add(normalize_answer(row["answer"])) + identifier = row["edge"][2] if "edge" in row else row["edges"][1][2] + assert row["canonical_answer_globally_unambiguous"] == ( + owners[normalize_answer(row["answer"])] == {identifier} + ) + e = row["encoded"] + assert e["target"][-1] == 50256 and len(e["target"]) <= 64 + assert e["input"] == (e["prefix"] + e["target"])[:-1] + assert len(e["prefix"]) + len(e["target"]) <= 256 + assert all(len(answers) == 1 for answers in prompt_answers.values()) + panel_ids = {i for name, ids in data["panels"].items() if name != "atomic" for i in ids} + assert {a for r in rows if r["id"] in panel_ids for a in r["atom_ids"]} <= set( + data["panels"]["atomic"] + ) + return { + "passed": True, + "atoms": len(atoms), + "train_compositions": len(train), + "evaluation_compositions": len(held), + "evaluation_roles": dict(Counter(r["role"] for r in held)), + "required_role_counts": dict(Counter(r["required_role"] for r in held)), + "canonical_unambiguous_evaluation_count": sum( + r["canonical_answer_globally_unambiguous"] for r in held + ), + "panels": {name: len(ids) for name, ids in data["panels"].items()}, + "head_bridge_id_overlap": 0, + "head_bridge_normalized_name_overlap": 0, + "necessary_atomic_coverage": 1.0, + "known_direct_shortcuts": sum(r["known_direct_shortcut"] for r in held), + "unseen_operations": sum(not r["operation_seen"] for r in held), + "max_input_tokens": max(len(r["encoded"]["input"]) for r in list(atoms.values()) + rows), + "atomic_relations": dict(Counter(r["edge"][1] for r in atoms.values())), + "train_relation_pairs": dict(Counter(" -> ".join(e[1] for e in r["edges"]) for r in train)), + } + + +def finalize_confirmation(config): + """Independently score raw outputs using the pinned author's scorer functions.""" + root, art = Path(config["results_root"]), Path(config["artifact_root"]) + data = json.loads(Path(config["data_file"]).read_text()) + scorer = Path(config["official_scorer"]) + scope = dict(re=re, string=string, Counter=Counter) + tree = ast.parse(scorer.read_text()) + functions = [ + n + for n in tree.body + if isinstance(n, ast.FunctionDef) and n.name in {"normalize_answer", "exact_match_score"} + ] + exec(compile(ast.Module(body=functions, type_ignores=[]), str(scorer), "exec"), scope) + + def score(prediction, row): + return float( + any( + scope["exact_match_score"](prediction, g) + for g in [row["answer"], *row.get("aliases", [])] + ) + ) + + held = data["evaluation_compositions"] + summary, scores, atom_scores, exposures, metadata = {}, {}, {}, {}, {} + for spec in config["runs"]: + name = spec["name"] + out = root / config["phase"] / name + complete = json.loads((out / "complete.json").read_text()) + assert complete["step"] == spec["steps"] and complete["independently_reloaded"] + raw = json.loads((out / "endpoint-predictions.json").read_text()) + metrics = json.loads((out / "endpoint.json").read_text()) + for group, records in [ + ("atomic", data["atoms"]), + ("train_composition", data["train_compositions"]), + ("test_all", held), + ]: + by_id = {p["id"]: p for p in raw[group]} + assert len(by_id) == len(records) == len(raw[group]) + assert set(by_id) == {r["id"] for r in records} + recomputed = {r["id"]: score(by_id[r["id"]]["prediction"], r) for r in records} + assert all(recomputed[i] == by_id[i]["alias_em"] for i in recomputed) + assert abs(sum(recomputed.values()) / len(records) - metrics[group]["alias_em"]) < 1e-12 + if group == "test_all": + scores[name] = recomputed + for role in ("II", "IO", "OI", "OO"): + selected = [r for r in held if r["role"] == role] + assert ( + abs( + sum(recomputed[r["id"]] for r in selected) / len(selected) + - metrics["test_" + role.lower()]["alias_em"] + ) + < 1e-12 + ) + if group == "atomic": + atom_scores[name] = recomputed + summary[name] = metrics + exposures[name] = { + step: np.load(out / f"exposure-{step:07d}.npz")["counts"] + for step in config["evaluation_nodes"] + } + metadata[name] = json.loads((out / "run.json").read_text()) + assert complete["checkpoint_sha256"] == sha256(out / "latest.pt") + comparisons = [] + for seed in sorted({s["initialization"] for s in config["runs"]}): + specs = {s["architecture"]: s for s in config["runs"] if s["initialization"] == seed} + assert set(specs) == {"standard8", "loop4x2", "standard4"} + names = [s["name"] for s in specs.values()] + assert len({metadata[n]["common_four_block_initial_sha256"] for n in names}) == 1 + for step in config["evaluation_nodes"]: + assert all( + np.array_equal(exposures[names[0]][step], exposures[n][step]) for n in names[1:] + ) + for baseline in ("standard8", "standard4"): + loop, base = specs["loop4x2"]["name"], specs[baseline]["name"] + for role in ("all", "OO"): + selected = held if role == "all" else [r for r in held if r["role"] == role] + common = [ + r + for r in selected + if all(atom_scores[n][a] for n in (loop, base) for a in r["atom_ids"]) + ] + comparisons.append( + { + "initialization": seed, + "baseline": baseline, + "pool": role, + "n": len(selected), + "paired_difference": sum( + scores[loop][r["id"]] - scores[base][r["id"]] for r in selected + ) + / len(selected), + "both_models_necessary_atoms_correct_n": len(common), + "both_models_necessary_atoms_correct_coverage": len(common) / len(selected), + "conditional_paired_difference": sum( + scores[loop][r["id"]] - scores[base][r["id"]] for r in common + ) + / len(common) + if common + else None, + } + ) + means = {} + for architecture in ("standard8", "loop4x2", "standard4"): + names = [s["name"] for s in config["runs"] if s["architecture"] == architecture] + means[architecture] = {} + for group in ( + "atomic", + "train_composition", + "test_all", + "test_ii", + "test_io", + "test_oi", + "test_oo", + "autonomous", + ): + values = [summary[n][group]["alias_em"] for n in names] + means[architecture][group] = { + "mean": statistics.mean(values), + "sample_sd": statistics.stdev(values), + "per_initialization": values, + } + result = { + "passed": True, + "runs": len(config["runs"]), + "scientific_updates": sum(s["steps"] for s in config["runs"]), + "independent_dataset_splits": 1, + "paired_initializations": 3, + "paired_exposures_equal_at_all_nodes": True, + "architecture_scores": means, + "paired_comparisons": comparisons, + "source_data_sha256": sha256(config["data_file"]), + "official_scorer_sha256": sha256(scorer), + } + write_json(art / "confirmation-summary.json", summary) + write_json(art / "confirmation-recount-audit.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py new file mode 100644 index 0000000000000000000000000000000000000000..1b6fcadbe2e7be2944fe6e398e29c0812ca1329f --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py @@ -0,0 +1,119 @@ +"""Registered relation/component and paired-knowledge trajectory descriptions.""" + +from __future__ import annotations + +import json +from collections import defaultdict +from pathlib import Path + +from .realworld_composition_data import write_json + + +def threshold_intervals(history, group, threshold): + passed = [r["metrics"][group]["alias_em"] >= threshold for r in history] + + def interval(index): + if index is None: + return None + return [history[index - 1]["step"] if index else None, history[index]["step"]] + + first = next((i for i, value in enumerate(passed) if value), None) + sustained = next((i for i, value in enumerate(passed) if value and all(passed[i:])), None) + return { + "first_observed_interval": interval(first), + "sustained_observed_interval": interval(sustained), + } + + +def analyze_confirmation(config): + root = Path(config["results_root"]) / config["phase"] + data = json.loads(Path(config["data_file"]).read_text()) + held = {r["id"]: r for r in data["evaluation_compositions"]} + endpoint_groups, thresholds, nodes = {}, {}, {} + for spec in config["runs"]: + name = spec["name"] + out = root / name + raw = json.loads((out / "endpoint-predictions.json").read_text())["test_all"] + by_relation, by_component = defaultdict(list), defaultdict(list) + for prediction in raw: + row = held[prediction["id"]] + by_relation[" -> ".join(e[1] for e in row["edges"])].append(prediction["alias_em"]) + by_component[row["group"]].append(prediction["alias_em"]) + endpoint_groups[name] = { + key: {k: {"n": len(v), "alias_em": sum(v) / len(v)} for k, v in groups.items()} + for key, groups in [ + ("relation_pair", by_relation), + ("source_head_bridge_component", by_component), + ] + } + history = json.loads((out / "learning.json").read_text()) + thresholds[name] = { + f"{group}_{value}": threshold_intervals(history, group, value) + for group, value in [("train_composition", 0.99), ("test_all", 0.5), ("test_all", 0.9)] + } + nodes[name] = {} + for step in config["evaluation_nodes"]: + node = json.loads((out / f"predictions-{step:07d}.json").read_text()) + nodes[name][step] = { + group: {r["id"]: r["alias_em"] for r in node[group]} + for group in ("atomic", "test_all") + } + trajectories = [] + for seed in sorted({s["initialization"] for s in config["runs"]}): + specs = {s["architecture"]: s for s in config["runs"] if s["initialization"] == seed} + loop = specs["loop4x2"]["name"] + for baseline in ("standard8", "standard4"): + base = specs[baseline]["name"] + for step in config["evaluation_nodes"]: + left, right = nodes[loop][step], nodes[base][step] + assert set(left["test_all"]) == set(right["test_all"]) + for pool in ("all", "OO"): + selected = [ + held[i] + for i in left["test_all"] + if pool == "all" or held[i]["role"] == pool + ] + common = [ + r + for r in selected + if all(n["atomic"][a] for n in (left, right) for a in r["atom_ids"]) + ] + trajectories.append( + { + "initialization": seed, + "baseline": baseline, + "step": step, + "pool": pool, + "panel_n": len(selected), + "both_models_necessary_atoms_correct_n": len(common), + "both_models_necessary_atoms_correct_coverage": len(common) + / len(selected), + "full_panel_paired_difference": sum( + left["test_all"][r["id"]] - right["test_all"][r["id"]] + for r in selected + ) + / len(selected), + "conditional_paired_difference": sum( + left["test_all"][r["id"]] - right["test_all"][r["id"]] + for r in common + ) + / len(common) + if common + else None, + } + ) + result = { + "endpoint_groups": endpoint_groups, + "threshold_intervals": thresholds, + "paired_knowledge_trajectories": trajectories, + "trajectory_scope": ( + "Fixed panels at registered nodes; threshold brackets are descriptive and do not " + "identify exact crossing times or establish grokking." + ), + "endpoint_scope": ( + "Full registered evaluation pool; source components are shared by questions, " + "not independent worlds." + ), + } + write_json(Path(config["artifact_root"]) / "confirmation-analysis.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/recurrence_use.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/recurrence_use.py new file mode 100644 index 0000000000000000000000000000000000000000..3f2cf4432769a0bc1ea0278bf25468307718877b --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/recurrence_use.py @@ -0,0 +1,416 @@ +"""Frozen-weight update deletion and semantic first-hop interventions. + +Responses are measurements of computational dependence, not learned predictors. +Truth graphs select donors before inference; query means prevent donor frequency +from creating additional scientific observations. +""" + +from __future__ import annotations + +import time + +import numpy as np +import torch +from torch.nn import functional as F + +from .depth_step import EOS, prompt_rows, truth_path_details +from .latent_scaling import model_digest + +COMPONENTS = ("full", "attention", "mlp") +TASKS = ("atomic",) + tuple(f"{s}_{h}" for h in (2, 3, 4) for s in ("familiar", "strict")) + + +@torch.no_grad() +def trace(model, tokens, repeats, *, skip=None, patch=None): + """Apply one occurrence deletion or one r1 replacement, with native SDPA.""" + if model.training or repeats < 1: + raise ValueError("Evaluation mode and positive recurrence are required") + blocks = list(model.iter_blocks(repeats)) + if skip is not None: + scope, source = skip + if scope not in ("all", "r1") or source not in range(len(blocks)): + raise ValueError("Unknown skip scope/occurrence") + if patch is not None and patch[0] not in ("full", "mlp"): + raise ValueError("Unknown patch component") + x = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=tokens.device)) + cache = {name: [] for name in ("input", "full", "attention", "mlp", "output")} + for index, block in enumerate(blocks): + incoming = x + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + attention = a.proj( + F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=0.0, + ) + .transpose(1, 2) + .reshape(batch, length, width) + ) + x = x + attention + mlp = block.mlp(block.ln2(x)) + if index == 0 and patch is not None and patch[0] == "mlp": + mlp = mlp.clone() + if patch[1].shape != mlp[:, 2].shape: + raise ValueError("Replacement shape differs") + mlp[:, 2] = patch[1] + x = x + mlp + if index == 0 and patch is not None and patch[0] == "full": + x = x.clone() + if patch[1].shape != x[:, 2].shape: + raise ValueError("Replacement shape differs") + x[:, 2] = patch[1] + if skip is not None and index == skip[1]: + if skip[0] == "all": + x, attention, mlp = incoming, torch.zeros_like(attention), torch.zeros_like(mlp) + else: + x, attention, mlp = x.clone(), attention.clone(), mlp.clone() + x[:, 2], attention[:, 2], mlp[:, 2] = incoming[:, 2], 0, 0 + for name, value in zip(cache, (incoming, x - incoming, attention, mlp, x), strict=True): + cache[name].append(value) + logits = F.linear(model.ln_final(x), model.token.weight) + return logits, {name: torch.stack(values) for name, values in cache.items()} + + +def interaction(numerator, denominator): + """Ratio of query-averaged norms; an absent denominator is not zero influence.""" + numerator, denominator = np.asarray(numerator), np.asarray(denominator) + if numerator.shape != denominator.shape or not len(numerator): + raise ValueError("Require nonempty aligned response arrays") + n, b = float(numerator.mean()), float(denominator.mean()) + return {"N": n, "B": b, "C": n / b if b > 1e-8 else None} + + +def prediction_metrics(prediction, targets): + generated = prediction["generated"] + logits = prediction["logits"].astype(np.float64) + targets = np.asarray(targets, dtype=np.int64) + maximum = logits.max(1) + partition = maximum + np.log(np.exp(logits - maximum[:, None]).sum(1)) + target_logits = logits[np.arange(len(targets)), targets] + competitors = logits.copy() + competitors[np.arange(len(targets)), targets] = -np.inf + return { + "answer": (generated[:, 0] == targets).astype(float), + "complete": ((generated[:, 0] == targets) & (generated[:, 1] == EOS)).astype(float), + "eos": (generated[:, 1] == EOS).astype(float), + "nll": partition - target_logits, + "margin": target_logits - competitors.max(1), + } + + +def mean_metrics(metrics, mask=None): + length = len(next(iter(metrics.values()))) + mask = np.ones(length, bool) if mask is None else np.asarray(mask, dtype=bool) + if mask.shape != (length,): + raise ValueError("Mask must align with observations") + return { + "n": int(mask.sum()), + "coverage": float(mask.mean()) if length else 0.0, + **{k: float(v[mask].mean()) if mask.any() else None for k, v in metrics.items()}, + } + + +def query_means(values, indices, n): + counts = np.bincount(indices, minlength=n) + sums = np.bincount(indices, weights=values, minlength=n) + out = np.full(n, np.nan) + np.divide(sums, counts, out=out, where=counts > 0) + return out + + +def role_counts(world): + counts = np.zeros((len(world["atomic"]), 4), dtype=np.int64) + for hop in (2, 3, 4): + _, edges = truth_path_details(world, world[f"train_{hop}"]) + for position in range(hop): + np.add.at(counts[:, position], edges[:, position], 1) + return counts + + +def select_donors(low, high): + """Enumerate shared bridge donors and select answer-blind changed paths.""" + atoms = low["atomic"] + for name in TASKS: + np.testing.assert_array_equal(low[name], high[name]) + id_mask = np.asarray(low["metadata"]["id_mask"], bool) + np.testing.assert_array_equal(id_mask, high["metadata"]["id_mask"]) + low_roles, high_roles = role_counts(low), role_counts(high) + if low_roles[~id_mask].any() or high_roles[~id_mask].any(): + raise ValueError("Strict fact has composition training exposure") + used_first = (low_roles[:, 0] > 0) & (high_roles[:, 0] > 0) + strict = ~id_mask & (low_roles.sum(1) == 0) & (high_roles.sum(1) == 0) + result = {"low_roles": low_roles, "high_roles": high_roles} + rows = low["strict_2"] + nodes, _ = truth_path_details(low, rows) + for label, eligible in (("experienced", used_first), ("strict", strict)): + recipients, indices = [], [] + for i, (row, path) in enumerate(zip(rows, nodes, strict=True)): + mask = eligible & (atoms[:, 1] == row[1]) & (atoms[:, 2] == path[1]) + mask &= (atoms[:, 0] != row[0]) & (atoms[:, 0] != row[-1]) + choices = sorted(np.flatnonzero(mask), key=lambda k: tuple(atoms[k])) + recipients.extend([i] * len(choices)) + indices.extend(choices) + result[label + "_recipients"] = np.asarray(recipients, dtype=np.int64) + result[label + "_atoms"] = np.asarray(indices, dtype=np.int64) + result["common"] = (np.bincount(result["experienced_recipients"], minlength=len(rows)) > 0) & ( + np.bincount(result["strict_recipients"], minlength=len(rows)) > 0 + ) + lookup = {(int(h), int(r)): (i, int(t)) for i, (h, r, t) in enumerate(atoms)} + trained = {tuple(row[:-1]) for w in (low, high) for row in w["train_2"]} + order = sorted(range(len(atoms)), key=lambda i: tuple(atoms[i])) + for label in ("familiar", "strict"): + rows = low[label + "_2"] + nodes, edges = truth_path_details(low, rows) + recipients, donors, targets, successors = [], [], [], [] + for i, (row, path) in enumerate(zip(rows, nodes, strict=True)): + for fact in order: + h, r1, bridge = map(int, atoms[fact]) + successor = lookup.get((bridge, int(row[2]))) + if successor is None: + continue + next_index, target = successor + if ( + r1 != row[1] + or h in (row[0], row[-1], target) + or bridge == path[1] + or target == row[-1] + or (h, r1, int(row[2])) in trained + or id_mask[fact] != id_mask[edges[i, 0]] + or id_mask[next_index] != id_mask[edges[i, 1]] + ): + continue + recipients.append(i) + donors.append(fact) + targets.append(target) + successors.append(next_index) + break + result[label + "_changed_recipients"] = np.asarray(recipients, dtype=np.int64) + result[label + "_changed_atoms"] = np.asarray(donors, dtype=np.int64) + result[label + "_changed_targets"] = np.asarray(targets, dtype=np.int64) + result[label + "_changed_successors"] = np.asarray(successors, dtype=np.int64) + return result + + +@torch.no_grad() +def generate(model, rows, separator, repeats, *, skip=None, donor_atoms=None, component="full"): + """Free answer and free EOS; a donor sees only the atomic question prefix.""" + rows = np.asarray(rows, np.int64) + if not len(rows): + return { + "generated": np.empty((0, 2), np.int64), + "logits": np.empty((0, model.config.vocab_size), np.float32), + }, None + device = next(model.parameters()).device + tokens = torch.as_tensor(prompt_rows(rows, separator), device=device) + + def forward(inputs): + patch = None + if donor_atoms is not None: + donor = torch.zeros_like(inputs) + donor[:, :3] = torch.as_tensor( + prompt_rows(donor_atoms, separator)[:, :3], device=device + ) + _, donor_cache = trace(model, donor, 1) + field = "output" if component == "full" else "mlp" + patch = (component, donor_cache[field][0, :, 2]) + return trace(model, inputs, repeats, skip=skip, patch=patch) + + logits, cache = forward(tokens) + answer_logits = logits[:, -1] + answer = answer_logits.argmax(-1) + eos_logits, _ = forward(torch.cat((tokens, answer[:, None]), dim=1)) + prediction = { + "generated": torch.stack((answer, eos_logits[:, -1].argmax(-1)), 1).cpu().numpy(), + "logits": answer_logits.cpu().numpy(), + } + return prediction, cache + + +def response_arrays(baseline, changed, source): + arrays, rows = {}, [] + for component in COMPONENTS: + for site, position in (("all", None), ("r1", 2), ("answer", -1)): + a, b = baseline[component], changed[component] + n, d = (b - a).norm(dim=-1), a.norm(dim=-1) + n, d = ( + (n.mean(-1), d.mean(-1)) + if position is None + else (n[..., position], d[..., position]) + ) + for target in range(source + 1, len(a)): + numerator, denominator = n[target].cpu().numpy(), d[target].cpu().numpy() + key = f"{component}_{site}_i{source}_j{target}" + arrays[key + "_N"], arrays[key + "_B"] = numerator, denominator + rows.append( + { + "component": component, + "site": site, + "source": source, + "target": target, + **interaction(numerator, denominator), + } + ) + return arrays, rows + + +@torch.no_grad() +def evaluate(model, world, selection, repeats): + started = time.perf_counter() + if any(p.requires_grad for p in model.parameters()) or model.training: + raise ValueError("All weights must be frozen in evaluation mode") + before = model_digest(model) + model.repeats = repeats + separator = world["metadata"]["separator_token"] + arrays, summaries, engineering = {}, {}, {} + predictions, caches, metrics = {}, {}, {} + conditions = [("baseline", None)] + [ + (f"skip_{scope}_{i}", (scope, i)) for scope in ("all", "r1") for i in range(repeats) + ] + for task in TASKS: + rows = world[task] + arrays[task + "_rows"] = rows + predictions[task], metrics[task] = {}, {} + for name, skip in conditions: + pred, cache = generate(model, rows, separator, repeats, skip=skip) + m = prediction_metrics(pred, rows[:, -1]) + predictions[task][name], metrics[task][name] = pred, m + for field, values in {**pred, **m}.items(): + arrays[f"{task}_{name}_{field}"] = values + summaries[f"{task}/{name}"] = {"full_pool": mean_metrics(m)} + if name == "baseline": + caches[task] = cache + inputs = torch.as_tensor( + prompt_rows(rows, separator), device=next(model.parameters()).device + ) + native = model(inputs)[:, -1].cpu().numpy() + if not np.array_equal(native, pred["logits"]): + raise AssertionError("Traced logits differ from native forward") + engineering[task + "_native_logits_exact"] = True + elif task != "atomic": + response, cells = response_arrays(caches[task], cache, skip[1]) + arrays.update({f"{task}_{name}_{k}": v for k, v in response.items()}) + summaries[f"{task}/{name}"]["responses"] = cells + if name == f"skip_r1_{repeats - 1}": + for field in ("generated", "logits"): + np.testing.assert_array_equal(pred[field], predictions[task]["baseline"][field]) + engineering[task + "_last_r1_no_downstream_effect"] = True + del cache + for task in TASKS[1:]: + _, edges = truth_path_details(world, world[task]) + arrays[task + "_atomic_indices"] = edges + common = np.ones(len(world[task]), bool) + for name, _ in conditions: + common &= metrics["atomic"][name]["complete"][edges].all(1) + arrays[task + "_common_atomic_mask"] = common + for name, _ in conditions: + cell = summaries[f"{task}/{name}"] + cell["necessary_atomic_coverage"] = float( + metrics["atomic"][name]["complete"][edges].all(1).mean() + ) + cell["common_atomic_pool"] = mean_metrics(metrics[task][name], common) + # Self-prefix patches at equal physical length verify absence of later-relation information. + for task in ("familiar_2", "strict_2"): + rows = world[task] + atoms = np.c_[rows[:, :2], np.zeros(len(rows), np.int64)] + for component in ("full", "mlp"): + pred, _ = generate( + model, rows, separator, repeats, donor_atoms=atoms, component=component + ) + for field in ("generated", "logits"): + np.testing.assert_array_equal(pred[field], predictions[task]["baseline"][field]) + engineering[f"{task}_self_prefix_{component}_exact"] = True + rows = world["strict_2"] + _, edges = truth_path_details(world, rows) + common = selection["common"] + donor_atom_ok = np.ones(len(world["atomic"]), bool) + for label in ("experienced", "strict"): + recipients, facts = selection[label + "_recipients"], selection[label + "_atoms"] + donor_atom_ok[facts] = metrics["atomic"]["baseline"]["complete"][facts].astype(bool) + for component in ("full", "mlp"): + if not len(recipients): + continue + pred, _ = generate( + model, + rows[recipients], + separator, + repeats, + donor_atoms=world["atomic"][facts], + component=component, + ) + m = prediction_metrics(pred, rows[recipients, -1]) + key = f"same_{label}_{component}" + for field, value in {**pred, **m}.items(): + arrays[key + "_" + field] = value + balanced = {k: query_means(v, recipients, len(rows)) for k, v in m.items()} + summaries[key] = { + "common_graph_pool": mean_metrics(balanced, common), + "all_available": mean_metrics(balanced, np.isfinite(balanced["complete"])), + } + known = metrics["atomic"]["baseline"]["complete"][edges].all(1) + for label in ("experienced", "strict"): + recipients, facts = selection[label + "_recipients"], selection[label + "_atoms"] + for recipient, fact in zip(recipients, facts, strict=True): + known[recipient] &= donor_atom_ok[fact] + arrays["same_common_known_mask"] = known & common + summaries["same_baseline"] = { + "common_graph_pool": mean_metrics(metrics["strict_2"]["baseline"], common), + "common_known_pool": mean_metrics(metrics["strict_2"]["baseline"], known & common), + } + for label in ("experienced", "strict"): + recipients = selection[label + "_recipients"] + for component in ("full", "mlp"): + key = f"same_{label}_{component}" + if key in summaries: + m = { + k: arrays[key + "_" + k] for k in ("answer", "complete", "eos", "nll", "margin") + } + balanced = {k: query_means(v, recipients, len(rows)) for k, v in m.items()} + summaries[key]["common_known_pool"] = mean_metrics(balanced, known & common) + for label in ("familiar", "strict"): + task = label + "_2" + recipients = selection[label + "_changed_recipients"] + facts = selection[label + "_changed_atoms"] + targets = selection[label + "_changed_targets"] + if not len(recipients): + continue + original = world[task][recipients] + counterfactual = original.copy() + counterfactual[:, 0] = world["atomic"][facts, 0] + counterfactual[:, -1] = targets + truth_path_details(world, counterfactual) + native_cf, _ = generate(model, counterfactual, separator, repeats) + values = { + "baseline": {k: v[recipients] for k, v in predictions[task]["baseline"].items()}, + "counterfactual": native_cf, + } + for component in ("full", "mlp"): + values[component], _ = generate( + model, + original, + separator, + repeats, + donor_atoms=world["atomic"][facts], + component=component, + ) + for name, pred in values.items(): + key = f"changed_{label}_{name}" + m = prediction_metrics(pred, targets) + for field, vector in {**pred, **m}.items(): + arrays[key + "_" + field] = vector + summaries[key] = mean_metrics(m) + arrays.update({"selection_" + k: v for k, v in selection.items()}) + if model_digest(model) != before: + raise AssertionError("Intervention changed model parameters") + return arrays, { + "repeats": repeats, + "seconds": time.perf_counter() - started, + "weights_unchanged": True, + "model_sha256": before, + "engineering": engineering, + "conditions": summaries, + } diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/representation_alignment.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/representation_alignment.py new file mode 100644 index 0000000000000000000000000000000000000000..923e412fdf09bfaf85ca6de1fcb11cf4d6e754de --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/representation_alignment.py @@ -0,0 +1,269 @@ +"""Intermediate supervision and input-compatible states in complete causal GPTs. + +The intervention observes the first executed block at the first relation token. +Every arm executes the same forward/backward graph. Ordinary full-token CE, +auxiliary entity CE, and state geometry are recorded separately. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import EpochStream, GraphStep, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .latent_scaling import build_world, construct, model_digest +from .storage_composition import data_digest, evaluate, file_hash, pack_sentences +from .storage_frontier import learning_rate + + +class RepresentationGPT(LoopGPT): + """Unchanged GPT/Loop computation, optionally exposing a causal early state.""" + + def forward(self, tokens, positions=None, repeats=None, return_bridge=False): + p = self.dropout if self.training else 0.0 + x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device)) + x = F.dropout(x, p=p, training=self.training) + bridge = None + for index, block in enumerate(self.iter_blocks(repeats)): + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=p, + ) + y = a.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + F.dropout(y, p=p, training=self.training) + x = x + F.dropout(block.mlp(block.ln2(x)), p=p, training=self.training) + if index == 0 and return_bridge: + bridge = x[:, 3] + x = self.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + logits = F.linear(x, self.token.weight) + return (logits, bridge) if return_bridge else logits + + +def new_model(spec, device): + # Construct through the established initializer, then replace only the type. + model = construct(spec, device) + model.__class__ = RepresentationGPT + return model + + +def pack_training(world): + strata = [world[k] for k in ("common_atomic", "train_composite", "anchor_atomic")] + tokens, labels = ( + np.concatenate(parts) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + # Column 2 is the atomic answer or the composition's first-hop answer. + # It never enters the composed input; it is an explicit auxiliary target. + targets = np.concatenate([rows[:, 2] for rows in strata]) + return (tokens, labels, targets), [len(rows) for rows in strata] + + +def objective(model, tokens, labels, targets, bridge_weight, alignment_weight): + logits, bridge = model(tokens, return_bridge=True) + text_ce = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + bridge_logits = F.linear(model.ln_final(bridge), model.token.weight) + bridge_ce = F.cross_entropy(bridge_logits, targets) + canonical = model.token(targets).detach() + alignment = ( + (F.normalize(bridge, dim=-1) - F.normalize(canonical, dim=-1)).square().sum(-1).mean() + ) + parts = torch.stack((text_ce, bridge_ce, alignment)) + return text_ce + bridge_weight * bridge_ce + alignment_weight * alignment, parts + + +class RepresentationStep(GraphStep): + def __init__(self, model, optimizer, table, batch_size, spec): + self.spec = spec + super().__init__(model, optimizer, table, batch_size) + + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + tokens, labels, targets = (part[self.index] for part in self.table) + loss, self.components = objective( + self.model, + tokens, + labels, + targets, + self.spec["bridge_weight"], + self.spec["alignment_weight"], + ) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def run_name(spec): + return f"{spec['phase']}-w{spec['world']}-i{spec['initialization']}-{spec['arm']}" + + +def train(spec, out, source, device): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "run.json").exists(): + raise FileExistsError(f"Do not overwrite an attempt: {out}") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(device) + started = time.perf_counter() + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + arrays, sizes = pack_training(world) + model = new_model(spec, device) + initial_hash = model_digest(model) + write_json( + out / "run.json", + { + "spec": spec, + "source": source, + "world_sha256": data_digest(world), + "initial_model_sha256": initial_hash, + "pid": os.getpid(), + "gpu": device.index, + "gpu_name": torch.cuda.get_device_name(device), + "dtype": "float32", + "parameters": sum(p.numel() for p in model.parameters()), + "atomic_examples": sizes[0] + sizes[2], + "composition_examples": sizes[1], + "vocab_size": model.config.vocab_size, + }, + ) + table = tuple(torch.as_tensor(a, device=device) for a in arrays) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + model.train() + graph = RepresentationStep(model, optimizer, table, spec["batch_size"], spec) + assert model_digest(model) == initial_hash, "CUDA capture changed initialization" + streams = [EpochStream(n, spec["stream_seed"] + j) for j, n in enumerate(sizes)] + offsets = np.cumsum([0, *sizes[:-1]]) + counts = [np.zeros(n, dtype=np.int64) for n in sizes] + input_hash = hashlib.sha256() + history, step, training_seconds = [], 0, 0.0 + flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 9, output_positions=9) + # All arms also execute the auxiliary readout and normalization. + flop_step += 6 * spec["batch_size"] * model.config.width * model.config.vocab_size + + def measure(): + metrics, predictions = evaluate(model, world, "low", device) + parts = graph.components.detach().cpu().tolist() if step else [None] * 3 + row = { + "step": step, + "metrics": metrics, + "text_ce": parts[0], + "bridge_ce": parts[1], + "alignment_loss": parts[2], + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "examples": step * spec["batch_size"], + "supervised_tokens": step * spec["batch_size"] // 3 * (7 + 9 + 7), + "auxiliary_target_presentations": step * spec["batch_size"], + "estimated_matmul_training_flops": step * flop_step, + "composition_epochs": step * spec["batch_size"] / 3 / sizes[1], + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + write_json(out / "status.json", {"state": "running", "step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["common_atomic"]["accuracy"], + "train": metrics["train_composite"]["accuracy"], + "familiar": metrics["familiar_test"]["accuracy"], + "strict": metrics["strict_test"]["accuracy"], + } + ), + flush=True, + ) + model.train() + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize(device) + began = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = [] + for j, stream in enumerate(streams): + drawn = stream.take(n * spec["batch_size"] // 3).reshape(n, -1) + counts[j] += np.bincount(drawn.ravel(), minlength=sizes[j]) + indices.append(drawn + offsets[j]) + indices = np.concatenate(indices, axis=1) + input_hash.update(indices.tobytes()) + indices = torch.as_tensor(indices, device=device) + for j in range(n): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += n + torch.cuda.synchronize(device) + training_seconds += time.perf_counter() - began + if not np.isfinite(float(loss)): + raise FloatingPointError(f"Nonfinite objective at {step}") + measure() + model.eval() + torch.save( + {"spec": spec, "model": model.state_dict(), "optimizer": optimizer.state_dict()}, + out / "model.pt", + ) + np.savez_compressed(out / "exposures.npz", **{f"stratum{j}": c for j, c in enumerate(counts)}) + write_json( + out / "complete.json", + { + "spec": spec, + "source": source, + "finished_utc": utc(), + "metrics": history[-1]["metrics"], + "training_seconds": training_seconds, + "world_sha256": data_digest(world), + "initial_model_sha256": initial_hash, + "sample_stream_sha256": input_hash.hexdigest(), + "model_sha256": file_hash(out / "model.pt"), + }, + ) + write_json(out / "status.json", {"state": "complete", "step": step}) + + +def audit(out, device): + out = Path(out) + # Match trainer arithmetic before comparing generated tokens and NLL. + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + payload = torch.load(out / "model.pt", map_location="cpu", weights_only=False) + spec = payload["spec"] + model = new_model(spec, device) + model.load_state_dict(payload["model"]) + world = build_world(spec) + metrics, predictions = evaluate(model, world, "low", device) + saved = np.load(out / f"predictions-{spec['steps']:06d}.npz") + max_nll_error = 0.0 + for key, actual in predictions.items(): + if key.endswith("nll"): + max_nll_error = max(max_nll_error, float(np.max(np.abs(actual - saved[key])))) + np.testing.assert_allclose(actual, saved[key], rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(actual, saved[key]) + write_json( + out / "audit.json", + {"passed": True, "metrics": metrics, "max_nll_error": max_nll_error, "allow_tf32": True}, + ) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_composition.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_composition.py new file mode 100644 index 0000000000000000000000000000000000000000..f7bc9b1ea8e7d825eb5f27c33bb4d7e38bb7bcc1 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_composition.py @@ -0,0 +1,543 @@ +"""Development comparison in an unchanged, fully trained pretrained Qwen LM. + +Only training document grouping differs. All weights, native embeddings, +residuals, attention, norms and distinct MLP layers are retained. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import re +import shutil +import time +from collections import Counter +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np +import torch +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +QUESTIONS = ( + ( + "Who is {head}'s mentor?", + "Who mentors {head}?", + "Name the mentor of {head}.", + "Who is the mentor of {head}?", + ), + ( + "Which city does {bridge} live in?", + "What city is {bridge}'s home?", + "Where does {bridge} live?", + "Name the city where {bridge} lives.", + ), + ( + "Which city does {head}'s mentor live in?", + "What city is home to {head}'s mentor?", + "Where does the mentor of {head} live?", + "Name the city where {head}'s mentor lives.", + ), +) +CITIES = ( + "Paris Rome London Berlin Tokyo Oslo Lima Cairo Delhi Seoul Dublin Madrid " + "Vienna Boston Sydney Lisbon" +).split() + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n") + + +def sha(path): + with Path(path).open("rb") as handle: + return hashlib.file_digest(handle, "sha256").hexdigest() + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def build_world(config): + first = ( + "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo" + ).split() + last = "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split() + names = [f"{a} {b}" for a in first for b in last] + n = config["target_triples"] + config["background_triples"] + assert 2 * n <= len(names) + rng = np.random.default_rng(config["world_seed"]) + names = rng.permutation(names).tolist() + rows = [] + for split, count in ( + ("target", config["target_triples"]), + ("background", config["background_triples"]), + ): + cities = rng.permutation([CITIES[i % len(CITIES)] for i in range(count)]) + for city in cities: + i = len(rows) + rows.append( + dict(id=i, split=split, head=names[2 * i], bridge=names[2 * i + 1], city=str(city)) + ) + return rows + + +def prompt(row, hop, variant=0): + return "Fictional registry.\nQuestion: " + QUESTIONS[hop][variant].format(**row) + "\nAnswer:" + + +def answer(row, hop): + return row["bridge"] if hop == 0 else row["city"] + + +def encode_document(tokenizer, row, hop, variant): + ids = tokenizer.encode( + prompt(row, hop, variant) + " " + answer(row, hop) + ".", add_special_tokens=False + ) + [tokenizer.eos_token_id] + # The initial token of each atomic document has no within-document predecessor. + # It remains unscored when documents are joined, preserving every target token. + return dict(ids=ids, labels=[-100, *ids[1:]], triple=row["id"], hop=hop, variant=variant) + + +def corpus(tokenizer, world): + records = {} + for row in world: + hops = range(3) if row["split"] == "background" else range(2) + for hop in hops: + for variant in range(4): + records[row["id"], hop, variant] = encode_document(tokenizer, row, hop, variant) + return records + + +def stream(config, world): + rng = np.random.default_rng(config["training_seed"]) + background = [r["id"] for r in world if r["split"] == "background"] + result = [] + for _ in range(config["steps"]): + pairs = [ + [int(i), int(v)] + for i, v in zip( + rng.choice(len(world), config["atomic_pairs_per_step"], replace=False), + rng.integers(4, size=config["atomic_pairs_per_step"]), + strict=True, + ) + ] + compositions = [ + [int(i), int(v)] + for i, v in zip( + rng.choice(background, config["background_compositions_per_step"], replace=False), + rng.integers(4, size=config["background_compositions_per_step"]), + strict=True, + ) + ] + result.append(dict(pairs=pairs, compositions=compositions)) + return result + + +def documents(records, batch, arm): + docs = [] + for i, v in batch["pairs"]: + first, second = records[i, 0, v], records[i, 1, v] + if arm == "separate": + docs.extend([first, second]) + elif arm == "linked": + docs.append( + dict(ids=first["ids"] + second["ids"], labels=first["labels"] + second["labels"]) + ) + else: + raise ValueError(arm) + docs.extend(records[i, 2, v] for i, v in batch["compositions"]) + return docs + + +def batch_tensors(docs, pad_id, device): + width = max(len(d["ids"]) for d in docs) + ids = torch.full((len(docs), width), pad_id, device=device, dtype=torch.long) + labels = torch.full_like(ids, -100) + mask = torch.zeros_like(ids) + for i, doc in enumerate(docs): + n = len(doc["ids"]) + ids[i, :n] = torch.tensor(doc["ids"], device=device) + labels[i, :n] = torch.tensor(doc["labels"], device=device) + mask[i, :n] = 1 + return dict(input_ids=ids, attention_mask=mask, labels=labels) + + +def normalize(text): + return re.sub(r"\s+", " ", text.strip().rstrip(".").strip()).casefold() + + +def grade(text, gold): + first_line = text.strip().split("\n")[0] + return normalize(first_line) == normalize(gold) + + +def evaluation_rows(world): + return [ + dict(**row, hop=hop, prompt=prompt(row, hop), answer=answer(row, hop)) + for row in world + for hop in (range(3) if row["split"] == "target" else [2]) + ] + + +@torch.inference_mode() +def evaluate(model, tokenizer, world, config): + model.eval() + tokenizer.padding_side = "left" + rows = evaluation_rows(world) + results = [] + for start in range(0, len(rows), config["eval_batch"]): + chunk = rows[start : start + config["eval_batch"]] + enc = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(config["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + generated = model.generate( + **enc, + do_sample=False, + max_new_tokens=config["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, enc.input_ids.shape[1] :] + for row, tokens in zip(chunk, generated.cpu().tolist(), strict=True): + # Drop batching padding after the first EOS; retain the actual generated EOS. + if tokenizer.eos_token_id in tokens: + tokens = tokens[: tokens.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tokens, skip_special_tokens=True) + results.append( + dict(**row, tokens=tokens, text=text, correct=grade(text, row["answer"])) + ) + return results + + +def score(rows): + result = {} + for split, hop, key in ( + ("target", 0, "first_hop"), + ("target", 1, "second_hop"), + ("target", 2, "two_hop"), + ("background", 2, "background_two_hop"), + ): + selected = [r for r in rows if r["split"] == split and r["hop"] == hop] + result[key] = sum(r["correct"] for r in selected) / len(selected) + indexed = {(r["id"], r["hop"]): r for r in rows if r["split"] == "target"} + mastered = [ + i for i, h in indexed if h == 0 and indexed[i, 0]["correct"] and indexed[i, 1]["correct"] + ] + result["both_atomic_coverage"] = len(mastered) / sum(h == 0 for _, h in indexed) + result["two_hop_if_both_atomic"] = ( + sum(indexed[i, 2]["correct"] for i in mastered) / len(mastered) if mastered else None + ) + return result + + +def prepare(config_path): + config = read(config_path) + art = Path(config["artifact_root"]) + if (art / "lock.json").exists(): + raise RuntimeError("Development lock already exists; do not overwrite it.") + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + world = build_world(config) + batches = stream(config, world) + records = corpus(tokenizer, world) + assert all(h != 2 or world[i]["split"] == "background" for i, h, _ in records) + stats = {} + for arm in config["arms"]: + counts = Counter() + token_counts = Counter() + input_tokens = supervised_tokens = padded_tokens = attention_cells = 0 + for batch in batches: + docs = documents(records, batch, arm) + for d in docs: + input_tokens += len(d["ids"]) + supervised_tokens += sum(t != -100 for t in d["labels"]) + counts.update(t for t in d["labels"] if t != -100) + token_counts.update(d["ids"]) + width = max(len(d["ids"]) for d in docs) + padded_tokens += len(docs) * width + attention_cells += len(docs) * width**2 + stats[arm] = dict( + input_tokens=input_tokens, + supervised_tokens=supervised_tokens, + padded_tokens=padded_tokens, + attention_cells=attention_cells, + target_token_counts=sorted(counts.items()), + input_token_counts=sorted(token_counts.items()), + ) + for key in ("input_tokens", "supervised_tokens", "target_token_counts", "input_token_counts"): + assert stats["separate"][key] == stats["linked"][key], key + write(art / "world.json", world) + write(art / "stream.json", batches) + write(art / "data-audit.json", dict(status="passed", stats=stats, target_composition_labels=0)) + sources = [ + str(config_path), + __file__, + "scripts/run_small_lm_composition.py", + "tests/test_small_lm_composition.py", + str(art / "development-plan.md"), + ] + frozen = {} + for source in sources: + path = Path(source).resolve() + relative = path.relative_to(Path.cwd()) + dest = art / "source" / relative + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, dest) + frozen[str(relative)] = sha(path) + model_files = { + str(p): sha(p) + for p in Path(config["model_path"]).iterdir() + if p.suffix in (".safetensors", ".json") + } + write( + art / "lock.json", + dict( + status="locked_before_training", + utc=now(), + sources=frozen, + model_files=model_files, + world_sha256=sha(art / "world.json"), + stream_sha256=sha(art / "stream.json"), + ), + ) + print( + json.dumps( + { + "status": "prepared", + "stats": { + a: {k: v for k, v in s.items() if not k.endswith("counts")} + for a, s in stats.items() + }, + } + ), + flush=True, + ) + + +def parameter_samples(model): + names = [ + "model.embed_tokens.weight", + "model.layers.0.self_attn.q_proj.weight", + "model.layers.0.mlp.down_proj.weight", + "model.layers.0.input_layernorm.weight", + "model.layers.27.self_attn.o_proj.weight", + "model.layers.27.mlp.down_proj.weight", + ] + params = dict(model.named_parameters()) + return {n: params[n].detach().flatten()[:4096].clone() for n in names} + + +def train(config_path, arm): + config = read(config_path) + assert arm in config["arms"] + art = Path(config["artifact_root"]) + lock = read(art / "lock.json") + for path, expected in lock["sources"].items(): + assert sha(path) == expected, path + for path, expected in lock["model_files"].items(): + assert sha(path) == expected, path + assert sha(art / "world.json") == lock["world_sha256"] + assert sha(art / "stream.json") == lock["stream_sha256"] + out = Path(config["output_root"]) / arm + out.mkdir(parents=True, exist_ok=True) + if (out / "status.json").exists(): + raise RuntimeError("A run record already exists; preserve it and use a new output root.") + write(out / "status.json", dict(status="running", arm=arm, utc=now())) + begun = time.perf_counter() + torch.set_num_threads(config["cpu_threads"]) + torch.manual_seed(config["training_seed"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.set_device(config["device"]) + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + model = AutoModelForCausalLM.from_pretrained( + config["model_path"], + torch_dtype=torch.float32, + attn_implementation="sdpa", + local_files_only=True, + ).to(config["device"]) + model.requires_grad_(True) + assert all(p.requires_grad for p in model.parameters()) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + samples = parameter_samples(model) + world, batches = read(art / "world.json"), read(art / "stream.json") + records = corpus(tokenizer, world) + optimizer = torch.optim.AdamW( + model.parameters(), + lr=config["learning_rate"], + weight_decay=config["weight_decay"], + fused=True, + ) + curve = [] + token_count = 0 + train_seconds = 0.0 + initial_gradients = {} + for step in range(config["steps"] + 1): + if step in config["nodes"]: + rows = evaluate(model, tokenizer, world, config) + write(out / f"predictions-{step:05d}.json", rows) + record = dict(step=step, **score(rows)) + curve.append(record) + write(out / "curve.json", curve) + print(json.dumps(dict(arm=arm, **record)), flush=True) + if step == config["steps"]: + break + rate = config["minimum_learning_rate"] + 0.5 * ( + config["learning_rate"] - config["minimum_learning_rate"] + ) * ( + 1 + + math.cos( + math.pi + * max(0, step - config["warmup_steps"]) + / (config["steps"] - config["warmup_steps"]) + ) + ) + rate *= min(1.0, (step + 1) / config["warmup_steps"]) + for group in optimizer.param_groups: + group["lr"] = rate + model.train() + docs = documents(records, batches[step], arm) + inputs = batch_tensors(docs, tokenizer.pad_token_id, config["device"]) + token_count += int(inputs["labels"].ne(-100).sum()) + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = model(**inputs, use_cache=False).loss + assert torch.isfinite(loss), float(loss) + loss.backward() + if step == 0: + for name, p in model.named_parameters(): + assert p.grad is not None and torch.isfinite(p.grad).all(), name + if name in samples: + initial_gradients[name] = float(p.grad.norm()) + torch.nn.utils.clip_grad_norm_(model.parameters(), config["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 32 == 0: + print( + json.dumps( + dict( + arm=arm, + step=step + 1, + loss=float(loss), + learning_rate=rate, + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + n: bool(not torch.equal(old, parameter_samples(model)[n])) for n, old in samples.items() + } + assert all(changed.values()), changed + parameter_count = sum(p.numel() for p in model.parameters()) + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + reloaded = AutoModelForCausalLM.from_pretrained( + out / "model", + torch_dtype=torch.float32, + attn_implementation="sdpa", + local_files_only=True, + ).to(config["device"]) + reloaded_rows = evaluate(reloaded, tokenizer, world, config) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in reloaded_rows] + write( + out / "reload-audit.json", + dict(status="passed", predictions=len(final_rows), exact_generated_tokens=True), + ) + budget = read(art / "data-audit.json")["stats"][arm] + assert token_count == budget["supervised_tokens"] + summary = dict( + status="complete", + phase="development", + arm=arm, + utc=now(), + metrics=score(final_rows), + model_repo=config["model_repo"], + model_revision=config["model_revision"], + lock_sha256=sha(art / "lock.json"), + parameter_count=parameter_count, + trainable_parameters=parameter_count, + sampled_parameters_changed=changed, + initial_sampled_gradient_norms=initial_gradients, + budget={k: v for k, v in budget.items() if not k.endswith("counts")}, + updates=config["steps"], + train_seconds=train_seconds, + process_seconds=time.perf_counter() - begun, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + train_weight_dtype="float32", + forward_dtype="bfloat16 autocast", + tf32=False, + checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + write(out / "summary.json", summary) + write(out / "status.json", dict(status="complete", utc=now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + config = read(config_path) + art = Path(config["artifact_root"]) + runs, predictions = {}, {} + for arm in config["arms"]: + out = Path(config["output_root"]) / arm + runs[arm] = read(out / "summary.json") + assert runs[arm]["status"] == "complete" + assert read(out / "reload-audit.json")["status"] == "passed" + rows = read(out / f"predictions-{config['steps']:05d}.json") + assert score(rows) == runs[arm]["metrics"] + predictions[arm] = {(r["id"], r["hop"]): r for r in rows if r["split"] == "target"} + common = [ + i + for i, h in predictions["separate"] + if h == 0 + and all(predictions[a][i, hop]["correct"] for a in config["arms"] for hop in (0, 1)) + ] + conditional = { + a: sum(predictions[a][i, 2]["correct"] for i in common) / len(common) if common else None + for a in config["arms"] + } + result = dict( + status="complete", + phase="development_only", + utc=now(), + runs=runs, + common_atomic_n=len(common), + common_atomic_coverage=len(common) / config["target_triples"], + common_atomic_two_hop=conditional, + two_hop_difference=runs["linked"]["metrics"]["two_hop"] + - runs["separate"]["metrics"]["two_hop"], + notes=[ + "One synthetic world and one training seed; no independent confirmation.", + "Natural-language fictional facts; original pretrained Qwen architecture.", + "Exact fact, input-token and supervised-token exposure match.", + "Document grouping changes context, positions and attention work.", + "Linked training co-presents the head and final city; not zero cooccurrence.", + "This behavior comparison does not uniquely identify an MLP mechanism.", + ], + ) + write(art / "summary.json", result) + print(json.dumps({k: v for k, v in result.items() if k != "runs"}), flush=True) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_followup.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_followup.py new file mode 100644 index 0000000000000000000000000000000000000000..4c986ea475b4f0abe83ea3d0411a049344ac0e08 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_followup.py @@ -0,0 +1,558 @@ +"""Small full-Qwen development: matched rehearsal, pairing, and factual updates.""" + +from __future__ import annotations + +import copy +import itertools +import json +import math +import shutil +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +from . import small_lm_composition as base + +HELDOUT = ( + "Give the name of the person mentoring {head}.", + "In which city is {bridge} living?", + "In which city is the person mentoring {head} living?", +) + + +def pairing_stream(config, world): + batches = base.stream(config, world) + rng = np.random.default_rng(config["pairing_seed"]) + for batch in batches: + pairs = batch["pairs"] + + def valid(order, pairs=pairs): + return all( + world[i]["city"] != world[pairs[k][0]]["city"] + for (i, _), k in zip(pairs, order, strict=True) + ) + + candidates = (rng.permutation(len(pairs)).tolist() for _ in range(1000)) + order = next((p for p in candidates if valid(p)), None) + if order is None: + order = next( + (list(p) for p in itertools.permutations(range(len(pairs))) if valid(p)), None + ) + if order is None: + raise ValueError("Batch cannot match distinct cities; revise before training.") + batch["second_order"] = order + return batches + + +def training_documents(records, batch, arm, copies=1): + pairs = batch["pairs"] + singles = [records[i, h, v] for i, v in pairs for h in (0, 1)] + docs = [] + if arm == "separate": + docs.extend(singles) + else: + order = range(len(pairs)) if arm == "linked" else batch["second_order"] + if arm not in ("linked", "shuffled"): + raise ValueError(arm) + for (i, v), j in zip(pairs, order, strict=True): + k, w = pairs[j] + first, second = records[i, 0, v], records[k, 1, w] + docs.append( + dict(ids=first["ids"] + second["ids"], labels=first["labels"] + second["labels"]) + ) + docs.extend(singles * copies) + docs.extend(records[i, 2, v] for i, v in batch["compositions"]) + return docs + + +def edit_design(config, world): + rng = np.random.default_rng(config["edit_seed"]) + ids = [] + for city in base.CITIES: + options = [r["id"] for r in world if r["split"] == "target" and r["city"] == city] + ids.extend(int(i) for i in rng.choice(options, len(options) // 2, replace=False)) + cities = rng.permutation(base.CITIES).tolist() + shift = int(rng.integers(1, len(cities))) + mapping = dict(zip(cities, cities[shift:] + cities[:shift], strict=True)) + changed = copy.deepcopy(world) + for row in changed: + if row["id"] in ids: + row["city"] = mapping[row["city"]] + rng = np.random.default_rng(config["edit_training_seed"]) + background = [r["id"] for r in world if r["split"] == "background"] + batches = [] + for _ in range(config["edit_steps"]): + specs = [] + for pool, count, hop in ( + (ids, config["edited_second_per_step"], 1), + (ids, config["replayed_first_per_step"], 0), + (background, config["background_atomic_per_step"], None), + (background, config["background_compositions_edit_per_step"], 2), + ): + for i in rng.choice(pool, count, replace=False): + h = int(rng.integers(2)) if hop is None else hop + specs.append([int(i), h, int(rng.integers(4))]) + batches.append(specs) + return dict(edited_ids=sorted(ids), city_mapping=mapping, world=changed, stream=batches) + + +def view_prompt(row, hop, view): + if view == 0: + return base.prompt(row, hop) + return "Fictional registry.\nQuestion: " + HELDOUT[hop].format(**row) + "\nAnswer:" + + +def evaluation_rows(world, extras=False): + return [ + dict( + **row, + hop=hop, + view=view, + mode="direct", + prompt=view_prompt(row, hop, view), + answer=base.answer(row, hop), + ) + for view in ((0, 1) if extras else (0,)) + for row in world + if view == 0 or row["split"] == "target" + for hop in range(3) + ] + + +def autonomous_rows(world, direct): + lookup = {r["id"]: r for r in world} + result = [] + for first in direct: + if first["split"] != "target" or first["hop"] != 0: + continue + bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip() + row = lookup[first["id"]] + substituted = dict(row, bridge=bridge) + result.append( + dict( + **row, + hop=2, + view=first["view"], + mode="autonomous", + prompt=view_prompt(substituted, 1, first["view"]), + answer=row["city"], + generated_bridge=bridge, + first_tokens=first["tokens"], + first_text=first["text"], + first_correct=first["correct"], + ) + ) + return result + + +@torch.inference_mode() +def generate(model, tokenizer, rows, config): + model.eval() + tokenizer.padding_side = "left" + result = [] + for start in range(0, len(rows), config["eval_batch"]): + chunk = rows[start : start + config["eval_batch"]] + x = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(config["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + tokens = model.generate( + **x, + do_sample=False, + max_new_tokens=config["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, x.input_ids.shape[1] :] + for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True): + if tokenizer.eos_token_id in tok: + tok = tok[: tok.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tok, skip_special_tokens=True) + result.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"]))) + return result + + +def evaluate(model, tokenizer, world, config, extras=False): + direct = generate(model, tokenizer, evaluation_rows(world, extras), config) + if not extras: + return direct + return direct + generate(model, tokenizer, autonomous_rows(world, direct), config) + + +def mean_correct(rows): + return sum(r["correct"] for r in rows) / len(rows) if rows else None + + +def metrics(rows, old_world, edit): + primary = [r for r in rows if r["view"] == 0 and r["mode"] == "direct"] + result = base.score(primary) + result["background_atomic"] = mean_correct( + [r for r in primary if r["split"] == "background" and r["hop"] < 2] + ) + edited = set(edit["edited_ids"]) + old = {r["id"]: r for r in old_world} + for view in (0, 1): + subset = [r for r in rows if r["view"] == view] + if not subset: + continue + for pool, keep in (("E", True), ("U", False)): + target = [r for r in subset if r["split"] == "target" and (r["id"] in edited) == keep] + for hop, name in ((0, "first"), (1, "second"), (2, "two")): + cell = [r for r in target if r["hop"] == hop and r["mode"] == "direct"] + result[f"v{view}_{pool}_{name}"] = mean_correct(cell) + if hop == 2 and cell: + result[f"v{view}_{pool}_old_two"] = sum( + base.grade(r["text"], old[r["id"]]["city"]) for r in cell + ) / len(cell) + result[f"v{view}_{pool}_autonomous"] = mean_correct( + [r for r in target if r["mode"] == "autonomous"] + ) + if view == 1: + for hop, name in ((0, "first"), (1, "second"), (2, "two")): + result[f"heldout_{name}"] = mean_correct( + [r for r in subset if r["mode"] == "direct" and r["hop"] == hop] + ) + return result + + +def document_budget(docs): + width = max(len(d["ids"]) for d in docs) + return dict( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(sum(t != -100 for t in d["labels"]) for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + + +def prepare(config_path): + config = base.read(config_path) + art = Path(config["artifact_root"]) + if (art / "lock.json").exists(): + raise RuntimeError("Preserve existing lock.") + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + world = base.build_world(config) + batches = pairing_stream(config, world) + edit = edit_design(config, world) + records = base.corpus(tokenizer, world) + stats = {arm: Counter() for arm in config["arms"]} + for batch in batches: + signatures = [] + for arm in config["arms"]: + docs = training_documents(records, batch, arm, config["standalone_rehearsal_copies"]) + stats[arm].update(document_budget(docs)) + signatures.append( + ( + Counter(t for d in docs for t in d["ids"]), + Counter(t for d in docs for t in d["labels"] if t != -100), + ) + ) + assert all(s == signatures[0] for s in signatures) + changed = base.corpus(tokenizer, edit["world"]) + edit_stats = {branch: Counter() for branch in ("update", "replay")} + for specs in edit["stream"]: + for branch, rec in (("update", changed), ("replay", records)): + docs = [rec[tuple(s)] for s in specs] + edit_stats[branch].update(document_budget(docs)) + assert [len(changed[tuple(s)]["ids"]) for s in specs] == [ + len(records[tuple(s)]["ids"]) for s in specs + ] + assert edit_stats["update"] == edit_stats["replay"] + base.write(art / "world.json", world) + base.write(art / "stream.json", batches) + base.write(art / "edit-design.json", edit) + base.write( + art / "data-audit.json", + dict( + status="passed", + training=stats, + editing=edit_stats, + paired_batch_checks=len(batches), + equal_edit_length_checks=len(edit["stream"]), + target_composition_labels=0, + edit_target_composition_labels=0, + ), + ) + sources = [ + str(config_path), + str(Path(__file__).relative_to(Path.cwd())) if Path(__file__).is_absolute() else __file__, + "src/llm_memory_editability/small_lm_composition.py", + "scripts/run_small_lm_followup.py", + "tests/test_small_lm_followup.py", + str(art / "development-plan.md"), + ] + hashes = {} + for source in sources: + relative = Path(source).resolve().relative_to(Path.cwd()) + dest = art / "source" / relative + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(relative, dest) + hashes[str(relative)] = base.sha(relative) + model_files = { + str(p): base.sha(p) + for p in Path(config["model_path"]).iterdir() + if p.suffix in (".safetensors", ".json") + } + base.write( + art / "lock.json", + dict( + status="locked_before_training", + utc=base.now(), + sources=hashes, + model_files=model_files, + data_files={ + str(art / f): base.sha(art / f) + for f in ("world.json", "stream.json", "edit-design.json", "data-audit.json") + }, + ), + ) + print(json.dumps(dict(status="prepared", training=stats, editing=edit_stats)), flush=True) + + +def check_lock(config): + art = Path(config["artifact_root"]) + lock = base.read(art / "lock.json") + for group in ("sources", "model_files", "data_files"): + for path, digest in lock[group].items(): + assert base.sha(path) == digest, path + + +def learning_rate(step, steps, lr, minimum, warmup): + decay = 0.5 * (1 + math.cos(math.pi * max(0, step - warmup) / (steps - warmup))) + return (minimum + (lr - minimum) * decay) * min(1.0, (step + 1) / warmup) + + +def run(config_path, arm, branch=None): + config = base.read(config_path) + check_lock(config) + assert arm in config["arms"] and branch in (None, "update", "replay") + art = Path(config["artifact_root"]) + root = Path(config["output_root"]) + out = root / ("training" if branch is None else "editing") / arm + if branch: + out = out / branch + if (out / "status.json").exists(): + raise RuntimeError(f"Preserve existing run: {out}") + old_world = base.read(art / "world.json") + edit = base.read(art / "edit-design.json") + # Both update and replay are scored against the SAME edited world. + world = edit["world"] if branch else old_world + source = Path(config["model_path"]) if branch is None else root / "training" / arm / "model" + if branch: + parent = base.read(root / "training" / arm / "summary.json") + for path, digest in parent["checkpoint_files"].items(): + assert base.sha(path) == digest + steps = config["edit_steps"] if branch else config["steps"] + nodes = config["edit_nodes"] if branch else config["nodes"] + seed = config["edit_training_seed"] if branch else config["training_seed"] + prefix = "edit_" if branch else "" + batches = edit["stream"] if branch else base.read(art / "stream.json") + base.write(out / "status.json", dict(status="running", utc=base.now(), arm=arm, branch=branch)) + started = time.perf_counter() + torch.set_num_threads(config["cpu_threads"]) + torch.manual_seed(seed) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.set_device(config["device"]) + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + + def load_model(path): + return AutoModelForCausalLM.from_pretrained( + path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True + ).to(config["device"]) + + model = load_model(source) + model.requires_grad_(True) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + samples = base.parameter_samples(model) + parameter_count = sum(p.numel() for p in model.parameters()) + records = base.corpus(tokenizer, edit["world"] if branch == "update" else old_world) + optimizer = torch.optim.AdamW( + model.parameters(), + lr=config[prefix + "learning_rate"], + weight_decay=config["weight_decay"], + fused=True, + ) + curve, budget = [], Counter() + train_seconds = 0.0 + for step in range(steps + 1): + if step in nodes: + rows = evaluate(model, tokenizer, world, config, extras=step == steps) + base.write(out / f"predictions-{step:05d}.json", rows) + record = dict(step=step, **metrics(rows, old_world, edit)) + curve.append(record) + base.write(out / "curve.json", curve) + print(json.dumps(dict(arm=arm, branch=branch, **record)), flush=True) + if step == steps: + break + rate = learning_rate( + step, + steps, + config[prefix + "learning_rate"], + config[prefix + "minimum_learning_rate"], + config[prefix + "warmup_steps"], + ) + for group in optimizer.param_groups: + group["lr"] = rate + docs = ( + [records[tuple(s)] for s in batches[step]] + if branch + else training_documents( + records, batches[step], arm, config["standalone_rehearsal_copies"] + ) + ) + budget.update(document_budget(docs)) + inputs = base.batch_tensors(docs, tokenizer.pad_token_id, config["device"]) + model.train() + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = model(**inputs, use_cache=False).loss + assert torch.isfinite(loss) + loss.backward() + if step == 0: + assert all( + p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all() + for p in model.parameters() + ) + torch.nn.utils.clip_grad_norm_(model.parameters(), config["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 64 == 0: + print( + json.dumps( + dict( + arm=arm, + branch=branch, + step=step + 1, + loss=float(loss.detach()), + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + n: not torch.equal(before, base.parameter_samples(model)[n]) + for n, before in samples.items() + } + assert all(changed.values()) + architecture = model.config.to_dict() + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + reloaded = load_model(out / "model") + again = evaluate(reloaded, tokenizer, world, config, extras=True) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again] + assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again] + base.write( + out / "reload-audit.json", + dict( + status="passed", + predictions=len(again), + exact_generated_tokens=True, + exact_autonomous_prompts=True, + ), + ) + expected = base.read(art / "data-audit.json") + assert budget == expected["editing" if branch else "training"][branch or arm] + # Dense matrix estimate: 3x forward for training; all vocab logits are evaluated. + d, layers, intermediate = 1024, 28, architecture["intermediate_size"] + kv = architecture["num_key_value_heads"] * architecture["head_dim"] + query_width = architecture["num_attention_heads"] * architecture["head_dim"] + attention_projections = 2 * d * query_width + 2 * d * kv + per_token = layers * (attention_projections + 3 * d * intermediate) + per_token += d * architecture["vocab_size"] + flops = ( + 6 * per_token * budget["padded_tokens"] + + 12 + * layers + * (architecture["num_attention_heads"] * architecture["head_dim"]) + * budget["attention_cells"] + ) + summary = dict( + status="complete", + phase="development_only", + arm=arm, + branch=branch, + utc=base.now(), + metrics=metrics(final_rows, old_world, edit), + updates=steps, + parameter_count=parameter_count, + trainable_parameters=parameter_count, + initial_all_gradients_finite=True, + sampled_parameters_changed=changed, + source_checkpoint=str(source), + fresh_optimizer=True, + budget=dict(budget), + estimated_training_matrix_flops=flops, + train_seconds=train_seconds, + process_seconds=time.perf_counter() - started, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + tf32=False, + lock_sha256=base.sha(art / "lock.json"), + checkpoint_files={str(p): base.sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + base.write(out / "summary.json", summary) + base.write(out / "status.json", dict(status="complete", utc=base.now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + config = base.read(config_path) + check_lock(config) + art, root = Path(config["artifact_root"]), Path(config["output_root"]) + world, edit = base.read(art / "world.json"), base.read(art / "edit-design.json") + runs = {} + checks = 0 + for arm in config["arms"]: + for branch in (None, "update", "replay"): + out = root / ("editing" if branch else "training") / arm + if branch: + out /= branch + key = f"{arm}/{branch or 'training'}" + summary = base.read(out / "summary.json") + assert summary["status"] == "complete" + assert base.read(out / "reload-audit.json")["status"] == "passed" + for node in base.read(out / "curve.json"): + rows = base.read(out / f"predictions-{node['step']:05d}.json") + assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows) + assert dict(step=node["step"], **metrics(rows, world, edit)) == node + checks += len(rows) + assert metrics(rows, world, edit) == summary["metrics"] + runs[key] = summary + result = dict( + status="complete", + phase="single_world_development", + utc=base.now(), + runs=runs, + node_prediction_checks=checks, + total_train_seconds=sum(r["train_seconds"] for r in runs.values()), + total_process_seconds=sum(r["process_seconds"] for r in runs.values()), + total_updates=sum(r["updates"] for r in runs.values()), + total_input_tokens=sum(r["budget"]["input_tokens"] for r in runs.values()), + total_supervised_tokens=sum(r["budget"]["supervised_tokens"] for r in runs.values()), + estimated_training_matrix_flops=sum( + r["estimated_training_matrix_flops"] for r in runs.values() + ), + lock_sha256=base.sha(art / "lock.json"), + ) + base.write(art / "summary.json", result) + print(json.dumps({k: v for k, v in result.items() if k != "runs"}), flush=True) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_composition.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_composition.py new file mode 100644 index 0000000000000000000000000000000000000000..094211c26edecbed2a534bad16c84c42b2cdebd0 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_composition.py @@ -0,0 +1,424 @@ +"""Fact-load experiments in unmodified GPT-2 blocks and depth-shared GPT-2 blocks. + +Template-language data are controlled; the architecture is an ordinary causal LM. +No embeddings/projections are frozen, no intermediate answers are supplied, and +all non-padding next tokens contribute to the training loss. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig +from .grok_depth import EpochStream, GraphStep, SmallGPT, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .text_pretrain import WORDS, atomic_sentence, composite_sentence + +SOURCE_FILES = [ + "src/llm_memory_editability/storage_composition.py", + "src/llm_memory_editability/bios_model.py", + "src/llm_memory_editability/grok_depth.py", + "src/llm_memory_editability/grok_loop_model.py", + "src/llm_memory_editability/text_pretrain.py", + "scripts/run_storage_composition.py", + "tests/test_storage_composition.py", +] +ARCHITECTURES = { + "standard1": (1, 1), + "standard2": (2, 1), + "standard3": (3, 1), + "loop1x2": (1, 2), + "loop1x3": (1, 3), +} + + +def file_hash(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def build_world(spec): + """Keep the target subgraph, vocabulary and candidates fixed across loads. + + Matched low load repeats anchor atomics outside every evaluated chain. + High load teaches distinct distractor atomics. The original development + setting repeated familiar atomics; its results are retained separately. + """ + rng = np.random.default_rng(spec["world"]) + hn, bn, tn = (spec[k] for k in ("heads_n", "bridges_n", "tails_n")) + familiar, strict = spec["familiar_n"], spec["strict_n"] + core = familiar + strict + if not (0 < familiar < core <= min(hn, bn)): + raise ValueError("Invalid disjoint familiar/strict subgraph sizes") + heads = np.arange(len(WORDS), len(WORDS) + hn) + bridges = np.arange(heads[-1] + 1, heads[-1] + 1 + bn) + tails = np.arange(bridges[-1] + 1, bridges[-1] + 1 + tn) + first = [] + for index, head in enumerate(heads): + candidates = ( + bridges[:familiar] + if index < familiar + else bridges[familiar:core] + if index < core + else bridges + ) + first.extend((head, r, rng.choice(candidates)) for r in range(13, 17)) + first = np.asarray(first, dtype=np.int64) + second = np.asarray( + [(b, r, rng.choice(tails)) for b in bridges for r in range(17, 21)], dtype=np.int64 + ) + lookup = {(int(h), int(r)): int(t) for h, r, t in second} + paths = np.asarray( + [ + (h, r1, b, r2, lookup[int(b), r2]) + for h, r1, b in first[: core * 4] + for r2 in range(17, 21) + ], + dtype=np.int64, + ) + familiar_paths = paths[paths[:, 0] < heads[familiar]] + # Hold out entire (head, terminal) pairs, including alternate relation paths. + reserved = rng.random((familiar, tn)) < spec["holdout_fraction"] + held = reserved[familiar_paths[:, 0] - heads[0], familiar_paths[:, 4] - tails[0]] + world = { + "common_atomic": np.concatenate([first[: core * 4], second[: core * 4]]), + "background_atomic": np.concatenate([first[: familiar * 4], second[: familiar * 4]]), + "extra_atomic": np.concatenate([first[core * 4 :], second[core * 4 :]]), + "train_composite": familiar_paths[~held], + "familiar_test": familiar_paths[held], + "strict_test": paths[paths[:, 0] >= heads[familiar]], + } + if spec.get("low_extra") == "anchors": + anchors = spec["anchor_n"] + if not 0 < anchors <= min(hn, bn) - core: + raise ValueError("Anchor entities must be outside the common subgraph") + world["anchor_atomic"] = np.concatenate( + [first[core * 4 : (core + anchors) * 4], second[core * 4 : (core + anchors) * 4]] + ) + if any(not len(rows) for rows in world.values()): + raise ValueError("Empty stratum: do not silently reroll a world") + atoms = np.concatenate([world["common_atomic"], world["extra_atomic"]]) + audit_world(world) + assert len(atoms) == 4 * (hn + bn) + return world + + +def audit_world(world): + atoms = np.concatenate([world["common_atomic"], world["extra_atomic"]]) + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + assert len(lookup) == len(atoms) + for name in ("train_composite", "familiar_test", "strict_test"): + for h, r1, b, r2, t in world[name]: + assert lookup[int(h), int(r1)] == b + assert lookup[int(b), int(r2)] == t + train_pairs = {tuple(r[[0, 4]]) for r in world["train_composite"]} + assert not train_pairs & {tuple(r[[0, 4]]) for r in world["familiar_test"]} + train_facts = {(int(h), int(r1), int(b)) for h, r1, b, _r2, _t in world["train_composite"]} | { + (int(b), int(r2), int(t)) for _h, _r1, b, r2, t in world["train_composite"] + } + strict_facts = {(int(h), int(r1), int(b)) for h, r1, b, _r2, _t in world["strict_test"]} | { + (int(b), int(r2), int(t)) for _h, _r1, b, r2, t in world["strict_test"] + } + assert not strict_facts & train_facts + assert not strict_facts & set(map(tuple, world["extra_atomic"])) + if "anchor_atomic" in world: + assert not set(map(tuple, world["anchor_atomic"])) & set(map(tuple, world["common_atomic"])) + assert set(map(tuple, world["anchor_atomic"])) <= set(map(tuple, world["extra_atomic"])) + + +def pack_sentences(rows): + render = atomic_sentence if rows.shape[1] == 3 else composite_sentence + x = np.zeros((len(rows), 9), dtype=np.int64) + labels = np.full_like(x, -100) + for index, row in enumerate(rows): + sentence = render(row) + x[index, : len(sentence) - 1] = sentence[:-1] + labels[index, : len(sentence) - 1] = sentence[1:] + return x, labels + + +class FullTokenStep(GraphStep): + def eager(self): + self.optimizer.zero_grad(set_to_none=True) + tokens, labels = (part[self.index] for part in self.table) + logits = self.model(tokens) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def construct(spec, device): + layers, repeats = ARCHITECTURES[spec["architecture"]] + config = ModelConfig( + vocab_size=len(WORDS) + spec["heads_n"] + spec["bridges_n"] + spec["tails_n"], + width=spec["width"], + layers=layers, + heads=spec["heads"], + context=16, + ) + torch.manual_seed(spec["initialization"]) + if repeats == 1: + model = SmallGPT(config, dropout=spec["dropout"]) + else: + # Same unique-block initialization as standard1, without zeroing residuals. + model = LoopGPT(config, repeats, spec["dropout"], initialization="legacy_unique") + return model.to(device) + + +@torch.no_grad() +def generate_rows(model, rows, device, repeats=None, batch_size=512): + """Greedy answer, then '.', then EOS; feed back every generated token.""" + model.eval() + if rows.shape[1] == 3: + prompts = np.asarray([atomic_sentence(r)[:5] for r in rows]) + else: + prompts = np.asarray([composite_sentence(r)[:7] for r in rows]) + predictions, nlls = [], [] + kwargs = {"repeats": repeats} if isinstance(model, LoopGPT) else {} + for start in range(0, len(rows), batch_size): + tokens = torch.as_tensor(prompts[start : start + batch_size], device=device) + target = torch.as_tensor(rows[start : start + batch_size, -1], device=device) + generated = [] + for i in range(3): + logits = model(tokens, **kwargs)[:, -1] + if i == 0: + nlls.append(F.cross_entropy(logits, target, reduction="none").cpu().numpy()) + next_token = logits.argmax(-1) + generated.append(next_token.cpu().numpy()) + tokens = torch.cat([tokens, next_token[:, None]], dim=1) + predictions.append(np.stack(generated, axis=1)) + pred, nll = np.concatenate(predictions), np.concatenate(nlls) + answer_ok = pred[:, 0] == rows[:, -1] + full_ok = answer_ok & (pred[:, 1] == 5) & (pred[:, 2] == 1) + metrics = { + "n": len(rows), + "answer_accuracy": float(answer_ok.mean()), + "accuracy": float(full_ok.mean()), + "answer_nll": float(nll.mean()), + } + return metrics, {"generated": pred, "correct": full_ok, "answer_nll": nll} + + +def evaluate(model, world, load, device, repeats=None): + metrics, predictions = {}, {} + names = ["common_atomic", "train_composite", "familiar_test", "strict_test"] + if "anchor_atomic" in world: + names.append("anchor_atomic") + if load == "high": + names.append("extra_atomic") + for name in names: + metrics[name], pred = generate_rows(model, world[name], device, repeats) + predictions.update({name + "_" + k: v for k, v in pred.items()}) + for name in ("familiar_test", "strict_test"): + rows = world[name] + first = rows[:, [0, 1, 2]] + second = rows[:, [2, 3, 4]] + _m, p1 = generate_rows(model, first, device, repeats) + _m, p2 = generate_rows(model, second, device, repeats) + covered = p1["correct"] & p2["correct"] + generated_second = second.copy() + generated_second[:, 0] = p1["generated"][:, 0] + _m, autonomous = generate_rows(model, generated_second, device, repeats) + calls_ok = ( + (p1["generated"][:, 1] == 5) & (p1["generated"][:, 2] == 1) & autonomous["correct"] + ) + direct = predictions[name + "_correct"] + metrics[name].update( + { + "atomic_correct_coverage": float(covered.mean()), + "conditional_accuracy": float(direct[covered].mean()) if covered.any() else None, + "autonomous_two_calls": float(calls_ok.mean()), + } + ) + predictions.update({name + "_coverage": covered, name + "_two_calls": calls_ok}) + model.train() + return metrics, predictions + + +def data_digest(world): + digest = hashlib.sha256() + for key, value in sorted(world.items()): + digest.update(key.encode()) + digest.update(str(value.shape).encode()) + digest.update(value.tobytes()) + return digest.hexdigest() + + +def run(spec, out, device="cuda:2"): + out = Path(out) + if (out / "complete.json").exists(): + raise FileExistsError(f"Completed run exists: {out}") + out.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + device = torch.device(device) + torch.cuda.set_device(device) + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + source = {path: file_hash(path) for path in SOURCE_FILES} + write_json( + out / "spec.json", {"spec": spec, "source": source, "data_sha256": data_digest(world)} + ) + model = construct(spec, device) + lr = torch.tensor(spec["lr"], device=device) + opt = make_optimizer(model, lr, spec["weight_decay"]) + low_extra = world["anchor_atomic"] if "anchor_atomic" in world else world["background_atomic"] + extra = world["extra_atomic"] if spec["load"] == "high" else low_extra + strata = [world["common_atomic"], world["train_composite"], extra] + packed = [pack_sentences(rows) for rows in strata] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) for parts in zip(*packed, strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + if batch % 3: + raise ValueError("Batch must divide into three equal exposure strata") + graph = FullTokenStep(model, opt, table, batch) + history, training_seconds = [], 0.0 + layers, repeats = ARCHITECTURES[spec["architecture"]] + parameters = sum(p.numel() for p in model.parameters()) + flop_step = flops(model.config, repeats, batch, 9, output_positions=9) + start = 0 + + def measure(step, loss=None): + metrics, predictions = evaluate(model, world, spec["load"], device) + row = { + "step": step, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": opt.state_dict(), + "streams": [s.state_dict() for s in streams], + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "counts": counts, + "source": source, + "data_sha256": data_digest(world), + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + write_json( + out / "status.json", + { + "step": step, + "budget": spec["steps"], + "atomic": metrics["common_atomic"]["accuracy"], + "familiar": metrics["familiar_test"]["accuracy"], + "strict": metrics["strict_test"]["accuracy"], + }, + ) + print(json.dumps({"run": str(out), "step": step, "metrics": metrics}), flush=True) + return row + + measure(0) + for end in spec["nodes"]: + if end == 0: + continue + torch.cuda.synchronize() + t0 = time.perf_counter() + while start < end: + n = min(128, end - start) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(spec["lr"] * min(1.0, (start + j + 1) / spec["warmup"])) + last_loss = graph(indices[j]) + start += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - t0 + loss = float(last_loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite loss at {end}") + endpoint = measure(end, loss) + assert start == spec["steps"] + # Prespecified test-time repeat sweep; these weights never change. + repeat_metrics = {} + if isinstance(model, LoopGPT): + for count in spec["test_repeats"]: + metrics, predictions = evaluate(model, world, spec["load"], device, count) + repeat_metrics[str(count)] = metrics + np.savez_compressed(out / f"repeat-{count:02d}.npz", **predictions) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + write_json( + out / "complete.json", + { + "spec": spec, + "finished_utc": utc(), + "parameters": parameters, + "unique_blocks": layers, + "executed_blocks": layers * repeats, + "independent_facts": len(world["common_atomic"]) + + (len(extra) if spec["load"] == "high" or "anchor_atomic" in world else 0), + "training_seconds": training_seconds, + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "examples": start * batch, + "effective_input_tokens": start * batch * 23 // 3, + "supervised_tokens": start * batch * 23 // 3, + "padded_input_tokens": start * batch * 9, + "source": source, + "data_sha256": data_digest(world), + "environment": {"torch": torch.__version__, "gpu": torch.cuda.get_device_name(device)}, + }, + ) + return endpoint + + +def audit_run(out, device="cuda:2"): + """Independently reload the final checkpoint and regenerate all endpoint tokens.""" + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + out = Path(out) + complete = json.loads((out / "complete.json").read_text()) + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + assert saved["step"] == complete["spec"]["steps"] + world = build_world(saved["spec"]) + assert data_digest(world) == saved["data_sha256"] == complete["data_sha256"] + model = construct(saved["spec"], device) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, saved["spec"]["load"], device) + expected = np.load(out / f"predictions-{saved['step']:06d}.npz") + for key, value in predictions.items(): + # Tiny batching/platform differences can affect NLL, never generated tokens. + np.testing.assert_allclose(value, expected[key], rtol=1e-5, atol=1e-5) + assert metrics == complete["endpoint"]["metrics"] + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == saved["step"] * saved["spec"]["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + result = { + "passed": True, + "step": saved["step"], + "prediction_arrays": len(predictions), + "utc": utc(), + } + write_json(out / "audit.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_frontier.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_frontier.py new file mode 100644 index 0000000000000000000000000000000000000000..db36e560aed8b173bb72c836b3d02dc8381bbcc5 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_frontier.py @@ -0,0 +1,262 @@ +"""Stable training and nested fact loads in ordinary GPT/Loop architectures. + +The historical storage_composition implementation is reused without changing its +frozen sources, truth, tokenizer, architecture or full-generation score. +""" + +from __future__ import annotations + +import json +import math +import time +from pathlib import Path + +import numpy as np +import torch + +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .storage_composition import ( + ARCHITECTURES, + FullTokenStep, + construct, + data_digest, + evaluate, + file_hash, + pack_sentences, +) +from .storage_composition import ( + SOURCE_FILES as HISTORICAL_SOURCE_FILES, +) +from .storage_composition import ( + build_world as historical_world, +) + +SOURCE_FILES = [ + *HISTORICAL_SOURCE_FILES, + "src/llm_memory_editability/storage_frontier.py", + "scripts/run_storage_frontier.py", + "tests/test_storage_frontier.py", +] + + +def learning_rate(spec, step): + """One-based update; paired schedules share the exact same warmup.""" + if not 1 <= step <= spec["steps"]: + raise ValueError("Step must be within the training budget") + warmup = spec["warmup"] + if warmup and step <= warmup: + return spec["lr"] * step / warmup + if spec["schedule"] == "constant": + return spec["lr"] + if spec["schedule"] != "cosine": + raise ValueError("Unknown learning-rate schedule") + fraction = (step - warmup) / (spec["steps"] - warmup) + floor = spec["min_lr_ratio"] + return spec["lr"] * (floor + (1 - floor) * (1 + math.cos(math.pi * fraction)) / 2) + + +def build_world(spec): + world = historical_world(spec) + if "extra_count" in spec: + # A world-specific, fixed permutation defines nested distractor fact sets. + # Common facts and every combination example remain bit-identical. + count = spec["extra_count"] + if not 0 < count <= len(world["extra_atomic"]): + raise ValueError("Extra fact count exceeds the fixed master graph") + rng = np.random.default_rng(spec["world"] + 900000) + order = rng.permutation(len(world["extra_atomic"])) + world["extra_atomic"] = world["extra_atomic"][order[:count]] + return world + + +def strata_for(spec, world): + extra = world["extra_atomic"] if spec["load"] == "high" else world["anchor_atomic"] + return [world["common_atomic"], world["train_composite"], extra] + + +def run_name(spec): + load = spec["load"] + if "extra_count" in spec: + load = f"f{spec['extra_count'] + 8 * (spec['familiar_n'] + spec['strict_n'])}" + return ( + f"w{spec['world']}-i{spec['initialization']}-{spec['architecture']}" + f"-d{spec['width']}-{load}-{spec['schedule']}-s{spec['steps']}" + ) + + +def train(spec, out, source, device="cuda:0"): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "latest.pt").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite an existing training attempt: {out}") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + device = torch.device(device) + torch.cuda.set_device(device) + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + digest = data_digest(world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_sha = file_hash(out / "spec.json") + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + strata = strata_for(spec, world) + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + if batch % 3: + raise ValueError("Batch must divide into three equal streams") + graph = FullTokenStep(model, optimizer, table, batch) + layers, repeats = ARCHITECTURES[spec["architecture"]] + flop_step = flops(model.config, repeats, batch, 9, output_positions=9) + history, training_seconds, start = [], 0.0, 0 + + def measure(step, loss=None): + metrics, predictions = evaluate(model, world, spec["load"], device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [stream.state_dict() for stream in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print(json.dumps({"run": run_name(spec), "step": step, "metrics": metrics}), flush=True) + return row + + measure(0) + for end in spec["nodes"]: + if not end: + continue + torch.cuda.synchronize() + started = time.perf_counter() + while start < end: + n = min(128, end - start) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(learning_rate(spec, start + j + 1)) + last_loss = graph(indices[j]) + start += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - started + loss = float(last_loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite training loss at {end}") + endpoint = measure(end, loss) + assert start == spec["steps"] + repeat_metrics = {} + if isinstance(model, LoopGPT): + for repeat in spec["test_repeats"]: + metrics, predictions = evaluate(model, world, spec["load"], device, repeat) + repeat_metrics[str(repeat)] = metrics + np.savez_compressed(out / f"repeat-{repeat:02d}.npz", **predictions) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + result = { + "spec": spec, + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "unique_blocks": layers, + "executed_blocks": layers * repeats, + "independent_facts": len(strata[0]) + len(strata[2]), + "training_seconds": training_seconds, + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "source": source, + "data_sha256": digest, + "spec_sha256": initial_sha, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "supervised_tokens": start * batch * 23 // 3, + "padded_input_tokens": start * batch * 9, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device), + "tf32": True, + }, + } + write_json(out / "complete.json", result) + return result + + +def audit(out, device="cuda:0"): + """Independent-process reload: tokens exact, floating NLL tolerance recorded.""" + out = Path(out) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + complete = json.loads((out / "complete.json").read_text()) + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + assert saved["step"] == complete["spec"]["steps"] + assert file_hash(out / "latest.pt") == complete["checkpoint_sha256"] + world = build_world(saved["spec"]) + assert data_digest(world) == saved["data_sha256"] == complete["data_sha256"] + model = construct(saved["spec"], device) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, saved["spec"]["load"], device) + expected = np.load(out / f"predictions-{saved['step']:06d}.npz") + max_nll_difference = 0.0 + for key, value in predictions.items(): + if key.endswith("answer_nll"): + max_nll_difference = max(max_nll_difference, float(np.abs(value - expected[key]).max())) + np.testing.assert_allclose(value, expected[key], rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(value, expected[key]) + for task, values in metrics.items(): + for key, value in values.items(): + reference = complete["endpoint"]["metrics"][task][key] + if key == "answer_nll": + np.testing.assert_allclose(value, reference, rtol=1e-5, atol=1e-5) + else: + assert value == reference + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == saved["step"] * saved["spec"]["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + result = { + "passed": True, + "step": saved["step"], + "prediction_arrays": len(predictions), + "max_nll_difference": max_nll_difference, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "tokens_exact": True, + "utc": utc(), + } + write_json(out / "audit.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_loss_source.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_loss_source.py new file mode 100644 index 0000000000000000000000000000000000000000..6f9377848d4673a2937273cf26a33f8e859874d0 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_loss_source.py @@ -0,0 +1,256 @@ +"""Factorial loss-source interventions on an unchanged text-pretraining stream.""" + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import EpochStream, GraphStep, make_optimizer, write_json +from .grok_loop_model import flops +from .text_pretrain import construct, evaluate, sha + +ARMS = {"AB": (1, 1), "A": (1, 0), "B": (0, 1), "N": (0, 0)} +SPLITS = ("atomic", "background_train", "background_test", "target_train", "target_test") + + +def loss_sources(labels, bounds): + """0=atomic text, 1=background composition, 2=neutral text, -1=ignored.""" + result = np.full(labels.shape, -1, dtype=np.int64) + result[: bounds[1]] = 0 + result[bounds[1] : bounds[2]] = 1 + result[bounds[2] :, :15] = 0 + result[bounds[2] :, 16:] = 2 + result[labels == -100] = -1 + assert np.array_equal(result >= 0, labels != -100) + return result + + +def weights_for(source, arm): + a, b = ARMS[arm] + return ((source == 0) * a + (source == 1) * b + (source == 2)).astype(np.float32) + + +def weighted_loss(logits, labels, weights): + per_token = F.cross_entropy( + logits.flatten(0, 1), labels.flatten(), reduction="none", ignore_index=-100 + ).view_as(labels) + # Removing a source does NOT renormalize the remaining losses. + return (per_token * weights).sum() / (labels != -100).sum() + + +class SourceGraphStep(GraphStep): + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, positions, mask, labels, weights = (t[self.index] for t in self.table) + logits = self.model(x, position_ids=positions, attention_mask=mask) + loss = weighted_loss(logits, labels, weights) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +@torch.inference_mode() +def measure(model, world, table, source, device): + scores, predictions = {}, {} + for split in SPLITS: + scores[split], pred = evaluate(model, world[split], device, composite=split != "atomic") + predictions.update({split + "_" + k: v for k, v in pred.items()}) + atomic = predictions["atomic_answer"] == world["atomic"][:, -1] + known = {(h, r): ok for (h, r, _), ok in zip(world["atomic"], atomic, strict=True)} + eligible = np.array([known[h, r1] and known[b, r2] for h, r1, b, r2, t in world["target_test"]]) + full = (predictions["target_test_answer"] == world["target_test"][:, -1]) & ( + predictions["target_test_stops"] == [5, 1] + ).all(-1) + scores["both_atomics"] = dict( + n=int(eligible.sum()), + coverage=float(eligible.mean()), + accuracy=float(full[eligible].mean()) if eligible.any() else None, + ) + sums, counts = np.zeros(3), np.zeros(3, dtype=np.int64) + for start in range(0, len(table[0]), 128): + x, pos, mask, labels = [ + torch.as_tensor(t[start : start + 128], device=device) for t in table[:4] + ] + logits = model(x, position_ids=pos, attention_mask=mask) + nll = ( + F.cross_entropy( + logits.flatten(0, 1), labels.flatten(), reduction="none", ignore_index=-100 + ) + .view_as(labels) + .cpu() + .numpy() + ) + for group in range(3): + selected = source[start : start + 128] == group + sums[group] += nll[selected].sum(dtype=np.float64) + counts[group] += selected.sum() + scores["training_text_nll"] = { + name: float(sums[i] / counts[i]) + for i, name in enumerate(("atomic", "background", "neutral")) + } + return scores, predictions + + +def run(cfg, name, device): + overrides = cfg["runs"][name] + root = Path(cfg["output_root"]) / name + if (root / "complete.json").exists(): + return + lock = json.loads(Path(cfg["lock"]).read_text()) + for p, digest in lock["sources"].items(): + assert sha(p) == digest, p + assert sha(cfg["config_path"]) == lock["config_sha256"] + assert sha(cfg["plan"]) == lock["plan_sha256"] + for p, expected in lock["inputs"].items(): + assert sha(p) == expected, p + parent = Path(overrides["parent"]) + assert sha(parent / "latest.pt") == lock["parents"][str(parent / "latest.pt")] + root.mkdir(parents=True, exist_ok=True) + state = torch.load(parent / "latest.pt", map_location=device, weights_only=False) + spec = state["spec"] + assert spec["arm"] == "P1" and state["step"] == 32000 + world = dict(np.load(parent / "world.npz")) + stored = np.load(parent / "training-table.npz") + table = tuple(stored[k] for k in ("tokens", "positions", "mask", "labels")) + bounds = np.cumsum( + [0, len(world["atomic"]), len(world["background_train"]), len(world["target_train"])] + ) + source = loss_sources(table[3], bounds) + weights = weights_for(source, overrides["arm"]) + gpu_table = tuple(torch.as_tensor(t, device=device) for t in (*table, weights)) + model = construct(spec, device) + model.load_state_dict(state["model"]) + opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"]) + opt.load_state_dict(state["optimizer"]) + streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(3)] + for stream, saved in zip(streams, state["streams"], strict=True): + stream.load_state_dict(saved) + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + settings = dict( + parent=str(parent), + world=spec["world"], + initialization=spec["initialization"], + arm=overrides["arm"], + steps=cfg["steps"], + parent_sha256=sha(parent / "latest.pt"), + config=cfg["config_path"], + ) + write_json(root / "settings.json", settings) + start, elapsed, histories = 0, 0.0, [] + digest = hashlib.sha256() + # Recovery is deliberately from this branch's saved stream, never its parent's. + if (root / "latest.pt").exists(): + saved = torch.load(root / "latest.pt", map_location=device, weights_only=False) + assert saved["settings"] == settings + model.load_state_dict(saved["model"]) + opt.load_state_dict(saved["optimizer"]) + for stream, value in zip(streams, saved["streams"], strict=True): + stream.load_state_dict(value) + torch.set_rng_state(saved["cpu_rng"].cpu()) + torch.cuda.set_rng_state(saved["cuda_rng"].cpu(), device) + start, elapsed, histories = saved["step"], saved["seconds"], saved["histories"] + # Rebuild the hash of previously consumed paired indices from the parent state. + replay = [EpochStream(bounds[i + 1] - bounds[i], 0) for i in range(3)] + for stream, value in zip(replay, state["streams"], strict=True): + stream.load_state_dict(value) + for _ in range(start): + idx = np.concatenate( + [ + stream.take(n) + lo + for stream, n, lo in zip(replay, spec["batch_parts"], bounds[:-1], strict=True) + ] + ) + digest.update(idx.tobytes()) + initial_vector = torch.nn.utils.parameters_to_vector( + [v for v in state["model"].values()] + ).clone() + + def checkpoint(step): + metrics, predictions = measure(model, world, table, source, device) + record = dict( + step=step, + seconds=elapsed, + metrics=metrics, + parameter_l2_from_source=float( + torch.linalg.vector_norm( + torch.nn.utils.parameters_to_vector(model.parameters()).detach() + - initial_vector + ) + ), + last_loss=None if step == 0 else float(graph.loss), + last_gradient_norm=None if step == 0 else float(graph.grad_norm), + ) + histories.append(record) + np.savez_compressed(root / f"predictions-{step:06d}.npz", **predictions) + write_json(root / "learning.json", histories) + model.train() + current = dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + streams=[s.state_dict() for s in streams], + cpu_rng=torch.get_rng_state(), + cuda_rng=torch.cuda.get_rng_state(device), + step=step, + seconds=elapsed, + histories=histories, + settings=settings, + ) + tmp = root / "latest.tmp" + torch.save(current, tmp) + tmp.replace(root / "latest.pt") + if step == 0 or step == cfg["steps"]: + torch.save( + dict(model=current["model"], step=step, settings=settings), + root / f"weights-{step:06d}.pt", + ) + print( + json.dumps( + dict( + run=name, + step=step, + target=metrics["target_test"]["accuracy"], + atomic=metrics["atomic"]["accuracy"], + background=metrics["background_test"]["accuracy"], + ) + ), + flush=True, + ) + + if start == 0: + checkpoint(0) + graph = SourceGraphStep(model, opt, gpu_table, sum(spec["batch_parts"])) + tick = time.monotonic() + for step in range(start + 1, cfg["steps"] + 1): + idx = np.concatenate( + [ + stream.take(n) + lo + for stream, n, lo in zip(streams, spec["batch_parts"], bounds[:-1], strict=True) + ] + ) + digest.update(idx.tobytes()) + graph(torch.as_tensor(idx, device=device)) + if step in cfg["nodes"]: + torch.cuda.synchronize() + elapsed += time.monotonic() - tick + checkpoint(step) + tick = time.monotonic() + a, b = ARMS[overrides["arm"]] + write_json( + root / "complete.json", + dict( + settings=settings, + final=histories[-1], + sample_trace_sha256=digest.hexdigest(), + visible_supervised_tokens=cfg["steps"] * 1984, + active_supervised_tokens=cfg["steps"] * (1120 * a + 288 * b + 576), + estimated_flops=cfg["steps"] + * flops(model.config, spec["repeats"], 128, 25, output_positions=25), + checkpoint_sha256=sha(root / "latest.pt"), + ), + ) diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_pretrain.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_pretrain.py new file mode 100644 index 0000000000000000000000000000000000000000..2682a0925a00e0e8b0eef3781521830d891ef9d7 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_pretrain.py @@ -0,0 +1,401 @@ +"""Paired full-token text pretraining with controlled cross-document access. + +P0/P1 have identical token arrays and labels; only document attention changes. +P2 replaces an isolated neutral record by a derived fact, an explicit change in +supervision. This is controlled template-language pretraining, not a pretrained +natural-language model or a replication of the original bioS scale. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig +from .grok_depth import EpochStream, GraphStep, make_optimizer, write_json +from .grok_loop_model import LoopGPT, flops + +WORDS = [ + "", + "", + "", + "'s", + "is", + ".", + "This", + "record", + "has", + "no", + "additional", + "fact", + "here", + "mentor", + "advisor", + "coach", + "supervisor", + "city", + "district", + "region", + "campus", +] +LENGTH = 26 +PAD, EOS, BOS = 0, 1, 2 + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def vocabulary(spec): + return ( + WORDS + + [f"Person{i:03d}" for i in range(spec["heads_n"])] + + [f"Expert{i:03d}" for i in range(spec["bridges_n"])] + + [f"Place{i:03d}" for i in range(spec["tails_n"])] + ) + + +def atomic_sentence(row): + h, r, t = map(int, row) + return [BOS, h, 3, r, 4, t, 5, EOS] + + +def composite_sentence(row): + h, r1, _b, r2, t = map(int, row) + return [BOS, h, 3, r1, 3, r2, 4, t, 5, EOS] + + +def pack_documents(documents, groups): + """Reset positions per record in every arm; BOS is an exogenous boundary. + + All remaining next-token targets, including names, relations and EOS, are + supervised. The next record's BOS and padding are never prediction targets. + """ + seq, positions, segments = [], [], [] + for doc, group in zip(documents, groups, strict=True): + seq.extend(doc) + positions.extend(range(len(doc))) + segments.extend([group] * len(doc)) + if len(seq) > LENGTH: + raise ValueError("Record exceeds fixed context") + n = len(seq) + seq += [PAD] * (LENGTH - n) + positions += [0] * (LENGTH - n) + segments += list(range(100, 100 + LENGTH - n)) + labels = np.asarray(seq[1:], dtype=np.int64) + labels[(labels == BOS) | (labels == PAD)] = -100 + seg = np.asarray(segments[:-1]) + mask = (seg[:, None] == seg[None, :]) & np.tri(LENGTH - 1, dtype=bool) + return ( + np.asarray(seq[:-1], dtype=np.int64), + np.asarray(positions[:-1], dtype=np.int64), + mask[None], + labels, + ) + + +def build_world(spec): + """One supplied world; complete head-tail pairs held out before rendering.""" + rng = np.random.default_rng(spec["world"]) + hn, bn, tn = spec["heads_n"], spec["bridges_n"], spec["tails_n"] + hs = np.arange(len(WORDS), len(WORDS) + hn) + bs = np.arange(hs[-1] + 1, hs[-1] + 1 + bn) + ts = np.arange(bs[-1] + 1, bs[-1] + 1 + tn) + first = np.array([(h, r, rng.choice(bs)) for h in hs for r in range(13, 17)]) + second = np.array([(b, r, rng.choice(ts)) for b in bs for r in range(17, 21)]) + lookup = {(int(h), int(r)): int(t) for h, r, t in second} + paths = np.array( + [(h, r1, b, r2, lookup[int(b), r2]) for h, r1, b in first for r2 in range(17, 21)], + dtype=np.int64, + ) + reserved = rng.random((hn, tn)) < spec["holdout_fraction"] + held = reserved[paths[:, 0] - hs[0], paths[:, 4] - ts[0]] + background = paths[:, 0] < hs[0] + hn // 2 + groups = { + "atomic_first": first, + "atomic_second": second, + "background_train": paths[background & ~held], + "background_test": paths[background & held], + "target_train": paths[~background & ~held], + "target_test": paths[~background & held], + } + for key, rows in groups.items(): + if not len(rows): + raise ValueError(f"Empty world stratum {key}; do not silently reroll") + train_pairs = {tuple(r[[0, 4]]) for r in paths[~held]} + test_pairs = {tuple(r[[0, 4]]) for r in paths[held]} + assert not train_pairs & test_pairs + # Typed atomics can never expose a head and a tail together. + assert not set(first[:, 0]) & set(second[:, 0]) + assert not set(first[:, 2]) & set(second[:, 2]) + groups["atomic"] = np.concatenate([first, second]) + groups["all_paths"] = paths + return groups + + +def training_table(world, arm): + if arm not in ("P0", "P1", "P2"): + raise ValueError(arm) + packed = [pack_documents([atomic_sentence(r)], [0]) for r in world["atomic"]] + base_end = len(packed) + packed.extend(pack_documents([composite_sentence(r)], [0]) for r in world["background_train"]) + background_end = len(packed) + neutral = [BOS, 6, 7, 8, 9, 10, 11, 12, 5, EOS] + for row in world["target_train"]: + h, r1, b, r2, t = row + third = composite_sentence(row) if arm == "P2" else neutral + packed.append( + pack_documents( + [atomic_sentence([h, r1, b]), atomic_sentence([b, r2, t]), third], + [0, 1, 2] if arm == "P0" else [0, 0, 2], + ) + ) + table = tuple(np.stack([row[i] for row in packed]) for i in range(4)) + return table, [0, base_end, background_end, len(packed)] + + +class TextGPT(LoopGPT): + def forward(self, tokens, position_ids=None, attention_mask=None, patch=None, cache=None): + if position_ids is None: + position_ids = torch.arange(tokens.shape[1], device=tokens.device)[None] + p = self.dropout if self.training else 0.0 + x = F.dropout(self.token(tokens) + self.position(position_ids), p=p, training=self.training) + for layer, block in enumerate(self.iter_blocks()): + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + attn_mask=attention_mask, + is_causal=attention_mask is None, + dropout_p=p, + ) + attn = F.dropout( + a.proj(y.transpose(1, 2).reshape(batch, length, width)), p=p, training=self.training + ) + mlp = F.dropout(block.mlp(block.ln2(x + attn)), p=p, training=self.training) + if cache is not None: + cache[layer] = { + "attention": attn.detach(), + "mlp": mlp.detach(), + "full": (x + attn + mlp).detach(), + } + if patch is not None and layer == patch["layer"]: + pos, value, component = patch["position"], patch["value"], patch["component"] + if component == "full": + x = x + attn + mlp + x = x.clone() + x[:, pos] = value + continue + if component == "attention": + attn = attn.clone() + attn[:, pos] = value + elif component == "mlp": + mlp = mlp.clone() + mlp[:, pos] = value + else: + raise ValueError(component) + x = x + attn + mlp + return F.linear(self.ln_final(x), self.token.weight) + + +class TextGraphStep(GraphStep): + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, positions, mask, labels = (t[self.index] for t in self.table) + logits = self.model(x, position_ids=positions, attention_mask=mask) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def construct(spec, device): + torch.manual_seed(spec["initialization"]) + cfg = ModelConfig( + vocab_size=len(vocabulary(spec)), + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=LENGTH, + ) + return TextGPT(cfg, repeats=spec["repeats"], dropout=spec["dropout"]).to(device) + + +@torch.inference_mode() +def evaluate(model, rows, device, composite=False, patch=None, batch_size=256): + model.eval() + encode = composite_sentence if composite else atomic_sentence + prompts = np.asarray([encode(r)[:-3] for r in rows], dtype=np.int64) + answers, stops, probs = [], [], [] + for start in range(0, len(rows), batch_size): + x = torch.as_tensor(prompts[start : start + batch_size], device=device) + intervention = ( + None if patch is None else dict(patch, value=patch["value"][start : start + batch_size]) + ) + logits = model(x, patch=intervention)[:, -1] + target = torch.as_tensor(rows[start : start + batch_size, -1], device=device) + probs.extend(logits.softmax(-1).gather(1, target[:, None]).squeeze(1).tolist()) + prediction = logits.argmax(-1) + answers.extend(prediction.tolist()) + x = torch.cat([x, prediction[:, None]], dim=1) + period = model(x, patch=intervention)[:, -1].argmax(-1) + x = torch.cat([x, period[:, None]], dim=1) + eos = model(x, patch=intervention)[:, -1].argmax(-1) + stops.extend(torch.stack([period, eos], dim=1).tolist()) + ans, stop, probability = np.asarray(answers), np.asarray(stops), np.asarray(probs) + correct = ans == rows[:, -1] + full = correct & (stop[:, 0] == 5) & (stop[:, 1] == EOS) + return dict( + n=len(rows), + answer_accuracy=float(correct.mean()), + accuracy=float(full.mean()), + answer_probability=float(probability.mean()), + ), dict(answer=ans, stops=stop, probability=probability, target=rows[:, -1]) + + +def run(spec, output, device): + output = Path(output) + if (output / "complete.json").exists(): + return json.loads((output / "complete.json").read_text()) + output.mkdir(parents=True, exist_ok=True) + lock = json.loads(Path(spec["source_lock"]).read_text()) + for file, expected in lock["sources"].items(): + assert sha(file) == expected, file + assert lock["config_sha256"] == sha(spec["config_path"]) + torch.set_num_threads(2) + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_per_process_memory_fraction(0.08, device) + world = build_world(spec) + cpu_table, bounds = training_table(world, spec["arm"]) + np.savez_compressed(output / "world.npz", **world) + np.savez_compressed( + output / "training-table.npz", + **{k: v for k, v in zip(("tokens", "positions", "mask", "labels"), cpu_table, strict=True)}, + ) + write_json(output / "spec.json", spec) + write_json(output / "vocabulary.json", vocabulary(spec)) + model = construct(spec, device) + opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"]) + table = tuple(torch.as_tensor(t, device=device) for t in cpu_table) + streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(3)] + latest = output / "latest.pt" + start, elapsed, histories = 0, 0.0, [] + if latest.exists(): + state = torch.load(latest, map_location=device, weights_only=False) + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + for stream, saved in zip(streams, state["streams"], strict=True): + stream.load_state_dict(saved) + start, elapsed, histories = state["step"], state["seconds"], state["histories"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + counts = spec["batch_parts"] + supervised_per_step = sum(n * tokens for n, tokens in zip(counts, [7, 9, 23], strict=True)) + step_flops = flops( + model.config, spec["repeats"], sum(counts), LENGTH - 1, output_positions=LENGTH - 1 + ) + + def checkpoint(step, seconds): + metrics, predictions = {}, {} + for split in ( + "atomic", + "background_train", + "background_test", + "target_train", + "target_test", + ): + metrics[split], preds = evaluate( + model, world[split], device, composite=split != "atomic" + ) + predictions.update({split + "_" + k: v for k, v in preds.items()}) + atomic_ok = predictions["atomic_answer"] == world["atomic"][:, -1] + knowledge = { + (int(h), int(r)): bool(ok) + for (h, r, _t), ok in zip(world["atomic"], atomic_ok, strict=True) + } + eligible = np.array( + [ + knowledge[int(h), int(r1)] and knowledge[int(b), int(r2)] + for h, r1, b, r2, _t in world["target_test"] + ] + ) + target_ok = predictions["target_test_answer"] == world["target_test"][:, -1] + metrics["target_atomic_correct"] = dict( + n=int(eligible.sum()), + coverage=float(eligible.mean()), + answer_accuracy=float(target_ok[eligible].mean()) if eligible.any() else None, + ) + record = dict( + step=step, + seconds=seconds, + supervised_tokens=step * supervised_per_step, + estimated_flops=step * step_flops, + metrics=metrics, + ) + histories.append(record) + np.savez_compressed(output / f"predictions-{step:06d}.npz", **predictions) + write_json(output / "learning.json", histories) + model.train() + state = dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + step=step, + seconds=seconds, + histories=histories, + spec=spec, + streams=[s.state_dict() for s in streams], + cpu_rng=torch.get_rng_state(), + cuda_rng=torch.cuda.get_rng_state(device), + ) + tmp = output / "latest.tmp" + torch.save(state, tmp) + tmp.replace(latest) + if step in spec["weight_nodes"]: + torch.save( + dict(model=state["model"], step=step, spec=spec), output / f"weights-{step:06d}.pt" + ) + print(json.dumps(dict(run=output.name, **record)), flush=True) + + if start == 0: + checkpoint(0, elapsed) + model.train() + graph = TextGraphStep(model, opt, table, sum(counts)) + tick = time.monotonic() + for step in range(start + 1, spec["steps"] + 1): + idx = np.concatenate( + [ + stream.take(n) + offset + for stream, n, offset in zip(streams, counts, bounds[:-1], strict=True) + ] + ) + for group in opt.param_groups: + group["lr"].fill_(spec["lr"] * min(1.0, step / spec["warmup"])) + graph(torch.as_tensor(idx, device=device)) + if step in spec["nodes"]: + torch.cuda.synchronize() + elapsed += time.monotonic() - tick + checkpoint(step, elapsed) + tick = time.monotonic() + result = dict( + status="complete", + final=histories[-1], + parameters=sum(p.numel() for p in model.parameters()), + source_lock_sha256=sha(spec["source_lock"]), + world_sha256=sha(output / "world.npz"), + peak_memory_bytes=torch.cuda.max_memory_allocated(device), + ) + write_json(output / "complete.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_structure.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_structure.py new file mode 100644 index 0000000000000000000000000000000000000000..e8c74f97848144e288267dedd2df039a1f8c1a52 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_structure.py @@ -0,0 +1,432 @@ +"""Matched relation-pair support and transfer to atomically trained facts. + +Reuse the full-token text model; change composition support, not atomics, +per-fact role counts, unique chain count, or token marginals. Target heads and +bridges are disjoint from background; answer values are deliberately shared. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch + +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import flops +from .text_pretrain import ( + LENGTH, + WORDS, + TextGraphStep, + atomic_sentence, + composite_sentence, + construct, + evaluate, + pack_documents, + sha, + vocabulary, +) + +ARMS = ("restricted", "broad", "positive") +TESTS = ("id_test", "first_only", "second_only", "background_neither", "strict_test") +SPLITS = ("atomic", "train_composite", "positive_train", *TESTS) + + +def build_world(spec): + """Balanced graph; common head-tail holdout defined before any model exists. + + Each background bridge receives four trained heads per first relation. + Two of its four second facts have composition experience. Restricted + support pairs r1[0:2] only with even r2 and r1[2:4] only with odd r2. + Broad support assigns half the incoming facts of EACH r1 to each active r2. + Thus the relation-pair support has two components versus one, while all + underlying first/second edge counts match exactly. + """ + rng = np.random.default_rng(spec["world"]) + hn, bn, tn = spec["heads_n"], spec["bridges_n"], spec["tails_n"] + if hn != 128 or bn != 32 or tn != 32: + raise ValueError("This version fixes 128 heads, 32 bridges, 32 shared answer values") + hs = np.arange(len(WORDS), len(WORDS) + hn) + bs = np.arange(hs[-1] + 1, hs[-1] + 1 + bn) + ts = np.arange(bs[-1] + 1, bs[-1] + 1 + tn) + first = [] + for heads, bridges in ((hs[:64], bs[:16]), (hs[64:96], bs[:16]), (hs[96:], bs[16:])): + mappings = [rng.permutation(np.tile(bridges, len(heads) // len(bridges))) for _ in range(4)] + first.extend((h, 13 + ri, mappings[ri][i]) for i, h in enumerate(heads) for ri in range(4)) + first = np.asarray(first, dtype=np.int64) + active, inactive = [], [] + for bi, b in enumerate(bs[:16]): + chosen = (17, 18) if bi % 2 == 0 else (19, 20) + active.extend((b, r) for r in chosen) + inactive.extend((b, r) for r in range(17, 21) if r not in chosen) + second = [] + for edges in (active, inactive, [(b, r) for b in bs[16:] for r in range(17, 21)]): + tails = rng.permutation(np.tile(ts, len(edges) // len(ts))) + second.extend((*edge, t) for edge, t in zip(edges, tails, strict=True)) + second = np.asarray(sorted(second), dtype=np.int64) + lookup = {(int(h), int(r)): int(t) for h, r, t in second} + paths = np.asarray( + [(h, r1, b, r2, lookup[int(b), r2]) for h, r1, b in first for r2 in range(17, 21)], + dtype=np.int64, + ) + trained_first = first[:256] + active_set = set(active) + broad_assignment = {} + for b in bs[:16]: + choices = sorted(r for bb, r in active if bb == b) + for r1 in range(13, 17): + incoming = rng.permutation( + trained_first[(trained_first[:, 2] == b) & (trained_first[:, 1] == r1), 0] + ) + if len(incoming) != 4: + raise ValueError("Unbalanced graph") + for i, h in enumerate(incoming): + broad_assignment[int(h), r1] = choices[i // 2] + trains = {} + for arm in ARMS[:2]: + rows = [] + for h, r1, b in trained_first: + choices = sorted(r for bb, r in active if bb == b) + r2 = ( + choices[int(r1 >= 15)] if arm == "restricted" else broad_assignment[int(h), int(r1)] + ) + rows.append((h, r1, b, r2, lookup[int(b), r2])) + trains[arm] = np.asarray(rows, dtype=np.int64) + # Two supervised paths per target person; keep the remaining head-tail + # pairs for an independent positive-control generalization evaluation. + positive = [] + for h in hs[96:]: + candidates = paths[paths[:, 0] == h] + positive.extend(candidates[rng.choice(len(candidates), 2, replace=False)]) + positive = np.asarray(positive, dtype=np.int64) + train_union = np.concatenate([trains["restricted"], trains["broad"], positive]) + pairs = {tuple(row[[0, 4]]) for row in train_union} + held = np.asarray([tuple(row[[0, 4]]) not in pairs for row in paths]) + first_seen = paths[:, 0] < hs[64] + second_seen = np.asarray([(int(b), int(r2)) in active_set for b, r2 in paths[:, [2, 3]]]) + strict = paths[:, 0] >= hs[96] + world = dict( + atomic=np.concatenate([first, second]), + atomic_first=first, + atomic_second=second, + restricted_train=trains["restricted"], + broad_train=trains["broad"], + positive_train=positive, + id_test=paths[held & first_seen & second_seen], + first_only=paths[held & first_seen & ~second_seen], + second_only=paths[held & ~first_seen & second_seen], + background_neither=paths[held & ~first_seen & ~second_seen & ~strict], + strict_test=paths[held & strict], + strict_all=paths[strict], + all_paths=paths, + background_heads=hs[:96], + background_bridges=bs[:16], + target_heads=hs[96:], + target_bridges=bs[16:], + active_second=np.asarray(active, dtype=np.int64), + ) + if any(not len(world[key]) for key in TESTS): + raise ValueError("Empty evaluation stratum; do not reroll worlds") + return world + + +def role_counts(rows): + return ( + Counter(map(tuple, rows[:, :3])), + Counter(map(tuple, rows[:, 2:])), + ) + + +def support_components(rows): + adjacency = {} + for _h, r1, _b, r2, _t in rows: + a, b = (0, int(r1)), (1, int(r2)) + adjacency.setdefault(a, set()).add(b) + adjacency.setdefault(b, set()).add(a) + remaining, components = set(adjacency), [] + while remaining: + stack, found = [min(remaining)], set() + while stack: + node = stack.pop() + if node not in found: + found.add(node) + stack.extend(adjacency[node] - found) + remaining -= found + components.append(sorted(found)) + return components + + +def data_audit(world): + a, b = world["restricted_train"], world["broad_train"] + assert len(a) == len(b) == 256 + assert len(set(map(tuple, a))) == len(set(map(tuple, b))) == 256 + assert role_counts(a) == role_counts(b) + assert Counter(t for row in a for t in composite_sentence(row)) == Counter( + t for row in b for t in composite_sentence(row) + ) + assert len(support_components(a)) == 2 and len(support_components(b)) == 1 + lookup = {(int(h), int(r)): int(t) for h, r, t in world["atomic"]} + for h, r1, bridge, r2, t in world["all_paths"]: + assert lookup[int(h), int(r1)] == bridge and lookup[int(bridge), int(r2)] == t + train_pairs = {tuple(r[[0, 4]]) for rows in (a, b, world["positive_train"]) for r in rows} + assert all(not train_pairs & {tuple(r[[0, 4]]) for r in world[s]} for s in TESTS) + assert not set(world["target_heads"]) & set( + np.concatenate([a[:, 0], a[:, 2], b[:, 0], b[:, 2]]) + ) + assert not set(world["target_bridges"]) & set(world["background_bridges"]) + assert set(world["strict_all"][:, 2]) <= set(world["target_bridges"]) + first_counts, second_counts = role_counts(a) + return dict( + status="passed", + sizes={k: len(v) for k, v in world.items()}, + unique_chains={arm: len(world[arm + "_train"]) for arm in ARMS[:2]}, + relation_pair_counts={ + arm: np.bincount( + (world[arm + "_train"][:, 1] - 13) * 4 + world[arm + "_train"][:, 3] - 17, + minlength=16, + ) + .reshape(4, 4) + .tolist() + for arm in ARMS[:2] + }, + role_counts_match=True, + token_marginals_match=True, + first_edge_usage=list(sorted(set(first_counts.values()))), + second_edge_usage=list(sorted(set(second_counts.values()))), + common_holdout_pairs=True, + isolated_target_heads_and_bridges=True, + shared_answer_values=True, + ) + + +def training_table(world, arm): + if arm not in ARMS: + raise ValueError(arm) + rows = world["restricted_train" if arm == "restricted" else "broad_train"] + if arm == "positive": + rows = np.concatenate([rows, world["positive_train"]]) + packed = [pack_documents([atomic_sentence(r)], [0]) for r in world["atomic"]] + packed.extend(pack_documents([composite_sentence(r)], [0]) for r in rows) + return ( + tuple(np.stack([row[i] for row in packed]) for i in range(4)), + [0, len(world["atomic"]), len(packed)], + rows, + ) + + +def score_predictions(predictions): + correct = predictions["answer"] == predictions["target"] + stops = predictions["stops"] + full = correct & (stops[:, 0] == 5) & (stops[:, 1] == 1) + return dict( + n=len(correct), + answer_accuracy=float(correct.mean()), + accuracy=float(full.mean()), + answer_probability=float(predictions["probability"].mean()), + ) + + +@torch.inference_mode() +def two_calls(model, rows, device): + first = rows[:, :3] + first_scores, first_pred = evaluate(model, first, device) + second = np.c_[first_pred["answer"], rows[:, 3:]] + _scores, pred = evaluate(model, second, device) + first_stops = first_pred["stops"] + format_ok = (first_stops[:, 0] == 5) & (first_stops[:, 1] == 1) + second_full = ( + (pred["answer"] == rows[:, -1]) & (pred["stops"][:, 0] == 5) & (pred["stops"][:, 1] == 1) + ) + first_ok = first_pred["answer"] == rows[:, 2] + scores = score_predictions(pred) + scores.update( + accuracy=float((format_ok & second_full).mean()), + path_accuracy=float((format_ok & first_ok & second_full).mean()), + first_accuracy=first_scores["accuracy"], + ) + pred.update( + first_answer=first_pred["answer"], + first_stops=first_stops, + first_target=rows[:, 2], + first_probability=first_pred["probability"], + ) + return scores, pred + + +def evaluate_all(model, world, train_rows, device): + metrics, predictions = {}, {} + groups = dict(world, train_composite=train_rows) + for split in SPLITS: + scores, pred = evaluate(model, groups[split], device, composite=split != "atomic") + metrics[split] = scores + predictions.update({split + "_" + k: v for k, v in pred.items()}) + atomic_ok = predictions["atomic_answer"] == world["atomic"][:, -1] + knowledge = { + (int(h), int(r)): bool(ok) + for (h, r, _t), ok in zip(world["atomic"], atomic_ok, strict=True) + } + for split in TESTS: + rows = world[split] + eligible = np.asarray( + [knowledge[int(h), int(r1)] and knowledge[int(b), int(r2)] for h, r1, b, r2, _t in rows] + ) + predictions[split + "_eligible"] = eligible + conditional = { + k: predictions[split + "_" + k][eligible] + for k in ("answer", "target", "stops", "probability") + } + metrics[split + "_conditional"] = dict( + n=int(eligible.sum()), coverage=float(eligible.mean()) + ) + if eligible.any(): + metrics[split + "_conditional"].update(score_predictions(conditional)) + else: + metrics[split + "_conditional"].update( + answer_accuracy=None, accuracy=None, answer_probability=None + ) + scores, pred = two_calls(model, rows, device) + metrics[split + "_two_calls"] = scores + predictions.update({split + "_two_calls_" + k: v for k, v in pred.items()}) + return metrics, predictions + + +def verify_lock(config, source_lock): + lock = json.loads(Path(source_lock).read_text()) + assert lock["config_sha256"] == sha(config), config + for file, expected in lock["sources"].items(): + assert sha(file) == expected, file + return lock + + +def run(spec, output, device): + output = Path(output) + verify_lock(spec["config_path"], spec["source_lock"]) + if (output / "complete.json").exists(): + return json.loads((output / "complete.json").read_text()) + output.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(2) + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_per_process_memory_fraction(0.06, device) + world = build_world(spec) + write_json(output / "data-audit.json", data_audit(world)) + cpu_table, bounds, train_rows = training_table(world, spec["arm"]) + np.savez_compressed(output / "world.npz", **world, train_composite=train_rows) + np.savez_compressed( + output / "training-table.npz", + **{k: v for k, v in zip(("tokens", "positions", "mask", "labels"), cpu_table, strict=True)}, + ) + write_json(output / "spec.json", spec) + write_json(output / "vocabulary.json", vocabulary(spec)) + model = construct(spec, device) + initial_hash = { + key: hashlib.sha256(value.detach().cpu().numpy().tobytes()).hexdigest() + for key, value in model.state_dict().items() + } + write_json(output / "initialization-hashes.json", initial_hash) + opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"]) + table = tuple(torch.as_tensor(t, device=device) for t in cpu_table) + streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(2)] + latest = output / "latest.pt" + start, elapsed, histories = 0, 0.0, [] + if latest.exists(): + state = torch.load(latest, map_location=device, weights_only=False) + assert state["spec"] == spec + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + for stream, saved in zip(streams, state["streams"], strict=True): + stream.load_state_dict(saved) + start, elapsed, histories = state["step"], state["seconds"], state["histories"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + counts = spec["batch_parts"] + supervised_per_step = sum(n * tokens for n, tokens in zip(counts, [7, 9], strict=True)) + step_flops = flops( + model.config, spec["repeats"], sum(counts), LENGTH - 1, output_positions=LENGTH - 1 + ) + started = utc() + + def checkpoint(step, seconds): + metrics, predictions = evaluate_all(model, world, train_rows, device) + record = dict( + step=step, + seconds=seconds, + supervised_tokens=step * supervised_per_step, + estimated_flops=step * step_flops, + metrics=metrics, + ) + histories.append(record) + np.savez_compressed(output / f"predictions-{step:06d}.npz", **predictions) + write_json(output / "learning.json", histories) + model.train() + state = dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + step=step, + seconds=seconds, + histories=histories, + spec=spec, + streams=[s.state_dict() for s in streams], + cpu_rng=torch.get_rng_state(), + cuda_rng=torch.cuda.get_rng_state(device), + ) + tmp = output / "latest.tmp" + torch.save(state, tmp) + tmp.replace(latest) + if step in spec["weight_nodes"]: + torch.save( + dict(model=state["model"], step=step, spec=spec), output / f"weights-{step:06d}.pt" + ) + print( + json.dumps( + dict( + run=output.name, + step=step, + seconds=seconds, + metrics={k: metrics[k] for k in ("atomic", "train_composite", *TESTS)}, + ) + ), + flush=True, + ) + + if start == 0: + checkpoint(0, elapsed) + model.train() + before = {k: v.detach().clone() for k, v in model.state_dict().items()} + graph = TextGraphStep(model, opt, table, sum(counts)) + assert all(torch.equal(before[k], v) for k, v in model.state_dict().items()) + tick = time.monotonic() + for step in range(start + 1, spec["steps"] + 1): + idx = np.concatenate( + [ + stream.take(n) + offset + for stream, n, offset in zip(streams, counts, bounds[:-1], strict=True) + ] + ) + for group in opt.param_groups: + group["lr"].fill_(spec["lr"] * min(1.0, step / spec["warmup"])) + graph(torch.as_tensor(idx, device=device)) + if step in spec["nodes"]: + torch.cuda.synchronize() + elapsed += time.monotonic() - tick + checkpoint(step, elapsed) + tick = time.monotonic() + result = dict( + status="complete", + started_utc=started, + finished_utc=utc(), + final=histories[-1], + parameters=sum(p.numel() for p in model.parameters()), + source_lock_sha256=sha(spec["source_lock"]), + world_sha256=sha(output / "world.npz"), + peak_memory_bytes=torch.cuda.max_memory_allocated(device), + gpu=torch.cuda.get_device_name(device), + torch_version=torch.__version__, + ) + write_json(output / "complete.json", result) + return result diff --git a/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/twohop_depth.py b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/twohop_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..19b9a4b76eadef68acf7603b8434567145244311 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/twohop_depth.py @@ -0,0 +1,362 @@ +"""Depth, held-out composition, and bridge interventions in random fact worlds. + +Entity IDs and relation IDs are disjoint. A relation is a random permutation; +this makes every atom and each split's answer marginal exactly balanced. +""" + +from __future__ import annotations + +import contextlib +import hashlib +import json +import os +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from llm_memory_editability.bios_model import CausalLM, ModelConfig + +ROOT = Path(os.environ.get("TWOHOP_PROJECT_ROOT", Path(__file__).resolve().parents[2])) +CONFIG = ROOT / "configs/twohop-depth-v1.json" +DATA = ROOT / "data/twohop-depth-v1" +RESULTS = ROOT / "results/twohop-depth-v1" +ART = ROOT / "docs/development-artifacts/twohop-depth-v1" +BOS, EOS, ENTITY = 1, 2, 3 + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temp = path.with_suffix(path.suffix + ".tmp") + temp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n") + temp.replace(path) + + +def digest(path): + h = hashlib.sha256() + with Path(path).open("rb") as f: + for block in iter(lambda: f.read(1024 * 1024), b""): + h.update(block) + return h.hexdigest() + + +def world_arrays(seed, cfg): + n, r = cfg["entities"], cfg["relations"] + if r % 2 or r < 2: + raise ValueError("An even relation count is required for balanced coverage") + rng = np.random.default_rng(seed) + maps = np.stack([rng.permutation(n) for _ in range(r)]) + # For each bridge, a regular bipartite graph over first/second relations. + # Each atom occurs in r/2 training compositions in EACH hop role. + orders = np.stack([rng.permutation(r) for _ in range(n)]) + mask = np.zeros((n, r, r), dtype=bool) + for a in range(n): + for r1 in range(r): + b = maps[r1, a] + mask[a, r1, orders[b, (r1 + np.arange(r // 2)) % r]] = True + atoms = np.array([(a, rel) for a in range(n) for rel in range(r)], dtype=np.int64) + comps = np.array( + [(a, r1, r2) for a in range(n) for r1 in range(r) for r2 in range(r)], + dtype=np.int64, + ) + a, r1, r2 = comps.T + bridge = maps[r1, a] + answer = maps[r2, bridge] + selected = rng.choice(np.flatnonzero(~mask.ravel()), cfg["diagnostic_cases"], replace=False) + cases = [] + inverse = np.argsort(maps, axis=1) + for index in selected: + a0, r10, r20 = comps[index] + b0, c0 = bridge[index], answer[index] + # Donor contains only a first-hop prefix; neither its explicit entity nor + # its first-hop answer is the counterfactual final answer. + candidates = [] + for b1 in range(n): + a1, c1 = inverse[r10, b1], maps[r20, b1] + if b1 != b0 and c1 not in {a1, b1, a0, b0, c0}: + candidates.append((int(a1), int(b1), int(c1))) + if not candidates: + raise ValueError("No answer-free bridge donor; increase world size") + a1, b1, c1 = candidates[int(rng.integers(len(candidates)))] + same_r = (r10 + 1) % r + same_a = inverse[same_r, b0] + wrong_candidates = [ + (rr, int(maps[rr, b1])) for rr in range(r) if rr != r20 and maps[rr, b1] not in {c0, c1} + ] + if not wrong_candidates: + raise ValueError("No distinct wrong-relation answer") + wrong_r, wrong_y = wrong_candidates[int(rng.integers(len(wrong_candidates)))] + cases.append([index, a0, r10, r20, b0, c0, a1, b1, c1, same_a, same_r, wrong_r, wrong_y]) + ax = np.c_[np.full(len(atoms), BOS), ENTITY + atoms[:, 0], ENTITY + n + atoms[:, 1]] + cx = np.c_[np.full(len(comps), BOS), ENTITY + a, ENTITY + n + r1, ENTITY + n + r2] + return { + "maps": maps, + "atoms": atoms, + "comps": comps, + "train_mask": mask.ravel(), + "atomic_x": ax, + "atomic_y": ENTITY + maps[atoms[:, 1], atoms[:, 0]], + "composite_x": cx, + "composite_y": ENTITY + answer, + "bridge": ENTITY + bridge, + "cases": np.asarray(cases, dtype=np.int64), + } + + +def audit_world(w, cfg): + n, r = cfg["entities"], cfg["relations"] + maps, comps = w["maps"], w["comps"] + assert all(np.array_equal(np.sort(row), np.arange(n)) for row in maps) + assert len(set(map(tuple, w["atomic_x"]))) == n * r + assert len(set(map(tuple, w["composite_x"]))) == n * r * r + for mask in (w["train_mask"], ~w["train_mask"]): + a, r1, r2 = comps[mask].T + b = maps[r1, a] + assert np.all(np.bincount(a * r + r1, minlength=n * r) == r // 2) + assert np.all(np.bincount(b * r + r2, minlength=n * r) == r // 2) + assert np.all(np.bincount(w["composite_y"][mask] - ENTITY, minlength=n) == r * r // 2) + assert np.all(~w["train_mask"][w["cases"][:, 0]]) + for _, a, r1, r2, b, c, da, db, dc, sa, sr, wr, wy in w["cases"]: + assert maps[r1, a] == b and maps[r2, b] == c + assert maps[r1, da] == db and maps[r2, db] == dc + assert maps[sr, sa] == b and sr != r1 + assert dc not in {da, db, a, b, c} + assert maps[wr, db] == wy and wr != r2 and wy not in {c, dc} + return { + "atoms": n * r, + "train_compositions": int(w["train_mask"].sum()), + "test_compositions": int((~w["train_mask"]).sum()), + "diagnostic_cases": len(w["cases"]), + "every_atom_train_composition_occurrences_per_hop": r // 2, + "balanced_answers": True, + "answer_free_donors": True, + } + + +def stream_indices(length, count, rng): + return np.concatenate([rng.permutation(length) for _ in range((count + length - 1) // length)])[ + :count + ] + + +def make_stream(w, seed, cfg): + rng = np.random.default_rng(seed) + count = cfg["steps"] * cfg["batch_per_kind"] + return { + "atomic": stream_indices(len(w["atomic_x"]), count, rng), + "composite": stream_indices(int(w["train_mask"].sum()), count, rng), + } + + +def build_model(arch, cfg): + return CausalLM( + ModelConfig( + vocab_size=ENTITY + cfg["entities"] + cfg["relations"], + layers=arch["layers"], + width=arch["width"], + heads=arch["heads"], + context=8, + ) + ) + + +def amp(device): + return ( + torch.autocast("cuda", dtype=torch.bfloat16) + if str(device).startswith("cuda") + else contextlib.nullcontext() + ) + + +def training_tensors(w, device): + result = {} + for name, mask in (("atomic", slice(None)), ("composite", w["train_mask"])): + x, y = w[name + "_x"][mask], w[name + "_y"][mask] + full = np.zeros((len(x), 6), dtype=np.int64) + full[:, : x.shape[1]] = x + full[:, x.shape[1]] = y + full[:, x.shape[1] + 1] = EOS + pos = np.tile([x.shape[1] - 1, x.shape[1]], (len(x), 1)) + labels = np.c_[y, np.full(len(x), EOS)] + result[name] = tuple(torch.as_tensor(v, device=device) for v in (full, pos, labels)) + return result + + +def optimizer_for(model, cfg, device): + decay, no_decay = [], [] + for p in model.parameters(): + (decay if p.ndim >= 2 else no_decay).append(p) + return torch.optim.AdamW( + [ + {"params": decay, "weight_decay": cfg["weight_decay"]}, + {"params": no_decay, "weight_decay": 0}, + ], + lr=cfg["lr"], + betas=(0.9, 0.999), + eps=1e-8, + fused=str(device).startswith("cuda"), + ) + + +def train_step(model, optimizer, tensors, indices, step, cfg, device): + parts = [tuple(v[indices[k]] for v in tensors[k]) for k in ("atomic", "composite")] + x, pos, labels = (torch.cat([p[j] for p in parts]) for j in range(3)) + lr = cfg["lr"] * min(1.0, (step + 1) / cfg["warmup"]) + for group in optimizer.param_groups: + group["lr"] = lr + optimizer.zero_grad(set_to_none=True) + with amp(device): + logits = model(x, positions=pos) + losses = F.cross_entropy(logits.float().flatten(0, 1), labels.flatten(), reduction="none") + loss = losses.mean() + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"]) + optimizer.step() + return loss.detach(), norm.detach() + + +@torch.no_grad() +def predict(model, x, y, device, batch=512): + pred, eos, prob = [], [], [] + for start in range(0, len(x), batch): + q = torch.as_tensor(x[start : start + batch], device=device) + target = torch.as_tensor(y[start : start + batch], device=device) + with amp(device): + logits = model(q)[:, -1].float() + answer = logits.argmax(-1) + stop = model(torch.cat([q, answer[:, None]], dim=1))[:, -1].argmax(-1) + pred.extend(answer.cpu().tolist()) + eos.extend(stop.cpu().tolist()) + prob.extend(logits.log_softmax(-1).gather(1, target[:, None]).squeeze(1).cpu().tolist()) + return np.asarray(pred), np.asarray(eos), np.asarray(prob) + + +@torch.no_grad() +def evaluate(model, w, cfg, device): + arrays, metrics = {}, {} + for name, key, mask in ( + ("atomic", "atomic", slice(None)), + ("train", "composite", w["train_mask"]), + ("test", "composite", ~w["train_mask"]), + ): + x, y = w[key + "_x"][mask], w[key + "_y"][mask] + pred, eos, logp = predict(model, x, y, device, cfg["eval_batch"]) + arrays.update({name + "_pred": pred, name + "_eos": eos, name + "_logp": logp}) + metrics.update( + { + name + "_answer": float(np.mean(pred == y)), + name + "_exact": float(np.mean((pred == y) & (eos == EOS))), + name + "_nll": float(-logp.mean()), + } + ) + # Autonomous two-call baseline uses its own generated bridge, never the oracle. + test_ids = np.flatnonzero(~w["train_mask"]) + a, r1, r2 = w["comps"][test_ids].T + bridge_pred = arrays["atomic_pred"][a * cfg["relations"] + r1] + bridge_eos = arrays["atomic_eos"][a * cfg["relations"] + r1] + second_x = np.c_[np.full(len(a), BOS), bridge_pred, ENTITY + cfg["entities"] + r2] + y = w["composite_y"][test_ids] + pred, eos, logp = predict(model, second_x, y, device, cfg["eval_batch"]) + arrays.update( + two_call_pred=pred, two_call_eos=eos, two_call_logp=logp, two_call_bridge=bridge_pred + ) + two_exact = (pred == y) & (eos == EOS) & (bridge_eos == EOS) + metrics["two_call_exact"] = float(two_exact.mean()) + atom_ok = (arrays["atomic_pred"] == w["atomic_y"]) & (arrays["atomic_eos"] == EOS) + b = w["maps"][r1, a] + both = atom_ok[a * cfg["relations"] + r1] & atom_ok[b * cfg["relations"] + r2] + arrays["test_both_atoms_correct"] = both + exact = (arrays["test_pred"] == y) & (arrays["test_eos"] == EOS) + metrics["test_both_atoms_n"] = int(both.sum()) + metrics["test_given_both_atoms"] = float(exact[both].mean()) if both.any() else None + return metrics, arrays + + +@torch.no_grad() +def states_and_logits(model, tokens, device): + # Mirrors bios_model.CausalLM.forward; contract-tested against ordinary forward. + with amp(device): + h = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=device)) + states = [h.clone()] + for block in model.blocks: + h = block(h) + states.append(h.clone()) + logits = F.linear(model.ln_final(h), model.token.weight) + return states, logits.float() + + +@torch.no_grad() +def patched_logits(model, tokens, layer, positions, replacement, device): + with amp(device): + h = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=device)) + if layer == 0: + h[:, positions] = replacement.to(h.dtype) + for number, block in enumerate(model.blocks, 1): + h = block(h) + if number == layer: + h[:, positions] = replacement.to(h.dtype) + return F.linear(model.ln_final(h), model.token.weight)[:, -1].float() + + +@torch.no_grad() +def diagnostics(model, w, cfg, device): + cases = w["cases"] + q = torch.as_tensor(w["composite_x"][cases[:, 0]], device=device) + dx = np.c_[ + np.full(len(cases), BOS), ENTITY + cases[:, 6], ENTITY + cfg["entities"] + cases[:, 2] + ] + sx = np.c_[ + np.full(len(cases), BOS), ENTITY + cases[:, 9], ENTITY + cfg["entities"] + cases[:, 10] + ] + clean, logits = states_and_logits(model, q, device) + donor, _ = states_and_logits(model, torch.as_tensor(dx, device=device), device) + same, _ = states_and_logits(model, torch.as_tensor(sx, device=device), device) + old = torch.as_tensor(ENTITY + cases[:, 5], device=device) + new = torch.as_tensor(ENTITY + cases[:, 8], device=device) + wrong = torch.as_tensor(ENTITY + cases[:, 12], device=device) + row = torch.arange(len(q), device=device) + baseline = logits[:, -1] + out = { + "case_ids": cases[:, 0], + "clean_pred": baseline.argmax(-1).cpu().numpy(), + "clean_margin": (baseline[row, new] - baseline[row, old]).cpu().numpy(), + "old_y": old.cpu().numpy(), + "new_y": new.cpu().numpy(), + "wrong_y": wrong.cpu().numpy(), + } + # Fixed random orthogonal coordinate permutation preserves perturbation norm. + rng = np.random.default_rng(142899) + perm = torch.as_tensor(rng.permutation(model.config.width), device=device) + signs = torch.as_tensor(rng.choice([-1, 1], model.config.width), device=device) + for layer in range(len(clean)): + with amp(device): + lens = F.linear(model.ln_final(clean[layer]), model.token.weight).float() + out[f"lens_bridge_pos2_{layer}"] = lens[:, 2].argmax(-1).cpu().numpy() + out[f"lens_query_pos3_{layer}"] = lens[:, 3].argmax(-1).cpu().numpy() + delta = donor[layer][:, 2] - clean[layer][:, 2] + random_state = clean[layer][:, 2] + delta[:, perm] * signs + conditions = { + "bridge": ([2], donor[layer][:, [2]]), + "same_bridge": ([2], same[layer][:, [2]]), + "random": ([2], random_state[:, None]), + "source": ([1], donor[layer][:, [1]]), + "prefix": ([1, 2], donor[layer][:, [1, 2]]), + "identity": ([2], clean[layer][:, [2]]), + } + for name, (positions, replacement) in conditions.items(): + z = patched_logits(model, q, layer, positions, replacement, device) + prefix = f"{name}_{layer}" + out[prefix + "_pred"] = z.argmax(-1).cpu().numpy() + out[prefix + "_margin"] = (z[row, new] - z[row, old]).cpu().numpy() + out[prefix + "_max_delta"] = (z - baseline).abs().max(-1).values.cpu().numpy() + return out + + +def run_name(world, seed, architecture): + return f"w{world}-s{seed}-{architecture}" diff --git a/docs/development-artifacts/composition-data-curves-v1/source/tests/test_composition_curves.py b/docs/development-artifacts/composition-data-curves-v1/source/tests/test_composition_curves.py new file mode 100644 index 0000000000000000000000000000000000000000..bb9241b1bbdbfa896044a1b2cadc4b14686f34c6 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/source/tests/test_composition_curves.py @@ -0,0 +1,208 @@ +"""Conclusion-changing contracts for the data-size and knowledge-load comparisons.""" + +import copy +import importlib.util +import json +import math +from pathlib import Path + +import numpy as np +import pytest + +from llm_memory_editability.composition_curves import ( + anchors_pass, + budget_nodes, + calibrated_choice, + confirmation_specs, + construct, + load_specs, + prepare_world, +) +from llm_memory_editability.grok_depth import EpochStream + +ROOT = Path(__file__).resolve().parents[1] + + +def spec(phi=1, entities=16): + return { + "world_seed": 311, + "entities": entities, + "max_entities": 32, + "relations": 8, + "degree": 4, + "phi": phi, + "id_fraction": 0.75, + "test_fraction": 0.1, + "evaluation_size": 128, + "batch_size": 16, + "target_exposures": 17, + "compute_steps": 64, + "width": 16, + "layers": 2, + "heads": 2, + "dropout": 0.1, + "initialization": 981, + } + + +def test_distinct_supports_are_nested_and_never_change_world_or_test_panels(): + previous = set() + identity = None + reference = None + for phi in (0, 0.5, 1, 2): + arrays, panels, meta = prepare_world(spec(phi)) + current = {tuple(row[:-1]) for row in arrays["train_composite"]} + assert previous <= current + assert len(current) == meta["composition_examples"] + assert not current & {tuple(row[:-1]) for row in arrays["test_composite"]} + if identity is None: + identity, reference = meta["world_sha256"], panels + assert meta["world_sha256"] == identity + for key in ("atomic", "II", "OO"): + np.testing.assert_array_equal(panels[key], reference[key]) + previous = current + + +def test_truth_and_ood_roles_survive_fixed_vocabulary_remapping(): + arrays, _, meta = prepare_world(spec(2)) + atomic = {tuple(row[:2]): int(row[2]) for row in arrays["atomic"]} + ood = {tuple(row[:2]) for row in arrays["ood_atomic"]} + for head, r1, r2, answer in arrays["train_composite"]: + bridge = atomic[head, r1] + assert atomic[bridge, r2] == answer + assert (head, r1) not in ood and (bridge, r2) not in ood + for head, r1, r2, answer in arrays["ood_composite"]: + bridge = atomic[head, r1] + assert atomic[bridge, r2] == answer + assert (head, r1) in ood and (bridge, r2) in ood + assert meta["role_coverage"]["ood_composite"]["both_facts_seen_in_required_roles"] in (0, None) + assert arrays["atomic"][:, 1].min() >= spec()["max_entities"] + 2 + + +def test_same_model_parameters_and_initial_weights_at_every_load(): + import torch + + small, cfg = construct(spec(1, 8), "cpu") + large, large_cfg = construct(spec(1, 32), "cpu") + assert cfg == large_cfg + for key, value in small.state_dict().items(): + assert torch.equal(value, large.state_dict()[key]) + for n in (8, 16, 32): + arrays, _, meta = prepare_world(spec(1, n)) + assert meta["knowledge_bits"] == len(arrays["atomic"]) * math.log2(n) + assert meta["composition_additional_independent_bits"] == 0 + + +def test_requests_never_cap_or_silently_repeat_distinct_compositions(): + with pytest.raises(ValueError, match="exceeds"): + prepare_world(spec(100)) + with pytest.raises(ValueError, match="vocabulary"): + prepare_world(spec(1, 33)) + + +def test_world_creation_does_not_touch_global_numpy_rng(): + np.random.seed(775) + expected = np.random.random(8) + np.random.seed(775) + prepare_world(spec()) + np.testing.assert_array_equal(np.random.random(8), expected) + + +def test_matched_exposure_budget_gives_every_record_the_declared_exposure(): + item = spec() + total = 39 + nodes, budgets = budget_nodes(item, total) + assert budgets["exposure"] == math.ceil(17 * total / 16) + assert budgets["exposure"] in nodes and budgets["compute"] in nodes + stream = EpochStream(total, 763) + seen = np.bincount(stream.take(budgets["exposure"] * 16), minlength=total) + assert seen.min() == 17 and seen.max() == 18 + resumed = EpochStream(total, 1) + resumed.load_state_dict(copy.deepcopy(stream.state_dict())) + np.testing.assert_array_equal(stream.take(120), resumed.take(120)) + + +def test_fixed_development_budget_does_not_pretend_to_reach_exposure_endpoint(): + item = {**spec(), "fixed_steps": 64} + nodes, budgets = budget_nodes(item, 1000) + assert budgets["end"] == 64 + assert nodes[-1] == 64 + assert budgets["exposure"] not in nodes + + +def metrics(atomic=1, train=1, test=0.9): + return { + "atomic": {"accuracy": atomic}, + "train_composition": {"accuracy": train}, + "II": {"accuracy": test}, + } + + +def test_development_gate_does_not_reward_best_training_fit_without_generalization(): + thresholds = {"atomic": 0.95, "train_composition": 0.95, "II": 0.8} + two, four = {"layers": 2}, {"layers": 4} + assert calibrated_choice([(two, metrics(test=0.02)), (four, metrics())], thresholds) == four + assert calibrated_choice([(four, metrics()), (two, metrics())], thresholds) == two + assert calibrated_choice([(two, metrics(atomic=0.94))], thresholds) is None + + +def test_load_gate_requires_all_distinct_registered_worlds(): + thresholds = {"atomic": 0.95, "train_composition": 0.95, "II": 0.8} + rows = [({"world_seed": n}, metrics()) for n in (1, 2, 3)] + assert anchors_pass(rows, [1, 2, 3], thresholds) + assert not anchors_pass(rows[:2], [1, 2, 3], thresholds) + assert not anchors_pass([rows[0], rows[0], rows[2]], [1, 2, 3], thresholds) + rows[1] = ({"world_seed": 2}, metrics(test=0.79)) + assert not anchors_pass(rows, [1, 2, 3], thresholds) + + +def test_complete_registered_matrix_reuses_low_load_without_duplicate_training(): + config = json.loads((ROOT / "configs/composition-data-curves-v1.json").read_text()) + selected = {**config["base_spec"], "layers": 2} + support = confirmation_specs(config, selected) + load = load_specs(config, selected) + assert len(support) == 21 and len(load) == 15 + assert len({row["name"] for row in support + load}) == 36 + for world in config["confirmation_worlds"]: + assert {row["phi"] for row in support if row["world_seed"] == world} == set( + config["support_phi"] + ) + anchors = [ + row + for row in support + if row["world_seed"] == world and row["phi"] == config["anchor_phi"] + ] + assert len(anchors) == 1 and anchors[0]["entities"] == 128 + assert all(row["entities"] != 128 for row in load) + assert all(row["phase"] == "confirmation" for row in support + load) + assert config["development_world"] not in config["confirmation_worlds"] + + +def load_executor(): + module_spec = importlib.util.spec_from_file_location( + "curve_executor", ROOT / "scripts/execute_composition_curves.py" + ) + module = importlib.util.module_from_spec(module_spec) + module_spec.loader.exec_module(module) + return module + + +def test_container_isolation_uses_real_repository_and_frozen_source(tmp_path): + executor = load_executor() + config = { + "batch": "example", + "repository": "/repo", + "source_root": "/repo/frozen/source", + "runtime": {"image": "sha256:fixed", "python": "/python", "cpus": 2, "memory": "12g"}, + } + name, command = executor.container_command( + config, Path("/repo/frozen/support-config.json"), {"name": "phi1"}, tmp_path, 1, 1 + ) + assert command[:4] == ["docker", "--context", "lm-memory", "run"] + assert "type=bind,src=/repo,dst=/repo,readonly" in command + assert "PYTHONPATH=/repo/frozen/source/src" in command + assert "device=1" in command and "--read-only" in command and "--network=none" in command + other, _ = executor.container_command( + config, Path("/repo/frozen/support-config.json"), {"name": "phi1"}, tmp_path, 1, 2 + ) + assert name != other diff --git a/docs/development-artifacts/composition-data-curves-v1/support-config.json b/docs/development-artifacts/composition-data-curves-v1/support-config.json new file mode 100644 index 0000000000000000000000000000000000000000..6504268dcf960f70f29a74fd8fb517cc92069d38 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/support-config.json @@ -0,0 +1,780 @@ +{ + "batch": "composition-data-curves-v1", + "results_root": "/ossfs/workspace/llm-memory-editability/results/composition-data-curves-v1", + "gpus": [ + 0, + 1 + ], + "preflight": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/cuda.json", + "runtime": { + "docker_context": "lm-memory", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "python": "/opt/conda/bin/python", + "cpus": 2, + "memory": "12g" + }, + "base_spec": { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200 + }, + "development_world": 961006101, + "confirmation_worlds": [ + 961006111, + 961006112, + 961006113 + ], + "initialization": 961006121, + "stream_seed": 961006131, + "calibration_layers": [ + 2, + 4 + ], + "calibration_steps": [ + 128000, + 512000 + ], + "calibration_thresholds": { + "atomic": 0.95, + "train_composition": 0.95, + "II": 0.8 + }, + "selection_rule": "development world only; prefer 2 layers if its fixed endpoint passes, otherwise 4; one predeclared common budget extension if neither passes", + "anchor_phi": 7.2, + "support_phi": [ + 0, + 0.5, + 1, + 2, + 4, + 7.2, + 12.6 + ], + "load_entities": [ + 128, + 256, + 512, + 1024, + 2048, + 4096 + ], + "load_gate": { + "atomic": 0.95, + "train_composition": 0.95, + "II": 0.8 + }, + "tracking": { + "enabled": true, + "entity": "zhusq20", + "project": "llm-memory-editability", + "mode": "online" + }, + "budget": { + "maximum_training_runs": 40, + "maximum_gpu_hours": 64, + "per_run_wall_seconds": 43200, + "extension_target_exposures": 8000, + "automatic_new_learning_rates": false, + "automatic_new_architectures": false + }, + "interpretation": { + "primary_level": "controlled synthetic behavior; no universal capacity law or internal MLP attribution", + "knowledge_entropy": "F log2(N), conditional on relation keys; composition support adds zero independent bits", + "load_graphs": "closed random graphs at each N, same registered world-family seeds but different facts; not a nested-fact intervention", + "world_weighting": "three independent world families, one initialization each; do not pool queries as independent worlds", + "budgets": "128000 updates gives identical executed-shape FLOPs; matched average record exposures is a separate comparison" + }, + "repository": "/ossfs/workspace/llm-memory-editability", + "source_root": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/composition_curves.py": "520c4503f3d1525612432dd2c0b9fbf56d2e39ee5d6dff9f1484f19a7bfae8ec", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/curve_tracking.py": "50cc8a1d652c44ef14d42b4a44cc800fb15e2ed72f4b83c4848870d76ab56fec", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/scripts/run_composition_curves.py": "f01b63f3e80427ffe37c730f81e3cc1ca854735807554d5a6cbd812416d00b3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/scripts/execute_composition_curves.py": "ba220f8f570c62a9677694de9bdf9b3f4b4dda9be5579242bb093d9d783d939d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/scripts/report_composition_curves.py": "89320834c058bd57b3307e95d6024a5025cdb45931020cbeac7cf7e9d32cbf05", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/tests/test_composition_curves.py": "3620a14156b8e40682da1309444be1e646ce10639b2691f6c99deb33e74b2674", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/configs/composition-data-curves-v1.json": "ea6b69279d78372490bb25f4bc46fda1325673a500ce070137b055acb7d75722", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/composition-data-curves-v1/source/docs/development-artifacts/composition-data-curves-v1/protocol.md": "22d9eabc0facbcc40cf9fc2dbb4b07bac3d0351caf91e10aa9625bcbe3ef45ee" + }, + "preflight_sha256": "599a85f6e3cd81a6105ae9168d3f4a387093fe68cd53c94697a88477e7d6f28f", + "frozen_utc": "2026-10-06T01:03:49.716017+00:00", + "git_commit": "b7b1741e5c840b68612c4eeb4fb2248ad5f2be61", + "runs": [ + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006111, + "initialization": 961006121, + "stream_seed": 961006131, + "phi": 0, + "phase": "confirmation", + "name": "support-w1-phi0" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006111, + "initialization": 961006121, + "stream_seed": 961006131, + "phi": 0.5, + "phase": "confirmation", + "name": "support-w1-phi0.5" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006111, + "initialization": 961006121, + "stream_seed": 961006131, + "phi": 1, + "phase": "confirmation", + "name": "support-w1-phi1" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006111, + "initialization": 961006121, + "stream_seed": 961006131, + "phi": 2, + "phase": "confirmation", + "name": "support-w1-phi2" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006111, + "initialization": 961006121, + "stream_seed": 961006131, + "phi": 4, + "phase": "confirmation", + "name": "support-w1-phi4" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006111, + "initialization": 961006121, + "stream_seed": 961006131, + "phi": 7.2, + "phase": "confirmation", + "name": "support-w1-phi7.2" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006111, + "initialization": 961006121, + "stream_seed": 961006131, + "phi": 12.6, + "phase": "confirmation", + "name": "support-w1-phi12.6" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006112, + "initialization": 961006122, + "stream_seed": 961006132, + "phi": 0, + "phase": "confirmation", + "name": "support-w2-phi0" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006112, + "initialization": 961006122, + "stream_seed": 961006132, + "phi": 0.5, + "phase": "confirmation", + "name": "support-w2-phi0.5" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006112, + "initialization": 961006122, + "stream_seed": 961006132, + "phi": 1, + "phase": "confirmation", + "name": "support-w2-phi1" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006112, + "initialization": 961006122, + "stream_seed": 961006132, + "phi": 2, + "phase": "confirmation", + "name": "support-w2-phi2" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006112, + "initialization": 961006122, + "stream_seed": 961006132, + "phi": 4, + "phase": "confirmation", + "name": "support-w2-phi4" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006112, + "initialization": 961006122, + "stream_seed": 961006132, + "phi": 7.2, + "phase": "confirmation", + "name": "support-w2-phi7.2" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006112, + "initialization": 961006122, + "stream_seed": 961006132, + "phi": 12.6, + "phase": "confirmation", + "name": "support-w2-phi12.6" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006113, + "initialization": 961006123, + "stream_seed": 961006133, + "phi": 0, + "phase": "confirmation", + "name": "support-w3-phi0" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006113, + "initialization": 961006123, + "stream_seed": 961006133, + "phi": 0.5, + "phase": "confirmation", + "name": "support-w3-phi0.5" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006113, + "initialization": 961006123, + "stream_seed": 961006133, + "phi": 1, + "phase": "confirmation", + "name": "support-w3-phi1" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006113, + "initialization": 961006123, + "stream_seed": 961006133, + "phi": 2, + "phase": "confirmation", + "name": "support-w3-phi2" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006113, + "initialization": 961006123, + "stream_seed": 961006133, + "phi": 4, + "phase": "confirmation", + "name": "support-w3-phi4" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006113, + "initialization": 961006123, + "stream_seed": 961006133, + "phi": 7.2, + "phase": "confirmation", + "name": "support-w3-phi7.2" + }, + { + "entities": 128, + "max_entities": 4096, + "relations": 32, + "degree": 16, + "id_fraction": 0.95, + "test_fraction": 0.1, + "width": 64, + "heads": 4, + "dropout": 0.1, + "lr": 0.0001, + "weight_decay": 0.1, + "warmup": 2000, + "batch_size": 256, + "evaluation_size": 2048, + "compute_steps": 128000, + "target_exposures": 4000, + "max_wall_seconds": 43200, + "layers": 4, + "world_seed": 961006113, + "initialization": 961006123, + "stream_seed": 961006133, + "phi": 12.6, + "phase": "confirmation", + "name": "support-w3-phi12.6" + } + ], + "phase": "support" +} diff --git a/docs/development-artifacts/composition-data-curves-v1/support-execution-lock.json b/docs/development-artifacts/composition-data-curves-v1/support-execution-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..b8d272f961c78e06c127abac962debd9ed8c5794 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/support-execution-lock.json @@ -0,0 +1,4 @@ +{ + "config_sha256": "630012f8b6c6d1a1032b3b66fb078777c3b032dd75c9db87eb315a7c9ba484b4", + "utc": "2026-10-06T01:07:16.671477+00:00" +} diff --git a/docs/development-artifacts/composition-data-curves-v1/verification.json b/docs/development-artifacts/composition-data-curves-v1/verification.json new file mode 100644 index 0000000000000000000000000000000000000000..bb8179eb47290856aec5c1802251906090a1bfa7 --- /dev/null +++ b/docs/development-artifacts/composition-data-curves-v1/verification.json @@ -0,0 +1,18 @@ +{ + "passed": true, + "utc": "2026-10-06T01:05:47.805911+00:00", + "pytest": { + "passed": 30, + "files": [ + "tests/test_composition_curves.py", + "tests/test_grok_depth_data.py", + "tests/test_grok_depth_training.py" + ] + }, + "ruff_check": "passed", + "ruff_format_check": "passed", + "cuda_preflight": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/cuda.json", + "gpu_pipeline_reload": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/smoke/audit.json", + "wandb_connectivity": "/ossfs/workspace/experiment-runs/composition-data-curves-v1-preflight/wandb-connectivity.json", + "engineering_preflight_not_scientific_result": true +} diff --git a/docs/development-artifacts/compositional-capacity-discussion-20261006/note.md b/docs/development-artifacts/compositional-capacity-discussion-20261006/note.md new file mode 100644 index 0000000000000000000000000000000000000000..bb73b3e137f0b89daa839277eaf20a89eceaa655 --- /dev/null +++ b/docs/development-artifacts/compositional-capacity-discussion-20261006/note.md @@ -0,0 +1,80 @@ +# 存储与组合容量的分离：讨论候选 + +2026-10-06。原论文标题保持 **Transformers as Associative Memories: Exploring the Scaling of Storage and Compositional Recall**。本文件保留限定模型的代数推导与 CPU 数值核验；结合 Physics of Language Models 的后续思考、实验逻辑与故事线已按用户要求纳入[当前研究计划](../../hebbian-learning-plan-v1.md#capacity-scaling-mainline-20261006)。这不是新的训练执行协议，不修改现有运行。 + +## 核心问题与证据层级 + +随着事实负载增加，单跳可提取的知识量与多跳可组合的知识量，是否出现不同的宽度依赖？如果存在差距，中间状态的纠错能否改变它的增长规律？ + +复合答案由原子事实决定，不自带一份与每条链独立的新知识熵。不能因组合链数量增长，就推出存储参数必须按链数量增长。所需解释是特定表示和计算过程的代价：被压缩存储的关联能否连续使用，以及中间串扰如何随负载传播。 + +下面的结果仅属于随机编码、外积叠加、直接线性串接这一构造。它不证明所有可学习矩阵、MLP 或 Transformer 都具有相同损失，更不构成任意架构的容量下界。训练可重排表示、改变读写规则或实现内部纠错，这正是后续实验必须检验的部分。 + +## 一个精确的二阶矩计算 + +每个阶段有 N 个实体的独立随机单位球编码，写成 E_l ∈ R^{d×N}，不同阶段也独立。阶段间关系取任意固定双射；对编码列重编号后，可无损地写成同索引关联。 + +记忆矩阵为 W_l = E_l E_{l-1}^T。一次查询从 E_0 e_i 开始，连续应用 h 个记忆矩阵，最后用 E_h 的内积打分。令 G_l = E_l^T E_l，则分数向量为 + + s = G_h G_{h-1} ... G_0 e_i. + +这里 G_l 独立，E[G_l]=I。对独立于 G_l 的固定向量 v，令 a=1+(N−1)/d、b=1−1/d，有 + + E ||G_l v||² = a ||v||², + E [(G_l v)_j²] = b v_j² + ||v||²/d. + +第一式由对角元恒为 1、非对角元均值为 0 且二阶矩为 1/d 得到；第二式展开平方后，不同非对角项的交叉期望为零。对先前随机向量条件化后同样成立。 + +记 t 个 Gram 因子之后的错误坐标二阶矩为 q_t，则 q_0=0，且 + + q_{t+1} = b q_t + a^t/d, + q_t = (a^t − b^t)/N. + +因此 h 次检索后的任一错误候选 j≠i 满足以下精确关系，期望遍历随机编码： + + E[s_j] = 0, + Var(s_j) = { [1+(N−1)/d]^(h+1) − [1−1/d]^(h+1) } / N. + +正确候选的均值为 1，二阶矩为 a^(h+1)/N + (1−1/N)b^(h+1)；正确分数本身也有随机性，不可把它当成恒定信号。 + +特别地： + + 一跳：Var(s_j) = 2/d + (N−2)/d², + 两跳：Var(s_j) = 3/d + 3(N−2)/d² + (N²−3N+3)/d³. + +在固定 h、N/d 足够大时，错误分数方差的主项为 N^h/d^(h+1)。这说明该构造中，连续组合的串扰负担增长快于单跳，不能仅按独立单跳错误率相乘解释。 + +这还不是准确率阈值定理。候选分数有依赖，正确分数也波动；要得到容量尺度，还须控制尾部概率和最大错误分数。把主项直接改写为 N≈d^(1+1/h)，只能得到忽略尾部及对数因子的启发式尺度，不能写成已证明的 Transformer 定律。 + +## 中间重编码与架构含义 + +在每一步后使用模型自己的 argmax，将状态替换为预测实体的固定编码，再进入下一步。在必要单跳都正确的查询上，整个链确定正确。这一性质是构造的直接结果，不是新的普遍定理；它需要编码表、额外解码计算，并可能在单跳错误时做出不可逆的错误选择。 + +有价值的理论目标是比较两类计算在相同随机记忆负载下的准确率尺度，并明确纠错资源。之后再问训练后的非线性网络是否出现同类分离，以及是否已经学会消除它。此推导不适用于同一矩阵重复相乘；Loop 的跨步误差依赖需另行分析。 + +## CPU 验算与复现 + +[sanity_check.py](sanity_check.py) 使用 NumPy、16 次独立编码抽样，每次抽取 48 个查询；各条件的随机流固定。结果保存于 [sanity-results.json](sanity-results.json)。未进行参数训练、未使用 GPU。查询在同一编码世界内相关，768 个查询不能当作 768 个独立世界。报告的是抽样原子准确率。 + +当前主机复现命令： + +```bash +LD_LIBRARY_PATH="/lib64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}" OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 python docs/development-artifacts/compositional-capacity-discussion-20261006/sanity_check.py +``` + +## 小 Transformer 需要区分的解释 + +- 主轴采用原子世界信息量相对于参数量的负载 B/P，N 作为其中一个控制量；[知识容量对接](physics-of-language-connection.md)区分数据熵和实测掌握量。少量宽度用于验证尺度，先固定两跳，有规律后才延伸三跳。模型从头预训练，原子事实和有限组合示范可见，测试链留出。 +- 固定最大词表、实体编码长度、关系类型、目标查询和目标事实的曝光；避免增加 N 时顺带改变词表参数或链难度。加入无关事实是一个关键比较：目标链保持不变，改变其他关联占用的记忆。 +- 固定每条事实曝光与固定总 FLOPs 不能同时随 N 严格保持。前者用于机制主比较，后者只作资源复核；分别报告曲线，不混成同一容量结论。对临界点检查延长训练是否移动边界，不能把有限预算的优化失败写成结构不可能性。 +- 报告全池多跳、必要单跳正确率及共同正确子集覆盖率。高平均原子准确率不足以排除组成目标链的事实恰好更难。 +- 优先普通 Transformer 与共享块 Transformer，再按观测选一个机制变体。中间纠错若需要首跳监督，两臂给相同监督；若加入计算，补同等计算的对照。仅有外部多次问答成功不证明内部架构改善。 +- 若串扰随负载的效应只存在于预设线性记忆、被正常训练消除，应收窄或放弃其作为普通 Transformer 主机制的解释。现有约 17% OO 平台不能被预先归因于容量。 + +## 相关文献及当前阅读边界 + +- [Meta: Scaling Laws for Looped Mixture of Experts](https://arxiv.org/html/2609.40316v1)，2026-09-30 预印本：核对联合 recurrence/sparsity scaling、有效参数映射和下游计算比较。之前的参数/循环计算效率选题与其确有明显重叠。 +- [Understanding Factual Recall in Transformers via Associative Memories](https://arxiv.org/html/2412.06538)：随机编码关联记忆、事实存储与 Transformer 构造的理论基础。其单跳容量不能直接当成连续组合容量。 +- [Sharp Capacity Thresholds in Linear Associative Memory: From Top-1 Retrieval to Tail-Average Learning](https://arxiv.org/html/2605.05189)，所读为 2026-08-19 v2：核对摘要、§1 模型及 top-1 阈值陈述。v1 与 v2 的标题和定理强度不同；本次未独立验证整篇证明。其模型表明检索标准影响容量，不能将“容量取决于读出方式”本身当作我们的新发现。 +- [Holographic Memory for Zero-Shot Compositional Reasoning in Knowledge Graphs](https://arxiv.org/html/2606.24948)，2026-06-23 预印本：核对 HRR/FHRR 记忆构造、hard cleanup 两跳及必要第二跳的原子难度诊断。该模型的结果提醒我们必须核验路径上的必要事实，不能仅比较全局单跳均值。 +- 搜索发现 OpenReview 稿件 *How Many Parameters for Multi-Hop?*，但两个正文入口都被站点验证页阻挡。本次未核对其定理，不据摘要认可其普遍容量结论；选题新颖性审查仍须补读。 diff --git a/docs/development-artifacts/compositional-capacity-discussion-20261006/physics-of-language-connection.md b/docs/development-artifacts/compositional-capacity-discussion-20261006/physics-of-language-connection.md new file mode 100644 index 0000000000000000000000000000000000000000..154314eac4650f3df6104ce783b77bc3a7eeddba --- /dev/null +++ b/docs/development-artifacts/compositional-capacity-discussion-20261006/physics-of-language-connection.md @@ -0,0 +1,48 @@ +# Physics of Language Models 3.3 对组合容量研究的帮助 + +2026-10-06，用户提出的文献连接；随后要求将思考和后续实验逻辑落盘。统一的故事线、实验顺序、判断分支和写作范围已纳入[当前研究计划](../../hebbian-learning-plan-v1.md#capacity-scaling-mainline-20261006)及[论文定位](../../paper-framing.md)。本文件保留文献口径与信息量定义，不增加训练预算或修改正在执行的协议。 + +## 原文口径 + +[Part 3.3，ICLR 2025 会议版](https://proceedings.iclr.cc/paper_files/paper/2025/file/26d3c9a66836ded8f34a944f2bfe868e-Paper-Conference.pdf)报告的是约 **2 bits of knowledge per parameter**，不是每条事实需要 2 bits。2 是受控实验中充分训练后的经验容量比例，信息论定理提供的是知识比特数的下界，不是任意 Transformer 都不得超过 2 bits/parameter 的普遍定理。 + +本次也读取了 [2024 arXiv 完整版](https://arxiv.org/html/2404.05405)的 §2–5、训练曝光与架构相关陈述、附录 A 的参数口径和提取验证。原文以随机生成的事实和知识 token 的损失估计信息量；名字集合、属性值、值词典分别计数。1000 次与 100 次事实曝光有不同经验容量。其参数口径排除未使用的词表行；MoE 分母是总存储参数，不是单次激活参数。提取验证借助在部分人物上微调 QA 后测试其余人物，不能自动解释为无监督零样本知识操作。 + +同系列 [Part 3.2，ICLR 2025 会议版](https://proceedings.iclr.cc/paper_files/paper/2025/file/d5494c8747276d3cdb2598e5617de89d-Paper-Conference.pdf)已研究提取、分类、比较、逆向搜索，并观察到提取成功与知识操作失败可以并存。因此，“记得但不会用”本身不是我们的新增主张。 + +## 用知识熵取代事实条数作为主负载 + +在固定地址与值词表、N 个独立且均匀的 M 选一属性值的简化世界中： + + H(Z) = N log₂ M. + +如果原子属性值的平均负对数概率为 ℓ₁（nats），则可采用与原文思路一致的经验量： + + B_hat = N (log₂ M − ℓ₁ / ln 2). + +跨随机世界取期望时，可由熵与交叉熵关系给出模型保有信息量的下界；单个世界的实测估计不等于已知的真实互信息。该简式只计条件属性信息，不包含随机名字/词典的学习成本，也不能直接用于相关的真实知识图。 + +区分两个横轴：数据负载 ρ_data=H(Z)/P，与已掌握信息的经验密度 ρ_learned=B_hat/P。提高数据量但没有学会，并不意味着存储密度提高。 + +多跳答案由原子世界 Z 决定。不能把大量复合查询的 log₂ 候选数相加，当作新存入的知识 bits。组合题之间共享事实，联合熵不能按题数独立计数。 + +## 候选容量定义与理论目标 + +固定世界生成器、训练支持、训练流程、知识表示、评价分布及准确率要求，定义： + +- C₁(P)：达到指定原子提取准确率时，可承载的最大原子世界信息量。 +- C_h(P)：同时满足同一原子提取要求及指定 h 跳泛化准确率时，可承载的最大原子世界信息量。 + +组合容量的单位是“满足使用要求的知识库 bits”，不是复合答案新增 bits。由定义的集合包含关系 C_h≤C₁；这个不等式不是论文贡献。真正要研究的是两者的尺度、差距随 h 的变化，以及架构是否改变差距。 + +尤其不能直接设 C₁(P)=2P：原文约 2 bits/parameter 是基于损失估计的峰值容量比例，与我们指定例如 99% 原子准确率时的容量边界不是同一定义。先复用其测量方法，再独立测定我们的 C₁ 和 C_h。 + +经典信息论能限制需要存储的世界信息，但不会因复合查询数量大就自动产生新的 h 倍信息下界。若需证明组合额外代价，必须引入明确的计算限制、状态维数、精度或中间纠错条件。前一份随机线性记忆的串扰推导只覆盖其中一个构造，不能推出所有学习到的 Transformer 都有同一尺度。 + +## 对当前实验的实际影响 + +当前真实图 65,968 条原子事实，D8 约 96.1M 总参数，二者尚未转换到相容的信息/参数口径。没有证据说明已经接近 3.3 的存储极限。仅作为量纲示例：如果每条独立关联为 20 bits，条件关联信息量约 1.32M bits，用当前总参数分母约为 0.014 bits/parameter；这不是当前真实数据的熵估计，也尚未扣除未使用词表行。 + +因此，下一步应先校准小模型的单跳容量曲线，适当缩小模型或增加受控事实熵，覆盖欠载至接近饱和的区间，再观察未见组合。保持共同词表，报告全部参数与按原文口径调整的参数；共享循环参数只计一次，MoE 同时报总参数和实际计算。 + +可检验的中心问题是：**在相同知识 bits/parameter 和必要原子提取水平下，组合能力是否仍受状态宽度、执行结构与中间纠错显著影响？** 若负载归一化能让单跳曲线接近重合、组合曲线却依架构分离，就得到超出架构排名的机制问题。先以两跳为主，负载为主轴；不自动追加架构或跳数全矩阵。 diff --git a/docs/development-artifacts/compositional-capacity-discussion-20261006/sanity-results.json b/docs/development-artifacts/compositional-capacity-discussion-20261006/sanity-results.json new file mode 100644 index 0000000000000000000000000000000000000000..56c454a58d975e2747145cfbf309ed0e8d35d958 --- /dev/null +++ b/docs/development-artifacts/compositional-capacity-discussion-20261006/sanity-results.json @@ -0,0 +1,99 @@ +{ + "kind": "exploratory CPU algebra verification; no training", + "seed": 601006, + "numpy_version": "1.23.5", + "rows": [ + { + "d": 64, + "associations_per_stage": 128, + "independent_codebook_draws": 16, + "queries_per_draw": 48, + "atomic1": 0.9817708333333334, + "atomic2": 0.9817708333333334, + "continuous_twohop": 0.4088541666666667, + "both_atomic_correct_coverage": 0.9635416666666666, + "continuous_twohop_given_both_correct": 0.4175675675675676, + "reset_twohop": 0.9635416666666666, + "reset_twohop_given_both_correct": 1.0, + "off_score_second_moment_onehop_measured": 0.06191769958576853, + "off_score_second_moment_onehop_exact": 0.06201171875, + "off_score_second_moment_twohop_measured": 0.19202592507422953, + "off_score_second_moment_twohop_exact": 0.20020675659179688 + }, + { + "d": 64, + "associations_per_stage": 256, + "independent_codebook_draws": 16, + "queries_per_draw": 48, + "atomic1": 0.73828125, + "atomic2": 0.7760416666666666, + "continuous_twohop": 0.078125, + "both_atomic_correct_coverage": 0.5572916666666666, + "continuous_twohop_given_both_correct": 0.11214953271028037, + "reset_twohop": 0.55859375, + "reset_twohop_given_both_correct": 1.0, + "off_score_second_moment_onehop_measured": 0.09284981942132862, + "off_score_second_moment_onehop_exact": 0.09326171875, + "off_score_second_moment_twohop_measured": 0.4692728946295357, + "off_score_second_moment_twohop_exact": 0.4799919128417969 + }, + { + "d": 128, + "associations_per_stage": 256, + "independent_codebook_draws": 16, + "queries_per_draw": 48, + "atomic1": 1.0, + "atomic2": 1.0, + "continuous_twohop": 0.64453125, + "both_atomic_correct_coverage": 1.0, + "continuous_twohop_given_both_correct": 0.64453125, + "reset_twohop": 1.0, + "reset_twohop_given_both_correct": 1.0, + "off_score_second_moment_onehop_measured": 0.03121580010666049, + "off_score_second_moment_onehop_exact": 0.0311279296875, + "off_score_second_moment_twohop_measured": 0.10011350323057835, + "off_score_second_moment_twohop_exact": 0.10083150863647461 + }, + { + "d": 128, + "associations_per_stage": 512, + "independent_codebook_draws": 16, + "queries_per_draw": 48, + "atomic1": 0.9778645833333334, + "atomic2": 0.96484375, + "continuous_twohop": 0.15494791666666666, + "both_atomic_correct_coverage": 0.9466145833333334, + "continuous_twohop_given_both_correct": 0.1623108665749656, + "reset_twohop": 0.9466145833333334, + "reset_twohop_given_both_correct": 1.0, + "off_score_second_moment_onehop_measured": 0.04736494144751186, + "off_score_second_moment_onehop_exact": 0.0467529296875, + "off_score_second_moment_twohop_measured": 0.2419763221214787, + "off_score_second_moment_twohop_exact": 0.2410902976989746 + }, + { + "d": 128, + "associations_per_stage": 1024, + "independent_codebook_draws": 16, + "queries_per_draw": 48, + "atomic1": 0.69140625, + "atomic2": 0.66015625, + "continuous_twohop": 0.013020833333333334, + "both_atomic_correct_coverage": 0.4635416666666667, + "continuous_twohop_given_both_correct": 0.02247191011235955, + "reset_twohop": 0.4635416666666667, + "reset_twohop_given_both_correct": 1.0, + "off_score_second_moment_onehop_measured": 0.07904413494810934, + "off_score_second_moment_onehop_exact": 0.0780029296875, + "off_score_second_moment_twohop_measured": 0.7224368904657623, + "off_score_second_moment_twohop_exact": 0.7091078758239746 + } + ], + "limitations": [ + "Query samples within a codebook draw are dependent.", + "Atomic percentages refer to sampled queries, not all stored facts.", + "Reset accesses a fixed codebook and adds decoding work.", + "No confidence intervals or capacity exponent fitted.", + "Independent codebooks do not establish behavior of tied recurrent weights." + ] +} diff --git a/docs/development-artifacts/compositional-capacity-discussion-20261006/sanity_check.py b/docs/development-artifacts/compositional-capacity-discussion-20261006/sanity_check.py new file mode 100644 index 0000000000000000000000000000000000000000..fa155b4cbc2679452e303d2016999eb43abf6ba2 --- /dev/null +++ b/docs/development-artifacts/compositional-capacity-discussion-20261006/sanity_check.py @@ -0,0 +1,81 @@ +"""CPU-only algebra check, not a Transformer training experiment. + +Run on the current host with /lib64 first in LD_LIBRARY_PATH and one BLAS thread. +The random codebooks are independent between stages and have unit-norm columns. +This does not model a repeatedly applied shared matrix or SGD learning. +""" + +import json +from pathlib import Path + +import numpy as np + + +def main(): + rng = np.random.default_rng(601006) + rows = [] + for d, n in [(64, 128), (64, 256), (128, 256), (128, 512), (128, 1024)]: + totals = np.zeros(9, dtype=float) + for _ in range(16): + codebooks = [rng.normal(size=(d, n)) for _ in range(3)] + codebooks = [e / np.linalg.norm(e, axis=0) for e in codebooks] + w1 = codebooks[1] @ codebooks[0].T + w2 = codebooks[2] @ codebooks[1].T + ids = rng.choice(n, size=48, replace=False) + hidden = w1 @ codebooks[0][:, ids] + s1 = codebooks[1].T @ hidden + s2_atomic = codebooks[2].T @ (w2 @ codebooks[1][:, ids]) + s2 = codebooks[2].T @ (w2 @ hidden) + predicted_bridge = s1.argmax(axis=0) + reset_scores = codebooks[2].T @ (w2 @ codebooks[1][:, predicted_bridge]) + correct1 = predicted_bridge == ids + correct2 = s2_atomic.argmax(axis=0) == ids + both = correct1 & correct2 + composed = s2.argmax(axis=0) == ids + reset_correct = reset_scores.argmax(axis=0) == ids + # Exact consequence of replacing a correct prediction by its codeword. + assert np.all(reset_correct[both]) + wrong = np.ones((n, len(ids)), dtype=bool) + wrong[ids, np.arange(len(ids))] = False + totals += [ + correct1.sum(), correct2.sum(), composed.sum(), both.sum(), + (composed & both).sum(), (s1[wrong] ** 2).mean(), + (s2[wrong] ** 2).mean(), len(ids), reset_correct.sum(), + ] + a, b = 1 + (n - 1) / d, 1 - 1 / d + rows.append(dict( + d=d, associations_per_stage=n, independent_codebook_draws=16, + queries_per_draw=48, atomic1=totals[0] / totals[7], + atomic2=totals[1] / totals[7], continuous_twohop=totals[2] / totals[7], + both_atomic_correct_coverage=totals[3] / totals[7], + continuous_twohop_given_both_correct=totals[4] / totals[3], + reset_twohop=totals[8] / totals[7], + reset_twohop_given_both_correct=1.0, + off_score_second_moment_onehop_measured=totals[5] / 16, + off_score_second_moment_onehop_exact=(a ** 2 - b ** 2) / n, + off_score_second_moment_twohop_measured=totals[6] / 16, + off_score_second_moment_twohop_exact=(a ** 3 - b ** 3) / n, + )) + output = dict( + kind="exploratory CPU algebra verification; no training", + seed=601006, numpy_version=np.__version__, rows=rows, + limitations=[ + "Query samples within a codebook draw are dependent.", + "Atomic percentages refer to sampled queries, not all stored facts.", + "Reset accesses a fixed codebook and adds decoding work.", + "No confidence intervals or capacity exponent fitted.", + "Independent codebooks do not establish behavior of tied recurrent weights.", + ], + ) + Path(__file__).with_name("sanity-results.json").write_text( + json.dumps(output, ensure_ascii=False, indent=2) + "\n" + ) + for row in rows: + print(json.dumps({k: row[k] for k in ( + "d", "associations_per_stage", "atomic1", "atomic2", + "continuous_twohop_given_both_correct", "reset_twohop", + )})) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/memory-interface-next-v1/container/lm-memory-daemon.log b/docs/development-artifacts/memory-interface-next-v1/container/lm-memory-daemon.log index 9541b0d0238345f0a2723664d4e73fdea8bfe5eb..8539341edc14e4c80c85b9622292b99ca010cc1c 100644 --- a/docs/development-artifacts/memory-interface-next-v1/container/lm-memory-daemon.log +++ b/docs/development-artifacts/memory-interface-next-v1/container/lm-memory-daemon.log @@ -705,3 +705,685 @@ time="2026-10-04T04:43:19.310386638+08:00" level=info msg="sbJoin: gwep4 ''->'', time="2026-10-04T04:43:19.514863204+08:00" level=info msg="connecting to shim 48c0cf8e71827b28de46b8d32ef418ebcb5ef990d98b97860a1bee40fdc05ed1" address="unix:///run/containerd/s/3e92c3028db96ba386de953bd6b05cebd8fbc18cc629242b01bd886ac20ab008" namespace=moby protocol=ttrpc version=3 time="2026-10-04T04:43:19.625832066+08:00" level=error msg="loading cgroup for 186727" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 time="2026-10-04T04:43:19.627958245+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=7435ace9fbb4 ep=lm-architecture-40ee7aad02b12e65867d net=none nid=f13f14be1124 +time="2026-10-04T05:52:23.397924606+08:00" level=info msg="received task-delete event from containerd" container=6b03338ad5f882841514df0ce2a094ddb0ae0661d4212dd4a5af854efed8395c module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T05:52:23.397928247+08:00" level=info msg="shim disconnected" id=6b03338ad5f882841514df0ce2a094ddb0ae0661d4212dd4a5af854efed8395c namespace=moby +time="2026-10-04T05:52:23.400766846+08:00" level=info msg="cleaning up after shim disconnected" id=6b03338ad5f882841514df0ce2a094ddb0ae0661d4212dd4a5af854efed8395c namespace=moby +time="2026-10-04T05:52:23.400777122+08:00" level=info msg="cleaning up dead shim" id=6b03338ad5f882841514df0ce2a094ddb0ae0661d4212dd4a5af854efed8395c namespace=moby +time="2026-10-04T05:52:24.534603082+08:00" level=info msg="connecting to shim 9ef5e18394a659f88a137fdba6b4db25ee7a5f39f27856547e55a4a169c87ddd" address="unix:///run/containerd/s/29b9cb292e022f7ebf7bb01f095d247f1c28eefe2242d41cec0f9f1854634405" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T05:52:24.647774096+08:00" level=error msg="loading cgroup for 319610" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T05:52:24.649317428+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=fb3ef6a2c5e0 ep=lm-architecture-0afef81e43b6a6004e99 net=none nid=f13f14be1124 +time="2026-10-04T06:12:29.937782278+08:00" level=info msg="shim disconnected" id=0e032e40f379ed03489700229d829a0e8d1103de990f44aa8f0dcc30d2772b5d namespace=moby +time="2026-10-04T06:12:29.937801269+08:00" level=info msg="received task-delete event from containerd" container=0e032e40f379ed03489700229d829a0e8d1103de990f44aa8f0dcc30d2772b5d module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T06:12:29.940634685+08:00" level=info msg="cleaning up after shim disconnected" id=0e032e40f379ed03489700229d829a0e8d1103de990f44aa8f0dcc30d2772b5d namespace=moby +time="2026-10-04T06:12:29.940654389+08:00" level=info msg="cleaning up dead shim" id=0e032e40f379ed03489700229d829a0e8d1103de990f44aa8f0dcc30d2772b5d namespace=moby +time="2026-10-04T06:12:32.324023525+08:00" level=info msg="connecting to shim 80fe0c2ef685ccdad1881ca425fa89710ad2cfc801739a6949ed382e4b1fc982" address="unix:///run/containerd/s/d7ce6595d4d3a1cf663e592342c256fc8cd7089b55cabe2a28f95a66a6ee1339" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T06:12:32.443416668+08:00" level=error msg="loading cgroup for 357173" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T06:12:32.445170491+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=7a0b490e9881 ep=lm-architecture-6dfd076d3dd45d2834bf net=none nid=f13f14be1124 +time="2026-10-04T06:27:51.919510625+08:00" level=info msg="shim disconnected" id=a4a2900d6b70f3bbfccd6e8b11afa6346d4bf134d3de807d565d88b4f7d17b54 namespace=moby +time="2026-10-04T06:27:51.919543765+08:00" level=info msg="received task-delete event from containerd" container=a4a2900d6b70f3bbfccd6e8b11afa6346d4bf134d3de807d565d88b4f7d17b54 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T06:27:51.922370635+08:00" level=info msg="cleaning up after shim disconnected" id=a4a2900d6b70f3bbfccd6e8b11afa6346d4bf134d3de807d565d88b4f7d17b54 namespace=moby +time="2026-10-04T06:27:51.922384062+08:00" level=info msg="cleaning up dead shim" id=a4a2900d6b70f3bbfccd6e8b11afa6346d4bf134d3de807d565d88b4f7d17b54 namespace=moby +time="2026-10-04T06:27:52.179959215+08:00" level=info msg="connecting to shim a3004358bbc86c80b45f721677fa3a86a39970a3add5de51b38f8b6939eb4618" address="unix:///run/containerd/s/4fc98bbda909df1a2f74445209cd974f68a8f30a328f05871291237b31a68c44" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T06:27:52.369409790+08:00" level=error msg="loading cgroup for 388781" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T06:27:52.371215917+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=58f36edf8c71 ep=lm-architecture-fefe028eebb3cb4d8331 net=none nid=f13f14be1124 +time="2026-10-04T06:48:54.990100045+08:00" level=info msg="shim disconnected" id=48c0cf8e71827b28de46b8d32ef418ebcb5ef990d98b97860a1bee40fdc05ed1 namespace=moby +time="2026-10-04T06:48:54.990101593+08:00" level=info msg="received task-delete event from containerd" container=48c0cf8e71827b28de46b8d32ef418ebcb5ef990d98b97860a1bee40fdc05ed1 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T06:48:54.993033659+08:00" level=info msg="cleaning up after shim disconnected" id=48c0cf8e71827b28de46b8d32ef418ebcb5ef990d98b97860a1bee40fdc05ed1 namespace=moby +time="2026-10-04T06:48:54.993047747+08:00" level=info msg="cleaning up dead shim" id=48c0cf8e71827b28de46b8d32ef418ebcb5ef990d98b97860a1bee40fdc05ed1 namespace=moby +time="2026-10-04T06:48:57.105217052+08:00" level=info msg="connecting to shim 90034611cfef78e093fe2293aec4f06471e738d5e1272e2435e6023ff216d5d1" address="unix:///run/containerd/s/96e3bbb5aaaf2d822c0bf6c7dd5968acab35317bacd3afedc0d8d109359c0ef9" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T06:48:57.229695475+08:00" level=error msg="loading cgroup for 429359" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T06:48:57.232252925+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=513a92ce28e8 ep=lm-architecture-dd83c20dfc65a41b64e8 net=none nid=f13f14be1124 +time="2026-10-04T07:01:58.893673565+08:00" level=info msg="shim disconnected" id=9ef5e18394a659f88a137fdba6b4db25ee7a5f39f27856547e55a4a169c87ddd namespace=moby +time="2026-10-04T07:01:58.893963257+08:00" level=info msg="received task-delete event from containerd" container=9ef5e18394a659f88a137fdba6b4db25ee7a5f39f27856547e55a4a169c87ddd module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T07:01:58.896559390+08:00" level=info msg="cleaning up after shim disconnected" id=9ef5e18394a659f88a137fdba6b4db25ee7a5f39f27856547e55a4a169c87ddd namespace=moby +time="2026-10-04T07:01:58.896577916+08:00" level=info msg="cleaning up dead shim" id=9ef5e18394a659f88a137fdba6b4db25ee7a5f39f27856547e55a4a169c87ddd namespace=moby +time="2026-10-04T07:01:59.634725156+08:00" level=info msg="connecting to shim b82c4d9a837af181c42a4669fea244ce53fcd42267075a1137b980dfa3a3d54d" address="unix:///run/containerd/s/fafb7ca5b568b6ab5ef29c8b0dc89b29ef96547fe415f449b119fd8e8ee1990d" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T07:01:59.751004436+08:00" level=error msg="loading cgroup for 462227" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T07:01:59.752978556+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=085e14c4b27e ep=lm-architecture-ee31486490dae7155fc3 net=none nid=f13f14be1124 +time="2026-10-04T07:48:40.576545651+08:00" level=info msg="shim disconnected" id=b82c4d9a837af181c42a4669fea244ce53fcd42267075a1137b980dfa3a3d54d namespace=moby +time="2026-10-04T07:48:40.579385428+08:00" level=info msg="cleaning up after shim disconnected" id=b82c4d9a837af181c42a4669fea244ce53fcd42267075a1137b980dfa3a3d54d namespace=moby +time="2026-10-04T07:48:40.579394827+08:00" level=info msg="cleaning up dead shim" id=b82c4d9a837af181c42a4669fea244ce53fcd42267075a1137b980dfa3a3d54d namespace=moby +time="2026-10-04T07:57:03.442554209+08:00" level=info msg="shim disconnected" id=a3004358bbc86c80b45f721677fa3a86a39970a3add5de51b38f8b6939eb4618 namespace=moby +time="2026-10-04T07:57:03.442560252+08:00" level=info msg="received task-delete event from containerd" container=a3004358bbc86c80b45f721677fa3a86a39970a3add5de51b38f8b6939eb4618 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T07:57:03.445386770+08:00" level=info msg="cleaning up after shim disconnected" id=a3004358bbc86c80b45f721677fa3a86a39970a3add5de51b38f8b6939eb4618 namespace=moby +time="2026-10-04T07:57:03.445407392+08:00" level=info msg="cleaning up dead shim" id=a3004358bbc86c80b45f721677fa3a86a39970a3add5de51b38f8b6939eb4618 namespace=moby +time="2026-10-04T07:57:06.822385919+08:00" level=info msg="received task-delete event from containerd" container=80fe0c2ef685ccdad1881ca425fa89710ad2cfc801739a6949ed382e4b1fc982 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T07:57:06.822393052+08:00" level=info msg="shim disconnected" id=80fe0c2ef685ccdad1881ca425fa89710ad2cfc801739a6949ed382e4b1fc982 namespace=moby +time="2026-10-04T07:57:06.822452275+08:00" level=info msg="cleaning up after shim disconnected" id=80fe0c2ef685ccdad1881ca425fa89710ad2cfc801739a6949ed382e4b1fc982 namespace=moby +time="2026-10-04T07:57:06.822464650+08:00" level=info msg="cleaning up dead shim" id=80fe0c2ef685ccdad1881ca425fa89710ad2cfc801739a6949ed382e4b1fc982 namespace=moby +time="2026-10-04T08:08:51.077504687+08:00" level=info msg="connecting to shim f2b1dd94d2ccbb32224a2cfe03617f834f6caeb78ac24e9de45baf3f3b513a02" address="unix:///run/containerd/s/580657210fea8e4dbb1f517a742420495e49e61bfc9ec83e80b602e691b049e9" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T08:08:51.189486374+08:00" level=error msg="loading cgroup for 69019" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T08:08:51.191267539+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=7346bf41ed5f ep=lm-architecture-a609772b7596665d29fb net=none nid=f13f14be1124 +time="2026-10-04T08:08:51.394245752+08:00" level=info msg="connecting to shim 3fc17546055de77920a6df9aa587a23760e1cae36057a405694dac3c8829a143" address="unix:///run/containerd/s/4c81d7ff8b0325f47e27fe58b04961c43e8f0ff192c352ad7eb1aa964401b6bc" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T08:08:51.521740681+08:00" level=error msg="loading cgroup for 69496" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T08:08:51.523870331+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e64ad94e3dfa ep=lm-architecture-beed9aeb7b3a62333571 net=none nid=f13f14be1124 +time="2026-10-04T08:08:51.707730532+08:00" level=info msg="connecting to shim 369e97a0b8ad5849c53f0673ea54de9d202f6bf557ba1377362166481fd8c866" address="unix:///run/containerd/s/0e088050afee26a5fa86144cf694f35cf3bcc8390be781dfa18c55f0b9df138d" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T08:08:51.843936597+08:00" level=error msg="loading cgroup for 70355" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T08:08:51.845820630+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=da1d1f8d9329 ep=lm-architecture-e44eb0a8969681d4071e net=none nid=f13f14be1124 +time="2026-10-04T08:53:54.971136964+08:00" level=info msg="shim disconnected" id=90034611cfef78e093fe2293aec4f06471e738d5e1272e2435e6023ff216d5d1 namespace=moby +time="2026-10-04T08:53:54.971198467+08:00" level=info msg="received task-delete event from containerd" container=90034611cfef78e093fe2293aec4f06471e738d5e1272e2435e6023ff216d5d1 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T08:53:54.979440963+08:00" level=info msg="cleaning up after shim disconnected" id=90034611cfef78e093fe2293aec4f06471e738d5e1272e2435e6023ff216d5d1 namespace=moby +time="2026-10-04T08:53:54.979459490+08:00" level=info msg="cleaning up dead shim" id=90034611cfef78e093fe2293aec4f06471e738d5e1272e2435e6023ff216d5d1 namespace=moby +time="2026-10-04T08:53:59.166595485+08:00" level=info msg="connecting to shim bf2047721d15c6eadf07ee5fed16834f3b4f6f015a56d38fa2ad2929c291c87e" address="unix:///run/containerd/s/637e8d2e0ac962209c09afd32a807cd9df1464b602a2c88d329e21e66f3cec5d" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T08:53:59.295672496+08:00" level=error msg="loading cgroup for 203162" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T08:53:59.297457712+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=a0b48ff51831 ep=lm-architecture-3d331581a1613a4ffd85 net=none nid=f13f14be1124 +time="2026-10-04T18:29:37.381343097+08:00" level=info msg="shim disconnected" id=f2b1dd94d2ccbb32224a2cfe03617f834f6caeb78ac24e9de45baf3f3b513a02 namespace=moby +time="2026-10-04T18:29:37.381369809+08:00" level=info msg="received task-delete event from containerd" container=f2b1dd94d2ccbb32224a2cfe03617f834f6caeb78ac24e9de45baf3f3b513a02 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T18:29:37.384323026+08:00" level=info msg="cleaning up after shim disconnected" id=f2b1dd94d2ccbb32224a2cfe03617f834f6caeb78ac24e9de45baf3f3b513a02 namespace=moby +time="2026-10-04T18:29:37.384336904+08:00" level=info msg="cleaning up dead shim" id=f2b1dd94d2ccbb32224a2cfe03617f834f6caeb78ac24e9de45baf3f3b513a02 namespace=moby +time="2026-10-04T18:29:39.677481606+08:00" level=info msg="connecting to shim 7beec9b30bf408dc54bb0d0862c0e8dd02fb4e85981c0e31cb7e4806734c0606" address="unix:///run/containerd/s/2a4e9948a681c8c04a066eb9893c22552a813761632d25cb7445e3b3a979dc14" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T18:29:39.782644984+08:00" level=error msg="loading cgroup for 146601" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T18:29:39.784370385+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=ca24dc197de5 ep=lm-architecture-e14a1f19aada20b16760 net=none nid=f13f14be1124 +time="2026-10-04T21:59:36.143518448+08:00" level=info msg="shim disconnected" id=369e97a0b8ad5849c53f0673ea54de9d202f6bf557ba1377362166481fd8c866 namespace=moby +time="2026-10-04T21:59:36.143588378+08:00" level=info msg="received task-delete event from containerd" container=369e97a0b8ad5849c53f0673ea54de9d202f6bf557ba1377362166481fd8c866 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-04T21:59:36.146343403+08:00" level=info msg="cleaning up after shim disconnected" id=369e97a0b8ad5849c53f0673ea54de9d202f6bf557ba1377362166481fd8c866 namespace=moby +time="2026-10-04T21:59:36.146357475+08:00" level=info msg="cleaning up dead shim" id=369e97a0b8ad5849c53f0673ea54de9d202f6bf557ba1377362166481fd8c866 namespace=moby +time="2026-10-04T21:59:38.528571498+08:00" level=info msg="connecting to shim 58eebb1c2fa60fb45c3522a06e11bae23af3b63a9238997460fc2c9397ea7f7d" address="unix:///run/containerd/s/1df7bdf6c5ed3d5b4ebcf40c2dcdd260732972bd4f6515bc0f90fef021880c08" namespace=moby protocol=ttrpc version=3 +time="2026-10-04T21:59:38.638389106+08:00" level=error msg="loading cgroup for 452166" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-04T21:59:38.639875597+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=977109c7d5d1 ep=lm-architecture-fe3cb340daa4d28e26d8 net=none nid=f13f14be1124 +time="2026-10-05T00:25:20.957143353+08:00" level=info msg="shim disconnected" id=3fc17546055de77920a6df9aa587a23760e1cae36057a405694dac3c8829a143 namespace=moby +time="2026-10-05T00:25:20.957223756+08:00" level=info msg="received task-delete event from containerd" container=3fc17546055de77920a6df9aa587a23760e1cae36057a405694dac3c8829a143 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T00:25:20.960019404+08:00" level=info msg="cleaning up after shim disconnected" id=3fc17546055de77920a6df9aa587a23760e1cae36057a405694dac3c8829a143 namespace=moby +time="2026-10-05T00:25:20.960038228+08:00" level=info msg="cleaning up dead shim" id=3fc17546055de77920a6df9aa587a23760e1cae36057a405694dac3c8829a143 namespace=moby +time="2026-10-05T00:25:21.590954390+08:00" level=info msg="connecting to shim 2b7a8055ea7c1550f70d954041f59242542045ec46e8fb92912a4e391e2dd31b" address="unix:///run/containerd/s/08466b24dbded78f3ffca58c6dbfd19e386b6d617745ee2b0f6c9b30303b9dee" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T00:25:21.706442217+08:00" level=error msg="loading cgroup for 156485" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T00:25:21.708272471+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=102dd4c9edb3 ep=lm-architecture-b598cb1a4764bfaeeb71 net=none nid=f13f14be1124 +time="2026-10-05T01:44:47.110326953+08:00" level=info msg="received task-delete event from containerd" container=7beec9b30bf408dc54bb0d0862c0e8dd02fb4e85981c0e31cb7e4806734c0606 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T01:44:47.110343007+08:00" level=info msg="shim disconnected" id=7beec9b30bf408dc54bb0d0862c0e8dd02fb4e85981c0e31cb7e4806734c0606 namespace=moby +time="2026-10-05T01:44:47.113154305+08:00" level=info msg="cleaning up after shim disconnected" id=7beec9b30bf408dc54bb0d0862c0e8dd02fb4e85981c0e31cb7e4806734c0606 namespace=moby +time="2026-10-05T01:44:47.113161813+08:00" level=info msg="cleaning up dead shim" id=7beec9b30bf408dc54bb0d0862c0e8dd02fb4e85981c0e31cb7e4806734c0606 namespace=moby +time="2026-10-05T01:44:49.388898636+08:00" level=info msg="connecting to shim 3b278b0907ad93e6d3f8358c82c8a0aa0497235642bf72eb0a5e3a38c2bc3ea8" address="unix:///run/containerd/s/91ad8802c09485a4e71534955af349a4ede25e24bbd2703ced954820de19a3df" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T01:44:49.492784523+08:00" level=error msg="loading cgroup for 270431" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T01:44:49.494321640+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=8cf04c94cca7 ep=lm-architecture-4fc6713db2b9bad094db net=none nid=f13f14be1124 +time="2026-10-05T03:53:13.044089868+08:00" level=info msg="shim disconnected" id=bf2047721d15c6eadf07ee5fed16834f3b4f6f015a56d38fa2ad2929c291c87e namespace=moby +time="2026-10-05T03:53:13.044174886+08:00" level=info msg="received task-delete event from containerd" container=bf2047721d15c6eadf07ee5fed16834f3b4f6f015a56d38fa2ad2929c291c87e module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T03:53:13.046917003+08:00" level=info msg="cleaning up after shim disconnected" id=bf2047721d15c6eadf07ee5fed16834f3b4f6f015a56d38fa2ad2929c291c87e namespace=moby +time="2026-10-05T03:53:13.046929792+08:00" level=info msg="cleaning up dead shim" id=bf2047721d15c6eadf07ee5fed16834f3b4f6f015a56d38fa2ad2929c291c87e namespace=moby +time="2026-10-05T03:53:15.548018983+08:00" level=info msg="connecting to shim d26dcad2c2c311fb59ee24febe5ff9863566995d841e38e281629c62b7474cae" address="unix:///run/containerd/s/d8949f4b1bdd3c3ac257beac7218f283fad6ab0cbbcf2fdbd24f71707ea50a72" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T03:53:15.673521155+08:00" level=error msg="loading cgroup for 455026" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T03:53:15.675216837+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=8203be55e6cc ep=lm-architecture-7acc43df79ac4d6b8689 net=none nid=f13f14be1124 +time="2026-10-05T08:14:10.577140377+08:00" level=info msg="received task-delete event from containerd" container=58eebb1c2fa60fb45c3522a06e11bae23af3b63a9238997460fc2c9397ea7f7d module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T08:14:10.577368238+08:00" level=info msg="shim disconnected" id=58eebb1c2fa60fb45c3522a06e11bae23af3b63a9238997460fc2c9397ea7f7d namespace=moby +time="2026-10-05T08:14:10.579962605+08:00" level=info msg="cleaning up after shim disconnected" id=58eebb1c2fa60fb45c3522a06e11bae23af3b63a9238997460fc2c9397ea7f7d namespace=moby +time="2026-10-05T08:14:10.579970651+08:00" level=info msg="cleaning up dead shim" id=58eebb1c2fa60fb45c3522a06e11bae23af3b63a9238997460fc2c9397ea7f7d namespace=moby +time="2026-10-05T08:14:11.580973341+08:00" level=info msg="connecting to shim 7de3805fdbaab536113fe546ade619c7ad123ba49ab0a78492f1a76522b4aea7" address="unix:///run/containerd/s/0fffc8b5d57f82d693c94f37a128dba8090d81a9752898b081cb56dd6d36e615" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T08:14:11.691353446+08:00" level=error msg="loading cgroup for 326435" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T08:14:11.693345928+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=fdce4f290e21 ep=lm-architecture-e0258c9f90c6a06f507b net=none nid=f13f14be1124 +time="2026-10-05T08:24:52.076485787+08:00" level=info msg="connecting to shim 2489f699fd0de9ac4dd16a3f933f2c0a58866848feba562b02c6ad56146ba3a3" address="unix:///run/containerd/s/b33f43f59a3b1d69d5beeb4837e07a52cca8aca607bdd0dfd217c2569fe91251" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T08:24:52.134712151+08:00" level=error msg="loading cgroup for 344628" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T08:24:52.136408466+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e04e1bfd6892 ep=lm-oo-attribution-cpu-check-20261005 net=none nid=f13f14be1124 +time="2026-10-05T08:25:00.261178782+08:00" level=info msg="shim disconnected" id=2489f699fd0de9ac4dd16a3f933f2c0a58866848feba562b02c6ad56146ba3a3 namespace=moby +time="2026-10-05T08:25:00.261226153+08:00" level=info msg="cleaning up after shim disconnected" id=2489f699fd0de9ac4dd16a3f933f2c0a58866848feba562b02c6ad56146ba3a3 namespace=moby +time="2026-10-05T08:25:00.261234756+08:00" level=info msg="cleaning up dead shim" id=2489f699fd0de9ac4dd16a3f933f2c0a58866848feba562b02c6ad56146ba3a3 namespace=moby +time="2026-10-05T08:25:00.261278844+08:00" level=info msg="received task-delete event from containerd" container=2489f699fd0de9ac4dd16a3f933f2c0a58866848feba562b02c6ad56146ba3a3 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T13:24:17.511052397+08:00" level=info msg="connecting to shim 3dd59509d033abf8833b02e2131b382f319fc17a1e763dfc6b18649a7cd7318e" address="unix:///run/containerd/s/e174fc3ccdaf028917345bfcf6aa638bd9ca78422a8b227ce774de0b7d256f66" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T13:24:17.619005693+08:00" level=error msg="loading cgroup for 337619" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T13:24:17.621186568+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=d6cf322c3993 ep=lm-architecture-3f734a8f4d6320b343b9 net=none nid=f13f14be1124 +time="2026-10-05T13:24:17.828314574+08:00" level=info msg="connecting to shim 9c0d0acbc5d1e8795767fe68b0d5ac5d803bcaab60aaa7bf598a7dcabf30462a" address="unix:///run/containerd/s/d7caed9adcf72f7deb6e50edd2b59301320135feb4a86fc53246e54241f9a8dc" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T13:24:17.958272614+08:00" level=error msg="loading cgroup for 337890" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T13:24:17.960149421+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=8da8f7b8de21 ep=lm-architecture-f70bfbe9e422a74aef34 net=none nid=f13f14be1124 +time="2026-10-05T15:28:54.648917970+08:00" level=info msg="received task-delete event from containerd" container=7de3805fdbaab536113fe546ade619c7ad123ba49ab0a78492f1a76522b4aea7 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T15:28:54.649690111+08:00" level=info msg="shim disconnected" id=7de3805fdbaab536113fe546ade619c7ad123ba49ab0a78492f1a76522b4aea7 namespace=moby +time="2026-10-05T15:28:54.651769849+08:00" level=info msg="cleaning up after shim disconnected" id=7de3805fdbaab536113fe546ade619c7ad123ba49ab0a78492f1a76522b4aea7 namespace=moby +time="2026-10-05T15:28:54.651777264+08:00" level=info msg="cleaning up dead shim" id=7de3805fdbaab536113fe546ade619c7ad123ba49ab0a78492f1a76522b4aea7 namespace=moby +time="2026-10-05T15:28:55.745307094+08:00" level=info msg="connecting to shim 5a3be56030b53bbe2c2ac955cf49f49047a18ff6a74158afd9eb25fd9e924dee" address="unix:///run/containerd/s/1914f5a8b62c049f4e94a5fd595db3870c3886d2ef88a5a3acb037b7e0a13555" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T15:28:55.848243670+08:00" level=error msg="loading cgroup for 402272" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T15:28:55.849946530+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e88e36123001 ep=lm-architecture-5395aef4f16e6c1f9114 net=none nid=f13f14be1124 +time="2026-10-05T15:35:40.955227447+08:00" level=info msg="received task-delete event from containerd" container=3b278b0907ad93e6d3f8358c82c8a0aa0497235642bf72eb0a5e3a38c2bc3ea8 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T15:35:40.955826933+08:00" level=info msg="shim disconnected" id=3b278b0907ad93e6d3f8358c82c8a0aa0497235642bf72eb0a5e3a38c2bc3ea8 namespace=moby +time="2026-10-05T15:35:40.958054340+08:00" level=info msg="cleaning up after shim disconnected" id=3b278b0907ad93e6d3f8358c82c8a0aa0497235642bf72eb0a5e3a38c2bc3ea8 namespace=moby +time="2026-10-05T15:35:40.958062853+08:00" level=info msg="cleaning up dead shim" id=3b278b0907ad93e6d3f8358c82c8a0aa0497235642bf72eb0a5e3a38c2bc3ea8 namespace=moby +time="2026-10-05T15:35:41.200458174+08:00" level=info msg="connecting to shim 408f9b595ad6a81ad08a08913a571fdd6fec1b08657e39982ba90ab5961d8dba" address="unix:///run/containerd/s/7ad5899454e834dc0e6f60e22d27b9e5105db64f7d5634ec7caf579d8ff1bf5f" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T15:35:41.317777194+08:00" level=error msg="loading cgroup for 405517" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T15:35:41.320481240+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=2853a20cd605 ep=lm-architecture-1e573385491f7985f05d net=none nid=f13f14be1124 +time="2026-10-05T16:38:54.831900627+08:00" level=info msg="received task-delete event from containerd" container=2b7a8055ea7c1550f70d954041f59242542045ec46e8fb92912a4e391e2dd31b module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T16:38:54.832036856+08:00" level=info msg="shim disconnected" id=2b7a8055ea7c1550f70d954041f59242542045ec46e8fb92912a4e391e2dd31b namespace=moby +time="2026-10-05T16:38:54.834721955+08:00" level=info msg="cleaning up after shim disconnected" id=2b7a8055ea7c1550f70d954041f59242542045ec46e8fb92912a4e391e2dd31b namespace=moby +time="2026-10-05T16:38:54.834729233+08:00" level=info msg="cleaning up dead shim" id=2b7a8055ea7c1550f70d954041f59242542045ec46e8fb92912a4e391e2dd31b namespace=moby +time="2026-10-05T16:38:57.879625781+08:00" level=info msg="connecting to shim e105c9807fbd2fe329e7c58f5766c1cc0689cbbce09c04709efb07de37c70f31" address="unix:///run/containerd/s/5ec4f4d91c6a381e5fb27e93a6f595792da69646b06b7bd1b2460941508688c6" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T16:38:58.003142074+08:00" level=error msg="loading cgroup for 433965" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T16:38:58.005223234+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=da9f238b5a49 ep=lm-architecture-61af1141bc3e19bad789 net=none nid=f13f14be1124 +time="2026-10-05T20:19:11.313571555+08:00" level=info msg="received task-delete event from containerd" container=9c0d0acbc5d1e8795767fe68b0d5ac5d803bcaab60aaa7bf598a7dcabf30462a module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T20:19:11.313610908+08:00" level=info msg="shim disconnected" id=9c0d0acbc5d1e8795767fe68b0d5ac5d803bcaab60aaa7bf598a7dcabf30462a namespace=moby +time="2026-10-05T20:19:11.365496660+08:00" level=info msg="cleaning up after shim disconnected" id=9c0d0acbc5d1e8795767fe68b0d5ac5d803bcaab60aaa7bf598a7dcabf30462a namespace=moby +time="2026-10-05T20:19:11.365511240+08:00" level=info msg="cleaning up dead shim" id=9c0d0acbc5d1e8795767fe68b0d5ac5d803bcaab60aaa7bf598a7dcabf30462a namespace=moby +time="2026-10-05T20:19:13.656247614+08:00" level=info msg="connecting to shim d6c7191d8045babda1cc4d6c63ae00d5b64ab41ed9be3e59e92dfc85a03060d4" address="unix:///run/containerd/s/7fbb7b818c9d81b4ef0819408bacb8b330611fe8b07d522c1f22271410aa6406" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T20:19:13.761088531+08:00" level=error msg="loading cgroup for 7774" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T20:19:13.762767701+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=1da1438bdd53 ep=lm-architecture-22f926e5640fbb6c65d8 net=none nid=f13f14be1124 +time="2026-10-05T20:20:02.729234864+08:00" level=info msg="shim disconnected" id=3dd59509d033abf8833b02e2131b382f319fc17a1e763dfc6b18649a7cd7318e namespace=moby +time="2026-10-05T20:20:02.729276963+08:00" level=info msg="cleaning up after shim disconnected" id=3dd59509d033abf8833b02e2131b382f319fc17a1e763dfc6b18649a7cd7318e namespace=moby +time="2026-10-05T20:20:02.729285137+08:00" level=info msg="cleaning up dead shim" id=3dd59509d033abf8833b02e2131b382f319fc17a1e763dfc6b18649a7cd7318e namespace=moby +time="2026-10-05T20:20:02.729335024+08:00" level=info msg="received task-delete event from containerd" container=3dd59509d033abf8833b02e2131b382f319fc17a1e763dfc6b18649a7cd7318e module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T20:20:03.216762409+08:00" level=info msg="connecting to shim 3a6498b6ae310e6444e8db2aef8d3ca4ddba9b34bfffabf47ecdb00bcd70074a" address="unix:///run/containerd/s/54fb9a40b24ea6e9485d4f4aeeadf43f8a9ffb67b5f09094ad09e55b607bdc92" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T20:20:03.320594651+08:00" level=error msg="loading cgroup for 9068" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T20:20:03.322539402+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e8e720e28cd3 ep=lm-architecture-b0c446785992c228e5c2 net=none nid=f13f14be1124 +time="2026-10-05T23:03:30.216801186+08:00" level=info msg="received task-delete event from containerd" container=d26dcad2c2c311fb59ee24febe5ff9863566995d841e38e281629c62b7474cae module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-05T23:03:30.216827593+08:00" level=info msg="shim disconnected" id=d26dcad2c2c311fb59ee24febe5ff9863566995d841e38e281629c62b7474cae namespace=moby +time="2026-10-05T23:03:30.219658983+08:00" level=info msg="cleaning up after shim disconnected" id=d26dcad2c2c311fb59ee24febe5ff9863566995d841e38e281629c62b7474cae namespace=moby +time="2026-10-05T23:03:30.219666254+08:00" level=info msg="cleaning up dead shim" id=d26dcad2c2c311fb59ee24febe5ff9863566995d841e38e281629c62b7474cae namespace=moby +time="2026-10-05T23:03:31.127214932+08:00" level=info msg="connecting to shim 63b33962ff8d36a5d839b8bafd0633ab2a5288e9252007a35542123cbf53310f" address="unix:///run/containerd/s/13c31a4450f52759da315f5c77cfd534d4a6f8efabe2b1f3f6a23599d9a8d350" namespace=moby protocol=ttrpc version=3 +time="2026-10-05T23:03:31.231891964+08:00" level=error msg="loading cgroup for 81121" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-05T23:03:31.233399809+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=0f5f2c8845a3 ep=lm-architecture-beeeec3d46986483b71d net=none nid=f13f14be1124 +time="2026-10-06T01:47:09.865942878+08:00" level=info msg="shim disconnected" id=5a3be56030b53bbe2c2ac955cf49f49047a18ff6a74158afd9eb25fd9e924dee namespace=moby +time="2026-10-06T01:47:09.866031977+08:00" level=info msg="received task-delete event from containerd" container=5a3be56030b53bbe2c2ac955cf49f49047a18ff6a74158afd9eb25fd9e924dee module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T01:47:09.875632805+08:00" level=info msg="cleaning up after shim disconnected" id=5a3be56030b53bbe2c2ac955cf49f49047a18ff6a74158afd9eb25fd9e924dee namespace=moby +time="2026-10-06T01:47:09.875647474+08:00" level=info msg="cleaning up dead shim" id=5a3be56030b53bbe2c2ac955cf49f49047a18ff6a74158afd9eb25fd9e924dee namespace=moby +time="2026-10-06T01:47:11.110194215+08:00" level=info msg="connecting to shim 43725bf68f3c27cde427818eff0ed077e38ee67450a6563dfc43779b74f01a4e" address="unix:///run/containerd/s/6a7348bb16ba2e9c0e4f0fd55e9a5929020816fed3e02c3260cbf52792510709" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T01:47:11.227097185+08:00" level=error msg="loading cgroup for 154456" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T01:47:11.228934258+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=103174dd88ff ep=lm-architecture-70969259f23e4245f265 net=none nid=f13f14be1124 +time="2026-10-06T03:15:12.189104282+08:00" level=info msg="shim disconnected" id=d6c7191d8045babda1cc4d6c63ae00d5b64ab41ed9be3e59e92dfc85a03060d4 namespace=moby +time="2026-10-06T03:15:12.189118130+08:00" level=info msg="received task-delete event from containerd" container=d6c7191d8045babda1cc4d6c63ae00d5b64ab41ed9be3e59e92dfc85a03060d4 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T03:15:12.191880217+08:00" level=info msg="cleaning up after shim disconnected" id=d6c7191d8045babda1cc4d6c63ae00d5b64ab41ed9be3e59e92dfc85a03060d4 namespace=moby +time="2026-10-06T03:15:12.191892253+08:00" level=info msg="cleaning up dead shim" id=d6c7191d8045babda1cc4d6c63ae00d5b64ab41ed9be3e59e92dfc85a03060d4 namespace=moby +time="2026-10-06T03:15:14.375350202+08:00" level=info msg="connecting to shim d15d72339973e2190140bb25cc79130d7c194f2931f6e44366e2c270dcf4bca4" address="unix:///run/containerd/s/ee3a551335adf9919acf317caf057adb950f8dd1789a5a82587d2f500ea7d6d9" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T03:15:14.483865529+08:00" level=error msg="loading cgroup for 196568" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T03:15:14.485630850+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=60a7556c5ad3 ep=lm-architecture-6b18429bca7828ff495c net=none nid=f13f14be1124 +time="2026-10-06T03:15:22.730465392+08:00" level=info msg="shim disconnected" id=3a6498b6ae310e6444e8db2aef8d3ca4ddba9b34bfffabf47ecdb00bcd70074a namespace=moby +time="2026-10-06T03:15:22.730511487+08:00" level=info msg="cleaning up after shim disconnected" id=3a6498b6ae310e6444e8db2aef8d3ca4ddba9b34bfffabf47ecdb00bcd70074a namespace=moby +time="2026-10-06T03:15:22.730516537+08:00" level=info msg="received task-delete event from containerd" container=3a6498b6ae310e6444e8db2aef8d3ca4ddba9b34bfffabf47ecdb00bcd70074a module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T03:15:22.730519760+08:00" level=info msg="cleaning up dead shim" id=3a6498b6ae310e6444e8db2aef8d3ca4ddba9b34bfffabf47ecdb00bcd70074a namespace=moby +time="2026-10-06T03:15:23.829789644+08:00" level=info msg="connecting to shim 5afd787967f0d45894b594bfd72c7c8fc0a25732a630a25e0c80fba98f871a6a" address="unix:///run/containerd/s/64333be07311224966d6bc81663f7f817df7338fe3e28046ffb460c84ce5ff3f" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T03:15:23.976762543+08:00" level=error msg="loading cgroup for 196996" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T03:15:23.982003679+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=44a69463ef3f ep=lm-architecture-3697bc2d256212595af1 net=none nid=f13f14be1124 +time="2026-10-06T04:51:08.150740244+08:00" level=info msg="connecting to shim f66fa31ec73cc7e2de6004a41d9357baccfa71bd9b589efb4663c86e9979fc12" address="unix:///run/containerd/s/e29a145bfa985e6586c9085fb6d017db4cc0f4d8c6a397d34d3eb9d78353ddad" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T04:51:08.205333296+08:00" level=error msg="loading cgroup for 250404" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T04:51:08.206849217+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=662c7fed3453 ep=lm-capacity-cpu-preflight-20261006 net=none nid=f13f14be1124 +time="2026-10-06T04:51:16.694179384+08:00" level=info msg="received task-delete event from containerd" container=f66fa31ec73cc7e2de6004a41d9357baccfa71bd9b589efb4663c86e9979fc12 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T04:51:16.694195865+08:00" level=info msg="shim disconnected" id=f66fa31ec73cc7e2de6004a41d9357baccfa71bd9b589efb4663c86e9979fc12 namespace=moby +time="2026-10-06T04:51:16.694240955+08:00" level=info msg="cleaning up after shim disconnected" id=f66fa31ec73cc7e2de6004a41d9357baccfa71bd9b589efb4663c86e9979fc12 namespace=moby +time="2026-10-06T04:51:16.694250450+08:00" level=info msg="cleaning up dead shim" id=f66fa31ec73cc7e2de6004a41d9357baccfa71bd9b589efb4663c86e9979fc12 namespace=moby +time="2026-10-06T04:54:16.730243609+08:00" level=info msg="connecting to shim c3d7c07a216da11f86205b86b9b93f2d347092240a8e32ab796576be59eeed38" address="unix:///run/containerd/s/ad041de2e9aaaff7c4de3faa831074a424ae32c400c4713e05b56f9509191d38" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T04:54:16.848446473+08:00" level=error msg="loading cgroup for 252301" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T04:54:16.849994234+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=13cac55e3716 ep=lm-capacity-cpu-preflight-v2-20261006 net=none nid=f13f14be1124 +time="2026-10-06T04:54:25.253832863+08:00" level=info msg="received task-delete event from containerd" container=c3d7c07a216da11f86205b86b9b93f2d347092240a8e32ab796576be59eeed38 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T04:54:25.253848378+08:00" level=info msg="shim disconnected" id=c3d7c07a216da11f86205b86b9b93f2d347092240a8e32ab796576be59eeed38 namespace=moby +time="2026-10-06T04:54:25.253893324+08:00" level=info msg="cleaning up after shim disconnected" id=c3d7c07a216da11f86205b86b9b93f2d347092240a8e32ab796576be59eeed38 namespace=moby +time="2026-10-06T04:54:25.253900407+08:00" level=info msg="cleaning up dead shim" id=c3d7c07a216da11f86205b86b9b93f2d347092240a8e32ab796576be59eeed38 namespace=moby +time="2026-10-06T05:02:24.981640917+08:00" level=info msg="connecting to shim e8d9043154cfb2164b8b06c56cd9af1e9251baf597339c401b835c5dc64541bb" address="unix:///run/containerd/s/84892d15717bf9827c7841e326e61053606eb6694bc50fe53849854214cceb94" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T05:02:25.085860712+08:00" level=error msg="loading cgroup for 259662" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T05:02:25.087275054+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=5d3c3b9ade79 ep=lm-capacity-df8a760964b843697dc2 net=none nid=f13f14be1124 +time="2026-10-06T05:02:25.292070346+08:00" level=info msg="connecting to shim a7e03368c3084483ae5d7c6c2f6104b42dee98a5673296515b98755f1f88548a" address="unix:///run/containerd/s/1f43937baa170eaff87ad485e85511d200d9b562d91de7b506b543effa13a87c" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T05:02:25.391280649+08:00" level=error msg="loading cgroup for 259924" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T05:02:25.393121461+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=0760eafa053f ep=lm-capacity-ec8d7880e4a5fae80e95 net=none nid=f13f14be1124 +time="2026-10-06T05:03:07.403805596+08:00" level=info msg="received task-delete event from containerd" container=e8d9043154cfb2164b8b06c56cd9af1e9251baf597339c401b835c5dc64541bb module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T05:03:07.403826208+08:00" level=info msg="shim disconnected" id=e8d9043154cfb2164b8b06c56cd9af1e9251baf597339c401b835c5dc64541bb namespace=moby +time="2026-10-06T05:03:07.403865737+08:00" level=info msg="cleaning up after shim disconnected" id=e8d9043154cfb2164b8b06c56cd9af1e9251baf597339c401b835c5dc64541bb namespace=moby +time="2026-10-06T05:03:07.403872774+08:00" level=info msg="cleaning up dead shim" id=e8d9043154cfb2164b8b06c56cd9af1e9251baf597339c401b835c5dc64541bb namespace=moby +time="2026-10-06T05:03:07.540182692+08:00" level=info msg="shim disconnected" id=a7e03368c3084483ae5d7c6c2f6104b42dee98a5673296515b98755f1f88548a namespace=moby +time="2026-10-06T05:03:07.540226519+08:00" level=info msg="cleaning up after shim disconnected" id=a7e03368c3084483ae5d7c6c2f6104b42dee98a5673296515b98755f1f88548a namespace=moby +time="2026-10-06T05:03:07.540216952+08:00" level=info msg="received task-delete event from containerd" container=a7e03368c3084483ae5d7c6c2f6104b42dee98a5673296515b98755f1f88548a module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T05:03:07.540233821+08:00" level=info msg="cleaning up dead shim" id=a7e03368c3084483ae5d7c6c2f6104b42dee98a5673296515b98755f1f88548a namespace=moby +time="2026-10-06T05:03:18.149450919+08:00" level=info msg="connecting to shim f020e5050fe1c0ac8b07737622d14b84fab2289aea785abedbfce064630c1237" address="unix:///run/containerd/s/63c02781beecd1e248ae3fb68bbb0e0e08c37d067583866c68b14a563650c40d" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T05:03:18.255338836+08:00" level=error msg="loading cgroup for 261337" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T05:03:18.256822832+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=4ea73f460eb7 ep=lm-capacity-c29110f6bae08c80afca net=none nid=f13f14be1124 +time="2026-10-06T05:05:02.100238529+08:00" level=info msg="received task-delete event from containerd" container=f020e5050fe1c0ac8b07737622d14b84fab2289aea785abedbfce064630c1237 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T05:05:02.100257995+08:00" level=info msg="shim disconnected" id=f020e5050fe1c0ac8b07737622d14b84fab2289aea785abedbfce064630c1237 namespace=moby +time="2026-10-06T05:05:02.103082232+08:00" level=info msg="cleaning up after shim disconnected" id=f020e5050fe1c0ac8b07737622d14b84fab2289aea785abedbfce064630c1237 namespace=moby +time="2026-10-06T05:05:02.103089888+08:00" level=info msg="cleaning up dead shim" id=f020e5050fe1c0ac8b07737622d14b84fab2289aea785abedbfce064630c1237 namespace=moby +time="2026-10-06T05:14:57.407498222+08:00" level=info msg="connecting to shim e0724e8181cc5cbd6e54978d5c9a95bcba319c76ac55f0a30ac77a37dd97c3cd" address="unix:///run/containerd/s/d833ce586cd0643ccec0e271501f6f4283490a35367d573cc1beebfae169998a" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T05:14:57.528006545+08:00" level=error msg="loading cgroup for 269245" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T05:14:57.529559324+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=12d79b20cdf8 ep=lm-capacity-3791e828481af9ec0656 net=none nid=f13f14be1124 +time="2026-10-06T05:14:57.922083072+08:00" level=info msg="connecting to shim 3a5d8f97d679965fd80f4b5268f3a0428ed246e5cd94f8c0203868f27fc46e9b" address="unix:///run/containerd/s/dca4e2dee2b9c66717b93d6a58a6fbf43567ca17ed2f77c45d7b587d6380c1ce" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T05:14:58.030402202+08:00" level=error msg="loading cgroup for 269514" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T05:14:58.032061993+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=42a7e6034e08 ep=lm-capacity-9c8dadd0fdab0c6973c0 net=none nid=f13f14be1124 +time="2026-10-06T05:19:18.200769424+08:00" level=info msg="received task-delete event from containerd" container=e0724e8181cc5cbd6e54978d5c9a95bcba319c76ac55f0a30ac77a37dd97c3cd module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T05:19:18.200787389+08:00" level=info msg="shim disconnected" id=e0724e8181cc5cbd6e54978d5c9a95bcba319c76ac55f0a30ac77a37dd97c3cd namespace=moby +time="2026-10-06T05:19:18.203612982+08:00" level=info msg="cleaning up after shim disconnected" id=e0724e8181cc5cbd6e54978d5c9a95bcba319c76ac55f0a30ac77a37dd97c3cd namespace=moby +time="2026-10-06T05:19:18.203620356+08:00" level=info msg="cleaning up dead shim" id=e0724e8181cc5cbd6e54978d5c9a95bcba319c76ac55f0a30ac77a37dd97c3cd namespace=moby +time="2026-10-06T05:19:19.744852599+08:00" level=info msg="connecting to shim 6e77e5b62db334c4acdf87c14d2875dc830f03a51b60e39829058cbc7c7e85d3" address="unix:///run/containerd/s/246dd1bc41799a5a026706600f21b9ea9a30e9678be419bf8728158363787750" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T05:19:19.850294735+08:00" level=error msg="loading cgroup for 272333" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T05:19:19.852210044+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=7cd87ad6e4ee ep=lm-capacity-c6ea239e6918a1739330 net=none nid=f13f14be1124 +time="2026-10-06T05:28:48.298198745+08:00" level=info msg="received task-delete event from containerd" container=3a5d8f97d679965fd80f4b5268f3a0428ed246e5cd94f8c0203868f27fc46e9b module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T05:28:48.298356153+08:00" level=info msg="shim disconnected" id=3a5d8f97d679965fd80f4b5268f3a0428ed246e5cd94f8c0203868f27fc46e9b namespace=moby +time="2026-10-06T05:28:48.301044208+08:00" level=info msg="cleaning up after shim disconnected" id=3a5d8f97d679965fd80f4b5268f3a0428ed246e5cd94f8c0203868f27fc46e9b namespace=moby +time="2026-10-06T05:28:48.301052164+08:00" level=info msg="cleaning up dead shim" id=3a5d8f97d679965fd80f4b5268f3a0428ed246e5cd94f8c0203868f27fc46e9b namespace=moby +time="2026-10-06T06:11:38.319521242+08:00" level=info msg="received task-delete event from containerd" container=6e77e5b62db334c4acdf87c14d2875dc830f03a51b60e39829058cbc7c7e85d3 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T06:11:38.319568045+08:00" level=info msg="shim disconnected" id=6e77e5b62db334c4acdf87c14d2875dc830f03a51b60e39829058cbc7c7e85d3 namespace=moby +time="2026-10-06T06:11:38.322930916+08:00" level=info msg="cleaning up after shim disconnected" id=6e77e5b62db334c4acdf87c14d2875dc830f03a51b60e39829058cbc7c7e85d3 namespace=moby +time="2026-10-06T06:11:38.322938910+08:00" level=info msg="cleaning up dead shim" id=6e77e5b62db334c4acdf87c14d2875dc830f03a51b60e39829058cbc7c7e85d3 namespace=moby +time="2026-10-06T06:12:02.947258891+08:00" level=info msg="connecting to shim 14abbc1f25849911a5d1381d7b42e752c7b359d856f5f35fb38d039054914ca7" address="unix:///run/containerd/s/a9f784134d0206b4d9689d0cff4e58731dae35c75832ce9148d4856a9b89d572" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T06:12:03.059387292+08:00" level=error msg="loading cgroup for 297228" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T06:12:03.061550276+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=bf291c965a4e ep=lm-capacity-612c7940d2295bb98106 net=none nid=f13f14be1124 +time="2026-10-06T06:12:03.261501680+08:00" level=info msg="connecting to shim e5bdb78f3019141f2607fc1001df323c366e058cde83fec514eb09a0270c3e55" address="unix:///run/containerd/s/0b3130cf98b09b7d732a6c67465732a234918bb90dc8c10c413af50b81b0707a" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T06:12:03.364654415+08:00" level=error msg="loading cgroup for 297492" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T06:12:03.366242923+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=5f04d0ddb6a1 ep=lm-capacity-153a8cef9c6dd06501de net=none nid=f13f14be1124 +time="2026-10-06T06:14:56.695874002+08:00" level=info msg="received task-delete event from containerd" container=14abbc1f25849911a5d1381d7b42e752c7b359d856f5f35fb38d039054914ca7 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T06:14:56.696005559+08:00" level=info msg="shim disconnected" id=14abbc1f25849911a5d1381d7b42e752c7b359d856f5f35fb38d039054914ca7 namespace=moby +time="2026-10-06T06:14:56.698826533+08:00" level=info msg="cleaning up after shim disconnected" id=14abbc1f25849911a5d1381d7b42e752c7b359d856f5f35fb38d039054914ca7 namespace=moby +time="2026-10-06T06:14:56.698841038+08:00" level=info msg="cleaning up dead shim" id=14abbc1f25849911a5d1381d7b42e752c7b359d856f5f35fb38d039054914ca7 namespace=moby +time="2026-10-06T06:14:59.421269053+08:00" level=info msg="connecting to shim fc2e0d17fe8424f4ff95b3336ae83d14c965e808d43504a983617f4ed6f7c549" address="unix:///run/containerd/s/83809abf481b5dbc707c58c37c7a98e9a7e8d4f67527365266ed3ccf4978a7c0" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T06:14:59.530984686+08:00" level=error msg="loading cgroup for 299272" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T06:14:59.532675560+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=f1c25cb2e9ce ep=lm-capacity-678c92b2a9717bd60611 net=none nid=f13f14be1124 +time="2026-10-06T06:19:24.462313823+08:00" level=info msg="shim disconnected" id=e5bdb78f3019141f2607fc1001df323c366e058cde83fec514eb09a0270c3e55 namespace=moby +time="2026-10-06T06:19:24.465175902+08:00" level=info msg="cleaning up after shim disconnected" id=e5bdb78f3019141f2607fc1001df323c366e058cde83fec514eb09a0270c3e55 namespace=moby +time="2026-10-06T06:19:24.465184710+08:00" level=info msg="cleaning up dead shim" id=e5bdb78f3019141f2607fc1001df323c366e058cde83fec514eb09a0270c3e55 namespace=moby +time="2026-10-06T06:27:03.705597106+08:00" level=info msg="received task-delete event from containerd" container=e105c9807fbd2fe329e7c58f5766c1cc0689cbbce09c04709efb07de37c70f31 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T06:27:03.705731239+08:00" level=info msg="shim disconnected" id=e105c9807fbd2fe329e7c58f5766c1cc0689cbbce09c04709efb07de37c70f31 namespace=moby +time="2026-10-06T06:27:03.708403804+08:00" level=info msg="cleaning up after shim disconnected" id=e105c9807fbd2fe329e7c58f5766c1cc0689cbbce09c04709efb07de37c70f31 namespace=moby +time="2026-10-06T06:27:03.708413082+08:00" level=info msg="cleaning up dead shim" id=e105c9807fbd2fe329e7c58f5766c1cc0689cbbce09c04709efb07de37c70f31 namespace=moby +time="2026-10-06T06:41:05.318545489+08:00" level=info msg="received task-delete event from containerd" container=fc2e0d17fe8424f4ff95b3336ae83d14c965e808d43504a983617f4ed6f7c549 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T06:41:05.319021239+08:00" level=info msg="shim disconnected" id=fc2e0d17fe8424f4ff95b3336ae83d14c965e808d43504a983617f4ed6f7c549 namespace=moby +time="2026-10-06T06:41:05.321418386+08:00" level=info msg="cleaning up after shim disconnected" id=fc2e0d17fe8424f4ff95b3336ae83d14c965e808d43504a983617f4ed6f7c549 namespace=moby +time="2026-10-06T06:41:05.321428248+08:00" level=info msg="cleaning up dead shim" id=fc2e0d17fe8424f4ff95b3336ae83d14c965e808d43504a983617f4ed6f7c549 namespace=moby +time="2026-10-06T07:12:10.165875629+08:00" level=info msg="connecting to shim 20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97" address="unix:///run/containerd/s/b28f5b96e77cee4a27467913d51eba6bd3b6a00695ccb34954208477b724f3d8" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:10.294961571+08:00" level=error msg="loading cgroup for 329253" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:10.298734411+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=3fcbeee5502d ep=lm-capctrl-120230e909823c33db81 net=none nid=f13f14be1124 +time="2026-10-06T07:12:10.488071169+08:00" level=info msg="connecting to shim acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70" address="unix:///run/containerd/s/a3165ee5af5f339b251da7ec31015966675f4acecf91bc90160646e49487f7d9" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:10.603541062+08:00" level=error msg="loading cgroup for 329520" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:10.605120462+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=08eab553ccaa ep=lm-capctrl-7bf5d747156264dfa65e net=none nid=f13f14be1124 +time="2026-10-06T07:12:20.925097825+08:00" level=info msg="received task-delete event from containerd" container=acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:20.925112548+08:00" level=info msg="shim disconnected" id=acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70 namespace=moby +time="2026-10-06T07:12:20.925160807+08:00" level=info msg="cleaning up after shim disconnected" id=acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70 namespace=moby +time="2026-10-06T07:12:20.925167902+08:00" level=info msg="cleaning up dead shim" id=acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70 namespace=moby +time="2026-10-06T07:12:20.955606125+08:00" level=info msg="received task-delete event from containerd" container=20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:20.955625977+08:00" level=info msg="shim disconnected" id=20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97 namespace=moby +time="2026-10-06T07:12:20.955665235+08:00" level=info msg="cleaning up after shim disconnected" id=20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97 namespace=moby +time="2026-10-06T07:12:20.955672549+08:00" level=info msg="cleaning up dead shim" id=20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97 namespace=moby +time="2026-10-06T07:12:23.457335344+08:00" level=info msg="connecting to shim c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2" address="unix:///run/containerd/s/1a7e2edef26ccfaa7e6e384cfe00d8088e9ca5fb16182b094b57bbbc6f6bae04" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:23.561229953+08:00" level=error msg="loading cgroup for 330181" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:23.562922437+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=2b879a3aaa9f ep=lm-capctrl-5e44ff448d062e3cc30b net=none nid=f13f14be1124 +time="2026-10-06T07:12:23.775610792+08:00" level=info msg="connecting to shim a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928" address="unix:///run/containerd/s/b7a4569aff4bfefcd376ef8be34be0f6c40e8afac0513e0c9ff24bc32d40c8e7" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:23.914745733+08:00" level=error msg="loading cgroup for 330450" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:23.916504003+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=f84b1907fd54 ep=lm-capctrl-9c188e9c2416b6bf3968 net=none nid=f13f14be1124 +time="2026-10-06T07:12:32.465795665+08:00" level=info msg="shim disconnected" id=c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2 namespace=moby +time="2026-10-06T07:12:32.465795533+08:00" level=info msg="received task-delete event from containerd" container=c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:32.465836128+08:00" level=info msg="cleaning up after shim disconnected" id=c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2 namespace=moby +time="2026-10-06T07:12:32.465848777+08:00" level=info msg="cleaning up dead shim" id=c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2 namespace=moby +time="2026-10-06T07:12:32.668292675+08:00" level=info msg="received task-delete event from containerd" container=a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:32.668423674+08:00" level=info msg="shim disconnected" id=a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928 namespace=moby +time="2026-10-06T07:12:32.673806601+08:00" level=info msg="cleaning up after shim disconnected" id=a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928 namespace=moby +time="2026-10-06T07:12:32.673819875+08:00" level=info msg="cleaning up dead shim" id=a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928 namespace=moby +time="2026-10-06T07:12:33.273041821+08:00" level=info msg="connecting to shim 036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f" address="unix:///run/containerd/s/72121f58210c2dcda21571ed9b00134de185c20be4cfd236a7bf3018934127ef" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:33.422445651+08:00" level=error msg="loading cgroup for 331150" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:33.424477397+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=c892aabb83e9 ep=lm-capctrl-f9feedb005b3ee517fb1 net=none nid=f13f14be1124 +time="2026-10-06T07:12:33.583634277+08:00" level=info msg="connecting to shim a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc" address="unix:///run/containerd/s/c6dc2ec04667ef07fa2f991a6a252f2f80b76f8070703a63b4c9faab346a062d" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:33.683644091+08:00" level=error msg="loading cgroup for 331413" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:33.685198650+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=fc11411cc937 ep=lm-capctrl-dbed9797167a62712648 net=none nid=f13f14be1124 +time="2026-10-06T07:12:41.728957485+08:00" level=info msg="shim disconnected" id=036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f namespace=moby +time="2026-10-06T07:12:41.729007433+08:00" level=info msg="cleaning up after shim disconnected" id=036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f namespace=moby +time="2026-10-06T07:12:41.729015432+08:00" level=info msg="cleaning up dead shim" id=036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f namespace=moby +time="2026-10-06T07:12:41.729075802+08:00" level=info msg="received task-delete event from containerd" container=036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:43.038168604+08:00" level=info msg="connecting to shim 3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee" address="unix:///run/containerd/s/0fe85a7809a070e12b18209dc906fd9faf22b2286840b8e80f712e81008ada76" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:43.145994788+08:00" level=error msg="loading cgroup for 331974" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:43.147996308+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=b5e5971c5761 ep=lm-capctrl-56b7e90dc1de119843b5 net=none nid=f13f14be1124 +time="2026-10-06T07:12:43.588646506+08:00" level=info msg="shim disconnected" id=a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc namespace=moby +time="2026-10-06T07:12:43.588691801+08:00" level=info msg="cleaning up after shim disconnected" id=a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc namespace=moby +time="2026-10-06T07:12:43.588676774+08:00" level=info msg="received task-delete event from containerd" container=a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:43.588699135+08:00" level=info msg="cleaning up dead shim" id=a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc namespace=moby +time="2026-10-06T07:12:46.442314551+08:00" level=info msg="connecting to shim 4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6" address="unix:///run/containerd/s/ccb6e934a8325287c9e3ed07c560852673f12195c906ab796e5ff0baf9412014" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:46.553128723+08:00" level=error msg="loading cgroup for 332340" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:46.555319460+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=ba78fba9a215 ep=lm-capctrl-1b15a443f45548326e60 net=none nid=f13f14be1124 +time="2026-10-06T07:12:50.708344500+08:00" level=info msg="received task-delete event from containerd" container=3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:50.708524489+08:00" level=info msg="shim disconnected" id=3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee namespace=moby +time="2026-10-06T07:12:50.712466987+08:00" level=info msg="cleaning up after shim disconnected" id=3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee namespace=moby +time="2026-10-06T07:12:50.712474761+08:00" level=info msg="cleaning up dead shim" id=3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee namespace=moby +time="2026-10-06T07:12:52.864339057+08:00" level=info msg="connecting to shim 03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da" address="unix:///run/containerd/s/2de722257acd969bd40e586291818c4be2f0cdaba32cebeb555cc2942108977e" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:52.978604903+08:00" level=error msg="loading cgroup for 332748" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:52.980233017+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=7d465b5327e9 ep=lm-capctrl-cd5bd422b84e4fd7c337 net=none nid=f13f14be1124 +time="2026-10-06T07:12:54.655995081+08:00" level=info msg="shim disconnected" id=4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6 namespace=moby +time="2026-10-06T07:12:54.656034547+08:00" level=info msg="cleaning up after shim disconnected" id=4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6 namespace=moby +time="2026-10-06T07:12:54.656028844+08:00" level=info msg="received task-delete event from containerd" container=4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:12:54.656042092+08:00" level=info msg="cleaning up dead shim" id=4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6 namespace=moby +time="2026-10-06T07:12:56.258909744+08:00" level=info msg="connecting to shim 0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046" address="unix:///run/containerd/s/225a7cd8e49170628437036cf30005596e8eb88e55e7cc2337e03a85d0bec85b" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:12:56.365477095+08:00" level=error msg="loading cgroup for 333110" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:12:56.367427476+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=4dd44480acef ep=lm-capctrl-8eee2eeac5c3dc74faa0 net=none nid=f13f14be1124 +time="2026-10-06T07:13:02.734442080+08:00" level=info msg="shim disconnected" id=03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da namespace=moby +time="2026-10-06T07:13:02.734461459+08:00" level=info msg="received task-delete event from containerd" container=03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:13:02.734480345+08:00" level=info msg="cleaning up after shim disconnected" id=03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da namespace=moby +time="2026-10-06T07:13:02.734497124+08:00" level=info msg="cleaning up dead shim" id=03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da namespace=moby +time="2026-10-06T07:13:05.720788936+08:00" level=info msg="connecting to shim 58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7" address="unix:///run/containerd/s/a27f879a1906faf1ed1271eb1a228832797fddbcfcb1cc070a9ac6af167cb7fd" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:13:05.828949393+08:00" level=error msg="loading cgroup for 333525" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:13:05.830592650+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=3188d54a9e4c ep=lm-capctrl-dbb34e5665d728349515 net=none nid=f13f14be1124 +time="2026-10-06T07:13:56.688243384+08:00" level=info msg="shim disconnected" id=0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046 namespace=moby +time="2026-10-06T07:13:56.688272156+08:00" level=info msg="received task-delete event from containerd" container=0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:13:56.688289796+08:00" level=info msg="cleaning up after shim disconnected" id=0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046 namespace=moby +time="2026-10-06T07:13:56.688312332+08:00" level=info msg="cleaning up dead shim" id=0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046 namespace=moby +time="2026-10-06T07:13:57.661952216+08:00" level=info msg="connecting to shim ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78" address="unix:///run/containerd/s/f64f47fde74383ffc549773221592806bb2a7a52c996ef0180ecfd5b8c26d3dd" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:13:57.767023911+08:00" level=error msg="loading cgroup for 334572" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:13:57.768535528+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=127b4788dcdc ep=lm-capctrl-efac2daf2e15820debe1 net=none nid=f13f14be1124 +time="2026-10-06T07:14:41.106778340+08:00" level=info msg="received task-delete event from containerd" container=58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:14:41.106803976+08:00" level=info msg="shim disconnected" id=58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7 namespace=moby +time="2026-10-06T07:14:41.106855258+08:00" level=info msg="cleaning up after shim disconnected" id=58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7 namespace=moby +time="2026-10-06T07:14:41.106862901+08:00" level=info msg="cleaning up dead shim" id=58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7 namespace=moby +time="2026-10-06T07:14:43.479407338+08:00" level=info msg="connecting to shim 0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb" address="unix:///run/containerd/s/80fe2a4233ceb501a7797c9b3a6cfca0250cee240e05946d41e1e648705a8bf7" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:14:43.587483169+08:00" level=error msg="loading cgroup for 335597" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:14:43.588974290+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=cce65373dcfe ep=lm-capctrl-851b87d2df399fa8e0e2 net=none nid=f13f14be1124 +time="2026-10-06T07:16:08.089440378+08:00" level=info msg="received task-delete event from containerd" container=ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:16:08.089587951+08:00" level=info msg="shim disconnected" id=ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78 namespace=moby +time="2026-10-06T07:16:08.137657737+08:00" level=info msg="cleaning up after shim disconnected" id=ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78 namespace=moby +time="2026-10-06T07:16:08.137685183+08:00" level=info msg="cleaning up dead shim" id=ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78 namespace=moby +time="2026-10-06T07:16:09.317026195+08:00" level=info msg="connecting to shim 1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df" address="unix:///run/containerd/s/d022cb2bd7b8e6026c1103d716d798427a0463518f224615a3850eb5ea78e772" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:16:09.442587481+08:00" level=error msg="loading cgroup for 336937" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:16:09.444239734+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=9f8f70b87ebd ep=lm-capctrl-063ec7692b7ddc21e0be net=none nid=f13f14be1124 +time="2026-10-06T07:18:44.716673214+08:00" level=info msg="received task-delete event from containerd" container=0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:18:44.716705892+08:00" level=info msg="shim disconnected" id=0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb namespace=moby +time="2026-10-06T07:18:44.740837852+08:00" level=info msg="cleaning up after shim disconnected" id=0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb namespace=moby +time="2026-10-06T07:18:44.740856163+08:00" level=info msg="cleaning up dead shim" id=0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb namespace=moby +time="2026-10-06T07:18:47.287499790+08:00" level=info msg="connecting to shim dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3" address="unix:///run/containerd/s/65ed6fad6c3e29b746ba619a5ca2e99cca08082995d002d775b87135a0e6cebc" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:18:47.397357306+08:00" level=error msg="loading cgroup for 339364" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:18:47.398889951+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=8975dd4f62fc ep=lm-capctrl-ecae10dca03b7c88dbc0 net=none nid=f13f14be1124 +time="2026-10-06T07:23:02.925707539+08:00" level=info msg="received task-delete event from containerd" container=1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:23:02.925736910+08:00" level=info msg="shim disconnected" id=1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df namespace=moby +time="2026-10-06T07:23:02.928491037+08:00" level=info msg="cleaning up after shim disconnected" id=1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df namespace=moby +time="2026-10-06T07:23:02.928498785+08:00" level=info msg="cleaning up dead shim" id=1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df namespace=moby +time="2026-10-06T07:23:06.041929004+08:00" level=info msg="connecting to shim 7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61" address="unix:///run/containerd/s/2e7e2e27ee4c8ade7b784d9e9b5cb170474c322025a1dc47e95e9a5dc6f2e310" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:23:06.160726884+08:00" level=error msg="loading cgroup for 342761" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:23:06.162304197+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=ef9fa48bfd36 ep=lm-capctrl-b079c47020bdf79b773a net=none nid=f13f14be1124 +time="2026-10-06T07:32:29.779829039+08:00" level=info msg="shim disconnected" id=dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3 namespace=moby +time="2026-10-06T07:32:29.779928075+08:00" level=info msg="received task-delete event from containerd" container=dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:32:29.782700586+08:00" level=info msg="cleaning up after shim disconnected" id=dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3 namespace=moby +time="2026-10-06T07:32:29.782719115+08:00" level=info msg="cleaning up dead shim" id=dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3 namespace=moby +time="2026-10-06T07:32:32.162527519+08:00" level=info msg="connecting to shim 4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1" address="unix:///run/containerd/s/bda66f5a7bb75d0969b7ca13fa6205bbc9dbcbe417a38de8aa786b37215baa7f" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:32:32.273562159+08:00" level=error msg="loading cgroup for 347893" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:32:32.275170436+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=a8c202885978 ep=lm-capctrl-2c03f374ae28bf5649f4 net=none nid=f13f14be1124 +time="2026-10-06T07:41:19.778959889+08:00" level=info msg="received task-delete event from containerd" container=7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:41:19.779051744+08:00" level=info msg="shim disconnected" id=7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61 namespace=moby +time="2026-10-06T07:41:19.806180641+08:00" level=info msg="cleaning up after shim disconnected" id=7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61 namespace=moby +time="2026-10-06T07:41:19.806197886+08:00" level=info msg="cleaning up dead shim" id=7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61 namespace=moby +time="2026-10-06T07:48:46.386184219+08:00" level=info msg="shim disconnected" id=408f9b595ad6a81ad08a08913a571fdd6fec1b08657e39982ba90ab5961d8dba namespace=moby +time="2026-10-06T07:48:46.386192177+08:00" level=info msg="received task-delete event from containerd" container=408f9b595ad6a81ad08a08913a571fdd6fec1b08657e39982ba90ab5961d8dba module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:48:46.388984477+08:00" level=info msg="cleaning up after shim disconnected" id=408f9b595ad6a81ad08a08913a571fdd6fec1b08657e39982ba90ab5961d8dba namespace=moby +time="2026-10-06T07:48:46.388997149+08:00" level=info msg="cleaning up dead shim" id=408f9b595ad6a81ad08a08913a571fdd6fec1b08657e39982ba90ab5961d8dba namespace=moby +time="2026-10-06T07:50:14.647976905+08:00" level=info msg="shim disconnected" id=4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1 namespace=moby +time="2026-10-06T07:50:14.648019324+08:00" level=info msg="received task-delete event from containerd" container=4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:50:14.650820450+08:00" level=info msg="cleaning up after shim disconnected" id=4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1 namespace=moby +time="2026-10-06T07:50:14.650835590+08:00" level=info msg="cleaning up dead shim" id=4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1 namespace=moby +time="2026-10-06T07:50:34.023914627+08:00" level=info msg="connecting to shim 76b817f4207ba63b282c5adfa4965549f346f3e2c708d6ccafafd875f78755df" address="unix:///run/containerd/s/4eb4a8b51896d8a07ddf67f27cef989aaa51e42fe2f30df8a198d83d8816a8a6" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:50:34.129016175+08:00" level=error msg="loading cgroup for 356345" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:50:34.130588068+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=baef24212990 ep=lm-capctrl-30c2d9720b781cd2213c net=none nid=f13f14be1124 +time="2026-10-06T07:50:34.335500841+08:00" level=info msg="connecting to shim 414e876e4c56b5623af66b5a3a5a9d53218fda47a8f864eb765fe2d113bcac36" address="unix:///run/containerd/s/83de91005e0cffaf7524e446d82e913251a4839e7afeee44c5c97fece804574a" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:50:34.440672119+08:00" level=error msg="loading cgroup for 356607" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:50:34.442271223+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e5554588aa05 ep=lm-capctrl-4876cdf5f844d9e4f013 net=none nid=f13f14be1124 +time="2026-10-06T07:52:07.540144837+08:00" level=info msg="received task-delete event from containerd" container=76b817f4207ba63b282c5adfa4965549f346f3e2c708d6ccafafd875f78755df module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:52:07.540389572+08:00" level=info msg="shim disconnected" id=76b817f4207ba63b282c5adfa4965549f346f3e2c708d6ccafafd875f78755df namespace=moby +time="2026-10-06T07:52:07.543041506+08:00" level=info msg="cleaning up after shim disconnected" id=76b817f4207ba63b282c5adfa4965549f346f3e2c708d6ccafafd875f78755df namespace=moby +time="2026-10-06T07:52:07.543051245+08:00" level=info msg="cleaning up dead shim" id=76b817f4207ba63b282c5adfa4965549f346f3e2c708d6ccafafd875f78755df namespace=moby +time="2026-10-06T07:52:08.812619480+08:00" level=info msg="shim disconnected" id=414e876e4c56b5623af66b5a3a5a9d53218fda47a8f864eb765fe2d113bcac36 namespace=moby +time="2026-10-06T07:52:08.812626844+08:00" level=info msg="received task-delete event from containerd" container=414e876e4c56b5623af66b5a3a5a9d53218fda47a8f864eb765fe2d113bcac36 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T07:52:08.812660858+08:00" level=info msg="cleaning up after shim disconnected" id=414e876e4c56b5623af66b5a3a5a9d53218fda47a8f864eb765fe2d113bcac36 namespace=moby +time="2026-10-06T07:52:08.812674240+08:00" level=info msg="cleaning up dead shim" id=414e876e4c56b5623af66b5a3a5a9d53218fda47a8f864eb765fe2d113bcac36 namespace=moby +time="2026-10-06T07:52:09.181182920+08:00" level=info msg="connecting to shim d43a9aa541d32985ab05897eb1ee2fdfcd2ef9be37a9eb3ecd879c76b1d75535" address="unix:///run/containerd/s/26f04502ae3742da148b8c4f91724e7f110f5ce77c6941038340f33469d71d7a" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:52:09.291185981+08:00" level=error msg="loading cgroup for 357865" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:52:09.292849349+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=aacff58998e2 ep=lm-capctrl-4ef417c7691a69254b21 net=none nid=f13f14be1124 +time="2026-10-06T07:52:09.446448145+08:00" level=info msg="connecting to shim ef1ac10ba9e451a17f31b0a3213e8a7e5a2395233dbcc98b71d7f1582d420d85" address="unix:///run/containerd/s/7b1b3516d055526b8ae4ae841db8b3ce241389522ccdb16c3921995439fdef66" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T07:52:09.568172299+08:00" level=error msg="loading cgroup for 358125" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T07:52:09.569745967+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=17f36e9333d4 ep=lm-capctrl-0defbeb2a47b12509ed4 net=none nid=f13f14be1124 +time="2026-10-06T08:05:44.027393993+08:00" level=info msg="received task-delete event from containerd" container=d43a9aa541d32985ab05897eb1ee2fdfcd2ef9be37a9eb3ecd879c76b1d75535 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T08:05:44.027509055+08:00" level=info msg="shim disconnected" id=d43a9aa541d32985ab05897eb1ee2fdfcd2ef9be37a9eb3ecd879c76b1d75535 namespace=moby +time="2026-10-06T08:05:44.030286699+08:00" level=info msg="cleaning up after shim disconnected" id=d43a9aa541d32985ab05897eb1ee2fdfcd2ef9be37a9eb3ecd879c76b1d75535 namespace=moby +time="2026-10-06T08:05:44.030303158+08:00" level=info msg="cleaning up dead shim" id=d43a9aa541d32985ab05897eb1ee2fdfcd2ef9be37a9eb3ecd879c76b1d75535 namespace=moby +time="2026-10-06T08:05:49.436540615+08:00" level=info msg="shim disconnected" id=ef1ac10ba9e451a17f31b0a3213e8a7e5a2395233dbcc98b71d7f1582d420d85 namespace=moby +time="2026-10-06T08:05:49.436582714+08:00" level=info msg="cleaning up after shim disconnected" id=ef1ac10ba9e451a17f31b0a3213e8a7e5a2395233dbcc98b71d7f1582d420d85 namespace=moby +time="2026-10-06T08:05:49.436582285+08:00" level=info msg="received task-delete event from containerd" container=ef1ac10ba9e451a17f31b0a3213e8a7e5a2395233dbcc98b71d7f1582d420d85 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T08:05:49.436590982+08:00" level=info msg="cleaning up dead shim" id=ef1ac10ba9e451a17f31b0a3213e8a7e5a2395233dbcc98b71d7f1582d420d85 namespace=moby +time="2026-10-06T08:53:50.989784133+08:00" level=info msg="connecting to shim 0496ed9c4d141cfcb33147c711dd37393c5e1cd2216fd28cf55dd5245297178e" address="unix:///run/containerd/s/4fb6a33101abe600f763dde9ef78c82ff0ae8c84207c7757ff7253939356fea9" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T08:53:51.106500956+08:00" level=error msg="loading cgroup for 389489" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T08:53:51.109213697+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=37c6d2c5584a ep=lm-composition-curves-preflight-20261006 net=none nid=f13f14be1124 +time="2026-10-06T08:53:57.747213733+08:00" level=info msg="shim disconnected" id=0496ed9c4d141cfcb33147c711dd37393c5e1cd2216fd28cf55dd5245297178e namespace=moby +time="2026-10-06T08:53:57.747229390+08:00" level=info msg="received task-delete event from containerd" container=0496ed9c4d141cfcb33147c711dd37393c5e1cd2216fd28cf55dd5245297178e module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T08:53:57.747259957+08:00" level=info msg="cleaning up after shim disconnected" id=0496ed9c4d141cfcb33147c711dd37393c5e1cd2216fd28cf55dd5245297178e namespace=moby +time="2026-10-06T08:53:57.747274245+08:00" level=info msg="cleaning up dead shim" id=0496ed9c4d141cfcb33147c711dd37393c5e1cd2216fd28cf55dd5245297178e namespace=moby +time="2026-10-06T09:00:10.027845651+08:00" level=info msg="received task-delete event from containerd" container=43725bf68f3c27cde427818eff0ed077e38ee67450a6563dfc43779b74f01a4e module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:00:10.028156776+08:00" level=info msg="shim disconnected" id=43725bf68f3c27cde427818eff0ed077e38ee67450a6563dfc43779b74f01a4e namespace=moby +time="2026-10-06T09:00:10.030671773+08:00" level=info msg="cleaning up after shim disconnected" id=43725bf68f3c27cde427818eff0ed077e38ee67450a6563dfc43779b74f01a4e namespace=moby +time="2026-10-06T09:00:10.030678830+08:00" level=info msg="cleaning up dead shim" id=43725bf68f3c27cde427818eff0ed077e38ee67450a6563dfc43779b74f01a4e namespace=moby +time="2026-10-06T09:01:45.750718597+08:00" level=info msg="connecting to shim 1fe254f6acc9a600b094166bd9a453feca8d9a9b963da178f1069e19887c5063" address="unix:///run/containerd/s/8feae4cf802fc1f063475b7384463abbf1ae3cf96b85cc36c2a7901cd96994f5" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:01:45.861033595+08:00" level=error msg="loading cgroup for 394263" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:01:45.864665162+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=86c6cb3e18f1 ep=lm-composition-curves-smoke-20261006 net=none nid=f13f14be1124 +time="2026-10-06T09:01:57.169294410+08:00" level=info msg="shim disconnected" id=1fe254f6acc9a600b094166bd9a453feca8d9a9b963da178f1069e19887c5063 namespace=moby +time="2026-10-06T09:01:57.169333398+08:00" level=info msg="cleaning up after shim disconnected" id=1fe254f6acc9a600b094166bd9a453feca8d9a9b963da178f1069e19887c5063 namespace=moby +time="2026-10-06T09:01:57.169341183+08:00" level=info msg="cleaning up dead shim" id=1fe254f6acc9a600b094166bd9a453feca8d9a9b963da178f1069e19887c5063 namespace=moby +time="2026-10-06T09:01:57.169347196+08:00" level=info msg="received task-delete event from containerd" container=1fe254f6acc9a600b094166bd9a453feca8d9a9b963da178f1069e19887c5063 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:03:53.934061160+08:00" level=info msg="connecting to shim 2849bff3f7fafde55e33e151535057231adf5379da0b4e5bc9f3b0b26f0765bf" address="unix:///run/containerd/s/de344411f5fbeff80c7dec8205fee9cf8a87824d04f001dbd3d9bf7fa412034f" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:03:54.060141350+08:00" level=error msg="loading cgroup for 396711" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:03:54.061619289+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=26738367e0b8 ep=lm-curves-9691caea1a5f8d752e86 net=none nid=f13f14be1124 +time="2026-10-06T09:03:54.479052345+08:00" level=info msg="connecting to shim cfbcd283d6a96c649f4785023147fc9aa8ee0f6f33b2e6640139c5241a48428c" address="unix:///run/containerd/s/a54eeb13a59de00cafaf32cd4d98652c3420a6a135eae89082fbd912568c4585" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:03:54.595930027+08:00" level=error msg="loading cgroup for 397208" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:03:54.597409396+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=1112aeab12b3 ep=lm-curves-06d66316fa457d95c9c8 net=none nid=f13f14be1124 +time="2026-10-06T09:06:03.247113237+08:00" level=info msg="shim disconnected" id=2849bff3f7fafde55e33e151535057231adf5379da0b4e5bc9f3b0b26f0765bf namespace=moby +time="2026-10-06T09:06:03.247183277+08:00" level=info msg="received task-delete event from containerd" container=2849bff3f7fafde55e33e151535057231adf5379da0b4e5bc9f3b0b26f0765bf module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:06:03.249916668+08:00" level=info msg="cleaning up after shim disconnected" id=2849bff3f7fafde55e33e151535057231adf5379da0b4e5bc9f3b0b26f0765bf namespace=moby +time="2026-10-06T09:06:03.249935486+08:00" level=info msg="cleaning up dead shim" id=2849bff3f7fafde55e33e151535057231adf5379da0b4e5bc9f3b0b26f0765bf namespace=moby +time="2026-10-06T09:07:09.944539195+08:00" level=info msg="shim disconnected" id=cfbcd283d6a96c649f4785023147fc9aa8ee0f6f33b2e6640139c5241a48428c namespace=moby +time="2026-10-06T09:07:09.944690241+08:00" level=info msg="received task-delete event from containerd" container=cfbcd283d6a96c649f4785023147fc9aa8ee0f6f33b2e6640139c5241a48428c module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:07:09.947348600+08:00" level=info msg="cleaning up after shim disconnected" id=cfbcd283d6a96c649f4785023147fc9aa8ee0f6f33b2e6640139c5241a48428c namespace=moby +time="2026-10-06T09:07:09.947367515+08:00" level=info msg="cleaning up dead shim" id=cfbcd283d6a96c649f4785023147fc9aa8ee0f6f33b2e6640139c5241a48428c namespace=moby +time="2026-10-06T09:07:17.014715229+08:00" level=info msg="connecting to shim 2c162c6a8c8ac7babd64e9846c5ac4e4c19c49ffc82679d28b8ecf296cf9a34b" address="unix:///run/containerd/s/02e2919f02383dd36c340b2093028209ee21f6ce3f9ad6a5b3e9042d503a47de" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:07:17.126703130+08:00" level=error msg="loading cgroup for 399938" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:07:17.128194141+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=a6d91476c0bb ep=lm-curves-5f6322c0ef40c07a1361 net=none nid=f13f14be1124 +time="2026-10-06T09:07:17.592889208+08:00" level=info msg="connecting to shim e4171a2588d1cab5105970b9a86944f9d00d3cff078d255ef8a4df922c730597" address="unix:///run/containerd/s/705670f8fd6679f388f0394f820ce108299f93306677126ef7b897b9cee06bc9" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:07:17.697972802+08:00" level=error msg="loading cgroup for 400426" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:07:17.700018051+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=4506675bee0e ep=lm-curves-74a9e2a06a0a50e9ecd3 net=none nid=f13f14be1124 +time="2026-10-06T09:10:37.441530456+08:00" level=info msg="shim disconnected" id=2c162c6a8c8ac7babd64e9846c5ac4e4c19c49ffc82679d28b8ecf296cf9a34b namespace=moby +time="2026-10-06T09:10:37.441649808+08:00" level=info msg="received task-delete event from containerd" container=2c162c6a8c8ac7babd64e9846c5ac4e4c19c49ffc82679d28b8ecf296cf9a34b module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:10:37.444349094+08:00" level=info msg="cleaning up after shim disconnected" id=2c162c6a8c8ac7babd64e9846c5ac4e4c19c49ffc82679d28b8ecf296cf9a34b namespace=moby +time="2026-10-06T09:10:37.444367450+08:00" level=info msg="cleaning up dead shim" id=2c162c6a8c8ac7babd64e9846c5ac4e4c19c49ffc82679d28b8ecf296cf9a34b namespace=moby +time="2026-10-06T09:10:38.967442156+08:00" level=info msg="received task-delete event from containerd" container=e4171a2588d1cab5105970b9a86944f9d00d3cff078d255ef8a4df922c730597 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:10:38.967465145+08:00" level=info msg="shim disconnected" id=e4171a2588d1cab5105970b9a86944f9d00d3cff078d255ef8a4df922c730597 namespace=moby +time="2026-10-06T09:10:38.967507544+08:00" level=info msg="cleaning up after shim disconnected" id=e4171a2588d1cab5105970b9a86944f9d00d3cff078d255ef8a4df922c730597 namespace=moby +time="2026-10-06T09:10:38.967516770+08:00" level=info msg="cleaning up dead shim" id=e4171a2588d1cab5105970b9a86944f9d00d3cff078d255ef8a4df922c730597 namespace=moby +time="2026-10-06T09:10:39.104809807+08:00" level=info msg="connecting to shim ba4e3fd9a4078ce0325e6c4258201c034843d5dd75c972325a53397c0be5c09f" address="unix:///run/containerd/s/636e4bcff7e11bcff3c0d37da61c27ea5130b06cd8d6e480e9ca188e25e6db77" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:10:39.221771651+08:00" level=error msg="loading cgroup for 402957" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:10:39.223196701+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=bfc735bc500c ep=lm-curves-294357faf31fffec848e net=none nid=f13f14be1124 +time="2026-10-06T09:10:42.867958721+08:00" level=info msg="connecting to shim 9ac2d3cac580d997a8e66cb199c412a0bfd6e0209982a1ad52892b78c9cb4299" address="unix:///run/containerd/s/6f68f4775508ec6aebe16a9b4a9b42f87864ac86c68581629f6e133835618787" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:10:42.981950689+08:00" level=error msg="loading cgroup for 403536" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:10:42.983740494+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e63388838e09 ep=lm-curves-d7c5dfbee6f9d67ce92e net=none nid=f13f14be1124 +time="2026-10-06T09:13:55.465942809+08:00" level=info msg="shim disconnected" id=ba4e3fd9a4078ce0325e6c4258201c034843d5dd75c972325a53397c0be5c09f namespace=moby +time="2026-10-06T09:13:55.466159242+08:00" level=info msg="received task-delete event from containerd" container=ba4e3fd9a4078ce0325e6c4258201c034843d5dd75c972325a53397c0be5c09f module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:13:55.468810437+08:00" level=info msg="cleaning up after shim disconnected" id=ba4e3fd9a4078ce0325e6c4258201c034843d5dd75c972325a53397c0be5c09f namespace=moby +time="2026-10-06T09:13:55.468830086+08:00" level=info msg="cleaning up dead shim" id=ba4e3fd9a4078ce0325e6c4258201c034843d5dd75c972325a53397c0be5c09f namespace=moby +time="2026-10-06T09:13:56.218243729+08:00" level=info msg="connecting to shim ff0bcb96c9a919bbeb2b159662b48a6eaa1cdf8c30b03fad99d36cc5a93ed784" address="unix:///run/containerd/s/262706b3ea251f94eea838cb1b286c799a2bb270ac89a40149a5d3754ee0c4cb" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:13:56.346343327+08:00" level=error msg="loading cgroup for 406257" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:13:56.348982281+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=deded14da35b ep=lm-curves-d8419fbbcc2468288b94 net=none nid=f13f14be1124 +time="2026-10-06T09:13:58.785978015+08:00" level=info msg="received task-delete event from containerd" container=9ac2d3cac580d997a8e66cb199c412a0bfd6e0209982a1ad52892b78c9cb4299 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:13:58.785984985+08:00" level=info msg="shim disconnected" id=9ac2d3cac580d997a8e66cb199c412a0bfd6e0209982a1ad52892b78c9cb4299 namespace=moby +time="2026-10-06T09:13:58.786036405+08:00" level=info msg="cleaning up after shim disconnected" id=9ac2d3cac580d997a8e66cb199c412a0bfd6e0209982a1ad52892b78c9cb4299 namespace=moby +time="2026-10-06T09:13:58.786053510+08:00" level=info msg="cleaning up dead shim" id=9ac2d3cac580d997a8e66cb199c412a0bfd6e0209982a1ad52892b78c9cb4299 namespace=moby +time="2026-10-06T09:13:59.846592685+08:00" level=info msg="connecting to shim bf8fa736bff795a619c4f1c3233d3b825c096c071e3f14b87fc50fc843617c9b" address="unix:///run/containerd/s/adcd94a363b0c401e06d430deac019a210a751a8cf7c454dc8243c64b1ee8681" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:13:59.980397343+08:00" level=error msg="loading cgroup for 406853" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:13:59.982471901+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=9faa123da035 ep=lm-curves-2c1850a295324e8abd35 net=none nid=f13f14be1124 +time="2026-10-06T09:17:54.359766587+08:00" level=info msg="received task-delete event from containerd" container=ff0bcb96c9a919bbeb2b159662b48a6eaa1cdf8c30b03fad99d36cc5a93ed784 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:17:54.359787933+08:00" level=info msg="shim disconnected" id=ff0bcb96c9a919bbeb2b159662b48a6eaa1cdf8c30b03fad99d36cc5a93ed784 namespace=moby +time="2026-10-06T09:17:54.362614388+08:00" level=info msg="cleaning up after shim disconnected" id=ff0bcb96c9a919bbeb2b159662b48a6eaa1cdf8c30b03fad99d36cc5a93ed784 namespace=moby +time="2026-10-06T09:17:54.362621532+08:00" level=info msg="cleaning up dead shim" id=ff0bcb96c9a919bbeb2b159662b48a6eaa1cdf8c30b03fad99d36cc5a93ed784 namespace=moby +time="2026-10-06T09:17:56.154810608+08:00" level=info msg="connecting to shim 47f30db6d45f82ebe71e8b223d4a9e28f3c3cd7683a0f05fbcf3dd46c29cc28a" address="unix:///run/containerd/s/862fcf9e67ec41e3d5d5ead39614470ef6f93b974e7f9a15092cde60ee841365" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:17:56.272412589+08:00" level=error msg="loading cgroup for 409904" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:17:56.274022901+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=32f737f697cf ep=lm-curves-beca01236d68a4c8ce9d net=none nid=f13f14be1124 +time="2026-10-06T09:20:04.049212852+08:00" level=info msg="received task-delete event from containerd" container=bf8fa736bff795a619c4f1c3233d3b825c096c071e3f14b87fc50fc843617c9b module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:20:04.049280558+08:00" level=info msg="shim disconnected" id=bf8fa736bff795a619c4f1c3233d3b825c096c071e3f14b87fc50fc843617c9b namespace=moby +time="2026-10-06T09:20:04.052076266+08:00" level=info msg="cleaning up after shim disconnected" id=bf8fa736bff795a619c4f1c3233d3b825c096c071e3f14b87fc50fc843617c9b namespace=moby +time="2026-10-06T09:20:04.052085230+08:00" level=info msg="cleaning up dead shim" id=bf8fa736bff795a619c4f1c3233d3b825c096c071e3f14b87fc50fc843617c9b namespace=moby +time="2026-10-06T09:20:05.121094030+08:00" level=info msg="connecting to shim e807d0fd3635f8e2ce3fa8739a932871156a61c93734f669e2f344b841c0243e" address="unix:///run/containerd/s/266bf24f9fcff9fe5da36c62bb835669feb7a0621e8213c10de9790643d0e8f2" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:20:05.273675627+08:00" level=error msg="loading cgroup for 411540" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:20:05.275498676+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e8c4dbf263b2 ep=lm-curves-cb71277423bc6700aabb net=none nid=f13f14be1124 +time="2026-10-06T09:23:27.488780270+08:00" level=info msg="received task-delete event from containerd" container=e807d0fd3635f8e2ce3fa8739a932871156a61c93734f669e2f344b841c0243e module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:23:27.488903029+08:00" level=info msg="shim disconnected" id=e807d0fd3635f8e2ce3fa8739a932871156a61c93734f669e2f344b841c0243e namespace=moby +time="2026-10-06T09:23:27.491778871+08:00" level=info msg="cleaning up after shim disconnected" id=e807d0fd3635f8e2ce3fa8739a932871156a61c93734f669e2f344b841c0243e namespace=moby +time="2026-10-06T09:23:27.491786549+08:00" level=info msg="cleaning up dead shim" id=e807d0fd3635f8e2ce3fa8739a932871156a61c93734f669e2f344b841c0243e namespace=moby +time="2026-10-06T09:23:31.056003412+08:00" level=info msg="connecting to shim 16599dd5167538698e7794e1c31310e816cf76877af6a071ef8133c1500134f0" address="unix:///run/containerd/s/7a400a3f22215c158ca28f04a666a99556f3c4d980731fa20ab967dcbe376409" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:23:31.222117190+08:00" level=error msg="loading cgroup for 414575" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:23:31.228174530+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=191154f386d8 ep=lm-curves-69066d69a16b0f4624bb net=none nid=f13f14be1124 +time="2026-10-06T09:26:40.859609948+08:00" level=info msg="received task-delete event from containerd" container=16599dd5167538698e7794e1c31310e816cf76877af6a071ef8133c1500134f0 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:26:40.859732350+08:00" level=info msg="shim disconnected" id=16599dd5167538698e7794e1c31310e816cf76877af6a071ef8133c1500134f0 namespace=moby +time="2026-10-06T09:26:40.862440019+08:00" level=info msg="cleaning up after shim disconnected" id=16599dd5167538698e7794e1c31310e816cf76877af6a071ef8133c1500134f0 namespace=moby +time="2026-10-06T09:26:40.862447799+08:00" level=info msg="cleaning up dead shim" id=16599dd5167538698e7794e1c31310e816cf76877af6a071ef8133c1500134f0 namespace=moby +time="2026-10-06T09:26:41.650582607+08:00" level=info msg="connecting to shim 7f32859a9017f661d9e8d80981ba2a34629b993ab2460bdbc11e7e5557923853" address="unix:///run/containerd/s/f83461b0dbe54bd426018ae530d71c3143ae0be44d54771d8901bfd1e498e631" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:26:41.757455651+08:00" level=error msg="loading cgroup for 417381" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:26:41.759253300+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=a67ff0f2ba53 ep=lm-curves-a6f12c964085704aee80 net=none nid=f13f14be1124 +time="2026-10-06T09:27:30.481182587+08:00" level=info msg="received task-delete event from containerd" container=47f30db6d45f82ebe71e8b223d4a9e28f3c3cd7683a0f05fbcf3dd46c29cc28a module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:27:30.481319212+08:00" level=info msg="shim disconnected" id=47f30db6d45f82ebe71e8b223d4a9e28f3c3cd7683a0f05fbcf3dd46c29cc28a namespace=moby +time="2026-10-06T09:27:30.486254781+08:00" level=info msg="cleaning up after shim disconnected" id=47f30db6d45f82ebe71e8b223d4a9e28f3c3cd7683a0f05fbcf3dd46c29cc28a namespace=moby +time="2026-10-06T09:27:30.486262547+08:00" level=info msg="cleaning up dead shim" id=47f30db6d45f82ebe71e8b223d4a9e28f3c3cd7683a0f05fbcf3dd46c29cc28a namespace=moby +time="2026-10-06T09:27:31.182389272+08:00" level=info msg="connecting to shim a1084f69681ddc74218625cc52c41fdc4060cbf0360681e52c2f21e391411382" address="unix:///run/containerd/s/1ace25f523b53aadbb1119184451f2917b2a52f2587777723147d64505584ac1" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:27:31.281861695+08:00" level=error msg="loading cgroup for 418345" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:27:31.283490163+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=70ba49afd11b ep=lm-curves-a606f454e20e77f0e733 net=none nid=f13f14be1124 +time="2026-10-06T09:29:54.368385132+08:00" level=info msg="shim disconnected" id=7f32859a9017f661d9e8d80981ba2a34629b993ab2460bdbc11e7e5557923853 namespace=moby +time="2026-10-06T09:29:54.368451533+08:00" level=info msg="received task-delete event from containerd" container=7f32859a9017f661d9e8d80981ba2a34629b993ab2460bdbc11e7e5557923853 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:29:54.371220302+08:00" level=info msg="cleaning up after shim disconnected" id=7f32859a9017f661d9e8d80981ba2a34629b993ab2460bdbc11e7e5557923853 namespace=moby +time="2026-10-06T09:29:54.371235927+08:00" level=info msg="cleaning up dead shim" id=7f32859a9017f661d9e8d80981ba2a34629b993ab2460bdbc11e7e5557923853 namespace=moby +time="2026-10-06T09:29:55.859330761+08:00" level=info msg="connecting to shim 18eeedc6d5a1c9098c99003138830cb50be6fb39b1779967edf3e6e772983dd3" address="unix:///run/containerd/s/8d4a6e3e79ca15f3b91874d0fc7f9ae4fd0a7a55aea2cae01d1f2a08b7e8c6af" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:29:55.967214368+08:00" level=error msg="loading cgroup for 420140" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:29:55.968735731+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=8cbb27b2bd57 ep=lm-curves-34b34908402de940fc1b net=none nid=f13f14be1124 +time="2026-10-06T09:30:48.952380778+08:00" level=info msg="received task-delete event from containerd" container=a1084f69681ddc74218625cc52c41fdc4060cbf0360681e52c2f21e391411382 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:30:48.952723635+08:00" level=info msg="shim disconnected" id=a1084f69681ddc74218625cc52c41fdc4060cbf0360681e52c2f21e391411382 namespace=moby +time="2026-10-06T09:30:48.957686728+08:00" level=info msg="cleaning up after shim disconnected" id=a1084f69681ddc74218625cc52c41fdc4060cbf0360681e52c2f21e391411382 namespace=moby +time="2026-10-06T09:30:48.957694745+08:00" level=info msg="cleaning up dead shim" id=a1084f69681ddc74218625cc52c41fdc4060cbf0360681e52c2f21e391411382 namespace=moby +time="2026-10-06T09:30:49.484277275+08:00" level=info msg="connecting to shim cb8b2dc015c1aefc31599f94f895dffc77c146eb101e96fe240601062462c3fe" address="unix:///run/containerd/s/85f002d85b11c8f4b8b311a2860decf1ee79f3a7e64bd276f1cee806aa21cddf" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:30:49.606559734+08:00" level=error msg="loading cgroup for 421105" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:30:49.608677273+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=243e932ee0ac ep=lm-curves-411d3932a0e60e52ae7e net=none nid=f13f14be1124 +time="2026-10-06T09:33:41.630312774+08:00" level=info msg="shim disconnected" id=18eeedc6d5a1c9098c99003138830cb50be6fb39b1779967edf3e6e772983dd3 namespace=moby +time="2026-10-06T09:33:41.630364855+08:00" level=info msg="received task-delete event from containerd" container=18eeedc6d5a1c9098c99003138830cb50be6fb39b1779967edf3e6e772983dd3 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:33:41.633103881+08:00" level=info msg="cleaning up after shim disconnected" id=18eeedc6d5a1c9098c99003138830cb50be6fb39b1779967edf3e6e772983dd3 namespace=moby +time="2026-10-06T09:33:41.633117434+08:00" level=info msg="cleaning up dead shim" id=18eeedc6d5a1c9098c99003138830cb50be6fb39b1779967edf3e6e772983dd3 namespace=moby +time="2026-10-06T09:33:46.248934370+08:00" level=info msg="connecting to shim 72105d89fe69488fd5c993ebcaa194b41151178dc5d0bc1c152f312241ef6198" address="unix:///run/containerd/s/e51cd979c6a403992e5dc8e182e0593eb79468d7c814b2b729de97bc1da6afe0" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:33:46.351558503+08:00" level=error msg="loading cgroup for 422919" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:33:46.353145329+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=5422cda67e97 ep=lm-curves-fbd3deb44f8f6a546b23 net=none nid=f13f14be1124 +time="2026-10-06T09:36:51.189465100+08:00" level=info msg="received task-delete event from containerd" container=cb8b2dc015c1aefc31599f94f895dffc77c146eb101e96fe240601062462c3fe module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:36:51.189615505+08:00" level=info msg="shim disconnected" id=cb8b2dc015c1aefc31599f94f895dffc77c146eb101e96fe240601062462c3fe namespace=moby +time="2026-10-06T09:36:51.192300644+08:00" level=info msg="cleaning up after shim disconnected" id=cb8b2dc015c1aefc31599f94f895dffc77c146eb101e96fe240601062462c3fe namespace=moby +time="2026-10-06T09:36:51.192308505+08:00" level=info msg="cleaning up dead shim" id=cb8b2dc015c1aefc31599f94f895dffc77c146eb101e96fe240601062462c3fe namespace=moby +time="2026-10-06T09:36:54.287328483+08:00" level=info msg="connecting to shim 67cf65f324354789c4edef61e81fc54c4c451034cfdd00dfa9e947e6ce72fc12" address="unix:///run/containerd/s/6ab160b9fcf5b1668bd1d0ee679e87741efc02c67f2209add72a3987b7e4acb2" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:36:54.393609857+08:00" level=error msg="loading cgroup for 424815" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:36:54.395488746+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=eb23bdf12dd1 ep=lm-curves-2de87d3c275fb640a323 net=none nid=f13f14be1124 +time="2026-10-06T09:40:14.404828442+08:00" level=info msg="shim disconnected" id=67cf65f324354789c4edef61e81fc54c4c451034cfdd00dfa9e947e6ce72fc12 namespace=moby +time="2026-10-06T09:40:14.404954233+08:00" level=info msg="received task-delete event from containerd" container=67cf65f324354789c4edef61e81fc54c4c451034cfdd00dfa9e947e6ce72fc12 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:40:14.407601381+08:00" level=info msg="cleaning up after shim disconnected" id=67cf65f324354789c4edef61e81fc54c4c451034cfdd00dfa9e947e6ce72fc12 namespace=moby +time="2026-10-06T09:40:14.407613255+08:00" level=info msg="cleaning up dead shim" id=67cf65f324354789c4edef61e81fc54c4c451034cfdd00dfa9e947e6ce72fc12 namespace=moby +time="2026-10-06T09:40:17.827069508+08:00" level=info msg="connecting to shim ba004b789edca312c28db445091baee86b54d350b2f9e4ac1f4c6d5d52519b03" address="unix:///run/containerd/s/740f36e48239af8771c2621b90ab325f5fbc233761ee40735af2e55bee211ed9" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:40:18.022216801+08:00" level=error msg="loading cgroup for 427410" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:40:18.024361455+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=f66db4ce687d ep=lm-curves-12b9a6cef38e3c916dfa net=none nid=f13f14be1124 +time="2026-10-06T09:42:56.273353499+08:00" level=info msg="connecting to shim 8dc3264a9bd3a8f9b81c26ad4269322dcc6b1824415e075d7dc7b7b263701375" address="unix:///run/containerd/s/a0f114d1a4faaf183e17a7ba32f994d0e087885fa558ce1112a12033c0abdb13" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:42:56.273353649+08:00" level=info msg="connecting to shim 16f0e10a397df9b4c294cdcf20067ceb7d08f2572ee64f52798567ce4b3209b9" address="unix:///run/containerd/s/e77b8bcc0286fe04cf4373c4b42ee1f44c8ffeaae8b2eaa8b3673e7247eb4958" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:42:56.273449222+08:00" level=info msg="connecting to shim 44cf3737a0b1463ff3701929933a93dfc8088a57f02356827eafea00beb86854" address="unix:///run/containerd/s/95ebe87b7c60e4b8067ea570514fab04595b5fd6e917ad361965032ea51781ec" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:42:56.402000263+08:00" level=error msg="loading cgroup for 429096" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:42:56.402419634+08:00" level=error msg="loading cgroup for 429097" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:42:56.403475545+08:00" level=error msg="loading cgroup for 429098" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:42:56.410055979+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=315a2d06976f ep=lm-curves-parallel-preflight-gpu3-20261006 net=none nid=f13f14be1124 +time="2026-10-06T09:42:56.410229368+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=32df17bb690d ep=lm-curves-parallel-preflight-gpu4-20261006 net=none nid=f13f14be1124 +time="2026-10-06T09:42:56.410318876+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=8b4cec11bb30 ep=lm-curves-parallel-preflight-gpu2-20261006 net=none nid=f13f14be1124 +time="2026-10-06T09:43:02.542668151+08:00" level=info msg="received task-delete event from containerd" container=8dc3264a9bd3a8f9b81c26ad4269322dcc6b1824415e075d7dc7b7b263701375 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:43:02.542694218+08:00" level=info msg="shim disconnected" id=8dc3264a9bd3a8f9b81c26ad4269322dcc6b1824415e075d7dc7b7b263701375 namespace=moby +time="2026-10-06T09:43:02.542754128+08:00" level=info msg="cleaning up after shim disconnected" id=8dc3264a9bd3a8f9b81c26ad4269322dcc6b1824415e075d7dc7b7b263701375 namespace=moby +time="2026-10-06T09:43:02.542762516+08:00" level=info msg="cleaning up dead shim" id=8dc3264a9bd3a8f9b81c26ad4269322dcc6b1824415e075d7dc7b7b263701375 namespace=moby +time="2026-10-06T09:43:02.685717033+08:00" level=info msg="received task-delete event from containerd" container=44cf3737a0b1463ff3701929933a93dfc8088a57f02356827eafea00beb86854 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:43:02.685733927+08:00" level=info msg="shim disconnected" id=44cf3737a0b1463ff3701929933a93dfc8088a57f02356827eafea00beb86854 namespace=moby +time="2026-10-06T09:43:02.685779325+08:00" level=info msg="cleaning up after shim disconnected" id=44cf3737a0b1463ff3701929933a93dfc8088a57f02356827eafea00beb86854 namespace=moby +time="2026-10-06T09:43:02.685787937+08:00" level=info msg="cleaning up dead shim" id=44cf3737a0b1463ff3701929933a93dfc8088a57f02356827eafea00beb86854 namespace=moby +time="2026-10-06T09:43:02.772238063+08:00" level=info msg="shim disconnected" id=16f0e10a397df9b4c294cdcf20067ceb7d08f2572ee64f52798567ce4b3209b9 namespace=moby +time="2026-10-06T09:43:02.772258165+08:00" level=info msg="received task-delete event from containerd" container=16f0e10a397df9b4c294cdcf20067ceb7d08f2572ee64f52798567ce4b3209b9 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:43:02.772276126+08:00" level=info msg="cleaning up after shim disconnected" id=16f0e10a397df9b4c294cdcf20067ceb7d08f2572ee64f52798567ce4b3209b9 namespace=moby +time="2026-10-06T09:43:02.772293247+08:00" level=info msg="cleaning up dead shim" id=16f0e10a397df9b4c294cdcf20067ceb7d08f2572ee64f52798567ce4b3209b9 namespace=moby +time="2026-10-06T09:43:11.541297282+08:00" level=info msg="received task-delete event from containerd" container=72105d89fe69488fd5c993ebcaa194b41151178dc5d0bc1c152f312241ef6198 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:43:11.541729582+08:00" level=info msg="shim disconnected" id=72105d89fe69488fd5c993ebcaa194b41151178dc5d0bc1c152f312241ef6198 namespace=moby +time="2026-10-06T09:43:11.546664117+08:00" level=info msg="cleaning up after shim disconnected" id=72105d89fe69488fd5c993ebcaa194b41151178dc5d0bc1c152f312241ef6198 namespace=moby +time="2026-10-06T09:43:11.546671926+08:00" level=info msg="cleaning up dead shim" id=72105d89fe69488fd5c993ebcaa194b41151178dc5d0bc1c152f312241ef6198 namespace=moby +time="2026-10-06T09:43:15.080580368+08:00" level=info msg="connecting to shim 027b618d749a900c6ee16dee1380a55db3b7d3f01b4dc06076346e21b51863e3" address="unix:///run/containerd/s/f01e20ad5b93f10366f0ed9de65995c0ba37e5832958fad5beb4b7f85f18e7c2" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:43:15.185555545+08:00" level=error msg="loading cgroup for 430188" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:43:15.187486918+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=e85c17a9572d ep=lm-curves-22a3faec263c7a0678f3 net=none nid=f13f14be1124 +time="2026-10-06T09:43:37.779514524+08:00" level=info msg="received task-delete event from containerd" container=ba004b789edca312c28db445091baee86b54d350b2f9e4ac1f4c6d5d52519b03 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:43:37.779649312+08:00" level=info msg="shim disconnected" id=ba004b789edca312c28db445091baee86b54d350b2f9e4ac1f4c6d5d52519b03 namespace=moby +time="2026-10-06T09:43:37.779683445+08:00" level=info msg="cleaning up after shim disconnected" id=ba004b789edca312c28db445091baee86b54d350b2f9e4ac1f4c6d5d52519b03 namespace=moby +time="2026-10-06T09:43:37.784619643+08:00" level=info msg="cleaning up dead shim" id=ba004b789edca312c28db445091baee86b54d350b2f9e4ac1f4c6d5d52519b03 namespace=moby +time="2026-10-06T09:43:40.892985457+08:00" level=info msg="connecting to shim 95e15d60e16ede8a836fa52809290ce4689fa82ed534865846a6928665b559a8" address="unix:///run/containerd/s/be1fe606add120bb709d98664dcc0cc0b76a76e3faf6ac0f9180d731529a0fcd" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:43:41.010642545+08:00" level=error msg="loading cgroup for 430960" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:43:41.012405992+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=20fc6d919971 ep=lm-curves-bfffaf6ac4d5a8bef2d4 net=none nid=f13f14be1124 +time="2026-10-06T09:44:49.512339558+08:00" level=info msg="connecting to shim bd6b766d6d01cfceef9f195b7f5ce1c03d8d1079bfdff42c42134779bb58a591" address="unix:///run/containerd/s/ba205bb7f6e18b6dfae579235c137427aa3139deeb74af4f69a58f26b3a0e4d6" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:44:49.705482814+08:00" level=error msg="loading cgroup for 432616" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:44:49.707324359+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=c2b16c2b04b8 ep=lm-curves-4890ec78ed09b98c6cfa net=none nid=f13f14be1124 +time="2026-10-06T09:44:50.590495641+08:00" level=info msg="connecting to shim 04124b048ce782db915127de39d11dc3e2b832f058e184cb506470f899961933" address="unix:///run/containerd/s/0f8eb906c4825547dd84416b40715332352e13dfef7f5f8e99cf5a7ddba65013" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:44:50.732270272+08:00" level=error msg="loading cgroup for 433123" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:44:50.734159535+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=4569af834a77 ep=lm-curves-1a5042ad47b4813d90a6 net=none nid=f13f14be1124 +time="2026-10-06T09:44:51.674766439+08:00" level=info msg="connecting to shim 62a9433ef792429c5351c1acfa2901f63a56195bd1e99523336e1c1396cf429d" address="unix:///run/containerd/s/f3b88eb368e4a545e3c50c462bf7b04e46a690935297e02911331957b5f84af8" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:44:51.783996894+08:00" level=error msg="loading cgroup for 433613" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:44:51.785588309+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=117fe744e308 ep=lm-curves-84fd7170db77f4176267 net=none nid=f13f14be1124 +time="2026-10-06T09:46:26.271075098+08:00" level=info msg="received task-delete event from containerd" container=027b618d749a900c6ee16dee1380a55db3b7d3f01b4dc06076346e21b51863e3 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:46:26.271089754+08:00" level=info msg="shim disconnected" id=027b618d749a900c6ee16dee1380a55db3b7d3f01b4dc06076346e21b51863e3 namespace=moby +time="2026-10-06T09:46:26.273866053+08:00" level=info msg="cleaning up after shim disconnected" id=027b618d749a900c6ee16dee1380a55db3b7d3f01b4dc06076346e21b51863e3 namespace=moby +time="2026-10-06T09:46:26.273878734+08:00" level=info msg="cleaning up dead shim" id=027b618d749a900c6ee16dee1380a55db3b7d3f01b4dc06076346e21b51863e3 namespace=moby +time="2026-10-06T09:46:53.558367168+08:00" level=info msg="shim disconnected" id=95e15d60e16ede8a836fa52809290ce4689fa82ed534865846a6928665b559a8 namespace=moby +time="2026-10-06T09:46:53.558415163+08:00" level=info msg="cleaning up after shim disconnected" id=95e15d60e16ede8a836fa52809290ce4689fa82ed534865846a6928665b559a8 namespace=moby +time="2026-10-06T09:46:53.558422339+08:00" level=info msg="cleaning up dead shim" id=95e15d60e16ede8a836fa52809290ce4689fa82ed534865846a6928665b559a8 namespace=moby +time="2026-10-06T09:46:53.558415343+08:00" level=info msg="received task-delete event from containerd" container=95e15d60e16ede8a836fa52809290ce4689fa82ed534865846a6928665b559a8 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:48:39.220272787+08:00" level=info msg="received task-delete event from containerd" container=bd6b766d6d01cfceef9f195b7f5ce1c03d8d1079bfdff42c42134779bb58a591 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:48:39.220320518+08:00" level=info msg="shim disconnected" id=bd6b766d6d01cfceef9f195b7f5ce1c03d8d1079bfdff42c42134779bb58a591 namespace=moby +time="2026-10-06T09:48:39.223110895+08:00" level=info msg="cleaning up after shim disconnected" id=bd6b766d6d01cfceef9f195b7f5ce1c03d8d1079bfdff42c42134779bb58a591 namespace=moby +time="2026-10-06T09:48:39.223121387+08:00" level=info msg="cleaning up dead shim" id=bd6b766d6d01cfceef9f195b7f5ce1c03d8d1079bfdff42c42134779bb58a591 namespace=moby +time="2026-10-06T09:50:45.662699862+08:00" level=info msg="received task-delete event from containerd" container=04124b048ce782db915127de39d11dc3e2b832f058e184cb506470f899961933 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:50:45.663202201+08:00" level=info msg="shim disconnected" id=04124b048ce782db915127de39d11dc3e2b832f058e184cb506470f899961933 namespace=moby +time="2026-10-06T09:50:45.665511978+08:00" level=info msg="cleaning up after shim disconnected" id=04124b048ce782db915127de39d11dc3e2b832f058e184cb506470f899961933 namespace=moby +time="2026-10-06T09:50:45.665519426+08:00" level=info msg="cleaning up dead shim" id=04124b048ce782db915127de39d11dc3e2b832f058e184cb506470f899961933 namespace=moby +time="2026-10-06T09:54:21.460723753+08:00" level=info msg="shim disconnected" id=62a9433ef792429c5351c1acfa2901f63a56195bd1e99523336e1c1396cf429d namespace=moby +time="2026-10-06T09:54:21.460852410+08:00" level=info msg="received task-delete event from containerd" container=62a9433ef792429c5351c1acfa2901f63a56195bd1e99523336e1c1396cf429d module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T09:54:21.463530646+08:00" level=info msg="cleaning up after shim disconnected" id=62a9433ef792429c5351c1acfa2901f63a56195bd1e99523336e1c1396cf429d namespace=moby +time="2026-10-06T09:54:21.463543704+08:00" level=info msg="cleaning up dead shim" id=62a9433ef792429c5351c1acfa2901f63a56195bd1e99523336e1c1396cf429d namespace=moby +time="2026-10-06T09:54:28.170395492+08:00" level=info msg="connecting to shim f0ed685ab0229c34f9220403c654bc2a3272bf7112d6d089292f044ff39d64b6" address="unix:///run/containerd/s/2f66ead606b06a8c1a9d076964f00d88ba87db1526437706220bb71a003f7e3d" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:54:28.273363647+08:00" level=error msg="loading cgroup for 443127" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:54:28.275001945+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=df2e79cc0bab ep=lm-curves-10491e108cd82865b30f net=none nid=f13f14be1124 +time="2026-10-06T09:54:28.694556708+08:00" level=info msg="connecting to shim d199355137d822b1be9cdac097d5d2424a1b8d34eba7ffd53e0e8dfc21447427" address="unix:///run/containerd/s/ef8c5e5b1a55c5f47a56c02f13af230a8fe6b1dd1927136d5c1406e79da44107" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:54:28.797681235+08:00" level=error msg="loading cgroup for 443610" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:54:28.799278313+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=df652f4e3bf5 ep=lm-curves-d0e0a6854cb9eb57d0ef net=none nid=f13f14be1124 +time="2026-10-06T09:54:29.263579076+08:00" level=info msg="connecting to shim a35c5d213ac29a80aa15dace18a22d35e204bbadc095fdb197bea1f811d00ef3" address="unix:///run/containerd/s/256b4338aff4478fb97e3629eaf5eb3320a30190592af0a6c79a3610dc7fafab" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:54:29.381899146+08:00" level=error msg="loading cgroup for 444121" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:54:29.383537962+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=04b7f569768a ep=lm-curves-fa87f14c661346646ba0 net=none nid=f13f14be1124 +time="2026-10-06T09:54:29.788845764+08:00" level=info msg="connecting to shim ec65ac021c08cfb0a53a3e9e7dd458a1cbb18db67f12813acbddd12dfcfda38c" address="unix:///run/containerd/s/e6658b3906947c392ffb6662f8a9c3a776afdb7f59fa345796c4a273be3cf3a1" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:54:29.927332104+08:00" level=error msg="loading cgroup for 444647" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:54:29.929268049+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=24d39baf14fc ep=lm-curves-705447ef97f8f4d35254 net=none nid=f13f14be1124 +time="2026-10-06T09:54:30.331553174+08:00" level=info msg="connecting to shim c7b22a3379f61e1c0f0c6f060b63131b3ada2f3607d7d9348037f7fd4b15ff57" address="unix:///run/containerd/s/33ff46c870be6a336fa7c5bf07b82e875888df5ecda78027a9400b9d07786527" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T09:54:30.435142164+08:00" level=error msg="loading cgroup for 445142" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T09:54:30.436865655+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=6be670899e68 ep=lm-curves-d63d3beb7a474a7e7c33 net=none nid=f13f14be1124 +time="2026-10-06T10:09:00.451366855+08:00" level=info msg="received task-delete event from containerd" container=5afd787967f0d45894b594bfd72c7c8fc0a25732a630a25e0c80fba98f871a6a module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T10:09:00.451487739+08:00" level=info msg="shim disconnected" id=5afd787967f0d45894b594bfd72c7c8fc0a25732a630a25e0c80fba98f871a6a namespace=moby +time="2026-10-06T10:09:00.454184917+08:00" level=info msg="cleaning up after shim disconnected" id=5afd787967f0d45894b594bfd72c7c8fc0a25732a630a25e0c80fba98f871a6a namespace=moby +time="2026-10-06T10:09:00.454196169+08:00" level=info msg="cleaning up dead shim" id=5afd787967f0d45894b594bfd72c7c8fc0a25732a630a25e0c80fba98f871a6a namespace=moby +time="2026-10-06T10:10:11.533125843+08:00" level=info msg="received task-delete event from containerd" container=d15d72339973e2190140bb25cc79130d7c194f2931f6e44366e2c270dcf4bca4 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T10:10:11.533143734+08:00" level=info msg="shim disconnected" id=d15d72339973e2190140bb25cc79130d7c194f2931f6e44366e2c270dcf4bca4 namespace=moby +time="2026-10-06T10:10:11.535915084+08:00" level=info msg="cleaning up after shim disconnected" id=d15d72339973e2190140bb25cc79130d7c194f2931f6e44366e2c270dcf4bca4 namespace=moby +time="2026-10-06T10:10:11.535922671+08:00" level=info msg="cleaning up dead shim" id=d15d72339973e2190140bb25cc79130d7c194f2931f6e44366e2c270dcf4bca4 namespace=moby +time="2026-10-06T10:10:17.991542684+08:00" level=info msg="connecting to shim 059495f5690ced5863a574bcfeac5c03bc2241267b07128c994d3b5facd47753" address="unix:///run/containerd/s/566a9de3e1e0c619a975ea94190156c1765b0c70eabe0e4953942c28bcb496e3" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T10:10:18.100421325+08:00" level=error msg="loading cgroup for 452681" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T10:10:18.102056691+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=1af8c8746530 ep=lm-curves-5ec98de2b5ebd251e03e net=none nid=f13f14be1124 +time="2026-10-06T10:10:18.526851410+08:00" level=info msg="connecting to shim d651d2221f7efb3cbbdcc103931586ff7b4316f735c8fae945bbdee319b57e16" address="unix:///run/containerd/s/64011bbf65d5eaef0719ed0a2d3f8bc7ce29f4a0954dd79ee096e8ea87f6b1f6" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T10:10:18.643310111+08:00" level=error msg="loading cgroup for 453171" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T10:10:18.645401952+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=ff884953e93f ep=lm-curves-822ab7a6ef69a14b127b net=none nid=f13f14be1124 +time="2026-10-06T10:57:54.971705021+08:00" level=info msg="received task-delete event from containerd" container=d651d2221f7efb3cbbdcc103931586ff7b4316f735c8fae945bbdee319b57e16 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T10:57:54.971796711+08:00" level=info msg="shim disconnected" id=d651d2221f7efb3cbbdcc103931586ff7b4316f735c8fae945bbdee319b57e16 namespace=moby +time="2026-10-06T10:57:54.974595498+08:00" level=info msg="cleaning up after shim disconnected" id=d651d2221f7efb3cbbdcc103931586ff7b4316f735c8fae945bbdee319b57e16 namespace=moby +time="2026-10-06T10:57:54.974602856+08:00" level=info msg="cleaning up dead shim" id=d651d2221f7efb3cbbdcc103931586ff7b4316f735c8fae945bbdee319b57e16 namespace=moby +time="2026-10-06T10:57:58.463232117+08:00" level=info msg="connecting to shim acdcf91ff3e2f6c67e0fbb552234f917cb5acdb702e9ea910d504fdcde7f97ae" address="unix:///run/containerd/s/c6f5943c4094d7991ea091c917260c262f279fd9e16bc713f72d9d7f9de22f8f" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T10:57:58.573625500+08:00" level=error msg="loading cgroup for 475082" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T10:57:58.575240338+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=b5b97f1a3023 ep=lm-curves-0552d31c44af432a63a6 net=none nid=f13f14be1124 +time="2026-10-06T11:23:43.750930819+08:00" level=info msg="received task-delete event from containerd" container=ec65ac021c08cfb0a53a3e9e7dd458a1cbb18db67f12813acbddd12dfcfda38c module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T11:23:43.751286597+08:00" level=info msg="shim disconnected" id=ec65ac021c08cfb0a53a3e9e7dd458a1cbb18db67f12813acbddd12dfcfda38c namespace=moby +time="2026-10-06T11:23:43.753791973+08:00" level=info msg="cleaning up after shim disconnected" id=ec65ac021c08cfb0a53a3e9e7dd458a1cbb18db67f12813acbddd12dfcfda38c namespace=moby +time="2026-10-06T11:23:43.753801339+08:00" level=info msg="cleaning up dead shim" id=ec65ac021c08cfb0a53a3e9e7dd458a1cbb18db67f12813acbddd12dfcfda38c namespace=moby +time="2026-10-06T11:23:43.843444584+08:00" level=info msg="shim disconnected" id=c7b22a3379f61e1c0f0c6f060b63131b3ada2f3607d7d9348037f7fd4b15ff57 namespace=moby +time="2026-10-06T11:23:43.843481712+08:00" level=info msg="cleaning up after shim disconnected" id=c7b22a3379f61e1c0f0c6f060b63131b3ada2f3607d7d9348037f7fd4b15ff57 namespace=moby +time="2026-10-06T11:23:43.843492645+08:00" level=info msg="cleaning up dead shim" id=c7b22a3379f61e1c0f0c6f060b63131b3ada2f3607d7d9348037f7fd4b15ff57 namespace=moby +time="2026-10-06T11:23:43.843593517+08:00" level=info msg="received task-delete event from containerd" container=c7b22a3379f61e1c0f0c6f060b63131b3ada2f3607d7d9348037f7fd4b15ff57 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T11:23:44.928385217+08:00" level=info msg="connecting to shim e0c2fe4cfbe5ce10fd6ccd1d405db46c5a41580bff153df40687021d47ebd92e" address="unix:///run/containerd/s/df45c5903e5f06492ebdd8c9cf2c1085d779d5f110cf3c1129d64c35e5dd7694" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T11:23:45.033164727+08:00" level=error msg="loading cgroup for 487206" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T11:23:45.035065275+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=ebab4f6613d9 ep=lm-curves-06eab68314c320db5b12 net=none nid=f13f14be1124 +time="2026-10-06T11:23:45.419978520+08:00" level=info msg="connecting to shim c505a46302c0488f811e21618d7646555fd2d2b8c624c693eb9ac80bb27ddae4" address="unix:///run/containerd/s/4daf96a4ed6c4e6fdd9baca02de10026e24f70d273788be43f2b6987917ba8a3" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T11:23:45.521093967+08:00" level=error msg="loading cgroup for 487697" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T11:23:45.522599075+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=d3291a9a6f3b ep=lm-curves-fd1dbfc6864b58884c4d net=none nid=f13f14be1124 +time="2026-10-06T11:41:56.774668103+08:00" level=info msg="shim disconnected" id=059495f5690ced5863a574bcfeac5c03bc2241267b07128c994d3b5facd47753 namespace=moby +time="2026-10-06T11:41:56.774753833+08:00" level=info msg="received task-delete event from containerd" container=059495f5690ced5863a574bcfeac5c03bc2241267b07128c994d3b5facd47753 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T11:41:56.777496381+08:00" level=info msg="cleaning up after shim disconnected" id=059495f5690ced5863a574bcfeac5c03bc2241267b07128c994d3b5facd47753 namespace=moby +time="2026-10-06T11:41:56.777514319+08:00" level=info msg="cleaning up dead shim" id=059495f5690ced5863a574bcfeac5c03bc2241267b07128c994d3b5facd47753 namespace=moby +time="2026-10-06T11:41:59.406282124+08:00" level=info msg="connecting to shim 690d1ee1ab26e725bda7b86f5419ab159d4ef477c0873f6f5e78ee9f5f0792ce" address="unix:///run/containerd/s/ab3a6c9eb98cf18ed24c0edd322839bd608eda87cee6b4e07c9a8defa717aa76" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T11:41:59.513702977+08:00" level=error msg="loading cgroup for 498911" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T11:41:59.515887720+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=a8dba774cf16 ep=lm-curves-235a62b25488a397a83e net=none nid=f13f14be1124 +time="2026-10-06T11:44:04.549614081+08:00" level=info msg="received task-delete event from containerd" container=acdcf91ff3e2f6c67e0fbb552234f917cb5acdb702e9ea910d504fdcde7f97ae module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T11:44:04.549622721+08:00" level=info msg="shim disconnected" id=acdcf91ff3e2f6c67e0fbb552234f917cb5acdb702e9ea910d504fdcde7f97ae namespace=moby +time="2026-10-06T11:44:04.552501225+08:00" level=info msg="cleaning up after shim disconnected" id=acdcf91ff3e2f6c67e0fbb552234f917cb5acdb702e9ea910d504fdcde7f97ae namespace=moby +time="2026-10-06T11:44:04.552508806+08:00" level=info msg="cleaning up dead shim" id=acdcf91ff3e2f6c67e0fbb552234f917cb5acdb702e9ea910d504fdcde7f97ae namespace=moby +time="2026-10-06T11:44:05.872021598+08:00" level=info msg="connecting to shim d0f2f4d60dd5a3d926606ea874b11ea191fc4a093eac3f32eadd3a5017ffe7da" address="unix:///run/containerd/s/0734ac6fe32cd1d547481c4d121489a8cd3abaa63eceac2b838c76ea027c8be9" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T11:44:06.012261579+08:00" level=error msg="loading cgroup for 501284" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T11:44:06.014105501+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=7cf866c0c01c ep=lm-curves-7dc9ca7aabe96b06c0fd net=none nid=f13f14be1124 +time="2026-10-06T11:47:14.829874080+08:00" level=info msg="shim disconnected" id=c505a46302c0488f811e21618d7646555fd2d2b8c624c693eb9ac80bb27ddae4 namespace=moby +time="2026-10-06T11:47:14.829911091+08:00" level=info msg="received task-delete event from containerd" container=c505a46302c0488f811e21618d7646555fd2d2b8c624c693eb9ac80bb27ddae4 module=libcontainerd namespace=moby topic=/tasks/delete type="*events.TaskDelete" +time="2026-10-06T11:47:14.832643835+08:00" level=info msg="cleaning up after shim disconnected" id=c505a46302c0488f811e21618d7646555fd2d2b8c624c693eb9ac80bb27ddae4 namespace=moby +time="2026-10-06T11:47:14.832666451+08:00" level=info msg="cleaning up dead shim" id=c505a46302c0488f811e21618d7646555fd2d2b8c624c693eb9ac80bb27ddae4 namespace=moby +time="2026-10-06T11:47:15.740938315+08:00" level=info msg="connecting to shim 138e3bc376267a47eb70c0f886567d572e1bd86b84afe747c5fa19fa05415952" address="unix:///run/containerd/s/fa88d5f789106f9c1216f9e5e18b3f4be0e4a2dc1d832fb4330b091b2bd55836" namespace=moby protocol=ttrpc version=3 +time="2026-10-06T11:47:15.843063851+08:00" level=error msg="loading cgroup for 503948" error="cgroups: cannot find cgroup mount destination" runtime=io.containerd.runc.v2 +time="2026-10-06T11:47:15.844682345+08:00" level=info msg="sbJoin: gwep4 ''->'', gwep6 ''->''" eid=892dc1b1e664 ep=lm-curves-49b725a6c173c8a8ea9b net=none nid=f13f14be1124 diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/analysis-execution.json b/docs/development-artifacts/oo-budget-attribution-20261005/analysis-execution.json new file mode 100644 index 0000000000000000000000000000000000000000..df70d16fb11039d25a87abe84d764407768561e7 --- /dev/null +++ b/docs/development-artifacts/oo-budget-attribution-20261005/analysis-execution.json @@ -0,0 +1,41 @@ +{ + "real_loop": { + "oo_percent": 16.73161860223435, + "training_hours": 6.638698058694394, + "estimated_matmul_training_flops": 2775305955439048704, + "executed_input_tokens": 6554798306.666667, + "examples": 153249855, + "atomic_epochs": 1255.2304046406339, + "composition_epochs": 1255.2309414776405, + "n_initializations": 3, + "oo_n_each": 1283, + "oo_sample_sd": 0.6536630618555017 + }, + "synthetic_loop_wd03": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "ratios": { + "training_hours": 1.020827932478953, + "estimated_matmul_training_flops": 1.9600860537562779, + "executed_input_tokens": 2.1337234071180555, + "examples": 0.1997069097316512, + "atomic_epochs": 0.5129707112100568 + }, + "recounted_pools": 81 +} diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/budget-brackets.json b/docs/development-artifacts/oo-budget-attribution-20261005/budget-brackets.json new file mode 100644 index 0000000000000000000000000000000000000000..9ae8af5217eaf79d77be82ea5ee93defb56293e4 --- /dev/null +++ b/docs/development-artifacts/oo-budget-attribution-20261005/budget-brackets.json @@ -0,0 +1,422 @@ +[ + { + "real_run": "confirmation-loop4x2-init1", + "budget": "training_hours", + "real_value": 6.636754266745928, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "synthetic_above": null, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init1", + "budget": "estimated_matmul_training_flops", + "real_value": 2775487015724686848, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "synthetic_above": null, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init1", + "budget": "examples", + "real_value": 153249855, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 296000, + "oo_n": 2004, + "oo_percent": 24.10179640718563, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.2962222684443825, + "estimated_matmul_training_flops": 279406291451904000, + "executed_input_tokens": 606208000, + "examples": 151428608, + "atomic_epochs": 482.872525, + "composition_epochs": 482.8717361111111 + }, + "synthetic_above": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 300000, + "oo_n": 2004, + "oo_percent": 24.451097804391217, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.3134469647612423, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153474816, + "atomic_epochs": 489.39375, + "composition_epochs": 489.39717105263156 + }, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init1", + "budget": "atomic_epochs", + "real_value": 1255.2305814940578, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 768000, + "oo_n": 2004, + "oo_percent": 70.60878243512974, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 3.328787970851279, + "estimated_matmul_training_flops": 724946053496832000, + "executed_input_tokens": 1572864000, + "examples": 392895488, + "atomic_epochs": 1252.856725, + "composition_epochs": 1252.855332602339 + }, + "synthetic_above": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 772000, + "oo_n": 2004, + "oo_percent": 70.50898203592814, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 3.3460153445280674, + "estimated_matmul_training_flops": 728721814192128000, + "executed_input_tokens": 1581056000, + "examples": 394941696, + "atomic_epochs": 1259.380075, + "composition_epochs": 1259.3804568713451 + }, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init2", + "budget": "training_hours", + "real_value": 6.642358209469045, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "synthetic_above": null, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init2", + "budget": "estimated_matmul_training_flops", + "real_value": 2775118595566491648, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "synthetic_above": null, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init2", + "budget": "examples", + "real_value": 153249855, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 296000, + "oo_n": 2004, + "oo_percent": 24.10179640718563, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.2962222684443825, + "estimated_matmul_training_flops": 279406291451904000, + "executed_input_tokens": 606208000, + "examples": 151428608, + "atomic_epochs": 482.872525, + "composition_epochs": 482.8717361111111 + }, + "synthetic_above": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 300000, + "oo_n": 2004, + "oo_percent": 24.451097804391217, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.3134469647612423, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153474816, + "atomic_epochs": 489.39375, + "composition_epochs": 489.39717105263156 + }, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init2", + "budget": "atomic_epochs", + "real_value": 1255.2311120543293, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 768000, + "oo_n": 2004, + "oo_percent": 70.60878243512974, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 3.328787970851279, + "estimated_matmul_training_flops": 724946053496832000, + "executed_input_tokens": 1572864000, + "examples": 392895488, + "atomic_epochs": 1252.856725, + "composition_epochs": 1252.855332602339 + }, + "synthetic_above": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 772000, + "oo_n": 2004, + "oo_percent": 70.50898203592814, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 3.3460153445280674, + "estimated_matmul_training_flops": 728721814192128000, + "executed_input_tokens": 1581056000, + "examples": 394941696, + "atomic_epochs": 1259.380075, + "composition_epochs": 1259.3804568713451 + }, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init3", + "budget": "training_hours", + "real_value": 6.636981699868209, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "synthetic_above": null, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init3", + "budget": "estimated_matmul_training_flops", + "real_value": 2775312255025967616, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "synthetic_above": null, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init3", + "budget": "examples", + "real_value": 153249855, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 296000, + "oo_n": 2004, + "oo_percent": 24.10179640718563, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.2962222684443825, + "estimated_matmul_training_flops": 279406291451904000, + "executed_input_tokens": 606208000, + "examples": 151428608, + "atomic_epochs": 482.872525, + "composition_epochs": 482.8717361111111 + }, + "synthetic_above": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 300000, + "oo_n": 2004, + "oo_percent": 24.451097804391217, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.3134469647612423, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153474816, + "atomic_epochs": 489.39375, + "composition_epochs": 489.39717105263156 + }, + "extrapolated": false + }, + { + "real_run": "confirmation-loop4x2-init3", + "budget": "atomic_epochs", + "real_value": 1255.2295203735143, + "synthetic_below": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 768000, + "oo_n": 2004, + "oo_percent": 70.60878243512974, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 3.328787970851279, + "estimated_matmul_training_flops": 724946053496832000, + "executed_input_tokens": 1572864000, + "examples": 392895488, + "atomic_epochs": 1252.856725, + "composition_epochs": 1252.855332602339 + }, + "synthetic_above": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 772000, + "oo_n": 2004, + "oo_percent": 70.50898203592814, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 3.3460153445280674, + "estimated_matmul_training_flops": 728721814192128000, + "executed_input_tokens": 1581056000, + "examples": 394941696, + "atomic_epochs": 1259.380075, + "composition_epochs": 1259.3804568713451 + }, + "extrapolated": false + } +] diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/budget-comparison.pdf b/docs/development-artifacts/oo-budget-attribution-20261005/budget-comparison.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ee9b798ae2333efe5ad93a7773bb9101648c1b07 Binary files /dev/null and b/docs/development-artifacts/oo-budget-attribution-20261005/budget-comparison.pdf differ diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/budget-comparison.png b/docs/development-artifacts/oo-budget-attribution-20261005/budget-comparison.png new file mode 100644 index 0000000000000000000000000000000000000000..0092500577693ed0022657eda0d4019c95122548 --- /dev/null +++ b/docs/development-artifacts/oo-budget-attribution-20261005/budget-comparison.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c26016c917209e262593b84cff136d96753406c1cf86c4723ce3618c39b60760 +size 177242 diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/endpoints.csv b/docs/development-artifacts/oo-budget-attribution-20261005/endpoints.csv new file mode 100644 index 0000000000000000000000000000000000000000..4e9a5443441a18c7d3c0e0e22e045366242302ff --- /dev/null +++ b/docs/development-artifacts/oo-budget-attribution-20261005/endpoints.csv @@ -0,0 +1,18 @@ +dataset,run,architecture,initialization,learning_rate,weight_decay,phi,step,oo_n,oo_percent,evaluation_scope,training_hours,estimated_matmul_training_flops,executed_input_tokens,examples,atomic_epochs,composition_epochs +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1500000,2004,66.1676646706587,fixed_full_OO_pool,6.511084337063755,1415910260736000000,3072000000,767455728,1479.289375,1479.2902109440267 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1500000,2004,25.64870259481038,fixed_full_OO_pool,6.498463879016539,1415910260736000000,3072000000,766474080,4335.2594,4335.260994152047 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1500000,2004,53.293413173652695,fixed_full_OO_pool,6.48271472582904,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1500000,2004,81.3373253493014,fixed_full_OO_pool,6.5032488311454655,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1500000,2004,0.0,fixed_full_OO_pool,6.750595387809185,1415910260736000000,3072000000,767455728,1479.289375,1479.2902109440267 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1500000,2004,0.39920159680638717,fixed_full_OO_pool,6.9142334482353185,1415910260736000000,3072000000,766474080,4335.2594,4335.260994152047 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1500000,2004,0.19960079840319359,fixed_full_OO_pool,6.740193886749653,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1500000,2004,0.0,fixed_full_OO_pool,6.771571062275519,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,300000,1283,17.069368667186282,full_endpoint,6.636754266745928,2775487015724686848,6555176928,153249855,1255.2305814940578,1255.2307335934854 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,300000,1283,17.1473109898675,full_endpoint,6.642358209469045,2775118595566491648,6554444824,153249855,1255.2311120543293,1255.2301099410204 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,300000,1283,15.97817614964926,full_endpoint,6.636981699868209,2775312255025967616,6554773168,153249855,1255.2295203735143,1255.231980898416 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,300000,1283,16.91348402182385,full_endpoint,4.311865449844756,1651459843050610176,6555176928,153249855,1255.2305814940578,1255.2307335934854 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,300000,1283,17.614964925954794,full_endpoint,4.306228105037784,1651217730075777024,6554444824,153249855,1255.2311120543293,1255.2301099410204 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,300000,1283,16.52377240841777,full_endpoint,4.338233347138804,1651354498478928384,6554773168,153249855,1255.2295203735143,1255.231980898416 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,300000,1283,17.692907248636008,full_endpoint,6.723028642990523,2775487015724686848,6555176928,153249855,1255.2305814940578,1255.2307335934854 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,300000,1283,19.095869056897897,full_endpoint,6.7091564928398775,2775118595566491648,6554444824,153249855,1255.2311120543293,1255.2301099410204 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,300000,1283,16.445830085736556,full_endpoint,6.712122530073135,2775312255025967616,6554773168,153249855,1255.2295203735143,1255.231980898416 diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/learning-budgets.csv b/docs/development-artifacts/oo-budget-attribution-20261005/learning-budgets.csv new file mode 100644 index 0000000000000000000000000000000000000000..48b985fa262d2c3b6094b622bebd0bd457e61c01 --- /dev/null +++ b/docs/development-artifacts/oo-budget-attribution-20261005/learning-budgets.csv @@ -0,0 +1,3508 @@ +dataset,run,architecture,initialization,learning_rate,weight_decay,phi,step,oo_n,oo_percent,evaluation_scope,training_hours,estimated_matmul_training_flops,executed_input_tokens,examples,atomic_epochs,composition_epochs +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,256,2004,0.0,fixed_full_OO_pool,0.0011264851068456968,241648684498944,524288,131072,0.2523,0.2526733500417711 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,512,2004,0.0,fixed_full_OO_pool,0.0022503336725963486,483297368997888,1048576,262144,0.50365,0.5054260651629072 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1000,2004,0.19960079840319359,fixed_full_OO_pool,0.0043915324399454725,943940173824000,2048000,512000,0.987075,0.9868776106934002 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,2000,2004,0.049900199600798396,fixed_full_OO_pool,0.008783450413288341,1887880347648000,4096000,1023632,1.974375,1.97296783625731 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,3000,2004,0.09980039920159679,fixed_full_OO_pool,0.013175336396735576,2831820521472000,6144000,1535264,2.960425,2.9591624895572264 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,4000,2004,0.0,fixed_full_OO_pool,0.01756744347616202,3775760695296000,8192000,2046896,3.945475,3.945440685045948 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,5000,2004,0.049900199600798396,fixed_full_OO_pool,0.02195978020110892,4719700869120000,10240000,2558528,4.931825,4.9316102756892235 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,6000,2004,0.09980039920159679,fixed_full_OO_pool,0.026351420616524086,5663641042944000,12288000,3070160,5.91605,5.917957393483709 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,7000,2004,0.049900199600798396,fixed_full_OO_pool,0.030737496867982876,6607581216768000,14336000,3581792,6.906125,6.9038157894736845 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,8000,2004,0.19960079840319359,fixed_full_OO_pool,0.03512308225242628,7551521390592000,16384000,4093424,7.890175,7.890177527151211 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,9000,2004,0.09980039920159679,fixed_full_OO_pool,0.03951025008844833,8495461564416000,18432000,4605056,8.87215,8.87671261487051 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,10000,2004,0.09980039920159679,fixed_full_OO_pool,0.043895879367159475,9439401738240000,20480000,5116688,9.864275,9.862399749373434 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,11000,2004,0.14970059880239522,fixed_full_OO_pool,0.04827932040207088,10383341912064000,22528000,5628320,10.84815,10.848776106934002 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,12000,2004,0.049900199600798396,fixed_full_OO_pool,0.05266261223807103,11327282085888000,24576000,6139952,11.83435,11.834958228905597 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,13000,2004,0.09980039920159679,fixed_full_OO_pool,0.05704484684289329,12271222259712000,26624000,6651584,12.8211,12.82109440267335 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,14000,2004,0.14970059880239522,fixed_full_OO_pool,0.06142829692715572,13215162433536000,28672000,7163216,13.80495,13.807472848788638 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,15000,2004,0.19960079840319359,fixed_full_OO_pool,0.06581175382869939,14159102607360000,30720000,7674848,14.7969,14.793174603174602 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,16000,2004,0.049900199600798396,fixed_full_OO_pool,0.07019516156158513,15103042781184000,32768000,8186480,15.77815,15.779770258980784 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,17000,2004,0.09980039920159679,fixed_full_OO_pool,0.07457911820668313,16046982955008000,34816000,8698112,16.769375,16.765532581453634 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,18000,2004,0.19960079840319359,fixed_full_OO_pool,0.07896248719861938,16990923128832000,36864000,9209744,17.7471,17.752422723475355 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,19000,2004,0.09980039920159679,fixed_full_OO_pool,0.08334622202441096,17934863302656000,38912000,9721376,18.74205,18.737873851294903 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,20000,2004,0.29940119760479045,fixed_full_OO_pool,0.08773017065082159,18878803476480000,40960000,10233008,19.72475,19.72434837092732 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,21000,2004,0.049900199600798396,fixed_full_OO_pool,0.09211379831035932,19822743650304000,43008000,10744640,20.711275,20.710503341687552 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,22000,2004,0.14970059880239522,fixed_full_OO_pool,0.0964975206595328,20766683824128000,45056000,11256272,21.697075,21.69671888053467 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,23000,2004,0.19960079840319359,fixed_full_OO_pool,0.10088141757477488,21710623997952000,47104000,11767904,22.68105,22.683086883876356 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,24000,2004,0.049900199600798396,fixed_full_OO_pool,0.10526494316756725,22654564171776000,49152000,12279536,23.66945,23.66908521303258 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,25000,2004,0.19960079840319359,fixed_full_OO_pool,0.10964859043351478,23598504345600000,51200000,12791168,24.65525,24.6553007518797 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,26000,2004,0.249500998003992,fixed_full_OO_pool,0.11403256753149132,24542444519424000,53248000,13302800,25.6451,25.641177944862154 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,27000,2004,0.14970059880239522,fixed_full_OO_pool,0.11841594220346047,25486384693248000,55296000,13814432,26.625975,26.62780492898914 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,28000,2004,0.19960079840319359,fixed_full_OO_pool,0.12279937714752223,26430324867072000,57344000,14326064,27.6133,27.61389306599833 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,29000,2004,0.34930139720558884,fixed_full_OO_pool,0.12718272363042665,27374265040896000,59392000,14837696,28.60135,28.599920634920636 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,30000,2004,0.19960079840319359,fixed_full_OO_pool,0.13156604811238745,28318205214720000,61440000,15349328,29.59035,29.585868838763577 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,31000,2004,0.19960079840319359,fixed_full_OO_pool,0.13594946884239714,29262145388544000,63488000,15860960,30.574025,30.572261904761906 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,32000,2004,0.0,fixed_full_OO_pool,0.1403329045853267,30206085562368000,65536000,16372592,31.556425,31.558761487050962 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,33000,2004,0.14970059880239522,fixed_full_OO_pool,0.1447164413312243,31150025736192000,67584000,16884224,32.542725,32.544935254803676 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,34000,2004,0.29940119760479045,fixed_full_OO_pool,0.1490999847671224,32093965910016000,69632000,17395856,33.532725,33.53079991645781 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,35000,2004,0.34930139720558884,fixed_full_OO_pool,0.1534840224766069,33037906083840000,71680000,17907488,34.516,34.51722639933166 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,36000,2004,0.34930139720558884,fixed_full_OO_pool,0.1578674753362106,33981846257664000,73728000,18419120,35.5008,35.503525480367585 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,37000,2004,0.049900199600798396,fixed_full_OO_pool,0.16225073203961882,34925786431488000,75776000,18930752,36.485475,36.48983500417711 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,38000,2004,0.09980039920159679,fixed_full_OO_pool,0.16663421044540075,35869726605312000,77824000,19442384,37.476925,37.475578529657476 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,39000,2004,0.29940119760479045,fixed_full_OO_pool,0.1710177705074764,36813666779136000,79872000,19954016,38.456575,38.46230785296575 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,40000,2004,0.29940119760479045,fixed_full_OO_pool,0.17540109439442556,37757606952960000,81920000,20465648,39.448025,39.44805137844612 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,41000,2004,0.14970059880239522,fixed_full_OO_pool,0.17978425553792882,38701547126784000,83968000,20977280,40.43455,40.43420634920635 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,42000,2004,0.19960079840319359,fixed_full_OO_pool,0.18416739330006143,39645487300608000,86016000,21488912,41.423575,41.42015246449457 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,43000,2004,0.29940119760479045,fixed_full_OO_pool,0.1885509129220413,40589427474432000,88064000,22000544,42.407,42.4065664160401 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,44000,2004,0.09980039920159679,fixed_full_OO_pool,0.19293454037772284,41533367648256000,90112000,22512176,43.387825,43.393197577276524 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,45000,2004,0.14970059880239522,fixed_full_OO_pool,0.19731828603065676,42477307822080000,92160000,23023808,44.382,44.378713450292395 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,46000,2004,0.049900199600798396,fixed_full_OO_pool,0.2017019243331419,43421247995904000,94208000,23535440,45.367575,45.364947786132 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,47000,2004,0.049900199600798396,fixed_full_OO_pool,0.20608550226522818,44365188169728000,96256000,24047072,46.35905,46.35068922305764 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,48000,2004,0.19960079840319359,fixed_full_OO_pool,0.21046888198186126,45309128343552000,98304000,24558704,47.3395,47.33735171261487 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,49000,2004,0.14970059880239522,fixed_full_OO_pool,0.2148523997173955,46253068517376000,100352000,25070336,48.32365,48.32370509607352 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,50000,2004,0.14970059880239522,fixed_full_OO_pool,0.2192356690309114,47197008691200000,102400000,25581968,49.314,49.30954051796157 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,51000,2004,0.09980039920159679,fixed_full_OO_pool,0.22361892821163767,48140948865024000,104448000,26093600,50.29575,50.29609440267335 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,52000,2004,0.14970059880239522,fixed_full_OO_pool,0.22800240890329912,49084889038848000,106496000,26605232,51.282575,51.28222431077694 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,53000,2004,0.29940119760479045,fixed_full_OO_pool,0.23238592775952485,50028829212672000,108544000,27116864,52.267425,52.268519214703424 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,54000,2004,0.34930139720558884,fixed_full_OO_pool,0.23676952939790985,50972769386496000,110592000,27628496,53.2517,53.25486215538847 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,55000,2004,0.39920159680638717,fixed_full_OO_pool,0.241153027208315,51916709560320000,112640000,28140128,54.240525,54.24082497911445 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,56000,2004,0.499001996007984,fixed_full_OO_pool,0.2455364552937034,52860649734144000,114688000,28651760,55.2228,55.22733500417711 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,57000,2004,0.39920159680638717,fixed_full_OO_pool,0.24992003388392428,53804589907968000,116736000,29163392,56.212025,56.213264411027566 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,58000,2004,0.34930139720558884,fixed_full_OO_pool,0.25430335791160663,54748530081792000,118784000,29675024,57.1979,57.199473684210524 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,59000,2004,0.14970059880239522,fixed_full_OO_pool,0.25868698121876355,55692470255616000,120832000,30186656,58.1871,58.18540517961571 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,60000,2004,0.29940119760479045,fixed_full_OO_pool,0.2630706515349448,56636410429440000,122880000,30698288,59.17475,59.171466165413534 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,61000,2004,0.249500998003992,fixed_full_OO_pool,0.26745444639585914,57580350603264000,124928000,31209920,60.15705,60.15797410192147 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,62000,2004,0.499001996007984,fixed_full_OO_pool,0.27183844283844033,58524290777088000,126976000,31721552,61.1441,61.14408521303258 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,63000,2004,0.29940119760479045,fixed_full_OO_pool,0.2762221916537318,59468230950912000,129024000,32233184,62.127825,62.13047410192147 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,64000,2004,0.4491017964071856,fixed_full_OO_pool,0.2806026085331622,60412171124736000,131072000,32744816,63.117175,63.11639306599833 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,68000,2004,0.8483033932135728,fixed_full_OO_pool,0.2981324706599116,64187931820032000,139264000,34791344,67.061125,67.0611925647452 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,72000,2004,0.34930139720558884,fixed_full_OO_pool,0.3156664288271632,67963692515328000,147456000,36837872,71.005925,71.00592105263158 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,76000,2004,0.8483033932135728,fixed_full_OO_pool,0.3332004298745758,71739453210624000,155648000,38884768,74.949575,74.95151420217209 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,80000,2004,0.9481037924151697,fixed_full_OO_pool,0.35073607750133506,75515213905920000,163840000,40931296,78.89815,78.89592731829573 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,84000,2004,0.5988023952095809,fixed_full_OO_pool,0.3682708493578765,79290974601216000,172032000,42977824,82.84205,82.84073099415205 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,88000,2004,1.0479041916167664,fixed_full_OO_pool,0.38580345401126476,83066735296512000,180224000,45024352,86.786175,86.78551587301587 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,92000,2004,1.1477045908183632,fixed_full_OO_pool,0.40333699104169174,86842495991808000,188416000,47070880,90.73005,90.7303216374269 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,96000,2004,0.998003992015968,fixed_full_OO_pool,0.4208700448616097,90618256687104000,196608000,49117408,94.676525,94.67491019214704 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,100000,2004,0.9481037924151697,fixed_full_OO_pool,0.43840311814099553,94394017382400000,204800000,51163936,98.6235,98.61945697577276 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,104000,2004,1.2974051896207583,fixed_full_OO_pool,0.45593613242006137,98169778077696000,212992000,53210464,102.56425,102.5645238095238 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,108000,2004,1.4471057884231537,fixed_full_OO_pool,0.4734694231849992,101945538772992000,221184000,55256992,106.5066,106.50945697577276 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,112000,2004,1.4471057884231537,fixed_full_OO_pool,0.49100260523354844,105721299468288000,229376000,57303520,110.4543,110.45394319131161 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,116000,2004,1.347305389221557,fixed_full_OO_pool,0.5085292713933934,109497060163584000,237568000,59350048,114.39625,114.39890977443609 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,120000,2004,1.6966067864271457,fixed_full_OO_pool,0.5260631315751622,113272820858880000,245760000,61396576,118.348,118.34305764411027 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,124000,2004,1.8463073852295409,fixed_full_OO_pool,0.5435961325528721,117048581554176000,253952000,63443104,122.288125,122.28817669172932 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,128000,2004,1.5469061876247505,fixed_full_OO_pool,0.5611295100146284,120824342249472000,262144000,65489632,126.23295,126.23290309106099 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,132000,2004,1.5469061876247505,fixed_full_OO_pool,0.5786624700451891,124600102944768000,270336000,67536160,130.1785,130.17756892230577 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,136000,2004,1.347305389221557,fixed_full_OO_pool,0.5961954909159491,128375863640064000,278528000,69582688,134.123125,134.1223120300752 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,140000,2004,1.6467065868263475,fixed_full_OO_pool,0.6137289121457272,132151624335360000,286720000,71629216,138.068175,138.06701963241437 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,144000,2004,1.7964071856287425,fixed_full_OO_pool,0.6312624423298985,135927385030656000,294912000,73675744,142.011775,142.0118483709273 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,148000,2004,2.095808383233533,fixed_full_OO_pool,0.6487950247577909,139703145725952000,303104000,75722640,145.9561,145.9573851294904 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,152000,2004,1.8463073852295409,fixed_full_OO_pool,0.6663293494470417,143478906421248000,311296000,77769168,149.90305,149.90193400167084 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,156000,2004,1.6467065868263475,fixed_full_OO_pool,0.6838649629842903,147254667116544000,319488000,79815696,153.8477,153.84667502088556 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,160000,2004,2.245508982035928,fixed_full_OO_pool,0.7013982638395909,151030427811840000,327680000,81862224,157.793675,157.79130534670009 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,164000,2004,1.2974051896207583,fixed_full_OO_pool,0.7189187440721111,154806188507136000,335872000,83908752,161.73125,161.7366374269006 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,168000,2004,1.5968063872255487,fixed_full_OO_pool,0.736451875920304,158581949202432000,344064000,85955280,165.68395,165.6807059314954 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,172000,2004,1.8962075848303395,fixed_full_OO_pool,0.7539849399081948,162357709897728000,352256000,88001808,169.623225,169.62589598997494 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,176000,2004,2.19560878243513,fixed_full_OO_pool,0.7715180669166147,166133470593024000,360448000,90048336,173.570325,173.57043233082706 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,180000,2004,1.6467065868263475,fixed_full_OO_pool,0.7890499475391375,169909231288320000,368640000,92094864,177.5097,177.5156140350877 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,184000,2004,2.2954091816367264,fixed_full_OO_pool,0.8065750513060226,173684991983616000,376832000,94141392,181.454675,181.46032790309107 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,188000,2004,1.996007984031936,fixed_full_OO_pool,0.8240949280218531,177460752678912000,385024000,96187920,185.401775,185.4048642439432 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,192000,2004,2.095808383233533,fixed_full_OO_pool,0.8416275832222567,181236513374208000,393216000,98234448,189.346675,189.34958437761068 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,196000,2004,2.3952095808383236,fixed_full_OO_pool,0.8591604144912627,185012274069504000,401408000,100280976,193.293425,193.2941499582289 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,200000,2004,2.7944111776447107,fixed_full_OO_pool,0.8766930909961876,188788034764800000,409600000,102327504,197.237125,197.23897034252298 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,204000,2004,2.1457085828343314,fixed_full_OO_pool,0.8942254761513323,192563795460096000,417792000,104374032,201.1831,201.1836006683375 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,208000,2004,2.19560878243513,fixed_full_OO_pool,0.9117454981400321,196339556155392000,425984000,106420560,205.129375,205.12820593149542 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,212000,2004,3.0439121756487024,fixed_full_OO_pool,0.9292786946768562,200115316850688000,434176000,108467088,209.074025,209.0729469507101 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,216000,2004,2.1457085828343314,fixed_full_OO_pool,0.9468104309205794,203891077545984000,442368000,110513616,213.017225,213.01780910609858 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,220000,2004,2.8942115768463075,fixed_full_OO_pool,0.9643417005965279,207666838241280000,450560000,112560512,216.961725,216.9633312447786 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,224000,2004,2.4451097804391217,fixed_full_OO_pool,0.9818757485039532,211442598936576000,458752000,114607040,220.908375,220.9079051796157 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,228000,2004,2.694610778443114,fixed_full_OO_pool,0.9994094627402309,215218359631872000,466944000,116653568,224.85025,224.85287802840435 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,232000,2004,3.093812375249501,fixed_full_OO_pool,1.0169412728450777,218994120327168000,475136000,118700096,228.7979,228.79736842105262 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,236000,2004,3.74251497005988,fixed_full_OO_pool,1.034472599827374,222769881022464000,483328000,120746624,232.7386,232.7424394319131 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,240000,2004,2.844311377245509,fixed_full_OO_pool,1.0520039528722152,226545641717760000,491520000,122793152,236.6863,236.68692564745197 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,244000,2004,2.944111776447106,fixed_full_OO_pool,1.0695355353959732,230321402413056000,499712000,124839680,240.6318,240.6315956558062 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,248000,2004,2.694610778443114,fixed_full_OO_pool,1.0870668436172937,234097163108352000,507904000,126886208,244.5788,244.57614035087718 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,252000,2004,2.4950099800399204,fixed_full_OO_pool,1.104598544296912,237872923803648000,516096000,128932736,248.51955,248.52120718462822 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,256000,2004,2.944111776447106,fixed_full_OO_pool,1.1221303786140764,241648684498944000,524288000,130979264,252.4649,252.46588972431078 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,260000,2004,3.5429141716566868,fixed_full_OO_pool,1.139662616847911,245424445194240000,532480000,133025792,256.409675,256.4106203007519 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,264000,2004,3.3932135728542914,fixed_full_OO_pool,1.1571949429727262,249200205889536000,540672000,135072320,260.35665,260.3551670843776 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,268000,2004,3.842315369261477,fixed_full_OO_pool,1.1747234640622304,252975966584832000,548864000,137118848,264.299525,264.30005639097743 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,272000,2004,4.5409181636726546,fixed_full_OO_pool,1.1922559921650422,256751727280128000,557056000,139165376,268.24625,268.2446240601504 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,276000,2004,3.992015968063872,fixed_full_OO_pool,1.209787278768296,260527487975424000,565248000,141211904,272.1865,272.1897326649958 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,280000,2004,3.842315369261477,fixed_full_OO_pool,1.2273068726207648,264303248670720000,573440000,143258432,276.13645,276.13403091060985 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,284000,2004,4.940119760479042,fixed_full_OO_pool,1.2448390962038602,268079009366016000,581632000,145304960,280.07945,280.0789097744361 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,288000,2004,3.6926147704590817,fixed_full_OO_pool,1.262370440301796,271854770061312000,589824000,147351488,284.0238,284.0236758563074 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,292000,2004,4.141716566866267,fixed_full_OO_pool,1.2799021906095247,275630530756608000,598016000,149398384,287.970075,287.9690497076023 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,296000,2004,3.842315369261477,fixed_full_OO_pool,1.2974365999083965,279406291451904000,606208000,151444912,291.9136,291.9138847117795 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,300000,2004,4.191616766467066,fixed_full_OO_pool,1.314970107605267,283182052147200000,614400000,153491440,295.857875,295.85865705931496 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,304000,2004,4.04191616766467,fixed_full_OO_pool,1.3325019202464157,286957812842496000,622592000,155537968,299.8069,299.80303258145364 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,308000,2004,4.5409181636726546,fixed_full_OO_pool,1.3500335943274613,290733573537792000,630784000,157584496,303.747125,303.7481432748538 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,312000,2004,4.940119760479042,fixed_full_OO_pool,1.367565721573515,294509334233088000,638976000,159631024,307.69255,307.6928195488722 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,316000,2004,5.239520958083832,fixed_full_OO_pool,1.3850971929097755,298285094928384000,647168000,161677552,311.6346,311.6377777777778 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,320000,2004,5.439121756487026,fixed_full_OO_pool,1.4026283233623125,302060855623680000,655360000,163724080,315.581525,315.58232873851296 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,324000,2004,4.441117764471058,fixed_full_OO_pool,1.4201595676400596,305836616318976000,663552000,165770608,319.52895,319.5268379281537 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,328000,2004,5.089820359281437,fixed_full_OO_pool,1.437689954387024,309612377014272000,671744000,167817136,323.471125,323.4717857142857 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,332000,2004,4.940119760479042,fixed_full_OO_pool,1.4552198782728778,313388137709568000,679936000,169863664,327.4165,327.4164661654135 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,336000,2004,5.189620758483033,fixed_full_OO_pool,1.472749783338772,317163898404864000,688128000,171910192,331.355625,331.3616687552214 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,340000,2004,4.8902195608782435,fixed_full_OO_pool,1.4899974067240125,320939659100160000,696320000,173956720,335.303475,335.30614243943194 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,344000,2004,6.487025948103792,fixed_full_OO_pool,1.5072387003619223,324715419795456000,704512000,176003248,339.25255,339.25051378446113 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,348000,2004,5.538922155688622,fixed_full_OO_pool,1.5244802285834318,328491180490752000,712704000,178049776,343.192875,343.1956161236424 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,352000,2004,7.53493013972056,fixed_full_OO_pool,1.541721765006789,332266941186048000,720896000,180096304,347.1385,347.1402756892231 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,356000,2004,7.385229540918163,fixed_full_OO_pool,1.5589629412866715,336042701881344000,729088000,182142832,351.085725,351.08480158730157 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,360000,2004,6.487025948103792,fixed_full_OO_pool,1.5762044983336494,339818462576640000,737280000,184189360,355.028775,355.02967627401836 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,364000,2004,7.135728542914172,fixed_full_OO_pool,1.5934455528969151,343594223271936000,745472000,186236256,358.976375,358.9749394319131 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,368000,2004,6.786427145708583,fixed_full_OO_pool,1.6106881818796197,347369983967232000,753664000,188282784,362.919475,362.91980994152044 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,372000,2004,7.235528942115768,fixed_full_OO_pool,1.62793159591241,351145744662528000,761856000,190329312,366.8682,366.8642105263158 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,376000,2004,8.383233532934131,fixed_full_OO_pool,1.6451719441947839,354921505357824000,770048000,192375840,370.8088,370.80928989139517 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,380000,2004,7.934131736526946,fixed_full_OO_pool,1.6624129914233667,358697266053120000,778240000,194422368,374.7552,374.75388471177945 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,384000,2004,7.335329341317365,fixed_full_OO_pool,1.6796536537270166,362473026748416000,786432000,196468896,378.6998,378.6986299081036 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,388000,2004,8.033932135728543,fixed_full_OO_pool,1.6968943259171727,366248787443712000,794624000,198515424,382.645675,382.643268588137 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,392000,2004,7.135728542914172,fixed_full_OO_pool,1.7141346788934122,370024548139008000,802816000,200561952,386.59005,386.58803258145366 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,396000,2004,8.982035928143713,fixed_full_OO_pool,1.7313745097619377,373800308834304000,811008000,202608480,390.531375,390.5330513784461 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,400000,2004,8.982035928143713,fixed_full_OO_pool,1.7486146565485332,377576069529600000,819200000,204655008,394.4778,394.47764411027566 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,404000,2004,9.3812375249501,fixed_full_OO_pool,1.765855224577503,381351830224896000,827392000,206701536,398.4209,398.42251461988303 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,408000,2004,8.832335329341317,fixed_full_OO_pool,1.7830953071142237,385127590920192000,835584000,208748064,402.3652,402.3672848788638 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,412000,2004,10.578842315369261,fixed_full_OO_pool,1.8003363791408225,388903351615488000,843776000,210794592,406.310375,406.3119820384294 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,416000,2004,9.780439121756487,fixed_full_OO_pool,1.8175767672320622,392679112310784000,851968000,212841120,410.2534,410.25685881370094 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,420000,2004,10.129740518962075,fixed_full_OO_pool,1.8348169269216144,396454873006080000,860160000,214887648,414.19845,414.2015664160401 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,424000,2004,9.780439121756487,fixed_full_OO_pool,1.8520573189182,400230633701376000,868352000,216934176,418.146375,418.1460338345865 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,428000,2004,11.27744510978044,fixed_full_OO_pool,1.8692970147935881,404006394396672000,876544000,218980704,422.090775,422.0907957393484 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,432000,2004,9.880239520958083,fixed_full_OO_pool,1.8865370724598567,407782155091968000,884736000,221027232,426.035375,426.0355409356725 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,436000,2004,10.978043912175648,fixed_full_OO_pool,1.9037770200262054,411557915787264000,892928000,223074128,429.9817,429.980910609858 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,440000,2004,10.62874251497006,fixed_full_OO_pool,1.9210192384674318,415333676482560000,901120000,225120656,433.92495,433.92576858813703 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,444000,2004,11.676646706586826,fixed_full_OO_pool,1.938260899912566,419109437177856000,909312000,227167184,437.87045,437.8704385964912 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,448000,2004,10.928143712574851,fixed_full_OO_pool,1.9555006020050496,422885197873152000,917504000,229213712,441.815125,441.8151775271512 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,452000,2004,11.327345309381236,fixed_full_OO_pool,1.9727407638387133,426660958568448000,925696000,231260240,445.76015,445.7598872180451 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,456000,2004,10.229540918163673,fixed_full_OO_pool,1.9899806871865358,430436719263744000,933888000,233306768,449.7051,449.70460317460316 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,460000,2004,11.57684630738523,fixed_full_OO_pool,2.007221052347579,434212479959040000,942080000,235353296,453.648775,453.64942564745195 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,464000,2004,12.724550898203594,fixed_full_OO_pool,2.0244617539406238,437988240654336000,950272000,237399824,457.594375,457.5940873015873 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,468000,2004,12.325349301397205,fixed_full_OO_pool,2.0417019395830316,441764001349632000,958464000,239446352,461.538475,461.5388742690059 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,472000,2004,12.674650698602793,fixed_full_OO_pool,2.058942266928239,445539762044928000,966656000,241492880,465.48515,465.48344611528825 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,476000,2004,13.17365269461078,fixed_full_OO_pool,2.0761825069702335,449315522740224000,974848000,243539408,469.427525,469.42837719298245 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,480000,2004,12.425149700598801,fixed_full_OO_pool,2.0934231277575925,453091283435520000,983040000,245585936,473.37755,473.3726691729323 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,484000,2004,11.22754491017964,fixed_full_OO_pool,2.1106634947305754,456867044130816000,991232000,247632464,477.320225,477.3175751879699 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,488000,2004,12.674650698602793,fixed_full_OO_pool,2.1279033854614116,460642804826112000,999424000,249678992,481.2619,481.2625647451963 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,492000,2004,14.520958083832337,fixed_full_OO_pool,2.1451442144862893,464418565521408000,1007616000,251725520,485.207775,485.20720342522975 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,496000,2004,15.06986027944112,fixed_full_OO_pool,2.1623845433485176,468194326216704000,1015808000,253772048,489.149375,489.1521992481203 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,500000,2004,15.169660678642716,fixed_full_OO_pool,2.179624812150788,471970086912000000,1024000000,255818576,493.096825,493.09670634920633 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,504000,2004,14.570858283433132,fixed_full_OO_pool,2.1968643495274915,475745847607296000,1032192000,257865104,497.042875,497.0413304093567 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,508000,2004,14.620758483033933,fixed_full_OO_pool,2.2141035692352387,479521608302592000,1040384000,259912000,500.986925,500.9868901420217 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,512000,2004,15.31936127744511,fixed_full_OO_pool,2.2313454139439597,483297368997888000,1048576000,261958528,504.931675,504.93162280701756 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,516000,2004,13.872255489021956,fixed_full_OO_pool,2.248586418689746,487073129693184000,1056768000,264005056,508.8765,508.87634920634923 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,520000,2004,14.171656686626747,fixed_full_OO_pool,2.2658287849856746,490848890388480000,1064960000,266051584,512.823775,512.8208709273183 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,524000,2004,14.870259481037923,fixed_full_OO_pool,2.2830685523649055,494624651083776000,1073152000,268098112,516.7655,516.7658563074352 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,528000,2004,14.471057884231536,fixed_full_OO_pool,2.300308242368822,498400411779072000,1081344000,270144640,520.70885,520.7107059314955 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,532000,2004,15.06986027944112,fixed_full_OO_pool,2.3175490553304554,502176172474368000,1089536000,272191168,524.654275,524.6553822055138 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,536000,2004,15.31936127744511,fixed_full_OO_pool,2.3347893233038484,505951933169664000,1097728000,274237696,528.603875,528.5997096908939 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,540000,2004,14.520958083832337,fixed_full_OO_pool,2.3520288625887287,509727693864960000,1105920000,276284224,532.5465,532.5446198830409 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,544000,2004,15.868263473053892,fixed_full_OO_pool,2.369268703830118,513503454560256000,1114112000,278330752,536.48995,536.4894611528822 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,548000,2004,17.764471057884233,fixed_full_OO_pool,2.3865081297181963,517279215255552000,1122304000,280377280,540.431275,540.4344799498747 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,552000,2004,17.115768463073852,fixed_full_OO_pool,2.4037473561024916,521054975950848000,1130496000,282423808,544.3753,544.3792731829574 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,556000,2004,17.81437125748503,fixed_full_OO_pool,2.4209867907336187,524830736646144000,1138688000,284470336,548.323625,548.3237071846282 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,560000,2004,17.415169660678643,fixed_full_OO_pool,2.4382263908090276,528606497341440000,1146880000,286516864,552.26875,552.2684085213033 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,564000,2004,16.067864271457086,fixed_full_OO_pool,2.4554657107312234,532382258036736000,1155072000,288563392,556.21375,556.2131203007518 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,568000,2004,17.065868263473057,fixed_full_OO_pool,2.472704575928963,536158018732032000,1163264000,290609920,560.155375,560.1581140350877 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,572000,2004,17.315369261477045,fixed_full_OO_pool,2.4899436610730157,539933779427328000,1171456000,292656448,564.104575,564.1024749373433 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,576000,2004,18.7125748502994,fixed_full_OO_pool,2.507182737138743,543709540122624000,1179648000,294702976,568.047425,568.0473663324979 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,580000,2004,17.315369261477045,fixed_full_OO_pool,2.524421921338265,547485300817920000,1187840000,296749872,571.9923,571.9928571428571 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,584000,2004,17.21556886227545,fixed_full_OO_pool,2.5416623920409216,551261061513216000,1196032000,298796400,575.93655,575.9376315789474 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,588000,2004,18.313373253493015,fixed_full_OO_pool,2.5589044845393962,555036822208512000,1204224000,300842928,579.882575,579.8822577276525 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,592000,2004,19.860279441117765,fixed_full_OO_pool,2.576146417512662,558812582903808000,1212416000,302889456,583.82895,583.8268546365915 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,596000,2004,19.411177644710577,fixed_full_OO_pool,2.59338617196824,562588343599104000,1220608000,304935984,587.77205,587.7717251461988 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,600000,2004,17.914171656686626,fixed_full_OO_pool,2.6106257959641517,566364104294400000,1228800000,306982512,591.717225,591.7164223057645 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,604000,2004,19.311377245508982,fixed_full_OO_pool,2.627864647456962,570139864989696000,1236992000,309029040,595.66345,595.6610317460318 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,608000,2004,19.06187624750499,fixed_full_OO_pool,2.6451044987473225,573915625684992000,1245184000,311075568,599.610825,599.605545112782 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,612000,2004,18.912175648702593,fixed_full_OO_pool,2.662344720902749,577691386380288000,1253376000,313122096,603.55215,603.5505639097744 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,616000,2004,18.912175648702593,fixed_full_OO_pool,2.679584210783036,581467147075584000,1261568000,315168624,607.497025,607.4952861319966 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,620000,2004,20.209580838323355,fixed_full_OO_pool,2.6968230058128637,585242907770880000,1269760000,317215152,611.435875,611.4405116959065 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,624000,2004,18.912175648702593,fixed_full_OO_pool,2.714062045292101,589018668466176000,1277952000,319261680,615.384475,615.3849227234754 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,628000,2004,20.25948103792415,fixed_full_OO_pool,2.7313015316954505,592794429161472000,1286144000,321308208,619.331575,619.3294590643275 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,632000,2004,19.760479041916167,fixed_full_OO_pool,2.7485405000444088,596570189856768000,1294336000,323354736,623.275275,623.2742794486215 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,636000,2004,21.706586826347305,fixed_full_OO_pool,2.765779331659691,600345950552064000,1302528000,325401264,627.22015,627.2190016708438 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,640000,2004,20.508982035928145,fixed_full_OO_pool,2.7830188403444156,604121711247360000,1310720000,327447792,631.16145,631.1640225563909 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,644000,2004,21.856287425149702,fixed_full_OO_pool,2.80025805586949,607897471942656000,1318912000,329494320,635.106525,635.1087280701754 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,648000,2004,23.003992015968063,fixed_full_OO_pool,2.817497910582978,611673232637952000,1327104000,331540848,639.05425,639.0532121971596 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,652000,2004,21.606786427145707,fixed_full_OO_pool,2.834737502694544,615448993333248000,1335296000,333587744,642.9987,642.998738512949 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,656000,2004,24.001996007984033,fixed_full_OO_pool,2.851978919796853,619224754028544000,1343488000,335634272,646.94255,646.9435463659148 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,660000,2004,23.602794411177644,fixed_full_OO_pool,2.8692197627056806,623000514723840000,1351680000,337680800,650.8878,650.8882372598162 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,664000,2004,23.802395209580837,fixed_full_OO_pool,2.8864601408804043,626776275419136000,1359872000,339727328,654.829725,654.8332059314954 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,668000,2004,21.606786427145707,fixed_full_OO_pool,2.9036983596026484,630552036114432000,1368064000,341773856,658.774175,658.7779636591479 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,672000,2004,22.205588822355292,fixed_full_OO_pool,2.9209362863645785,634327796809728000,1376256000,343820384,662.72285,662.7223684210526 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,676000,2004,25.798403193612774,fixed_full_OO_pool,2.9381750696959594,638103557505024000,1384448000,345866912,666.668325,666.6670405179616 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,680000,2004,22.45508982035928,fixed_full_OO_pool,2.9554139785478926,641879318200320000,1392640000,347913440,670.610725,670.6119695071011 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,684000,2004,25.149700598802394,fixed_full_OO_pool,2.9726524577890006,645655078895616000,1400832000,349959968,674.56125,674.5562197159566 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,688000,2004,25.499001996007987,fixed_full_OO_pool,2.9898911099653276,649430839590912000,1409024000,352006496,678.501,678.5013700918964 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,692000,2004,24.451097804391217,fixed_full_OO_pool,3.0071295538068648,653206600286208000,1417216000,354053024,682.449675,682.4457748538011 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,696000,2004,25.0499001996008,fixed_full_OO_pool,3.024367719380599,656982360981504000,1425408000,356099552,686.387625,686.3910756056808 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,700000,2004,26.29740518962076,fixed_full_OO_pool,3.0416064822384055,660758121676800000,1433600000,358146080,690.3337,690.3356975772765 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,704000,2004,25.848303393213573,fixed_full_OO_pool,3.058845106171858,664533882372096000,1441792000,360192608,694.278975,694.2803863826232 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,708000,2004,25.59880239520958,fixed_full_OO_pool,3.0760841330834148,668309643067392000,1449984000,362239136,698.221375,698.2253153717627 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,712000,2004,25.0,fixed_full_OO_pool,3.0933228541548465,672085403762688000,1458176000,364285664,702.165875,702.1700689223057 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,716000,2004,25.299401197604794,fixed_full_OO_pool,3.1105620734176287,675861164457984000,1466368000,366332192,706.11495,706.114440267335 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,720000,2004,25.149700598802394,fixed_full_OO_pool,3.127800791842035,679636925153280000,1474560000,368378720,710.05715,710.0593859649123 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,724000,2004,27.844311377245507,fixed_full_OO_pool,3.1450391107321614,683412685848576000,1482752000,370425248,714.00345,714.0039891395155 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,728000,2004,27.59481037924152,fixed_full_OO_pool,3.1622781249849745,687188446543872000,1490944000,372472144,717.9495,717.9493817878028 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,732000,2004,26.59680638722555,fixed_full_OO_pool,3.1795196494625673,690964207239168000,1499136000,374518672,721.892425,721.8942669172932 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,736000,2004,29.34131736526946,fixed_full_OO_pool,3.196761014060014,694739967934464000,1507328000,376565200,725.835325,725.8391541353384 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,740000,2004,28.043912175648707,fixed_full_OO_pool,3.2140008310187196,698515728629760000,1515520000,378611728,729.7834,729.7836090225564 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,744000,2004,27.295409181636725,fixed_full_OO_pool,3.2312396590825583,702291489325056000,1523712000,380658256,733.73045,733.728149540518 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,748000,2004,27.395209580838326,fixed_full_OO_pool,3.248477631983244,706067250020352000,1531904000,382704784,737.67405,737.6729782790309 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,752000,2004,29.69061876247505,fixed_full_OO_pool,3.265716002824613,709843010715648000,1540096000,384751312,741.614875,741.6180388471178 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,756000,2004,28.942115768463072,fixed_full_OO_pool,3.2829554026480765,713618771410944000,1548288000,386797840,745.562975,745.5624916457812 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,760000,2004,31.037924151696604,fixed_full_OO_pool,3.300194598462226,717394532106240000,1556480000,388844368,749.50745,749.5072472848789 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,764000,2004,29.540918163672654,fixed_full_OO_pool,3.317433290777521,721170292801536000,1564672000,390890896,753.451575,753.4520321637427 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,768000,2004,29.44111776447106,fixed_full_OO_pool,3.3346718567133777,724946053496832000,1572864000,392937424,757.396875,757.3967188805346 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,772000,2004,27.744510978043913,fixed_full_OO_pool,3.3519101213684515,728721814192128000,1581056000,394983952,761.3477,761.3409440267335 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,776000,2004,27.844311377245507,fixed_full_OO_pool,3.369147731249945,732497574887424000,1589248000,397030480,765.2836,765.2864160401002 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,780000,2004,30.938123752495013,fixed_full_OO_pool,3.38638548949009,736273335582720000,1597440000,399077008,769.231825,769.23085839599 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,784000,2004,30.439121756487026,fixed_full_OO_pool,3.4036232399423088,740049096278016000,1605632000,401123536,773.177075,773.1755492898914 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,788000,2004,31.487025948103792,fixed_full_OO_pool,3.4208616140888384,743824856973312000,1613824000,403170064,777.12325,777.1201629072682 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,792000,2004,32.23552894211577,fixed_full_OO_pool,3.438099950818966,747600617668608000,1622016000,405216592,781.06215,781.0653842940685 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,796000,2004,34.231536926147704,fixed_full_OO_pool,3.4553375309819563,751376378363904000,1630208000,407263120,785.008825,785.0099561403508 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,800000,2004,34.3313373253493,fixed_full_OO_pool,3.472575051081884,755152139059200000,1638400000,409310016,788.954475,788.9553822055137 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,804000,2004,33.33333333333333,fixed_full_OO_pool,3.4898149175372803,758927899754496000,1646592000,411356544,792.899625,792.9000814536341 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,808000,2004,32.035928143712574,fixed_full_OO_pool,3.5070552294183934,762703660449792000,1654784000,413403072,796.84425,796.8448245614035 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,812000,2004,32.684630738522955,fixed_full_OO_pool,3.524292348957517,766479421145088000,1662976000,415449600,800.7904,800.789440267335 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,816000,2004,32.08582834331337,fixed_full_OO_pool,3.5415311704793324,770255181840384000,1671168000,417496128,804.731925,804.7344423558898 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,820000,2004,32.23552894211577,fixed_full_OO_pool,3.558769534698998,774030942535680000,1679360000,419542656,808.679125,808.678970342523 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,824000,2004,31.636726546906186,fixed_full_OO_pool,3.5760071766128143,777806703230976000,1687552000,421589184,812.630275,812.6231683375105 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,828000,2004,33.23353293413174,fixed_full_OO_pool,3.593245186692932,781582463926272000,1695744000,423635712,816.567525,816.5685275689223 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,832000,2004,33.23353293413174,fixed_full_OO_pool,3.6104833547108703,785358224621568000,1703936000,425682240,820.5127,820.5132247284879 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,836000,2004,34.181636726546905,fixed_full_OO_pool,3.6277212957085836,789133985316864000,1712128000,427728768,824.457475,824.457955304929 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,840000,2004,33.93213572854291,fixed_full_OO_pool,3.6449587106270096,792909746012160000,1720320000,429775296,828.404825,828.4024707602339 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,844000,2004,33.83233532934132,fixed_full_OO_pool,3.662196863291578,796685506707456000,1728512000,431821824,832.34465,832.3476148705096 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,848000,2004,35.62874251497006,fixed_full_OO_pool,3.679436137838703,800461267402752000,1736704000,433868352,836.29,836.2922974101922 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,852000,2004,33.88223552894212,fixed_full_OO_pool,3.6966737770361617,804237028098048000,1744896000,435914880,840.23675,840.2368629908103 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,856000,2004,34.2814371257485,fixed_full_OO_pool,3.713911713955717,808012788793344000,1753088000,437961408,844.181075,844.1816311612364 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,860000,2004,34.181636726546905,fixed_full_OO_pool,3.731149786327862,811788549488640000,1761280000,440007936,848.122725,848.1266228070175 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,864000,2004,35.47904191616767,fixed_full_OO_pool,3.748388372539646,815564310183936000,1769472000,442054464,852.071675,852.0710045948204 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,868000,2004,38.17365269461078,fixed_full_OO_pool,3.765627476765464,819340070879232000,1777664000,444100992,856.0158,856.0157894736842 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,872000,2004,35.778443113772454,fixed_full_OO_pool,3.7828656684089865,823115831574528000,1785856000,446147888,859.96205,859.9611654135339 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,876000,2004,36.27744510978044,fixed_full_OO_pool,3.8001060647175957,826891592269824000,1794048000,448194416,863.9046,863.906081871345 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,880000,2004,38.572854291417165,fixed_full_OO_pool,3.8173470543397383,830667352965120000,1802240000,450240944,867.8483,867.8509022556391 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,884000,2004,35.42914171656687,fixed_full_OO_pool,3.834585110504801,834443113660416000,1810432000,452287472,871.7936,871.7955889724311 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,888000,2004,37.12574850299401,fixed_full_OO_pool,3.851810892013212,838218874355712000,1818624000,454334000,875.74015,875.740171261487 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,892000,2004,35.728542914171655,fixed_full_OO_pool,3.869050073694024,841994635051008000,1826816000,456380528,879.684725,879.6849185463659 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,896000,2004,35.42914171656687,fixed_full_OO_pool,3.8862759126205413,845770395746304000,1835008000,458427056,883.629625,883.6296386800334 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,900000,2004,34.73053892215569,fixed_full_OO_pool,3.9035144635983223,849546156441600000,1843200000,460473584,887.576225,887.5742167919799 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,904000,2004,39.12175648702595,fixed_full_OO_pool,3.9207402980213777,853321917136896000,1851392000,462520112,891.5183,891.5191729323308 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,908000,2004,37.22554890219561,fixed_full_OO_pool,3.9379790083443127,857097677832192000,1859584000,464566640,895.4646,895.463776106934 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,912000,2004,40.5189620758483,fixed_full_OO_pool,3.955213784997662,860873438527488000,1867776000,466613168,899.404325,899.4089285714285 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,916000,2004,39.62075848303393,fixed_full_OO_pool,3.972453534577249,864649199222784000,1875968000,468659696,903.3485,903.353709273183 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,920000,2004,37.6746506986028,fixed_full_OO_pool,3.9896934770461585,868424959918080000,1884160000,470706224,907.300975,907.2977965747702 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,924000,2004,37.82435129740519,fixed_full_OO_pool,4.006933395876032,872200720613376000,1892352000,472752752,911.24055,911.2429615705931 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,928000,2004,40.21956087824351,fixed_full_OO_pool,4.02417270704276,875976481308672000,1900544000,474799280,915.183425,915.187850877193 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,932000,2004,39.321357285429144,fixed_full_OO_pool,4.041398899211652,879752242003968000,1908736000,476845808,919.129725,919.1324540517961 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,936000,2004,40.36926147704591,fixed_full_OO_pool,4.058638974079448,883528002699264000,1916928000,478892336,923.0733,923.0772848788638 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,940000,2004,39.271457085828345,fixed_full_OO_pool,4.075878403153684,887303763394560000,1925120000,480938864,927.021375,927.0217397660819 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,944000,2004,40.96806387225549,fixed_full_OO_pool,4.093117946943061,891079524089856000,1933312000,482985760,930.967325,930.9671407685881 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,948000,2004,40.86826347305389,fixed_full_OO_pool,4.1103592044984305,894855284785152000,1941504000,485032288,934.911025,934.9119611528822 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,952000,2004,40.5688622754491,fixed_full_OO_pool,4.127601178877263,898631045480448000,1949696000,487078816,938.855925,938.8566812865497 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,956000,2004,41.71656686626746,fixed_full_OO_pool,4.144841120631123,902406806175744000,1957888000,489125344,942.80195,942.8013074352548 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,960000,2004,40.818363273453095,fixed_full_OO_pool,4.1620811057690945,906182566871040000,1966080000,491171872,946.743375,946.7463178780284 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,964000,2004,41.91616766467065,fixed_full_OO_pool,4.179319820723807,909958327566336000,1974272000,493218400,950.6899,950.6909022556391 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,968000,2004,42.76447105788423,fixed_full_OO_pool,4.196559637301705,913734088261632000,1982464000,495264928,954.637525,954.6353947368422 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,972000,2004,42.01596806387226,fixed_full_OO_pool,4.213799019828439,917509848956928000,1990656000,497311456,958.580225,958.5802986633249 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,976000,2004,39.421157684630735,fixed_full_OO_pool,4.2310400668397135,921285609652224000,1998848000,499357984,962.52365,962.525142021721 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,980000,2004,42.06586826347306,fixed_full_OO_pool,4.248280150434002,925061370347520000,2007040000,501404512,966.4709,966.4696658312448 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,984000,2004,41.96606786427146,fixed_full_OO_pool,4.265520196705022,928837131042816000,2015232000,503451040,970.415575,970.4144047619047 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,988000,2004,40.7185628742515,fixed_full_OO_pool,4.282759960240995,932612891738112000,2023424000,505497568,974.361225,974.3590622389306 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,992000,2004,40.41916167664671,fixed_full_OO_pool,4.299999819517963,936388652433408000,2031616000,507544096,978.3049,978.3038847117795 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,996000,2004,41.51696606786427,fixed_full_OO_pool,4.317226681380222,940164413128704000,2039808000,509590624,982.248225,982.2487364243943 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1000000,2004,42.76447105788423,fixed_full_OO_pool,4.334453545292425,943940173824000000,2048000000,511637152,986.195875,986.1932268170426 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1004000,2004,42.71457085828344,fixed_full_OO_pool,4.351689632784368,947715934519296000,2056192000,513683680,990.135225,990.1384106098579 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1008000,2004,41.86626746506986,fixed_full_OO_pool,4.368922051487283,951491695214592000,2064384000,515730208,994.08265,994.0829197994988 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1012000,2004,43.213572854291414,fixed_full_OO_pool,4.3861625104904585,955267455909888000,2072576000,517776736,998.028575,998.0275543024227 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1016000,2004,42.71457085828344,fixed_full_OO_pool,4.403402530394701,959043216605184000,2080768000,519823632,1001.9733,1001.9730576441103 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1020000,2004,44.510978043912175,fixed_full_OO_pool,4.420644255245311,962818977300480000,2088960000,521870160,1005.917875,1005.9178049289891 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1024000,2004,42.66467065868264,fixed_full_OO_pool,4.437885643090639,966594737995776000,2097152000,523916688,1009.86135,1009.8626441102757 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1028000,2004,44.61077844311377,fixed_full_OO_pool,4.455124506990736,970370498691072000,2105344000,525963216,1013.81015,1013.8070384294068 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1032000,2004,44.31137724550898,fixed_full_OO_pool,4.4723916829874115,974146259386368000,2113536000,528009744,1017.7512,1017.7520802005013 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1036000,2004,46.40718562874252,fixed_full_OO_pool,4.489630989476831,977922020081664000,2121728000,530056272,1021.6979,1021.6966499582289 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1040000,2004,45.90818363273453,fixed_full_OO_pool,4.507061630144922,981697780776960000,2129920000,532102800,1025.6447,1025.6412113617378 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1044000,2004,47.355289421157686,fixed_full_OO_pool,4.524300745349998,985473541472256000,2138112000,534149328,1029.582225,1029.5865476190477 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1048000,2004,42.91417165668663,fixed_full_OO_pool,4.5415398901421575,989249302167552000,2146304000,536195856,1033.533375,1033.5307456140351 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1052000,2004,47.1057884231537,fixed_full_OO_pool,4.55897798480466,993025062862848000,2154496000,538242384,1037.474425,1037.4757873851295 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1056000,2004,43.213572854291414,fixed_full_OO_pool,4.576217281533819,996800823558144000,2162688000,540288912,1041.4197,1041.4204761904762 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1060000,2004,44.461077844311376,fixed_full_OO_pool,4.593456619515394,1000576584253440000,2170880000,542335440,1045.3671,1045.3649874686716 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1064000,2004,48.55289421157685,fixed_full_OO_pool,4.610697074751887,1004352344948736000,2179072000,544381968,1049.308725,1049.3099812030075 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1068000,2004,48.45309381237525,fixed_full_OO_pool,4.6309520024858,1008128105644032000,2187264000,546428496,1053.255825,1053.2545175438597 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1072000,2004,46.8063872255489,fixed_full_OO_pool,4.652510182737476,1011903866339328000,2195456000,548475024,1057.200675,1057.1992418546365 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1076000,2004,48.952095808383234,fixed_full_OO_pool,4.676314250931351,1015679627034624000,2203648000,550521552,1061.14525,1061.1439891395155 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1080000,2004,47.1057884231537,fixed_full_OO_pool,4.6976974451841995,1019455387729920000,2211840000,552568080,1065.0906,1065.088671679198 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1084000,2004,49.30139720558882,fixed_full_OO_pool,4.717744710917274,1023231148425216000,2220032000,554614608,1069.033425,1069.0335651629073 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1088000,2004,45.958083832335326,fixed_full_OO_pool,4.735527153227271,1027006909120512000,2228224000,556661504,1072.97815,1072.9790685045948 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1092000,2004,49.9001996007984,fixed_full_OO_pool,4.752767813768652,1030782669815808000,2236416000,558708032,1076.9228,1076.9238095238095 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1096000,2004,48.75249500998004,fixed_full_OO_pool,4.770008963606217,1034558430511104000,2244608000,560754560,1080.86855,1080.8684586466165 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1100000,2004,48.15369261477046,fixed_full_OO_pool,4.787247248012573,1038334191206400000,2252800000,562801088,1084.81295,1084.8132205513784 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1104000,2004,47.90419161676647,fixed_full_OO_pool,4.804486244143918,1042109951901696000,2260992000,564847616,1088.7569,1088.7580200501254 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1108000,2004,53.0439121756487,fixed_full_OO_pool,4.821725078263423,1045885712596992000,2269184000,566894144,1092.7006,1092.7028404344194 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1112000,2004,51.39720558882236,fixed_full_OO_pool,4.838964039598488,1049661473292288000,2277376000,568940672,1096.645475,1096.6475626566416 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1116000,2004,50.249500998003995,fixed_full_OO_pool,4.856204179551246,1053437233987584000,2285568000,570987200,1100.59075,1100.5922514619883 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1120000,2004,52.74451097804391,fixed_full_OO_pool,4.873443694618634,1057212994682880000,2293760000,573033728,1104.535475,1104.536986215539 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1124000,2004,50.79840319361277,fixed_full_OO_pool,4.890682671330869,1060988755378176000,2301952000,575080256,1108.48175,1108.4815914786968 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1128000,2004,50.69860279441117,fixed_full_OO_pool,4.907921566722087,1064764516073472000,2310144000,577126784,1112.4267,1112.4263074352548 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1132000,2004,51.796407185628745,fixed_full_OO_pool,4.925160311446008,1068540276768768000,2318336000,579173312,1116.37075,1116.3710985797827 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1136000,2004,50.0998003992016,fixed_full_OO_pool,4.9423991926780175,1072316037464064000,2326528000,581219840,1120.3142,1120.315939849624 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1140000,2004,52.29540918163673,fixed_full_OO_pool,4.959637971572164,1076091798159360000,2334720000,583266368,1124.262825,1124.2603487886383 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1144000,2004,48.60279441117765,fixed_full_OO_pool,4.976877090515983,1079867558854656000,2342912000,585312896,1128.20475,1128.2053174603175 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1148000,2004,52.544910179640716,fixed_full_OO_pool,4.994115675963047,1083643319549952000,2351104000,587359424,1132.151575,1132.1498767752714 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1152000,2004,51.147704590818364,fixed_full_OO_pool,5.0113549595657325,1087419080245248000,2359296000,589405952,1136.096025,1136.094634502924 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1156000,2004,53.49301397205589,fixed_full_OO_pool,5.028593772271027,1091194840940544000,2367488000,591452480,1140.04075,1140.0393692564746 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1160000,2004,52.84431137724551,fixed_full_OO_pool,5.045832662846272,1094970601635840000,2375680000,593499376,1143.985525,1143.9848684210526 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1164000,2004,51.39720558882236,fixed_full_OO_pool,5.063073740859205,1098746362331136000,2383872000,595545904,1147.9281,1147.9297827903092 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1168000,2004,52.445109780439125,fixed_full_OO_pool,5.080314933097818,1102522123026432000,2392064000,597592432,1151.874475,1151.874379699248 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1172000,2004,53.243512974051896,fixed_full_OO_pool,5.09755403918835,1106297883721728000,2400256000,599638960,1155.8181,1155.8192063492063 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1176000,2004,52.644710578842314,fixed_full_OO_pool,5.1147931732392555,1110073644417024000,2408448000,601685488,1159.766625,1159.7636236424394 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1180000,2004,53.093812375249506,fixed_full_OO_pool,5.1320329999809875,1113849405112320000,2416640000,603732016,1163.708525,1163.7085944026733 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1184000,2004,51.147704590818364,fixed_full_OO_pool,5.1492729434898745,1117625165807616000,2424832000,605778544,1167.653325,1167.6533228905598 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1188000,2004,53.243512974051896,fixed_full_OO_pool,5.166512107209613,1121400926502912000,2433024000,607825072,1171.5965,1171.598187134503 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1192000,2004,50.998003992015974,fixed_full_OO_pool,5.183750125222529,1125176687198208000,2441216000,609871600,1175.54945,1175.5422347535505 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1196000,2004,53.243512974051896,fixed_full_OO_pool,5.200989209580132,1128952447893504000,2449408000,611918128,1179.482225,1179.4879678362572 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1200000,2004,52.24550898203593,fixed_full_OO_pool,5.2182284257871405,1132728208588800000,2457600000,613964656,1183.43255,1183.4322347535506 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1204000,2004,54.24151696606786,fixed_full_OO_pool,5.235467065889388,1136503969284096000,2465792000,616011184,1187.37685,1187.3770050125313 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1208000,2004,54.091816367265466,fixed_full_OO_pool,5.252705556519537,1140279729979392000,2473984000,618057712,1191.32125,1191.3217669172932 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1212000,2004,51.996007984031934,fixed_full_OO_pool,5.2699445467990715,1144055490674688000,2482176000,620104240,1195.266975,1195.266418128655 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1216000,2004,54.34131736526946,fixed_full_OO_pool,5.287183332483594,1147831251369984000,2490368000,622150768,1199.2107,1199.2112364243944 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1220000,2004,51.69660678642715,fixed_full_OO_pool,5.304422509928958,1151607012065280000,2498560000,624197296,1203.155175,1203.155992063492 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1224000,2004,53.3433133732535,fixed_full_OO_pool,5.321661586320649,1155382772760576000,2506752000,626243824,1207.10105,1207.1006307435255 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1228000,2004,52.644710578842314,fixed_full_OO_pool,5.3389001333651445,1159158533455872000,2514944000,628290352,1211.044575,1211.0454657477026 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1232000,2004,53.942115768463076,fixed_full_OO_pool,5.356139060486522,1162934294151168000,2523136000,630337248,1214.991175,1214.990812447786 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1236000,2004,52.49500998003992,fixed_full_OO_pool,5.3733797923754905,1166710054846464000,2531328000,632383776,1218.93465,1218.9356516290727 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1240000,2004,53.69261477045908,fixed_full_OO_pool,5.390620371591714,1170485815541760000,2539520000,634430304,1222.88165,1222.8801963241438 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1244000,2004,55.83832335329342,fixed_full_OO_pool,5.407861163440264,1174261576237056000,2547712000,636476832,1226.8233,1226.8251879699249 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1248000,2004,59.4311377245509,fixed_full_OO_pool,5.425099731002831,1178037336932352000,2555904000,638523360,1230.767425,1230.7699728487887 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1252000,2004,56.137724550898206,fixed_full_OO_pool,5.442339063153292,1181813097627648000,2564096000,640569888,1234.716775,1234.7143212197159 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1256000,2004,56.63672654690619,fixed_full_OO_pool,5.459570375274246,1185588858322944000,2572288000,642616416,1238.65755,1238.6593859649122 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1260000,2004,52.49500998003992,fixed_full_OO_pool,5.47680929850166,1189364619018240000,2580480000,644662944,1242.605825,1242.6038241436925 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1264000,2004,52.644710578842314,fixed_full_OO_pool,5.494047741352891,1193140379713536000,2588672000,646709472,1246.551375,1246.5484899749374 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1268000,2004,52.59481037924152,fixed_full_OO_pool,5.511286964642091,1196916140408832000,2596864000,648756000,1250.49465,1250.4933458646617 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1272000,2004,56.187624750499,fixed_full_OO_pool,5.528525180524836,1200691901104128000,2605056000,650802528,1254.440825,1254.4379594820384 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1276000,2004,54.690618762475054,fixed_full_OO_pool,5.545763512451408,1204467661799424000,2613248000,652849056,1258.380575,1258.3831098579783 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1280000,2004,56.337325349301395,fixed_full_OO_pool,5.5630023468234056,1208243422494720000,2621440000,654895584,1262.326625,1262.3277339181286 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1284000,2004,59.13173652694611,fixed_full_OO_pool,5.5802288784076355,1212019183190016000,2629632000,656942112,1266.2734,1266.272297410192 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1288000,2004,56.53692614770459,fixed_full_OO_pool,5.59746802474786,1215794943885312000,2637824000,658988640,1270.216,1270.217209690894 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1292000,2004,58.38323353293413,fixed_full_OO_pool,5.614706893346996,1219570704580608000,2646016000,661035168,1274.16425,1274.161649958229 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1296000,2004,54.740518962075846,fixed_full_OO_pool,5.6319453816457345,1223346465275904000,2654208000,663081696,1278.107275,1278.1065267335005 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1300000,2004,55.98802395209581,fixed_full_OO_pool,5.649183998545632,1227122225971200000,2662400000,665128224,1282.052775,1282.0511967418547 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1304000,2004,57.43512974051897,fixed_full_OO_pool,5.666422516256571,1230897986666496000,2670592000,667175120,1285.99695,1285.996746031746 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1308000,2004,55.938123752495,fixed_full_OO_pool,5.683662371886894,1234673747361792000,2678784000,669221648,1289.943825,1289.9413011695906 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1312000,2004,57.58483033932136,fixed_full_OO_pool,5.700902040020252,1238449508057088000,2686976000,671268176,1293.885575,1293.8862844611529 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1316000,2004,58.73253493013972,fixed_full_OO_pool,5.718143128725804,1242225268752384000,2695168000,673314704,1297.83205,1297.830873015873 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1320000,2004,59.830339321357286,fixed_full_OO_pool,5.735382780909745,1246001029447680000,2703360000,675361232,1301.776525,1301.7756286549707 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1324000,2004,56.337325349301395,fixed_full_OO_pool,5.752616979801614,1249776790142976000,2711552000,677407760,1305.71995,1305.7204720133668 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1328000,2004,57.13572854291418,fixed_full_OO_pool,5.769855267613505,1253552550838272000,2719744000,679454288,1309.66595,1309.6651002506267 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1332000,2004,58.23353293413174,fixed_full_OO_pool,5.787093654030727,1257328311533568000,2727936000,681500816,1313.608425,1313.6100229741019 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1336000,2004,58.13373253493014,fixed_full_OO_pool,5.804331732165689,1261104072228864000,2736128000,683547344,1317.55605,1317.554515455305 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1340000,2004,56.73652694610778,fixed_full_OO_pool,5.8215702514992,1264879832924160000,2744320000,685593872,1321.500425,1321.4992794486216 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1344000,2004,57.33532934131736,fixed_full_OO_pool,5.838808294058674,1268655593619456000,2752512000,687640400,1325.44465,1325.4440559732666 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1348000,2004,58.03393213572854,fixed_full_OO_pool,5.856046509412635,1272431354314752000,2760704000,689686928,1329.390675,1329.3886821219717 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1352000,2004,59.980039920159676,fixed_full_OO_pool,5.873284928454086,1276207115010048000,2768896000,691733456,1333.3321,1333.3336925647452 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1356000,2004,59.73053892215569,fixed_full_OO_pool,5.890523378992867,1279982875705344000,2777088000,693779984,1337.2783,1337.2783040935672 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1360000,2004,59.181636726546905,fixed_full_OO_pool,5.907761167695539,1283758636400640000,2785280000,695826512,1341.223275,1341.2230179615706 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1364000,2004,59.980039920159676,fixed_full_OO_pool,5.924999057382552,1287534397095936000,2793472000,697873040,1345.168925,1345.1676754385965 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1368000,2004,59.980039920159676,fixed_full_OO_pool,5.942236823922851,1291310157791232000,2801664000,699919568,1349.1133,1349.1124394319131 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1372000,2004,60.22954091816367,fixed_full_OO_pool,5.9594746967539605,1295085918486528000,2809856000,701966096,1353.05585,1353.0573558897242 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1376000,2004,60.728542914171655,fixed_full_OO_pool,5.976712731173676,1298861679181824000,2818048000,704012624,1357.0021,1357.001963241437 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1380000,2004,60.52894211576846,fixed_full_OO_pool,5.9939511247983,1302637439877120000,2826240000,706059520,1360.94845,1360.9473308270676 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1384000,2004,58.43313373253493,fixed_full_OO_pool,6.011185566416631,1306413200572416000,2834432000,708106048,1364.892525,1364.892119883041 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1388000,2004,58.48303393213573,fixed_full_OO_pool,6.028425193462107,1310188961267712000,2842624000,710152576,1368.837575,1368.8368274853801 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1392000,2004,59.331337325349295,fixed_full_OO_pool,6.045662258237393,1313964721963008000,2850816000,712199104,1372.7806,1372.7817042606516 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1396000,2004,60.52894211576846,fixed_full_OO_pool,6.062900072590758,1317740482658304000,2859008000,714245632,1376.724925,1376.7264724310776 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1400000,2004,62.025948103792416,fixed_full_OO_pool,6.080136956817781,1321516243353600000,2867200000,716292160,1380.67005,1380.6711737677526 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1404000,2004,60.67864271457086,fixed_full_OO_pool,6.097374538001087,1325292004048896000,2875392000,718338688,1384.613375,1384.6160254803676 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1408000,2004,58.93213572854291,fixed_full_OO_pool,6.114611394109412,1329067764744192000,2883584000,720385216,1388.5613,1388.560492898914 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1412000,2004,59.88023952095808,fixed_full_OO_pool,6.131848747611253,1332843525439488000,2891776000,722431744,1392.5033,1392.505455304929 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1416000,2004,61.62674650698603,fixed_full_OO_pool,6.149086149731237,1336619286134784000,2899968000,724478272,1396.450525,1396.4499812030076 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1420000,2004,61.876247504990026,fixed_full_OO_pool,6.166323717420714,1340395046830080000,2908160000,726524800,1400.391675,1400.395014619883 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1424000,2004,62.4750499001996,fixed_full_OO_pool,6.183561835216565,1344170807525376000,2916352000,728571328,1404.34155,1404.3393191311613 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1428000,2004,62.225548902195605,fixed_full_OO_pool,6.20079974888203,1347946568220672000,2924544000,730617856,1408.2827,1408.2843525480368 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1432000,2004,62.4251497005988,fixed_full_OO_pool,6.218037622384727,1351722328915968000,2932736000,732664384,1412.23435,1412.22850877193 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1436000,2004,60.87824351297405,fixed_full_OO_pool,6.235276370280319,1355498089611264000,2940928000,734710912,1416.171725,1416.1738575605682 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1440000,2004,61.27744510978044,fixed_full_OO_pool,6.252515207086172,1359273850306560000,2949120000,736757440,1420.1182,1420.1184461152882 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1444000,2004,64.62075848303394,fixed_full_OO_pool,6.269753445495541,1363049611001856000,2957312000,738803968,1424.063875,1424.0631015037593 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1448000,2004,60.67864271457086,fixed_full_OO_pool,6.286991741182282,1366825371697152000,2965504000,740850496,1428.00755,1428.0079239766083 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1452000,2004,62.27544910179641,fixed_full_OO_pool,6.304229530568959,1370601132392448000,2973696000,742897392,1431.9544,1431.9532497911446 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1456000,2004,62.27544910179641,fixed_full_OO_pool,6.321469843157877,1374376893087744000,2981888000,744943920,1435.89715,1435.898149540518 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1460000,2004,61.72654690618763,fixed_full_OO_pool,6.338710435824469,1378152653783040000,2990080000,746990448,1439.84305,1439.8427861319967 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1464000,2004,61.52694610778443,fixed_full_OO_pool,6.355948524793817,1381928414478336000,2998272000,749036976,1443.78635,1443.7876399331662 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1468000,2004,62.17564870259481,fixed_full_OO_pool,6.373185847506134,1385704175173632000,3006464000,751083504,1447.735625,1447.7319945697577 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1472000,2004,61.62674650698603,fixed_full_OO_pool,6.390422364113231,1389479935868928000,3014656000,753130032,1451.678875,1451.6768525480368 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1476000,2004,61.82634730538922,fixed_full_OO_pool,6.4076598542835566,1393255696564224000,3022848000,755176560,1455.620375,1455.6218567251462 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1480000,2004,61.27744510978044,fixed_full_OO_pool,6.424897231575516,1397031457259520000,3031040000,757223088,1459.563975,1459.566685463659 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1484000,2004,63.07385229540918,fixed_full_OO_pool,6.44213454660856,1400807217954816000,3039232000,759269616,1463.51195,1463.511148705096 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1488000,2004,64.87025948103793,fixed_full_OO_pool,6.459372210530564,1404582978650112000,3047424000,761316144,1467.45765,1467.4558020050126 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1492000,2004,64.77045908183634,fixed_full_OO_pool,6.476609569088453,1408358739345408000,3055616000,763362672,1471.4006,1471.4006850459482 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1496000,2004,64.52095808383234,fixed_full_OO_pool,6.49384753140207,1412134500040704000,3063808000,765409200,1475.346,1475.3453634085213 +synthetic,loop4x2-phi12.6-wd0.1,loop4x2,791101,0.0001,0.1,12.6,1500000,2004,66.1676646706587,fixed_full_OO_pool,6.511084337063755,1415910260736000000,3072000000,767455728,1479.289375,1479.2902109440267 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,256,2004,0.0,fixed_full_OO_pool,0.001125210498770078,241648684498944,524288,131072,0.738675,0.7421418128654971 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,512,2004,0.0,fixed_full_OO_pool,0.0022507017623219225,483297368997888,1048576,261792,1.4825,1.480204678362573 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1000,2004,0.14970059880239522,fixed_full_OO_pool,0.0044523322416676414,943940173824000,2048000,511296,2.89215,2.8918859649122806 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,2000,2004,0.049900199600798396,fixed_full_OO_pool,0.008758644946954317,1887880347648000,4096000,1022240,5.7857,5.7807894736842105 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,3000,2004,0.0,fixed_full_OO_pool,0.013066258141770959,2831820521472000,6144000,1533184,8.6757,8.670730994152047 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,4000,2004,0.09980039920159679,fixed_full_OO_pool,0.017753083820765216,3775760695296000,8192000,2044128,11.562675,11.56155701754386 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,5000,2004,0.09980039920159679,fixed_full_OO_pool,0.022063384730782773,4719700869120000,10240000,2555072,14.4528,14.451461988304093 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,6000,2004,0.09980039920159679,fixed_full_OO_pool,0.026371262405688566,5663641042944000,12288000,3066016,17.3402,17.342163742690058 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,7000,2004,0.14970059880239522,fixed_full_OO_pool,0.031199524260850417,6607581216768000,14336000,3576960,20.2311,20.23184210526316 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,8000,2004,0.09980039920159679,fixed_full_OO_pool,0.03584989467946192,7551521390592000,16384000,4087904,23.12215,23.121476608187134 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,9000,2004,0.14970059880239522,fixed_full_OO_pool,0.0406815762931688,8495461564416000,18432000,4598848,26.011525,26.011600877192983 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,10000,2004,0.19960079840319359,fixed_full_OO_pool,0.04551282717639373,9439401738240000,20480000,5110144,28.903575,28.903516081871345 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,11000,2004,0.049900199600798396,fixed_full_OO_pool,0.04982228924727274,10383341912064000,22528000,5621088,31.793675,31.7934283625731 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,12000,2004,0.049900199600798396,fixed_full_OO_pool,0.05413116954680946,11327282085888000,24576000,6132032,34.683625,34.68338450292398 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,13000,2004,0.19960079840319359,fixed_full_OO_pool,0.05896427562667264,12271222259712000,26624000,6642976,37.572925,37.573530701754386 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,14000,2004,0.049900199600798396,fixed_full_OO_pool,0.06379498821683229,13215162433536000,28672000,7153920,40.45805,40.464897660818714 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,15000,2004,0.19960079840319359,fixed_full_OO_pool,0.06865952746528718,14159102607360000,30720000,7664864,43.354575,43.352931286549705 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,16000,2004,0.09980039920159679,fixed_full_OO_pool,0.07334449169225991,15103042781184000,32768000,8175808,46.243725,46.24312134502924 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,17000,2004,0.14970059880239522,fixed_full_OO_pool,0.07765101908913088,16046982955008000,34816000,8686752,49.133,49.13327485380117 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,18000,2004,0.19960079840319359,fixed_full_OO_pool,0.08195510300704174,16990923128832000,36864000,9197696,52.0224,52.0233918128655 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,19000,2004,0.14970059880239522,fixed_full_OO_pool,0.08626167793758213,17934863302656000,38912000,9708992,54.9153,54.91505847953216 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,20000,2004,0.09980039920159679,fixed_full_OO_pool,0.09056782129531106,18878803476480000,40960000,10219936,57.806875,57.80453947368421 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,21000,2004,0.09980039920159679,fixed_full_OO_pool,0.09487359571891527,19822743650304000,43008000,10730880,60.697725,60.69423245614035 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,22000,2004,0.09980039920159679,fixed_full_OO_pool,0.09917956377793517,20766683824128000,45056000,11241824,63.58775,63.58416666666667 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,23000,2004,0.049900199600798396,fixed_full_OO_pool,0.10348429894074798,21710623997952000,47104000,11752768,66.477375,66.47421783625731 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,24000,2004,0.19960079840319359,fixed_full_OO_pool,0.10778923705634144,22654564171776000,49152000,12263712,69.365,69.36485380116959 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,25000,2004,0.249500998003992,fixed_full_OO_pool,0.11209408289649421,23598504345600000,51200000,12774656,72.2516,72.25578947368422 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,26000,2004,0.049900199600798396,fixed_full_OO_pool,0.11639817997192344,24542444519424000,53248000,13285600,75.1447,75.14482456140351 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,27000,2004,0.29940119760479045,fixed_full_OO_pool,0.12070221410339906,25486384693248000,55296000,13796544,78.034875,78.0347149122807 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,28000,2004,0.09980039920159679,fixed_full_OO_pool,0.12500681184646156,26430324867072000,57344000,14307840,80.9273,80.92652046783626 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,29000,2004,0.14970059880239522,fixed_full_OO_pool,0.12931164527518882,27374265040896000,59392000,14818784,83.8138,83.81748538011696 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,30000,2004,0.29940119760479045,fixed_full_OO_pool,0.13361643211916088,28318205214720000,61440000,15329728,86.705675,86.70687865497077 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,31000,2004,0.249500998003992,fixed_full_OO_pool,0.13792167971117628,29262145388544000,63488000,15840672,89.596875,89.59646929824561 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,32000,2004,0.249500998003992,fixed_full_OO_pool,0.14222598917989268,30206085562368000,65536000,16351616,92.488375,92.48597222222222 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,33000,2004,0.19960079840319359,fixed_full_OO_pool,0.14653047317535514,31150025736192000,67584000,16862560,95.377875,95.37605994152047 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,34000,2004,0.19960079840319359,fixed_full_OO_pool,0.1508352901807262,32093965910016000,69632000,17373504,98.266,98.26654970760234 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,35000,2004,0.14970059880239522,fixed_full_OO_pool,0.15513912686146797,33037906083840000,71680000,17884448,101.154825,101.15683479532164 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,36000,2004,0.14970059880239522,fixed_full_OO_pool,0.15944341063292491,33981846257664000,73728000,18395392,104.046475,104.04629385964913 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,37000,2004,0.29940119760479045,fixed_full_OO_pool,0.16374721197928818,34925786431488000,75776000,18906688,106.93695,106.93866959064327 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,38000,2004,0.19960079840319359,fixed_full_OO_pool,0.1680520621376733,35869726605312000,77824000,19417632,109.8284,109.82818713450293 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,39000,2004,0.249500998003992,fixed_full_OO_pool,0.172356765423384,36813666779136000,79872000,19928576,112.720025,112.71765350877193 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,40000,2004,0.249500998003992,fixed_full_OO_pool,0.17666109027134047,37757606952960000,81920000,20439520,115.60865,115.6079970760234 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,41000,2004,0.14970059880239522,fixed_full_OO_pool,0.18096526702038115,38701547126784000,83968000,20950464,118.497425,118.49829678362573 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,42000,2004,0.29940119760479045,fixed_full_OO_pool,0.18526937544138894,39645487300608000,86016000,21461408,121.388075,121.38804824561403 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,43000,2004,0.09980039920159679,fixed_full_OO_pool,0.18957330799661576,40589427474432000,88064000,21972352,124.281475,124.27699561403509 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,44000,2004,0.19960079840319359,fixed_full_OO_pool,0.193877352985243,41533367648256000,90112000,22483296,127.16835,127.16785087719298 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,45000,2004,0.19960079840319359,fixed_full_OO_pool,0.19818128993320797,42477307822080000,92160000,22994240,130.0571,130.05815789473684 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,46000,2004,0.249500998003992,fixed_full_OO_pool,0.20248606407807934,43421247995904000,94208000,23505536,132.9483,132.9503216374269 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,47000,2004,0.29940119760479045,fixed_full_OO_pool,0.20679059974642264,44365188169728000,96256000,24016480,135.8419,135.83921052631578 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,48000,2004,0.249500998003992,fixed_full_OO_pool,0.21109514703353247,45309128343552000,98304000,24527424,138.728775,138.73006578947368 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,49000,2004,0.19960079840319359,fixed_full_OO_pool,0.21539971176948813,46253068517376000,100352000,25038368,141.6183,141.6201461988304 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,50000,2004,0.34930139720558884,fixed_full_OO_pool,0.21970339809440903,47197008691200000,102400000,25549312,144.50795,144.51019005847954 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,51000,2004,0.29940119760479045,fixed_full_OO_pool,0.22400713494771884,48140948865024000,104448000,26060256,147.395725,147.4007821637427 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,52000,2004,0.14970059880239522,fixed_full_OO_pool,0.22831102966330946,49084889038848000,106496000,26571200,150.289325,150.28967105263158 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,53000,2004,0.29940119760479045,fixed_full_OO_pool,0.23261529238894582,50028829212672000,108544000,27082144,153.174725,153.1809576023392 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,54000,2004,0.249500998003992,fixed_full_OO_pool,0.2369195764646348,50972769386496000,110592000,27593088,156.0696,156.06947368421052 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,55000,2004,0.39920159680638717,fixed_full_OO_pool,0.24122439871956078,51916709560320000,112640000,28104384,158.960125,158.96183479532164 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,56000,2004,0.249500998003992,fixed_full_OO_pool,0.24552961632712847,52860649734144000,114688000,28615328,161.851925,161.85125 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,57000,2004,0.34930139720558884,fixed_full_OO_pool,0.24983528380592665,53804589907968000,116736000,29126272,164.74035,164.74165204678363 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,58000,2004,0.34930139720558884,fixed_full_OO_pool,0.25414061388000847,54748530081792000,118784000,29637216,167.629,167.63198830409357 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,59000,2004,0.39920159680638717,fixed_full_OO_pool,0.2584449432769583,55692470255616000,120832000,30148160,170.520425,170.52151315789473 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,60000,2004,0.249500998003992,fixed_full_OO_pool,0.2627488049223191,56636410429440000,122880000,30659104,173.4141,173.41038011695906 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,61000,2004,0.34930139720558884,fixed_full_OO_pool,0.2670529512740258,57580350603264000,124928000,31170048,176.30215,176.3008918128655 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,62000,2004,0.09980039920159679,fixed_full_OO_pool,0.27135725300862557,58524290777088000,126976000,31680992,179.18975,179.1915350877193 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,63000,2004,0.249500998003992,fixed_full_OO_pool,0.27566144993735686,59468230950912000,129024000,32191936,182.0821,182.0807894736842 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,64000,2004,0.19960079840319359,fixed_full_OO_pool,0.27996596086873776,60412171124736000,131072000,32703232,184.9739,184.97277777777776 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,68000,2004,0.34930139720558884,fixed_full_OO_pool,0.2972126311684648,64187931820032000,139264000,34747008,196.534775,196.5322880116959 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,72000,2004,0.249500998003992,fixed_full_OO_pool,0.31445767044089734,67963692515328000,147456000,36790784,208.096325,208.09160087719297 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,76000,2004,0.249500998003992,fixed_full_OO_pool,0.3317035275946061,71739453210624000,155648000,38834912,219.65295,219.6549269005848 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,80000,2004,0.14970059880239522,fixed_full_OO_pool,0.348950083107791,75515213905920000,163840000,40878688,231.214275,231.21430555555557 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,84000,2004,0.249500998003992,fixed_full_OO_pool,0.366195148665251,79290974601216000,172032000,42922816,242.7747,242.77652046783626 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,88000,2004,0.29940119760479045,fixed_full_OO_pool,0.3834425133425328,83066735296512000,180224000,44966592,254.3344,254.33637426900586 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,92000,2004,0.34930139720558884,fixed_full_OO_pool,0.4006891304564973,86842495991808000,188416000,47010720,265.89915,265.89732456140354 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,96000,2004,0.29940119760479045,fixed_full_OO_pool,0.4179354139189753,90618256687104000,196608000,49054496,277.4587,277.45722222222224 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,100000,2004,0.34930139720558884,fixed_full_OO_pool,0.43518205337329874,94394017382400000,204800000,51098272,289.017125,289.01744883040936 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,104000,2004,0.34930139720558884,fixed_full_OO_pool,0.45242940598995324,98169778077696000,212992000,53142400,300.580475,300.57880847953214 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,108000,2004,0.39920159680638717,fixed_full_OO_pool,0.4696768993977457,101945538772992000,221184000,55186176,312.1393,312.13891812865495 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,112000,2004,0.249500998003992,fixed_full_OO_pool,0.4869236994969348,105721299468288000,229376000,57230304,323.6992,323.7012865497076 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,116000,2004,0.4491017964071856,fixed_full_OO_pool,0.5041730182824863,109497060163584000,237568000,59274080,335.257625,335.26151315789474 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,120000,2004,0.249500998003992,fixed_full_OO_pool,0.5214206881283058,113272820858880000,245760000,61318208,346.81975,346.823230994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,124000,2004,0.4491017964071856,fixed_full_OO_pool,0.538667719564918,117048581554176000,253952000,63361984,358.385525,358.38130847953215 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,128000,2004,0.19960079840319359,fixed_full_OO_pool,0.5559151414398932,120824342249472000,262144000,65406112,369.943925,369.94411549707604 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,132000,2004,0.34930139720558884,fixed_full_OO_pool,0.5731645808255093,124600102944768000,270336000,67449888,381.506125,381.50323830409354 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,136000,2004,0.249500998003992,fixed_full_OO_pool,0.5904101025851236,128375863640064000,278528000,69493664,393.0647,393.06342105263155 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,140000,2004,0.34930139720558884,fixed_full_OO_pool,0.6076563724751274,132151624335360000,286720000,71537792,404.627725,404.6248757309942 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,144000,2004,0.4491017964071856,fixed_full_OO_pool,0.6249017748495357,135927385030656000,294912000,73581568,416.1857,416.18523391812863 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,148000,2004,0.4491017964071856,fixed_full_OO_pool,0.6421478536383559,139703145725952000,303104000,75625696,427.74555,427.7476169590643 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,152000,2004,0.34930139720558884,fixed_full_OO_pool,0.6593957992073977,143478906421248000,311296000,77669472,439.308125,439.30663011695907 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,156000,2004,0.39920159680638717,fixed_full_OO_pool,0.6766429540525294,147254667116544000,319488000,79713600,450.867875,450.8690423976608 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,160000,2004,0.39920159680638717,fixed_full_OO_pool,0.6938902624023872,151030427811840000,327680000,81757376,462.431225,462.4278289473684 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,164000,2004,0.29940119760479045,fixed_full_OO_pool,0.7111366411081205,154806188507136000,335872000,83801504,473.99045,473.9903947368421 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,168000,2004,0.34930139720558884,fixed_full_OO_pool,0.728382319851468,158581949202432000,344064000,85845280,485.55075,485.5500730994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,172000,2004,0.09980039920159679,fixed_full_OO_pool,0.7456274502931369,162357709897728000,352256000,87889056,497.10955,497.11019005847953 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,176000,2004,0.249500998003992,fixed_full_OO_pool,0.762872733173685,166133470593024000,360448000,89933184,508.672125,508.6717763157895 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,180000,2004,0.14970059880239522,fixed_full_OO_pool,0.7801194606969754,169909231288320000,368640000,91976960,520.233225,520.2312207602339 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,184000,2004,0.249500998003992,fixed_full_OO_pool,0.7973644807024135,173684991983616000,376832000,94021088,531.794675,531.7931359649123 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,188000,2004,0.29940119760479045,fixed_full_OO_pool,0.81461015446422,177460752678912000,385024000,96064864,543.356125,543.3524780701755 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,192000,2004,0.34930139720558884,fixed_full_OO_pool,0.8318555630536543,181236513374208000,393216000,98108992,554.91525,554.9150730994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,196000,2004,0.249500998003992,fixed_full_OO_pool,0.8491017624311563,185012274069504000,401408000,100152768,566.4763,566.4745321637427 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,200000,2004,0.5489021956087825,fixed_full_OO_pool,0.8663475292714106,188788034764800000,409600000,102196544,578.03335,578.0351608187135 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,204000,2004,0.249500998003992,fixed_full_OO_pool,0.8835936581488285,192563795460096000,417792000,104240672,589.596175,589.5966739766081 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,208000,2004,0.499001996007984,fixed_full_OO_pool,0.9008406001567426,196339556155392000,425984000,106284448,601.15555,601.1566228070176 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,212000,2004,0.4491017964071856,fixed_full_OO_pool,0.9180864474415366,200115316850688000,434176000,108328576,612.716425,612.7187061403508 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,216000,2004,0.249500998003992,fixed_full_OO_pool,0.9353336329892692,203891077545984000,442368000,110372352,624.279825,624.2774780701754 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,220000,2004,0.29940119760479045,fixed_full_OO_pool,0.952579565807763,207666838241280000,450560000,112416480,635.838275,635.8402704678363 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,224000,2004,0.19960079840319359,fixed_full_OO_pool,0.9698272075441976,211442598936576000,458752000,114460256,647.398675,647.3999195906433 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,228000,2004,0.249500998003992,fixed_full_OO_pool,0.9870737504379616,215218359631872000,466944000,116504384,658.963125,658.9609576023391 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,232000,2004,0.499001996007984,fixed_full_OO_pool,1.0043219691080352,218994120327168000,475136000,118548160,670.5206,670.521461988304 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,236000,2004,0.4491017964071856,fixed_full_OO_pool,1.0215685227803057,222769881022464000,483328000,120591936,682.080625,682.0812207602339 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,240000,2004,0.4491017964071856,fixed_full_OO_pool,1.0388166618347168,226545641717760000,491520000,122636064,693.644725,693.6423611111111 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,244000,2004,0.5489021956087825,fixed_full_OO_pool,1.0560657143996408,230321402413056000,499712000,124679840,705.203275,705.2025511695906 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,248000,2004,0.29940119760479045,fixed_full_OO_pool,1.0733122235422747,234097163108352000,507904000,126723968,716.764875,716.7644225146199 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,252000,2004,0.4491017964071856,fixed_full_OO_pool,1.0905592208169401,237872923803648000,516096000,128767744,728.322775,728.3248026315789 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,256000,2004,0.19960079840319359,fixed_full_OO_pool,1.107806318162216,241648684498944000,524288000,130811872,739.885525,739.8863377192982 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,260000,2004,0.249500998003992,fixed_full_OO_pool,1.1250542535332755,245424445194240000,532480000,132855648,751.446475,751.4458260233918 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,264000,2004,0.049900199600798396,fixed_full_OO_pool,1.142301890798327,249200205889536000,540672000,134899424,763.005325,763.0059283625731 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,268000,2004,0.19960079840319359,fixed_full_OO_pool,1.1595487396160347,252975966584832000,548864000,136943552,774.56595,774.5680847953216 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,272000,2004,0.5988023952095809,fixed_full_OO_pool,1.1767965061238244,256751727280128000,557056000,138987328,786.1286,786.1270760233919 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,276000,2004,0.29940119760479045,fixed_full_OO_pool,1.194044626945009,260527487975424000,565248000,141031456,797.68705,797.6898684210527 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,280000,2004,0.14970059880239522,fixed_full_OO_pool,1.2112929222577562,264303248670720000,573440000,143075232,809.249375,809.2489546783626 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,284000,2004,0.39920159680638717,fixed_full_OO_pool,1.228541928426259,268079009366016000,581632000,145119360,820.81125,820.8107456140351 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,288000,2004,0.249500998003992,fixed_full_OO_pool,1.2457917097200537,271854770061312000,589824000,147163136,832.374125,832.3696710526316 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,292000,2004,0.249500998003992,fixed_full_OO_pool,1.2630378622178817,275630530756608000,598016000,149207264,843.932525,843.9324780701754 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,296000,2004,0.29940119760479045,fixed_full_OO_pool,1.2802870585076096,279406291451904000,606208000,151251040,855.490375,855.4928728070175 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,300000,2004,0.5988023952095809,fixed_full_OO_pool,1.2975357177926021,283182052147200000,614400000,153294816,867.052825,867.0519225146198 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,304000,2004,0.4491017964071856,fixed_full_OO_pool,1.3147844337392598,286957812842496000,622592000,155338944,878.611975,878.6145102339182 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,308000,2004,0.29940119760479045,fixed_full_OO_pool,1.3320332117213143,290733573537792000,630784000,157382720,890.17425,890.1736111111111 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,312000,2004,0.5489021956087825,fixed_full_OO_pool,1.3492831288640283,294509334233088000,638976000,159426848,901.7347,901.7358187134503 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,316000,2004,0.499001996007984,fixed_full_OO_pool,1.3665369422164642,298285094928384000,647168000,161470624,913.298675,913.2944225146199 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,320000,2004,0.4491017964071856,fixed_full_OO_pool,1.3837922415251118,302060855623680000,655360000,163514752,924.8561,924.8575146198831 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,324000,2004,0.39920159680638717,fixed_full_OO_pool,1.4010447183489385,305836616318976000,663552000,165558528,936.4152,936.4175438596491 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,328000,2004,0.499001996007984,fixed_full_OO_pool,1.4182980124072897,309612377014272000,671744000,167602656,947.979,947.9787719298246 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,332000,2004,0.5489021956087825,fixed_full_OO_pool,1.43554939551072,313388137709568000,679936000,169646432,959.53855,959.5386695906433 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,336000,2004,0.29940119760479045,fixed_full_OO_pool,1.4528008322810961,317163898404864000,688128000,171690208,971.098475,971.0984576023392 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,340000,2004,0.249500998003992,fixed_full_OO_pool,1.4700513759917684,320939659100160000,696320000,173734336,982.65995,982.660365497076 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,344000,2004,0.39920159680638717,fixed_full_OO_pool,1.4873040858500948,324715419795456000,704512000,175778112,994.221225,994.2197587719298 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,348000,2004,0.34930139720558884,fixed_full_OO_pool,1.5045564923083616,328491180490752000,712704000,177822240,1005.782425,1005.7817470760234 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,352000,2004,0.34930139720558884,fixed_full_OO_pool,1.5218070106663637,332266941186048000,720896000,179866016,1017.336125,1017.343355263158 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,356000,2004,0.34930139720558884,fixed_full_OO_pool,1.5390563914159106,336042701881344000,729088000,181910144,1028.907325,1028.9024195906434 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,360000,2004,0.6487025948103792,fixed_full_OO_pool,1.5563072014103334,339818462576640000,737280000,183953920,1040.464975,1040.4628728070174 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,364000,2004,0.4491017964071856,fixed_full_OO_pool,1.5735570399111343,343594223271936000,745472000,185997696,1052.02295,1052.023230994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,368000,2004,0.6487025948103792,fixed_full_OO_pool,1.5908045580931423,347369983967232000,753664000,188041824,1063.584925,1063.5849926900585 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,372000,2004,0.6487025948103792,fixed_full_OO_pool,1.6080520362727757,351145744662528000,761856000,190085600,1075.145775,1075.144510233918 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,376000,2004,0.6487025948103792,fixed_full_OO_pool,1.625304470229894,354921505357824000,770048000,192129728,1086.703625,1086.7074780701755 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,380000,2004,0.5988023952095809,fixed_full_OO_pool,1.6425553481508461,358697266053120000,778240000,194173504,1098.26725,1098.2661842105263 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,384000,2004,0.4491017964071856,fixed_full_OO_pool,1.6598058883111095,362473026748416000,786432000,196217632,1109.829025,1109.828004385965 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,388000,2004,0.6487025948103792,fixed_full_OO_pool,1.6770578901273094,366248787443712000,794624000,198261408,1121.389275,1121.387697368421 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,392000,2004,0.34930139720558884,fixed_full_OO_pool,1.6943105916430552,370024548139008000,802816000,200305536,1132.94945,1132.949985380117 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,396000,2004,0.39920159680638717,fixed_full_OO_pool,1.7115626813864542,373800308834304000,811008000,202349312,1144.5121,1144.5089766081871 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,400000,2004,0.5489021956087825,fixed_full_OO_pool,1.7288134034474691,377576069529600000,819200000,204393088,1156.06985,1156.0694005847954 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,404000,2004,0.4491017964071856,fixed_full_OO_pool,1.7460621438051263,381351830224896000,827392000,206437216,1167.629,1167.6319883040935 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,408000,2004,0.34930139720558884,fixed_full_OO_pool,1.7633093840142504,385127590920192000,835584000,208480992,1179.18995,1179.191476608187 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,412000,2004,0.499001996007984,fixed_full_OO_pool,1.780557111868014,388903351615488000,843776000,210525120,1190.75375,1190.7527046783625 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,416000,2004,0.6487025948103792,fixed_full_OO_pool,1.7978060343768447,392679112310784000,851968000,212568896,1202.312025,1202.3129751461988 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,420000,2004,0.5988023952095809,fixed_full_OO_pool,1.8150534782424155,396454873006080000,860160000,214613024,1213.876475,1213.8740131578948 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,424000,2004,0.5489021956087825,fixed_full_OO_pool,1.8323002828026398,400230633701376000,868352000,216656800,1225.435575,1225.4340423976607 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,428000,2004,0.499001996007984,fixed_full_OO_pool,1.8495491781530695,404006394396672000,876544000,218700928,1236.99625,1236.9961842105263 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,432000,2004,0.499001996007984,fixed_full_OO_pool,1.8667989838982209,407782155091968000,884736000,220744704,1248.55375,1248.5566812865497 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,436000,2004,0.4491017964071856,fixed_full_OO_pool,1.8840472175470657,411557915787264000,892928000,222788480,1260.114275,1260.1162938596492 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,440000,2004,0.499001996007984,fixed_full_OO_pool,1.9012940353113743,415333676482560000,901120000,224832608,1271.675325,1271.6783260233917 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,444000,2004,0.29940119760479045,fixed_full_OO_pool,1.9185434210942023,419109437177856000,909312000,226876384,1283.236625,1283.237711988304 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,448000,2004,0.4491017964071856,fixed_full_OO_pool,1.9357923400805641,422885197873152000,917504000,228920512,1294.801975,1294.7984868421054 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,452000,2004,0.4491017964071856,fixed_full_OO_pool,1.9530397984012962,426660958568448000,925696000,230964288,1306.362075,1306.3582236842105 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,456000,2004,0.6986027944111777,fixed_full_OO_pool,1.9702872197557655,430436719263744000,933888000,233008416,1317.92185,1317.9206286549709 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,460000,2004,0.4491017964071856,fixed_full_OO_pool,1.9875366989968137,434212479959040000,942080000,235052192,1329.48015,1329.4808918128656 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,464000,2004,0.6986027944111777,fixed_full_OO_pool,2.0047860604038257,437988240654336000,950272000,237095968,1341.0407,1341.0404970760235 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,468000,2004,0.5988023952095809,fixed_full_OO_pool,2.0220340715069325,441764001349632000,958464000,239140096,1352.601175,1352.602697368421 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,472000,2004,0.6487025948103792,fixed_full_OO_pool,2.0392821452580394,445539762044928000,966656000,241183872,1364.16295,1364.1619444444445 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,476000,2004,0.5489021956087825,fixed_full_OO_pool,2.056530866017565,449315522740224000,974848000,243228000,1375.722825,1375.7243201754386 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,480000,2004,0.998003992015968,fixed_full_OO_pool,2.073780085626576,453091283435520000,983040000,245271776,1387.28105,1387.2846052631578 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,484000,2004,0.5988023952095809,fixed_full_OO_pool,2.091030367007479,456867044130816000,991232000,247315904,1398.844975,1398.8457967836257 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,488000,2004,0.6487025948103792,fixed_full_OO_pool,2.1082800777453103,460642804826112000,999424000,249359680,1410.404425,1410.4057236842104 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,492000,2004,0.7984031936127743,fixed_full_OO_pool,2.125529946876276,464418565521408000,1007616000,251403808,1421.968225,1421.966951754386 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,496000,2004,0.5988023952095809,fixed_full_OO_pool,2.1427802257602,468194326216704000,1015808000,253447584,1433.524825,1433.5277119883042 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,500000,2004,0.499001996007984,fixed_full_OO_pool,2.1600293551157748,471970086912000000,1024000000,255491360,1445.088525,1445.0863961988305 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,504000,2004,0.8483033932135728,fixed_full_OO_pool,2.177277915250096,475745847607296000,1032192000,257535488,1456.646325,1456.6493786549709 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,508000,2004,0.9481037924151697,fixed_full_OO_pool,2.194526411347712,479521608302592000,1040384000,259579264,1468.2094,1468.2082456140351 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,512000,2004,0.6487025948103792,fixed_full_OO_pool,2.211773682769595,483297368997888000,1048576000,261623392,1479.77025,1479.77033625731 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,516000,2004,0.8483033932135728,fixed_full_OO_pool,2.229022353173544,487073129693184000,1056768000,263667168,1491.332625,1491.3294078947367 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,520000,2004,0.5988023952095809,fixed_full_OO_pool,2.246271910381814,490848890388480000,1064960000,265711296,1502.89105,1502.892207602339 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,524000,2004,0.7485029940119761,fixed_full_OO_pool,2.263520716185578,494624651083776000,1073152000,267755072,1514.4588,1514.4497076023392 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,528000,2004,0.5988023952095809,fixed_full_OO_pool,2.280768981448685,498400411779072000,1081344000,269798848,1526.01185,1526.0115058479532 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,532000,2004,0.4491017964071856,fixed_full_OO_pool,2.2980169646100452,502176172474368000,1089536000,271842976,1537.57275,1537.5735818713451 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,536000,2004,0.5489021956087825,fixed_full_OO_pool,2.315266190438221,505951933169664000,1097728000,273886752,1549.1349,1549.1327192982455 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,540000,2004,0.7984031936127743,fixed_full_OO_pool,2.3325141822639854,509727693864960000,1105920000,275930880,1560.693825,1560.6953728070175 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,544000,2004,0.5489021956087825,fixed_full_OO_pool,2.3497637814438592,513503454560256000,1114112000,277974656,1572.2551,1572.2547660818714 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,548000,2004,0.998003992015968,fixed_full_OO_pool,2.3670111776339926,517279215255552000,1122304000,280018784,1583.81425,1583.8173538011697 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,552000,2004,0.6487025948103792,fixed_full_OO_pool,2.384257905413914,521054975950848000,1130496000,282062560,1595.377875,1595.3760599415205 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,556000,2004,0.6487025948103792,fixed_full_OO_pool,2.4015045173838736,524830736646144000,1138688000,284106688,1606.93965,1606.9378801169591 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,560000,2004,0.4491017964071856,fixed_full_OO_pool,2.4187568761801552,528606497341440000,1146880000,286150464,1618.501225,1618.4971856725147 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,564000,2004,0.8483033932135728,fixed_full_OO_pool,2.4360067512498547,532382258036736000,1155072000,288194240,1630.058,1630.0578947368422 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,568000,2004,0.7984031936127743,fixed_full_OO_pool,2.453255960184874,536158018732032000,1163264000,290238368,1641.620975,1641.6193640350878 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,572000,2004,0.499001996007984,fixed_full_OO_pool,2.4705081522495798,539933779427328000,1171456000,292282144,1653.1784,1653.1798830409357 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,576000,2004,0.5489021956087825,fixed_full_OO_pool,2.4877586909921634,543709540122624000,1179648000,294326272,1664.742875,1664.74091374269 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,580000,2004,0.7485029940119761,fixed_full_OO_pool,2.505012119460023,547485300817920000,1187840000,296370048,1676.301775,1676.3010014619883 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,584000,2004,0.5988023952095809,fixed_full_OO_pool,2.5222641896063256,551261061513216000,1196032000,298414176,1687.862275,1687.8631944444444 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,588000,2004,0.8483033932135728,fixed_full_OO_pool,2.5395150611922146,555036822208512000,1204224000,300457952,1699.42215,1699.4229970760234 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,592000,2004,0.8982035928143712,fixed_full_OO_pool,2.556762949874004,558812582903808000,1212416000,302502080,1710.985,1710.9845029239766 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,596000,2004,0.34930139720558884,fixed_full_OO_pool,2.5740117336613024,562588343599104000,1220608000,304545856,1722.546875,1722.543720760234 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,600000,2004,0.4491017964071856,fixed_full_OO_pool,2.5912587914791785,566364104294400000,1228800000,306589632,1734.105,1734.1040350877192 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,604000,2004,0.6487025948103792,fixed_full_OO_pool,2.608509878050536,570139864989696000,1236992000,308633760,1745.666225,1745.6660160818712 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,608000,2004,0.499001996007984,fixed_full_OO_pool,2.6257591246937713,573915625684992000,1245184000,310677536,1757.228575,1757.2250950292398 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,612000,2004,0.7984031936127743,fixed_full_OO_pool,2.6430092947153994,577691386380288000,1253376000,312721664,1768.789075,1768.7872880116959 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,616000,2004,0.8982035928143712,fixed_full_OO_pool,2.6602586683610245,581467147075584000,1261568000,314765440,1780.347,1780.3476608187134 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,620000,2004,0.39920159680638717,fixed_full_OO_pool,2.6775062538993857,585242907770880000,1269760000,316809568,1791.9093,1791.9093274853801 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,624000,2004,0.6986027944111777,fixed_full_OO_pool,2.694755463819537,589018668466176000,1277952000,318853344,1803.469475,1803.4690423976608 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,628000,2004,0.499001996007984,fixed_full_OO_pool,2.7120057163594495,592794429161472000,1286144000,320897120,1815.028525,1815.02908625731 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,632000,2004,0.6487025948103792,fixed_full_OO_pool,2.7292525665938028,596570189856768000,1294336000,322941248,1826.59285,1826.5901608187135 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,636000,2004,0.7984031936127743,fixed_full_OO_pool,2.746500093400892,600345950552064000,1302528000,324985024,1838.15025,1838.150687134503 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,640000,2004,0.8483033932135728,fixed_full_OO_pool,2.7637469067062357,604121711247360000,1310720000,327029152,1849.713625,1849.7120394736842 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,644000,2004,0.499001996007984,fixed_full_OO_pool,2.7809947477415617,607897471942656000,1318912000,329072928,1861.27385,1861.271739766082 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,648000,2004,1.2974051896207583,fixed_full_OO_pool,2.798241372120877,611673232637952000,1327104000,331117056,1872.832725,1872.8344078947368 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,652000,2004,0.7485029940119761,fixed_full_OO_pool,2.815490077979242,615448993333248000,1335296000,333160832,1884.39475,1884.393581871345 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,656000,2004,1.347305389221557,fixed_full_OO_pool,2.8327411729221543,619224754028544000,1343488000,335204960,1895.954525,1895.9559868421052 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,660000,2004,0.8982035928143712,fixed_full_OO_pool,2.8499890664913172,623000514723840000,1351680000,337248736,1907.51545,1907.5154824561403 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,664000,2004,1.0479041916167664,fixed_full_OO_pool,2.8672348983047735,626776275419136000,1359872000,339292512,1919.07355,1919.0758040935673 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,668000,2004,0.9481037924151697,fixed_full_OO_pool,2.8844809486085756,630552036114432000,1368064000,341336640,1930.63605,1930.6374122807017 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,672000,2004,0.998003992015968,fixed_full_OO_pool,2.9017300416591265,634327796809728000,1376256000,343380416,1942.194725,1942.1975657894736 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,676000,2004,0.8483033932135728,fixed_full_OO_pool,2.91897985358826,638103557505024000,1384448000,345424544,1953.759775,1953.758428362573 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,680000,2004,0.8483033932135728,fixed_full_OO_pool,2.9362275508180673,641879318200320000,1392640000,347468320,1965.3176,1965.3188304093567 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,684000,2004,0.998003992015968,fixed_full_OO_pool,2.953473070194531,645655078895616000,1400832000,349512448,1976.879675,1976.880562865497 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,688000,2004,0.7984031936127743,fixed_full_OO_pool,2.9707196784009122,649430839590912000,1409024000,351556224,1988.44025,1988.4401608187134 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,692000,2004,1.097804391217565,fixed_full_OO_pool,2.9879665263400725,653206600286208000,1417216000,353600000,2000.0,2000.0 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,696000,2004,1.2475049900199602,fixed_full_OO_pool,3.005213846848864,656982360981504000,1425408000,355644128,2011.5593,2011.5625438596492 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,700000,2004,1.097804391217565,fixed_full_OO_pool,3.0224624681069203,660758121676800000,1433600000,357687904,2023.1232,2023.1211695906434 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,704000,2004,1.0479041916167664,fixed_full_OO_pool,3.039711572095338,664533882372096000,1441792000,359732032,2034.68475,2034.6830555555555 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,708000,2004,1.6467065868263475,fixed_full_OO_pool,3.056961042320149,668309643067392000,1449984000,361775808,2046.24495,2046.2427631578948 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,712000,2004,1.6966067864271457,fixed_full_OO_pool,3.0742093516772404,672085403762688000,1458176000,363819936,2057.80495,2057.8051023391813 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,716000,2004,1.347305389221557,fixed_full_OO_pool,3.091455800690585,675861164457984000,1466368000,365863712,2069.364325,2069.3650511695905 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,720000,2004,1.2475049900199602,fixed_full_OO_pool,3.1087007291946147,679636925153280000,1474560000,367907840,2080.9282,2080.9262573099413 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,724000,2004,1.5469061876247505,fixed_full_OO_pool,3.1259468178047487,683412685848576000,1482752000,369951616,2092.489475,2092.485650584795 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,728000,2004,1.5968063872255487,fixed_full_OO_pool,3.1431949076128918,687188446543872000,1490944000,371995392,2104.04705,2104.046125730994 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,732000,2004,1.2475049900199602,fixed_full_OO_pool,3.16044335753243,690964207239168000,1499136000,374039520,2115.606875,2115.608516081871 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,736000,2004,1.6467065868263475,fixed_full_OO_pool,3.1776904638763517,694739967934464000,1507328000,376083296,2127.1694,2127.167543859649 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,740000,2004,1.2974051896207583,fixed_full_OO_pool,3.1949383074438407,698515728629760000,1515520000,378127424,2138.72975,2138.7297807017544 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,744000,2004,1.1477045908183632,fixed_full_OO_pool,3.2121896155199243,702291489325056000,1523712000,380171200,2150.28925,2150.289692982456 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,748000,2004,1.9461077844311379,fixed_full_OO_pool,3.2294415422725593,706067250020352000,1531904000,382215328,2161.851975,2161.851235380117 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,752000,2004,1.2974051896207583,fixed_full_OO_pool,3.246691518392828,709843010715648000,1540096000,384259104,2173.414975,2173.410124269006 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,756000,2004,1.7964071856287425,fixed_full_OO_pool,3.2639401945554547,713618771410944000,1548288000,386303232,2184.972825,2184.9730921052633 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,760000,2004,1.3972055888223553,fixed_full_OO_pool,3.2811897488828334,717394532106240000,1556480000,388347008,2196.535475,2196.5320833333335 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,764000,2004,1.8962075848303395,fixed_full_OO_pool,3.2984404674896766,721170292801536000,1564672000,390390784,2208.0957,2208.091783625731 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,768000,2004,1.4970059880239521,fixed_full_OO_pool,3.3156901095993816,724946053496832000,1572864000,392434912,2219.6548,2219.6543859649123 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,772000,2004,1.5968063872255487,fixed_full_OO_pool,3.33294145211267,728721814192128000,1581056000,394478688,2231.217225,2231.213442982456 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,776000,2004,1.347305389221557,fixed_full_OO_pool,3.3501919468730272,732497574887424000,1589248000,396522816,2242.77625,2242.776067251462 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,780000,2004,1.6966067864271457,fixed_full_OO_pool,3.367442745121403,736273335582720000,1597440000,398566592,2254.33585,2254.3359502923977 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,784000,2004,1.5968063872255487,fixed_full_OO_pool,3.384693396822032,740049096278016000,1605632000,400610720,2265.897725,2265.89774122807 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,788000,2004,1.1976047904191618,fixed_full_OO_pool,3.4019437534693213,743824856973312000,1613824000,402654496,2277.459025,2277.4571271929826 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,792000,2004,1.4471057884231537,fixed_full_OO_pool,3.419191813744191,747600617668608000,1622016000,404698272,2289.0177,2289.0172807017543 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,796000,2004,1.2974051896207583,fixed_full_OO_pool,3.4364418736845255,751376378363904000,1630208000,406742400,2300.578425,2300.579407894737 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,800000,2004,1.5968063872255487,fixed_full_OO_pool,3.4536910011588287,755152139059200000,1638400000,408786176,2312.13805,2312.139283625731 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,804000,2004,1.3972055888223553,fixed_full_OO_pool,3.470941894274826,758927899754496000,1646592000,410830304,2323.702275,2323.7003874269008 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,808000,2004,1.2974051896207583,fixed_full_OO_pool,3.488192812082254,762703660449792000,1654784000,412874080,2335.2593,2335.261023391813 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,812000,2004,1.6467065868263475,fixed_full_OO_pool,3.5054423732041484,766479421145088000,1662976000,414918208,2346.823,2346.8222807017546 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,816000,2004,1.6966067864271457,fixed_full_OO_pool,3.522694220861627,770255181840384000,1671168000,416961984,2358.383125,2358.382010233918 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,820000,2004,1.8962075848303395,fixed_full_OO_pool,3.539946775176666,774030942535680000,1679360000,419006112,2369.94445,2369.943961988304 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,824000,2004,1.746506986027944,fixed_full_OO_pool,3.5572004296465054,777806703230976000,1687552000,421049888,2381.504325,2381.503764619883 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,828000,2004,1.746506986027944,fixed_full_OO_pool,3.5744512813434834,781582463926272000,1695744000,423093664,2393.063225,2393.0638523391813 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,832000,2004,1.3972055888223553,fixed_full_OO_pool,3.5917020997270526,785358224621568000,1703936000,425137792,2404.624025,2404.625957602339 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,836000,2004,2.19560878243513,fixed_full_OO_pool,3.6089503948442223,789133985316864000,1712128000,427181568,2416.184625,2416.185548245614 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,840000,2004,1.996007984031936,fixed_full_OO_pool,3.6262005620625697,792909746012160000,1720320000,429225696,2427.750525,2427.746162280702 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,844000,2004,2.3952095808383236,fixed_full_OO_pool,3.643451681893526,796685506707456000,1728512000,431269472,2439.30695,2439.3069736842103 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,848000,2004,1.9461077844311379,fixed_full_OO_pool,3.660702676713053,800461267402752000,1736704000,433313600,2450.86875,2450.8687865497077 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,852000,2004,1.996007984031936,fixed_full_OO_pool,3.677953835564355,804237028098048000,1744896000,435357376,2462.429925,2462.4282090643273 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,856000,2004,1.8962075848303395,fixed_full_OO_pool,3.695202147156621,808012788793344000,1753088000,437401504,2473.9897,2473.9906140350877 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,860000,2004,2.19560878243513,fixed_full_OO_pool,3.712455114867124,811788549488640000,1761280000,439445280,2485.5492,2485.5505263157893 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,864000,2004,2.4950099800399204,fixed_full_OO_pool,3.7297082290074064,815564310183936000,1769472000,441489056,2497.1089,2497.1103801169593 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,868000,2004,1.7964071856287425,fixed_full_OO_pool,3.746960031307406,819340070879232000,1777664000,443533184,2508.6737,2508.6713157894737 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,872000,2004,2.0459081836327346,fixed_full_OO_pool,3.7642131301657193,823115831574528000,1785856000,445576960,2520.233975,2520.2310014619884 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,876000,2004,2.095808383233533,fixed_full_OO_pool,3.7814640609547494,826891592269824000,1794048000,447621088,2531.794875,2531.7930774853803 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,880000,2004,2.3952095808383236,fixed_full_OO_pool,3.7987142905034124,830667352965120000,1802240000,449664864,2543.353375,2543.3532821637427 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,884000,2004,2.4950099800399204,fixed_full_OO_pool,3.815963496253308,834443113660416000,1810432000,451708992,2554.9139,2554.9154678362574 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,888000,2004,2.2954091816367264,fixed_full_OO_pool,3.8332159961273686,838218874355712000,1818624000,453752768,2566.47495,2566.4749269005847 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,892000,2004,2.8942115768463075,fixed_full_OO_pool,3.8504671736641063,841994635051008000,1826816000,455796544,2578.0335,2578.0351169590645 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,896000,2004,2.3952095808383236,fixed_full_OO_pool,3.8677175189347732,845770395746304000,1835008000,457840672,2589.59485,2589.5970614035086 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,900000,2004,2.3952095808383236,fixed_full_OO_pool,3.8849643555045543,849546156441600000,1843200000,459884448,2601.156375,2601.1563815789473 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,904000,2004,2.5948103792415167,fixed_full_OO_pool,3.902211851566616,853321917136896000,1851392000,461928576,2612.71565,2612.718932748538 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,908000,2004,2.1457085828343314,fixed_full_OO_pool,3.9194614229547895,857097677832192000,1859584000,463972352,2624.27895,2624.2777339181284 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,912000,2004,3.493013972055888,fixed_full_OO_pool,3.936708492014764,860873438527488000,1867776000,466016480,2635.83975,2635.8398391812866 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,916000,2004,3.0439121756487024,fixed_full_OO_pool,3.95395556077982,864649199222784000,1875968000,468060256,2647.398475,2647.3999780701756 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,920000,2004,2.6447105788423153,fixed_full_OO_pool,3.971201418503705,868424959918080000,1884160000,470104384,2658.960675,2658.9616739766084 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,924000,2004,2.5948103792415167,fixed_full_OO_pool,3.9884495642594993,872200720613376000,1892352000,472148160,2670.520325,2670.5215423976606 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,928000,2004,2.095808383233533,fixed_full_OO_pool,4.005699276165623,875976481308672000,1900544000,474191936,2682.079425,2682.081571637427 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,932000,2004,2.7944111776447107,fixed_full_OO_pool,4.022949894157549,879752242003968000,1908736000,476236064,2693.643175,2693.642814327485 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,936000,2004,2.5948103792415167,fixed_full_OO_pool,4.040197047070704,883528002699264000,1916928000,478279840,2705.20505,2705.202032163743 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,940000,2004,3.1936127744510974,fixed_full_OO_pool,4.057447809821202,887303763394560000,1925120000,480323968,2716.764675,2716.764480994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,944000,2004,3.293413173652695,fixed_full_OO_pool,4.07469816201056,891079524089856000,1933312000,482367744,2728.32825,2728.323201754386 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,948000,2004,3.5429141716566868,fixed_full_OO_pool,4.091949628864725,894855284785152000,1941504000,484411872,2739.887825,2739.8856652046784 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,952000,2004,3.842315369261477,fixed_full_OO_pool,4.109198916352664,898631045480448000,1949696000,486455648,2751.4427,2751.4469298245613 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,956000,2004,3.1936127744510974,fixed_full_OO_pool,4.126448496930922,902406806175744000,1957888000,488499424,2763.00535,2763.0059210526315 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,960000,2004,3.74251497005988,fixed_full_OO_pool,4.143697471274063,906182566871040000,1966080000,490543552,2774.570625,2774.5667178362573 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,964000,2004,3.642714570858283,fixed_full_OO_pool,4.160946734054014,909958327566336000,1974272000,492587328,2786.125875,2786.1278728070174 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,968000,2004,3.243512974051896,fixed_full_OO_pool,4.178194695549706,913734088261632000,1982464000,494631456,2797.691,2797.688713450292 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,972000,2004,3.8922155688622757,fixed_full_OO_pool,4.195443447437137,917509848956928000,1990656000,496675232,2809.249925,2809.248793859649 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,976000,2004,3.6926147704590817,fixed_full_OO_pool,4.212692645100049,921285609652224000,1998848000,498719360,2820.809525,2820.81125 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,980000,2004,4.241516966067864,fixed_full_OO_pool,4.229943050567267,925061370347520000,2007040000,500763136,2832.3749,2832.3694444444445 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,984000,2004,3.642714570858283,fixed_full_OO_pool,4.24719334085058,928837131042816000,2015232000,502807264,2843.93305,2843.9323245614037 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,988000,2004,4.04191616766467,fixed_full_OO_pool,4.2644408561672185,932612891738112000,2023424000,504851040,2855.495975,2855.491235380117 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,992000,2004,4.291417165668663,fixed_full_OO_pool,4.282012849718125,936388652433408000,2031616000,506894816,2867.0535,2867.051725146199 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,996000,2004,4.840319361277445,fixed_full_OO_pool,4.299261103150331,940164413128704000,2039808000,508938944,2878.612775,2878.6142763157895 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1000000,2004,3.592814371257485,fixed_full_OO_pool,4.31651031857046,943940173824000000,2048000000,510982720,2890.175025,2890.173384502924 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1004000,2004,4.241516966067864,fixed_full_OO_pool,4.333760273190629,947715934519296000,2056192000,513026848,2901.737225,2901.7350804093567 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1008000,2004,4.640718562874251,fixed_full_OO_pool,4.351009862641287,951491695214592000,2064384000,515070624,2913.294575,2913.2956213450293 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1012000,2004,3.74251497005988,fixed_full_OO_pool,4.368259296789765,955267455909888000,2072576000,517114752,2924.8567,2924.8573391812865 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1016000,2004,4.491017964071856,fixed_full_OO_pool,4.38551206652489,959043216605184000,2080768000,519158528,2936.416125,2936.417273391813 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1020000,2004,4.940119760479042,fixed_full_OO_pool,4.403453352033264,962818977300480000,2088960000,521202656,2947.978275,2947.9789839181285 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1024000,2004,4.8902195608782435,fixed_full_OO_pool,4.421671274782469,966594737995776000,2097152000,523246432,2959.5367,2959.539210526316 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1028000,2004,4.640718562874251,fixed_full_OO_pool,4.439008430870664,970370498691072000,2105344000,525290208,2971.0992,2971.098245614035 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1032000,2004,6.037924151696607,fixed_full_OO_pool,4.456259940408377,974146259386368000,2113536000,527334336,2982.6603,2982.660263157895 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1036000,2004,4.740518962075848,fixed_full_OO_pool,4.473510098796751,977922020081664000,2121728000,529378112,2994.218075,2994.2206798245616 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1040000,2004,4.590818363273453,fixed_full_OO_pool,4.490758605207213,981697780776960000,2129920000,531422240,3005.7826,3005.7816959064326 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1044000,2004,5.63872255489022,fixed_full_OO_pool,4.508009389664771,985473541472256000,2138112000,533466016,3017.34065,3017.3420321637427 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1048000,2004,4.990019960079841,fixed_full_OO_pool,4.5252584523914585,989249302167552000,2146304000,535510144,3028.901175,3028.9042178362574 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1052000,2004,5.039920159680639,fixed_full_OO_pool,4.5425091418344525,993025062862848000,2154496000,537553920,3040.46525,3040.462792397661 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1056000,2004,5.9880239520958085,fixed_full_OO_pool,4.559760039502548,996800823558144000,2162688000,539597696,3052.023225,3052.0231505847955 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1060000,2004,5.389221556886228,fixed_full_OO_pool,4.577010269800408,1000576584253440000,2170880000,541641824,3063.58605,3063.5846637426903 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1064000,2004,6.137724550898203,fixed_full_OO_pool,4.594259797834481,1004352344948736000,2179072000,543685600,3075.146925,3075.1441739766083 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1068000,2004,5.139720558882235,fixed_full_OO_pool,4.611921328953985,1008128105644032000,2187264000,545729728,3086.703375,3086.7075511695907 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1072000,2004,5.738522954091816,fixed_full_OO_pool,4.63274840459538,1011903866339328000,2195456000,547773504,3098.261175,3098.2679605263156 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1076000,2004,6.2375249500998,fixed_full_OO_pool,4.654483904993782,1015679627034624000,2203648000,549817632,3109.8289,3109.8280409356726 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1080000,2004,5.489021956087824,fixed_full_OO_pool,4.676954597481009,1019455387729920000,2211840000,551861408,3121.389625,3121.38759502924 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1084000,2004,6.786427145708583,fixed_full_OO_pool,4.697960629678435,1023231148425216000,2220032000,553905536,3132.948025,3132.9504020467834 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1088000,2004,6.337325349301397,fixed_full_OO_pool,4.718645909199905,1027006909120512000,2228224000,555949312,3144.51055,3144.5094298245613 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1092000,2004,6.2375249500998,fixed_full_OO_pool,4.736623674426228,1030782669815808000,2236416000,557993088,3156.067825,3156.0699926900584 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1096000,2004,6.636726546906188,fixed_full_OO_pool,4.753877169830311,1034558430511104000,2244608000,560037216,3167.63045,3167.631564327485 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1100000,2004,6.487025948103792,fixed_full_OO_pool,4.77112681808571,1038334191206400000,2252800000,562080992,3179.189475,3179.191615497076 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1104000,2004,7.734530938123753,fixed_full_OO_pool,4.78837631414334,1042109951901696000,2260992000,564125120,3190.753375,3190.7528143274853 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1108000,2004,6.986027944111776,fixed_full_OO_pool,4.805627180819089,1045885712596992000,2269184000,566168896,3202.311,3202.313274853801 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1112000,2004,8.183632734530939,fixed_full_OO_pool,4.82287752024105,1049661473292288000,2277376000,568213024,3213.87355,3213.8748684210527 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1116000,2004,8.13373253493014,fixed_full_OO_pool,4.840127930658766,1053437233987584000,2285568000,570256800,3225.4302,3225.435614035088 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1120000,2004,8.08383233532934,fixed_full_OO_pool,4.857379887865649,1057212994682880000,2293760000,572300928,3236.996475,3236.9961184210524 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1124000,2004,8.78243512974052,fixed_full_OO_pool,4.874629008854843,1060988755378176000,2301952000,574344704,3248.552025,3248.5571856725146 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1128000,2004,8.483033932135728,fixed_full_OO_pool,4.891882409007392,1064764516073472000,2310144000,576388480,3260.114775,3260.1161476608186 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1132000,2004,8.632734530938125,fixed_full_OO_pool,4.90913838308615,1068540276768768000,2318336000,578432608,3271.6776,3271.6776608187133 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1136000,2004,8.632734530938125,fixed_full_OO_pool,4.928680453719571,1072316037464064000,2326528000,580476384,3283.239125,3283.236980994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1140000,2004,8.483033932135728,fixed_full_OO_pool,4.945931126186625,1076091798159360000,2334720000,582520512,3294.8015,3294.798625730994 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1144000,2004,7.18562874251497,fixed_full_OO_pool,4.963179983902308,1079867558854656000,2342912000,584564288,3306.356875,3306.359744152047 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1148000,2004,8.13373253493014,fixed_full_OO_pool,4.9804308732723195,1083643319549952000,2351104000,586608416,3317.9198,3317.9212280701754 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1152000,2004,8.08383233532934,fixed_full_OO_pool,4.997682163477358,1087419080245248000,2359296000,588652192,3329.483725,3329.4798464912283 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1156000,2004,8.682634730538922,fixed_full_OO_pool,5.014931810488925,1091194840940544000,2367488000,590695968,3341.041575,3341.04024122807 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1160000,2004,8.982035928143713,fixed_full_OO_pool,5.032180412904256,1094970601635840000,2375680000,592740096,3352.600375,3352.60293128655 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1164000,2004,8.932135728542914,fixed_full_OO_pool,5.0494290861787485,1098746362331136000,2383872000,594783872,3364.161825,3364.162273391813 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1168000,2004,10.828343313373253,fixed_full_OO_pool,5.066679130898168,1102522123026432000,2392064000,596828000,3375.7226,3375.7243859649125 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1172000,2004,10.029940119760479,fixed_full_OO_pool,5.08393169881776,1106297883721728000,2400256000,598871776,3387.2855,3387.283304093567 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1176000,2004,9.930139720558882,fixed_full_OO_pool,5.101182590752012,1110073644417024000,2408448000,600915904,3398.84695,3398.8452192982454 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1180000,2004,10.62874251497006,fixed_full_OO_pool,5.118434311069755,1113849405112320000,2416640000,602959680,3410.406875,3410.4050073099415 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1184000,2004,9.73053892215569,fixed_full_OO_pool,5.135682882568282,1117625165807616000,2424832000,605003808,3421.9676,3421.967134502924 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1188000,2004,10.129740518962075,fixed_full_OO_pool,5.152932444186881,1121400926502912000,2433024000,607047584,3433.52605,3433.5273538011697 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1192000,2004,9.930139720558882,fixed_full_OO_pool,5.17018424593947,1125176687198208000,2441216000,609091360,3445.0867,3445.0869298245616 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1196000,2004,11.027944111776447,fixed_full_OO_pool,5.187431819927362,1128952447893504000,2449408000,611135488,3456.647275,3456.649100877193 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1200000,2004,12.375249500998004,fixed_full_OO_pool,5.204683623195936,1132728208588800000,2457600000,613179264,3468.2082,3468.208596491228 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1204000,2004,9.68063872255489,fixed_full_OO_pool,5.221933203425466,1136503969284096000,2465792000,615223392,3479.772825,3479.7695833333332 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1208000,2004,11.22754491017964,fixed_full_OO_pool,5.239184429804898,1140279729979392000,2473984000,617267168,3491.3276,3491.3308771929824 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1212000,2004,12.624750499001996,fixed_full_OO_pool,5.256434910054215,1144055490674688000,2482176000,619311296,3502.891375,3502.8921125730994 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1216000,2004,12.624750499001996,fixed_full_OO_pool,5.273686927904685,1147831251369984000,2490368000,621355072,3514.4535,3514.4512573099414 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1220000,2004,11.526946107784433,fixed_full_OO_pool,5.290936342763404,1151607012065280000,2498560000,623398848,3526.01065,3526.011856725146 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1224000,2004,11.87624750499002,fixed_full_OO_pool,5.308186468976653,1155382772760576000,2506752000,625442976,3537.57085,3537.5741374269005 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1228000,2004,13.12375249500998,fixed_full_OO_pool,5.3254356324921055,1159158533455872000,2514944000,627486752,3549.13515,3549.1326461988306 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1232000,2004,12.025948103792414,fixed_full_OO_pool,5.342687089814701,1162934294151168000,2523136000,629530880,3560.6952,3560.694970760234 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1236000,2004,12.075848303393213,fixed_full_OO_pool,5.3599380261575185,1166710054846464000,2531328000,631574656,3572.253625,3572.2551973684212 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1240000,2004,12.075848303393213,fixed_full_OO_pool,5.377187328765997,1170485815541760000,2539520000,633618784,3583.81925,3583.8158918128656 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1244000,2004,14.021956087824353,fixed_full_OO_pool,5.394437903740132,1174261576237056000,2547712000,635662560,3595.376225,3595.3765423976606 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1248000,2004,13.872255489021956,fixed_full_OO_pool,5.4116898161069384,1178037336932352000,2555904000,637706688,3606.93815,3606.9383187134504 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1252000,2004,14.920159680638722,fixed_full_OO_pool,5.428941237386316,1181813097627648000,2564096000,639750464,3618.49615,3618.498669590643 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1256000,2004,15.019960079840319,fixed_full_OO_pool,5.446194898309186,1185588858322944000,2572288000,641794240,3630.057725,3630.0579751461987 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1260000,2004,15.219560878243513,fixed_full_OO_pool,5.463443459124408,1189364619018240000,2580480000,643838368,3641.620725,3641.6194371345027 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1264000,2004,15.369261477045908,fixed_full_OO_pool,5.480694150806715,1193140379713536000,2588672000,645882144,3653.178425,3653.1798757309944 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1268000,2004,14.171656686626747,fixed_full_OO_pool,5.497945087324414,1196916140408832000,2596864000,647926272,3664.743,3664.7408771929827 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1272000,2004,14.770459081836327,fixed_full_OO_pool,5.5151975519375664,1200691901104128000,2605056000,649970048,3676.30325,3676.3005701754387 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1276000,2004,14.471057884231536,fixed_full_OO_pool,5.532449211850762,1204467661799424000,2613248000,652014176,3687.86175,3687.8633479532164 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1280000,2004,14.97005988023952,fixed_full_OO_pool,5.549700066470024,1208243422494720000,2621440000,654057952,3699.421775,3699.423106725146 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1284000,2004,14.271457085828343,fixed_full_OO_pool,5.566951383229138,1212019183190016000,2629632000,656102080,3710.983725,3710.984875730994 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1288000,2004,14.97005988023952,fixed_full_OO_pool,5.584204086729636,1215794943885312000,2637824000,658145856,3722.544725,3722.5443494152046 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1292000,2004,15.219560878243513,fixed_full_OO_pool,5.601455171027531,1219570704580608000,2646016000,660189632,3734.104575,3734.104159356725 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1296000,2004,16.81636726546906,fixed_full_OO_pool,5.618706920729537,1223346465275904000,2654208000,662233760,3745.663975,3745.6666739766083 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1300000,2004,15.518962075848302,fixed_full_OO_pool,5.635959372205867,1227122225971200000,2662400000,664277536,3757.225225,3757.2260745614035 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1304000,2004,17.864271457085827,fixed_full_OO_pool,5.6532106787897645,1230897986666496000,2670592000,666321664,3768.78815,3768.787558479532 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1308000,2004,17.015968063872254,fixed_full_OO_pool,5.670461306640258,1234673747361792000,2678784000,668365440,3780.34755,3780.3475 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1312000,2004,16.716566866267467,fixed_full_OO_pool,5.687710633831513,1238449508057088000,2686976000,670409568,3791.91035,3791.9090204678364 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1316000,2004,17.315369261477045,fixed_full_OO_pool,5.7049594230639435,1242225268752384000,2695168000,672453344,3803.4657,3803.47014619883 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1320000,2004,19.211576846307384,fixed_full_OO_pool,5.7222076582474015,1246001029447680000,2703360000,674497120,3815.029375,3815.0288377192983 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1324000,2004,19.560878243512974,fixed_full_OO_pool,5.739456968317843,1249776790142976000,2711552000,676541248,3826.59085,3826.5907456140353 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1328000,2004,16.766467065868262,fixed_full_OO_pool,5.7567061005274045,1253552550838272000,2719744000,678585024,3838.148025,3838.151337719298 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1332000,2004,19.16167664670659,fixed_full_OO_pool,5.773956031857265,1257328311533568000,2727936000,680629152,3849.711275,3849.712726608187 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1336000,2004,18.46307385229541,fixed_full_OO_pool,5.7912065593784465,1261104072228864000,2736128000,682672928,3861.27085,3861.272616959064 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1340000,2004,18.46307385229541,fixed_full_OO_pool,5.808457746811004,1264879832924160000,2744320000,684717056,3872.8352,3872.8336842105264 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1344000,2004,19.860279441117765,fixed_full_OO_pool,5.8257087128205844,1268655593619456000,2752512000,686760832,3884.3922,3884.39432748538 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1348000,2004,18.912175648702593,fixed_full_OO_pool,5.842959238912703,1272431354314752000,2760704000,688804960,3895.9554,3895.955730994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1352000,2004,17.964071856287426,fixed_full_OO_pool,5.860210952694631,1276207115010048000,2768896000,690848736,3907.515725,3907.5154020467835 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1356000,2004,19.560878243512974,fixed_full_OO_pool,5.8774586399986095,1279982875705344000,2777088000,692892512,3919.07625,3919.075014619883 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1360000,2004,20.009980039920162,fixed_full_OO_pool,5.894708776398458,1283758636400640000,2785280000,694936640,3930.637425,3930.6370102339183 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1364000,2004,20.85828343313373,fixed_full_OO_pool,5.911958221256112,1287534397095936000,2793472000,696980416,3942.1987,3942.1964035087717 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1368000,2004,20.309381237524953,fixed_full_OO_pool,5.929204974588421,1291310157791232000,2801664000,699024544,3953.760425,3953.7582383040935 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1372000,2004,19.91017964071856,fixed_full_OO_pool,5.946454443315872,1295085918486528000,2809856000,701068320,3965.321975,3965.317551169591 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1376000,2004,20.25948103792415,fixed_full_OO_pool,5.963701726875993,1298861679181824000,2818048000,703112448,3976.881325,3976.8800804093567 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1380000,2004,21.55688622754491,fixed_full_OO_pool,5.9809510380712645,1302637439877120000,2826240000,705156224,3988.441275,3988.439861111111 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1384000,2004,19.810379241516966,fixed_full_OO_pool,5.9982004399007804,1306413200572416000,2834432000,707200000,4000.0,4000.0 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1388000,2004,21.956087824351297,fixed_full_OO_pool,6.015450027551916,1310188961267712000,2842624000,709244128,4011.5633,4011.5613742690057 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1392000,2004,20.60878243512974,fixed_full_OO_pool,6.032700036523035,1313964721963008000,2850816000,711287904,4023.1223,4023.121432748538 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1396000,2004,21.35728542914172,fixed_full_OO_pool,6.049947615341387,1317740482658304000,2859008000,713332032,4034.680675,4034.6842470760234 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1400000,2004,24.35129740518962,fixed_full_OO_pool,6.067195834033191,1321516243353600000,2867200000,715375808,4046.246275,4046.2423757309944 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1404000,2004,20.65868263473054,fixed_full_OO_pool,6.084443650771346,1325292004048896000,2875392000,717419936,4057.804975,4057.80509502924 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1408000,2004,21.057884231536928,fixed_full_OO_pool,6.101694124057475,1329067764744192000,2883584000,719463712,4069.36705,4069.364254385965 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1412000,2004,22.15568862275449,fixed_full_OO_pool,6.118942359352691,1332843525439488000,2891776000,721507840,4080.927125,4080.926571637427 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1416000,2004,21.457085828343313,fixed_full_OO_pool,6.136194424687161,1336619286134784000,2899968000,723551616,4092.48215,4092.487792397661 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1420000,2004,21.457085828343313,fixed_full_OO_pool,6.153446850549016,1340395046830080000,2908160000,725595392,4104.047075,4104.046118421053 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1424000,2004,23.602794411177644,fixed_full_OO_pool,6.170698206238448,1344170807525376000,2916352000,727639520,4115.607175,4115.608428362573 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1428000,2004,22.604790419161677,fixed_full_OO_pool,6.187948562957139,1347946568220672000,2924544000,729683296,4127.16805,4127.167938596491 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1432000,2004,21.906187624750498,fixed_full_OO_pool,6.205201559957738,1351722328915968000,2932736000,731727424,4138.730525,4138.7295540935675 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1436000,2004,25.998003992015967,fixed_full_OO_pool,6.222453140090737,1355498089611264000,2940928000,733771200,4150.290025,4150.289466374269 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1440000,2004,25.349301397205586,fixed_full_OO_pool,6.2397043593041595,1359273850306560000,2949120000,735815328,4161.849575,4161.851937134503 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1444000,2004,26.047904191616766,fixed_full_OO_pool,6.256954182823085,1363049611001856000,2957312000,737859104,4173.41035,4173.4114766081875 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1448000,2004,25.349301397205586,fixed_full_OO_pool,6.274204188314163,1366825371697152000,2965504000,739903232,4184.97285,4184.9730847953215 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1452000,2004,24.75049900199601,fixed_full_OO_pool,6.291456877924502,1370601132392448000,2973696000,741947008,4196.534825,4196.532273391813 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1456000,2004,23.952095808383234,fixed_full_OO_pool,6.308710123623411,1374376893087744000,2981888000,743990784,4208.093575,4208.09240497076 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1460000,2004,25.998003992015967,fixed_full_OO_pool,6.325962830401129,1378152653783040000,2990080000,746034912,4219.6502,4219.655730994152 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1464000,2004,26.147704590818364,fixed_full_OO_pool,6.343216972342796,1381928414478336000,2998272000,748078688,4231.2143,4231.214298245614 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1468000,2004,26.047904191616766,fixed_full_OO_pool,6.360466920714825,1385704175173632000,3006464000,750122816,4242.7771,4242.7758187134505 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1472000,2004,25.59880239520958,fixed_full_OO_pool,6.377719368913935,1389479935868928000,3014656000,752166592,4254.3352,4254.336140350877 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1476000,2004,26.24750499001996,fixed_full_OO_pool,6.394971724943154,1393255696564224000,3022848000,754210720,4265.898375,4265.897551169591 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1480000,2004,26.696606786427147,fixed_full_OO_pool,6.412222630519213,1397031457259520000,3031040000,756254496,4277.45625,4277.457938596492 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1484000,2004,23.20359281437126,fixed_full_OO_pool,6.4294737270319215,1400807217954816000,3039232000,758298272,4289.017125,4289.017448830409 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1488000,2004,24.9500998003992,fixed_full_OO_pool,6.446721820173164,1404582978650112000,3047424000,760342400,4300.577425,4300.579700292397 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1492000,2004,26.147704590818364,fixed_full_OO_pool,6.46396895846352,1408358739345408000,3055616000,762386176,4312.136475,4312.139744152047 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1496000,2004,29.091816367265473,fixed_full_OO_pool,6.4812166487094425,1412134500040704000,3063808000,764430304,4323.701025,4323.700752923976 +synthetic,loop4x2-phi3.6-wd0.1,loop4x2,791101,0.0001,0.1,3.6,1500000,2004,25.64870259481038,fixed_full_OO_pool,6.498463879016539,1415910260736000000,3072000000,766474080,4335.2594,4335.260994152047 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,256,2004,0.0,fixed_full_OO_pool,0.0011241452830533186,241648684498944,524288,131072,0.412975,0.41868786549707604 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,512,2004,0.0,fixed_full_OO_pool,0.002245886345497436,483297368997888,1048576,262144,0.8341,0.8361842105263158 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1000,2004,0.049900199600798396,fixed_full_OO_pool,0.004384277283938394,943940173824000,2048000,511744,1.6305,1.63203216374269 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,2000,2004,0.0,fixed_full_OO_pool,0.008762949846891892,1887880347648000,4096000,1023232,3.263775,3.2627229532163744 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,3000,2004,0.049900199600798396,fixed_full_OO_pool,0.013145498590957788,2831820521472000,6144000,1534976,4.89595,4.894510233918129 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,4000,2004,0.049900199600798396,fixed_full_OO_pool,0.01752516156476405,3775760695296000,8192000,2046464,6.52905,6.525226608187134 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,5000,2004,0.29940119760479045,fixed_full_OO_pool,0.021907143264801966,4719700869120000,10240000,2557952,8.1597,8.156301169590643 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,6000,2004,0.14970059880239522,fixed_full_OO_pool,0.02629006017930806,5663641042944000,12288000,3069696,9.788625,9.788563596491228 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,7000,2004,0.09980039920159679,fixed_full_OO_pool,0.031127237901091575,6607581216768000,14336000,3581184,11.4216,11.419298245614035 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,8000,2004,0.09980039920159679,fixed_full_OO_pool,0.03587276820610795,7551521390592000,16384000,4092672,13.0503,13.050657894736842 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,9000,2004,0.14970059880239522,fixed_full_OO_pool,0.04068172918839587,8495461564416000,18432000,4604416,14.6867,14.681827485380117 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,10000,2004,0.09980039920159679,fixed_full_OO_pool,0.04498764434725874,9439401738240000,20480000,5115904,16.310875,16.313848684210527 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,11000,2004,0.049900199600798396,fixed_full_OO_pool,0.04929343666570882,10383341912064000,22528000,5627648,17.9435,17.945570175438597 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,12000,2004,0.09980039920159679,fixed_full_OO_pool,0.053600362865254284,11327282085888000,24576000,6139136,19.57665,19.57627923976608 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,13000,2004,0.29940119760479045,fixed_full_OO_pool,0.058435840726726584,12271222259712000,26624000,6650624,21.20495,21.20769736842105 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,14000,2004,0.29940119760479045,fixed_full_OO_pool,0.0633206264105522,13215162433536000,28672000,7162368,22.8415,22.838845029239767 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,15000,2004,0.14970059880239522,fixed_full_OO_pool,0.0682009631767869,14159102607360000,30720000,7673856,24.4697,24.470277777777778 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,16000,2004,0.19960079840319359,fixed_full_OO_pool,0.07272105745867723,15103042781184000,32768000,8185344,26.100225,26.101370614035087 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,17000,2004,0.34930139720558884,fixed_full_OO_pool,0.0770278641415967,16046982955008000,34816000,8697088,27.7315,27.73328947368421 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,18000,2004,0.4491017964071856,fixed_full_OO_pool,0.08133387300082379,16990923128832000,36864000,9208576,29.365125,29.36392909356725 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,19000,2004,0.049900199600798396,fixed_full_OO_pool,0.08564049597208699,17934863302656000,38912000,9720320,30.995775,30.99593932748538 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,20000,2004,0.29940119760479045,fixed_full_OO_pool,0.08994774155318737,18878803476480000,40960000,10231808,32.62985,32.626513157894735 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,21000,2004,0.249500998003992,fixed_full_OO_pool,0.09425365161564615,19822743650304000,43008000,10743296,34.2587,34.25785087719298 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,22000,2004,0.29940119760479045,fixed_full_OO_pool,0.09855981487056448,20766683824128000,45056000,11255040,35.88965,35.88981725146199 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,23000,2004,0.29940119760479045,fixed_full_OO_pool,0.10286712426692247,21710623997952000,47104000,11766528,37.52075,37.52082602339181 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,24000,2004,0.249500998003992,fixed_full_OO_pool,0.10717325259310503,22654564171776000,49152000,12278016,39.1531,39.151652046783624 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,25000,2004,0.249500998003992,fixed_full_OO_pool,0.11147930879870223,23598504345600000,51200000,12789760,40.78145,40.783998538011694 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,26000,2004,0.29940119760479045,fixed_full_OO_pool,0.11578526326972577,24542444519424000,53248000,13301248,42.413275,42.41490131578947 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,27000,2004,0.19960079840319359,fixed_full_OO_pool,0.1200913583383792,25486384693248000,55296000,13812736,44.0468,44.04555555555555 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,28000,2004,0.049900199600798396,fixed_full_OO_pool,0.12439737892606192,26430324867072000,57344000,14324480,45.67505,45.67791666666667 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,29000,2004,0.249500998003992,fixed_full_OO_pool,0.12870362848871283,27374265040896000,59392000,14835968,47.3092,47.308479532163744 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,30000,2004,0.29940119760479045,fixed_full_OO_pool,0.13300979376874036,28318205214720000,61440000,15347712,48.939325,48.94056652046783 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,31000,2004,0.29940119760479045,fixed_full_OO_pool,0.13731718487002784,29262145388544000,63488000,15859200,50.572825,50.571224415204675 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,32000,2004,0.249500998003992,fixed_full_OO_pool,0.14162321288138627,30206085562368000,65536000,16370688,52.20115,52.20263888888889 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,33000,2004,0.19960079840319359,fixed_full_OO_pool,0.14593031353110242,31150025736192000,67584000,16882432,53.832525,53.83454312865497 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,34000,2004,0.19960079840319359,fixed_full_OO_pool,0.1502378996151189,32093965910016000,69632000,17393920,55.46365,55.46554824561404 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,35000,2004,0.19960079840319359,fixed_full_OO_pool,0.15454426659581563,33037906083840000,71680000,17905408,57.09505,57.096513157894734 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,36000,2004,0.499001996007984,fixed_full_OO_pool,0.15885047789973517,33981846257664000,73728000,18417152,58.727825,58.72821271929825 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,37000,2004,0.14970059880239522,fixed_full_OO_pool,0.16315654809483224,34925786431488000,75776000,18928640,60.355625,60.35970394736842 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,38000,2004,0.19960079840319359,fixed_full_OO_pool,0.16746274831911756,35869726605312000,77824000,19440384,61.99095,61.99103070175438 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,39000,2004,0.34930139720558884,fixed_full_OO_pool,0.17177028932919106,36813666779136000,79872000,19951872,63.62315,63.62187865497076 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,40000,2004,0.39920159680638717,fixed_full_OO_pool,0.17607632509432733,37757606952960000,81920000,20463360,65.2529,65.25308479532164 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,41000,2004,0.29940119760479045,fixed_full_OO_pool,0.18038218316104676,38701547126784000,83968000,20975104,66.886125,66.88471856725147 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,42000,2004,0.14970059880239522,fixed_full_OO_pool,0.18468943423695033,39645487300608000,86016000,21486592,68.5145,68.51612573099415 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,43000,2004,0.249500998003992,fixed_full_OO_pool,0.1889960964003371,40589427474432000,88064000,21998080,70.148525,70.14670687134503 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,44000,2004,0.249500998003992,fixed_full_OO_pool,0.19330234128567908,41533367648256000,90112000,22509824,71.78185,71.77832602339181 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,45000,2004,0.14970059880239522,fixed_full_OO_pool,0.19760852749355964,42477307822080000,92160000,23021312,73.41665,73.40879385964912 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,46000,2004,0.19960079840319359,fixed_full_OO_pool,0.20191477314879497,43421247995904000,94208000,23532800,75.041875,75.04066154970761 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,47000,2004,0.249500998003992,fixed_full_OO_pool,0.2062209101041986,44365188169728000,96256000,24044544,76.67005,76.673033625731 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,48000,2004,0.29940119760479045,fixed_full_OO_pool,0.21052701784401304,45309128343552000,98304000,24556032,78.304225,78.30359283625731 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,49000,2004,0.29940119760479045,fixed_full_OO_pool,0.21483307299307652,46253068517376000,100352000,25067776,79.935,79.93558479532163 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,50000,2004,0.39920159680638717,fixed_full_OO_pool,0.21914057094293335,47197008691200000,102400000,25579264,81.564025,81.56689692982457 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,51000,2004,0.499001996007984,fixed_full_OO_pool,0.22344674973645143,48140948865024000,104448000,26090752,83.19275,83.19825292397661 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,52000,2004,0.29940119760479045,fixed_full_OO_pool,0.2277530434427576,49084889038848000,106496000,26602496,84.829475,84.829375 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,53000,2004,0.19960079840319359,fixed_full_OO_pool,0.23206026065887678,50028829212672000,108544000,27113984,86.46075,86.4603581871345 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,54000,2004,0.249500998003992,fixed_full_OO_pool,0.23636639343160723,50972769386496000,110592000,27625472,88.0915,88.09141812865496 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,55000,2004,0.14970059880239522,fixed_full_OO_pool,0.24067259551025927,51916709560320000,112640000,28137216,89.720875,89.72361476608187 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,56000,2004,0.09980039920159679,fixed_full_OO_pool,0.24497892588066558,52860649734144000,114688000,28648704,91.355375,91.3541264619883 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,57000,2004,0.34930139720558884,fixed_full_OO_pool,0.2492851367065062,53804589907968000,116736000,29160448,92.98645,92.98607456140351 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,58000,2004,0.19960079840319359,fixed_full_OO_pool,0.25359240328789584,54748530081792000,118784000,29671936,94.616975,94.61716739766082 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,59000,2004,0.34930139720558884,fixed_full_OO_pool,0.25789881808476317,55692470255616000,120832000,30183424,96.249875,96.2479130116959 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,60000,2004,0.34930139720558884,fixed_full_OO_pool,0.26220539304945206,56636410429440000,122880000,30695168,97.879975,97.88000365497076 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,61000,2004,0.14970059880239522,fixed_full_OO_pool,0.2665130158751789,57580350603264000,124928000,31206656,99.5082,99.51143274853801 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,62000,2004,0.249500998003992,fixed_full_OO_pool,0.2708195265962018,58524290777088000,126976000,31718144,101.140075,101.14232821637427 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,63000,2004,0.19960079840319359,fixed_full_OO_pool,0.2751261330395937,59468230950912000,129024000,32229888,102.777075,102.7734100877193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,64000,2004,0.249500998003992,fixed_full_OO_pool,0.27943266146195433,60412171124736000,131072000,32741376,104.4066,104.40464912280702 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,68000,2004,0.249500998003992,fixed_full_OO_pool,0.29665784313136506,64187931820032000,139264000,34787840,110.929625,110.93075657894737 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,72000,2004,0.34930139720558884,fixed_full_OO_pool,0.31388457282653287,67963692515328000,147456000,36834048,117.453525,117.4558004385965 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,76000,2004,0.249500998003992,fixed_full_OO_pool,0.3311097878559182,71739453210624000,155648000,38880512,123.9815,123.98118421052632 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,80000,2004,0.29940119760479045,fixed_full_OO_pool,0.34833551022120646,75515213905920000,163840000,40926720,130.5097,130.50559941520467 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,84000,2004,0.34930139720558884,fixed_full_OO_pool,0.36556057101736467,79290974601216000,172032000,42972928,137.031775,137.0309100877193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,88000,2004,0.34930139720558884,fixed_full_OO_pool,0.38278384518395697,83066735296512000,180224000,45019392,143.557075,143.55668494152047 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,92000,2004,0.249500998003992,fixed_full_OO_pool,0.4000072495235751,86842495991808000,188416000,47065600,150.0823,150.0815350877193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,96000,2004,0.499001996007984,fixed_full_OO_pool,0.4172305336729106,90618256687104000,196608000,49112064,156.60565,156.60759502923977 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,100000,2004,0.5489021956087825,fixed_full_OO_pool,0.4344540291548603,94394017382400000,204800000,51158272,163.130525,163.13249634502924 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,104000,2004,0.7984031936127743,fixed_full_OO_pool,0.4516773463330335,98169778077696000,212992000,53204736,169.654125,169.6585197368421 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,108000,2004,0.5988023952095809,fixed_full_OO_pool,0.468900986433857,101945538772992000,221184000,55250944,176.18455,176.1826096491228 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,112000,2004,0.7984031936127743,fixed_full_OO_pool,0.4861244080360565,105721299468288000,229376000,57297408,182.709075,182.70849780701755 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,116000,2004,0.5988023952095809,fixed_full_OO_pool,0.5033477622167104,109497060163584000,237568000,59343616,189.233275,189.23349780701756 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,120000,2004,0.6986027944111777,fixed_full_OO_pool,0.5205712545849382,113272820858880000,245760000,61390080,195.763725,195.75851973684212 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,124000,2004,0.5489021956087825,fixed_full_OO_pool,0.5377944727045381,117048581554176000,253952000,63436288,202.284825,202.28397295321636 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,128000,2004,0.6986027944111777,fixed_full_OO_pool,0.5550177381249766,120824342249472000,262144000,65482752,208.811175,208.80959429824563 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,132000,2004,0.8483033932135728,fixed_full_OO_pool,0.5722418297402975,124600102944768000,270336000,67528960,215.335825,215.33452850877194 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,136000,2004,0.9481037924151697,fixed_full_OO_pool,0.5894654651110371,128375863640064000,278528000,69575424,221.859925,221.8604788011696 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,140000,2004,1.1477045908183632,fixed_full_OO_pool,0.6066903457728525,132151624335360000,286720000,71621632,228.384975,228.38535453216375 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,144000,2004,1.097804391217565,fixed_full_OO_pool,0.6239135170044998,135927385030656000,294912000,73668096,234.91125,234.91098684210527 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,148000,2004,1.097804391217565,fixed_full_OO_pool,0.6411378369418284,139703145725952000,303104000,75714304,241.4382,241.43558479532163 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,152000,2004,0.998003992015968,fixed_full_OO_pool,0.6583607299408565,143478906421248000,311296000,77760768,247.961725,247.96161915204678 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,156000,2004,0.8483033932135728,fixed_full_OO_pool,0.6755842928391778,147254667116544000,319488000,79806976,254.4794,254.48757309941521 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,160000,2004,1.1976047904191618,fixed_full_OO_pool,0.6928072100867414,151030427811840000,327680000,81853184,261.01085,261.01151315789474 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,164000,2004,0.8982035928143712,fixed_full_OO_pool,0.710030643855118,154806188507136000,335872000,83899648,267.540575,267.5366410818713 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,168000,2004,1.2475049900199602,fixed_full_OO_pool,0.7272535969989581,158581949202432000,344064000,85945856,274.0624,274.0619883040936 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,172000,2004,0.998003992015968,fixed_full_OO_pool,0.7444771398717744,162357709897728000,352256000,87992320,280.5924,280.58707602339183 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,176000,2004,1.1976047904191618,fixed_full_OO_pool,0.7617001690570679,166133470593024000,360448000,90038528,287.112375,287.1126937134503 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,180000,2004,1.4471057884231537,fixed_full_OO_pool,0.7789223792786814,169909231288320000,368640000,92084992,293.6389,293.6382894736842 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,184000,2004,1.9461077844311379,fixed_full_OO_pool,0.7961450098548084,173684991983616000,376832000,94131200,300.161475,300.1635270467836 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,188000,2004,1.996007984031936,fixed_full_OO_pool,0.8133666739612818,177460752678912000,385024000,96177664,306.690925,306.6886951754386 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,192000,2004,1.4471057884231537,fixed_full_OO_pool,0.8305884760111156,181236513374208000,393216000,98223872,313.214825,313.2137390350877 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,196000,2004,1.746506986027944,fixed_full_OO_pool,0.8478106510753018,185012274069504000,401408000,100270336,319.7388,319.7397076023392 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,200000,2004,2.345309381237525,fixed_full_OO_pool,0.8650334764127102,188788034764800000,409600000,102316544,326.26785,326.2639985380117 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,204000,2004,1.6966067864271457,fixed_full_OO_pool,0.8822557470430102,192563795460096000,417792000,104363008,332.790075,332.79022295321636 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,208000,2004,1.7964071856287425,fixed_full_OO_pool,0.8994784096338683,196339556155392000,425984000,106409216,339.3112,339.3156725146199 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,212000,2004,2.245508982035928,fixed_full_OO_pool,0.9167000692482624,200115316850688000,434176000,108455680,345.838675,345.8411293859649 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,216000,2004,1.9461077844311379,fixed_full_OO_pool,0.9339239516367929,203891077545984000,442368000,110501888,352.36695,352.365533625731 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,220000,2004,2.345309381237525,fixed_full_OO_pool,0.9511460397051027,207666838241280000,450560000,112548352,358.891375,358.89143640350875 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,224000,2004,2.744510978043912,fixed_full_OO_pool,0.9683693243925356,211442598936576000,458752000,114594560,365.41325,365.4167763157895 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,228000,2004,2.694610778443114,fixed_full_OO_pool,0.9855914711341676,215218359631872000,466944000,116641024,371.944975,371.94161184210526 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,232000,2004,2.245508982035928,fixed_full_OO_pool,1.002814306517442,218994120327168000,475136000,118687232,378.464275,378.46732821637426 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,236000,2004,3.44311377245509,fixed_full_OO_pool,1.0200367368643897,222769881022464000,483328000,120733696,384.9926,384.99266081871343 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,240000,2004,3.1936127744510974,fixed_full_OO_pool,1.0372601793395977,226545641717760000,491520000,122779904,391.5193,391.51729532163745 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,244000,2004,2.844311377245509,fixed_full_OO_pool,1.0544828168840872,230321402413056000,499712000,124826112,398.042225,398.0424817251462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,248000,2004,2.0459081836327346,fixed_full_OO_pool,1.0717048751573182,234097163108352000,507904000,126872576,404.567575,404.56824926900583 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,252000,2004,3.293413173652695,fixed_full_OO_pool,1.0889271168193468,237872923803648000,516096000,128918784,411.0936,411.09298245614036 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,256000,2004,2.8942115768463075,fixed_full_OO_pool,1.1061492554460548,241648684498944000,524288000,130965248,417.61815,417.61886695906435 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,260000,2004,3.44311377245509,fixed_full_OO_pool,1.1233715990340958,245424445194240000,532480000,133011456,424.142975,424.1437755847953 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,264000,2004,3.1936127744510974,fixed_full_OO_pool,1.1405937555815198,249200205889536000,540672000,135057920,430.67075,430.6691885964912 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,268000,2004,3.243512974051896,fixed_full_OO_pool,1.1578160268803024,252975966584832000,548864000,137104128,437.191275,437.194725877193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,272000,2004,3.44311377245509,fixed_full_OO_pool,1.1750383589623703,256751727280128000,557056000,139150592,443.7231,443.71954678362573 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,276000,2004,3.3932135728542914,fixed_full_OO_pool,1.192260432034317,260527487975424000,565248000,141196800,450.245675,450.2447843567251 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,280000,2004,3.592814371257485,fixed_full_OO_pool,1.2094825385086652,264303248670720000,573440000,143243264,456.769775,456.7707346491228 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,284000,2004,3.493013972055888,fixed_full_OO_pool,1.2267046806619812,268079009366016000,581632000,145289472,463.2998,463.29488304093564 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,288000,2004,3.493013972055888,fixed_full_OO_pool,1.243926893936263,271854770061312000,589824000,147335936,469.82105,469.82125 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,292000,2004,3.592814371257485,fixed_full_OO_pool,1.2611502263984746,275630530756608000,598016000,149382144,476.347325,476.3459466374269 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,296000,2004,3.6926147704590817,fixed_full_OO_pool,1.2783724141007082,279406291451904000,606208000,151428608,482.872525,482.8717361111111 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,300000,2004,3.493013972055888,fixed_full_OO_pool,1.2955957310543291,283182052147200000,614400000,153474816,489.39375,489.39717105263156 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,304000,2004,4.241516966067864,fixed_full_OO_pool,1.3128174061100517,286957812842496000,622592000,155521280,495.924625,495.9221308479532 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,308000,2004,3.592814371257485,fixed_full_OO_pool,1.330040697782404,290733573537792000,630784000,157567488,502.44855,502.4471710526316 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,312000,2004,3.992015968063872,fixed_full_OO_pool,1.3472620452940465,294509334233088000,638976000,159613952,508.97245,508.97315058479535 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,316000,2004,3.1936127744510974,fixed_full_OO_pool,1.3644846539333877,298285094928384000,647168000,161660160,515.499175,515.4977814327485 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,320000,2004,3.642714570858283,fixed_full_OO_pool,1.381705480661864,302060855623680000,655360000,163706368,522.02315,522.0228143274854 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,324000,2004,4.291417165668663,fixed_full_OO_pool,1.3989267645848709,305836616318976000,663552000,165752832,528.550525,528.5482858187135 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,328000,2004,4.39121756487026,fixed_full_OO_pool,1.4161481920329646,309612377014272000,671744000,167799040,535.075275,535.0732054093568 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,332000,2004,4.840319361277445,fixed_full_OO_pool,1.4333689178547098,313388137709568000,679936000,169845504,541.599425,541.5991483918128 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,336000,2004,5.189620758483033,fixed_full_OO_pool,1.4505894834848327,317163898404864000,688128000,171891712,548.1241,548.1240789473684 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,340000,2004,5.239520958083832,fixed_full_OO_pool,1.4678108013990439,320939659100160000,696320000,173938176,554.6525,554.6494005847953 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,344000,2004,4.790419161676647,fixed_full_OO_pool,1.4850321420168298,324715419795456000,704512000,175984384,561.176225,561.1744700292397 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,348000,2004,5.489021956087824,fixed_full_OO_pool,1.5022534664306375,328491180490752000,712704000,178030848,567.6995,567.7005409356725 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,352000,2004,6.487025948103792,fixed_full_OO_pool,1.5194747917457587,332266941186048000,720896000,180077056,574.229,574.2247660818714 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,356000,2004,4.990019960079841,fixed_full_OO_pool,1.5366954488100277,336042701881344000,729088000,182123520,580.74945,580.75125 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,360000,2004,4.740518962075848,fixed_full_OO_pool,1.553915957107933,339818462576640000,737280000,184169728,587.2773,587.275716374269 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,364000,2004,4.990019960079841,fixed_full_OO_pool,1.571136964123903,343594223271936000,745472000,186216192,593.80205,593.801571637427 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,368000,2004,5.389221556886228,fixed_full_OO_pool,1.5883594830303143,347369983967232000,753664000,188262400,600.328575,600.3262317251462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,372000,2004,5.788423153692615,fixed_full_OO_pool,1.6055802949311004,351145744662528000,761856000,190308864,606.854025,606.8519846491228 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,376000,2004,4.8902195608782435,fixed_full_OO_pool,1.6228025160471184,354921505357824000,770048000,192355072,613.377875,613.3770358187135 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,380000,2004,6.636726546906188,fixed_full_OO_pool,1.6400233293397146,358697266053120000,778240000,194401536,619.905425,619.9024817251462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,384000,2004,6.487025948103792,fixed_full_OO_pool,1.6572456817929115,362473026748416000,786432000,196447744,626.429275,626.4275328947368 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,388000,2004,6.037924151696607,fixed_full_OO_pool,1.6744670729101119,366248787443712000,794624000,198494208,632.953,632.9535380116959 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,392000,2004,6.836327345309382,fixed_full_OO_pool,1.6916893879489767,370024548139008000,802816000,200540416,639.47635,639.4786622807018 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,396000,2004,5.888223552894212,fixed_full_OO_pool,1.7089108505048272,373800308834304000,811008000,202586624,646.00355,646.0032236842105 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,400000,2004,8.08383233532934,fixed_full_OO_pool,1.7261319980811742,377576069529600000,819200000,204633088,652.52465,652.5296125730994 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,404000,2004,7.135728542914172,fixed_full_OO_pool,1.7433535927896284,381351830224896000,827392000,206679296,659.053775,659.0538925438597 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,408000,2004,8.632734530938125,fixed_full_OO_pool,1.7605747158556349,385127590920192000,835584000,208725760,665.582875,665.5791118421052 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,412000,2004,6.487025948103792,fixed_full_OO_pool,1.7777957253240877,388903351615488000,843776000,210771968,672.1037,672.1046052631579 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,416000,2004,7.18562874251497,fixed_full_OO_pool,1.7950168502682613,392679112310784000,851968000,212818432,678.629725,678.630274122807 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,420000,2004,7.83433133732535,fixed_full_OO_pool,1.8122377785885087,396454873006080000,860160000,214864640,685.153725,685.1553033625731 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,424000,2004,8.43313373253493,fixed_full_OO_pool,1.829458395631777,400230633701376000,868352000,216911104,691.68155,691.6807090643275 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,428000,2004,8.682634730538922,fixed_full_OO_pool,1.8466792602588733,404006394396672000,876544000,218957312,698.205125,698.2058004385965 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,432000,2004,8.932135728542914,fixed_full_OO_pool,1.8639000989455317,407782155091968000,884736000,221003776,704.73425,704.7310160818713 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,436000,2004,8.682634730538922,fixed_full_OO_pool,1.881121156881046,411557915787264000,892928000,223049984,711.25405,711.2566593567251 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,440000,2004,8.682634730538922,fixed_full_OO_pool,1.8983419457698862,415333676482560000,901120000,225096448,717.782775,717.7819334795322 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,444000,2004,8.383233532934131,fixed_full_OO_pool,1.9155631267641569,419109437177856000,909312000,227142656,724.311975,724.3062024853801 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,448000,2004,9.281437125748502,fixed_full_OO_pool,1.9327833104982144,422885197873152000,917504000,229189120,730.8328,730.8326315789474 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,452000,2004,10.079840319361278,fixed_full_OO_pool,1.950004903882121,426660958568448000,925696000,231235328,737.355575,737.3578399122807 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,456000,2004,9.530938123752495,fixed_full_OO_pool,1.9672252398574104,430436719263744000,933888000,233281792,743.8846,743.8830701754385 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,460000,2004,9.580838323353294,fixed_full_OO_pool,1.984447337022672,434212479959040000,942080000,235328000,750.409,750.4080409356725 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,464000,2004,11.676646706586826,fixed_full_OO_pool,2.0016687845552545,437988240654336000,950272000,237374464,756.931775,756.9341849415205 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,468000,2004,9.780439121756487,fixed_full_OO_pool,2.0188904868583712,441764001349632000,958464000,239420672,763.45835,763.4588377192982 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,472000,2004,11.626746506986029,fixed_full_OO_pool,2.036110906942437,445539762044928000,966656000,241467136,769.984375,769.9845065789474 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,476000,2004,9.580838323353294,fixed_full_OO_pool,2.05333293494458,449315522740224000,974848000,243513344,776.5063,776.5098391812866 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,480000,2004,12.375249500998004,fixed_full_OO_pool,2.0705542867196103,453091283435520000,983040000,245559552,783.0342,783.0342982456141 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,484000,2004,10.728542914171657,fixed_full_OO_pool,2.0877756061518773,456867044130816000,991232000,247606016,789.559875,789.5600182748537 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,488000,2004,10.229540918163673,fixed_full_OO_pool,2.104997044145647,460642804826112000,999424000,249652224,796.08695,796.0845979532164 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,492000,2004,11.826347305389222,fixed_full_OO_pool,2.1222182516432886,464418565521408000,1007616000,251698688,802.611575,802.610471491228 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,496000,2004,10.978043912175648,fixed_full_OO_pool,2.1394388126136943,468194326216704000,1015808000,253744896,809.136325,809.1353910818714 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,500000,2004,11.526946107784433,fixed_full_OO_pool,2.1566598780039286,471970086912000000,1024000000,255791360,815.660125,815.6613852339182 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,504000,2004,11.477045908183632,fixed_full_OO_pool,2.1738810994765823,475745847607296000,1032192000,257837568,822.185675,822.1861878654971 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,508000,2004,12.674650698602793,fixed_full_OO_pool,2.191101713858338,479521608302592000,1040384000,259884032,828.71065,828.7120102339181 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,512000,2004,13.722554890219559,fixed_full_OO_pool,2.2083221771640495,483297368997888000,1048576000,261930240,835.23295,835.2372880116959 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,516000,2004,13.47305389221557,fixed_full_OO_pool,2.2255427019360163,487073129693184000,1056768000,263976704,841.763075,841.7623574561403 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,520000,2004,13.223552894211576,fixed_full_OO_pool,2.242763526679741,490848890388480000,1064960000,266022912,848.28965,848.2870102339182 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,524000,2004,12.425149700598801,fixed_full_OO_pool,2.259984550767889,494624651083776000,1073152000,268069376,854.814675,854.8128252923976 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,528000,2004,12.82435129740519,fixed_full_OO_pool,2.2772066344155206,498400411779072000,1081344000,270115584,861.340575,861.337576754386 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,532000,2004,12.77445109780439,fixed_full_OO_pool,2.294427530614452,502176172474368000,1089536000,272162048,867.8607,867.8641081871345 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,536000,2004,12.125748502994012,fixed_full_OO_pool,2.311649487645676,505951933169664000,1097728000,274208256,874.3878,874.3886842105263 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,540000,2004,14.37125748502994,fixed_full_OO_pool,2.3288706786951257,509727693864960000,1105920000,276254720,880.911925,880.9146308479532 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,544000,2004,14.12175648702595,fixed_full_OO_pool,2.3460920427853447,513503454560256000,1114112000,278300928,887.4355,887.4397222222223 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,548000,2004,14.97005988023952,fixed_full_OO_pool,2.3633125112836972,517279215255552000,1122304000,280347392,893.965575,893.9647989766082 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,552000,2004,15.768463073852296,fixed_full_OO_pool,2.3805337975919247,521054975950848000,1130496000,282393600,900.4841,900.4906286549708 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,556000,2004,14.920159680638722,fixed_full_OO_pool,2.397754232129082,524830736646144000,1138688000,284439808,907.014725,907.0146893274854 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,560000,2004,17.21556886227545,fixed_full_OO_pool,2.4149747011914022,528606497341440000,1146880000,286486272,913.539325,913.5405665204678 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,564000,2004,17.065868263473057,fixed_full_OO_pool,2.4321950011659,532382258036736000,1155072000,288532480,920.064275,920.0654568713451 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,568000,2004,16.217564870259483,fixed_full_OO_pool,2.4494152534556473,536158018732032000,1163264000,290578944,926.594875,926.590456871345 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,572000,2004,14.97005988023952,fixed_full_OO_pool,2.4666357406673747,539933779427328000,1171456000,292625152,933.1148,933.116081871345 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,576000,2004,14.770459081836327,fixed_full_OO_pool,2.4838562939833437,543709540122624000,1179648000,294671616,939.638775,939.6420504385965 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,580000,2004,16.26746506986028,fixed_full_OO_pool,2.5010764595545414,547485300817920000,1187840000,296717824,946.168025,946.166312134503 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,584000,2004,15.219560878243513,fixed_full_OO_pool,2.5182966386412993,551261061513216000,1196032000,298764288,952.690725,952.6924671052632 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,588000,2004,16.716566866267467,fixed_full_OO_pool,2.5355171738834015,555036822208512000,1204224000,300810496,959.216975,959.2171673976608 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,592000,2004,16.81636726546906,fixed_full_OO_pool,2.5527375580059983,558812582903808000,1212416000,302856960,965.746525,965.7423209064327 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,596000,2004,17.465069860279442,fixed_full_OO_pool,2.5699579540743596,562588343599104000,1220608000,304903168,972.265375,972.2681030701755 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,600000,2004,16.16766467065868,fixed_full_OO_pool,2.5871794877118535,566364104294400000,1228800000,306949632,978.793025,978.7935343567251 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,604000,2004,17.26546906187625,fixed_full_OO_pool,2.604400874742617,570139864989696000,1236992000,308995840,985.318275,985.3183808479532 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,608000,2004,17.415169660678643,fixed_full_OO_pool,2.621620949516073,573915625684992000,1245184000,311042304,991.843275,991.8441995614035 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,612000,2004,16.86626746506986,fixed_full_OO_pool,2.638842877233401,577691386380288000,1253376000,313088512,998.367125,998.3692507309942 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,616000,2004,19.06187624750499,fixed_full_OO_pool,2.6560632207503336,581467147075584000,1261568000,315134976,1004.89305,1004.8949342105263 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,620000,2004,17.415169660678643,fixed_full_OO_pool,2.673285136861313,585242907770880000,1269760000,317181184,1011.419075,1011.4196673976609 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,624000,2004,18.562874251497004,fixed_full_OO_pool,2.690505960019719,589018668466176000,1277952000,319227648,1017.94655,1017.9451242690059 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,628000,2004,19.311377245508982,fixed_full_OO_pool,2.707727693353469,592794429161472000,1286144000,321273856,1024.4692,1024.470350877193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,632000,2004,18.962075848303392,fixed_full_OO_pool,2.724948152810749,596570189856768000,1294336000,323320320,1030.9954,1030.9959941520467 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,636000,2004,17.21556886227545,fixed_full_OO_pool,2.742170008709654,600345950552064000,1302528000,325366528,1037.51875,1037.5211184210527 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,640000,2004,18.113772455089823,fixed_full_OO_pool,2.7593912607110624,604121711247360000,1310720000,327412736,1044.046025,1044.0456688596491 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,644000,2004,18.912175648702593,fixed_full_OO_pool,2.776612045848742,607897471942656000,1318912000,329459200,1050.569475,1050.5717141812866 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,648000,2004,19.311377245508982,fixed_full_OO_pool,2.79383248450338,611673232637952000,1327104000,331505408,1057.095525,1057.0964437134503 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,652000,2004,18.6626746506986,fixed_full_OO_pool,2.8110531062022264,615448993333248000,1335296000,333551872,1063.6214,1063.622134502924 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,656000,2004,19.660678642714572,fixed_full_OO_pool,2.8282736181178025,619224754028544000,1343488000,335598080,1070.148925,1070.146648391813 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,660000,2004,19.16167664670659,fixed_full_OO_pool,2.8454943578597156,623000514723840000,1351680000,337644544,1076.674075,1076.6724451754385 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,664000,2004,19.610778443113773,fixed_full_OO_pool,2.8627146328944297,626776275419136000,1359872000,339690752,1083.19835,1083.1974342105264 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,668000,2004,19.860279441117765,fixed_full_OO_pool,2.879935316245796,630552036114432000,1368064000,341737216,1089.72275,1089.723340643275 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,672000,2004,20.159680638722556,fixed_full_OO_pool,2.897155619594786,634327796809728000,1376256000,343783424,1096.2529,1096.247470760234 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,676000,2004,21.35728542914172,fixed_full_OO_pool,2.914375915158954,638103557505024000,1384448000,345829888,1102.7743,1102.7738157894737 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,680000,2004,20.65868263473054,fixed_full_OO_pool,2.93159613580443,641879318200320000,1392640000,347876096,1109.302275,1109.2982638888889 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,684000,2004,19.261477045908183,fixed_full_OO_pool,2.9488166445400568,645655078895616000,1400832000,349922560,1115.822275,1115.8248135964911 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,688000,2004,20.808383233532936,fixed_full_OO_pool,2.9660382080357524,649430839590912000,1409024000,351968768,1122.351,1122.3491520467837 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,692000,2004,21.55688622754491,fixed_full_OO_pool,2.983257827407991,653206600286208000,1417216000,354015232,1128.875075,1128.8751059941521 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,696000,2004,22.355289421157686,fixed_full_OO_pool,3.0004787673677007,656982360981504000,1425408000,356061440,1135.395625,1135.4006396198831 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,700000,2004,21.25748502994012,fixed_full_OO_pool,3.017698931639186,660758121676800000,1433600000,358107904,1141.9251,1141.9258040935672 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,704000,2004,21.506986027944112,fixed_full_OO_pool,3.0349201003834607,664533882372096000,1441792000,360154112,1148.44995,1148.4507090643274 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,708000,2004,22.75449101796407,fixed_full_OO_pool,3.0521402302125678,668309643067392000,1449984000,362200576,1154.97815,1154.9760599415204 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,712000,2004,23.10379241516966,fixed_full_OO_pool,3.0693620458359105,672085403762688000,1458176000,364246784,1161.502725,1161.501005116959 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,716000,2004,23.852295409181636,fixed_full_OO_pool,3.086582318847585,675861164457984000,1466368000,366292992,1168.026725,1168.0260343567252 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,720000,2004,21.157684630738522,fixed_full_OO_pool,3.103802233611544,679636925153280000,1474560000,368339456,1174.5495,1174.5521783625732 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,724000,2004,23.353293413173652,fixed_full_OO_pool,3.1210224979132826,683412685848576000,1482752000,370385664,1181.07815,1181.0765277777778 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,728000,2004,21.956087824351297,fixed_full_OO_pool,3.138242260625379,687188446543872000,1490944000,372432128,1187.599725,1187.6028472222222 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,732000,2004,22.85429141716567,fixed_full_OO_pool,3.1554624470416455,690964207239168000,1499136000,374478336,1194.12625,1194.1275073099416 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,736000,2004,24.900199600798402,fixed_full_OO_pool,3.172683142265305,694739967934464000,1507328000,376524800,1200.653825,1200.6529495614036 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,740000,2004,23.55289421157685,fixed_full_OO_pool,3.1899037362635134,698515728629760000,1515520000,378571008,1207.174725,1207.1784320175439 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,744000,2004,21.756487025948104,fixed_full_OO_pool,3.2071241056836315,702291489325056000,1523712000,380617472,1213.702075,1213.7039071637428 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,748000,2004,23.253493013972058,fixed_full_OO_pool,3.2243442804387046,706067250020352000,1531904000,382663680,1220.225675,1220.228994883041 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,752000,2004,23.952095808383234,fixed_full_OO_pool,3.2415641303039675,709843010715648000,1540096000,384710144,1226.75395,1226.7543347953217 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,756000,2004,25.349301397205586,fixed_full_OO_pool,3.258783885916281,713618771410944000,1548288000,386756352,1233.2791,1233.2791959064327 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,760000,2004,24.201596806387226,fixed_full_OO_pool,3.2760035217625814,717394532106240000,1556480000,388802816,1239.804525,1239.8049524853802 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,764000,2004,24.600798403193615,fixed_full_OO_pool,3.2932244371560713,721170292801536000,1564672000,390849024,1246.3319,1246.3294883040935 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,768000,2004,24.251497005988025,fixed_full_OO_pool,3.3104437583922928,724946053496832000,1572864000,392895488,1252.856725,1252.855332602339 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,772000,2004,24.70059880239521,fixed_full_OO_pool,3.3276644918208733,728721814192128000,1581056000,394941696,1259.380075,1259.3804568713451 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,776000,2004,26.94610778443114,fixed_full_OO_pool,3.3448837986081426,732497574887424000,1589248000,396988160,1265.9052,1265.9062573099416 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,780000,2004,25.199600798403193,fixed_full_OO_pool,3.36210473482704,736273335582720000,1597440000,399034368,1272.43,1272.4311695906433 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,784000,2004,26.746506986027946,fixed_full_OO_pool,3.3793242952124114,740049096278016000,1605632000,401080832,1278.957575,1278.9566118421053 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,788000,2004,28.343313373253494,fixed_full_OO_pool,3.3965448714233935,743824856973312000,1613824000,403127040,1285.480925,1285.481736111111 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,792000,2004,26.696606786427147,fixed_full_OO_pool,3.4137644158376172,747600617668608000,1622016000,405173248,1292.006575,1292.006524122807 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,796000,2004,26.89620758483034,fixed_full_OO_pool,3.430984494976906,751376378363904000,1630208000,407219712,1298.530425,1298.5325109649123 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,800000,2004,27.295409181636725,fixed_full_OO_pool,3.4482041037765643,755152139059200000,1638400000,409265920,1305.056825,1305.0571893274853 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,804000,2004,26.89620758483034,fixed_full_OO_pool,3.465423878207803,758927899754496000,1646592000,411312384,1311.584675,1311.582591374269 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,808000,2004,25.69860279441118,fixed_full_OO_pool,3.482643688402863,762703660449792000,1654784000,413358592,1318.1077,1318.1077631578946 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,812000,2004,27.744510978043913,fixed_full_OO_pool,3.4998637445364147,766479421145088000,1662976000,415405056,1324.6323,1324.6336403508772 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,816000,2004,27.295409181636725,fixed_full_OO_pool,3.5170840328704154,770255181840384000,1671168000,417451264,1331.1573,1331.1585233918129 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,820000,2004,26.546906187624753,fixed_full_OO_pool,3.5343037634953443,774030942535680000,1679360000,419497728,1337.68455,1337.6840131578947 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,824000,2004,28.69261477045908,fixed_full_OO_pool,3.5515229611253987,777806703230976000,1687552000,421543936,1344.2104,1344.2087719298245 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,828000,2004,29.740518962075846,fixed_full_OO_pool,3.5687422676291316,781582463926272000,1695744000,423590400,1350.736375,1350.7344480994152 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,832000,2004,28.74251497005988,fixed_full_OO_pool,3.5859616839575272,785358224621568000,1703936000,425636608,1357.26155,1357.2593055555556 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,836000,2004,28.542914171656687,fixed_full_OO_pool,3.603180714541425,789133985316864000,1712128000,427683072,1363.786375,1363.7851498538012 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,840000,2004,29.590818363273453,fixed_full_OO_pool,3.6204004471490365,792909746012160000,1720320000,429729280,1370.3079,1370.3105409356724 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,844000,2004,28.393213572854293,fixed_full_OO_pool,3.637620427114889,796685506707456000,1728512000,431775744,1376.836875,1376.835778508772 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,848000,2004,30.83832335329341,fixed_full_OO_pool,3.6548411118818653,800461267402752000,1736704000,433821952,1383.35955,1383.3610014619883 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,852000,2004,30.289421157684632,fixed_full_OO_pool,3.6720603130623286,804237028098048000,1744896000,435868416,1389.88515,1389.8867324561404 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,856000,2004,28.892215568862273,fixed_full_OO_pool,3.6892809133728344,808012788793344000,1753088000,437914624,1396.4091,1396.4117690058479 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,860000,2004,28.892215568862273,fixed_full_OO_pool,3.7065001499466597,811788549488640000,1761280000,439961088,1402.935675,1402.9373574561403 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,864000,2004,32.93413173652694,fixed_full_OO_pool,3.72372050728028,815564310183936000,1769472000,442007296,1409.461675,1409.4620942982456 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,868000,2004,32.23552894211577,fixed_full_OO_pool,3.740939893994687,819340070879232000,1777664000,444053760,1415.9872,1415.98783625731 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,872000,2004,30.63872255489022,fixed_full_OO_pool,3.7581606180510585,823115831574528000,1785856000,446099968,1422.51175,1422.5127850877193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,876000,2004,32.28542914171656,fixed_full_OO_pool,3.775380088881486,826891592269824000,1794048000,448146176,1429.037575,1429.03754751462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,880000,2004,34.4311377245509,fixed_full_OO_pool,3.7925998533806866,830667352965120000,1802240000,450192640,1435.563525,1435.5632273391814 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,884000,2004,33.13373253493014,fixed_full_OO_pool,3.8098192465377765,834443113660416000,1810432000,452238848,1442.0886,1442.0880994152046 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,888000,2004,33.23353293413174,fixed_full_OO_pool,3.827038842877373,838218874355712000,1818624000,454285312,1448.613375,1448.6139510233918 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,892000,2004,30.938123752495013,fixed_full_OO_pool,3.8442582603771656,841994635051008000,1826816000,456331520,1455.135925,1455.139192251462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,896000,2004,33.433133732534934,fixed_full_OO_pool,3.8614773746476407,845770395746304000,1835008000,458377984,1461.66955,1461.66375 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,900000,2004,34.980039920159676,fixed_full_OO_pool,3.878696726847233,849546156441600000,1843200000,460424192,1468.1904,1468.189239766082 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,904000,2004,32.33532934131736,fixed_full_OO_pool,3.8959161583882653,853321917136896000,1851392000,462470656,1474.7163,1474.7149269005847 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,908000,2004,31.387225548902197,fixed_full_OO_pool,3.913135978679897,857097677832192000,1859584000,464516864,1481.23855,1481.240211988304 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,912000,2004,32.13572854291417,fixed_full_OO_pool,3.9303557482837803,860873438527488000,1867776000,466563328,1487.766175,1487.7656469298245 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,916000,2004,34.03193612774451,fixed_full_OO_pool,3.9475757086815104,864649199222784000,1875968000,468609536,1494.294025,1494.2901133040937 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,920000,2004,34.4810379241517,fixed_full_OO_pool,3.9647950187377217,868424959918080000,1884160000,470656000,1500.817625,1500.8161366959064 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,924000,2004,30.239520958083833,fixed_full_OO_pool,3.982016043945526,872200720613376000,1892352000,472702208,1507.339175,1507.341524122807 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,928000,2004,33.582834331337324,fixed_full_OO_pool,3.999235919119997,875976481308672000,1900544000,474748672,1513.8643,1513.8673245614036 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,932000,2004,35.678642714570856,fixed_full_OO_pool,4.016457042411591,879752242003968000,1908736000,476794880,1520.39315,1520.3916447368422 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,936000,2004,33.63273453093812,fixed_full_OO_pool,4.033677327968181,883528002699264000,1916928000,478841344,1526.918675,1526.9173866959065 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,940000,2004,35.17964071856288,fixed_full_OO_pool,4.050899254294733,887303763394560000,1925120000,480887552,1533.445425,1533.4420138888888 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,944000,2004,33.28343313373254,fixed_full_OO_pool,4.068119613612071,891079524089856000,1933312000,482934016,1539.96965,1539.9679459064328 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,948000,2004,34.930139720558884,fixed_full_OO_pool,4.085341220617087,894855284785152000,1941504000,484980224,1546.4949,1546.4927923976609 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,952000,2004,35.778443113772454,fixed_full_OO_pool,4.102561776889488,898631045480448000,1949696000,487026432,1553.0175,1553.0180263157895 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,956000,2004,34.2814371257485,fixed_full_OO_pool,4.119781595377458,902406806175744000,1957888000,489072896,1559.5433,1559.5437280701753 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,960000,2004,33.98203592814371,fixed_full_OO_pool,4.13700167602342,906182566871040000,1966080000,491119104,1566.067025,1566.06879751462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,964000,2004,33.33333333333333,fixed_full_OO_pool,4.154221278722916,909958327566336000,1974272000,493165568,1572.59525,1572.594144736842 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,968000,2004,35.27944111776447,fixed_full_OO_pool,4.17144081423887,913734088261632000,1982464000,495211776,1579.121725,1579.1188121345028 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,972000,2004,35.27944111776447,fixed_full_OO_pool,4.18866056679748,917509848956928000,1990656000,497258240,1585.641325,1585.6454203216374 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,976000,2004,36.72654690618762,fixed_full_OO_pool,4.205879774768319,921285609652224000,1998848000,499304448,1592.16975,1592.169802631579 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,980000,2004,38.07385229540918,fixed_full_OO_pool,4.223098988999716,925061370347520000,2007040000,501350912,1598.69315,1598.695855263158 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,984000,2004,39.87025948103792,fixed_full_OO_pool,4.2403189651657724,928837131042816000,2015232000,503397120,1605.22065,1605.2203728070176 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,988000,2004,34.5309381237525,fixed_full_OO_pool,4.257538382850794,932612891738112000,2023424000,505443584,1611.74645,1611.7460745614035 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,992000,2004,38.47305389221557,fixed_full_OO_pool,4.275078419941581,936388652433408000,2031616000,507489792,1618.267875,1618.2714802631579 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,996000,2004,36.377245508982035,fixed_full_OO_pool,4.2922982428243595,940164413128704000,2039808000,509536256,1624.797525,1624.7966191520468 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1000000,2004,34.381237524950095,fixed_full_OO_pool,4.309519090551055,943940173824000000,2048000000,511582464,1631.3245,1631.3212134502924 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1004000,2004,33.582834331337324,fixed_full_OO_pool,4.3267385373688825,947715934519296000,2056192000,513628928,1637.848,1637.8472514619882 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1008000,2004,34.980039920159676,fixed_full_OO_pool,4.3439599798402435,951491695214592000,2064384000,515675136,1644.377825,1644.3714290935673 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1012000,2004,35.97804391217565,fixed_full_OO_pool,4.361179726927852,955267455909888000,2072576000,517721600,1650.897675,1650.8980007309942 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1016000,2004,38.72255489021956,fixed_full_OO_pool,4.378400800070829,959043216605184000,2080768000,519767808,1657.4205,1657.423201754386 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1020000,2004,35.22954091816367,fixed_full_OO_pool,4.395773704590069,962818977300480000,2088960000,521814272,1663.95055,1663.9482821637428 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1024000,2004,38.07385229540918,fixed_full_OO_pool,4.4134897653986185,966594737995776000,2097152000,523860480,1670.47305,1670.4735307017545 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1028000,2004,36.87624750499002,fixed_full_OO_pool,4.430709618534893,970370498691072000,2105344000,525906944,1676.999125,1676.999192251462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1032000,2004,37.924151696606785,fixed_full_OO_pool,4.447930430235962,974146259386368000,2113536000,527953152,1683.52685,1683.5236769005849 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1036000,2004,37.87425149700599,fixed_full_OO_pool,4.465150500216211,977922020081664000,2121728000,529999360,1690.048475,1690.0490533625732 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1040000,2004,41.51696606786427,fixed_full_OO_pool,4.482370312717847,981697780776960000,2129920000,532045824,1696.57575,1696.5745394736841 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1044000,2004,39.471057884231534,fixed_full_OO_pool,4.499589807418071,985473541472256000,2138112000,534092032,1703.1006,1703.0994444444445 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1048000,2004,39.920159680638726,fixed_full_OO_pool,4.516809859712505,989249302167552000,2146304000,536138496,1709.626925,1709.6250694444445 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1052000,2004,37.4750499001996,fixed_full_OO_pool,4.534029724737629,993025062862848000,2154496000,538184704,1716.15085,1716.150109649123 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1056000,2004,35.778443113772454,fixed_full_OO_pool,4.5512494363304645,996800823558144000,2162688000,540231168,1722.676175,1722.6758808479533 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1060000,2004,40.21956087824351,fixed_full_OO_pool,4.568469313019887,1000576584253440000,2170880000,542277376,1729.20065,1729.200840643275 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1064000,2004,39.321357285429144,fixed_full_OO_pool,4.585688643627282,1004352344948736000,2179072000,544323840,1735.7277,1735.7263596491227 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1068000,2004,41.01796407185629,fixed_full_OO_pool,4.602908424273547,1008128105644032000,2187264000,546370048,1742.252225,1742.251312134503 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1072000,2004,43.96207584830339,fixed_full_OO_pool,4.621416494873249,1011903866339328000,2195456000,548416512,1748.7758,1748.7773391812866 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1076000,2004,38.772455089820355,fixed_full_OO_pool,4.643245224881296,1015679627034624000,2203648000,550462720,1755.302825,1755.3019261695906 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1080000,2004,39.52095808383233,fixed_full_OO_pool,4.666333317616955,1019455387729920000,2211840000,552509184,1761.827875,1761.8277375730995 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1084000,2004,40.31936127744511,fixed_full_OO_pool,4.688327089216974,1023231148425216000,2220032000,554555392,1768.352325,1768.3527010233918 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1088000,2004,41.06786427145709,fixed_full_OO_pool,4.707883168835607,1027006909120512000,2228224000,556601856,1774.8786,1774.8783333333333 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1092000,2004,41.06786427145709,fixed_full_OO_pool,4.726337755675324,1030782669815808000,2236416000,558648064,1781.401475,1781.4035270467837 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1096000,2004,40.5688622754491,fixed_full_OO_pool,4.74355721330891,1034558430511104000,2244608000,560694528,1787.9267,1787.929312865497 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1100000,2004,38.42315369261477,fixed_full_OO_pool,4.760778518006619,1038334191206400000,2252800000,562740736,1794.454175,1794.4538340643276 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1104000,2004,40.818363273453095,fixed_full_OO_pool,4.777998232730768,1042109951901696000,2260992000,564787200,1800.979075,1800.9796673976607 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1108000,2004,42.16566866267465,fixed_full_OO_pool,4.795218900845697,1045885712596992000,2269184000,566833408,1807.505475,1807.504345760234 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1112000,2004,38.522954091816366,fixed_full_OO_pool,4.812438676071664,1049661473292288000,2277376000,568879616,1814.0292,1814.0294152046783 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1116000,2004,42.41516966067864,fixed_full_OO_pool,4.8296577799527185,1053437233987584000,2285568000,570926080,1820.55255,1820.555475146199 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1120000,2004,41.467065868263475,fixed_full_OO_pool,4.846876764787982,1057212994682880000,2293760000,572972288,1827.0793,1827.0801023391814 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1124000,2004,44.11177644710579,fixed_full_OO_pool,4.864095933429069,1060988755378176000,2301952000,575018752,1833.60705,1833.605519005848 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1128000,2004,43.6127744510978,fixed_full_OO_pool,4.8813146835617305,1064764516073472000,2310144000,577064960,1840.1335,1840.1301900584795 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1132000,2004,42.86427145708583,fixed_full_OO_pool,4.898533258347047,1068540276768768000,2318336000,579111424,1846.655175,1846.656494883041 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1136000,2004,42.01596806387226,fixed_full_OO_pool,4.915752666438412,1072316037464064000,2326528000,581157632,1853.1819,1853.1811257309942 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1140000,2004,40.618762475049905,fixed_full_OO_pool,4.932972204065364,1076091798159360000,2334720000,583204096,1859.7061,1859.7070614035088 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1144000,2004,40.768463073852296,fixed_full_OO_pool,4.950192353384983,1079867558854656000,2342912000,585250304,1866.233425,1866.2316045321638 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1148000,2004,44.01197604790419,fixed_full_OO_pool,4.967411702640562,1083643319549952000,2351104000,587296768,1872.75915,1872.757317251462 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1152000,2004,44.560878243512974,fixed_full_OO_pool,4.984630672854061,1087419080245248000,2359296000,589342976,1879.282975,1879.2823720760234 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1156000,2004,42.71457085828344,fixed_full_OO_pool,5.001849879852186,1091194840940544000,2367488000,591389440,1885.806675,1885.8083808479532 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1160000,2004,42.46506986027944,fixed_full_OO_pool,5.019070385176067,1094970601635840000,2375680000,593435648,1892.3363,1892.3325877192983 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1164000,2004,41.66666666666667,fixed_full_OO_pool,5.036289890673426,1098746362331136000,2383872000,595482112,1898.854725,1898.8593676900584 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1168000,2004,44.86027944111776,fixed_full_OO_pool,5.053511238277165,1102522123026432000,2392064000,597528320,1905.38405,1905.3836184210527 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1172000,2004,42.76447105788423,fixed_full_OO_pool,5.07073112973633,1106297883721728000,2400256000,599574784,1911.9119,1911.9090204678362 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1176000,2004,42.315369261477045,fixed_full_OO_pool,5.087951600346714,1110073644417024000,2408448000,601620992,1918.435525,1918.4341045321637 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1180000,2004,41.76646706586826,fixed_full_OO_pool,5.105171075117671,1113849405112320000,2416640000,603667456,1924.95995,1924.9600073099416 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1184000,2004,41.06786427145709,fixed_full_OO_pool,5.122391794666441,1117625165807616000,2424832000,605713664,1931.481875,1931.4853399122808 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1188000,2004,44.71057884231537,fixed_full_OO_pool,5.139611057890579,1121400926502912000,2433024000,607759872,1938.009425,1938.009850146199 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1192000,2004,43.812375249500995,fixed_full_OO_pool,5.156830600206223,1125176687198208000,2441216000,609806336,1944.534275,1944.5356907894736 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1196000,2004,42.66467065868264,fixed_full_OO_pool,5.174049767300279,1128952447893504000,2449408000,611852544,1951.0621,1951.0601608187135 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1200000,2004,43.862275449101794,fixed_full_OO_pool,5.191268421881315,1132728208588800000,2457600000,613899008,1957.584825,1957.586312134503 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1204000,2004,45.45908183632735,fixed_full_OO_pool,5.208487384542823,1136503969284096000,2465792000,615945216,1964.108875,1964.1113340643276 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1208000,2004,43.31337325349301,fixed_full_OO_pool,5.225706124140157,1140279729979392000,2473984000,617991680,1970.63505,1970.636980994152 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1212000,2004,45.70858283433134,fixed_full_OO_pool,5.2429248073541865,1144055490674688000,2482176000,620037888,1977.162125,1977.1615606725147 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1216000,2004,44.461077844311376,fixed_full_OO_pool,5.260143668014142,1147831251369984000,2490368000,622084352,1983.6894,1983.6870467836256 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1220000,2004,43.712574850299404,fixed_full_OO_pool,5.277362590359731,1151607012065280000,2498560000,624130560,1990.215475,1990.2117726608187 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1224000,2004,45.05988023952096,fixed_full_OO_pool,5.294581973949033,1155382772760576000,2506752000,626177024,1996.7373,1996.7380555555555 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1228000,2004,44.411177644710584,fixed_full_OO_pool,5.311800824964626,1159158533455872000,2514944000,628223232,2003.262225,2003.2629495614035 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1232000,2004,45.259481037924154,fixed_full_OO_pool,5.329020147732355,1162934294151168000,2523136000,630269696,2009.79055,2009.7882821637427 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1236000,2004,46.656686626746506,fixed_full_OO_pool,5.346239443835285,1166710054846464000,2531328000,632315904,2016.315575,2016.3131615497075 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1240000,2004,42.365269461077844,fixed_full_OO_pool,5.363458533156663,1170485815541760000,2539520000,634362368,2022.841425,2022.838855994152 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1244000,2004,48.253493013972054,fixed_full_OO_pool,5.380678735841066,1174261576237056000,2547712000,636408576,2029.3629,2029.3642543859648 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1248000,2004,47.85429141716567,fixed_full_OO_pool,5.397898000036884,1178037336932352000,2555904000,638455040,2035.889075,2035.8899013157895 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1252000,2004,44.461077844311376,fixed_full_OO_pool,5.415118817628051,1181813097627648000,2564096000,640501248,2042.414125,2042.4147770467837 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1256000,2004,45.75848303393214,fixed_full_OO_pool,5.4323384149962415,1185588858322944000,2572288000,642547712,2048.936625,2048.94096125731 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1260000,2004,46.756487025948104,fixed_full_OO_pool,5.449558720148893,1189364619018240000,2580480000,644593920,2055.4625,2055.465716374269 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1264000,2004,46.706586826347305,fixed_full_OO_pool,5.466778026909257,1193140379713536000,2588672000,646640384,2061.990325,2061.991122076023 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1268000,2004,45.00998003992016,fixed_full_OO_pool,5.483998029039552,1196916140408832000,2596864000,648686592,2068.517525,2068.515683479532 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1272000,2004,43.213572854291414,fixed_full_OO_pool,5.501217668567681,1200691901104128000,2605056000,650732800,2075.040975,2075.040793128655 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1276000,2004,45.858283433133735,fixed_full_OO_pool,5.518437060103234,1204467661799424000,2613248000,652779264,2081.566575,2081.566524122807 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1280000,2004,45.259481037924154,fixed_full_OO_pool,5.535656348707982,1208243422494720000,2621440000,654825472,2088.094025,2088.0910489766084 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1284000,2004,48.45309381237525,fixed_full_OO_pool,5.552875513239867,1212019183190016000,2629632000,656871936,2094.62025,2094.6166885964913 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1288000,2004,48.20359281437126,fixed_full_OO_pool,5.5700938863265845,1215794943885312000,2637824000,658918144,2101.1387,2101.142529239766 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1292000,2004,47.75449101796407,fixed_full_OO_pool,5.5873130227408065,1219570704580608000,2646016000,660964608,2107.668425,2107.6676571637427 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1296000,2004,44.91017964071856,fixed_full_OO_pool,5.60453229727327,1223346465275904000,2654208000,663010816,2114.193775,2114.192489035088 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1300000,2004,45.75848303393214,fixed_full_OO_pool,5.621752267535776,1227122225971200000,2662400000,665057280,2120.717475,2120.7184978070177 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1304000,2004,44.21157684630739,fixed_full_OO_pool,5.638971709689747,1230897986666496000,2670592000,667103488,2127.249425,2127.2423647660817 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1308000,2004,43.36327345309382,fixed_full_OO_pool,5.656191110572674,1234673747361792000,2678784000,669149952,2133.767925,2133.76913377193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1312000,2004,46.8063872255489,fixed_full_OO_pool,5.673410444974692,1238449508057088000,2686976000,671196160,2140.293825,2140.293885233918 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1316000,2004,47.20558882235529,fixed_full_OO_pool,5.690629483948772,1242225268752384000,2695168000,673242624,2146.8188,2146.8197076023393 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1320000,2004,46.10778443113773,fixed_full_OO_pool,5.707849617664599,1246001029447680000,2703360000,675288832,2153.35105,2153.3435307017544 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1324000,2004,46.55688622754491,fixed_full_OO_pool,5.725068440290375,1249776790142976000,2711552000,677335296,2159.869725,2159.870274122807 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1328000,2004,49.25149700598803,fixed_full_OO_pool,5.742288359094204,1253552550838272000,2719744000,679381504,2166.39615,2166.3949488304092 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1332000,2004,50.54890219560878,fixed_full_OO_pool,5.759507639206325,1257328311533568000,2727936000,681427968,2172.920625,2172.920844298246 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1336000,2004,49.25149700598803,fixed_full_OO_pool,5.776727567678318,1261104072228864000,2736128000,683474176,2179.44505,2179.4458114035087 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1340000,2004,47.80439121756487,fixed_full_OO_pool,5.793946576398901,1264879832924160000,2744320000,685520640,2185.970725,2185.9715314327486 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1344000,2004,48.10379241516966,fixed_full_OO_pool,5.8111677234733685,1268655593619456000,2752512000,687566848,2192.4966,2192.4962865497077 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1348000,2004,49.25149700598803,fixed_full_OO_pool,5.828387268253913,1272431354314752000,2760704000,689613056,2199.02225,2199.0210745614036 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1352000,2004,47.90419161676647,fixed_full_OO_pool,5.8456067296904,1276207115010048000,2768896000,691659520,2205.549225,2205.5466045321637 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1356000,2004,50.34930139720559,fixed_full_OO_pool,5.862825805749744,1279982875705344000,2777088000,693705728,2212.071925,2212.0718238304094 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1360000,2004,48.70259481037924,fixed_full_OO_pool,5.880044629223024,1283758636400640000,2785280000,695752192,2218.5972,2218.5976023391813 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1364000,2004,47.85429141716567,fixed_full_OO_pool,5.897263434800423,1287534397095936000,2793472000,697798400,2225.11965,2225.1228581871346 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1368000,2004,47.1057884231537,fixed_full_OO_pool,5.9144824192724705,1291310157791232000,2801664000,699844864,2231.646725,2231.6483735380116 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1372000,2004,48.05389221556886,fixed_full_OO_pool,5.931701220941419,1295085918486528000,2809856000,701891072,2238.171425,2238.1733004385965 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1376000,2004,47.30538922155689,fixed_full_OO_pool,5.948920335815185,1298861679181824000,2818048000,703937536,2244.698475,2244.6988194444443 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1380000,2004,50.74850299401198,fixed_full_OO_pool,5.966138963723141,1302637439877120000,2826240000,705983744,2251.225825,2251.2233589181287 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1384000,2004,48.55289421157685,fixed_full_OO_pool,5.983357834306856,1306413200572416000,2834432000,708030208,2257.75135,2257.749100877193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1388000,2004,49.20159680638723,fixed_full_OO_pool,6.000577181977117,1310188961267712000,2842624000,710076416,2264.274525,2264.274250730994 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1392000,2004,49.50099800399202,fixed_full_OO_pool,6.017795827201464,1313964721963008000,2850816000,712122880,2270.802725,2270.799601608187 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1396000,2004,47.30538922155689,fixed_full_OO_pool,6.035015488784346,1317740482658304000,2859008000,714169088,2277.325425,2277.3248209064327 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1400000,2004,49.45109780439122,fixed_full_OO_pool,6.052234086818579,1321516243353600000,2867200000,716215552,2283.849875,2283.8507200292397 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1404000,2004,50.199600798403196,fixed_full_OO_pool,6.069454252123832,1325292004048896000,2875392000,718261760,2290.376375,2290.37538377193 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1408000,2004,51.29740518962076,fixed_full_OO_pool,6.086672958880663,1329067764744192000,2883584000,720308224,2296.901125,2296.9012390350877 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1412000,2004,48.253493013972054,fixed_full_OO_pool,6.103892783718184,1332843525439488000,2891776000,722354432,2303.423775,2303.4264656432747 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1416000,2004,50.249500998003995,fixed_full_OO_pool,6.121111545749009,1336619286134784000,2899968000,724400896,2309.950975,2309.951962719298 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1420000,2004,51.09780439121756,fixed_full_OO_pool,6.13833154873819,1340395046830080000,2908160000,726447104,2316.4738,2316.47716374269 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1424000,2004,47.95409181636727,fixed_full_OO_pool,6.155550587043787,1344170807525376000,2916352000,728493312,2323.001475,2323.0016557017543 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1428000,2004,50.34930139720559,fixed_full_OO_pool,6.172769512394443,1347946568220672000,2924544000,730539776,2329.526925,2329.527408625731 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1432000,2004,49.20159680638723,fixed_full_OO_pool,6.189987538541771,1351722328915968000,2932736000,732585984,2336.05215,2336.0522587719297 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1436000,2004,49.35129740518962,fixed_full_OO_pool,6.207205745014879,1355498089611264000,2940928000,734632448,2342.57685,2342.578121345029 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1440000,2004,50.04990019960079,fixed_full_OO_pool,6.224424079313047,1359273850306560000,2949120000,736678656,2349.1014,2349.1030701754385 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1444000,2004,49.40119760479042,fixed_full_OO_pool,6.241642600695292,1363049611001856000,2957312000,738725120,2355.6274,2355.6287426900585 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1448000,2004,50.34930139720559,fixed_full_OO_pool,6.258861476671364,1366825371697152000,2965504000,740771328,2362.15255,2362.1536038011695 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1452000,2004,51.49700598802395,fixed_full_OO_pool,6.276080619107104,1370601132392448000,2973696000,742817792,2368.679725,2368.679104532164 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1456000,2004,49.25149700598803,fixed_full_OO_pool,6.293299500240634,1374376893087744000,2981888000,744864000,2375.204275,2375.204053362573 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1460000,2004,51.69660678642715,fixed_full_OO_pool,6.310518467918866,1378152653783040000,2990080000,746910464,2381.726575,2381.7302668128655 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1464000,2004,49.00199600798403,fixed_full_OO_pool,6.327737438827753,1381928414478336000,2998272000,748956672,2388.25755,2388.2542763157894 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1468000,2004,51.74650698602794,fixed_full_OO_pool,6.344956274451688,1385704175173632000,3006464000,751003136,2394.7818,2394.7802046783627 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1472000,2004,50.74850299401198,fixed_full_OO_pool,6.3621753706524355,1389479935868928000,3014656000,753049344,2401.3038,2401.3055263157894 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1476000,2004,50.74850299401198,fixed_full_OO_pool,6.379394927632271,1393255696564224000,3022848000,755095808,2407.83105,2407.8310160818714 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1480000,2004,48.253493013972054,fixed_full_OO_pool,6.396615533302021,1397031457259520000,3031040000,757142016,2414.353925,2414.356209795322 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1484000,2004,50.898203592814376,fixed_full_OO_pool,6.413835246173872,1400807217954816000,3039232000,759188480,2420.880325,2420.8818238304093 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1488000,2004,50.94810379241517,fixed_full_OO_pool,6.431056197671634,1404582978650112000,3047424000,761234688,2427.40705,2427.4064546783625 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1492000,2004,51.49700598802395,fixed_full_OO_pool,6.448275398871758,1408358739345408000,3055616000,763281152,2433.932325,2433.9322331871344 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1496000,2004,52.69461077844312,fixed_full_OO_pool,6.465495814774186,1412134500040704000,3063808000,765327360,2440.456625,2440.4572185672514 +synthetic,loop4x2-phi7.2-wd0.1,loop4x2,791101,0.0001,0.1,7.2,1500000,2004,53.293413173652695,fixed_full_OO_pool,6.48271472582904,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,256,2004,0.0,fixed_full_OO_pool,0.0011250077726112472,241648684498944,524288,131072,0.412975,0.41868786549707604 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,512,2004,0.0,fixed_full_OO_pool,0.0022494181007560758,483297368997888,1048576,262144,0.8341,0.8361842105263158 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1000,2004,0.049900199600798396,fixed_full_OO_pool,0.004394162251717514,943940173824000,2048000,511744,1.6305,1.63203216374269 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,2000,2004,0.0,fixed_full_OO_pool,0.008783807035328613,1887880347648000,4096000,1023232,3.263775,3.2627229532163744 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,3000,2004,0.049900199600798396,fixed_full_OO_pool,0.013177746716472838,2831820521472000,6144000,1534976,4.89595,4.894510233918129 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,4000,2004,0.049900199600798396,fixed_full_OO_pool,0.017573208501562475,3775760695296000,8192000,2046464,6.52905,6.525226608187134 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,5000,2004,0.29940119760479045,fixed_full_OO_pool,0.021953480200221143,4719700869120000,10240000,2557952,8.1597,8.156301169590643 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,6000,2004,0.19960079840319359,fixed_full_OO_pool,0.026331591084599495,5663641042944000,12288000,3069696,9.788625,9.788563596491228 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,7000,2004,0.19960079840319359,fixed_full_OO_pool,0.03070946249903904,6607581216768000,14336000,3581184,11.4216,11.419298245614035 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,8000,2004,0.14970059880239522,fixed_full_OO_pool,0.035087812292493054,7551521390592000,16384000,4092672,13.0503,13.050657894736842 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,9000,2004,0.14970059880239522,fixed_full_OO_pool,0.039482504171836706,8495461564416000,18432000,4604416,14.6867,14.681827485380117 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,10000,2004,0.249500998003992,fixed_full_OO_pool,0.043877506598623266,9439401738240000,20480000,5115904,16.310875,16.313848684210527 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,11000,2004,0.0,fixed_full_OO_pool,0.04827231313515869,10383341912064000,22528000,5627648,17.9435,17.945570175438597 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,12000,2004,0.09980039920159679,fixed_full_OO_pool,0.05266853035117189,11327282085888000,24576000,6139136,19.57665,19.57627923976608 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,13000,2004,0.049900199600798396,fixed_full_OO_pool,0.05706344306779405,12271222259712000,26624000,6650624,21.20495,21.20769736842105 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,14000,2004,0.34930139720558884,fixed_full_OO_pool,0.06145842511103385,13215162433536000,28672000,7162368,22.8415,22.838845029239767 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,15000,2004,0.34930139720558884,fixed_full_OO_pool,0.06585482807416054,14159102607360000,30720000,7673856,24.4697,24.470277777777778 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,16000,2004,0.14970059880239522,fixed_full_OO_pool,0.07024989444658988,15103042781184000,32768000,8185344,26.100225,26.101370614035087 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,17000,2004,0.19960079840319359,fixed_full_OO_pool,0.07462978969742026,16046982955008000,34816000,8697088,27.7315,27.73328947368421 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,18000,2004,0.14970059880239522,fixed_full_OO_pool,0.07900915587320924,16990923128832000,36864000,9208576,29.365125,29.36392909356725 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,19000,2004,0.09980039920159679,fixed_full_OO_pool,0.08338819715090924,17934863302656000,38912000,9720320,30.995775,30.99593932748538 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,20000,2004,0.14970059880239522,fixed_full_OO_pool,0.08776853605070048,18878803476480000,40960000,10231808,32.62985,32.626513157894735 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,21000,2004,0.249500998003992,fixed_full_OO_pool,0.09214746310789552,19822743650304000,43008000,10743296,34.2587,34.25785087719298 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,22000,2004,0.19960079840319359,fixed_full_OO_pool,0.09652641271344489,20766683824128000,45056000,11255040,35.88965,35.88981725146199 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,23000,2004,0.34930139720558884,fixed_full_OO_pool,0.10090622393310898,21710623997952000,47104000,11766528,37.52075,37.52082602339181 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,24000,2004,0.4491017964071856,fixed_full_OO_pool,0.1052849160362449,22654564171776000,49152000,12278016,39.1531,39.151652046783624 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,25000,2004,0.4491017964071856,fixed_full_OO_pool,0.10966306752835711,23598504345600000,51200000,12789760,40.78145,40.783998538011694 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,26000,2004,0.34930139720558884,fixed_full_OO_pool,0.11404221695330408,24542444519424000,53248000,13301248,42.413275,42.41490131578947 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,27000,2004,0.29940119760479045,fixed_full_OO_pool,0.11842073780381017,25486384693248000,55296000,13812736,44.0468,44.04555555555555 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,28000,2004,0.14970059880239522,fixed_full_OO_pool,0.12279974607543813,26430324867072000,57344000,14324480,45.67505,45.67791666666667 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,29000,2004,0.14970059880239522,fixed_full_OO_pool,0.12717892526545457,27374265040896000,59392000,14835968,47.3092,47.308479532163744 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,30000,2004,0.34930139720558884,fixed_full_OO_pool,0.13155881088951396,28318205214720000,61440000,15347712,48.939325,48.94056652046783 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,31000,2004,0.09980039920159679,fixed_full_OO_pool,0.13593816242387724,29262145388544000,63488000,15859200,50.572825,50.571224415204675 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,32000,2004,0.29940119760479045,fixed_full_OO_pool,0.140316791890396,30206085562368000,65536000,16370688,52.20115,52.20263888888889 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,33000,2004,0.29940119760479045,fixed_full_OO_pool,0.14469559718337324,31150025736192000,67584000,16882432,53.832525,53.83454312865497 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,34000,2004,0.14970059880239522,fixed_full_OO_pool,0.14907519999995,32093965910016000,69632000,17393920,55.46365,55.46554824561404 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,35000,2004,0.249500998003992,fixed_full_OO_pool,0.1534544153470132,33037906083840000,71680000,17905408,57.09505,57.096513157894734 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,36000,2004,0.249500998003992,fixed_full_OO_pool,0.15783298528960182,33981846257664000,73728000,18417152,58.727825,58.72821271929825 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,37000,2004,0.34930139720558884,fixed_full_OO_pool,0.16221153393077353,34925786431488000,75776000,18928640,60.355625,60.35970394736842 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,38000,2004,0.39920159680638717,fixed_full_OO_pool,0.16659073020228082,35869726605312000,77824000,19440384,61.99095,61.99103070175438 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,39000,2004,0.499001996007984,fixed_full_OO_pool,0.17097080634182527,36813666779136000,79872000,19951872,63.62315,63.62187865497076 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,40000,2004,0.4491017964071856,fixed_full_OO_pool,0.1753491838917964,37757606952960000,81920000,20463360,65.2529,65.25308479532164 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,41000,2004,0.29940119760479045,fixed_full_OO_pool,0.17972790683412718,38701547126784000,83968000,20975104,66.886125,66.88471856725147 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,42000,2004,0.39920159680638717,fixed_full_OO_pool,0.18410802423643569,39645487300608000,86016000,21486592,68.5145,68.51612573099415 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,43000,2004,0.5489021956087825,fixed_full_OO_pool,0.18848797041094967,40589427474432000,88064000,21998080,70.148525,70.14670687134503 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,44000,2004,0.34930139720558884,fixed_full_OO_pool,0.19286688747712308,41533367648256000,90112000,22509824,71.78185,71.77832602339181 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,45000,2004,0.499001996007984,fixed_full_OO_pool,0.1972465410766502,42477307822080000,92160000,23021312,73.41665,73.40879385964912 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,46000,2004,0.6487025948103792,fixed_full_OO_pool,0.20162596356537607,43421247995904000,94208000,23532800,75.041875,75.04066154970761 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,47000,2004,0.39920159680638717,fixed_full_OO_pool,0.20600471411210794,44365188169728000,96256000,24044544,76.67005,76.673033625731 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,48000,2004,0.8483033932135728,fixed_full_OO_pool,0.2103835816650341,45309128343552000,98304000,24556032,78.304225,78.30359283625731 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,49000,2004,0.7984031936127743,fixed_full_OO_pool,0.21476309687313105,46253068517376000,100352000,25067776,79.935,79.93558479532163 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,50000,2004,0.7984031936127743,fixed_full_OO_pool,0.21914276977587077,47197008691200000,102400000,25579264,81.564025,81.56689692982457 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,51000,2004,0.8483033932135728,fixed_full_OO_pool,0.2235215193271223,48140948865024000,104448000,26090752,83.19275,83.19825292397661 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,52000,2004,0.5489021956087825,fixed_full_OO_pool,0.2279010867834505,49084889038848000,106496000,26602496,84.829475,84.829375 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,53000,2004,0.5988023952095809,fixed_full_OO_pool,0.23228070525038574,50028829212672000,108544000,27113984,86.46075,86.4603581871345 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,54000,2004,0.5489021956087825,fixed_full_OO_pool,0.23665915742723478,50972769386496000,110592000,27625472,88.0915,88.09141812865496 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,55000,2004,0.499001996007984,fixed_full_OO_pool,0.24103774806174139,51916709560320000,112640000,28137216,89.720875,89.72361476608187 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,56000,2004,0.7984031936127743,fixed_full_OO_pool,0.24541632672668331,52860649734144000,114688000,28648704,91.355375,91.3541264619883 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,57000,2004,0.6487025948103792,fixed_full_OO_pool,0.24979521043391692,53804589907968000,116736000,29160448,92.98645,92.98607456140351 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,58000,2004,0.499001996007984,fixed_full_OO_pool,0.25417478213293687,54748530081792000,118784000,29671936,94.616975,94.61716739766082 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,59000,2004,0.6487025948103792,fixed_full_OO_pool,0.25855349737116035,55692470255616000,120832000,30183424,96.249875,96.2479130116959 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,60000,2004,0.998003992015968,fixed_full_OO_pool,0.2629318402697229,56636410429440000,122880000,30695168,97.879975,97.88000365497076 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,61000,2004,1.0479041916167664,fixed_full_OO_pool,0.26731168136311073,57580350603264000,124928000,31206656,99.5082,99.51143274853801 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,62000,2004,0.5988023952095809,fixed_full_OO_pool,0.2716901757216288,58524290777088000,126976000,31718144,101.140075,101.14232821637427 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,63000,2004,0.4491017964071856,fixed_full_OO_pool,0.27606884683171906,59468230950912000,129024000,32229888,102.777075,102.7734100877193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,64000,2004,0.4491017964071856,fixed_full_OO_pool,0.2804479024466127,60412171124736000,131072000,32741376,104.4066,104.40464912280702 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,68000,2004,0.8483033932135728,fixed_full_OO_pool,0.29796168240822024,64187931820032000,139264000,34787840,110.929625,110.93075657894737 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,72000,2004,1.0479041916167664,fixed_full_OO_pool,0.31547627841018966,67963692515328000,147456000,36834048,117.453525,117.4558004385965 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,76000,2004,1.2974051896207583,fixed_full_OO_pool,0.3329903405656417,71739453210624000,155648000,38880512,123.9815,123.98118421052632 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,80000,2004,1.5968063872255487,fixed_full_OO_pool,0.3505068423681789,75515213905920000,163840000,40926720,130.5097,130.50559941520467 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,84000,2004,2.245508982035928,fixed_full_OO_pool,0.3680200705915276,79290974601216000,172032000,42972928,137.031775,137.0309100877193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,88000,2004,1.8962075848303395,fixed_full_OO_pool,0.3855319187365886,83066735296512000,180224000,45019392,143.557075,143.55668494152047 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,92000,2004,2.7944111776447107,fixed_full_OO_pool,0.4030453635317584,86842495991808000,188416000,47065600,150.0823,150.0815350877193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,96000,2004,2.3952095808383236,fixed_full_OO_pool,0.42055723257880245,90618256687104000,196608000,49112064,156.60565,156.60759502923977 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,100000,2004,2.694610778443114,fixed_full_OO_pool,0.43806959646133087,94394017382400000,204800000,51158272,163.130525,163.13249634502924 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,104000,2004,4.39121756487026,fixed_full_OO_pool,0.45558234222336774,98169778077696000,212992000,53204736,169.654125,169.6585197368421 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,108000,2004,3.343313373253493,fixed_full_OO_pool,0.4730962212352703,101945538772992000,221184000,55250944,176.18455,176.1826096491228 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,112000,2004,3.293413173652695,fixed_full_OO_pool,0.4906093685256524,105721299468288000,229376000,57297408,182.709075,182.70849780701755 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,116000,2004,3.5429141716566868,fixed_full_OO_pool,0.508121773134917,109497060163584000,237568000,59343616,189.233275,189.23349780701756 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,120000,2004,4.291417165668663,fixed_full_OO_pool,0.5256344806082133,113272820858880000,245760000,61390080,195.763725,195.75851973684212 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,124000,2004,4.241516966067864,fixed_full_OO_pool,0.5431467266163478,117048581554176000,253952000,63436288,202.284825,202.28397295321636 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,128000,2004,4.69061876247505,fixed_full_OO_pool,0.560659320531413,120824342249472000,262144000,65482752,208.811175,208.80959429824563 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,132000,2004,5.489021956087824,fixed_full_OO_pool,0.5781730655497975,124600102944768000,270336000,67528960,215.335825,215.33452850877194 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,136000,2004,5.33932135728543,fixed_full_OO_pool,0.5956864063503842,128375863640064000,278528000,69575424,221.859925,221.8604788011696 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,140000,2004,5.489021956087824,fixed_full_OO_pool,0.6132002029309256,132151624335360000,286720000,71621632,228.384975,228.38535453216375 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,144000,2004,5.139720558882235,fixed_full_OO_pool,0.6307139235797028,135927385030656000,294912000,73668096,234.91125,234.91098684210527 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,148000,2004,6.88622754491018,fixed_full_OO_pool,0.6482275873360535,139703145725952000,303104000,75714304,241.4382,241.43558479532163 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,152000,2004,6.936127744510978,fixed_full_OO_pool,0.6657412253320217,143478906421248000,311296000,77760768,247.961725,247.96161915204678 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,156000,2004,6.187624750499002,fixed_full_OO_pool,0.683256023388563,147254667116544000,319488000,79806976,254.4794,254.48757309941521 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,160000,2004,8.08383233532934,fixed_full_OO_pool,0.7007694805548009,151030427811840000,327680000,81853184,261.01085,261.01151315789474 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,164000,2004,7.934131736526946,fixed_full_OO_pool,0.7182840105498003,154806188507136000,335872000,83899648,267.540575,267.5366410818713 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,168000,2004,7.285429141716566,fixed_full_OO_pool,0.7357971445408961,158581949202432000,344064000,85945856,274.0624,274.0619883040936 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,172000,2004,8.732534930139721,fixed_full_OO_pool,0.7533128571789711,162357709897728000,352256000,87992320,280.5924,280.58707602339183 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,176000,2004,9.630738522954092,fixed_full_OO_pool,0.7708260923686127,166133470593024000,360448000,90038528,287.112375,287.1126937134503 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,180000,2004,10.179640718562874,fixed_full_OO_pool,0.7883403366441942,169909231288320000,368640000,92084992,293.6389,293.6382894736842 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,184000,2004,9.73053892215569,fixed_full_OO_pool,0.8058541581210577,173684991983616000,376832000,94131200,300.161475,300.1635270467836 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,188000,2004,11.327345309381236,fixed_full_OO_pool,0.8233677802141756,177460752678912000,385024000,96177664,306.690925,306.6886951754386 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,192000,2004,10.62874251497006,fixed_full_OO_pool,0.8408807926769886,181236513374208000,393216000,98223872,313.214825,313.2137390350877 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,196000,2004,11.826347305389222,fixed_full_OO_pool,0.8583948286208841,185012274069504000,401408000,100270336,319.7388,319.7397076023392 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,200000,2004,10.778443113772456,fixed_full_OO_pool,0.8759083927878075,188788034764800000,409600000,102316544,326.26785,326.2639985380117 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,204000,2004,12.674650698602793,fixed_full_OO_pool,0.8934214059335904,192563795460096000,417792000,104363008,332.790075,332.79022295321636 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,208000,2004,12.125748502994012,fixed_full_OO_pool,0.9109338192072594,196339556155392000,425984000,106409216,339.3112,339.3156725146199 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,212000,2004,15.968063872255488,fixed_full_OO_pool,0.9284471915434632,200115316850688000,434176000,108455680,345.838675,345.8411293859649 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,216000,2004,14.271457085828343,fixed_full_OO_pool,0.9459609905661395,203891077545984000,442368000,110501888,352.36695,352.365533625731 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,220000,2004,16.86626746506986,fixed_full_OO_pool,0.96347359051514,207666838241280000,450560000,112548352,358.891375,358.89143640350875 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,224000,2004,15.768463073852296,fixed_full_OO_pool,0.9809870281939705,211442598936576000,458752000,114594560,365.41325,365.4167763157895 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,228000,2004,16.61676646706587,fixed_full_OO_pool,0.9985009169775165,215218359631872000,466944000,116641024,371.944975,371.94161184210526 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,232000,2004,16.81636726546906,fixed_full_OO_pool,1.0160137524052213,218994120327168000,475136000,118687232,378.464275,378.46732821637426 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,236000,2004,18.7125748502994,fixed_full_OO_pool,1.033524407669902,222769881022464000,483328000,120733696,384.9926,384.99266081871343 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,240000,2004,17.115768463073852,fixed_full_OO_pool,1.0510368270095851,226545641717760000,491520000,122779904,391.5193,391.51729532163745 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,244000,2004,19.760479041916167,fixed_full_OO_pool,1.0685486892196867,230321402413056000,499712000,124826112,398.042225,398.0424817251462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,248000,2004,18.862275449101794,fixed_full_OO_pool,1.0860619187737919,234097163108352000,507904000,126872576,404.567575,404.56824926900583 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,252000,2004,20.009980039920162,fixed_full_OO_pool,1.1035751583127098,237872923803648000,516096000,128918784,411.0936,411.09298245614036 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,256000,2004,19.760479041916167,fixed_full_OO_pool,1.1210868353603616,241648684498944000,524288000,130965248,417.61815,417.61886695906435 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,260000,2004,20.009980039920162,fixed_full_OO_pool,1.138598713521949,245424445194240000,532480000,133011456,424.142975,424.1437755847953 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,264000,2004,19.510978043912175,fixed_full_OO_pool,1.1561100637043515,249200205889536000,540672000,135057920,430.67075,430.6691885964912 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,268000,2004,21.00798403193613,fixed_full_OO_pool,1.1736236442097774,252975966584832000,548864000,137104128,437.191275,437.194725877193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,272000,2004,20.758483033932134,fixed_full_OO_pool,1.191136162298628,256751727280128000,557056000,139150592,443.7231,443.71954678362573 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,276000,2004,21.756487025948104,fixed_full_OO_pool,1.2086486204817064,260527487975424000,565248000,141196800,450.245675,450.2447843567251 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,280000,2004,21.856287425149702,fixed_full_OO_pool,1.2261613165266398,264303248670720000,573440000,143243264,456.769775,456.7707346491228 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,284000,2004,23.952095808383234,fixed_full_OO_pool,1.2436756471844597,268079009366016000,581632000,145289472,463.2998,463.29488304093564 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,288000,2004,21.20758483033932,fixed_full_OO_pool,1.2611899966249864,271854770061312000,589824000,147335936,469.82105,469.82125 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,292000,2004,25.299401197604794,fixed_full_OO_pool,1.2787073105356346,275630530756608000,598016000,149382144,476.347325,476.3459466374269 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,296000,2004,24.10179640718563,fixed_full_OO_pool,1.2962222684443825,279406291451904000,606208000,151428608,482.872525,482.8717361111111 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,300000,2004,24.451097804391217,fixed_full_OO_pool,1.3134469647612423,283182052147200000,614400000,153474816,489.39375,489.39717105263156 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,304000,2004,24.850299401197603,fixed_full_OO_pool,1.3306707793898467,286957812842496000,622592000,155521280,495.924625,495.9221308479532 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,308000,2004,26.497005988023954,fixed_full_OO_pool,1.3478999400821825,290733573537792000,630784000,157567488,502.44855,502.4471710526316 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,312000,2004,30.63872255489022,fixed_full_OO_pool,1.365123758809641,294509334233088000,638976000,159613952,508.97245,508.97315058479535 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,316000,2004,25.69860279441118,fixed_full_OO_pool,1.3823512589683136,298285094928384000,647168000,161660160,515.499175,515.4977814327485 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,320000,2004,27.395209580838326,fixed_full_OO_pool,1.399574827398691,302060855623680000,655360000,163706368,522.02315,522.0228143274854 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,324000,2004,26.047904191616766,fixed_full_OO_pool,1.4167982140307624,305836616318976000,663552000,165752832,528.550525,528.5482858187135 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,328000,2004,28.592814371257486,fixed_full_OO_pool,1.434023746278965,309612377014272000,671744000,167799040,535.075275,535.0732054093568 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,332000,2004,28.79241516966068,fixed_full_OO_pool,1.4512473029094852,313388137709568000,679936000,169845504,541.599425,541.5991483918128 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,336000,2004,30.039920159680637,fixed_full_OO_pool,1.4684723625404554,317163898404864000,688128000,171891712,548.1241,548.1240789473684 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,340000,2004,29.840319361277444,fixed_full_OO_pool,1.485695373075497,320939659100160000,696320000,173938176,554.6525,554.6494005847953 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,344000,2004,32.18562874251497,fixed_full_OO_pool,1.502917484751799,324715419795456000,704512000,175984384,561.176225,561.1744700292397 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,348000,2004,31.437125748502993,fixed_full_OO_pool,1.5201407170978685,328491180490752000,712704000,178030848,567.6995,567.7005409356725 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,352000,2004,33.03393213572854,fixed_full_OO_pool,1.537363241813663,332266941186048000,720896000,180077056,574.229,574.2247660818714 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,356000,2004,33.63273453093812,fixed_full_OO_pool,1.5545857893261645,336042701881344000,729088000,182123520,580.74945,580.75125 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,360000,2004,33.13373253493014,fixed_full_OO_pool,1.571810750638445,339818462576640000,737280000,184169728,587.2773,587.275716374269 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,364000,2004,31.686626746506985,fixed_full_OO_pool,1.5890347216423186,343594223271936000,745472000,186216192,593.80205,593.801571637427 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,368000,2004,33.88223552894212,fixed_full_OO_pool,1.6062619147159987,347369983967232000,753664000,188262400,600.328575,600.3262317251462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,372000,2004,33.83233532934132,fixed_full_OO_pool,1.6234891347162839,351145744662528000,761856000,190308864,606.854025,606.8519846491228 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,376000,2004,33.23353293413174,fixed_full_OO_pool,1.6407158797451606,354921505357824000,770048000,192355072,613.377875,613.3770358187135 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,380000,2004,33.93213572854291,fixed_full_OO_pool,1.6579406523156084,358697266053120000,778240000,194401536,619.905425,619.9024817251462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,384000,2004,36.427145708582835,fixed_full_OO_pool,1.675165958756374,362473026748416000,786432000,196447744,626.429275,626.4275328947368 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,388000,2004,40.4690618762475,fixed_full_OO_pool,1.6923896974759798,366248787443712000,794624000,198494208,632.953,632.9535380116959 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,392000,2004,36.377245508982035,fixed_full_OO_pool,1.7096148439238055,370024548139008000,802816000,200540416,639.47635,639.4786622807018 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,396000,2004,38.27345309381238,fixed_full_OO_pool,1.726840497450903,373800308834304000,811008000,202586624,646.00355,646.0032236842105 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,400000,2004,39.421157684630735,fixed_full_OO_pool,1.744067591091411,377576069529600000,819200000,204633088,652.52465,652.5296125730994 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,404000,2004,37.974051896207584,fixed_full_OO_pool,1.7612995313345972,381351830224896000,827392000,206679296,659.053775,659.0538925438597 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,408000,2004,40.618762475049905,fixed_full_OO_pool,1.7785300781463997,385127590920192000,835584000,208725760,665.582875,665.5791118421052 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,412000,2004,40.21956087824351,fixed_full_OO_pool,1.7957588681112975,388903351615488000,843776000,210771968,672.1037,672.1046052631579 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,416000,2004,40.36926147704591,fixed_full_OO_pool,1.812983510657731,392679112310784000,851968000,212818432,678.629725,678.630274122807 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,420000,2004,44.01197604790419,fixed_full_OO_pool,1.8302107167823447,396454873006080000,860160000,214864640,685.153725,685.1553033625731 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,424000,2004,42.61477045908183,fixed_full_OO_pool,1.8474387148219265,400230633701376000,868352000,216911104,691.68155,691.6807090643275 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,428000,2004,43.16367265469062,fixed_full_OO_pool,1.8646639993714376,404006394396672000,876544000,218957312,698.205125,698.2058004385965 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,432000,2004,43.712574850299404,fixed_full_OO_pool,1.8818915393948554,407782155091968000,884736000,221003776,704.73425,704.7310160818713 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,436000,2004,42.115768463073856,fixed_full_OO_pool,1.8991172747003535,411557915787264000,892928000,223049984,711.25405,711.2566593567251 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,440000,2004,41.96606786427146,fixed_full_OO_pool,1.9163415687614016,415333676482560000,901120000,225096448,717.782775,717.7819334795322 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,444000,2004,42.71457085828344,fixed_full_OO_pool,1.9335647928135262,419109437177856000,909312000,227142656,724.311975,724.3062024853801 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,448000,2004,43.712574850299404,fixed_full_OO_pool,1.9507867487137103,422885197873152000,917504000,229189120,730.8328,730.8326315789474 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,452000,2004,44.71057884231537,fixed_full_OO_pool,1.9680116600150035,426660958568448000,925696000,231235328,737.355575,737.3578399122807 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,456000,2004,47.85429141716567,fixed_full_OO_pool,1.9852363387422842,430436719263744000,933888000,233281792,743.8846,743.8830701754385 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,460000,2004,48.05389221556886,fixed_full_OO_pool,2.002463505518519,434212479959040000,942080000,235328000,750.409,750.4080409356725 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,464000,2004,47.65469061876247,fixed_full_OO_pool,2.019687972922499,437988240654336000,950272000,237374464,756.931775,756.9341849415205 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,468000,2004,49.50099800399202,fixed_full_OO_pool,2.0369144354770996,441764001349632000,958464000,239420672,763.45835,763.4588377192982 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,472000,2004,49.00199600798403,fixed_full_OO_pool,2.0541421164582587,445539762044928000,966656000,241467136,769.984375,769.9845065789474 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,476000,2004,48.952095808383234,fixed_full_OO_pool,2.0713688237095873,449315522740224000,974848000,243513344,776.5063,776.5098391812866 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,480000,2004,48.902195608782435,fixed_full_OO_pool,2.0885927263461053,453091283435520000,983040000,245559552,783.0342,783.0342982456141 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,484000,2004,47.70459081836327,fixed_full_OO_pool,2.105815654300774,456867044130816000,991232000,247606016,789.559875,789.5600182748537 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,488000,2004,50.84830339321357,fixed_full_OO_pool,2.1230376895289456,460642804826112000,999424000,249652224,796.08695,796.0845979532164 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,492000,2004,49.05189620758483,fixed_full_OO_pool,2.1402593331535655,464418565521408000,1007616000,251698688,802.611575,802.610471491228 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,496000,2004,51.29740518962076,fixed_full_OO_pool,2.1574814385382663,468194326216704000,1015808000,253744896,809.136325,809.1353910818714 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,500000,2004,51.29740518962076,fixed_full_OO_pool,2.174704005997628,471970086912000000,1024000000,255791360,815.660125,815.6613852339182 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,504000,2004,51.44710578842315,fixed_full_OO_pool,2.19192565895824,475745847607296000,1032192000,257837568,822.185675,822.1861878654971 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,508000,2004,51.94610778443114,fixed_full_OO_pool,2.2091469719923205,479521608302592000,1040384000,259884032,828.71065,828.7120102339181 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,512000,2004,53.443113772455085,fixed_full_OO_pool,2.2263685131083344,483297368997888000,1048576000,261930240,835.23295,835.2372880116959 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,516000,2004,54.29141716566866,fixed_full_OO_pool,2.2435908648402743,487073129693184000,1056768000,263976704,841.763075,841.7623574561403 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,520000,2004,52.09580838323353,fixed_full_OO_pool,2.260816547025202,490848890388480000,1064960000,266022912,848.28965,848.2870102339182 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,524000,2004,50.74850299401198,fixed_full_OO_pool,2.278040318031692,494624651083776000,1073152000,268069376,854.814675,854.8128252923976 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,528000,2004,53.942115768463076,fixed_full_OO_pool,2.295265647259851,498400411779072000,1081344000,270115584,861.340575,861.337576754386 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,532000,2004,54.740518962075846,fixed_full_OO_pool,2.3124880151088454,502176172474368000,1089536000,272162048,867.8607,867.8641081871345 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,536000,2004,53.64271457085829,fixed_full_OO_pool,2.3297114359887523,505951933169664000,1097728000,274208256,874.3878,874.3886842105263 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,540000,2004,54.14171656686627,fixed_full_OO_pool,2.346933352580915,509727693864960000,1105920000,276254720,880.911925,880.9146308479532 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,544000,2004,53.443113772455085,fixed_full_OO_pool,2.364156736449028,513503454560256000,1114112000,278300928,887.4355,887.4397222222223 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,548000,2004,56.3872255489022,fixed_full_OO_pool,2.3813786550269773,517279215255552000,1122304000,280347392,893.965575,893.9647989766082 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,552000,2004,53.3433133732535,fixed_full_OO_pool,2.3986018837470975,521054975950848000,1130496000,282393600,900.4841,900.4906286549708 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,556000,2004,55.33932135728543,fixed_full_OO_pool,2.4158244182190134,524830736646144000,1138688000,284439808,907.014725,907.0146893274854 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,560000,2004,56.4870259481038,fixed_full_OO_pool,2.433046614242097,528606497341440000,1146880000,286486272,913.539325,913.5405665204678 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,564000,2004,58.38323353293413,fixed_full_OO_pool,2.4502698853880993,532382258036736000,1155072000,288532480,920.064275,920.0654568713451 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,568000,2004,59.88023952095808,fixed_full_OO_pool,2.4674942466440712,536158018732032000,1163264000,290578944,926.594875,926.590456871345 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,572000,2004,56.63672654690619,fixed_full_OO_pool,2.4847160104351738,539933779427328000,1171456000,292625152,933.1148,933.116081871345 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,576000,2004,57.43512974051897,fixed_full_OO_pool,2.501937105099981,543709540122624000,1179648000,294671616,939.638775,939.6420504385965 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,580000,2004,59.48103792415169,fixed_full_OO_pool,2.5191598221949407,547485300817920000,1187840000,296717824,946.168025,946.166312134503 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,584000,2004,57.28542914171657,fixed_full_OO_pool,2.5363808585693026,551261061513216000,1196032000,298764288,952.690725,952.6924671052632 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,588000,2004,57.28542914171657,fixed_full_OO_pool,2.553602057359078,555036822208512000,1204224000,300810496,959.216975,959.2171673976608 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,592000,2004,61.52694610778443,fixed_full_OO_pool,2.5708224371748254,558812582903808000,1212416000,302856960,965.746525,965.7423209064327 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,596000,2004,59.5309381237525,fixed_full_OO_pool,2.5880426660718188,562588343599104000,1220608000,304903168,972.265375,972.2681030701755 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,600000,2004,58.982035928143716,fixed_full_OO_pool,2.6052650237725015,566364104294400000,1228800000,306949632,978.793025,978.7935343567251 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,604000,2004,59.58083832335329,fixed_full_OO_pool,2.6224880189179545,570139864989696000,1236992000,308995840,985.318275,985.3183808479532 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,608000,2004,61.32734530938124,fixed_full_OO_pool,2.639711925332538,573915625684992000,1245184000,311042304,991.843275,991.8441995614035 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,612000,2004,60.87824351297405,fixed_full_OO_pool,2.656938175703916,577691386380288000,1253376000,313088512,998.367125,998.3692507309942 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,616000,2004,60.32934131736527,fixed_full_OO_pool,2.6741639385041265,581467147075584000,1261568000,315134976,1004.89305,1004.8949342105263 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,620000,2004,59.930139720558884,fixed_full_OO_pool,2.6913937354946715,585242907770880000,1269760000,317181184,1011.419075,1011.4196673976609 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,624000,2004,64.67065868263472,fixed_full_OO_pool,2.7086198725385797,589018668466176000,1277952000,319227648,1017.94655,1017.9451242690059 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,628000,2004,62.6746506986028,fixed_full_OO_pool,2.725847855851882,592794429161472000,1286144000,321273856,1024.4692,1024.470350877193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,632000,2004,61.77644710578842,fixed_full_OO_pool,2.7430757420603187,596570189856768000,1294336000,323320320,1030.9954,1030.9959941520467 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,636000,2004,62.92415169660679,fixed_full_OO_pool,2.7603028743072517,600345950552064000,1302528000,325366528,1037.51875,1037.5211184210527 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,640000,2004,65.01996007984032,fixed_full_OO_pool,2.777530834754515,604121711247360000,1310720000,327412736,1044.046025,1044.0456688596491 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,644000,2004,65.51896207584831,fixed_full_OO_pool,2.7947556545823398,607897471942656000,1318912000,329459200,1050.569475,1050.5717141812866 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,648000,2004,65.76846307385229,fixed_full_OO_pool,2.811978615562742,611673232637952000,1327104000,331505408,1057.095525,1057.0964437134503 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,652000,2004,64.02195608782435,fixed_full_OO_pool,2.8292040653268082,615448993333248000,1335296000,333551872,1063.6214,1063.622134502924 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,656000,2004,62.5748502994012,fixed_full_OO_pool,2.846426842395837,619224754028544000,1343488000,335598080,1070.148925,1070.146648391813 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,660000,2004,66.71656686626747,fixed_full_OO_pool,2.863649742714026,623000514723840000,1351680000,337644544,1076.674075,1076.6724451754385 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,664000,2004,64.27145708582835,fixed_full_OO_pool,2.880872192008214,626776275419136000,1359872000,339690752,1083.19835,1083.1974342105264 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,668000,2004,66.46706586826348,fixed_full_OO_pool,2.898099004214423,630552036114432000,1368064000,341737216,1089.72275,1089.723340643275 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,672000,2004,65.01996007984032,fixed_full_OO_pool,2.915328195821494,634327796809728000,1376256000,343783424,1096.2529,1096.247470760234 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,676000,2004,68.01397205588823,fixed_full_OO_pool,2.932557549491111,638103557505024000,1384448000,345829888,1102.7743,1102.7738157894737 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,680000,2004,68.01397205588823,fixed_full_OO_pool,2.949787525850245,641879318200320000,1392640000,347876096,1109.302275,1109.2982638888889 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,684000,2004,66.46706586826348,fixed_full_OO_pool,2.967014744653263,645655078895616000,1400832000,349922560,1115.822275,1115.8248135964911 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,688000,2004,66.26746506986028,fixed_full_OO_pool,2.9842421217521444,649430839590912000,1409024000,351968768,1122.351,1122.3491520467837 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,692000,2004,64.37125748502994,fixed_full_OO_pool,3.001468160164853,653206600286208000,1417216000,354015232,1128.875075,1128.8751059941521 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,696000,2004,65.26946107784431,fixed_full_OO_pool,3.0186965735877553,656982360981504000,1425408000,356061440,1135.395625,1135.4006396198831 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,700000,2004,67.46506986027944,fixed_full_OO_pool,3.0359256334375178,660758121676800000,1433600000,358107904,1141.9251,1141.9258040935672 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,704000,2004,66.46706586826348,fixed_full_OO_pool,3.0531539151279463,664533882372096000,1441792000,360154112,1148.44995,1148.4507090643274 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,708000,2004,66.61676646706587,fixed_full_OO_pool,3.070380117105734,668309643067392000,1449984000,362200576,1154.97815,1154.9760599415204 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,712000,2004,67.11576846307385,fixed_full_OO_pool,3.0876135635976163,672085403762688000,1458176000,364246784,1161.502725,1161.501005116959 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,716000,2004,69.66067864271457,fixed_full_OO_pool,3.1048433123549652,675861164457984000,1466368000,366292992,1168.026725,1168.0260343567252 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,720000,2004,68.26347305389223,fixed_full_OO_pool,3.122068726863298,679636925153280000,1474560000,368339456,1174.5495,1174.5521783625732 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,724000,2004,68.01397205588823,fixed_full_OO_pool,3.1392968886242145,683412685848576000,1482752000,370385664,1181.07815,1181.0765277777778 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,728000,2004,68.7125748502994,fixed_full_OO_pool,3.1565245666520463,687188446543872000,1490944000,372432128,1187.599725,1187.6028472222222 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,732000,2004,68.9620758483034,fixed_full_OO_pool,3.173753410174201,690964207239168000,1499136000,374478336,1194.12625,1194.1275073099416 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,736000,2004,69.81037924151696,fixed_full_OO_pool,3.1909787000043113,694739967934464000,1507328000,376524800,1200.653825,1200.6529495614036 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,740000,2004,68.16367265469061,fixed_full_OO_pool,3.2082077934613658,698515728629760000,1515520000,378571008,1207.174725,1207.1784320175439 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,744000,2004,69.311377245509,fixed_full_OO_pool,3.225433354391199,702291489325056000,1523712000,380617472,1213.702075,1213.7039071637428 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,748000,2004,68.8622754491018,fixed_full_OO_pool,3.2426569497026505,706067250020352000,1531904000,382663680,1220.225675,1220.228994883041 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,752000,2004,68.6626746506986,fixed_full_OO_pool,3.2598811739352014,709843010715648000,1540096000,384710144,1226.75395,1226.7543347953217 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,756000,2004,69.2115768463074,fixed_full_OO_pool,3.2771062611902337,713618771410944000,1548288000,386756352,1233.2791,1233.2791959064327 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,760000,2004,72.0558882235529,fixed_full_OO_pool,3.2943339617550373,717394532106240000,1556480000,388802816,1239.804525,1239.8049524853802 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,764000,2004,69.01197604790418,fixed_full_OO_pool,3.3115633501360815,721170292801536000,1564672000,390849024,1246.3319,1246.3294883040935 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,768000,2004,70.60878243512974,fixed_full_OO_pool,3.328787970851279,724946053496832000,1572864000,392895488,1252.856725,1252.855332602339 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,772000,2004,70.50898203592814,fixed_full_OO_pool,3.3460153445280674,728721814192128000,1581056000,394941696,1259.380075,1259.3804568713451 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,776000,2004,68.91217564870259,fixed_full_OO_pool,3.3632401290504883,732497574887424000,1589248000,396988160,1265.9052,1265.9062573099416 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,780000,2004,71.20758483033931,fixed_full_OO_pool,3.380468349474379,736273335582720000,1597440000,399034368,1272.43,1272.4311695906433 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,784000,2004,71.25748502994011,fixed_full_OO_pool,3.397693392255654,740049096278016000,1605632000,401080832,1278.957575,1278.9566118421053 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,788000,2004,70.15968063872255,fixed_full_OO_pool,3.4149200013818013,743824856973312000,1613824000,403127040,1285.480925,1285.481736111111 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,792000,2004,69.36127744510978,fixed_full_OO_pool,3.4321460416840597,747600617668608000,1622016000,405173248,1292.006575,1292.006524122807 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,796000,2004,71.15768463073853,fixed_full_OO_pool,3.449368479699931,751376378363904000,1630208000,407219712,1298.530425,1298.5325109649123 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,800000,2004,70.00998003992017,fixed_full_OO_pool,3.4665908590072974,755152139059200000,1638400000,409265920,1305.056825,1305.0571893274853 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,804000,2004,73.90219560878243,fixed_full_OO_pool,3.4838144988266544,758927899754496000,1646592000,411312384,1311.584675,1311.582591374269 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,808000,2004,71.00798403193613,fixed_full_OO_pool,3.5010371815827157,762703660449792000,1654784000,413358592,1318.1077,1318.1077631578946 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,812000,2004,70.35928143712576,fixed_full_OO_pool,3.5182605919448866,766479421145088000,1662976000,415405056,1324.6323,1324.6336403508772 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,816000,2004,71.15768463073853,fixed_full_OO_pool,3.5354851196561423,770255181840384000,1671168000,417451264,1331.1573,1331.1585233918129 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,820000,2004,72.1057884231537,fixed_full_OO_pool,3.5527081166238834,774030942535680000,1679360000,419497728,1337.68455,1337.6840131578947 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,824000,2004,71.7564870259481,fixed_full_OO_pool,3.5699296048449147,777806703230976000,1687552000,421543936,1344.2104,1344.2087719298245 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,828000,2004,73.65269461077844,fixed_full_OO_pool,3.587150900470507,781582463926272000,1695744000,423590400,1350.736375,1350.7344480994152 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,832000,2004,70.00998003992017,fixed_full_OO_pool,3.604373427928529,785358224621568000,1703936000,425636608,1357.26155,1357.2593055555556 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,836000,2004,72.15568862275448,fixed_full_OO_pool,3.621594260727159,789133985316864000,1712128000,427683072,1363.786375,1363.7851498538012 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,840000,2004,73.95209580838323,fixed_full_OO_pool,3.638814374659624,792909746012160000,1720320000,429729280,1370.3079,1370.3105409356724 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,844000,2004,73.20359281437125,fixed_full_OO_pool,3.656036121038099,796685506707456000,1728512000,431775744,1376.836875,1376.835778508772 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,848000,2004,69.96007984031935,fixed_full_OO_pool,3.67325915362272,800461267402752000,1736704000,433821952,1383.35955,1383.3610014619883 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,852000,2004,71.40718562874252,fixed_full_OO_pool,3.6904809553766,804237028098048000,1744896000,435868416,1389.88515,1389.8867324561404 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,856000,2004,70.20958083832335,fixed_full_OO_pool,3.7077054502359696,808012788793344000,1753088000,437914624,1396.4091,1396.4117690058479 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,860000,2004,76.24750499001996,fixed_full_OO_pool,3.7249271347477206,811788549488640000,1761280000,439961088,1402.935675,1402.9373574561403 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,864000,2004,73.35329341317365,fixed_full_OO_pool,3.742148372820682,815564310183936000,1769472000,442007296,1409.461675,1409.4620942982456 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,868000,2004,72.80439121756487,fixed_full_OO_pool,3.759369468917656,819340070879232000,1777664000,444053760,1415.9872,1415.98783625731 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,872000,2004,71.8063872255489,fixed_full_OO_pool,3.7765922321358487,823115831574528000,1785856000,446099968,1422.51175,1422.5127850877193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,876000,2004,74.20159680638723,fixed_full_OO_pool,3.7938131466125036,826891592269824000,1794048000,448146176,1429.037575,1429.03754751462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,880000,2004,72.2554890219561,fixed_full_OO_pool,3.8110335901079493,830667352965120000,1802240000,450192640,1435.563525,1435.5632273391814 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,884000,2004,74.15169660678643,fixed_full_OO_pool,3.8282555552240876,834443113660416000,1810432000,452238848,1442.0886,1442.0880994152046 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,888000,2004,74.35129740518963,fixed_full_OO_pool,3.84547998773348,838218874355712000,1818624000,454285312,1448.613375,1448.6139510233918 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,892000,2004,72.45508982035929,fixed_full_OO_pool,3.862705743857142,841994635051008000,1826816000,456331520,1455.135925,1455.139192251462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,896000,2004,73.20359281437125,fixed_full_OO_pool,3.8799306025966587,845770395746304000,1835008000,458377984,1461.66955,1461.66375 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,900000,2004,75.1996007984032,fixed_full_OO_pool,3.8971547450259743,849546156441600000,1843200000,460424192,1468.1904,1468.189239766082 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,904000,2004,72.75449101796407,fixed_full_OO_pool,3.9143776425429517,853321917136896000,1851392000,462470656,1474.7163,1474.7149269005847 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,908000,2004,73.65269461077844,fixed_full_OO_pool,3.9316027246167264,857097677832192000,1859584000,464516864,1481.23855,1481.240211988304 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,912000,2004,74.20159680638723,fixed_full_OO_pool,3.9488303552443784,860873438527488000,1867776000,466563328,1487.766175,1487.7656469298245 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,916000,2004,73.20359281437125,fixed_full_OO_pool,3.966054997075763,864649199222784000,1875968000,468609536,1494.294025,1494.2901133040937 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,920000,2004,71.50698602794411,fixed_full_OO_pool,3.983280393484359,868424959918080000,1884160000,470656000,1500.817625,1500.8161366959064 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,924000,2004,74.50099800399201,fixed_full_OO_pool,4.00050749548297,872200720613376000,1892352000,472702208,1507.339175,1507.341524122807 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,928000,2004,75.94810379241517,fixed_full_OO_pool,4.017732367721489,875976481308672000,1900544000,474748672,1513.8643,1513.8673245614036 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,932000,2004,74.60079840319361,fixed_full_OO_pool,4.034960286076077,879752242003968000,1908736000,476794880,1520.39315,1520.3916447368422 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,936000,2004,76.74650698602794,fixed_full_OO_pool,4.052188061561642,883528002699264000,1916928000,478841344,1526.918675,1526.9173866959065 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,940000,2004,74.30139720558883,fixed_full_OO_pool,4.069413222973752,887303763394560000,1925120000,480887552,1533.445425,1533.4420138888888 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,944000,2004,74.35129740518963,fixed_full_OO_pool,4.0866366903752915,891079524089856000,1933312000,482934016,1539.96965,1539.9679459064328 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,948000,2004,70.75848303393214,fixed_full_OO_pool,4.103861149408751,894855284785152000,1941504000,484980224,1546.4949,1546.4927923976609 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,952000,2004,71.9560878243513,fixed_full_OO_pool,4.121090114309142,898631045480448000,1949696000,487026432,1553.0175,1553.0180263157895 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,956000,2004,76.74650698602794,fixed_full_OO_pool,4.1383196527128,902406806175744000,1957888000,489072896,1559.5433,1559.5437280701753 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,960000,2004,76.34730538922156,fixed_full_OO_pool,4.1555469934290485,906182566871040000,1966080000,491119104,1566.067025,1566.06879751462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,964000,2004,73.90219560878243,fixed_full_OO_pool,4.172773531636016,909958327566336000,1974272000,493165568,1572.59525,1572.594144736842 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,968000,2004,75.59880239520959,fixed_full_OO_pool,4.189996911499442,913734088261632000,1982464000,495211776,1579.121725,1579.1188121345028 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,972000,2004,74.10179640718563,fixed_full_OO_pool,4.2072223391301105,917509848956928000,1990656000,497258240,1585.641325,1585.6454203216374 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,976000,2004,77.24550898203593,fixed_full_OO_pool,4.224445835379884,921285609652224000,1998848000,499304448,1592.16975,1592.169802631579 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,980000,2004,78.69261477045907,fixed_full_OO_pool,4.241669280275495,925061370347520000,2007040000,501350912,1598.69315,1598.695855263158 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,984000,2004,76.54690618762476,fixed_full_OO_pool,4.258893875209615,928837131042816000,2015232000,503397120,1605.22065,1605.2203728070176 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,988000,2004,77.8942115768463,fixed_full_OO_pool,4.276115858270269,932612891738112000,2023424000,505443584,1611.74645,1611.7460745614035 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,992000,2004,75.59880239520959,fixed_full_OO_pool,4.293336800578982,936388652433408000,2031616000,507489792,1618.267875,1618.2714802631579 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,996000,2004,75.1497005988024,fixed_full_OO_pool,4.310558076272201,940164413128704000,2039808000,509536256,1624.797525,1624.7966191520468 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1000000,2004,75.94810379241517,fixed_full_OO_pool,4.327780924500484,943940173824000000,2048000000,511582464,1631.3245,1631.3212134502924 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1004000,2004,76.19760479041916,fixed_full_OO_pool,4.34500354432294,947715934519296000,2056192000,513628928,1637.848,1637.8472514619882 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1008000,2004,76.59680638722554,fixed_full_OO_pool,4.362228172131711,951491695214592000,2064384000,515675136,1644.377825,1644.3714290935673 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1012000,2004,75.2994011976048,fixed_full_OO_pool,4.3794516968416675,955267455909888000,2072576000,517721600,1650.897675,1650.8980007309942 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1016000,2004,78.0938123752495,fixed_full_OO_pool,4.396676725431655,959043216605184000,2080768000,519767808,1657.4205,1657.423201754386 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1020000,2004,78.79241516966069,fixed_full_OO_pool,4.413902179870961,962818977300480000,2088960000,521814272,1663.95055,1663.9482821637428 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1024000,2004,77.59481037924152,fixed_full_OO_pool,4.431127260686416,966594737995776000,2097152000,523860480,1670.47305,1670.4735307017545 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1028000,2004,78.3433133732535,fixed_full_OO_pool,4.448354871999473,970370498691072000,2105344000,525906944,1676.999125,1676.999192251462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1032000,2004,77.59481037924152,fixed_full_OO_pool,4.465579214717986,974146259386368000,2113536000,527953152,1683.52685,1683.5236769005849 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1036000,2004,76.14770459081836,fixed_full_OO_pool,4.482802542739858,977922020081664000,2121728000,529999360,1690.048475,1690.0490533625732 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1040000,2004,76.89620758483034,fixed_full_OO_pool,4.500027815095253,981697780776960000,2129920000,532045824,1696.57575,1696.5745394736841 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1044000,2004,74.9500998003992,fixed_full_OO_pool,4.517253047208198,985473541472256000,2138112000,534092032,1703.1006,1703.0994444444445 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1048000,2004,75.74850299401199,fixed_full_OO_pool,4.53447868420846,989249302167552000,2146304000,536138496,1709.626925,1709.6250694444445 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1052000,2004,76.39720558882236,fixed_full_OO_pool,4.5517050499727745,993025062862848000,2154496000,538184704,1716.15085,1716.150109649123 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1056000,2004,72.95409181636727,fixed_full_OO_pool,4.568928335334899,996800823558144000,2162688000,540231168,1722.676175,1722.6758808479533 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1060000,2004,78.89221556886228,fixed_full_OO_pool,4.586154038661884,1000576584253440000,2170880000,542277376,1729.20065,1729.200840643275 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1064000,2004,79.14171656686626,fixed_full_OO_pool,4.603380878459041,1004352344948736000,2179072000,544323840,1735.7277,1735.7263596491227 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1068000,2004,76.29740518962076,fixed_full_OO_pool,4.621922764092063,1008128105644032000,2187264000,546370048,1742.252225,1742.251312134503 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1072000,2004,79.09181636726547,fixed_full_OO_pool,4.643876352928992,1011903866339328000,2195456000,548416512,1748.7758,1748.7773391812866 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1076000,2004,77.19560878243513,fixed_full_OO_pool,4.666841295180428,1015679627034624000,2203648000,550462720,1755.302825,1755.3019261695906 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1080000,2004,75.94810379241517,fixed_full_OO_pool,4.689771350821894,1019455387729920000,2211840000,552509184,1761.827875,1761.8277375730995 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1084000,2004,77.8942115768463,fixed_full_OO_pool,4.7101976463219355,1023231148425216000,2220032000,554555392,1768.352325,1768.3527010233918 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1088000,2004,78.69261477045907,fixed_full_OO_pool,4.728474998498957,1027006909120512000,2228224000,556601856,1774.8786,1774.8783333333333 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1092000,2004,78.69261477045907,fixed_full_OO_pool,4.745708879088569,1030782669815808000,2236416000,558648064,1781.401475,1781.4035270467837 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1096000,2004,75.39920159680639,fixed_full_OO_pool,4.762944611216792,1034558430511104000,2244608000,560694528,1787.9267,1787.929312865497 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1100000,2004,79.54091816367266,fixed_full_OO_pool,4.780178257200039,1038334191206400000,2252800000,562740736,1794.454175,1794.4538340643276 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1104000,2004,77.8942115768463,fixed_full_OO_pool,4.797410410783357,1042109951901696000,2260992000,564787200,1800.979075,1800.9796673976607 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1108000,2004,76.59680638722554,fixed_full_OO_pool,4.814644619157124,1045885712596992000,2269184000,566833408,1807.505475,1807.504345760234 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1112000,2004,78.89221556886228,fixed_full_OO_pool,4.831880244500935,1049661473292288000,2277376000,568879616,1814.0292,1814.0294152046783 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1116000,2004,74.8502994011976,fixed_full_OO_pool,4.849114756396868,1053437233987584000,2285568000,570926080,1820.55255,1820.555475146199 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1120000,2004,77.49500998003992,fixed_full_OO_pool,4.866349283894524,1057212994682880000,2293760000,572972288,1827.0793,1827.0801023391814 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1124000,2004,76.74650698602794,fixed_full_OO_pool,4.883583244832439,1060988755378176000,2301952000,575018752,1833.60705,1833.605519005848 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1128000,2004,79.09181636726547,fixed_full_OO_pool,4.900814701631251,1064764516073472000,2310144000,577064960,1840.1335,1840.1301900584795 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1132000,2004,78.0439121756487,fixed_full_OO_pool,4.918049285469784,1068540276768768000,2318336000,579111424,1846.655175,1846.656494883041 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1136000,2004,73.40319361277446,fixed_full_OO_pool,4.93528579428999,1072316037464064000,2326528000,581157632,1853.1819,1853.1811257309942 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1140000,2004,77.59481037924152,fixed_full_OO_pool,4.952522779760055,1076091798159360000,2334720000,583204096,1859.7061,1859.7070614035088 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1144000,2004,75.74850299401199,fixed_full_OO_pool,4.9697597176385,1079867558854656000,2342912000,585250304,1866.233425,1866.2316045321638 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1148000,2004,75.3493013972056,fixed_full_OO_pool,4.986994815365308,1083643319549952000,2351104000,587296768,1872.75915,1872.757317251462 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1152000,2004,79.29141716566866,fixed_full_OO_pool,5.004232547300764,1087419080245248000,2359296000,589342976,1879.282975,1879.2823720760234 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1156000,2004,78.54291417165669,fixed_full_OO_pool,5.021470017743607,1091194840940544000,2367488000,591389440,1885.806675,1885.8083808479532 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1160000,2004,76.94610778443113,fixed_full_OO_pool,5.03870923949716,1094970601635840000,2375680000,593435648,1892.3363,1892.3325877192983 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1164000,2004,79.34131736526946,fixed_full_OO_pool,5.0559426132693055,1098746362331136000,2383872000,595482112,1898.854725,1898.8593676900584 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1168000,2004,80.83832335329342,fixed_full_OO_pool,5.073179317606199,1102522123026432000,2392064000,597528320,1905.38405,1905.3836184210527 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1172000,2004,78.44311377245509,fixed_full_OO_pool,5.090412564628447,1106297883721728000,2400256000,599574784,1911.9119,1911.9090204678362 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1176000,2004,76.54690618762476,fixed_full_OO_pool,5.107650016439664,1110073644417024000,2408448000,601620992,1918.435525,1918.4341045321637 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1180000,2004,76.89620758483034,fixed_full_OO_pool,5.124882094808337,1113849405112320000,2416640000,603667456,1924.95995,1924.9600073099416 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1184000,2004,78.2934131736527,fixed_full_OO_pool,5.142117254402902,1117625165807616000,2424832000,605713664,1931.481875,1931.4853399122808 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1188000,2004,79.74051896207584,fixed_full_OO_pool,5.159348583271106,1121400926502912000,2433024000,607759872,1938.009425,1938.009850146199 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1192000,2004,77.69461077844312,fixed_full_OO_pool,5.176581127997488,1125176687198208000,2441216000,609806336,1944.534275,1944.5356907894736 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1196000,2004,79.29141716566866,fixed_full_OO_pool,5.193814380431755,1128952447893504000,2449408000,611852544,1951.0621,1951.0601608187135 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1200000,2004,80.938123752495,fixed_full_OO_pool,5.2110446555560666,1132728208588800000,2457600000,613899008,1957.584825,1957.586312134503 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1204000,2004,78.3932135728543,fixed_full_OO_pool,5.228277457678277,1136503969284096000,2465792000,615945216,1964.108875,1964.1113340643276 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1208000,2004,77.29540918163673,fixed_full_OO_pool,5.245502429088163,1140279729979392000,2473984000,617991680,1970.63505,1970.636980994152 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1212000,2004,78.0439121756487,fixed_full_OO_pool,5.262731487144612,1144055490674688000,2482176000,620037888,1977.162125,1977.1615606725147 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1216000,2004,78.0439121756487,fixed_full_OO_pool,5.279959380509745,1147831251369984000,2490368000,622084352,1983.6894,1983.6870467836256 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1220000,2004,79.79041916167665,fixed_full_OO_pool,5.297184902610671,1151607012065280000,2498560000,624130560,1990.215475,1990.2117726608187 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1224000,2004,79.44111776447106,fixed_full_OO_pool,5.314409507730355,1155382772760576000,2506752000,626177024,1996.7373,1996.7380555555555 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1228000,2004,81.0379241516966,fixed_full_OO_pool,5.3316333658982895,1159158533455872000,2514944000,628223232,2003.262225,2003.2629495614035 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1232000,2004,75.59880239520959,fixed_full_OO_pool,5.348859119428735,1162934294151168000,2523136000,630269696,2009.79055,2009.7882821637427 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1236000,2004,78.49301397205589,fixed_full_OO_pool,5.36608519473734,1166710054846464000,2531328000,632315904,2016.315575,2016.3131615497075 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1240000,2004,78.74251497005989,fixed_full_OO_pool,5.383309613561464,1170485815541760000,2539520000,634362368,2022.841425,2022.838855994152 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1244000,2004,80.98802395209582,fixed_full_OO_pool,5.400538592873555,1174261576237056000,2547712000,636408576,2029.3629,2029.3642543859648 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1248000,2004,78.0938123752495,fixed_full_OO_pool,5.417767083763869,1178037336932352000,2555904000,638455040,2035.889075,2035.8899013157895 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1252000,2004,80.13972055888223,fixed_full_OO_pool,5.434995316551585,1181813097627648000,2564096000,640501248,2042.414125,2042.4147770467837 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1256000,2004,80.43912175648703,fixed_full_OO_pool,5.452225479821985,1185588858322944000,2572288000,642547712,2048.936625,2048.94096125731 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1260000,2004,78.3932135728543,fixed_full_OO_pool,5.4694579827206,1189364619018240000,2580480000,644593920,2055.4625,2055.465716374269 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1264000,2004,78.49301397205589,fixed_full_OO_pool,5.4866859890893105,1193140379713536000,2588672000,646640384,2061.990325,2061.991122076023 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1268000,2004,79.84031936127745,fixed_full_OO_pool,5.503913430083129,1196916140408832000,2596864000,648686592,2068.517525,2068.515683479532 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1272000,2004,79.84031936127745,fixed_full_OO_pool,5.5211410077619885,1200691901104128000,2605056000,650732800,2075.040975,2075.040793128655 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1276000,2004,80.08982035928143,fixed_full_OO_pool,5.5383700951550985,1204467661799424000,2613248000,652779264,2081.566575,2081.566524122807 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1280000,2004,80.53892215568862,fixed_full_OO_pool,5.55560534324704,1208243422494720000,2621440000,654825472,2088.094025,2088.0910489766084 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1284000,2004,77.7445109780439,fixed_full_OO_pool,5.5728399750600675,1212019183190016000,2629632000,656871936,2094.62025,2094.6166885964913 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1288000,2004,79.79041916167665,fixed_full_OO_pool,5.590069344439026,1215794943885312000,2637824000,658918144,2101.1387,2101.142529239766 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1292000,2004,77.24550898203593,fixed_full_OO_pool,5.607303493517555,1219570704580608000,2646016000,660964608,2107.668425,2107.6676571637427 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1296000,2004,79.69061876247505,fixed_full_OO_pool,5.624538537393221,1223346465275904000,2654208000,663010816,2114.193775,2114.192489035088 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1300000,2004,79.24151696606786,fixed_full_OO_pool,5.641772386009494,1227122225971200000,2662400000,665057280,2120.717475,2120.7184978070177 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1304000,2004,79.29141716566866,fixed_full_OO_pool,5.6590078084760655,1230897986666496000,2670592000,667103488,2127.249425,2127.2423647660817 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1308000,2004,79.64071856287424,fixed_full_OO_pool,5.676240980761746,1234673747361792000,2678784000,669149952,2133.767925,2133.76913377193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1312000,2004,80.98802395209582,fixed_full_OO_pool,5.6934714581817385,1238449508057088000,2686976000,671196160,2140.293825,2140.293885233918 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1316000,2004,79.19161676646706,fixed_full_OO_pool,5.710701242114107,1242225268752384000,2695168000,673242624,2146.8188,2146.8197076023393 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1320000,2004,79.94011976047905,fixed_full_OO_pool,5.7279312863118115,1246001029447680000,2703360000,675288832,2153.35105,2153.3435307017544 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1324000,2004,80.98802395209582,fixed_full_OO_pool,5.745161697421636,1249776790142976000,2711552000,677335296,2159.869725,2159.870274122807 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1328000,2004,76.29740518962076,fixed_full_OO_pool,5.7623949892518835,1253552550838272000,2719744000,679381504,2166.39615,2166.3949488304092 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1332000,2004,80.58882235528942,fixed_full_OO_pool,5.779625971300734,1257328311533568000,2727936000,681427968,2172.920625,2172.920844298246 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1336000,2004,81.3872255489022,fixed_full_OO_pool,5.796857953288903,1261104072228864000,2736128000,683474176,2179.44505,2179.4458114035087 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1340000,2004,79.24151696606786,fixed_full_OO_pool,5.814088664421191,1264879832924160000,2744320000,685520640,2185.970725,2185.9715314327486 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1344000,2004,77.69461077844312,fixed_full_OO_pool,5.831320138627456,1268655593619456000,2752512000,687566848,2192.4966,2192.4962865497077 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1348000,2004,79.79041916167665,fixed_full_OO_pool,5.848551276306519,1272431354314752000,2760704000,689613056,2199.02225,2199.0210745614036 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1352000,2004,79.99001996007983,fixed_full_OO_pool,5.865781463816141,1276207115010048000,2768896000,691659520,2205.549225,2205.5466045321637 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1356000,2004,79.34131736526946,fixed_full_OO_pool,5.88301676708377,1279982875705344000,2777088000,693705728,2212.071925,2212.0718238304094 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1360000,2004,79.29141716566866,fixed_full_OO_pool,5.900248152293885,1283758636400640000,2785280000,695752192,2218.5972,2218.5976023391813 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1364000,2004,80.48902195608783,fixed_full_OO_pool,5.917480252261998,1287534397095936000,2793472000,697798400,2225.11965,2225.1228581871346 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1368000,2004,77.44510978043913,fixed_full_OO_pool,5.934713233558254,1291310157791232000,2801664000,699844864,2231.646725,2231.6483735380116 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1372000,2004,78.3932135728543,fixed_full_OO_pool,5.9519449231101,1295085918486528000,2809856000,701891072,2238.171425,2238.1733004385965 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1376000,2004,79.64071856287424,fixed_full_OO_pool,5.969176612585369,1298861679181824000,2818048000,703937536,2244.698475,2244.6988194444443 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1380000,2004,78.84231536926147,fixed_full_OO_pool,5.986408827528358,1302637439877120000,2826240000,705983744,2251.225825,2251.2233589181287 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1384000,2004,80.58882235528942,fixed_full_OO_pool,6.003640296365031,1306413200572416000,2834432000,708030208,2257.75135,2257.749100877193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1388000,2004,77.54491017964071,fixed_full_OO_pool,6.020867693405599,1310188961267712000,2842624000,710076416,2264.274525,2264.274250730994 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1392000,2004,80.03992015968065,fixed_full_OO_pool,6.0380934186466035,1313964721963008000,2850816000,712122880,2270.802725,2270.799601608187 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1396000,2004,79.89021956087824,fixed_full_OO_pool,6.055319243939594,1317740482658304000,2859008000,714169088,2277.325425,2277.3248209064327 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1400000,2004,80.43912175648703,fixed_full_OO_pool,6.072546244441635,1321516243353600000,2867200000,716215552,2283.849875,2283.8507200292397 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1404000,2004,79.09181636726547,fixed_full_OO_pool,6.089774944339362,1325292004048896000,2875392000,718261760,2290.376375,2290.37538377193 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1408000,2004,80.38922155688623,fixed_full_OO_pool,6.10700117255561,1329067764744192000,2883584000,720308224,2296.901125,2296.9012390350877 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1412000,2004,79.24151696606786,fixed_full_OO_pool,6.124229838462132,1332843525439488000,2891776000,722354432,2303.423775,2303.4264656432747 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1416000,2004,80.938123752495,fixed_full_OO_pool,6.141454235197355,1336619286134784000,2899968000,724400896,2309.950975,2309.951962719298 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1420000,2004,81.08782435129741,fixed_full_OO_pool,6.158683210661014,1340395046830080000,2908160000,726447104,2316.4738,2316.47716374269 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1424000,2004,79.24151696606786,fixed_full_OO_pool,6.175909945917212,1344170807525376000,2916352000,728493312,2323.001475,2323.0016557017543 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1428000,2004,78.2435129740519,fixed_full_OO_pool,6.193137377512952,1347946568220672000,2924544000,730539776,2329.526925,2329.527408625731 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1432000,2004,79.44111776447106,fixed_full_OO_pool,6.210367256986598,1351722328915968000,2932736000,732585984,2336.05215,2336.0522587719297 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1436000,2004,80.688622754491,fixed_full_OO_pool,6.227594681385284,1355498089611264000,2940928000,734632448,2342.57685,2342.578121345029 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1440000,2004,78.79241516966069,fixed_full_OO_pool,6.244823390448259,1359273850306560000,2949120000,736678656,2349.1014,2349.1030701754385 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1444000,2004,81.48702594810379,fixed_full_OO_pool,6.262055199929616,1363049611001856000,2957312000,738725120,2355.6274,2355.6287426900585 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1448000,2004,82.23552894211576,fixed_full_OO_pool,6.279287116921817,1366825371697152000,2965504000,740771328,2362.15255,2362.1536038011695 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1452000,2004,80.03992015968065,fixed_full_OO_pool,6.296516185476341,1370601132392448000,2973696000,742817792,2368.679725,2368.679104532164 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1456000,2004,81.23752495009981,fixed_full_OO_pool,6.3137456668406315,1374376893087744000,2981888000,744864000,2375.204275,2375.204053362573 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1460000,2004,75.79840319361277,fixed_full_OO_pool,6.330972318830383,1378152653783040000,2990080000,746910464,2381.726575,2381.7302668128655 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1464000,2004,78.74251497005989,fixed_full_OO_pool,6.34820352327182,1381928414478336000,2998272000,748956672,2388.25755,2388.2542763157894 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1468000,2004,80.7884231536926,fixed_full_OO_pool,6.36543175364948,1385704175173632000,3006464000,751003136,2394.7818,2394.7802046783627 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1472000,2004,78.1437125748503,fixed_full_OO_pool,6.382656118264422,1389479935868928000,3014656000,753049344,2401.3038,2401.3055263157894 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1476000,2004,81.2874251497006,fixed_full_OO_pool,6.399881884079012,1393255696564224000,3022848000,755095808,2407.83105,2407.8310160818714 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1480000,2004,80.688622754491,fixed_full_OO_pool,6.417111420592086,1397031457259520000,3031040000,757142016,2414.353925,2414.356209795322 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1484000,2004,82.48502994011976,fixed_full_OO_pool,6.434340159597082,1400807217954816000,3039232000,759188480,2420.880325,2420.8818238304093 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1488000,2004,79.99001996007983,fixed_full_OO_pool,6.451570965364161,1404582978650112000,3047424000,761234688,2427.40705,2427.4064546783625 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1492000,2004,77.84431137724552,fixed_full_OO_pool,6.468798626656127,1408358739345408000,3055616000,763281152,2433.932325,2433.9322331871344 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1496000,2004,77.64471057884231,fixed_full_OO_pool,6.4860237875694615,1412134500040704000,3063808000,765327360,2440.456625,2440.4572185672514 +synthetic,loop4x2-phi7.2-wd0.3,loop4x2,791101,0.0001,0.3,7.2,1500000,2004,81.3373253493014,fixed_full_OO_pool,6.5032488311454655,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,256,2004,0.0,fixed_full_OO_pool,0.001168717249400086,241648684498944,524288,131072,0.2523,0.2526733500417711 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,512,2004,0.0,fixed_full_OO_pool,0.00233562495559454,483297368997888,1048576,262144,0.50365,0.5054260651629072 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1000,2004,0.0,fixed_full_OO_pool,0.004561347455407183,943940173824000,2048000,512000,0.987075,0.9868776106934002 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,2000,2004,0.249500998003992,fixed_full_OO_pool,0.009123158437303372,1887880347648000,4096000,1023632,1.974375,1.97296783625731 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,3000,2004,0.09980039920159679,fixed_full_OO_pool,0.013685539276856515,2831820521472000,6144000,1535264,2.960425,2.9591624895572264 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,4000,2004,0.09980039920159679,fixed_full_OO_pool,0.01824736732368668,3775760695296000,8192000,2046896,3.945475,3.945440685045948 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,5000,2004,0.049900199600798396,fixed_full_OO_pool,0.022809656627683177,4719700869120000,10240000,2558528,4.931825,4.9316102756892235 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,6000,2004,0.14970059880239522,fixed_full_OO_pool,0.027370626858125132,5663641042944000,12288000,3070160,5.91605,5.917957393483709 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,7000,2004,0.049900199600798396,fixed_full_OO_pool,0.03193197267026537,6607581216768000,14336000,3581792,6.906125,6.9038157894736845 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,8000,2004,0.249500998003992,fixed_full_OO_pool,0.0364950296913998,7551521390592000,16384000,4093424,7.890175,7.890177527151211 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,9000,2004,0.14970059880239522,fixed_full_OO_pool,0.041056299932921925,8495461564416000,18432000,4605056,8.87215,8.87671261487051 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,10000,2004,0.19960079840319359,fixed_full_OO_pool,0.04561834220877952,9439401738240000,20480000,5116688,9.864275,9.862399749373434 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,11000,2004,0.14970059880239522,fixed_full_OO_pool,0.050176942992127604,10383341912064000,22528000,5628320,10.84815,10.848776106934002 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,12000,2004,0.049900199600798396,fixed_full_OO_pool,0.05473542041352226,11327282085888000,24576000,6139952,11.83435,11.834958228905597 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,13000,2004,0.249500998003992,fixed_full_OO_pool,0.05929359309478766,12271222259712000,26624000,6651584,12.8211,12.82109440267335 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,14000,2004,0.049900199600798396,fixed_full_OO_pool,0.06385197034105658,13215162433536000,28672000,7163216,13.80495,13.807472848788638 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,15000,2004,0.049900199600798396,fixed_full_OO_pool,0.06841142979657484,14159102607360000,30720000,7674848,14.7969,14.793174603174602 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,16000,2004,0.09980039920159679,fixed_full_OO_pool,0.07297122536020147,15103042781184000,32768000,8186480,15.77815,15.779770258980784 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,17000,2004,0.09980039920159679,fixed_full_OO_pool,0.07753015407775012,16046982955008000,34816000,8698112,16.769375,16.765532581453634 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,18000,2004,0.14970059880239522,fixed_full_OO_pool,0.08209026105184522,16990923128832000,36864000,9209744,17.7471,17.752422723475355 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,19000,2004,0.249500998003992,fixed_full_OO_pool,0.08665000985376536,17934863302656000,38912000,9721376,18.74205,18.737873851294903 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,20000,2004,0.09980039920159679,fixed_full_OO_pool,0.09120808630560835,18878803476480000,40960000,10233008,19.72475,19.72434837092732 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,21000,2004,0.14970059880239522,fixed_full_OO_pool,0.09576469048133326,19822743650304000,43008000,10744640,20.711275,20.710503341687552 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,22000,2004,0.14970059880239522,fixed_full_OO_pool,0.10032106439996924,20766683824128000,45056000,11256272,21.697075,21.69671888053467 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,23000,2004,0.19960079840319359,fixed_full_OO_pool,0.10487876621385415,21710623997952000,47104000,11767904,22.68105,22.683086883876356 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,24000,2004,0.09980039920159679,fixed_full_OO_pool,0.10943681045435369,22654564171776000,49152000,12279536,23.66945,23.66908521303258 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,25000,2004,0.09980039920159679,fixed_full_OO_pool,0.11399485171358618,23598504345600000,51200000,12791168,24.65525,24.6553007518797 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,26000,2004,0.14970059880239522,fixed_full_OO_pool,0.11855341842087606,24542444519424000,53248000,13302800,25.6451,25.641177944862154 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,27000,2004,0.09980039920159679,fixed_full_OO_pool,0.12311348688892192,25486384693248000,55296000,13814432,26.625975,26.62780492898914 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,28000,2004,0.14970059880239522,fixed_full_OO_pool,0.12767334101411204,26430324867072000,57344000,14326064,27.6133,27.61389306599833 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,29000,2004,0.249500998003992,fixed_full_OO_pool,0.13223334609530865,27374265040896000,59392000,14837696,28.60135,28.599920634920636 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,30000,2004,0.14970059880239522,fixed_full_OO_pool,0.13679292161328097,28318205214720000,61440000,15349328,29.59035,29.585868838763577 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,31000,2004,0.19960079840319359,fixed_full_OO_pool,0.1413529640208516,29262145388544000,63488000,15860960,30.574025,30.572261904761906 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,32000,2004,0.0,fixed_full_OO_pool,0.14591264876743987,30206085562368000,65536000,16372592,31.556425,31.558761487050962 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,33000,2004,0.09980039920159679,fixed_full_OO_pool,0.15047271836342083,31150025736192000,67584000,16884224,32.542725,32.544935254803676 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,34000,2004,0.09980039920159679,fixed_full_OO_pool,0.15503243690667054,32093965910016000,69632000,17395856,33.532725,33.53079991645781 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,35000,2004,0.19960079840319359,fixed_full_OO_pool,0.15959127818027305,33037906083840000,71680000,17907488,34.516,34.51722639933166 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,36000,2004,0.14970059880239522,fixed_full_OO_pool,0.16415045087846616,33981846257664000,73728000,18419120,35.5008,35.503525480367585 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,37000,2004,0.14970059880239522,fixed_full_OO_pool,0.16870956415620944,34925786431488000,75776000,18930752,36.485475,36.48983500417711 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,38000,2004,0.09980039920159679,fixed_full_OO_pool,0.17326882310211658,35869726605312000,77824000,19442384,37.476925,37.475578529657476 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,39000,2004,0.0,fixed_full_OO_pool,0.1778283672189961,36813666779136000,79872000,19954016,38.456575,38.46230785296575 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,40000,2004,0.09980039920159679,fixed_full_OO_pool,0.18238739636105797,37757606952960000,81920000,20465648,39.448025,39.44805137844612 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,41000,2004,0.249500998003992,fixed_full_OO_pool,0.18694686569376953,38701547126784000,83968000,20977280,40.43455,40.43420634920635 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,42000,2004,0.19960079840319359,fixed_full_OO_pool,0.1915068023869147,39645487300608000,86016000,21488912,41.423575,41.42015246449457 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,43000,2004,0.09980039920159679,fixed_full_OO_pool,0.19606601706809468,40589427474432000,88064000,22000544,42.407,42.4065664160401 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,44000,2004,0.049900199600798396,fixed_full_OO_pool,0.20062572268148263,41533367648256000,90112000,22512176,43.387825,43.393197577276524 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,45000,2004,0.049900199600798396,fixed_full_OO_pool,0.20518629473427102,42477307822080000,92160000,23023808,44.382,44.378713450292395 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,46000,2004,0.049900199600798396,fixed_full_OO_pool,0.20974555324245658,43421247995904000,94208000,23535440,45.367575,45.364947786132 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,47000,2004,0.09980039920159679,fixed_full_OO_pool,0.21430483175752063,44365188169728000,96256000,24047072,46.35905,46.35068922305764 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,48000,2004,0.14970059880239522,fixed_full_OO_pool,0.21886472787190642,45309128343552000,98304000,24558704,47.3395,47.33735171261487 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,49000,2004,0.09980039920159679,fixed_full_OO_pool,0.22342365628522304,46253068517376000,100352000,25070336,48.32365,48.32370509607352 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,50000,2004,0.09980039920159679,fixed_full_OO_pool,0.22798204317171541,47197008691200000,102400000,25581968,49.314,49.30954051796157 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,51000,2004,0.09980039920159679,fixed_full_OO_pool,0.23254031663760544,48140948865024000,104448000,26093600,50.29575,50.29609440267335 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,52000,2004,0.09980039920159679,fixed_full_OO_pool,0.23709939549366632,49084889038848000,106496000,26605232,51.282575,51.28222431077694 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,53000,2004,0.19960079840319359,fixed_full_OO_pool,0.24165699256273607,50028829212672000,108544000,27116864,52.267425,52.268519214703424 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,54000,2004,0.0,fixed_full_OO_pool,0.2462159646778471,50972769386496000,110592000,27628496,53.2517,53.25486215538847 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,55000,2004,0.09980039920159679,fixed_full_OO_pool,0.2507749089536567,51916709560320000,112640000,28140128,54.240525,54.24082497911445 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,56000,2004,0.0,fixed_full_OO_pool,0.2553338685404095,52860649734144000,114688000,28651760,55.2228,55.22733500417711 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,57000,2004,0.14970059880239522,fixed_full_OO_pool,0.2598936413197468,53804589907968000,116736000,29163392,56.212025,56.213264411027566 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,58000,2004,0.14970059880239522,fixed_full_OO_pool,0.2644533824661954,54748530081792000,118784000,29675024,57.1979,57.199473684210524 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,59000,2004,0.09980039920159679,fixed_full_OO_pool,0.26901288211138713,55692470255616000,120832000,30186656,58.1871,58.18540517961571 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,60000,2004,0.049900199600798396,fixed_full_OO_pool,0.27357251120110354,56636410429440000,122880000,30698288,59.17475,59.171466165413534 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,61000,2004,0.14970059880239522,fixed_full_OO_pool,0.27813182550378973,57580350603264000,124928000,31209920,60.15705,60.15797410192147 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,62000,2004,0.14970059880239522,fixed_full_OO_pool,0.2826926136875732,58524290777088000,126976000,31721552,61.1441,61.14408521303258 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,63000,2004,0.049900199600798396,fixed_full_OO_pool,0.28725262627316017,59468230950912000,129024000,32233184,62.127825,62.13047410192147 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,64000,2004,0.0,fixed_full_OO_pool,0.2918116677293761,60412171124736000,131072000,32744816,63.117175,63.11639306599833 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,68000,2004,0.14970059880239522,fixed_full_OO_pool,0.31004756382356086,64187931820032000,139264000,34791344,67.061125,67.0611925647452 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,72000,2004,0.0,fixed_full_OO_pool,0.32828326881759695,67963692515328000,147456000,36837872,71.005925,71.00592105263158 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,76000,2004,0.09980039920159679,fixed_full_OO_pool,0.34651929565084477,71739453210624000,155648000,38884768,74.949575,74.95151420217209 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,80000,2004,0.049900199600798396,fixed_full_OO_pool,0.364756483880596,75515213905920000,163840000,40931296,78.89815,78.89592731829573 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,84000,2004,0.249500998003992,fixed_full_OO_pool,0.38299531458152664,79290974601216000,172032000,42977824,82.84205,82.84073099415205 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,88000,2004,0.14970059880239522,fixed_full_OO_pool,0.40123011325279045,83066735296512000,180224000,45024352,86.786175,86.78551587301587 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,92000,2004,0.14970059880239522,fixed_full_OO_pool,0.4194657295776738,86842495991808000,188416000,47070880,90.73005,90.7303216374269 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,96000,2004,0.249500998003992,fixed_full_OO_pool,0.4377014688526591,90618256687104000,196608000,49117408,94.676525,94.67491019214704 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,100000,2004,0.09980039920159679,fixed_full_OO_pool,0.4559356876172953,94394017382400000,204800000,51163936,98.6235,98.61945697577276 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,104000,2004,0.14970059880239522,fixed_full_OO_pool,0.474170099351969,98169778077696000,212992000,53210464,102.56425,102.5645238095238 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,108000,2004,0.14970059880239522,fixed_full_OO_pool,0.49240460407920184,101945538772992000,221184000,55256992,106.5066,106.50945697577276 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,112000,2004,0.19960079840319359,fixed_full_OO_pool,0.5106395675738653,105721299468288000,229376000,57303520,110.4543,110.45394319131161 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,116000,2004,0.049900199600798396,fixed_full_OO_pool,0.5288756569640504,109497060163584000,237568000,59350048,114.39625,114.39890977443609 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,120000,2004,0.14970059880239522,fixed_full_OO_pool,0.5471122144887017,113272820858880000,245760000,61396576,118.348,118.34305764411027 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,124000,2004,0.0,fixed_full_OO_pool,0.5653478984307084,117048581554176000,253952000,63443104,122.288125,122.28817669172932 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,128000,2004,0.14970059880239522,fixed_full_OO_pool,0.5835822232729859,120824342249472000,262144000,65489632,126.23295,126.23290309106099 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,132000,2004,0.249500998003992,fixed_full_OO_pool,0.6018149038487011,124600102944768000,270336000,67536160,130.1785,130.17756892230577 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,136000,2004,0.19960079840319359,fixed_full_OO_pool,0.6197287581633363,128375863640064000,278528000,69582688,134.123125,134.1223120300752 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,140000,2004,0.14970059880239522,fixed_full_OO_pool,0.6376421858173692,132151624335360000,286720000,71629216,138.068175,138.06701963241437 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,144000,2004,0.09980039920159679,fixed_full_OO_pool,0.6555591009598639,135927385030656000,294912000,73675744,142.011775,142.0118483709273 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,148000,2004,0.14970059880239522,fixed_full_OO_pool,0.6734756056188296,139703145725952000,303104000,75722640,145.9561,145.9573851294904 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,152000,2004,0.14970059880239522,fixed_full_OO_pool,0.6913945470957292,143478906421248000,311296000,77769168,149.90305,149.90193400167084 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,156000,2004,0.19960079840319359,fixed_full_OO_pool,0.7093121220968249,147254667116544000,319488000,79815696,153.8477,153.84667502088556 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,160000,2004,0.09980039920159679,fixed_full_OO_pool,0.7272271961698101,151030427811840000,327680000,81862224,157.793675,157.79130534670009 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,164000,2004,0.0,fixed_full_OO_pool,0.7451451445039776,154806188507136000,335872000,83908752,161.73125,161.7366374269006 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,168000,2004,0.249500998003992,fixed_full_OO_pool,0.7630630648519016,158581949202432000,344064000,85955280,165.68395,165.6807059314954 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,172000,2004,0.0,fixed_full_OO_pool,0.7809826795880993,162357709897728000,352256000,88001808,169.623225,169.62589598997494 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,176000,2004,0.09980039920159679,fixed_full_OO_pool,0.7988979404792189,166133470593024000,360448000,90048336,173.570325,173.57043233082706 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,180000,2004,0.249500998003992,fixed_full_OO_pool,0.8168125315859086,169909231288320000,368640000,92094864,177.5097,177.5156140350877 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,184000,2004,0.049900199600798396,fixed_full_OO_pool,0.8347281923496889,173684991983616000,376832000,94141392,181.454675,181.46032790309107 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,188000,2004,0.09980039920159679,fixed_full_OO_pool,0.8526449102215055,177460752678912000,385024000,96187920,185.401775,185.4048642439432 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,192000,2004,0.09980039920159679,fixed_full_OO_pool,0.8705623356014904,181236513374208000,393216000,98234448,189.346675,189.34958437761068 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,196000,2004,0.14970059880239522,fixed_full_OO_pool,0.8884800889994949,185012274069504000,401408000,100280976,193.293425,193.2941499582289 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,200000,2004,0.14970059880239522,fixed_full_OO_pool,0.9063971639714308,188788034764800000,409600000,102327504,197.237125,197.23897034252298 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,204000,2004,0.09980039920159679,fixed_full_OO_pool,0.9243142120198657,192563795460096000,417792000,104374032,201.1831,201.1836006683375 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,208000,2004,0.049900199600798396,fixed_full_OO_pool,0.9422299498029881,196339556155392000,425984000,106420560,205.129375,205.12820593149542 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,212000,2004,0.14970059880239522,fixed_full_OO_pool,0.9601457472507738,200115316850688000,434176000,108467088,209.074025,209.0729469507101 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,216000,2004,0.249500998003992,fixed_full_OO_pool,0.9780626590653426,203891077545984000,442368000,110513616,213.017225,213.01780910609858 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,220000,2004,0.14970059880239522,fixed_full_OO_pool,0.9959784137519697,207666838241280000,450560000,112560512,216.961725,216.9633312447786 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,224000,2004,0.19960079840319359,fixed_full_OO_pool,1.0138954393234518,211442598936576000,458752000,114607040,220.908375,220.9079051796157 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,228000,2004,0.09980039920159679,fixed_full_OO_pool,1.0318134776430412,215218359631872000,466944000,116653568,224.85025,224.85287802840435 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,232000,2004,0.0,fixed_full_OO_pool,1.0497248986487586,218994120327168000,475136000,118700096,228.7979,228.79736842105262 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,236000,2004,0.09980039920159679,fixed_full_OO_pool,1.0676371192642384,222769881022464000,483328000,120746624,232.7386,232.7424394319131 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,240000,2004,0.049900199600798396,fixed_full_OO_pool,1.0855454001803364,226545641717760000,491520000,122793152,236.6863,236.68692564745197 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,244000,2004,0.09980039920159679,fixed_full_OO_pool,1.1034591545143888,230321402413056000,499712000,124839680,240.6318,240.6315956558062 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,248000,2004,0.29940119760479045,fixed_full_OO_pool,1.121372279609657,234097163108352000,507904000,126886208,244.5788,244.57614035087718 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,252000,2004,0.39920159680638717,fixed_full_OO_pool,1.1392845255012314,237872923803648000,516096000,128932736,248.51955,248.52120718462822 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,256000,2004,0.049900199600798396,fixed_full_OO_pool,1.1571975869685411,241648684498944000,524288000,130979264,252.4649,252.46588972431078 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,260000,2004,0.049900199600798396,fixed_full_OO_pool,1.1751136978798442,245424445194240000,532480000,133025792,256.409675,256.4106203007519 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,264000,2004,0.29940119760479045,fixed_full_OO_pool,1.1930245572618312,249200205889536000,540672000,135072320,260.35665,260.3551670843776 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,268000,2004,0.09980039920159679,fixed_full_OO_pool,1.2109364016768005,252975966584832000,548864000,137118848,264.299525,264.30005639097743 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,272000,2004,0.14970059880239522,fixed_full_OO_pool,1.2288509384646185,256751727280128000,557056000,139165376,268.24625,268.2446240601504 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,276000,2004,0.09980039920159679,fixed_full_OO_pool,1.2467643729897422,260527487975424000,565248000,141211904,272.1865,272.1897326649958 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,280000,2004,0.14970059880239522,fixed_full_OO_pool,1.2646794795917553,264303248670720000,573440000,143258432,276.13645,276.13403091060985 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,284000,2004,0.09980039920159679,fixed_full_OO_pool,1.2825958159503836,268079009366016000,581632000,145304960,280.07945,280.0789097744361 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,288000,2004,0.14970059880239522,fixed_full_OO_pool,1.300508505176339,271854770061312000,589824000,147351488,284.0238,284.0236758563074 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,292000,2004,0.19960079840319359,fixed_full_OO_pool,1.3184232291186022,275630530756608000,598016000,149398384,287.970075,287.9690497076023 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,296000,2004,0.09980039920159679,fixed_full_OO_pool,1.3363388140261587,279406291451904000,606208000,151444912,291.9136,291.9138847117795 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,300000,2004,0.09980039920159679,fixed_full_OO_pool,1.354255857601141,283182052147200000,614400000,153491440,295.857875,295.85865705931496 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,304000,2004,0.049900199600798396,fixed_full_OO_pool,1.3721706959481041,286957812842496000,622592000,155537968,299.8069,299.80303258145364 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,308000,2004,0.249500998003992,fixed_full_OO_pool,1.3900847101014935,290733573537792000,630784000,157584496,303.747125,303.7481432748538 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,312000,2004,0.14970059880239522,fixed_full_OO_pool,1.407998432741604,294509334233088000,638976000,159631024,307.69255,307.6928195488722 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,316000,2004,0.29940119760479045,fixed_full_OO_pool,1.4259134060103031,298285094928384000,647168000,161677552,311.6346,311.6377777777778 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,320000,2004,0.09980039920159679,fixed_full_OO_pool,1.4438315839930955,302060855623680000,655360000,163724080,315.581525,315.58232873851296 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,324000,2004,0.14970059880239522,fixed_full_OO_pool,1.4617490635915762,305836616318976000,663552000,165770608,319.52895,319.5268379281537 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,328000,2004,0.049900199600798396,fixed_full_OO_pool,1.4796661105358766,309612377014272000,671744000,167817136,323.471125,323.4717857142857 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,332000,2004,0.09980039920159679,fixed_full_OO_pool,1.4975836226250976,313388137709568000,679936000,169863664,327.4165,327.4164661654135 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,336000,2004,0.19960079840319359,fixed_full_OO_pool,1.5155013612336996,317163898404864000,688128000,171910192,331.355625,331.3616687552214 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,340000,2004,0.14970059880239522,fixed_full_OO_pool,1.5334188756543314,320939659100160000,696320000,173956720,335.303475,335.30614243943194 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,344000,2004,0.09980039920159679,fixed_full_OO_pool,1.551335530064793,324715419795456000,704512000,176003248,339.25255,339.25051378446113 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,348000,2004,0.14970059880239522,fixed_full_OO_pool,1.5692517427944888,328491180490752000,712704000,178049776,343.192875,343.1956161236424 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,352000,2004,0.29940119760479045,fixed_full_OO_pool,1.5871677517063087,332266941186048000,720896000,180096304,347.1385,347.1402756892231 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,356000,2004,0.19960079840319359,fixed_full_OO_pool,1.605081792274076,336042701881344000,729088000,182142832,351.085725,351.08480158730157 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,360000,2004,0.249500998003992,fixed_full_OO_pool,1.6229997991087537,339818462576640000,737280000,184189360,355.028775,355.02967627401836 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,364000,2004,0.19960079840319359,fixed_full_OO_pool,1.640915298635761,343594223271936000,745472000,186236256,358.976375,358.9749394319131 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,368000,2004,0.39920159680638717,fixed_full_OO_pool,1.6588327904769944,347369983967232000,753664000,188282784,362.919475,362.91980994152044 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,372000,2004,0.34930139720558884,fixed_full_OO_pool,1.676750807567603,351145744662528000,761856000,190329312,366.8682,366.8642105263158 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,376000,2004,0.049900199600798396,fixed_full_OO_pool,1.6946671254808705,354921505357824000,770048000,192375840,370.8088,370.80928989139517 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,380000,2004,0.14970059880239522,fixed_full_OO_pool,1.71258403293478,358697266053120000,778240000,194422368,374.7552,374.75388471177945 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,384000,2004,0.249500998003992,fixed_full_OO_pool,1.7305017597321422,362473026748416000,786432000,196468896,378.6998,378.6986299081036 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,388000,2004,0.14970059880239522,fixed_full_OO_pool,1.7484193550640097,366248787443712000,794624000,198515424,382.645675,382.643268588137 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,392000,2004,0.09980039920159679,fixed_full_OO_pool,1.7663372999522835,370024548139008000,802816000,200561952,386.59005,386.58803258145366 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,396000,2004,0.049900199600798396,fixed_full_OO_pool,1.7842537995903855,373800308834304000,811008000,202608480,390.531375,390.5330513784461 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,400000,2004,0.19960079840319359,fixed_full_OO_pool,1.8021696691059819,377576069529600000,819200000,204655008,394.4778,394.47764411027566 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,404000,2004,0.14970059880239522,fixed_full_OO_pool,1.820086518122504,381351830224896000,827392000,206701536,398.4209,398.42251461988303 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,408000,2004,0.14970059880239522,fixed_full_OO_pool,1.8380037142088015,385127590920192000,835584000,208748064,402.3652,402.3672848788638 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,412000,2004,0.049900199600798396,fixed_full_OO_pool,1.8559205953631963,388903351615488000,843776000,210794592,406.310375,406.3119820384294 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,416000,2004,0.14970059880239522,fixed_full_OO_pool,1.8738364375279182,392679112310784000,851968000,212841120,410.2534,410.25685881370094 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,420000,2004,0.09980039920159679,fixed_full_OO_pool,1.8917514908944981,396454873006080000,860160000,214887648,414.19845,414.2015664160401 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,424000,2004,0.14970059880239522,fixed_full_OO_pool,1.9096680853557255,400230633701376000,868352000,216934176,418.146375,418.1460338345865 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,428000,2004,0.09980039920159679,fixed_full_OO_pool,1.9275847126429693,404006394396672000,876544000,218980704,422.090775,422.0907957393484 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,432000,2004,0.0,fixed_full_OO_pool,1.9455009425876455,407782155091968000,884736000,221027232,426.035375,426.0355409356725 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,436000,2004,0.249500998003992,fixed_full_OO_pool,1.96341635704144,411557915787264000,892928000,223074128,429.9817,429.980910609858 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,440000,2004,0.049900199600798396,fixed_full_OO_pool,1.9813352121661107,415333676482560000,901120000,225120656,433.92495,433.92576858813703 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,444000,2004,0.19960079840319359,fixed_full_OO_pool,1.9992538082071891,419109437177856000,909312000,227167184,437.87045,437.8704385964912 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,448000,2004,0.14970059880239522,fixed_full_OO_pool,2.017169565909232,422885197873152000,917504000,229213712,441.815125,441.8151775271512 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,452000,2004,0.14970059880239522,fixed_full_OO_pool,2.035086616904785,426660958568448000,925696000,231260240,445.76015,445.7598872180451 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,456000,2004,0.19960079840319359,fixed_full_OO_pool,2.0530032278804313,430436719263744000,933888000,233306768,449.7051,449.70460317460316 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,460000,2004,0.09980039920159679,fixed_full_OO_pool,2.0709211006243198,434212479959040000,942080000,235353296,453.648775,453.64942564745195 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,464000,2004,0.34930139720558884,fixed_full_OO_pool,2.0888385412904125,437988240654336000,950272000,237399824,457.594375,457.5940873015873 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,468000,2004,0.34930139720558884,fixed_full_OO_pool,2.1067553371356595,441764001349632000,958464000,239446352,461.538475,461.5388742690059 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,472000,2004,0.049900199600798396,fixed_full_OO_pool,2.124672174109146,445539762044928000,966656000,241492880,465.48515,465.48344611528825 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,476000,2004,0.19960079840319359,fixed_full_OO_pool,2.14258917723058,449315522740224000,974848000,243539408,469.427525,469.42837719298245 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,480000,2004,0.249500998003992,fixed_full_OO_pool,2.1605047850248713,453091283435520000,983040000,245585936,473.37755,473.3726691729323 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,484000,2004,0.249500998003992,fixed_full_OO_pool,2.178420652752328,456867044130816000,991232000,247632464,477.320225,477.3175751879699 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,488000,2004,0.14970059880239522,fixed_full_OO_pool,2.1963360046657425,460642804826112000,999424000,249678992,481.2619,481.2625647451963 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,492000,2004,0.049900199600798396,fixed_full_OO_pool,2.2142518571577967,464418565521408000,1007616000,251725520,485.207775,485.20720342522975 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,496000,2004,0.14970059880239522,fixed_full_OO_pool,2.2321681803009574,468194326216704000,1015808000,253772048,489.149375,489.1521992481203 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,500000,2004,0.29940119760479045,fixed_full_OO_pool,2.2500820422596814,471970086912000000,1024000000,255818576,493.096825,493.09670634920633 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,504000,2004,0.29940119760479045,fixed_full_OO_pool,2.2679963092785327,475745847607296000,1032192000,257865104,497.042875,497.0413304093567 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,508000,2004,0.049900199600798396,fixed_full_OO_pool,2.2859106543432506,479521608302592000,1040384000,259912000,500.986925,500.9868901420217 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,512000,2004,0.0,fixed_full_OO_pool,2.3038262342506397,483297368997888000,1048576000,261958528,504.931675,504.93162280701756 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,516000,2004,0.09980039920159679,fixed_full_OO_pool,2.3217447646593468,487073129693184000,1056768000,264005056,508.8765,508.87634920634923 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,520000,2004,0.14970059880239522,fixed_full_OO_pool,2.339662991663855,490848890388480000,1064960000,266051584,512.823775,512.8208709273183 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,524000,2004,0.39920159680638717,fixed_full_OO_pool,2.357578923664987,494624651083776000,1073152000,268098112,516.7655,516.7658563074352 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,528000,2004,0.19960079840319359,fixed_full_OO_pool,2.3754952196414685,498400411779072000,1081344000,270144640,520.70885,520.7107059314955 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,532000,2004,0.19960079840319359,fixed_full_OO_pool,2.393410760804804,502176172474368000,1089536000,272191168,524.654275,524.6553822055138 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,536000,2004,0.249500998003992,fixed_full_OO_pool,2.4113263355495613,505951933169664000,1097728000,274237696,528.603875,528.5997096908939 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,540000,2004,0.049900199600798396,fixed_full_OO_pool,2.429241803633049,509727693864960000,1105920000,276284224,532.5465,532.5446198830409 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,544000,2004,0.19960079840319359,fixed_full_OO_pool,2.447157690692693,513503454560256000,1114112000,278330752,536.48995,536.4894611528822 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,548000,2004,0.39920159680638717,fixed_full_OO_pool,2.4650729912529803,517279215255552000,1122304000,280377280,540.431275,540.4344799498747 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,552000,2004,0.29940119760479045,fixed_full_OO_pool,2.4829889976274635,521054975950848000,1130496000,282423808,544.3753,544.3792731829574 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,556000,2004,0.14970059880239522,fixed_full_OO_pool,2.5009054039542873,524830736646144000,1138688000,284470336,548.323625,548.3237071846282 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,560000,2004,0.19960079840319359,fixed_full_OO_pool,2.5188203318820643,528606497341440000,1146880000,286516864,552.26875,552.2684085213033 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,564000,2004,0.049900199600798396,fixed_full_OO_pool,2.5367355400427347,532382258036736000,1155072000,288563392,556.21375,556.2131203007518 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,568000,2004,0.14970059880239522,fixed_full_OO_pool,2.5546513442136347,536158018732032000,1163264000,290609920,560.155375,560.1581140350877 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,572000,2004,0.09980039920159679,fixed_full_OO_pool,2.5725676123518495,539933779427328000,1171456000,292656448,564.104575,564.1024749373433 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,576000,2004,0.09980039920159679,fixed_full_OO_pool,2.5904840758194525,543709540122624000,1179648000,294702976,568.047425,568.0473663324979 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,580000,2004,0.09980039920159679,fixed_full_OO_pool,2.608398867404709,547485300817920000,1187840000,296749872,571.9923,571.9928571428571 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,584000,2004,0.14970059880239522,fixed_full_OO_pool,2.6263162726505347,551261061513216000,1196032000,298796400,575.93655,575.9376315789474 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,588000,2004,0.19960079840319359,fixed_full_OO_pool,2.6442344737425447,555036822208512000,1204224000,300842928,579.882575,579.8822577276525 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,592000,2004,0.049900199600798396,fixed_full_OO_pool,2.6621526592566322,558812582903808000,1212416000,302889456,583.82895,583.8268546365915 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,596000,2004,0.19960079840319359,fixed_full_OO_pool,2.6800674166944294,562588343599104000,1220608000,304935984,587.77205,587.7717251461988 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,600000,2004,0.19960079840319359,fixed_full_OO_pool,2.6979832893165034,566364104294400000,1228800000,306982512,591.717225,591.7164223057645 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,604000,2004,0.049900199600798396,fixed_full_OO_pool,2.7158984691556545,570139864989696000,1236992000,309029040,595.66345,595.6610317460318 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,608000,2004,0.14970059880239522,fixed_full_OO_pool,2.7338133527907647,573915625684992000,1245184000,311075568,599.610825,599.605545112782 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,612000,2004,0.14970059880239522,fixed_full_OO_pool,2.751728501395426,577691386380288000,1253376000,313122096,603.55215,603.5505639097744 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,616000,2004,0.249500998003992,fixed_full_OO_pool,2.769644809395282,581467147075584000,1261568000,315168624,607.497025,607.4952861319966 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,620000,2004,0.14970059880239522,fixed_full_OO_pool,2.7875604179553273,585242907770880000,1269760000,317215152,611.435875,611.4405116959065 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,624000,2004,0.34930139720558884,fixed_full_OO_pool,2.8054767335361492,589018668466176000,1277952000,319261680,615.384475,615.3849227234754 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,628000,2004,0.049900199600798396,fixed_full_OO_pool,2.823391894698143,592794429161472000,1286144000,321308208,619.331575,619.3294590643275 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,632000,2004,0.09980039920159679,fixed_full_OO_pool,2.8413067262040244,596570189856768000,1294336000,323354736,623.275275,623.2742794486215 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,636000,2004,0.29940119760479045,fixed_full_OO_pool,2.8592220829675594,600345950552064000,1302528000,325401264,627.22015,627.2190016708438 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,640000,2004,0.0,fixed_full_OO_pool,2.8771366009405916,604121711247360000,1310720000,327447792,631.16145,631.1640225563909 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,644000,2004,0.19960079840319359,fixed_full_OO_pool,2.8950513365564663,607897471942656000,1318912000,329494320,635.106525,635.1087280701754 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,648000,2004,0.14970059880239522,fixed_full_OO_pool,2.9129657486598526,611673232637952000,1327104000,331540848,639.05425,639.0532121971596 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,652000,2004,0.19960079840319359,fixed_full_OO_pool,2.93088001320449,615448993333248000,1335296000,333587744,642.9987,642.998738512949 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,656000,2004,0.249500998003992,fixed_full_OO_pool,2.948796902951888,619224754028544000,1343488000,335634272,646.94255,646.9435463659148 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,660000,2004,0.09980039920159679,fixed_full_OO_pool,2.9667115095444023,623000514723840000,1351680000,337680800,650.8878,650.8882372598162 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,664000,2004,0.09980039920159679,fixed_full_OO_pool,2.9846277278889386,626776275419136000,1359872000,339727328,654.829725,654.8332059314954 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,668000,2004,0.14970059880239522,fixed_full_OO_pool,3.0025430799824084,630552036114432000,1368064000,341773856,658.774175,658.7779636591479 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,672000,2004,0.19960079840319359,fixed_full_OO_pool,3.020457231139557,634327796809728000,1376256000,343820384,662.72285,662.7223684210526 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,676000,2004,0.09980039920159679,fixed_full_OO_pool,3.0383700771805726,638103557505024000,1384448000,345866912,666.668325,666.6670405179616 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,680000,2004,0.09980039920159679,fixed_full_OO_pool,3.0562858240099415,641879318200320000,1392640000,347913440,670.610725,670.6119695071011 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,684000,2004,0.249500998003992,fixed_full_OO_pool,3.074200089639053,645655078895616000,1400832000,349959968,674.56125,674.5562197159566 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,688000,2004,0.09980039920159679,fixed_full_OO_pool,3.0921167018833673,649430839590912000,1409024000,352006496,678.501,678.5013700918964 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,692000,2004,0.09980039920159679,fixed_full_OO_pool,3.110031614339807,653206600286208000,1417216000,354053024,682.449675,682.4457748538011 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,696000,2004,0.19960079840319359,fixed_full_OO_pool,3.1279455999491943,656982360981504000,1425408000,356099552,686.387625,686.3910756056808 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,700000,2004,0.14970059880239522,fixed_full_OO_pool,3.14586108455124,660758121676800000,1433600000,358146080,690.3337,690.3356975772765 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,704000,2004,0.14970059880239522,fixed_full_OO_pool,3.163777151975988,664533882372096000,1441792000,360192608,694.278975,694.2803863826232 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,708000,2004,0.19960079840319359,fixed_full_OO_pool,3.1816911736968905,668309643067392000,1449984000,362239136,698.221375,698.2253153717627 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,712000,2004,0.09980039920159679,fixed_full_OO_pool,3.199605086888704,672085403762688000,1458176000,364285664,702.165875,702.1700689223057 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,716000,2004,0.14970059880239522,fixed_full_OO_pool,3.2175198842905877,675861164457984000,1466368000,366332192,706.11495,706.114440267335 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,720000,2004,0.09980039920159679,fixed_full_OO_pool,3.235435280689142,679636925153280000,1474560000,368378720,710.05715,710.0593859649123 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,724000,2004,0.049900199600798396,fixed_full_OO_pool,3.2533523957545145,683412685848576000,1482752000,370425248,714.00345,714.0039891395155 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,728000,2004,0.09980039920159679,fixed_full_OO_pool,3.271267098515398,687188446543872000,1490944000,372472144,717.9495,717.9493817878028 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,732000,2004,0.14970059880239522,fixed_full_OO_pool,3.289184891980969,690964207239168000,1499136000,374518672,721.892425,721.8942669172932 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,736000,2004,0.249500998003992,fixed_full_OO_pool,3.307100647031847,694739967934464000,1507328000,376565200,725.835325,725.8391541353384 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,740000,2004,0.09980039920159679,fixed_full_OO_pool,3.325014204059003,698515728629760000,1515520000,378611728,729.7834,729.7836090225564 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,744000,2004,0.14970059880239522,fixed_full_OO_pool,3.3429291475139973,702291489325056000,1523712000,380658256,733.73045,733.728149540518 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,748000,2004,0.14970059880239522,fixed_full_OO_pool,3.360841631763097,706067250020352000,1531904000,382704784,737.67405,737.6729782790309 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,752000,2004,0.249500998003992,fixed_full_OO_pool,3.378754197816468,709843010715648000,1540096000,384751312,741.614875,741.6180388471178 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,756000,2004,0.14970059880239522,fixed_full_OO_pool,3.3966682688157177,713618771410944000,1548288000,386797840,745.562975,745.5624916457812 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,760000,2004,0.049900199600798396,fixed_full_OO_pool,3.4145813220801453,717394532106240000,1556480000,388844368,749.50745,749.5072472848789 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,764000,2004,0.09980039920159679,fixed_full_OO_pool,3.432496515393464,721170292801536000,1564672000,390890896,753.451575,753.4520321637427 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,768000,2004,0.19960079840319359,fixed_full_OO_pool,3.450412023205103,724946053496832000,1572864000,392937424,757.396875,757.3967188805346 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,772000,2004,0.09980039920159679,fixed_full_OO_pool,3.4683280867679667,728721814192128000,1581056000,394983952,761.3477,761.3409440267335 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,776000,2004,0.14970059880239522,fixed_full_OO_pool,3.48624362187874,732497574887424000,1589248000,397030480,765.2836,765.2864160401002 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,780000,2004,0.049900199600798396,fixed_full_OO_pool,3.504159277739624,736273335582720000,1597440000,399077008,769.231825,769.23085839599 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,784000,2004,0.19960079840319359,fixed_full_OO_pool,3.5220748744108197,740049096278016000,1605632000,401123536,773.177075,773.1755492898914 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,788000,2004,0.14970059880239522,fixed_full_OO_pool,3.539989704515578,743824856973312000,1613824000,403170064,777.12325,777.1201629072682 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,792000,2004,0.14970059880239522,fixed_full_OO_pool,3.5579039686255984,747600617668608000,1622016000,405216592,781.06215,781.0653842940685 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,796000,2004,0.049900199600798396,fixed_full_OO_pool,3.5758183680319537,751376378363904000,1630208000,407263120,785.008825,785.0099561403508 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,800000,2004,0.049900199600798396,fixed_full_OO_pool,3.593733368377305,755152139059200000,1638400000,409310016,788.954475,788.9553822055137 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,804000,2004,0.19960079840319359,fixed_full_OO_pool,3.6116484584410986,758927899754496000,1646592000,411356544,792.899625,792.9000814536341 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,808000,2004,0.14970059880239522,fixed_full_OO_pool,3.6295642102675307,762703660449792000,1654784000,413403072,796.84425,796.8448245614035 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,812000,2004,0.249500998003992,fixed_full_OO_pool,3.647474931286027,766479421145088000,1662976000,415449600,800.7904,800.789440267335 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,816000,2004,0.0,fixed_full_OO_pool,3.6653886010363284,770255181840384000,1671168000,417496128,804.731925,804.7344423558898 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,820000,2004,0.14970059880239522,fixed_full_OO_pool,3.6833027545093664,774030942535680000,1679360000,419542656,808.679125,808.678970342523 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,824000,2004,0.0,fixed_full_OO_pool,3.7012151756313525,777806703230976000,1687552000,421589184,812.630275,812.6231683375105 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,828000,2004,0.049900199600798396,fixed_full_OO_pool,3.719127903725538,781582463926272000,1695744000,423635712,816.567525,816.5685275689223 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,832000,2004,0.09980039920159679,fixed_full_OO_pool,3.7370422602558717,785358224621568000,1703936000,425682240,820.5127,820.5132247284879 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,836000,2004,0.0,fixed_full_OO_pool,3.754954500214921,789133985316864000,1712128000,427728768,824.457475,824.457955304929 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,840000,2004,0.249500998003992,fixed_full_OO_pool,3.7728709781832164,792909746012160000,1720320000,429775296,828.404825,828.4024707602339 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,844000,2004,0.09980039920159679,fixed_full_OO_pool,3.7907860751325884,796685506707456000,1728512000,431821824,832.34465,832.3476148705096 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,848000,2004,0.19960079840319359,fixed_full_OO_pool,3.808701850284512,800461267402752000,1736704000,433868352,836.29,836.2922974101922 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,852000,2004,0.09980039920159679,fixed_full_OO_pool,3.826614641415783,804237028098048000,1744896000,435914880,840.23675,840.2368629908103 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,856000,2004,0.09980039920159679,fixed_full_OO_pool,3.8445298906198393,808012788793344000,1753088000,437961408,844.181075,844.1816311612364 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,860000,2004,0.0,fixed_full_OO_pool,3.862442976676135,811788549488640000,1761280000,440007936,848.122725,848.1266228070175 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,864000,2004,0.049900199600798396,fixed_full_OO_pool,3.880356576230584,815564310183936000,1769472000,442054464,852.071675,852.0710045948204 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,868000,2004,0.09980039920159679,fixed_full_OO_pool,3.8982684574669433,819340070879232000,1777664000,444100992,856.0158,856.0157894736842 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,872000,2004,0.049900199600798396,fixed_full_OO_pool,3.9161817195639013,823115831574528000,1785856000,446147888,859.96205,859.9611654135339 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,876000,2004,0.09980039920159679,fixed_full_OO_pool,3.9340978788843173,826891592269824000,1794048000,448194416,863.9046,863.906081871345 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,880000,2004,0.09980039920159679,fixed_full_OO_pool,3.952014320142981,830667352965120000,1802240000,450240944,867.8483,867.8509022556391 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,884000,2004,0.049900199600798396,fixed_full_OO_pool,3.9699284332628464,834443113660416000,1810432000,452287472,871.7936,871.7955889724311 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,888000,2004,0.049900199600798396,fixed_full_OO_pool,3.9878420214758563,838218874355712000,1818624000,454334000,875.74015,875.740171261487 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,892000,2004,0.19960079840319359,fixed_full_OO_pool,4.005754337917185,841994635051008000,1826816000,456380528,879.684725,879.6849185463659 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,896000,2004,0.0,fixed_full_OO_pool,4.023668972654268,845770395746304000,1835008000,458427056,883.629625,883.6296386800334 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,900000,2004,0.14970059880239522,fixed_full_OO_pool,4.041585035819767,849546156441600000,1843200000,460473584,887.576225,887.5742167919799 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,904000,2004,0.0,fixed_full_OO_pool,4.0595009055723335,853321917136896000,1851392000,462520112,891.5183,891.5191729323308 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,908000,2004,0.049900199600798396,fixed_full_OO_pool,4.077417202255585,857097677832192000,1859584000,464566640,895.4646,895.463776106934 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,912000,2004,0.09980039920159679,fixed_full_OO_pool,4.095333140663182,860873438527488000,1867776000,466613168,899.404325,899.4089285714285 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,916000,2004,0.0,fixed_full_OO_pool,4.113248905779587,864649199222784000,1875968000,468659696,903.3485,903.353709273183 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,920000,2004,0.09980039920159679,fixed_full_OO_pool,4.131163670296471,868424959918080000,1884160000,470706224,907.300975,907.2977965747702 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,924000,2004,0.049900199600798396,fixed_full_OO_pool,4.149078861039339,872200720613376000,1892352000,472752752,911.24055,911.2429615705931 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,928000,2004,0.09980039920159679,fixed_full_OO_pool,4.166993323472432,875976481308672000,1900544000,474799280,915.183425,915.187850877193 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,932000,2004,0.0,fixed_full_OO_pool,4.1849068856818805,879752242003968000,1908736000,476845808,919.129725,919.1324540517961 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,936000,2004,0.14970059880239522,fixed_full_OO_pool,4.202822113616599,883528002699264000,1916928000,478892336,923.0733,923.0772848788638 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,940000,2004,0.09980039920159679,fixed_full_OO_pool,4.220738427319254,887303763394560000,1925120000,480938864,927.021375,927.0217397660819 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,944000,2004,0.09980039920159679,fixed_full_OO_pool,4.23865456020977,891079524089856000,1933312000,482985760,930.967325,930.9671407685881 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,948000,2004,0.09980039920159679,fixed_full_OO_pool,4.2565737472940235,894855284785152000,1941504000,485032288,934.911025,934.9119611528822 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,952000,2004,0.049900199600798396,fixed_full_OO_pool,4.274490821912057,898631045480448000,1949696000,487078816,938.855925,938.8566812865497 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,956000,2004,0.19960079840319359,fixed_full_OO_pool,4.29240709210746,902406806175744000,1957888000,489125344,942.80195,942.8013074352548 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,960000,2004,0.19960079840319359,fixed_full_OO_pool,4.310321502445473,906182566871040000,1966080000,491171872,946.743375,946.7463178780284 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,964000,2004,0.14970059880239522,fixed_full_OO_pool,4.3282371047791095,909958327566336000,1974272000,493218400,950.6899,950.6909022556391 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,968000,2004,0.049900199600798396,fixed_full_OO_pool,4.346151704557447,913734088261632000,1982464000,495264928,954.637525,954.6353947368422 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,972000,2004,0.049900199600798396,fixed_full_OO_pool,4.3640666509512815,917509848956928000,1990656000,497311456,958.580225,958.5802986633249 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,976000,2004,0.14970059880239522,fixed_full_OO_pool,4.381980859709697,921285609652224000,1998848000,499357984,962.52365,962.525142021721 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,980000,2004,0.0,fixed_full_OO_pool,4.3998929891569745,925061370347520000,2007040000,501404512,966.4709,966.4696658312448 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,984000,2004,0.14970059880239522,fixed_full_OO_pool,4.417805733118827,928837131042816000,2015232000,503451040,970.415575,970.4144047619047 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,988000,2004,0.049900199600798396,fixed_full_OO_pool,4.435720277301346,932612891738112000,2023424000,505497568,974.361225,974.3590622389306 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,992000,2004,0.09980039920159679,fixed_full_OO_pool,4.45363422660571,936388652433408000,2031616000,507544096,978.3049,978.3038847117795 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,996000,2004,0.09980039920159679,fixed_full_OO_pool,4.471571549942924,940164413128704000,2039808000,509590624,982.248225,982.2487364243943 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1000000,2004,0.09980039920159679,fixed_full_OO_pool,4.489486000163273,943940173824000000,2048000000,511637152,986.195875,986.1932268170426 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1004000,2004,0.049900199600798396,fixed_full_OO_pool,4.507604242756756,947715934519296000,2056192000,513683680,990.135225,990.1384106098579 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1008000,2004,0.14970059880239522,fixed_full_OO_pool,4.525519925067202,951491695214592000,2064384000,515730208,994.08265,994.0829197994988 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1012000,2004,0.049900199600798396,fixed_full_OO_pool,4.543435578392819,955267455909888000,2072576000,517776736,998.028575,998.0275543024227 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1016000,2004,0.09980039920159679,fixed_full_OO_pool,4.5613504680152985,959043216605184000,2080768000,519823632,1001.9733,1001.9730576441103 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1020000,2004,0.0,fixed_full_OO_pool,4.579267312053384,962818977300480000,2088960000,521870160,1005.917875,1005.9178049289891 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1024000,2004,0.049900199600798396,fixed_full_OO_pool,4.597184806054251,966594737995776000,2097152000,523916688,1009.86135,1009.8626441102757 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1028000,2004,0.19960079840319359,fixed_full_OO_pool,4.616454491789142,970370498691072000,2105344000,525963216,1013.81015,1013.8070384294068 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1032000,2004,0.049900199600798396,fixed_full_OO_pool,4.63892211835314,974146259386368000,2113536000,528009744,1017.7512,1017.7520802005013 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1036000,2004,0.09980039920159679,fixed_full_OO_pool,4.662956045063005,977922020081664000,2121728000,530056272,1021.6979,1021.6966499582289 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1040000,2004,0.049900199600798396,fixed_full_OO_pool,4.686046332715907,981697780776960000,2129920000,532102800,1025.6447,1025.6412113617378 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1044000,2004,0.09980039920159679,fixed_full_OO_pool,4.707509076084114,985473541472256000,2138112000,534149328,1029.582225,1029.5865476190477 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1048000,2004,0.14970059880239522,fixed_full_OO_pool,4.726307694443191,989249302167552000,2146304000,536195856,1033.533375,1033.5307456140351 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1052000,2004,0.09980039920159679,fixed_full_OO_pool,4.744223248899604,993025062862848000,2154496000,538242384,1037.474425,1037.4757873851295 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1056000,2004,0.049900199600798396,fixed_full_OO_pool,4.762139427386638,996800823558144000,2162688000,540288912,1041.4197,1041.4204761904762 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1060000,2004,0.049900199600798396,fixed_full_OO_pool,4.7800533878668725,1000576584253440000,2170880000,542335440,1045.3671,1045.3649874686716 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1064000,2004,0.14970059880239522,fixed_full_OO_pool,4.797968458223881,1004352344948736000,2179072000,544381968,1049.308725,1049.3099812030075 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1068000,2004,0.049900199600798396,fixed_full_OO_pool,4.815882355389703,1008128105644032000,2187264000,546428496,1053.255825,1053.2545175438597 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1072000,2004,0.049900199600798396,fixed_full_OO_pool,4.8337972272446175,1011903866339328000,2195456000,548475024,1057.200675,1057.1992418546365 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1076000,2004,0.049900199600798396,fixed_full_OO_pool,4.851710468460288,1015679627034624000,2203648000,550521552,1061.14525,1061.1439891395155 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1080000,2004,0.14970059880239522,fixed_full_OO_pool,4.869626164207649,1019455387729920000,2211840000,552568080,1065.0906,1065.088671679198 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1084000,2004,0.09980039920159679,fixed_full_OO_pool,4.887539140368915,1023231148425216000,2220032000,554614608,1069.033425,1069.0335651629073 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1088000,2004,0.049900199600798396,fixed_full_OO_pool,4.905451101805601,1027006909120512000,2228224000,556661504,1072.97815,1072.9790685045948 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1092000,2004,0.049900199600798396,fixed_full_OO_pool,4.923366745381306,1030782669815808000,2236416000,558708032,1076.9228,1076.9238095238095 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1096000,2004,0.14970059880239522,fixed_full_OO_pool,4.941283587019684,1034558430511104000,2244608000,560754560,1080.86855,1080.8684586466165 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1100000,2004,0.049900199600798396,fixed_full_OO_pool,4.959198602857068,1038334191206400000,2252800000,562801088,1084.81295,1084.8132205513784 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1104000,2004,0.0,fixed_full_OO_pool,4.9771135302374345,1042109951901696000,2260992000,564847616,1088.7569,1088.7580200501254 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1108000,2004,0.14970059880239522,fixed_full_OO_pool,4.995027189511392,1045885712596992000,2269184000,566894144,1092.7006,1092.7028404344194 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1112000,2004,0.049900199600798396,fixed_full_OO_pool,5.012941937151675,1049661473292288000,2277376000,568940672,1096.645475,1096.6475626566416 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1116000,2004,0.09980039920159679,fixed_full_OO_pool,5.030856574496461,1053437233987584000,2285568000,570987200,1100.59075,1100.5922514619883 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1120000,2004,0.09980039920159679,fixed_full_OO_pool,5.048771356189002,1057212994682880000,2293760000,573033728,1104.535475,1104.536986215539 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1124000,2004,0.0,fixed_full_OO_pool,5.06668534670646,1060988755378176000,2301952000,575080256,1108.48175,1108.4815914786968 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1128000,2004,0.0,fixed_full_OO_pool,5.0845986233806855,1064764516073472000,2310144000,577126784,1112.4267,1112.4263074352548 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1132000,2004,0.14970059880239522,fixed_full_OO_pool,5.10251045241745,1068540276768768000,2318336000,579173312,1116.37075,1116.3710985797827 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1136000,2004,0.0,fixed_full_OO_pool,5.120424664011225,1072316037464064000,2326528000,581219840,1120.3142,1120.315939849624 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1140000,2004,0.0,fixed_full_OO_pool,5.138338944870565,1076091798159360000,2334720000,583266368,1124.262825,1124.2603487886383 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1144000,2004,0.0,fixed_full_OO_pool,5.156252794128118,1079867558854656000,2342912000,585312896,1128.20475,1128.2053174603175 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1148000,2004,0.14970059880239522,fixed_full_OO_pool,5.174166402680179,1083643319549952000,2351104000,587359424,1132.151575,1132.1498767752714 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1152000,2004,0.0,fixed_full_OO_pool,5.192080778844861,1087419080245248000,2359296000,589405952,1136.096025,1136.094634502924 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1156000,2004,0.09980039920159679,fixed_full_OO_pool,5.209992836975596,1091194840940544000,2367488000,591452480,1140.04075,1140.0393692564746 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1160000,2004,0.0,fixed_full_OO_pool,5.227905868443971,1094970601635840000,2375680000,593499376,1143.985525,1143.9848684210526 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1164000,2004,0.049900199600798396,fixed_full_OO_pool,5.24582277033478,1098746362331136000,2383872000,595545904,1147.9281,1147.9297827903092 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1168000,2004,0.09980039920159679,fixed_full_OO_pool,5.263739656233746,1102522123026432000,2392064000,597592432,1151.874475,1151.874379699248 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1172000,2004,0.0,fixed_full_OO_pool,5.281653629411012,1106297883721728000,2400256000,599638960,1155.8181,1155.8192063492063 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1176000,2004,0.049900199600798396,fixed_full_OO_pool,5.299568274511645,1110073644417024000,2408448000,601685488,1159.766625,1159.7636236424394 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1180000,2004,0.0,fixed_full_OO_pool,5.31748321799044,1113849405112320000,2416640000,603732016,1163.708525,1163.7085944026733 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1184000,2004,0.049900199600798396,fixed_full_OO_pool,5.335397925866354,1117625165807616000,2424832000,605778544,1167.653325,1167.6533228905598 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1188000,2004,0.049900199600798396,fixed_full_OO_pool,5.353311900384724,1121400926502912000,2433024000,607825072,1171.5965,1171.598187134503 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1192000,2004,0.0,fixed_full_OO_pool,5.371226863374726,1125176687198208000,2441216000,609871600,1175.54945,1175.5422347535505 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1196000,2004,0.19960079840319359,fixed_full_OO_pool,5.389141121681573,1128952447893504000,2449408000,611918128,1179.482225,1179.4879678362572 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1200000,2004,0.049900199600798396,fixed_full_OO_pool,5.407057110924895,1132728208588800000,2457600000,613964656,1183.43255,1183.4322347535506 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1204000,2004,0.049900199600798396,fixed_full_OO_pool,5.424972090117841,1136503969284096000,2465792000,616011184,1187.37685,1187.3770050125313 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1208000,2004,0.19960079840319359,fixed_full_OO_pool,5.44288644112957,1140279729979392000,2473984000,618057712,1191.32125,1191.3217669172932 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1212000,2004,0.14970059880239522,fixed_full_OO_pool,5.460801560878753,1144055490674688000,2482176000,620104240,1195.266975,1195.266418128655 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1216000,2004,0.09980039920159679,fixed_full_OO_pool,5.478715492668044,1147831251369984000,2490368000,622150768,1199.2107,1199.2112364243944 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1220000,2004,0.14970059880239522,fixed_full_OO_pool,5.496630277811653,1151607012065280000,2498560000,624197296,1203.155175,1203.155992063492 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1224000,2004,0.09980039920159679,fixed_full_OO_pool,5.514544245494116,1155382772760576000,2506752000,626243824,1207.10105,1207.1006307435255 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1228000,2004,0.09980039920159679,fixed_full_OO_pool,5.5324577997914615,1159158533455872000,2514944000,628290352,1211.044575,1211.0454657477026 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1232000,2004,0.09980039920159679,fixed_full_OO_pool,5.550370807770847,1162934294151168000,2523136000,630337248,1214.991175,1214.990812447786 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1236000,2004,0.0,fixed_full_OO_pool,5.568285915327983,1166710054846464000,2531328000,632383776,1218.93465,1218.9356516290727 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1240000,2004,0.0,fixed_full_OO_pool,5.5862014741750645,1170485815541760000,2539520000,634430304,1222.88165,1222.8801963241438 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1244000,2004,0.049900199600798396,fixed_full_OO_pool,5.604118669141704,1174261576237056000,2547712000,636476832,1226.8233,1226.8251879699249 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1248000,2004,0.049900199600798396,fixed_full_OO_pool,5.622032906505176,1178037336932352000,2555904000,638523360,1230.767425,1230.7699728487887 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1252000,2004,0.09980039920159679,fixed_full_OO_pool,5.639946917558296,1181813097627648000,2564096000,640569888,1234.716775,1234.7143212197159 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1256000,2004,0.049900199600798396,fixed_full_OO_pool,5.657861557361773,1185588858322944000,2572288000,642616416,1238.65755,1238.6593859649122 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1260000,2004,0.049900199600798396,fixed_full_OO_pool,5.675775871324457,1189364619018240000,2580480000,644662944,1242.605825,1242.6038241436925 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1264000,2004,0.09980039920159679,fixed_full_OO_pool,5.693690672851064,1193140379713536000,2588672000,646709472,1246.551375,1246.5484899749374 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1268000,2004,0.049900199600798396,fixed_full_OO_pool,5.7116052843185345,1196916140408832000,2596864000,648756000,1250.49465,1250.4933458646617 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1272000,2004,0.09980039920159679,fixed_full_OO_pool,5.7295208923249605,1200691901104128000,2605056000,650802528,1254.440825,1254.4379594820384 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1276000,2004,0.049900199600798396,fixed_full_OO_pool,5.74743475651679,1204467661799424000,2613248000,652849056,1258.380575,1258.3831098579783 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1280000,2004,0.14970059880239522,fixed_full_OO_pool,5.765349173221944,1208243422494720000,2621440000,654895584,1262.326625,1262.3277339181286 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1284000,2004,0.049900199600798396,fixed_full_OO_pool,5.783263702887214,1212019183190016000,2629632000,656942112,1266.2734,1266.272297410192 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1288000,2004,0.14970059880239522,fixed_full_OO_pool,5.80117856680726,1215794943885312000,2637824000,658988640,1270.216,1270.217209690894 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1292000,2004,0.09980039920159679,fixed_full_OO_pool,5.819089563587267,1219570704580608000,2646016000,661035168,1274.16425,1274.161649958229 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1296000,2004,0.0,fixed_full_OO_pool,5.837003405913711,1223346465275904000,2654208000,663081696,1278.107275,1278.1065267335005 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1300000,2004,0.14970059880239522,fixed_full_OO_pool,5.854916395106249,1227122225971200000,2662400000,665128224,1282.052775,1282.0511967418547 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1304000,2004,0.14970059880239522,fixed_full_OO_pool,5.872828692726584,1230897986666496000,2670592000,667175120,1285.99695,1285.996746031746 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1308000,2004,0.049900199600798396,fixed_full_OO_pool,5.89074553353919,1234673747361792000,2678784000,669221648,1289.943825,1289.9413011695906 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1312000,2004,0.049900199600798396,fixed_full_OO_pool,5.9086611648235055,1238449508057088000,2686976000,671268176,1293.885575,1293.8862844611529 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1316000,2004,0.049900199600798396,fixed_full_OO_pool,5.926576083514632,1242225268752384000,2695168000,673314704,1297.83205,1297.830873015873 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1320000,2004,0.049900199600798396,fixed_full_OO_pool,5.944488766986049,1246001029447680000,2703360000,675361232,1301.776525,1301.7756286549707 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1324000,2004,0.049900199600798396,fixed_full_OO_pool,5.962401722107703,1249776790142976000,2711552000,677407760,1305.71995,1305.7204720133668 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1328000,2004,0.049900199600798396,fixed_full_OO_pool,5.980315307066259,1253552550838272000,2719744000,679454288,1309.66595,1309.6651002506267 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1332000,2004,0.09980039920159679,fixed_full_OO_pool,5.998227891251445,1257328311533568000,2727936000,681500816,1313.608425,1313.6100229741019 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1336000,2004,0.0,fixed_full_OO_pool,6.016141494313876,1261104072228864000,2736128000,683547344,1317.55605,1317.554515455305 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1340000,2004,0.0,fixed_full_OO_pool,6.0340537738179165,1264879832924160000,2744320000,685593872,1321.500425,1321.4992794486216 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1344000,2004,0.09980039920159679,fixed_full_OO_pool,6.0519668999366045,1268655593619456000,2752512000,687640400,1325.44465,1325.4440559732666 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1348000,2004,0.049900199600798396,fixed_full_OO_pool,6.069878847586612,1272431354314752000,2760704000,689686928,1329.390675,1329.3886821219717 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1352000,2004,0.09980039920159679,fixed_full_OO_pool,6.087791504314583,1276207115010048000,2768896000,691733456,1333.3321,1333.3336925647452 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1356000,2004,0.049900199600798396,fixed_full_OO_pool,6.105703536066123,1279982875705344000,2777088000,693779984,1337.2783,1337.2783040935672 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1360000,2004,0.14970059880239522,fixed_full_OO_pool,6.123616181731017,1283758636400640000,2785280000,695826512,1341.223275,1341.2230179615706 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1364000,2004,0.14970059880239522,fixed_full_OO_pool,6.141530177107908,1287534397095936000,2793472000,697873040,1345.168925,1345.1676754385965 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1368000,2004,0.0,fixed_full_OO_pool,6.159444055634861,1291310157791232000,2801664000,699919568,1349.1133,1349.1124394319131 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1372000,2004,0.049900199600798396,fixed_full_OO_pool,6.1773575236524145,1295085918486528000,2809856000,701966096,1353.05585,1353.0573558897242 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1376000,2004,0.049900199600798396,fixed_full_OO_pool,6.195271096102273,1298861679181824000,2818048000,704012624,1357.0021,1357.001963241437 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1380000,2004,0.09980039920159679,fixed_full_OO_pool,6.2131842498429535,1302637439877120000,2826240000,706059520,1360.94845,1360.9473308270676 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1384000,2004,0.049900199600798396,fixed_full_OO_pool,6.231101282835007,1306413200572416000,2834432000,708106048,1364.892525,1364.892119883041 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1388000,2004,0.0,fixed_full_OO_pool,6.249017132718323,1310188961267712000,2842624000,710152576,1368.837575,1368.8368274853801 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1392000,2004,0.09980039920159679,fixed_full_OO_pool,6.266930815824825,1313964721963008000,2850816000,712199104,1372.7806,1372.7817042606516 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1396000,2004,0.14970059880239522,fixed_full_OO_pool,6.2848444732785635,1317740482658304000,2859008000,714245632,1376.724925,1376.7264724310776 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1400000,2004,0.14970059880239522,fixed_full_OO_pool,6.302758035521126,1321516243353600000,2867200000,716292160,1380.67005,1380.6711737677526 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1404000,2004,0.049900199600798396,fixed_full_OO_pool,6.320671968253122,1325292004048896000,2875392000,718338688,1384.613375,1384.6160254803676 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1408000,2004,0.09980039920159679,fixed_full_OO_pool,6.33858495264935,1329067764744192000,2883584000,720385216,1388.5613,1388.560492898914 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1412000,2004,0.049900199600798396,fixed_full_OO_pool,6.35649849616612,1332843525439488000,2891776000,722431744,1392.5033,1392.505455304929 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1416000,2004,0.09980039920159679,fixed_full_OO_pool,6.374411517486183,1336619286134784000,2899968000,724478272,1396.450525,1396.4499812030076 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1420000,2004,0.049900199600798396,fixed_full_OO_pool,6.392323878551316,1340395046830080000,2908160000,726524800,1400.391675,1400.395014619883 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1424000,2004,0.09980039920159679,fixed_full_OO_pool,6.4102364989101055,1344170807525376000,2916352000,728571328,1404.34155,1404.3393191311613 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1428000,2004,0.14970059880239522,fixed_full_OO_pool,6.42814960602464,1347946568220672000,2924544000,730617856,1408.2827,1408.2843525480368 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1432000,2004,0.14970059880239522,fixed_full_OO_pool,6.446062152993141,1351722328915968000,2932736000,732664384,1412.23435,1412.22850877193 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1436000,2004,0.19960079840319359,fixed_full_OO_pool,6.463975820564148,1355498089611264000,2940928000,734710912,1416.171725,1416.1738575605682 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1440000,2004,0.0,fixed_full_OO_pool,6.4818893370539366,1359273850306560000,2949120000,736757440,1420.1182,1420.1184461152882 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1444000,2004,0.09980039920159679,fixed_full_OO_pool,6.499802824280535,1363049611001856000,2957312000,738803968,1424.063875,1424.0631015037593 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1448000,2004,0.09980039920159679,fixed_full_OO_pool,6.517715552912818,1366825371697152000,2965504000,740850496,1428.00755,1428.0079239766083 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1452000,2004,0.049900199600798396,fixed_full_OO_pool,6.5356294313901,1370601132392448000,2973696000,742897392,1431.9544,1431.9532497911446 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1456000,2004,0.049900199600798396,fixed_full_OO_pool,6.55354465023304,1374376893087744000,2981888000,744943920,1435.89715,1435.898149540518 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1460000,2004,0.049900199600798396,fixed_full_OO_pool,6.571460117766013,1378152653783040000,2990080000,746990448,1439.84305,1439.8427861319967 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1464000,2004,0.09980039920159679,fixed_full_OO_pool,6.58937293136182,1381928414478336000,2998272000,749036976,1443.78635,1443.7876399331662 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1468000,2004,0.049900199600798396,fixed_full_OO_pool,6.607285919862075,1385704175173632000,3006464000,751083504,1447.735625,1447.7319945697577 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1472000,2004,0.049900199600798396,fixed_full_OO_pool,6.625199513812032,1389479935868928000,3014656000,753130032,1451.678875,1451.6768525480368 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1476000,2004,0.049900199600798396,fixed_full_OO_pool,6.643112945972631,1393255696564224000,3022848000,755176560,1455.620375,1455.6218567251462 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1480000,2004,0.14970059880239522,fixed_full_OO_pool,6.661028312680622,1397031457259520000,3031040000,757223088,1459.563975,1459.566685463659 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1484000,2004,0.049900199600798396,fixed_full_OO_pool,6.678942034814714,1400807217954816000,3039232000,759269616,1463.51195,1463.511148705096 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1488000,2004,0.14970059880239522,fixed_full_OO_pool,6.696855047175454,1404582978650112000,3047424000,761316144,1467.45765,1467.4558020050126 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1492000,2004,0.09980039920159679,fixed_full_OO_pool,6.714768589878869,1408358739345408000,3055616000,763362672,1471.4006,1471.4006850459482 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1496000,2004,0.049900199600798396,fixed_full_OO_pool,6.732682191608474,1412134500040704000,3063808000,765409200,1475.346,1475.3453634085213 +synthetic,standard8-phi12.6-wd0.1,standard8,791101,0.0001,0.1,12.6,1500000,2004,0.0,fixed_full_OO_pool,6.750595387809185,1415910260736000000,3072000000,767455728,1479.289375,1479.2902109440267 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,256,2004,0.0,fixed_full_OO_pool,0.0011706445335100094,241648684498944,524288,131072,0.738675,0.7421418128654971 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,512,2004,0.0,fixed_full_OO_pool,0.0023407850062681567,483297368997888,1048576,261792,1.4825,1.480204678362573 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1000,2004,0.14970059880239522,fixed_full_OO_pool,0.004565025034050147,943940173824000,2048000,511296,2.89215,2.8918859649122806 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,2000,2004,0.09980039920159679,fixed_full_OO_pool,0.009126192908734083,1887880347648000,4096000,1022240,5.7857,5.7807894736842105 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,3000,2004,0.0,fixed_full_OO_pool,0.013685612995177508,2831820521472000,6144000,1533184,8.6757,8.670730994152047 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,4000,2004,0.09980039920159679,fixed_full_OO_pool,0.01824382469058037,3775760695296000,8192000,2044128,11.562675,11.56155701754386 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,5000,2004,0.19960079840319359,fixed_full_OO_pool,0.022801594528266127,4719700869120000,10240000,2555072,14.4528,14.451461988304093 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,6000,2004,0.19960079840319359,fixed_full_OO_pool,0.027359417335440714,5663641042944000,12288000,3066016,17.3402,17.342163742690058 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,7000,2004,0.249500998003992,fixed_full_OO_pool,0.03191706686280668,6607581216768000,14336000,3576960,20.2311,20.23184210526316 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,8000,2004,0.14970059880239522,fixed_full_OO_pool,0.03647458082892829,7551521390592000,16384000,4087904,23.12215,23.121476608187134 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,9000,2004,0.049900199600798396,fixed_full_OO_pool,0.041032745123116506,8495461564416000,18432000,4598848,26.011525,26.011600877192983 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,10000,2004,0.0,fixed_full_OO_pool,0.04559123446544011,9439401738240000,20480000,5110144,28.903575,28.903516081871345 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,11000,2004,0.14970059880239522,fixed_full_OO_pool,0.05015728196129203,10383341912064000,22528000,5621088,31.793675,31.7934283625731 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,12000,2004,0.09980039920159679,fixed_full_OO_pool,0.054723433970163264,11327282085888000,24576000,6132032,34.683625,34.68338450292398 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,13000,2004,0.14970059880239522,fixed_full_OO_pool,0.05929004018505414,12271222259712000,26624000,6642976,37.572925,37.573530701754386 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,14000,2004,0.14970059880239522,fixed_full_OO_pool,0.06385714583305849,13215162433536000,28672000,7153920,40.45805,40.464897660818714 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,15000,2004,0.14970059880239522,fixed_full_OO_pool,0.06842472059548729,14159102607360000,30720000,7664864,43.354575,43.352931286549705 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,16000,2004,0.09980039920159679,fixed_full_OO_pool,0.07299238820560276,15103042781184000,32768000,8175808,46.243725,46.24312134502924 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,17000,2004,0.29940119760479045,fixed_full_OO_pool,0.07755512591037485,16046982955008000,34816000,8686752,49.133,49.13327485380117 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,18000,2004,0.14970059880239522,fixed_full_OO_pool,0.08212278444526924,16990923128832000,36864000,9197696,52.0224,52.0233918128655 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,19000,2004,0.19960079840319359,fixed_full_OO_pool,0.08668953751006889,17934863302656000,38912000,9708992,54.9153,54.91505847953216 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,20000,2004,0.19960079840319359,fixed_full_OO_pool,0.09125744511683782,18878803476480000,40960000,10219936,57.806875,57.80453947368421 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,21000,2004,0.09980039920159679,fixed_full_OO_pool,0.09582510810655852,19822743650304000,43008000,10730880,60.697725,60.69423245614035 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,22000,2004,0.19960079840319359,fixed_full_OO_pool,0.10039271690365341,20766683824128000,45056000,11241824,63.58775,63.58416666666667 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,23000,2004,0.09980039920159679,fixed_full_OO_pool,0.1049594568575008,21710623997952000,47104000,11752768,66.477375,66.47421783625731 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,24000,2004,0.049900199600798396,fixed_full_OO_pool,0.1095253594385253,22654564171776000,49152000,12263712,69.365,69.36485380116959 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,25000,2004,0.19960079840319359,fixed_full_OO_pool,0.11409177423454821,23598504345600000,51200000,12774656,72.2516,72.25578947368422 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,26000,2004,0.09980039920159679,fixed_full_OO_pool,0.1186586219434523,24542444519424000,53248000,13285600,75.1447,75.14482456140351 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,27000,2004,0.19960079840319359,fixed_full_OO_pool,0.12322480800561607,25486384693248000,55296000,13796544,78.034875,78.0347149122807 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,28000,2004,0.14970059880239522,fixed_full_OO_pool,0.12779200479698677,26430324867072000,57344000,14307840,80.9273,80.92652046783626 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,29000,2004,0.049900199600798396,fixed_full_OO_pool,0.13236004274752405,27374265040896000,59392000,14818784,83.8138,83.81748538011696 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,30000,2004,0.19960079840319359,fixed_full_OO_pool,0.13692776349476643,28318205214720000,61440000,15329728,86.705675,86.70687865497077 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,31000,2004,0.249500998003992,fixed_full_OO_pool,0.14149521950528854,29262145388544000,63488000,15840672,89.596875,89.59646929824561 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,32000,2004,0.09980039920159679,fixed_full_OO_pool,0.14606169839907024,30206085562368000,65536000,16351616,92.488375,92.48597222222222 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,33000,2004,0.09980039920159679,fixed_full_OO_pool,0.15062539507117537,31150025736192000,67584000,16862560,95.377875,95.37605994152047 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,34000,2004,0.249500998003992,fixed_full_OO_pool,0.15519220255004862,32093965910016000,69632000,17373504,98.266,98.26654970760234 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,35000,2004,0.19960079840319359,fixed_full_OO_pool,0.15975894428065254,33037906083840000,71680000,17884448,101.154825,101.15683479532164 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,36000,2004,0.049900199600798396,fixed_full_OO_pool,0.16432542206409076,33981846257664000,73728000,18395392,104.046475,104.04629385964913 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,37000,2004,0.249500998003992,fixed_full_OO_pool,0.1688934143922395,34925786431488000,75776000,18906688,106.93695,106.93866959064327 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,38000,2004,0.19960079840319359,fixed_full_OO_pool,0.17346102679562236,35869726605312000,77824000,19417632,109.8284,109.82818713450293 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,39000,2004,0.249500998003992,fixed_full_OO_pool,0.1780287222853965,36813666779136000,79872000,19928576,112.720025,112.71765350877193 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,40000,2004,0.14970059880239522,fixed_full_OO_pool,0.18259684225854775,37757606952960000,81920000,20439520,115.60865,115.6079970760234 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,41000,2004,0.09980039920159679,fixed_full_OO_pool,0.18716392863645323,38701547126784000,83968000,20950464,118.497425,118.49829678362573 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,42000,2004,0.14970059880239522,fixed_full_OO_pool,0.19173134563490749,39645487300608000,86016000,21461408,121.388075,121.38804824561403 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,43000,2004,0.09980039920159679,fixed_full_OO_pool,0.19629864661850863,40589427474432000,88064000,21972352,124.281475,124.27699561403509 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,44000,2004,0.09980039920159679,fixed_full_OO_pool,0.2008657580231213,41533367648256000,90112000,22483296,127.16835,127.16785087719298 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,45000,2004,0.09980039920159679,fixed_full_OO_pool,0.2054338884084589,42477307822080000,92160000,22994240,130.0571,130.05815789473684 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,46000,2004,0.19960079840319359,fixed_full_OO_pool,0.21000129392784503,43421247995904000,94208000,23505536,132.9483,132.9503216374269 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,47000,2004,0.14970059880239522,fixed_full_OO_pool,0.2145687043045958,44365188169728000,96256000,24016480,135.8419,135.83921052631578 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,48000,2004,0.249500998003992,fixed_full_OO_pool,0.21913670417024858,45309128343552000,98304000,24527424,138.728775,138.73006578947368 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,49000,2004,0.0,fixed_full_OO_pool,0.22370430554573734,46253068517376000,100352000,25038368,141.6183,141.6201461988304 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,50000,2004,0.19960079840319359,fixed_full_OO_pool,0.22827067486320932,47197008691200000,102400000,25549312,144.50795,144.51019005847954 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,51000,2004,0.19960079840319359,fixed_full_OO_pool,0.23283899073489012,48140948865024000,104448000,26060256,147.395725,147.4007821637427 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,52000,2004,0.09980039920159679,fixed_full_OO_pool,0.23740648465541503,49084889038848000,106496000,26571200,150.289325,150.28967105263158 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,53000,2004,0.049900199600798396,fixed_full_OO_pool,0.24197304487331875,50028829212672000,108544000,27082144,153.174725,153.1809576023392 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,54000,2004,0.19960079840319359,fixed_full_OO_pool,0.24653920672316518,50972769386496000,110592000,27593088,156.0696,156.06947368421052 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,55000,2004,0.049900199600798396,fixed_full_OO_pool,0.25110526122049326,51916709560320000,112640000,28104384,158.960125,158.96183479532164 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,56000,2004,0.049900199600798396,fixed_full_OO_pool,0.2556720750292556,52860649734144000,114688000,28615328,161.851925,161.85125 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,57000,2004,0.09980039920159679,fixed_full_OO_pool,0.26023943309051295,53804589907968000,116736000,29126272,164.74035,164.74165204678363 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,58000,2004,0.14970059880239522,fixed_full_OO_pool,0.26480607146397234,54748530081792000,118784000,29637216,167.629,167.63198830409357 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,59000,2004,0.09980039920159679,fixed_full_OO_pool,0.2693728504836973,55692470255616000,120832000,30148160,170.520425,170.52151315789473 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,60000,2004,0.09980039920159679,fixed_full_OO_pool,0.2739393530672209,56636410429440000,122880000,30659104,173.4141,173.41038011695906 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,61000,2004,0.249500998003992,fixed_full_OO_pool,0.27850621772412626,57580350603264000,124928000,31170048,176.30215,176.3008918128655 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,62000,2004,0.19960079840319359,fixed_full_OO_pool,0.2830728464325269,58524290777088000,126976000,31680992,179.18975,179.1915350877193 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,63000,2004,0.14970059880239522,fixed_full_OO_pool,0.2876393449565189,59468230950912000,129024000,32191936,182.0821,182.0807894736842 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,64000,2004,0.19960079840319359,fixed_full_OO_pool,0.2922056198803087,60412171124736000,131072000,32703232,184.9739,184.97277777777776 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,68000,2004,0.39920159680638717,fixed_full_OO_pool,0.3104654658140822,64187931820032000,139264000,34747008,196.534775,196.5322880116959 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,72000,2004,0.049900199600798396,fixed_full_OO_pool,0.32873190972436633,67963692515328000,147456000,36790784,208.096325,208.09160087719297 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,76000,2004,0.249500998003992,fixed_full_OO_pool,0.34699823803061414,71739453210624000,155648000,38834912,219.65295,219.6549269005848 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,80000,2004,0.14970059880239522,fixed_full_OO_pool,0.3652647178320007,75515213905920000,163840000,40878688,231.214275,231.21430555555557 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,84000,2004,0.249500998003992,fixed_full_OO_pool,0.38353044820432036,79290974601216000,172032000,42922816,242.7747,242.77652046783626 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,88000,2004,0.09980039920159679,fixed_full_OO_pool,0.40179638259526756,83066735296512000,180224000,44966592,254.3344,254.33637426900586 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,92000,2004,0.14970059880239522,fixed_full_OO_pool,0.4200649022290276,86842495991808000,188416000,47010720,265.89915,265.89732456140354 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,96000,2004,0.19960079840319359,fixed_full_OO_pool,0.4383329612027026,90618256687104000,196608000,49054496,277.4587,277.45722222222224 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,100000,2004,0.09980039920159679,fixed_full_OO_pool,0.45659791871905325,94394017382400000,204800000,51098272,289.017125,289.01744883040936 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,104000,2004,0.249500998003992,fixed_full_OO_pool,0.4748620733028899,98169778077696000,212992000,53142400,300.580475,300.57880847953214 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,108000,2004,0.19960079840319359,fixed_full_OO_pool,0.4931269037185444,101945538772992000,221184000,55186176,312.1393,312.13891812865495 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,112000,2004,0.14970059880239522,fixed_full_OO_pool,0.5113915901537984,105721299468288000,229376000,57230304,323.6992,323.7012865497076 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,116000,2004,0.19960079840319359,fixed_full_OO_pool,0.5296583630206684,109497060163584000,237568000,59274080,335.257625,335.26151315789474 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,120000,2004,0.39920159680638717,fixed_full_OO_pool,0.5479241184621222,113272820858880000,245760000,61318208,346.81975,346.823230994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,124000,2004,0.19960079840319359,fixed_full_OO_pool,0.5661910204848067,117048581554176000,253952000,63361984,358.385525,358.38130847953215 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,128000,2004,0.249500998003992,fixed_full_OO_pool,0.5844584561180737,120824342249472000,262144000,65406112,369.943925,369.94411549707604 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,132000,2004,0.049900199600798396,fixed_full_OO_pool,0.6027233599902441,124600102944768000,270336000,67449888,381.506125,381.50323830409354 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,136000,2004,0.14970059880239522,fixed_full_OO_pool,0.6209913136468579,128375863640064000,278528000,69493664,393.0647,393.06342105263155 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,140000,2004,0.14970059880239522,fixed_full_OO_pool,0.6392586862771875,132151624335360000,286720000,71537792,404.627725,404.6248757309942 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,144000,2004,0.14970059880239522,fixed_full_OO_pool,0.6575270433258266,135927385030656000,294912000,73581568,416.1857,416.18523391812863 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,148000,2004,0.249500998003992,fixed_full_OO_pool,0.6757929868675354,139703145725952000,303104000,75625696,427.74555,427.7476169590643 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,152000,2004,0.19960079840319359,fixed_full_OO_pool,0.6940583181815843,143478906421248000,311296000,77669472,439.308125,439.30663011695907 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,156000,2004,0.049900199600798396,fixed_full_OO_pool,0.7123253130612688,147254667116544000,319488000,79713600,450.867875,450.8690423976608 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,160000,2004,0.049900199600798396,fixed_full_OO_pool,0.7305924145732489,151030427811840000,327680000,81757376,462.431225,462.4278289473684 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,164000,2004,0.14970059880239522,fixed_full_OO_pool,0.7488590802324728,154806188507136000,335872000,83801504,473.99045,473.9903947368421 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,168000,2004,0.049900199600798396,fixed_full_OO_pool,0.7671258247467793,158581949202432000,344064000,85845280,485.55075,485.5500730994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,172000,2004,0.39920159680638717,fixed_full_OO_pool,0.7853920349002712,162357709897728000,352256000,87889056,497.10955,497.11019005847953 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,176000,2004,0.09980039920159679,fixed_full_OO_pool,0.8036554815951321,166133470593024000,360448000,89933184,508.672125,508.6717763157895 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,180000,2004,0.09980039920159679,fixed_full_OO_pool,0.8219211109851797,169909231288320000,368640000,91976960,520.233225,520.2312207602339 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,184000,2004,0.249500998003992,fixed_full_OO_pool,0.8401862754931466,173684991983616000,376832000,94021088,531.794675,531.7931359649123 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,188000,2004,0.19960079840319359,fixed_full_OO_pool,0.8584507455842363,177460752678912000,385024000,96064864,543.356125,543.3524780701755 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,192000,2004,0.19960079840319359,fixed_full_OO_pool,0.876714944947097,181236513374208000,393216000,98108992,554.91525,554.9150730994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,196000,2004,0.249500998003992,fixed_full_OO_pool,0.894980403776798,185012274069504000,401408000,100152768,566.4763,566.4745321637427 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,200000,2004,0.19960079840319359,fixed_full_OO_pool,0.9132492024172097,188788034764800000,409600000,102196544,578.03335,578.0351608187135 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,204000,2004,0.14970059880239522,fixed_full_OO_pool,0.9315172847888122,192563795460096000,417792000,104240672,589.596175,589.5966739766081 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,208000,2004,0.19960079840319359,fixed_full_OO_pool,0.9497844908396816,196339556155392000,425984000,106284448,601.15555,601.1566228070176 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,212000,2004,0.249500998003992,fixed_full_OO_pool,0.9680477907032602,200115316850688000,434176000,108328576,612.716425,612.7187061403508 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,216000,2004,0.14970059880239522,fixed_full_OO_pool,0.9863159963881803,203891077545984000,442368000,110372352,624.279825,624.2774780701754 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,220000,2004,0.29940119760479045,fixed_full_OO_pool,1.0045803471499433,207666838241280000,450560000,112416480,635.838275,635.8402704678363 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,224000,2004,0.09980039920159679,fixed_full_OO_pool,1.0228443607905258,211442598936576000,458752000,114460256,647.398675,647.3999195906433 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,228000,2004,0.249500998003992,fixed_full_OO_pool,1.0411070513373448,215218359631872000,466944000,116504384,658.963125,658.9609576023391 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,232000,2004,0.09980039920159679,fixed_full_OO_pool,1.059373033499966,218994120327168000,475136000,118548160,670.5206,670.521461988304 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,236000,2004,0.14970059880239522,fixed_full_OO_pool,1.0776384110810857,222769881022464000,483328000,120591936,682.080625,682.0812207602339 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,240000,2004,0.19960079840319359,fixed_full_OO_pool,1.0959039880407768,226545641717760000,491520000,122636064,693.644725,693.6423611111111 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,244000,2004,0.09980039920159679,fixed_full_OO_pool,1.114171280152061,230321402413056000,499712000,124679840,705.203275,705.2025511695906 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,248000,2004,0.249500998003992,fixed_full_OO_pool,1.1324379725733564,234097163108352000,507904000,126723968,716.764875,716.7644225146199 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,252000,2004,0.19960079840319359,fixed_full_OO_pool,1.1507050514148756,237872923803648000,516096000,128767744,728.322775,728.3248026315789 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,256000,2004,0.14970059880239522,fixed_full_OO_pool,1.1689727431370152,241648684498944000,524288000,130811872,739.885525,739.8863377192982 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,260000,2004,0.34930139720558884,fixed_full_OO_pool,1.1895656561944634,245424445194240000,532480000,132855648,751.446475,751.4458260233918 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,264000,2004,0.29940119760479045,fixed_full_OO_pool,1.2075333400929553,249200205889536000,540672000,134899424,763.005325,763.0059283625731 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,268000,2004,0.14970059880239522,fixed_full_OO_pool,1.2254805543273688,252975966584832000,548864000,136943552,774.56595,774.5680847953216 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,272000,2004,0.14970059880239522,fixed_full_OO_pool,1.2490240021712251,256751727280128000,557056000,138987328,786.1286,786.1270760233919 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,276000,2004,0.39920159680638717,fixed_full_OO_pool,1.2712833657612403,260527487975424000,565248000,141031456,797.68705,797.6898684210527 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,280000,2004,0.39920159680638717,fixed_full_OO_pool,1.2892307064351107,264303248670720000,573440000,143075232,809.249375,809.2489546783626 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,284000,2004,0.19960079840319359,fixed_full_OO_pool,1.307178019736376,268079009366016000,581632000,145119360,820.81125,820.8107456140351 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,288000,2004,0.29940119760479045,fixed_full_OO_pool,1.3305050711902893,271854770061312000,589824000,147163136,832.374125,832.3696710526316 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,292000,2004,0.09980039920159679,fixed_full_OO_pool,1.3628307403965543,275630530756608000,598016000,149207264,843.932525,843.9324780701754 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,296000,2004,0.19960079840319359,fixed_full_OO_pool,1.3945910300717999,279406291451904000,606208000,151251040,855.490375,855.4928728070175 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,300000,2004,0.249500998003992,fixed_full_OO_pool,1.4251112236020467,283182052147200000,614400000,153294816,867.052825,867.0519225146198 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,304000,2004,0.19960079840319359,fixed_full_OO_pool,1.4560389063269314,286957812842496000,622592000,155338944,878.611975,878.6145102339182 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,308000,2004,0.249500998003992,fixed_full_OO_pool,1.4886673196384477,290733573537792000,630784000,157382720,890.17425,890.1736111111111 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,312000,2004,0.34930139720558884,fixed_full_OO_pool,1.5192827939024816,294509334233088000,638976000,159426848,901.7347,901.7358187134503 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,316000,2004,0.39920159680638717,fixed_full_OO_pool,1.5392368595964379,298285094928384000,647168000,161470624,913.298675,913.2944225146199 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,320000,2004,0.5489021956087825,fixed_full_OO_pool,1.557183133813863,302060855623680000,655360000,163514752,924.8561,924.8575146198831 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,324000,2004,0.29940119760479045,fixed_full_OO_pool,1.575131099447608,305836616318976000,663552000,165558528,936.4152,936.4175438596491 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,328000,2004,0.249500998003992,fixed_full_OO_pool,1.5930802696477622,309612377014272000,671744000,167602656,947.979,947.9787719298246 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,332000,2004,0.249500998003992,fixed_full_OO_pool,1.6110276209521626,313388137709568000,679936000,169646432,959.53855,959.5386695906433 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,336000,2004,0.09980039920159679,fixed_full_OO_pool,1.6289763987116102,317163898404864000,688128000,171690208,971.098475,971.0984576023392 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,340000,2004,0.09980039920159679,fixed_full_OO_pool,1.6469249166010154,320939659100160000,696320000,173734336,982.65995,982.660365497076 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,344000,2004,0.09980039920159679,fixed_full_OO_pool,1.6648734992504535,324715419795456000,704512000,175778112,994.221225,994.2197587719298 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,348000,2004,0.049900199600798396,fixed_full_OO_pool,1.6828232588339598,328491180490752000,712704000,177822240,1005.782425,1005.7817470760234 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,352000,2004,0.09980039920159679,fixed_full_OO_pool,1.700773304614963,332266941186048000,720896000,179866016,1017.336125,1017.343355263158 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,356000,2004,0.19960079840319359,fixed_full_OO_pool,1.7187236532817285,336042701881344000,729088000,181910144,1028.907325,1028.9024195906434 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,360000,2004,0.29940119760479045,fixed_full_OO_pool,1.7366739078238607,339818462576640000,737280000,183953920,1040.464975,1040.4628728070174 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,364000,2004,0.249500998003992,fixed_full_OO_pool,1.7546231326595363,343594223271936000,745472000,185997696,1052.02295,1052.023230994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,368000,2004,0.19960079840319359,fixed_full_OO_pool,1.772571044428688,347369983967232000,753664000,188041824,1063.584925,1063.5849926900585 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,372000,2004,0.29940119760479045,fixed_full_OO_pool,1.7905191535119795,351145744662528000,761856000,190085600,1075.145775,1075.144510233918 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,376000,2004,0.14970059880239522,fixed_full_OO_pool,1.8084658338791795,354921505357824000,770048000,192129728,1086.703625,1086.7074780701755 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,380000,2004,0.29940119760479045,fixed_full_OO_pool,1.8264147528095378,358697266053120000,778240000,194173504,1098.26725,1098.2661842105263 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,384000,2004,0.049900199600798396,fixed_full_OO_pool,1.8443660213374016,362473026748416000,786432000,196217632,1109.829025,1109.828004385965 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,388000,2004,0.249500998003992,fixed_full_OO_pool,1.8623157523624185,366248787443712000,794624000,198261408,1121.389275,1121.387697368421 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,392000,2004,0.29940119760479045,fixed_full_OO_pool,1.8802647384773525,370024548139008000,802816000,200305536,1132.94945,1132.949985380117 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,396000,2004,0.39920159680638717,fixed_full_OO_pool,1.8982153477550794,373800308834304000,811008000,202349312,1144.5121,1144.5089766081871 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,400000,2004,0.29940119760479045,fixed_full_OO_pool,1.916164927460874,377576069529600000,819200000,204393088,1156.06985,1156.0694005847954 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,404000,2004,0.34930139720558884,fixed_full_OO_pool,1.934112802028863,381351830224896000,827392000,206437216,1167.629,1167.6319883040935 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,408000,2004,0.249500998003992,fixed_full_OO_pool,1.9520625015513764,385127590920192000,835584000,208480992,1179.18995,1179.191476608187 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,412000,2004,0.29940119760479045,fixed_full_OO_pool,1.9700118146277965,388903351615488000,843776000,210525120,1190.75375,1190.7527046783625 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,416000,2004,0.29940119760479045,fixed_full_OO_pool,1.9879602287130222,392679112310784000,851968000,212568896,1202.312025,1202.3129751461988 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,420000,2004,0.19960079840319359,fixed_full_OO_pool,2.0059096497928515,396454873006080000,860160000,214613024,1213.876475,1213.8740131578948 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,424000,2004,0.19960079840319359,fixed_full_OO_pool,2.023861921094358,400230633701376000,868352000,216656800,1225.435575,1225.4340423976607 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,428000,2004,0.14970059880239522,fixed_full_OO_pool,2.0418133378794625,404006394396672000,876544000,218700928,1236.99625,1236.9961842105263 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,432000,2004,0.29940119760479045,fixed_full_OO_pool,2.059765731472936,407782155091968000,884736000,220744704,1248.55375,1248.5566812865497 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,436000,2004,0.19960079840319359,fixed_full_OO_pool,2.0777166095645065,411557915787264000,892928000,222788480,1260.114275,1260.1162938596492 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,440000,2004,0.4491017964071856,fixed_full_OO_pool,2.0956682115720793,415333676482560000,901120000,224832608,1271.675325,1271.6783260233917 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,444000,2004,0.34930139720558884,fixed_full_OO_pool,2.1136192256998685,419109437177856000,909312000,226876384,1283.236625,1283.237711988304 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,448000,2004,0.249500998003992,fixed_full_OO_pool,2.1315693752208933,422885197873152000,917504000,228920512,1294.801975,1294.7984868421054 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,452000,2004,0.29940119760479045,fixed_full_OO_pool,2.1495210125297306,426660958568448000,925696000,230964288,1306.362075,1306.3582236842105 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,456000,2004,0.249500998003992,fixed_full_OO_pool,2.167468521597071,430436719263744000,933888000,233008416,1317.92185,1317.9206286549709 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,460000,2004,0.19960079840319359,fixed_full_OO_pool,2.185417271733491,434212479959040000,942080000,235052192,1329.48015,1329.4808918128656 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,464000,2004,0.19960079840319359,fixed_full_OO_pool,2.203366689236007,437988240654336000,950272000,237095968,1341.0407,1341.0404970760235 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,468000,2004,0.14970059880239522,fixed_full_OO_pool,2.221316149842201,441764001349632000,958464000,239140096,1352.601175,1352.602697368421 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,472000,2004,0.29940119760479045,fixed_full_OO_pool,2.239266853189717,445539762044928000,966656000,241183872,1364.16295,1364.1619444444445 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,476000,2004,0.29940119760479045,fixed_full_OO_pool,2.257217013521327,449315522740224000,974848000,243228000,1375.722825,1375.7243201754386 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,480000,2004,0.39920159680638717,fixed_full_OO_pool,2.2751681273482327,453091283435520000,983040000,245271776,1387.28105,1387.2846052631578 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,484000,2004,0.29940119760479045,fixed_full_OO_pool,2.2931189898898205,456867044130816000,991232000,247315904,1398.844975,1398.8457967836257 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,488000,2004,0.34930139720558884,fixed_full_OO_pool,2.3110703056626436,460642804826112000,999424000,249359680,1410.404425,1410.4057236842104 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,492000,2004,0.249500998003992,fixed_full_OO_pool,2.329022096555887,464418565521408000,1007616000,251403808,1421.968225,1421.966951754386 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,496000,2004,0.29940119760479045,fixed_full_OO_pool,2.346977836120253,468194326216704000,1015808000,253447584,1433.524825,1433.5277119883042 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,500000,2004,0.19960079840319359,fixed_full_OO_pool,2.3649320968426766,471970086912000000,1024000000,255491360,1445.088525,1445.0863961988305 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,504000,2004,0.34930139720558884,fixed_full_OO_pool,2.3828861930728373,475745847607296000,1032192000,257535488,1456.646325,1456.6493786549709 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,508000,2004,0.34930139720558884,fixed_full_OO_pool,2.4008386677710547,479521608302592000,1040384000,259579264,1468.2094,1468.2082456140351 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,512000,2004,0.39920159680638717,fixed_full_OO_pool,2.4187904686263453,483297368997888000,1048576000,261623392,1479.77025,1479.77033625731 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,516000,2004,0.249500998003992,fixed_full_OO_pool,2.4367413419578225,487073129693184000,1056768000,263667168,1491.332625,1491.3294078947367 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,520000,2004,0.29940119760479045,fixed_full_OO_pool,2.4546914627496155,490848890388480000,1064960000,265711296,1502.89105,1502.892207602339 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,524000,2004,0.09980039920159679,fixed_full_OO_pool,2.4726433950714353,494624651083776000,1073152000,267755072,1514.4588,1514.4497076023392 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,528000,2004,0.09980039920159679,fixed_full_OO_pool,2.4905915167389643,498400411779072000,1081344000,269798848,1526.01185,1526.0115058479532 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,532000,2004,0.4491017964071856,fixed_full_OO_pool,2.508541830415941,502176172474368000,1089536000,271842976,1537.57275,1537.5735818713451 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,536000,2004,0.19960079840319359,fixed_full_OO_pool,2.526489773520993,505951933169664000,1097728000,273886752,1549.1349,1549.1327192982455 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,540000,2004,0.4491017964071856,fixed_full_OO_pool,2.544436873155129,509727693864960000,1105920000,275930880,1560.693825,1560.6953728070175 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,544000,2004,0.19960079840319359,fixed_full_OO_pool,2.5623861871132005,513503454560256000,1114112000,277974656,1572.2551,1572.2547660818714 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,548000,2004,0.34930139720558884,fixed_full_OO_pool,2.580333324826012,517279215255552000,1122304000,280018784,1583.81425,1583.8173538011697 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,552000,2004,0.34930139720558884,fixed_full_OO_pool,2.5982821664679796,521054975950848000,1130496000,282062560,1595.377875,1595.3760599415205 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,556000,2004,0.39920159680638717,fixed_full_OO_pool,2.6162290080709174,524830736646144000,1138688000,284106688,1606.93965,1606.9378801169591 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,560000,2004,0.29940119760479045,fixed_full_OO_pool,2.634176643245543,528606497341440000,1146880000,286150464,1618.501225,1618.4971856725147 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,564000,2004,0.4491017964071856,fixed_full_OO_pool,2.6521223536723606,532382258036736000,1155072000,288194240,1630.058,1630.0578947368422 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,568000,2004,0.499001996007984,fixed_full_OO_pool,2.670069007542398,536158018732032000,1163264000,290238368,1641.620975,1641.6193640350878 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,572000,2004,0.29940119760479045,fixed_full_OO_pool,2.688018251169059,539933779427328000,1171456000,292282144,1653.1784,1653.1798830409357 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,576000,2004,0.09980039920159679,fixed_full_OO_pool,2.7059672200793607,543709540122624000,1179648000,294326272,1664.742875,1664.74091374269 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,580000,2004,0.34930139720558884,fixed_full_OO_pool,2.723915966528778,547485300817920000,1187840000,296370048,1676.301775,1676.3010014619883 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,584000,2004,0.29940119760479045,fixed_full_OO_pool,2.7418641726020723,551261061513216000,1196032000,298414176,1687.862275,1687.8631944444444 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,588000,2004,0.249500998003992,fixed_full_OO_pool,2.7598119778889747,555036822208512000,1204224000,300457952,1699.42215,1699.4229970760234 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,592000,2004,0.249500998003992,fixed_full_OO_pool,2.777757554952469,558812582903808000,1212416000,302502080,1710.985,1710.9845029239766 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,596000,2004,0.19960079840319359,fixed_full_OO_pool,2.7957049503115314,562588343599104000,1220608000,304545856,1722.546875,1722.543720760234 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,600000,2004,0.34930139720558884,fixed_full_OO_pool,2.8136521237871297,566364104294400000,1228800000,306589632,1734.105,1734.1040350877192 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,604000,2004,0.29940119760479045,fixed_full_OO_pool,2.831601576814428,570139864989696000,1236992000,308633760,1745.666225,1745.6660160818712 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,608000,2004,0.4491017964071856,fixed_full_OO_pool,2.849553364937504,573915625684992000,1245184000,310677536,1757.228575,1757.2250950292398 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,612000,2004,0.34930139720558884,fixed_full_OO_pool,2.8675041560104324,577691386380288000,1253376000,312721664,1768.789075,1768.7872880116959 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,616000,2004,0.34930139720558884,fixed_full_OO_pool,2.8854559080406195,581467147075584000,1261568000,314765440,1780.347,1780.3476608187134 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,620000,2004,0.499001996007984,fixed_full_OO_pool,2.9034028113002166,585242907770880000,1269760000,316809568,1791.9093,1791.9093274853801 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,624000,2004,0.19960079840319359,fixed_full_OO_pool,2.921352274953905,589018668466176000,1277952000,318853344,1803.469475,1803.4690423976608 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,628000,2004,0.249500998003992,fixed_full_OO_pool,2.939300148004873,592794429161472000,1286144000,320897120,1815.028525,1815.02908625731 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,632000,2004,0.34930139720558884,fixed_full_OO_pool,2.957246749146531,596570189856768000,1294336000,322941248,1826.59285,1826.5901608187135 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,636000,2004,0.4491017964071856,fixed_full_OO_pool,2.9751937640406605,600345950552064000,1302528000,324985024,1838.15025,1838.150687134503 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,640000,2004,0.39920159680638717,fixed_full_OO_pool,2.993139864877901,604121711247360000,1310720000,327029152,1849.713625,1849.7120394736842 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,644000,2004,0.39920159680638717,fixed_full_OO_pool,3.011086226294024,607897471942656000,1318912000,329072928,1861.27385,1861.271739766082 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,648000,2004,0.29940119760479045,fixed_full_OO_pool,3.029032770249372,611673232637952000,1327104000,331117056,1872.832725,1872.8344078947368 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,652000,2004,0.249500998003992,fixed_full_OO_pool,3.046979381000209,615448993333248000,1335296000,333160832,1884.39475,1884.393581871345 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,656000,2004,0.4491017964071856,fixed_full_OO_pool,3.0649247960901507,619224754028544000,1343488000,335204960,1895.954525,1895.9559868421052 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,660000,2004,0.34930139720558884,fixed_full_OO_pool,3.082871248320573,623000514723840000,1351680000,337248736,1907.51545,1907.5154824561403 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,664000,2004,0.29940119760479045,fixed_full_OO_pool,3.1008167478700894,626776275419136000,1359872000,339292512,1919.07355,1919.0758040935673 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,668000,2004,0.249500998003992,fixed_full_OO_pool,3.118762581022456,630552036114432000,1368064000,341336640,1930.63605,1930.6374122807017 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,672000,2004,0.14970059880239522,fixed_full_OO_pool,3.136709687911595,634327796809728000,1376256000,343380416,1942.194725,1942.1975657894736 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,676000,2004,0.049900199600798396,fixed_full_OO_pool,3.154654829237196,638103557505024000,1384448000,345424544,1953.759775,1953.758428362573 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,680000,2004,0.19960079840319359,fixed_full_OO_pool,3.1726009709874377,641879318200320000,1392640000,347468320,1965.3176,1965.3188304093567 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,684000,2004,0.39920159680638717,fixed_full_OO_pool,3.1905465956456545,645655078895616000,1400832000,349512448,1976.879675,1976.880562865497 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,688000,2004,0.39920159680638717,fixed_full_OO_pool,3.208493550840972,649430839590912000,1409024000,351556224,1988.44025,1988.4401608187134 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,692000,2004,0.19960079840319359,fixed_full_OO_pool,3.2264396200649856,653206600286208000,1417216000,353600000,2000.0,2000.0 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,696000,2004,0.29940119760479045,fixed_full_OO_pool,3.2443870721012353,656982360981504000,1425408000,355644128,2011.5593,2011.5625438596492 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,700000,2004,0.34930139720558884,fixed_full_OO_pool,3.262332130976849,660758121676800000,1433600000,357687904,2023.1232,2023.1211695906434 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,704000,2004,0.39920159680638717,fixed_full_OO_pool,3.280278667688577,664533882372096000,1441792000,359732032,2034.68475,2034.6830555555555 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,708000,2004,0.14970059880239522,fixed_full_OO_pool,3.2982263420242814,668309643067392000,1449984000,361775808,2046.24495,2046.2427631578948 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,712000,2004,0.249500998003992,fixed_full_OO_pool,3.3161723947307715,672085403762688000,1458176000,363819936,2057.80495,2057.8051023391813 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,716000,2004,0.39920159680638717,fixed_full_OO_pool,3.334120980890261,675861164457984000,1466368000,365863712,2069.364325,2069.3650511695905 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,720000,2004,0.34930139720558884,fixed_full_OO_pool,3.3520704818506624,679636925153280000,1474560000,367907840,2080.9282,2080.9262573099413 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,724000,2004,0.29940119760479045,fixed_full_OO_pool,3.3700206208663683,683412685848576000,1482752000,369951616,2092.489475,2092.485650584795 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,728000,2004,0.29940119760479045,fixed_full_OO_pool,3.387968517454962,687188446543872000,1490944000,371995392,2104.04705,2104.046125730994 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,732000,2004,0.249500998003992,fixed_full_OO_pool,3.4059175653745317,690964207239168000,1499136000,374039520,2115.606875,2115.608516081871 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,736000,2004,0.19960079840319359,fixed_full_OO_pool,3.423863827086364,694739967934464000,1507328000,376083296,2127.1694,2127.167543859649 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,740000,2004,0.14970059880239522,fixed_full_OO_pool,3.4418115482665597,698515728629760000,1515520000,378127424,2138.72975,2138.7297807017544 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,744000,2004,0.34930139720558884,fixed_full_OO_pool,3.4597621138569794,702291489325056000,1523712000,380171200,2150.28925,2150.289692982456 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,748000,2004,0.249500998003992,fixed_full_OO_pool,3.4777137436055474,706067250020352000,1531904000,382215328,2161.851975,2161.851235380117 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,752000,2004,0.249500998003992,fixed_full_OO_pool,3.4956654352446397,709843010715648000,1540096000,384259104,2173.414975,2173.410124269006 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,756000,2004,0.4491017964071856,fixed_full_OO_pool,3.5136165391343335,713618771410944000,1548288000,386303232,2184.972825,2184.9730921052633 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,760000,2004,0.19960079840319359,fixed_full_OO_pool,3.531565736527037,717394532106240000,1556480000,388347008,2196.535475,2196.5320833333335 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,764000,2004,0.29940119760479045,fixed_full_OO_pool,3.5495152905573035,721170292801536000,1564672000,390390784,2208.0957,2208.091783625731 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,768000,2004,0.29940119760479045,fixed_full_OO_pool,3.5674647777465482,724946053496832000,1572864000,392434912,2219.6548,2219.6543859649123 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,772000,2004,0.29940119760479045,fixed_full_OO_pool,3.5854150704170267,728721814192128000,1581056000,394478688,2231.217225,2231.213442982456 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,776000,2004,0.34930139720558884,fixed_full_OO_pool,3.6033652704271177,732497574887424000,1589248000,396522816,2242.77625,2242.776067251462 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,780000,2004,0.249500998003992,fixed_full_OO_pool,3.621318802021237,736273335582720000,1597440000,398566592,2254.33585,2254.3359502923977 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,784000,2004,0.34930139720558884,fixed_full_OO_pool,3.6392686840767663,740049096278016000,1605632000,400610720,2265.897725,2265.89774122807 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,788000,2004,0.29940119760479045,fixed_full_OO_pool,3.6572190350687337,743824856973312000,1613824000,402654496,2277.459025,2277.4571271929826 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,792000,2004,0.29940119760479045,fixed_full_OO_pool,3.6751706695008197,747600617668608000,1622016000,404698272,2289.0177,2289.0172807017543 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,796000,2004,0.249500998003992,fixed_full_OO_pool,3.6931230931387593,751376378363904000,1630208000,406742400,2300.578425,2300.579407894737 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,800000,2004,0.29940119760479045,fixed_full_OO_pool,3.7110736741870642,755152139059200000,1638400000,408786176,2312.13805,2312.139283625731 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,804000,2004,0.29940119760479045,fixed_full_OO_pool,3.729024529222192,758927899754496000,1646592000,410830304,2323.702275,2323.7003874269008 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,808000,2004,0.34930139720558884,fixed_full_OO_pool,3.746976378980196,762703660449792000,1654784000,412874080,2335.2593,2335.261023391813 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,812000,2004,0.249500998003992,fixed_full_OO_pool,3.764926876143242,766479421145088000,1662976000,414918208,2346.823,2346.8222807017546 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,816000,2004,0.19960079840319359,fixed_full_OO_pool,3.782877818527114,770255181840384000,1671168000,416961984,2358.383125,2358.382010233918 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,820000,2004,0.19960079840319359,fixed_full_OO_pool,3.8008293965738265,774030942535680000,1679360000,419006112,2369.94445,2369.943961988304 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,824000,2004,0.19960079840319359,fixed_full_OO_pool,3.818781381542277,777806703230976000,1687552000,421049888,2381.504325,2381.503764619883 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,828000,2004,0.19960079840319359,fixed_full_OO_pool,3.8367320217709575,781582463926272000,1695744000,423093664,2393.063225,2393.0638523391813 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,832000,2004,0.249500998003992,fixed_full_OO_pool,3.8546838122585583,785358224621568000,1703936000,425137792,2404.624025,2404.625957602339 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,836000,2004,0.499001996007984,fixed_full_OO_pool,3.872634549409979,789133985316864000,1712128000,427181568,2416.184625,2416.185548245614 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,840000,2004,0.249500998003992,fixed_full_OO_pool,3.890586605499395,792909746012160000,1720320000,429225696,2427.750525,2427.746162280702 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,844000,2004,0.34930139720558884,fixed_full_OO_pool,3.908538625340702,796685506707456000,1728512000,431269472,2439.30695,2439.3069736842103 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,848000,2004,0.29940119760479045,fixed_full_OO_pool,3.926488913774697,800461267402752000,1736704000,433313600,2450.86875,2450.8687865497077 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,852000,2004,0.249500998003992,fixed_full_OO_pool,3.9444412595188867,804237028098048000,1744896000,435357376,2462.429925,2462.4282090643273 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,856000,2004,0.19960079840319359,fixed_full_OO_pool,3.962390815653942,808012788793344000,1753088000,437401504,2473.9897,2473.9906140350877 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,860000,2004,0.34930139720558884,fixed_full_OO_pool,3.9803408151637347,811788549488640000,1761280000,439445280,2485.5492,2485.5505263157893 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,864000,2004,0.14970059880239522,fixed_full_OO_pool,3.9982899994910177,815564310183936000,1769472000,441489056,2497.1089,2497.1103801169593 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,868000,2004,0.29940119760479045,fixed_full_OO_pool,4.016241111856782,819340070879232000,1777664000,443533184,2508.6737,2508.6713157894737 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,872000,2004,0.39920159680638717,fixed_full_OO_pool,4.03419099221213,823115831574528000,1785856000,445576960,2520.233975,2520.2310014619884 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,876000,2004,0.049900199600798396,fixed_full_OO_pool,4.052140775590928,826891592269824000,1794048000,447621088,2531.794875,2531.7930774853803 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,880000,2004,0.19960079840319359,fixed_full_OO_pool,4.070089197695876,830667352965120000,1802240000,449664864,2543.353375,2543.3532821637427 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,884000,2004,0.19960079840319359,fixed_full_OO_pool,4.088036197114529,834443113660416000,1810432000,451708992,2554.9139,2554.9154678362574 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,888000,2004,0.29940119760479045,fixed_full_OO_pool,4.105984920803458,838218874355712000,1818624000,453752768,2566.47495,2566.4749269005847 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,892000,2004,0.0,fixed_full_OO_pool,4.123932080590683,841994635051008000,1826816000,455796544,2578.0335,2578.0351169590645 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,896000,2004,0.14970059880239522,fixed_full_OO_pool,4.141878474866972,845770395746304000,1835008000,457840672,2589.59485,2589.5970614035086 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,900000,2004,0.29940119760479045,fixed_full_OO_pool,4.159826294425875,849546156441600000,1843200000,459884448,2601.156375,2601.1563815789473 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,904000,2004,0.29940119760479045,fixed_full_OO_pool,4.177774229981005,853321917136896000,1851392000,461928576,2612.71565,2612.718932748538 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,908000,2004,0.249500998003992,fixed_full_OO_pool,4.195722298655245,857097677832192000,1859584000,463972352,2624.27895,2624.2777339181284 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,912000,2004,0.29940119760479045,fixed_full_OO_pool,4.213671840580387,860873438527488000,1867776000,466016480,2635.83975,2635.8398391812866 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,916000,2004,0.14970059880239522,fixed_full_OO_pool,4.231622953425265,864649199222784000,1875968000,468060256,2647.398475,2647.3999780701756 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,920000,2004,0.249500998003992,fixed_full_OO_pool,4.24956987960471,868424959918080000,1884160000,470104384,2658.960675,2658.9616739766084 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,924000,2004,0.249500998003992,fixed_full_OO_pool,4.267701822253358,872200720613376000,1892352000,472148160,2670.520325,2670.5215423976606 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,928000,2004,0.39920159680638717,fixed_full_OO_pool,4.285685077579692,875976481308672000,1900544000,474191936,2682.079425,2682.081571637427 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,932000,2004,0.19960079840319359,fixed_full_OO_pool,4.303633359217395,879752242003968000,1908736000,476236064,2693.643175,2693.642814327485 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,936000,2004,0.29940119760479045,fixed_full_OO_pool,4.321582531826571,883528002699264000,1916928000,478279840,2705.20505,2705.202032163743 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,940000,2004,0.34930139720558884,fixed_full_OO_pool,4.339529590429738,887303763394560000,1925120000,480323968,2716.764675,2716.764480994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,944000,2004,0.29940119760479045,fixed_full_OO_pool,4.357481372630637,891079524089856000,1933312000,482367744,2728.32825,2728.323201754386 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,948000,2004,0.19960079840319359,fixed_full_OO_pool,4.375430207958238,894855284785152000,1941504000,484411872,2739.887825,2739.8856652046784 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,952000,2004,0.249500998003992,fixed_full_OO_pool,4.393846343448385,898631045480448000,1949696000,486455648,2751.4427,2751.4469298245613 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,956000,2004,0.14970059880239522,fixed_full_OO_pool,4.4127153909754835,902406806175744000,1957888000,488499424,2763.00535,2763.0059210526315 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,960000,2004,0.19960079840319359,fixed_full_OO_pool,4.431008885457284,906182566871040000,1966080000,490543552,2774.570625,2774.5667178362573 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,964000,2004,0.19960079840319359,fixed_full_OO_pool,4.448959144612568,909958327566336000,1974272000,492587328,2786.125875,2786.1278728070174 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,968000,2004,0.049900199600798396,fixed_full_OO_pool,4.466908273396807,913734088261632000,1982464000,494631456,2797.691,2797.688713450292 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,972000,2004,0.09980039920159679,fixed_full_OO_pool,4.484856754412046,917509848956928000,1990656000,496675232,2809.249925,2809.248793859649 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,976000,2004,0.249500998003992,fixed_full_OO_pool,4.502804993651807,921285609652224000,1998848000,498719360,2820.809525,2820.81125 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,980000,2004,0.249500998003992,fixed_full_OO_pool,4.520753835839116,925061370347520000,2007040000,500763136,2832.3749,2832.3694444444445 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,984000,2004,0.34930139720558884,fixed_full_OO_pool,4.538704656389439,928837131042816000,2015232000,502807264,2843.93305,2843.9323245614037 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,988000,2004,0.29940119760479045,fixed_full_OO_pool,4.556656558383256,932612891738112000,2023424000,504851040,2855.495975,2855.491235380117 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,992000,2004,0.09980039920159679,fixed_full_OO_pool,4.574607272308527,936388652433408000,2031616000,506894816,2867.0535,2867.051725146199 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,996000,2004,0.29940119760479045,fixed_full_OO_pool,4.592555447458807,940164413128704000,2039808000,508938944,2878.612775,2878.6142763157895 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1000000,2004,0.049900199600798396,fixed_full_OO_pool,4.6117559723007595,943940173824000000,2048000000,510982720,2890.175025,2890.173384502924 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1004000,2004,0.34930139720558884,fixed_full_OO_pool,4.63426298629596,947715934519296000,2056192000,513026848,2901.737225,2901.7350804093567 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1008000,2004,0.39920159680638717,fixed_full_OO_pool,4.656838446369187,951491695214592000,2064384000,515070624,2913.294575,2913.2956213450293 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1012000,2004,0.34930139720558884,fixed_full_OO_pool,4.68081138904103,955267455909888000,2072576000,517114752,2924.8567,2924.8573391812865 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1016000,2004,0.29940119760479045,fixed_full_OO_pool,4.702654419512385,959043216605184000,2080768000,519158528,2936.416125,2936.417273391813 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1020000,2004,0.249500998003992,fixed_full_OO_pool,4.722879040252624,962818977300480000,2088960000,521202656,2947.978275,2947.9789839181285 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1024000,2004,0.6487025948103792,fixed_full_OO_pool,4.740826810087181,966594737995776000,2097152000,523246432,2959.5367,2959.539210526316 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1028000,2004,0.39920159680638717,fixed_full_OO_pool,4.75877442424496,970370498691072000,2105344000,525290208,2971.0992,2971.098245614035 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1032000,2004,0.249500998003992,fixed_full_OO_pool,4.776721626747814,974146259386368000,2113536000,527334336,2982.6603,2982.660263157895 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1036000,2004,0.29940119760479045,fixed_full_OO_pool,4.794669036296093,977922020081664000,2121728000,529378112,2994.218075,2994.2206798245616 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1040000,2004,0.34930139720558884,fixed_full_OO_pool,4.8126152283884585,981697780776960000,2129920000,531422240,3005.7826,3005.7816959064326 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1044000,2004,0.249500998003992,fixed_full_OO_pool,4.830561199668381,985473541472256000,2138112000,533466016,3017.34065,3017.3420321637427 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1048000,2004,0.34930139720558884,fixed_full_OO_pool,4.848507593942599,989249302167552000,2146304000,535510144,3028.901175,3028.9042178362574 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1052000,2004,0.19960079840319359,fixed_full_OO_pool,4.866453891010541,993025062862848000,2154496000,537553920,3040.46525,3040.462792397661 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1056000,2004,0.14970059880239522,fixed_full_OO_pool,4.8843987502343955,996800823558144000,2162688000,539597696,3052.023225,3052.0231505847955 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1060000,2004,0.19960079840319359,fixed_full_OO_pool,4.9023427911920265,1000576584253440000,2170880000,541641824,3063.58605,3063.5846637426903 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1064000,2004,0.249500998003992,fixed_full_OO_pool,4.922584818471223,1004352344948736000,2179072000,543685600,3075.146925,3075.1441739766083 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1068000,2004,0.19960079840319359,fixed_full_OO_pool,4.940530001003709,1008128105644032000,2187264000,545729728,3086.703375,3086.7075511695907 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1072000,2004,0.29940119760479045,fixed_full_OO_pool,4.958476122948858,1011903866339328000,2195456000,547773504,3098.261175,3098.2679605263156 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1076000,2004,0.4491017964071856,fixed_full_OO_pool,4.976421232922003,1015679627034624000,2203648000,549817632,3109.8289,3109.8280409356726 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1080000,2004,0.19960079840319359,fixed_full_OO_pool,4.994368115728721,1019455387729920000,2211840000,551861408,3121.389625,3121.38759502924 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1084000,2004,0.39920159680638717,fixed_full_OO_pool,5.012314197853621,1023231148425216000,2220032000,553905536,3132.948025,3132.9504020467834 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1088000,2004,0.19960079840319359,fixed_full_OO_pool,5.030259200520813,1027006909120512000,2228224000,555949312,3144.51055,3144.5094298245613 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1092000,2004,0.249500998003992,fixed_full_OO_pool,5.048204146418721,1030782669815808000,2236416000,557993088,3156.067825,3156.0699926900584 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1096000,2004,0.19960079840319359,fixed_full_OO_pool,5.066149583948362,1034558430511104000,2244608000,560037216,3167.63045,3167.631564327485 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1100000,2004,0.249500998003992,fixed_full_OO_pool,5.084094831394031,1038334191206400000,2252800000,562080992,3179.189475,3179.191615497076 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1104000,2004,0.19960079840319359,fixed_full_OO_pool,5.102040583507883,1042109951901696000,2260992000,564125120,3190.753375,3190.7528143274853 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1108000,2004,0.19960079840319359,fixed_full_OO_pool,5.119986331763988,1045885712596992000,2269184000,566168896,3202.311,3202.313274853801 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1112000,2004,0.09980039920159679,fixed_full_OO_pool,5.137932922143696,1049661473292288000,2277376000,568213024,3213.87355,3213.8748684210527 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1116000,2004,0.29940119760479045,fixed_full_OO_pool,5.155882754909496,1053437233987584000,2285568000,570256800,3225.4302,3225.435614035088 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1120000,2004,0.34930139720558884,fixed_full_OO_pool,5.173835400738236,1057212994682880000,2293760000,572300928,3236.996475,3236.9961184210524 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1124000,2004,0.14970059880239522,fixed_full_OO_pool,5.191788201787405,1060988755378176000,2301952000,574344704,3248.552025,3248.5571856725146 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1128000,2004,0.34930139720558884,fixed_full_OO_pool,5.209740085745644,1064764516073472000,2310144000,576388480,3260.114775,3260.1161476608186 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1132000,2004,0.249500998003992,fixed_full_OO_pool,5.227689357118474,1068540276768768000,2318336000,578432608,3271.6776,3271.6776608187133 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1136000,2004,0.29940119760479045,fixed_full_OO_pool,5.245640355351691,1072316037464064000,2326528000,580476384,3283.239125,3283.236980994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1140000,2004,0.29940119760479045,fixed_full_OO_pool,5.263591117384947,1076091798159360000,2334720000,582520512,3294.8015,3294.798625730994 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1144000,2004,0.39920159680638717,fixed_full_OO_pool,5.281543543923439,1079867558854656000,2342912000,584564288,3306.356875,3306.359744152047 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1148000,2004,0.39920159680638717,fixed_full_OO_pool,5.299495766260144,1083643319549952000,2351104000,586608416,3317.9198,3317.9212280701754 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1152000,2004,0.29940119760479045,fixed_full_OO_pool,5.317446870452,1087419080245248000,2359296000,588652192,3329.483725,3329.4798464912283 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1156000,2004,0.249500998003992,fixed_full_OO_pool,5.335396354872112,1091194840940544000,2367488000,590695968,3341.041575,3341.04024122807 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1160000,2004,0.249500998003992,fixed_full_OO_pool,5.353343617844706,1094970601635840000,2375680000,592740096,3352.600375,3352.60293128655 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1164000,2004,0.09980039920159679,fixed_full_OO_pool,5.371289474695093,1098746362331136000,2383872000,594783872,3364.161825,3364.162273391813 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1168000,2004,0.249500998003992,fixed_full_OO_pool,5.3892368011445635,1102522123026432000,2392064000,596828000,3375.7226,3375.7243859649125 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1172000,2004,0.34930139720558884,fixed_full_OO_pool,5.407184826034225,1106297883721728000,2400256000,598871776,3387.2855,3387.283304093567 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1176000,2004,0.39920159680638717,fixed_full_OO_pool,5.425132238077413,1110073644417024000,2408448000,600915904,3398.84695,3398.8452192982454 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1180000,2004,0.29940119760479045,fixed_full_OO_pool,5.443080631596968,1113849405112320000,2416640000,602959680,3410.406875,3410.4050073099415 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1184000,2004,0.39920159680638717,fixed_full_OO_pool,5.461026876564655,1117625165807616000,2424832000,605003808,3421.9676,3421.967134502924 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1188000,2004,0.5489021956087825,fixed_full_OO_pool,5.478975883189382,1121400926502912000,2433024000,607047584,3433.52605,3433.5273538011697 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1192000,2004,0.249500998003992,fixed_full_OO_pool,5.496922956126639,1125176687198208000,2441216000,609091360,3445.0867,3445.0869298245616 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1196000,2004,0.29940119760479045,fixed_full_OO_pool,5.5148695494068996,1128952447893504000,2449408000,611135488,3456.647275,3456.649100877193 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1200000,2004,0.19960079840319359,fixed_full_OO_pool,5.532815180381553,1132728208588800000,2457600000,613179264,3468.2082,3468.208596491228 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1204000,2004,0.09980039920159679,fixed_full_OO_pool,5.550761990211904,1136503969284096000,2465792000,615223392,3479.772825,3479.7695833333332 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1208000,2004,0.14970059880239522,fixed_full_OO_pool,5.568706573319311,1140279729979392000,2473984000,617267168,3491.3276,3491.3308771929824 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1212000,2004,0.249500998003992,fixed_full_OO_pool,5.5866523442955485,1144055490674688000,2482176000,619311296,3502.891375,3502.8921125730994 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1216000,2004,0.34930139720558884,fixed_full_OO_pool,5.6046023521251565,1147831251369984000,2490368000,621355072,3514.4535,3514.4512573099414 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1220000,2004,0.19960079840319359,fixed_full_OO_pool,5.622550778030935,1151607012065280000,2498560000,623398848,3526.01065,3526.011856725146 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1224000,2004,0.4491017964071856,fixed_full_OO_pool,5.640498225833807,1155382772760576000,2506752000,625442976,3537.57085,3537.5741374269005 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1228000,2004,0.34930139720558884,fixed_full_OO_pool,5.658443790580042,1159158533455872000,2514944000,627486752,3549.13515,3549.1326461988306 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1232000,2004,0.34930139720558884,fixed_full_OO_pool,5.676388817326062,1162934294151168000,2523136000,629530880,3560.6952,3560.694970760234 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1236000,2004,0.39920159680638717,fixed_full_OO_pool,5.69433447837933,1166710054846464000,2531328000,631574656,3572.253625,3572.2551973684212 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1240000,2004,0.29940119760479045,fixed_full_OO_pool,5.712282279451482,1170485815541760000,2539520000,633618784,3583.81925,3583.8158918128656 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1244000,2004,0.249500998003992,fixed_full_OO_pool,5.73022991733729,1174261576237056000,2547712000,635662560,3595.376225,3595.3765423976606 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1248000,2004,0.29940119760479045,fixed_full_OO_pool,5.748177853644722,1178037336932352000,2555904000,637706688,3606.93815,3606.9383187134504 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1252000,2004,0.14970059880239522,fixed_full_OO_pool,5.7661271756007855,1181813097627648000,2564096000,639750464,3618.49615,3618.498669590643 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1256000,2004,0.4491017964071856,fixed_full_OO_pool,5.784076099377126,1185588858322944000,2572288000,641794240,3630.057725,3630.0579751461987 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1260000,2004,0.249500998003992,fixed_full_OO_pool,5.802022721541839,1189364619018240000,2580480000,643838368,3641.620725,3641.6194371345027 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1264000,2004,0.29940119760479045,fixed_full_OO_pool,5.819971356282218,1193140379713536000,2588672000,645882144,3653.178425,3653.1798757309944 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1268000,2004,0.34930139720558884,fixed_full_OO_pool,5.837918840879574,1196916140408832000,2596864000,647926272,3664.743,3664.7408771929827 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1272000,2004,0.09980039920159679,fixed_full_OO_pool,5.855866905438403,1200691901104128000,2605056000,649970048,3676.30325,3676.3005701754387 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1276000,2004,0.14970059880239522,fixed_full_OO_pool,5.873814785350114,1204467661799424000,2613248000,652014176,3687.86175,3687.8633479532164 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1280000,2004,0.29940119760479045,fixed_full_OO_pool,5.89176432119165,1208243422494720000,2621440000,654057952,3699.421775,3699.423106725146 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1284000,2004,0.29940119760479045,fixed_full_OO_pool,5.909711040537804,1212019183190016000,2629632000,656102080,3710.983725,3710.984875730994 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1288000,2004,0.19960079840319359,fixed_full_OO_pool,5.927660323763266,1215794943885312000,2637824000,658145856,3722.544725,3722.5443494152046 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1292000,2004,0.39920159680638717,fixed_full_OO_pool,5.945610631151745,1219570704580608000,2646016000,660189632,3734.104575,3734.104159356725 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1296000,2004,0.19960079840319359,fixed_full_OO_pool,5.963560657691624,1223346465275904000,2654208000,662233760,3745.663975,3745.6666739766083 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1300000,2004,0.29940119760479045,fixed_full_OO_pool,5.9815091974847014,1227122225971200000,2662400000,664277536,3757.225225,3757.2260745614035 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1304000,2004,0.39920159680638717,fixed_full_OO_pool,5.9994580650722815,1230897986666496000,2670592000,666321664,3768.78815,3768.787558479532 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1308000,2004,0.19960079840319359,fixed_full_OO_pool,6.017406892001422,1234673747361792000,2678784000,668365440,3780.34755,3780.3475 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1312000,2004,0.34930139720558884,fixed_full_OO_pool,6.035358108757063,1238449508057088000,2686976000,670409568,3791.91035,3791.9090204678364 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1316000,2004,0.249500998003992,fixed_full_OO_pool,6.053308502337378,1242225268752384000,2695168000,672453344,3803.4657,3803.47014619883 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1320000,2004,0.29940119760479045,fixed_full_OO_pool,6.071259934770771,1246001029447680000,2703360000,674497120,3815.029375,3815.0288377192983 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1324000,2004,0.29940119760479045,fixed_full_OO_pool,6.089210710722125,1249776790142976000,2711552000,676541248,3826.59085,3826.5907456140353 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1328000,2004,0.499001996007984,fixed_full_OO_pool,6.1071615047773555,1253552550838272000,2719744000,678585024,3838.148025,3838.151337719298 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1332000,2004,0.34930139720558884,fixed_full_OO_pool,6.12511162354197,1257328311533568000,2727936000,680629152,3849.711275,3849.712726608187 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1336000,2004,0.249500998003992,fixed_full_OO_pool,6.143059536713279,1261104072228864000,2736128000,682672928,3861.27085,3861.272616959064 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1340000,2004,0.29940119760479045,fixed_full_OO_pool,6.161005451051104,1264879832924160000,2744320000,684717056,3872.8352,3872.8336842105264 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1344000,2004,0.29940119760479045,fixed_full_OO_pool,6.178954074349669,1268655593619456000,2752512000,686760832,3884.3922,3884.39432748538 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1348000,2004,0.39920159680638717,fixed_full_OO_pool,6.196899837145788,1272431354314752000,2760704000,688804960,3895.9554,3895.955730994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1352000,2004,0.29940119760479045,fixed_full_OO_pool,6.214847320848041,1276207115010048000,2768896000,690848736,3907.515725,3907.5154020467835 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1356000,2004,0.19960079840319359,fixed_full_OO_pool,6.23279362842958,1279982875705344000,2777088000,692892512,3919.07625,3919.075014619883 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1360000,2004,0.29940119760479045,fixed_full_OO_pool,6.250740366189016,1283758636400640000,2785280000,694936640,3930.637425,3930.6370102339183 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1364000,2004,0.19960079840319359,fixed_full_OO_pool,6.268688167493997,1287534397095936000,2793472000,696980416,3942.1987,3942.1964035087717 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1368000,2004,0.29940119760479045,fixed_full_OO_pool,6.286635981725736,1291310157791232000,2801664000,699024544,3953.760425,3953.7582383040935 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1372000,2004,0.19960079840319359,fixed_full_OO_pool,6.304582040893535,1295085918486528000,2809856000,701068320,3965.321975,3965.317551169591 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1376000,2004,0.19960079840319359,fixed_full_OO_pool,6.322527291055562,1298861679181824000,2818048000,703112448,3976.881325,3976.8800804093567 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1380000,2004,0.249500998003992,fixed_full_OO_pool,6.3404724638371,1302637439877120000,2826240000,705156224,3988.441275,3988.439861111111 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1384000,2004,0.4491017964071856,fixed_full_OO_pool,6.3584181660682795,1306413200572416000,2834432000,707200000,4000.0,4000.0 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1388000,2004,0.19960079840319359,fixed_full_OO_pool,6.376365366302845,1310188961267712000,2842624000,709244128,4011.5633,4011.5613742690057 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1392000,2004,0.249500998003992,fixed_full_OO_pool,6.394310723553515,1313964721963008000,2850816000,711287904,4023.1223,4023.121432748538 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1396000,2004,0.29940119760479045,fixed_full_OO_pool,6.4122557396824575,1317740482658304000,2859008000,713332032,4034.680675,4034.6842470760234 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1400000,2004,0.29940119760479045,fixed_full_OO_pool,6.430200635304468,1321516243353600000,2867200000,715375808,4046.246275,4046.2423757309944 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1404000,2004,0.19960079840319359,fixed_full_OO_pool,6.4481452852301295,1325292004048896000,2875392000,717419936,4057.804975,4057.80509502924 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1408000,2004,0.249500998003992,fixed_full_OO_pool,6.466091103759697,1329067764744192000,2883584000,719463712,4069.36705,4069.364254385965 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1412000,2004,0.29940119760479045,fixed_full_OO_pool,6.484036732278764,1332843525439488000,2891776000,721507840,4080.927125,4080.926571637427 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1416000,2004,0.09980039920159679,fixed_full_OO_pool,6.503257371310352,1336619286134784000,2899968000,723551616,4092.48215,4092.487792397661 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1420000,2004,0.19960079840319359,fixed_full_OO_pool,6.527152106981311,1340395046830080000,2908160000,725595392,4104.047075,4104.046118421053 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1424000,2004,0.29940119760479045,fixed_full_OO_pool,6.551599996681842,1344170807525376000,2916352000,727639520,4115.607175,4115.608428362573 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1428000,2004,0.249500998003992,fixed_full_OO_pool,6.5738858397242925,1347946568220672000,2924544000,729683296,4127.16805,4127.167938596491 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1432000,2004,0.5988023952095809,fixed_full_OO_pool,6.591797541671743,1351722328915968000,2932736000,731727424,4138.730525,4138.7295540935675 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1436000,2004,0.4491017964071856,fixed_full_OO_pool,6.609710363274854,1355498089611264000,2940928000,733771200,4150.290025,4150.289466374269 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1440000,2004,0.29940119760479045,fixed_full_OO_pool,6.627623759243224,1359273850306560000,2949120000,735815328,4161.849575,4161.851937134503 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1444000,2004,0.049900199600798396,fixed_full_OO_pool,6.645537266860613,1363049611001856000,2957312000,737859104,4173.41035,4173.4114766081875 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1448000,2004,0.249500998003992,fixed_full_OO_pool,6.663448659659673,1366825371697152000,2965504000,739903232,4184.97285,4184.9730847953215 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1452000,2004,0.09980039920159679,fixed_full_OO_pool,6.681359917720159,1370601132392448000,2973696000,741947008,4196.534825,4196.532273391813 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1456000,2004,0.249500998003992,fixed_full_OO_pool,6.699271194771346,1374376893087744000,2981888000,743990784,4208.093575,4208.09240497076 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1460000,2004,0.5489021956087825,fixed_full_OO_pool,6.717183372102057,1378152653783040000,2990080000,746034912,4219.6502,4219.655730994152 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1464000,2004,0.34930139720558884,fixed_full_OO_pool,6.735096788540896,1381928414478336000,2998272000,748078688,4231.2143,4231.214298245614 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1468000,2004,0.249500998003992,fixed_full_OO_pool,6.7530272611034,1385704175173632000,3006464000,750122816,4242.7771,4242.7758187134505 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1472000,2004,0.34930139720558884,fixed_full_OO_pool,6.7740752303890055,1389479935868928000,3014656000,752166592,4254.3352,4254.336140350877 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1476000,2004,0.29940119760479045,fixed_full_OO_pool,6.798814061188863,1393255696564224000,3022848000,754210720,4265.898375,4265.897551169591 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1480000,2004,0.19960079840319359,fixed_full_OO_pool,6.823004445111793,1397031457259520000,3031040000,756254496,4277.45625,4277.457938596492 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1484000,2004,0.249500998003992,fixed_full_OO_pool,6.842581349452957,1400807217954816000,3039232000,758298272,4289.017125,4289.017448830409 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1488000,2004,0.249500998003992,fixed_full_OO_pool,6.860493152737617,1404582978650112000,3047424000,760342400,4300.577425,4300.579700292397 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1492000,2004,0.19960079840319359,fixed_full_OO_pool,6.878405673040284,1408358739345408000,3055616000,762386176,4312.136475,4312.139744152047 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1496000,2004,0.09980039920159679,fixed_full_OO_pool,6.896319644322825,1412134500040704000,3063808000,764430304,4323.701025,4323.700752923976 +synthetic,standard8-phi3.6-wd0.1,standard8,791101,0.0001,0.1,3.6,1500000,2004,0.39920159680638717,fixed_full_OO_pool,6.9142334482353185,1415910260736000000,3072000000,766474080,4335.2594,4335.260994152047 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,256,2004,0.0,fixed_full_OO_pool,0.0011694812712570032,241648684498944,524288,131072,0.412975,0.41868786549707604 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,512,2004,0.0,fixed_full_OO_pool,0.0023931098801808224,483297368997888,1048576,262144,0.8341,0.8361842105263158 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1000,2004,0.14970059880239522,fixed_full_OO_pool,0.004907501930784848,943940173824000,2048000,511744,1.6305,1.63203216374269 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,2000,2004,0.0,fixed_full_OO_pool,0.009390006048811806,1887880347648000,4096000,1023232,3.263775,3.2627229532163744 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,3000,2004,0.09980039920159679,fixed_full_OO_pool,0.01440715896172656,2831820521472000,6144000,1534976,4.89595,4.894510233918129 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,4000,2004,0.09980039920159679,fixed_full_OO_pool,0.01888243477170666,3775760695296000,8192000,2046464,6.52905,6.525226608187134 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,5000,2004,0.19960079840319359,fixed_full_OO_pool,0.023386213922252257,4719700869120000,10240000,2557952,8.1597,8.156301169590643 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,6000,2004,0.14970059880239522,fixed_full_OO_pool,0.028455180602355135,5663641042944000,12288000,3069696,9.788625,9.788563596491228 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,7000,2004,0.049900199600798396,fixed_full_OO_pool,0.03344991458269457,6607581216768000,14336000,3581184,11.4216,11.419298245614035 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,8000,2004,0.049900199600798396,fixed_full_OO_pool,0.03839951253806551,7551521390592000,16384000,4092672,13.0503,13.050657894736842 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,9000,2004,0.049900199600798396,fixed_full_OO_pool,0.042873080050986674,8495461564416000,18432000,4604416,14.6867,14.681827485380117 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,10000,2004,0.09980039920159679,fixed_full_OO_pool,0.04734690893337958,9439401738240000,20480000,5115904,16.310875,16.313848684210527 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,11000,2004,0.14970059880239522,fixed_full_OO_pool,0.05206988318616317,10383341912064000,22528000,5627648,17.9435,17.945570175438597 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,12000,2004,0.09980039920159679,fixed_full_OO_pool,0.05717964538476533,11327282085888000,24576000,6139136,19.57665,19.57627923976608 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,13000,2004,0.29940119760479045,fixed_full_OO_pool,0.062185937700172264,12271222259712000,26624000,6650624,21.20495,21.20769736842105 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,14000,2004,0.049900199600798396,fixed_full_OO_pool,0.06714460789846877,13215162433536000,28672000,7162368,22.8415,22.838845029239767 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,15000,2004,0.14970059880239522,fixed_full_OO_pool,0.07161996649785174,14159102607360000,30720000,7673856,24.4697,24.470277777777778 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,16000,2004,0.09980039920159679,fixed_full_OO_pool,0.07609472764759428,15103042781184000,32768000,8185344,26.100225,26.101370614035087 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,17000,2004,0.249500998003992,fixed_full_OO_pool,0.0805682047880772,16046982955008000,34816000,8697088,27.7315,27.73328947368421 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,18000,2004,0.09980039920159679,fixed_full_OO_pool,0.08504261527934837,16990923128832000,36864000,9208576,29.365125,29.36392909356725 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,19000,2004,0.049900199600798396,fixed_full_OO_pool,0.08951678310624427,17934863302656000,38912000,9720320,30.995775,30.99593932748538 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,20000,2004,0.049900199600798396,fixed_full_OO_pool,0.09399269712571469,18878803476480000,40960000,10231808,32.62985,32.626513157894735 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,21000,2004,0.14970059880239522,fixed_full_OO_pool,0.09846739061694178,19822743650304000,43008000,10743296,34.2587,34.25785087719298 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,22000,2004,0.249500998003992,fixed_full_OO_pool,0.10294219316707717,20766683824128000,45056000,11255040,35.88965,35.88981725146199 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,23000,2004,0.19960079840319359,fixed_full_OO_pool,0.10741786236460837,21710623997952000,47104000,11766528,37.52075,37.52082602339181 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,24000,2004,0.14970059880239522,fixed_full_OO_pool,0.1118931969989919,22654564171776000,49152000,12278016,39.1531,39.151652046783624 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,25000,2004,0.19960079840319359,fixed_full_OO_pool,0.11636860396402578,23598504345600000,51200000,12789760,40.78145,40.783998538011694 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,26000,2004,0.14970059880239522,fixed_full_OO_pool,0.12084387401015394,24542444519424000,53248000,13301248,42.413275,42.41490131578947 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,27000,2004,0.19960079840319359,fixed_full_OO_pool,0.12531812912163634,25486384693248000,55296000,13812736,44.0468,44.04555555555555 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,28000,2004,0.14970059880239522,fixed_full_OO_pool,0.12979369548252886,26430324867072000,57344000,14324480,45.67505,45.67791666666667 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,29000,2004,0.14970059880239522,fixed_full_OO_pool,0.13426977841080062,27374265040896000,59392000,14835968,47.3092,47.308479532163744 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,30000,2004,0.14970059880239522,fixed_full_OO_pool,0.13874589967955317,28318205214720000,61440000,15347712,48.939325,48.94056652046783 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,31000,2004,0.09980039920159679,fixed_full_OO_pool,0.14322157587442133,29262145388544000,63488000,15859200,50.572825,50.571224415204675 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,32000,2004,0.34930139720558884,fixed_full_OO_pool,0.14769635300152004,30206085562368000,65536000,16370688,52.20115,52.20263888888889 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,33000,2004,0.14970059880239522,fixed_full_OO_pool,0.15217003665450546,31150025736192000,67584000,16882432,53.832525,53.83454312865497 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,34000,2004,0.14970059880239522,fixed_full_OO_pool,0.1566462250157363,32093965910016000,69632000,17393920,55.46365,55.46554824561404 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,35000,2004,0.14970059880239522,fixed_full_OO_pool,0.16112064520000582,33037906083840000,71680000,17905408,57.09505,57.096513157894734 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,36000,2004,0.19960079840319359,fixed_full_OO_pool,0.16559562056739296,33981846257664000,73728000,18417152,58.727825,58.72821271929825 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,37000,2004,0.049900199600798396,fixed_full_OO_pool,0.17006988894090885,34925786431488000,75776000,18928640,60.355625,60.35970394736842 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,38000,2004,0.049900199600798396,fixed_full_OO_pool,0.17454486505542363,35869726605312000,77824000,19440384,61.99095,61.99103070175438 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,39000,2004,0.09980039920159679,fixed_full_OO_pool,0.1790209204268952,36813666779136000,79872000,19951872,63.62315,63.62187865497076 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,40000,2004,0.29940119760479045,fixed_full_OO_pool,0.1834958273762216,37757606952960000,81920000,20463360,65.2529,65.25308479532164 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,41000,2004,0.049900199600798396,fixed_full_OO_pool,0.18797162452505695,38701547126784000,83968000,20975104,66.886125,66.88471856725147 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,42000,2004,0.14970059880239522,fixed_full_OO_pool,0.19244866443797945,39645487300608000,86016000,21486592,68.5145,68.51612573099415 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,43000,2004,0.09980039920159679,fixed_full_OO_pool,0.19692431770161622,40589427474432000,88064000,21998080,70.148525,70.14670687134503 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,44000,2004,0.249500998003992,fixed_full_OO_pool,0.20140067824783425,41533367648256000,90112000,22509824,71.78185,71.77832602339181 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,45000,2004,0.049900199600798396,fixed_full_OO_pool,0.20587690265952713,42477307822080000,92160000,23021312,73.41665,73.40879385964912 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,46000,2004,0.14970059880239522,fixed_full_OO_pool,0.21035257196467783,43421247995904000,94208000,23532800,75.041875,75.04066154970761 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,47000,2004,0.29940119760479045,fixed_full_OO_pool,0.21482842311780487,44365188169728000,96256000,24044544,76.67005,76.673033625731 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,48000,2004,0.19960079840319359,fixed_full_OO_pool,0.21930544095631274,45309128343552000,98304000,24556032,78.304225,78.30359283625731 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,49000,2004,0.09980039920159679,fixed_full_OO_pool,0.22378080546338525,46253068517376000,100352000,25067776,79.935,79.93558479532163 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,50000,2004,0.049900199600798396,fixed_full_OO_pool,0.22825789663423265,47197008691200000,102400000,25579264,81.564025,81.56689692982457 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,51000,2004,0.14970059880239522,fixed_full_OO_pool,0.23273381114833885,48140948865024000,104448000,26090752,83.19275,83.19825292397661 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,52000,2004,0.14970059880239522,fixed_full_OO_pool,0.237209905291804,49084889038848000,106496000,26602496,84.829475,84.829375 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,53000,2004,0.249500998003992,fixed_full_OO_pool,0.2416861574424224,50028829212672000,108544000,27113984,86.46075,86.4603581871345 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,54000,2004,0.14970059880239522,fixed_full_OO_pool,0.24616172702983022,50972769386496000,110592000,27625472,88.0915,88.09141812865496 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,55000,2004,0.09980039920159679,fixed_full_OO_pool,0.25063666545372043,51916709560320000,112640000,28137216,89.720875,89.72361476608187 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,56000,2004,0.19960079840319359,fixed_full_OO_pool,0.25511214149598443,52860649734144000,114688000,28648704,91.355375,91.3541264619883 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,57000,2004,0.19960079840319359,fixed_full_OO_pool,0.25958833520197205,53804589907968000,116736000,29160448,92.98645,92.98607456140351 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,58000,2004,0.14970059880239522,fixed_full_OO_pool,0.2640650872161819,54748530081792000,118784000,29671936,94.616975,94.61716739766082 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,59000,2004,0.14970059880239522,fixed_full_OO_pool,0.26854011218063534,55692470255616000,120832000,30183424,96.249875,96.2479130116959 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,60000,2004,0.14970059880239522,fixed_full_OO_pool,0.2730146651787476,56636410429440000,122880000,30695168,97.879975,97.88000365497076 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,61000,2004,0.19960079840319359,fixed_full_OO_pool,0.27749042300507426,57580350603264000,124928000,31206656,99.5082,99.51143274853801 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,62000,2004,0.14970059880239522,fixed_full_OO_pool,0.28196478083522786,58524290777088000,126976000,31718144,101.140075,101.14232821637427 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,63000,2004,0.14970059880239522,fixed_full_OO_pool,0.28643957309528356,59468230950912000,129024000,32229888,102.777075,102.7734100877193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,64000,2004,0.049900199600798396,fixed_full_OO_pool,0.29091521540553206,60412171124736000,131072000,32741376,104.4066,104.40464912280702 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,68000,2004,0.19960079840319359,fixed_full_OO_pool,0.30881312334392635,64187931820032000,139264000,34787840,110.929625,110.93075657894737 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,72000,2004,0.19960079840319359,fixed_full_OO_pool,0.3267122074785746,67963692515328000,147456000,36834048,117.453525,117.4558004385965 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,76000,2004,0.14970059880239522,fixed_full_OO_pool,0.34460934904300505,71739453210624000,155648000,38880512,123.9815,123.98118421052632 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,80000,2004,0.049900199600798396,fixed_full_OO_pool,0.36251044653666514,75515213905920000,163840000,40926720,130.5097,130.50559941520467 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,84000,2004,0.14970059880239522,fixed_full_OO_pool,0.3804084993298683,79290974601216000,172032000,42972928,137.031775,137.0309100877193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,88000,2004,0.14970059880239522,fixed_full_OO_pool,0.39830607598233553,83066735296512000,180224000,45019392,143.557075,143.55668494152047 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,92000,2004,0.0,fixed_full_OO_pool,0.4162062523824473,86842495991808000,188416000,47065600,150.0823,150.0815350877193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,96000,2004,0.09980039920159679,fixed_full_OO_pool,0.43410496194846926,90618256687104000,196608000,49112064,156.60565,156.60759502923977 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,100000,2004,0.29940119760479045,fixed_full_OO_pool,0.4520036373484052,94394017382400000,204800000,51158272,163.130525,163.13249634502924 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,104000,2004,0.19960079840319359,fixed_full_OO_pool,0.46990158229238455,98169778077696000,212992000,53204736,169.654125,169.6585197368421 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,108000,2004,0.09980039920159679,fixed_full_OO_pool,0.487800697757759,101945538772992000,221184000,55250944,176.18455,176.1826096491228 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,112000,2004,0.14970059880239522,fixed_full_OO_pool,0.5057043264702791,105721299468288000,229376000,57297408,182.709075,182.70849780701755 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,116000,2004,0.249500998003992,fixed_full_OO_pool,0.5236069922780411,109497060163584000,237568000,59343616,189.233275,189.23349780701756 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,120000,2004,0.249500998003992,fixed_full_OO_pool,0.541509434270362,113272820858880000,245760000,61390080,195.763725,195.75851973684212 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,124000,2004,0.249500998003992,fixed_full_OO_pool,0.559409762441905,117048581554176000,253952000,63436288,202.284825,202.28397295321636 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,128000,2004,0.19960079840319359,fixed_full_OO_pool,0.5773096723192268,120824342249472000,262144000,65482752,208.811175,208.80959429824563 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,132000,2004,0.249500998003992,fixed_full_OO_pool,0.5952099743009441,124600102944768000,270336000,67528960,215.335825,215.33452850877194 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,136000,2004,0.14970059880239522,fixed_full_OO_pool,0.6131110975446387,128375863640064000,278528000,69575424,221.859925,221.8604788011696 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,140000,2004,0.14970059880239522,fixed_full_OO_pool,0.631014979860435,132151624335360000,286720000,71621632,228.384975,228.38535453216375 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,144000,2004,0.29940119760479045,fixed_full_OO_pool,0.6489170186387168,135927385030656000,294912000,73668096,234.91125,234.91098684210527 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,148000,2004,0.19960079840319359,fixed_full_OO_pool,0.6668178464099764,139703145725952000,303104000,75714304,241.4382,241.43558479532163 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,152000,2004,0.049900199600798396,fixed_full_OO_pool,0.6847179940705084,143478906421248000,311296000,77760768,247.961725,247.96161915204678 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,156000,2004,0.14970059880239522,fixed_full_OO_pool,0.7026209780294448,147254667116544000,319488000,79806976,254.4794,254.48757309941521 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,160000,2004,0.049900199600798396,fixed_full_OO_pool,0.7205217976433536,151030427811840000,327680000,81853184,261.01085,261.01151315789474 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,164000,2004,0.09980039920159679,fixed_full_OO_pool,0.7384203737291197,154806188507136000,335872000,83899648,267.540575,267.5366410818713 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,168000,2004,0.049900199600798396,fixed_full_OO_pool,0.7563186030814217,158581949202432000,344064000,85945856,274.0624,274.0619883040936 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,172000,2004,0.049900199600798396,fixed_full_OO_pool,0.774214662551466,162357709897728000,352256000,87992320,280.5924,280.58707602339183 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,176000,2004,0.14970059880239522,fixed_full_OO_pool,0.7921123722195625,166133470593024000,360448000,90038528,287.112375,287.1126937134503 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,180000,2004,0.14970059880239522,fixed_full_OO_pool,0.8100095096509904,169909231288320000,368640000,92084992,293.6389,293.6382894736842 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,184000,2004,0.14970059880239522,fixed_full_OO_pool,0.8279074905109074,173684991983616000,376832000,94131200,300.161475,300.1635270467836 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,188000,2004,0.29940119760479045,fixed_full_OO_pool,0.8458043719745345,177460752678912000,385024000,96177664,306.690925,306.6886951754386 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,192000,2004,0.249500998003992,fixed_full_OO_pool,0.8637009629141539,181236513374208000,393216000,98223872,313.214825,313.2137390350877 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,196000,2004,0.09980039920159679,fixed_full_OO_pool,0.8815982299970669,185012274069504000,401408000,100270336,319.7388,319.7397076023392 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,200000,2004,0.09980039920159679,fixed_full_OO_pool,0.8994954336310427,188788034764800000,409600000,102316544,326.26785,326.2639985380117 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,204000,2004,0.14970059880239522,fixed_full_OO_pool,0.9173927832508667,192563795460096000,417792000,104363008,332.790075,332.79022295321636 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,208000,2004,0.29940119760479045,fixed_full_OO_pool,0.9352894845842901,196339556155392000,425984000,106409216,339.3112,339.3156725146199 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,212000,2004,0.14970059880239522,fixed_full_OO_pool,0.9531869611185458,200115316850688000,434176000,108455680,345.838675,345.8411293859649 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,216000,2004,0.19960079840319359,fixed_full_OO_pool,0.971087635272286,203891077545984000,442368000,110501888,352.36695,352.365533625731 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,220000,2004,0.29940119760479045,fixed_full_OO_pool,0.9889838869248827,207666838241280000,450560000,112548352,358.891375,358.89143640350875 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,224000,2004,0.34930139720558884,fixed_full_OO_pool,1.0068818454682413,211442598936576000,458752000,114594560,365.41325,365.4167763157895 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,228000,2004,0.14970059880239522,fixed_full_OO_pool,1.024779097907659,215218359631872000,466944000,116641024,371.944975,371.94161184210526 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,232000,2004,0.4491017964071856,fixed_full_OO_pool,1.0426764647848905,218994120327168000,475136000,118687232,378.464275,378.46732821637426 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,236000,2004,0.14970059880239522,fixed_full_OO_pool,1.060575330407462,222769881022464000,483328000,120733696,384.9926,384.99266081871343 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,240000,2004,0.19960079840319359,fixed_full_OO_pool,1.0784768009806673,226545641717760000,491520000,122779904,391.5193,391.51729532163745 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,244000,2004,0.249500998003992,fixed_full_OO_pool,1.0963752824161201,230321402413056000,499712000,124826112,398.042225,398.0424817251462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,248000,2004,0.249500998003992,fixed_full_OO_pool,1.1142780577080946,234097163108352000,507904000,126872576,404.567575,404.56824926900583 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,252000,2004,0.19960079840319359,fixed_full_OO_pool,1.132177757560793,237872923803648000,516096000,128918784,411.0936,411.09298245614036 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,256000,2004,0.29940119760479045,fixed_full_OO_pool,1.150080175805423,241648684498944000,524288000,130965248,417.61815,417.61886695906435 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,260000,2004,0.249500998003992,fixed_full_OO_pool,1.1679784571017242,245424445194240000,532480000,133011456,424.142975,424.1437755847953 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,264000,2004,0.14970059880239522,fixed_full_OO_pool,1.185878340230427,249200205889536000,540672000,135057920,430.67075,430.6691885964912 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,268000,2004,0.34930139720558884,fixed_full_OO_pool,1.2037803937349882,252975966584832000,548864000,137104128,437.191275,437.194725877193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,272000,2004,0.34930139720558884,fixed_full_OO_pool,1.2216805555774934,256751727280128000,557056000,139150592,443.7231,443.71954678362573 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,276000,2004,0.29940119760479045,fixed_full_OO_pool,1.2395822382511363,260527487975424000,565248000,141196800,450.245675,450.2447843567251 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,280000,2004,0.14970059880239522,fixed_full_OO_pool,1.2574867719287675,264303248670720000,573440000,143243264,456.769775,456.7707346491228 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,284000,2004,0.049900199600798396,fixed_full_OO_pool,1.2753947666463339,268079009366016000,581632000,145289472,463.2998,463.29488304093564 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,288000,2004,0.19960079840319359,fixed_full_OO_pool,1.2932999999872927,271854770061312000,589824000,147335936,469.82105,469.82125 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,292000,2004,0.09980039920159679,fixed_full_OO_pool,1.3112027406206148,275630530756608000,598016000,149382144,476.347325,476.3459466374269 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,296000,2004,0.19960079840319359,fixed_full_OO_pool,1.3291039020847528,279406291451904000,606208000,151428608,482.872525,482.8717361111111 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,300000,2004,0.09980039920159679,fixed_full_OO_pool,1.3470063004373676,283182052147200000,614400000,153474816,489.39375,489.39717105263156 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,304000,2004,0.19960079840319359,fixed_full_OO_pool,1.3649074171431776,286957812842496000,622592000,155521280,495.924625,495.9221308479532 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,308000,2004,0.34930139720558884,fixed_full_OO_pool,1.3828129373997864,290733573537792000,630784000,157567488,502.44855,502.4471710526316 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,312000,2004,0.39920159680638717,fixed_full_OO_pool,1.4007189207151531,294509334233088000,638976000,159613952,508.97245,508.97315058479535 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,316000,2004,0.249500998003992,fixed_full_OO_pool,1.4186232316618164,298285094928384000,647168000,161660160,515.499175,515.4977814327485 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,320000,2004,0.049900199600798396,fixed_full_OO_pool,1.436527390030937,302060855623680000,655360000,163706368,522.02315,522.0228143274854 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,324000,2004,0.14970059880239522,fixed_full_OO_pool,1.4544315282658984,305836616318976000,663552000,165752832,528.550525,528.5482858187135 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,328000,2004,0.29940119760479045,fixed_full_OO_pool,1.4723342043440788,309612377014272000,671744000,167799040,535.075275,535.0732054093568 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,332000,2004,0.29940119760479045,fixed_full_OO_pool,1.490234386401458,313388137709568000,679936000,169845504,541.599425,541.5991483918128 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,336000,2004,0.19960079840319359,fixed_full_OO_pool,1.5081395049920927,317163898404864000,688128000,171891712,548.1241,548.1240789473684 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,340000,2004,0.14970059880239522,fixed_full_OO_pool,1.5260429828582953,320939659100160000,696320000,173938176,554.6525,554.6494005847953 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,344000,2004,0.09980039920159679,fixed_full_OO_pool,1.5439436720125377,324715419795456000,704512000,175984384,561.176225,561.1744700292397 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,348000,2004,0.499001996007984,fixed_full_OO_pool,1.5618439521775063,328491180490752000,712704000,178030848,567.6995,567.7005409356725 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,352000,2004,0.5489021956087825,fixed_full_OO_pool,1.579744755776806,332266941186048000,720896000,180077056,574.229,574.2247660818714 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,356000,2004,0.4491017964071856,fixed_full_OO_pool,1.5976462346667217,336042701881344000,729088000,182123520,580.74945,580.75125 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,360000,2004,0.249500998003992,fixed_full_OO_pool,1.6155489405047976,339818462576640000,737280000,184169728,587.2773,587.275716374269 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,364000,2004,0.29940119760479045,fixed_full_OO_pool,1.633450072557769,343594223271936000,745472000,186216192,593.80205,593.801571637427 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,368000,2004,0.249500998003992,fixed_full_OO_pool,1.6513528680480603,347369983967232000,753664000,188262400,600.328575,600.3262317251462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,372000,2004,0.19960079840319359,fixed_full_OO_pool,1.6692516293221464,351145744662528000,761856000,190308864,606.854025,606.8519846491228 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,376000,2004,0.249500998003992,fixed_full_OO_pool,1.6871549743507057,354921505357824000,770048000,192355072,613.377875,613.3770358187135 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,380000,2004,0.09980039920159679,fixed_full_OO_pool,1.70505771261019,358697266053120000,778240000,194401536,619.905425,619.9024817251462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,384000,2004,0.19960079840319359,fixed_full_OO_pool,1.7229596259807134,362473026748416000,786432000,196447744,626.429275,626.4275328947368 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,388000,2004,0.09980039920159679,fixed_full_OO_pool,1.740859488973187,366248787443712000,794624000,198494208,632.953,632.9535380116959 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,392000,2004,0.19960079840319359,fixed_full_OO_pool,1.7587592818515583,370024548139008000,802816000,200540416,639.47635,639.4786622807018 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,396000,2004,0.049900199600798396,fixed_full_OO_pool,1.7766551822475676,373800308834304000,811008000,202586624,646.00355,646.0032236842105 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,400000,2004,0.14970059880239522,fixed_full_OO_pool,1.7945527442472262,377576069529600000,819200000,204633088,652.52465,652.5296125730994 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,404000,2004,0.29940119760479045,fixed_full_OO_pool,1.8124500792225202,381351830224896000,827392000,206679296,659.053775,659.0538925438597 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,408000,2004,0.09980039920159679,fixed_full_OO_pool,1.8303472727237062,385127590920192000,835584000,208725760,665.582875,665.5791118421052 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,412000,2004,0.09980039920159679,fixed_full_OO_pool,1.848247567601502,388903351615488000,843776000,210771968,672.1037,672.1046052631579 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,416000,2004,0.29940119760479045,fixed_full_OO_pool,1.8661452502467566,392679112310784000,851968000,212818432,678.629725,678.630274122807 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,420000,2004,0.249500998003992,fixed_full_OO_pool,1.884042495154879,396454873006080000,860160000,214864640,685.153725,685.1553033625731 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,424000,2004,0.19960079840319359,fixed_full_OO_pool,1.90194106250277,400230633701376000,868352000,216911104,691.68155,691.6807090643275 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,428000,2004,0.29940119760479045,fixed_full_OO_pool,1.919840325979102,404006394396672000,876544000,218957312,698.205125,698.2058004385965 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,432000,2004,0.09980039920159679,fixed_full_OO_pool,1.9377400288006499,407782155091968000,884736000,221003776,704.73425,704.7310160818713 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,436000,2004,0.249500998003992,fixed_full_OO_pool,1.955637394381273,411557915787264000,892928000,223049984,711.25405,711.2566593567251 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,440000,2004,0.249500998003992,fixed_full_OO_pool,1.973537861633425,415333676482560000,901120000,225096448,717.782775,717.7819334795322 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,444000,2004,0.29940119760479045,fixed_full_OO_pool,1.9914389879649712,419109437177856000,909312000,227142656,724.311975,724.3062024853801 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,448000,2004,0.34930139720558884,fixed_full_OO_pool,2.009339770168687,422885197873152000,917504000,229189120,730.8328,730.8326315789474 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,452000,2004,0.34930139720558884,fixed_full_OO_pool,2.0272410503598963,426660958568448000,925696000,231235328,737.355575,737.3578399122807 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,456000,2004,0.34930139720558884,fixed_full_OO_pool,2.0451422340754006,430436719263744000,933888000,233281792,743.8846,743.8830701754385 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,460000,2004,0.19960079840319359,fixed_full_OO_pool,2.063047526160048,434212479959040000,942080000,235328000,750.409,750.4080409356725 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,464000,2004,0.4491017964071856,fixed_full_OO_pool,2.0809466567428574,437988240654336000,950272000,237374464,756.931775,756.9341849415205 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,468000,2004,0.14970059880239522,fixed_full_OO_pool,2.0988496431035712,441764001349632000,958464000,239420672,763.45835,763.4588377192982 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,472000,2004,0.29940119760479045,fixed_full_OO_pool,2.116752532141076,445539762044928000,966656000,241467136,769.984375,769.9845065789474 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,476000,2004,0.14970059880239522,fixed_full_OO_pool,2.134658841353117,449315522740224000,974848000,243513344,776.5063,776.5098391812866 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,480000,2004,0.249500998003992,fixed_full_OO_pool,2.152566298548546,453091283435520000,983040000,245559552,783.0342,783.0342982456141 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,484000,2004,0.049900199600798396,fixed_full_OO_pool,2.1704714778427863,456867044130816000,991232000,247606016,789.559875,789.5600182748537 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,488000,2004,0.049900199600798396,fixed_full_OO_pool,2.188376239721353,460642804826112000,999424000,249652224,796.08695,796.0845979532164 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,492000,2004,0.29940119760479045,fixed_full_OO_pool,2.206276531278466,464418565521408000,1007616000,251698688,802.611575,802.610471491228 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,496000,2004,0.09980039920159679,fixed_full_OO_pool,2.224177573449496,468194326216704000,1015808000,253744896,809.136325,809.1353910818714 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,500000,2004,0.249500998003992,fixed_full_OO_pool,2.242079669268181,471970086912000000,1024000000,255791360,815.660125,815.6613852339182 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,504000,2004,0.34930139720558884,fixed_full_OO_pool,2.259979692896207,475745847607296000,1032192000,257837568,822.185675,822.1861878654971 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,508000,2004,0.09980039920159679,fixed_full_OO_pool,2.277876270248865,479521608302592000,1040384000,259884032,828.71065,828.7120102339181 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,512000,2004,0.14970059880239522,fixed_full_OO_pool,2.2957740771087507,483297368997888000,1048576000,261930240,835.23295,835.2372880116959 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,516000,2004,0.19960079840319359,fixed_full_OO_pool,2.313672130888121,487073129693184000,1056768000,263976704,841.763075,841.7623574561403 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,520000,2004,0.19960079840319359,fixed_full_OO_pool,2.331568913133815,490848890388480000,1064960000,266022912,848.28965,848.2870102339182 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,524000,2004,0.29940119760479045,fixed_full_OO_pool,2.3494668706992847,494624651083776000,1073152000,268069376,854.814675,854.8128252923976 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,528000,2004,0.0,fixed_full_OO_pool,2.3673681997538853,498400411779072000,1081344000,270115584,861.340575,861.337576754386 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,532000,2004,0.4491017964071856,fixed_full_OO_pool,2.3852651641269524,502176172474368000,1089536000,272162048,867.8607,867.8641081871345 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,536000,2004,0.19960079840319359,fixed_full_OO_pool,2.4031659781953527,505951933169664000,1097728000,274208256,874.3878,874.3886842105263 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,540000,2004,0.14970059880239522,fixed_full_OO_pool,2.42106493071239,509727693864960000,1105920000,276254720,880.911925,880.9146308479532 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,544000,2004,0.29940119760479045,fixed_full_OO_pool,2.4389677264396514,513503454560256000,1114112000,278300928,887.4355,887.4397222222223 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,548000,2004,0.19960079840319359,fixed_full_OO_pool,2.456866685292787,517279215255552000,1122304000,280347392,893.965575,893.9647989766082 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,552000,2004,0.14970059880239522,fixed_full_OO_pool,2.4747682557130855,521054975950848000,1130496000,282393600,900.4841,900.4906286549708 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,556000,2004,0.14970059880239522,fixed_full_OO_pool,2.4926685761349896,524830736646144000,1138688000,284439808,907.014725,907.0146893274854 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,560000,2004,0.29940119760479045,fixed_full_OO_pool,2.5105652445130464,528606497341440000,1146880000,286486272,913.539325,913.5405665204678 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,564000,2004,0.34930139720558884,fixed_full_OO_pool,2.5284607347939163,532382258036736000,1155072000,288532480,920.064275,920.0654568713451 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,568000,2004,0.249500998003992,fixed_full_OO_pool,2.54635606327715,536158018732032000,1163264000,290578944,926.594875,926.590456871345 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,572000,2004,0.19960079840319359,fixed_full_OO_pool,2.5642517310132584,539933779427328000,1171456000,292625152,933.1148,933.116081871345 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,576000,2004,0.34930139720558884,fixed_full_OO_pool,2.5821510005038646,543709540122624000,1179648000,294671616,939.638775,939.6420504385965 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,580000,2004,0.14970059880239522,fixed_full_OO_pool,2.6000462860841718,547485300817920000,1187840000,296717824,946.168025,946.166312134503 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,584000,2004,0.39920159680638717,fixed_full_OO_pool,2.617944465779389,551261061513216000,1196032000,298764288,952.690725,952.6924671052632 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,588000,2004,0.14970059880239522,fixed_full_OO_pool,2.6358401167620387,555036822208512000,1204224000,300810496,959.216975,959.2171673976608 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,592000,2004,0.0,fixed_full_OO_pool,2.6537362235039472,558812582903808000,1212416000,302856960,965.746525,965.7423209064327 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,596000,2004,0.14970059880239522,fixed_full_OO_pool,2.671635539111578,562588343599104000,1220608000,304903168,972.265375,972.2681030701755 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,600000,2004,0.09980039920159679,fixed_full_OO_pool,2.6895333284439724,566364104294400000,1228800000,306949632,978.793025,978.7935343567251 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,604000,2004,0.249500998003992,fixed_full_OO_pool,2.7074299244831006,570139864989696000,1236992000,308995840,985.318275,985.3183808479532 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,608000,2004,0.19960079840319359,fixed_full_OO_pool,2.7253235702433933,573915625684992000,1245184000,311042304,991.843275,991.8441995614035 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,612000,2004,0.14970059880239522,fixed_full_OO_pool,2.7432213315512572,577691386380288000,1253376000,313088512,998.367125,998.3692507309942 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,616000,2004,0.4491017964071856,fixed_full_OO_pool,2.761120832092646,581467147075584000,1261568000,315134976,1004.89305,1004.8949342105263 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,620000,2004,0.19960079840319359,fixed_full_OO_pool,2.7790241832865608,585242907770880000,1269760000,317181184,1011.419075,1011.4196673976609 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,624000,2004,0.09980039920159679,fixed_full_OO_pool,2.796923661654194,589018668466176000,1277952000,319227648,1017.94655,1017.9451242690059 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,628000,2004,0.0,fixed_full_OO_pool,2.8148233978460646,592794429161472000,1286144000,321273856,1024.4692,1024.470350877193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,632000,2004,0.049900199600798396,fixed_full_OO_pool,2.832724661489742,596570189856768000,1294336000,323320320,1030.9954,1030.9959941520467 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,636000,2004,0.09980039920159679,fixed_full_OO_pool,2.850624680068965,600345950552064000,1302528000,325366528,1037.51875,1037.5211184210527 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,640000,2004,0.14970059880239522,fixed_full_OO_pool,2.8685224481102907,604121711247360000,1310720000,327412736,1044.046025,1044.0456688596491 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,644000,2004,0.09980039920159679,fixed_full_OO_pool,2.886425391747099,607897471942656000,1318912000,329459200,1050.569475,1050.5717141812866 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,648000,2004,0.09980039920159679,fixed_full_OO_pool,2.9043248392703633,611673232637952000,1327104000,331505408,1057.095525,1057.0964437134503 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,652000,2004,0.29940119760479045,fixed_full_OO_pool,2.9222239491674635,615448993333248000,1335296000,333551872,1063.6214,1063.622134502924 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,656000,2004,0.249500998003992,fixed_full_OO_pool,2.9401210158256195,619224754028544000,1343488000,335598080,1070.148925,1070.146648391813 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,660000,2004,0.14970059880239522,fixed_full_OO_pool,2.95801734133934,623000514723840000,1351680000,337644544,1076.674075,1076.6724451754385 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,664000,2004,0.34930139720558884,fixed_full_OO_pool,2.975914246023943,626776275419136000,1359872000,339690752,1083.19835,1083.1974342105264 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,668000,2004,0.29940119760479045,fixed_full_OO_pool,2.9938106014755452,630552036114432000,1368064000,341737216,1089.72275,1089.723340643275 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,672000,2004,0.29940119760479045,fixed_full_OO_pool,3.0117092392510836,634327796809728000,1376256000,343783424,1096.2529,1096.247470760234 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,676000,2004,0.249500998003992,fixed_full_OO_pool,3.029607556887592,638103557505024000,1384448000,345829888,1102.7743,1102.7738157894737 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,680000,2004,0.09980039920159679,fixed_full_OO_pool,3.047507352297091,641879318200320000,1392640000,347876096,1109.302275,1109.2982638888889 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,684000,2004,0.049900199600798396,fixed_full_OO_pool,3.065408381149173,645655078895616000,1400832000,349922560,1115.822275,1115.8248135964911 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,688000,2004,0.34930139720558884,fixed_full_OO_pool,3.0833081453376345,649430839590912000,1409024000,351968768,1122.351,1122.3491520467837 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,692000,2004,0.09980039920159679,fixed_full_OO_pool,3.10120600209261,653206600286208000,1417216000,354015232,1128.875075,1128.8751059941521 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,696000,2004,0.14970059880239522,fixed_full_OO_pool,3.119110271030416,656982360981504000,1425408000,356061440,1135.395625,1135.4006396198831 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,700000,2004,0.29940119760479045,fixed_full_OO_pool,3.137011260802133,660758121676800000,1433600000,358107904,1141.9251,1141.9258040935672 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,704000,2004,0.049900199600798396,fixed_full_OO_pool,3.1549090337980954,664533882372096000,1441792000,360154112,1148.44995,1148.4507090643274 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,708000,2004,0.29940119760479045,fixed_full_OO_pool,3.172805045310201,668309643067392000,1449984000,362200576,1154.97815,1154.9760599415204 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,712000,2004,0.19960079840319359,fixed_full_OO_pool,3.1907011601825555,672085403762688000,1458176000,364246784,1161.502725,1161.501005116959 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,716000,2004,0.4491017964071856,fixed_full_OO_pool,3.2085957660288034,675861164457984000,1466368000,366292992,1168.026725,1168.0260343567252 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,720000,2004,0.19960079840319359,fixed_full_OO_pool,3.2264905853393593,679636925153280000,1474560000,368339456,1174.5495,1174.5521783625732 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,724000,2004,0.249500998003992,fixed_full_OO_pool,3.244384624434428,683412685848576000,1482752000,370385664,1181.07815,1181.0765277777778 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,728000,2004,0.29940119760479045,fixed_full_OO_pool,3.2622806478436623,687188446543872000,1490944000,372432128,1187.599725,1187.6028472222222 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,732000,2004,0.14970059880239522,fixed_full_OO_pool,3.2801784073592475,690964207239168000,1499136000,374478336,1194.12625,1194.1275073099416 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,736000,2004,0.34930139720558884,fixed_full_OO_pool,3.2980734029370877,694739967934464000,1507328000,376524800,1200.653825,1200.6529495614036 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,740000,2004,0.29940119760479045,fixed_full_OO_pool,3.3159678691190977,698515728629760000,1515520000,378571008,1207.174725,1207.1784320175439 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,744000,2004,0.19960079840319359,fixed_full_OO_pool,3.333863220884361,702291489325056000,1523712000,380617472,1213.702075,1213.7039071637428 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,748000,2004,0.29940119760479045,fixed_full_OO_pool,3.3517620355873885,706067250020352000,1531904000,382663680,1220.225675,1220.228994883041 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,752000,2004,0.19960079840319359,fixed_full_OO_pool,3.369659623077346,709843010715648000,1540096000,384710144,1226.75395,1226.7543347953217 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,756000,2004,0.19960079840319359,fixed_full_OO_pool,3.3875546458932675,713618771410944000,1548288000,386756352,1233.2791,1233.2791959064327 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,760000,2004,0.14970059880239522,fixed_full_OO_pool,3.405450806274182,717394532106240000,1556480000,388802816,1239.804525,1239.8049524853802 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,764000,2004,0.29940119760479045,fixed_full_OO_pool,3.423347310549062,721170292801536000,1564672000,390849024,1246.3319,1246.3294883040935 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,768000,2004,0.4491017964071856,fixed_full_OO_pool,3.4412439498802025,724946053496832000,1572864000,392895488,1252.856725,1252.855332602339 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,772000,2004,0.09980039920159679,fixed_full_OO_pool,3.4591425902841406,728721814192128000,1581056000,394941696,1259.380075,1259.3804568713451 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,776000,2004,0.19960079840319359,fixed_full_OO_pool,3.477038571335789,732497574887424000,1589248000,396988160,1265.9052,1265.9062573099416 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,780000,2004,0.29940119760479045,fixed_full_OO_pool,3.4949352800101043,736273335582720000,1597440000,399034368,1272.43,1272.4311695906433 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,784000,2004,0.5489021956087825,fixed_full_OO_pool,3.512832822697237,740049096278016000,1605632000,401080832,1278.957575,1278.9566118421053 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,788000,2004,0.5489021956087825,fixed_full_OO_pool,3.530731704669694,743824856973312000,1613824000,403127040,1285.480925,1285.481736111111 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,792000,2004,0.249500998003992,fixed_full_OO_pool,3.548632469582889,747600617668608000,1622016000,405173248,1292.006575,1292.006524122807 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,796000,2004,0.4491017964071856,fixed_full_OO_pool,3.5665351244527845,751376378363904000,1630208000,407219712,1298.530425,1298.5325109649123 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,800000,2004,0.09980039920159679,fixed_full_OO_pool,3.584432219463504,755152139059200000,1638400000,409265920,1305.056825,1305.0571893274853 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,804000,2004,0.14970059880239522,fixed_full_OO_pool,3.6023330818851376,758927899754496000,1646592000,411312384,1311.584675,1311.582591374269 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,808000,2004,0.249500998003992,fixed_full_OO_pool,3.620234133736748,762703660449792000,1654784000,413358592,1318.1077,1318.1077631578946 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,812000,2004,0.19960079840319359,fixed_full_OO_pool,3.6381332844816563,766479421145088000,1662976000,415405056,1324.6323,1324.6336403508772 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,816000,2004,0.29940119760479045,fixed_full_OO_pool,3.6560322807739594,770255181840384000,1671168000,417451264,1331.1573,1331.1585233918129 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,820000,2004,0.19960079840319359,fixed_full_OO_pool,3.673931693840358,774030942535680000,1679360000,419497728,1337.68455,1337.6840131578947 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,824000,2004,0.19960079840319359,fixed_full_OO_pool,3.6918291950246527,777806703230976000,1687552000,421543936,1344.2104,1344.2087719298245 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,828000,2004,0.39920159680638717,fixed_full_OO_pool,3.709728942659373,781582463926272000,1695744000,423590400,1350.736375,1350.7344480994152 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,832000,2004,0.34930139720558884,fixed_full_OO_pool,3.727625644506059,785358224621568000,1703936000,425636608,1357.26155,1357.2593055555556 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,836000,2004,0.29940119760479045,fixed_full_OO_pool,3.7455245444664937,789133985316864000,1712128000,427683072,1363.786375,1363.7851498538012 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,840000,2004,0.249500998003992,fixed_full_OO_pool,3.763420023231043,792909746012160000,1720320000,429729280,1370.3079,1370.3105409356724 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,844000,2004,0.5489021956087825,fixed_full_OO_pool,3.7813169981301247,796685506707456000,1728512000,431775744,1376.836875,1376.835778508772 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,848000,2004,0.249500998003992,fixed_full_OO_pool,3.7992166987961777,800461267402752000,1736704000,433821952,1383.35955,1383.3610014619883 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,852000,2004,0.39920159680638717,fixed_full_OO_pool,3.8171129460705235,804237028098048000,1744896000,435868416,1389.88515,1389.8867324561404 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,856000,2004,0.249500998003992,fixed_full_OO_pool,3.8350112126757288,808012788793344000,1753088000,437914624,1396.4091,1396.4117690058479 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,860000,2004,0.049900199600798396,fixed_full_OO_pool,3.8529069923299053,811788549488640000,1761280000,439961088,1402.935675,1402.9373574561403 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,864000,2004,0.34930139720558884,fixed_full_OO_pool,3.8708086309944174,815564310183936000,1769472000,442007296,1409.461675,1409.4620942982456 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,868000,2004,0.34930139720558884,fixed_full_OO_pool,3.888705592284807,819340070879232000,1777664000,444053760,1415.9872,1415.98783625731 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,872000,2004,0.14970059880239522,fixed_full_OO_pool,3.9066014395850814,823115831574528000,1785856000,446099968,1422.51175,1422.5127850877193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,876000,2004,0.19960079840319359,fixed_full_OO_pool,3.924499596025174,826891592269824000,1794048000,448146176,1429.037575,1429.03754751462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,880000,2004,0.39920159680638717,fixed_full_OO_pool,3.9424001092722434,830667352965120000,1802240000,450192640,1435.563525,1435.5632273391814 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,884000,2004,0.29940119760479045,fixed_full_OO_pool,3.9602970467176704,834443113660416000,1810432000,452238848,1442.0886,1442.0880994152046 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,888000,2004,0.249500998003992,fixed_full_OO_pool,3.978193775201216,838218874355712000,1818624000,454285312,1448.613375,1448.6139510233918 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,892000,2004,0.4491017964071856,fixed_full_OO_pool,3.9960929612877467,841994635051008000,1826816000,456331520,1455.135925,1455.139192251462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,896000,2004,0.29940119760479045,fixed_full_OO_pool,4.013995270762178,845770395746304000,1835008000,458377984,1461.66955,1461.66375 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,900000,2004,0.34930139720558884,fixed_full_OO_pool,4.0318979074795624,849546156441600000,1843200000,460424192,1468.1904,1468.189239766082 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,904000,2004,0.4491017964071856,fixed_full_OO_pool,4.049795812569145,853321917136896000,1851392000,462470656,1474.7163,1474.7149269005847 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,908000,2004,0.34930139720558884,fixed_full_OO_pool,4.067697046976536,857097677832192000,1859584000,464516864,1481.23855,1481.240211988304 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,912000,2004,0.29940119760479045,fixed_full_OO_pool,4.085594687625352,860873438527488000,1867776000,466563328,1487.766175,1487.7656469298245 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,916000,2004,0.34930139720558884,fixed_full_OO_pool,4.103494030616971,864649199222784000,1875968000,468609536,1494.294025,1494.2901133040937 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,920000,2004,0.14970059880239522,fixed_full_OO_pool,4.12139414918609,868424959918080000,1884160000,470656000,1500.817625,1500.8161366959064 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,924000,2004,0.14970059880239522,fixed_full_OO_pool,4.139293068026503,872200720613376000,1892352000,472702208,1507.339175,1507.341524122807 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,928000,2004,0.29940119760479045,fixed_full_OO_pool,4.157188139636483,875976481308672000,1900544000,474748672,1513.8643,1513.8673245614036 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,932000,2004,0.249500998003992,fixed_full_OO_pool,4.175084495566164,879752242003968000,1908736000,476794880,1520.39315,1520.3916447368422 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,936000,2004,0.19960079840319359,fixed_full_OO_pool,4.192982488636756,883528002699264000,1916928000,478841344,1526.918675,1526.9173866959065 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,940000,2004,0.14970059880239522,fixed_full_OO_pool,4.21088160005812,887303763394560000,1925120000,480887552,1533.445425,1533.4420138888888 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,944000,2004,0.5988023952095809,fixed_full_OO_pool,4.22877683685782,891079524089856000,1933312000,482934016,1539.96965,1539.9679459064328 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,948000,2004,0.29940119760479045,fixed_full_OO_pool,4.246676268699683,894855284785152000,1941504000,484980224,1546.4949,1546.4927923976609 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,952000,2004,0.39920159680638717,fixed_full_OO_pool,4.264572696313262,898631045480448000,1949696000,487026432,1553.0175,1553.0180263157895 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,956000,2004,0.249500998003992,fixed_full_OO_pool,4.282794216111716,902406806175744000,1957888000,489072896,1559.5433,1559.5437280701753 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,960000,2004,0.29940119760479045,fixed_full_OO_pool,4.300692581160821,906182566871040000,1966080000,491119104,1566.067025,1566.06879751462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,964000,2004,0.249500998003992,fixed_full_OO_pool,4.318593766140855,909958327566336000,1974272000,493165568,1572.59525,1572.594144736842 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,968000,2004,0.29940119760479045,fixed_full_OO_pool,4.336496556738599,913734088261632000,1982464000,495211776,1579.121725,1579.1188121345028 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,972000,2004,0.249500998003992,fixed_full_OO_pool,4.354398598547818,917509848956928000,1990656000,497258240,1585.641325,1585.6454203216374 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,976000,2004,0.34930139720558884,fixed_full_OO_pool,4.372297163333537,921285609652224000,1998848000,499304448,1592.16975,1592.169802631579 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,980000,2004,0.09980039920159679,fixed_full_OO_pool,4.390228348161197,925061370347520000,2007040000,501350912,1598.69315,1598.695855263158 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,984000,2004,0.499001996007984,fixed_full_OO_pool,4.408688388431652,928837131042816000,2015232000,503397120,1605.22065,1605.2203728070176 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,988000,2004,0.34930139720558884,fixed_full_OO_pool,4.4265851530515485,932612891738112000,2023424000,505443584,1611.74645,1611.7460745614035 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,992000,2004,0.5489021956087825,fixed_full_OO_pool,4.4444813690241425,936388652433408000,2031616000,507489792,1618.267875,1618.2714802631579 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,996000,2004,0.29940119760479045,fixed_full_OO_pool,4.46237717473983,940164413128704000,2039808000,509536256,1624.797525,1624.7966191520468 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1000000,2004,0.39920159680638717,fixed_full_OO_pool,4.480278902707829,943940173824000000,2048000000,511582464,1631.3245,1631.3212134502924 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1004000,2004,0.29940119760479045,fixed_full_OO_pool,4.498177615393781,947715934519296000,2056192000,513628928,1637.848,1637.8472514619882 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1008000,2004,0.39920159680638717,fixed_full_OO_pool,4.516078773746267,951491695214592000,2064384000,515675136,1644.377825,1644.3714290935673 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1012000,2004,0.249500998003992,fixed_full_OO_pool,4.5339800823148755,955267455909888000,2072576000,517721600,1650.897675,1650.8980007309942 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1016000,2004,0.14970059880239522,fixed_full_OO_pool,4.551882689509334,959043216605184000,2080768000,519767808,1657.4205,1657.423201754386 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1020000,2004,0.29940119760479045,fixed_full_OO_pool,4.569781915861078,962818977300480000,2088960000,521814272,1663.95055,1663.9482821637428 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1024000,2004,0.14970059880239522,fixed_full_OO_pool,4.587678833549014,966594737995776000,2097152000,523860480,1670.47305,1670.4735307017545 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1028000,2004,0.34930139720558884,fixed_full_OO_pool,4.605972507455283,970370498691072000,2105344000,525906944,1676.999125,1676.999192251462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1032000,2004,0.29940119760479045,fixed_full_OO_pool,4.627391061917361,974146259386368000,2113536000,527953152,1683.52685,1683.5236769005849 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1036000,2004,0.19960079840319359,fixed_full_OO_pool,4.650062943802525,977922020081664000,2121728000,529999360,1690.048475,1690.0490533625732 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1040000,2004,0.4491017964071856,fixed_full_OO_pool,4.674513524052584,981697780776960000,2129920000,532045824,1696.57575,1696.5745394736841 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1044000,2004,0.09980039920159679,fixed_full_OO_pool,4.696469650964977,985473541472256000,2138112000,534092032,1703.1006,1703.0994444444445 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1048000,2004,0.39920159680638717,fixed_full_OO_pool,4.716560744162028,989249302167552000,2146304000,536138496,1709.626925,1709.6250694444445 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1052000,2004,0.34930139720558884,fixed_full_OO_pool,4.734458155121861,993025062862848000,2154496000,538184704,1716.15085,1716.150109649123 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1056000,2004,0.4491017964071856,fixed_full_OO_pool,4.752356169669786,996800823558144000,2162688000,540231168,1722.676175,1722.6758808479533 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1060000,2004,0.19960079840319359,fixed_full_OO_pool,4.770256138217325,1000576584253440000,2170880000,542277376,1729.20065,1729.200840643275 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1064000,2004,0.29940119760479045,fixed_full_OO_pool,4.788152353537994,1004352344948736000,2179072000,544323840,1735.7277,1735.7263596491227 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1068000,2004,0.39920159680638717,fixed_full_OO_pool,4.806048875096151,1008128105644032000,2187264000,546370048,1742.252225,1742.251312134503 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1072000,2004,0.34930139720558884,fixed_full_OO_pool,4.823946373740005,1011903866339328000,2195456000,548416512,1748.7758,1748.7773391812866 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1076000,2004,0.19960079840319359,fixed_full_OO_pool,4.841839843549662,1015679627034624000,2203648000,550462720,1755.302825,1755.3019261695906 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1080000,2004,0.34930139720558884,fixed_full_OO_pool,4.85973469562932,1019455387729920000,2211840000,552509184,1761.827875,1761.8277375730995 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1084000,2004,0.29940119760479045,fixed_full_OO_pool,4.877632145336312,1023231148425216000,2220032000,554555392,1768.352325,1768.3527010233918 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1088000,2004,0.249500998003992,fixed_full_OO_pool,4.89552581673695,1027006909120512000,2228224000,556601856,1774.8786,1774.8783333333333 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1092000,2004,0.19960079840319359,fixed_full_OO_pool,4.914884350730313,1030782669815808000,2236416000,558648064,1781.401475,1781.4035270467837 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1096000,2004,0.34930139720558884,fixed_full_OO_pool,4.932778465573986,1034558430511104000,2244608000,560694528,1787.9267,1787.929312865497 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1100000,2004,0.499001996007984,fixed_full_OO_pool,4.9506744494330555,1038334191206400000,2252800000,562740736,1794.454175,1794.4538340643276 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1104000,2004,0.29940119760479045,fixed_full_OO_pool,4.968571091210469,1042109951901696000,2260992000,564787200,1800.979075,1800.9796673976607 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1108000,2004,0.29940119760479045,fixed_full_OO_pool,4.986468844067098,1045885712596992000,2269184000,566833408,1807.505475,1807.504345760234 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1112000,2004,0.249500998003992,fixed_full_OO_pool,5.0043646550054355,1049661473292288000,2277376000,568879616,1814.0292,1814.0294152046783 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1116000,2004,0.39920159680638717,fixed_full_OO_pool,5.022262108142798,1053437233987584000,2285568000,570926080,1820.55255,1820.555475146199 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1120000,2004,0.39920159680638717,fixed_full_OO_pool,5.040160230723107,1057212994682880000,2293760000,572972288,1827.0793,1827.0801023391814 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1124000,2004,0.4491017964071856,fixed_full_OO_pool,5.05805685226909,1060988755378176000,2301952000,575018752,1833.60705,1833.605519005848 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1128000,2004,0.19960079840319359,fixed_full_OO_pool,5.075956989569176,1064764516073472000,2310144000,577064960,1840.1335,1840.1301900584795 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1132000,2004,0.29940119760479045,fixed_full_OO_pool,5.093858932820666,1068540276768768000,2318336000,579111424,1846.655175,1846.656494883041 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1136000,2004,0.249500998003992,fixed_full_OO_pool,5.111758514319857,1072316037464064000,2326528000,581157632,1853.1819,1853.1811257309942 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1140000,2004,0.19960079840319359,fixed_full_OO_pool,5.129656615479746,1076091798159360000,2334720000,583204096,1859.7061,1859.7070614035088 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1144000,2004,0.049900199600798396,fixed_full_OO_pool,5.14756010892387,1079867558854656000,2342912000,585250304,1866.233425,1866.2316045321638 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1148000,2004,0.19960079840319359,fixed_full_OO_pool,5.1654610429642105,1083643319549952000,2351104000,587296768,1872.75915,1872.757317251462 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1152000,2004,0.14970059880239522,fixed_full_OO_pool,5.1833610037683195,1087419080245248000,2359296000,589342976,1879.282975,1879.2823720760234 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1156000,2004,0.249500998003992,fixed_full_OO_pool,5.2012630418087875,1091194840940544000,2367488000,591389440,1885.806675,1885.8083808479532 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1160000,2004,0.29940119760479045,fixed_full_OO_pool,5.21916321138127,1094970601635840000,2375680000,593435648,1892.3363,1892.3325877192983 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1164000,2004,0.249500998003992,fixed_full_OO_pool,5.237059159991849,1098746362331136000,2383872000,595482112,1898.854725,1898.8593676900584 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1168000,2004,0.5489021956087825,fixed_full_OO_pool,5.2549572307989,1102522123026432000,2392064000,597528320,1905.38405,1905.3836184210527 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1172000,2004,0.09980039920159679,fixed_full_OO_pool,5.272853652799709,1106297883721728000,2400256000,599574784,1911.9119,1911.9090204678362 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1176000,2004,0.19960079840319359,fixed_full_OO_pool,5.290748534057704,1110073644417024000,2408448000,601620992,1918.435525,1918.4341045321637 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1180000,2004,0.09980039920159679,fixed_full_OO_pool,5.3086451400299035,1113849405112320000,2416640000,603667456,1924.95995,1924.9600073099416 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1184000,2004,0.09980039920159679,fixed_full_OO_pool,5.326543790112353,1117625165807616000,2424832000,605713664,1931.481875,1931.4853399122808 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1188000,2004,0.249500998003992,fixed_full_OO_pool,5.344443334851207,1121400926502912000,2433024000,607759872,1938.009425,1938.009850146199 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1192000,2004,0.29940119760479045,fixed_full_OO_pool,5.362344906249394,1125176687198208000,2441216000,609806336,1944.534275,1944.5356907894736 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1196000,2004,0.34930139720558884,fixed_full_OO_pool,5.380244663780969,1128952447893504000,2449408000,611852544,1951.0621,1951.0601608187135 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1200000,2004,0.19960079840319359,fixed_full_OO_pool,5.398144548118322,1132728208588800000,2457600000,613899008,1957.584825,1957.586312134503 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1204000,2004,0.34930139720558884,fixed_full_OO_pool,5.4160414534031105,1136503969284096000,2465792000,615945216,1964.108875,1964.1113340643276 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1208000,2004,0.39920159680638717,fixed_full_OO_pool,5.433937890271967,1140279729979392000,2473984000,617991680,1970.63505,1970.636980994152 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1212000,2004,0.19960079840319359,fixed_full_OO_pool,5.451836689770635,1144055490674688000,2482176000,620037888,1977.162125,1977.1615606725147 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1216000,2004,0.19960079840319359,fixed_full_OO_pool,5.469732886279623,1147831251369984000,2490368000,622084352,1983.6894,1983.6870467836256 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1220000,2004,0.249500998003992,fixed_full_OO_pool,5.487629126320696,1151607012065280000,2498560000,624130560,1990.215475,1990.2117726608187 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1224000,2004,0.34930139720558884,fixed_full_OO_pool,5.5055237917177795,1155382772760576000,2506752000,626177024,1996.7373,1996.7380555555555 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1228000,2004,0.29940119760479045,fixed_full_OO_pool,5.523422311493713,1159158533455872000,2514944000,628223232,2003.262225,2003.2629495614035 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1232000,2004,0.34930139720558884,fixed_full_OO_pool,5.541319786383667,1162934294151168000,2523136000,630269696,2009.79055,2009.7882821637427 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1236000,2004,0.34930139720558884,fixed_full_OO_pool,5.5592168062107845,1166710054846464000,2531328000,632315904,2016.315575,2016.3131615497075 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1240000,2004,0.14970059880239522,fixed_full_OO_pool,5.577112497842561,1170485815541760000,2539520000,634362368,2022.841425,2022.838855994152 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1244000,2004,0.39920159680638717,fixed_full_OO_pool,5.595010149430276,1174261576237056000,2547712000,636408576,2029.3629,2029.3642543859648 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1248000,2004,0.29940119760479045,fixed_full_OO_pool,5.612905815507596,1178037336932352000,2555904000,638455040,2035.889075,2035.8899013157895 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1252000,2004,0.249500998003992,fixed_full_OO_pool,5.630803705533553,1181813097627648000,2564096000,640501248,2042.414125,2042.4147770467837 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1256000,2004,0.39920159680638717,fixed_full_OO_pool,5.64869727158919,1185588858322944000,2572288000,642547712,2048.936625,2048.94096125731 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1260000,2004,0.29940119760479045,fixed_full_OO_pool,5.666591083985857,1189364619018240000,2580480000,644593920,2055.4625,2055.465716374269 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1264000,2004,0.14970059880239522,fixed_full_OO_pool,5.684483963278018,1193140379713536000,2588672000,646640384,2061.990325,2061.991122076023 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1268000,2004,0.29940119760479045,fixed_full_OO_pool,5.7023786226049475,1196916140408832000,2596864000,648686592,2068.517525,2068.515683479532 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1272000,2004,0.14970059880239522,fixed_full_OO_pool,5.720273698505221,1200691901104128000,2605056000,650732800,2075.040975,2075.040793128655 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1276000,2004,0.39920159680638717,fixed_full_OO_pool,5.7381669608265575,1204467661799424000,2613248000,652779264,2081.566575,2081.566524122807 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1280000,2004,0.19960079840319359,fixed_full_OO_pool,5.756059900780933,1208243422494720000,2621440000,654825472,2088.094025,2088.0910489766084 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1284000,2004,0.19960079840319359,fixed_full_OO_pool,5.7739533707861685,1212019183190016000,2629632000,656871936,2094.62025,2094.6166885964913 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1288000,2004,0.4491017964071856,fixed_full_OO_pool,5.7918483053851455,1215794943885312000,2637824000,658918144,2101.1387,2101.142529239766 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1292000,2004,0.249500998003992,fixed_full_OO_pool,5.809743374893442,1219570704580608000,2646016000,660964608,2107.668425,2107.6676571637427 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1296000,2004,0.29940119760479045,fixed_full_OO_pool,5.827636671537119,1223346465275904000,2654208000,663010816,2114.193775,2114.192489035088 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1300000,2004,0.39920159680638717,fixed_full_OO_pool,5.845529073131167,1227122225971200000,2662400000,665057280,2120.717475,2120.7184978070177 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1304000,2004,0.29940119760479045,fixed_full_OO_pool,5.863422893379918,1230897986666496000,2670592000,667103488,2127.249425,2127.2423647660817 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1308000,2004,0.19960079840319359,fixed_full_OO_pool,5.8813142801966105,1234673747361792000,2678784000,669149952,2133.767925,2133.76913377193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1312000,2004,0.29940119760479045,fixed_full_OO_pool,5.899206747965266,1238449508057088000,2686976000,671196160,2140.293825,2140.293885233918 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1316000,2004,0.249500998003992,fixed_full_OO_pool,5.917099999342527,1242225268752384000,2695168000,673242624,2146.8188,2146.8197076023393 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1320000,2004,0.34930139720558884,fixed_full_OO_pool,5.934995981417597,1246001029447680000,2703360000,675288832,2153.35105,2153.3435307017544 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1324000,2004,0.499001996007984,fixed_full_OO_pool,5.952889990746561,1249776790142976000,2711552000,677335296,2159.869725,2159.870274122807 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1328000,2004,0.6487025948103792,fixed_full_OO_pool,5.970783155200382,1253552550838272000,2719744000,679381504,2166.39615,2166.3949488304092 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1332000,2004,0.499001996007984,fixed_full_OO_pool,5.988675889784677,1257328311533568000,2727936000,681427968,2172.920625,2172.920844298246 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1336000,2004,0.29940119760479045,fixed_full_OO_pool,6.006569866108604,1261104072228864000,2736128000,683474176,2179.44505,2179.4458114035087 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1340000,2004,0.09980039920159679,fixed_full_OO_pool,6.024463392928657,1264879832924160000,2744320000,685520640,2185.970725,2185.9715314327486 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1344000,2004,0.14970059880239522,fixed_full_OO_pool,6.042357331382939,1268655593619456000,2752512000,687566848,2192.4966,2192.4962865497077 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1348000,2004,0.34930139720558884,fixed_full_OO_pool,6.060250542012768,1272431354314752000,2760704000,689613056,2199.02225,2199.0210745614036 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1352000,2004,0.14970059880239522,fixed_full_OO_pool,6.078144169040025,1276207115010048000,2768896000,691659520,2205.549225,2205.5466045321637 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1356000,2004,0.29940119760479045,fixed_full_OO_pool,6.0960384338597455,1279982875705344000,2777088000,693705728,2212.071925,2212.0718238304094 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1360000,2004,0.19960079840319359,fixed_full_OO_pool,6.113935807957831,1283758636400640000,2785280000,695752192,2218.5972,2218.5976023391813 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1364000,2004,0.14970059880239522,fixed_full_OO_pool,6.131833986974218,1287534397095936000,2793472000,697798400,2225.11965,2225.1228581871346 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1368000,2004,0.09980039920159679,fixed_full_OO_pool,6.149729286559547,1291310157791232000,2801664000,699844864,2231.646725,2231.6483735380116 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1372000,2004,0.4491017964071856,fixed_full_OO_pool,6.167623095949077,1295085918486528000,2809856000,701891072,2238.171425,2238.1733004385965 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1376000,2004,0.39920159680638717,fixed_full_OO_pool,6.185516773680639,1298861679181824000,2818048000,703937536,2244.698475,2244.6988194444443 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1380000,2004,0.34930139720558884,fixed_full_OO_pool,6.203412954622052,1302637439877120000,2826240000,705983744,2251.225825,2251.2233589181287 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1384000,2004,0.34930139720558884,fixed_full_OO_pool,6.221306832978088,1306413200572416000,2834432000,708030208,2257.75135,2257.749100877193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1388000,2004,0.249500998003992,fixed_full_OO_pool,6.239199909173573,1310188961267712000,2842624000,710076416,2264.274525,2264.274250730994 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1392000,2004,0.19960079840319359,fixed_full_OO_pool,6.2570923146191575,1313964721963008000,2850816000,712122880,2270.802725,2270.799601608187 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1396000,2004,0.34930139720558884,fixed_full_OO_pool,6.274987945554571,1317740482658304000,2859008000,714169088,2277.325425,2277.3248209064327 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1400000,2004,0.34930139720558884,fixed_full_OO_pool,6.292881909586075,1321516243353600000,2867200000,716215552,2283.849875,2283.8507200292397 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1404000,2004,0.34930139720558884,fixed_full_OO_pool,6.31077852228346,1325292004048896000,2875392000,718261760,2290.376375,2290.37538377193 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1408000,2004,0.39920159680638717,fixed_full_OO_pool,6.328674753040282,1329067764744192000,2883584000,720308224,2296.901125,2296.9012390350877 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1412000,2004,0.14970059880239522,fixed_full_OO_pool,6.346571184606809,1332843525439488000,2891776000,722354432,2303.423775,2303.4264656432747 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1416000,2004,0.249500998003992,fixed_full_OO_pool,6.36446486567561,1336619286134784000,2899968000,724400896,2309.950975,2309.951962719298 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1420000,2004,0.14970059880239522,fixed_full_OO_pool,6.38236043679321,1340395046830080000,2908160000,726447104,2316.4738,2316.47716374269 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1424000,2004,0.249500998003992,fixed_full_OO_pool,6.400254542976618,1344170807525376000,2916352000,728493312,2323.001475,2323.0016557017543 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1428000,2004,0.19960079840319359,fixed_full_OO_pool,6.418148810385416,1347946568220672000,2924544000,730539776,2329.526925,2329.527408625731 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1432000,2004,0.14970059880239522,fixed_full_OO_pool,6.43604192393625,1351722328915968000,2932736000,732585984,2336.05215,2336.0522587719297 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1436000,2004,0.249500998003992,fixed_full_OO_pool,6.453936611416025,1355498089611264000,2940928000,734632448,2342.57685,2342.578121345029 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1440000,2004,0.14970059880239522,fixed_full_OO_pool,6.471831660139271,1359273850306560000,2949120000,736678656,2349.1014,2349.1030701754385 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1444000,2004,0.14970059880239522,fixed_full_OO_pool,6.489727170602936,1363049611001856000,2957312000,738725120,2355.6274,2355.6287426900585 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1448000,2004,0.049900199600798396,fixed_full_OO_pool,6.507618888927003,1366825371697152000,2965504000,740771328,2362.15255,2362.1536038011695 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1452000,2004,0.19960079840319359,fixed_full_OO_pool,6.525510136846246,1370601132392448000,2973696000,742817792,2368.679725,2368.679104532164 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1456000,2004,0.19960079840319359,fixed_full_OO_pool,6.543400123529136,1374376893087744000,2981888000,744864000,2375.204275,2375.204053362573 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1460000,2004,0.249500998003992,fixed_full_OO_pool,6.56129028443661,1378152653783040000,2990080000,746910464,2381.726575,2381.7302668128655 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1464000,2004,0.34930139720558884,fixed_full_OO_pool,6.579180730644406,1381928414478336000,2998272000,748956672,2388.25755,2388.2542763157894 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1468000,2004,0.14970059880239522,fixed_full_OO_pool,6.59707120589291,1385704175173632000,3006464000,751003136,2394.7818,2394.7802046783627 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1472000,2004,0.19960079840319359,fixed_full_OO_pool,6.6149604146213585,1389479935868928000,3014656000,753049344,2401.3038,2401.3055263157894 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1476000,2004,0.09980039920159679,fixed_full_OO_pool,6.6328504193791495,1393255696564224000,3022848000,755095808,2407.83105,2407.8310160818714 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1480000,2004,0.39920159680638717,fixed_full_OO_pool,6.650742119012607,1397031457259520000,3031040000,757142016,2414.353925,2414.356209795322 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1484000,2004,0.29940119760479045,fixed_full_OO_pool,6.668631883117681,1400807217954816000,3039232000,759188480,2420.880325,2420.8818238304093 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1488000,2004,0.34930139720558884,fixed_full_OO_pool,6.6865234715170745,1404582978650112000,3047424000,761234688,2427.40705,2427.4064546783625 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1492000,2004,0.39920159680638717,fixed_full_OO_pool,6.704413724708267,1408358739345408000,3055616000,763281152,2433.932325,2433.9322331871344 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1496000,2004,0.249500998003992,fixed_full_OO_pool,6.722305112688078,1412134500040704000,3063808000,765327360,2440.456625,2440.4572185672514 +synthetic,standard8-phi7.2-wd0.1,standard8,791101,0.0001,0.1,7.2,1500000,2004,0.19960079840319359,fixed_full_OO_pool,6.740193886749653,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,0,2004,0.0,fixed_full_OO_pool,0.0,0,0,0,0.0,0.0 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,256,2004,0.0,fixed_full_OO_pool,0.001170449247583747,241648684498944,524288,131072,0.412975,0.41868786549707604 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,512,2004,0.0,fixed_full_OO_pool,0.002339438268293937,483297368997888,1048576,262144,0.8341,0.8361842105263158 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1000,2004,0.14970059880239522,fixed_full_OO_pool,0.004564383284499248,943940173824000,2048000,511744,1.6305,1.63203216374269 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,2000,2004,0.0,fixed_full_OO_pool,0.00912029370975991,1887880347648000,4096000,1023232,3.263775,3.2627229532163744 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,3000,2004,0.049900199600798396,fixed_full_OO_pool,0.013675896517104573,2831820521472000,6144000,1534976,4.89595,4.894510233918129 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,4000,2004,0.14970059880239522,fixed_full_OO_pool,0.01823822198021743,3775760695296000,8192000,2046464,6.52905,6.525226608187134 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,5000,2004,0.19960079840319359,fixed_full_OO_pool,0.022799666034471658,4719700869120000,10240000,2557952,8.1597,8.156301169590643 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,6000,2004,0.09980039920159679,fixed_full_OO_pool,0.02736313798257874,5663641042944000,12288000,3069696,9.788625,9.788563596491228 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,7000,2004,0.049900199600798396,fixed_full_OO_pool,0.0319271320818613,6607581216768000,14336000,3581184,11.4216,11.419298245614035 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,8000,2004,0.0,fixed_full_OO_pool,0.03649106375666128,7551521390592000,16384000,4092672,13.0503,13.050657894736842 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,9000,2004,0.049900199600798396,fixed_full_OO_pool,0.04105442527785069,8495461564416000,18432000,4604416,14.6867,14.681827485380117 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,10000,2004,0.09980039920159679,fixed_full_OO_pool,0.045619017339001096,9439401738240000,20480000,5115904,16.310875,16.313848684210527 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,11000,2004,0.19960079840319359,fixed_full_OO_pool,0.050183510683063,10383341912064000,22528000,5627648,17.9435,17.945570175438597 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,12000,2004,0.049900199600798396,fixed_full_OO_pool,0.054749867271424994,11327282085888000,24576000,6139136,19.57665,19.57627923976608 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,13000,2004,0.29940119760479045,fixed_full_OO_pool,0.0593147906433377,12271222259712000,26624000,6650624,21.20495,21.20769736842105 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,14000,2004,0.09980039920159679,fixed_full_OO_pool,0.06387979046959016,13215162433536000,28672000,7162368,22.8415,22.838845029239767 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,15000,2004,0.049900199600798396,fixed_full_OO_pool,0.06844619977494909,14159102607360000,30720000,7673856,24.4697,24.470277777777778 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,16000,2004,0.09980039920159679,fixed_full_OO_pool,0.07301147957435912,15103042781184000,32768000,8185344,26.100225,26.101370614035087 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,17000,2004,0.249500998003992,fixed_full_OO_pool,0.07757610711165601,16046982955008000,34816000,8697088,27.7315,27.73328947368421 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,18000,2004,0.14970059880239522,fixed_full_OO_pool,0.08214129067026078,16990923128832000,36864000,9208576,29.365125,29.36392909356725 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,19000,2004,0.14970059880239522,fixed_full_OO_pool,0.08674261696533196,17934863302656000,38912000,9720320,30.995775,30.99593932748538 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,20000,2004,0.09980039920159679,fixed_full_OO_pool,0.0913491099462327,18878803476480000,40960000,10231808,32.62985,32.626513157894735 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,21000,2004,0.09980039920159679,fixed_full_OO_pool,0.09583464611425167,19822743650304000,43008000,10743296,34.2587,34.25785087719298 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,22000,2004,0.14970059880239522,fixed_full_OO_pool,0.1003203277124299,20766683824128000,45056000,11255040,35.88965,35.88981725146199 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,23000,2004,0.14970059880239522,fixed_full_OO_pool,0.10480755735809605,21710623997952000,47104000,11766528,37.52075,37.52082602339181 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,24000,2004,0.09980039920159679,fixed_full_OO_pool,0.10929318057890568,22654564171776000,49152000,12278016,39.1531,39.151652046783624 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,25000,2004,0.09980039920159679,fixed_full_OO_pool,0.11377872701734304,23598504345600000,51200000,12789760,40.78145,40.783998538011694 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,26000,2004,0.249500998003992,fixed_full_OO_pool,0.1182644064258784,24542444519424000,53248000,13301248,42.413275,42.41490131578947 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,27000,2004,0.14970059880239522,fixed_full_OO_pool,0.12275000090089937,25486384693248000,55296000,13812736,44.0468,44.04555555555555 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,28000,2004,0.09980039920159679,fixed_full_OO_pool,0.12723558153336248,26430324867072000,57344000,14324480,45.67505,45.67791666666667 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,29000,2004,0.049900199600798396,fixed_full_OO_pool,0.13172125858772132,27374265040896000,59392000,14835968,47.3092,47.308479532163744 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,30000,2004,0.09980039920159679,fixed_full_OO_pool,0.13620691826980974,28318205214720000,61440000,15347712,48.939325,48.94056652046783 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,31000,2004,0.14970059880239522,fixed_full_OO_pool,0.14069391619931493,29262145388544000,63488000,15859200,50.572825,50.571224415204675 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,32000,2004,0.19960079840319359,fixed_full_OO_pool,0.14517928073389663,30206085562368000,65536000,16370688,52.20115,52.20263888888889 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,33000,2004,0.049900199600798396,fixed_full_OO_pool,0.149664336523662,31150025736192000,67584000,16882432,53.832525,53.83454312865497 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,34000,2004,0.14970059880239522,fixed_full_OO_pool,0.1541512742700676,32093965910016000,69632000,17393920,55.46365,55.46554824561404 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,35000,2004,0.29940119760479045,fixed_full_OO_pool,0.1586367947825541,33037906083840000,71680000,17905408,57.09505,57.096513157894734 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,36000,2004,0.049900199600798396,fixed_full_OO_pool,0.16312232583968175,33981846257664000,73728000,18417152,58.727825,58.72821271929825 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,37000,2004,0.09980039920159679,fixed_full_OO_pool,0.16760812013927434,34925786431488000,75776000,18928640,60.355625,60.35970394736842 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,38000,2004,0.19960079840319359,fixed_full_OO_pool,0.17209390372244848,35869726605312000,77824000,19440384,61.99095,61.99103070175438 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,39000,2004,0.14970059880239522,fixed_full_OO_pool,0.17658082011362744,36813666779136000,79872000,19951872,63.62315,63.62187865497076 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,40000,2004,0.19960079840319359,fixed_full_OO_pool,0.18106671911043426,37757606952960000,81920000,20463360,65.2529,65.25308479532164 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,41000,2004,0.19960079840319359,fixed_full_OO_pool,0.1855527544859797,38701547126784000,83968000,20975104,66.886125,66.88471856725147 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,42000,2004,0.09980039920159679,fixed_full_OO_pool,0.19003968933493726,39645487300608000,86016000,21486592,68.5145,68.51612573099415 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,43000,2004,0.19960079840319359,fixed_full_OO_pool,0.19452553512011136,40589427474432000,88064000,21998080,70.148525,70.14670687134503 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,44000,2004,0.19960079840319359,fixed_full_OO_pool,0.1990111262196054,41533367648256000,90112000,22509824,71.78185,71.77832602339181 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,45000,2004,0.34930139720558884,fixed_full_OO_pool,0.2034969395130045,42477307822080000,92160000,23021312,73.41665,73.40879385964912 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,46000,2004,0.09980039920159679,fixed_full_OO_pool,0.20798275525992116,43421247995904000,94208000,23532800,75.041875,75.04066154970761 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,47000,2004,0.09980039920159679,fixed_full_OO_pool,0.21246867346991266,44365188169728000,96256000,24044544,76.67005,76.673033625731 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,48000,2004,0.049900199600798396,fixed_full_OO_pool,0.21695442624079683,45309128343552000,98304000,24556032,78.304225,78.30359283625731 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,49000,2004,0.19960079840319359,fixed_full_OO_pool,0.2214401642119305,46253068517376000,100352000,25067776,79.935,79.93558479532163 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,50000,2004,0.14970059880239522,fixed_full_OO_pool,0.22592736615592407,47197008691200000,102400000,25579264,81.564025,81.56689692982457 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,51000,2004,0.09980039920159679,fixed_full_OO_pool,0.23041328040986425,48140948865024000,104448000,26090752,83.19275,83.19825292397661 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,52000,2004,0.14970059880239522,fixed_full_OO_pool,0.23489908625578715,49084889038848000,106496000,26602496,84.829475,84.829375 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,53000,2004,0.29940119760479045,fixed_full_OO_pool,0.2393861730924497,50028829212672000,108544000,27113984,86.46075,86.4603581871345 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,54000,2004,0.14970059880239522,fixed_full_OO_pool,0.24387199331178433,50972769386496000,110592000,27625472,88.0915,88.09141812865496 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,55000,2004,0.19960079840319359,fixed_full_OO_pool,0.24835785354177156,51916709560320000,112640000,28137216,89.720875,89.72361476608187 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,56000,2004,0.14970059880239522,fixed_full_OO_pool,0.25284373342266514,52860649734144000,114688000,28648704,91.355375,91.3541264619883 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,57000,2004,0.14970059880239522,fixed_full_OO_pool,0.2573296911962744,53804589907968000,116736000,29160448,92.98645,92.98607456140351 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,58000,2004,0.19960079840319359,fixed_full_OO_pool,0.26181679625478055,54748530081792000,118784000,29671936,94.616975,94.61716739766082 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,59000,2004,0.049900199600798396,fixed_full_OO_pool,0.2663026491790596,55692470255616000,120832000,30183424,96.249875,96.2479130116959 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,60000,2004,0.09980039920159679,fixed_full_OO_pool,0.2707888470383154,56636410429440000,122880000,30695168,97.879975,97.88000365497076 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,61000,2004,0.14970059880239522,fixed_full_OO_pool,0.275276063249136,57580350603264000,124928000,31206656,99.5082,99.51143274853801 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,62000,2004,0.29940119760479045,fixed_full_OO_pool,0.2797620115439511,58524290777088000,126976000,31718144,101.140075,101.14232821637427 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,63000,2004,0.29940119760479045,fixed_full_OO_pool,0.28424657077942456,59468230950912000,129024000,32229888,102.777075,102.7734100877193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,64000,2004,0.19960079840319359,fixed_full_OO_pool,0.2893665167472015,60412171124736000,131072000,32741376,104.4066,104.40464912280702 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,68000,2004,0.09980039920159679,fixed_full_OO_pool,0.31211229135282337,64187931820032000,139264000,34787840,110.929625,110.93075657894737 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,72000,2004,0.14970059880239522,fixed_full_OO_pool,0.3300524410936568,67963692515328000,147456000,36834048,117.453525,117.4558004385965 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,76000,2004,0.14970059880239522,fixed_full_OO_pool,0.3603543365332815,71739453210624000,155648000,38880512,123.9815,123.98118421052632 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,80000,2004,0.29940119760479045,fixed_full_OO_pool,0.3782926699405329,75515213905920000,163840000,40926720,130.5097,130.50559941520467 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,84000,2004,0.19960079840319359,fixed_full_OO_pool,0.3961847392842174,79290974601216000,172032000,42972928,137.031775,137.0309100877193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,88000,2004,0.09980039920159679,fixed_full_OO_pool,0.41848454208837615,83066735296512000,180224000,45019392,143.557075,143.55668494152047 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,92000,2004,0.19960079840319359,fixed_full_OO_pool,0.4364214859302673,86842495991808000,188416000,47065600,150.0823,150.0815350877193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,96000,2004,0.34930139720558884,fixed_full_OO_pool,0.4543132528786858,90618256687104000,196608000,49112064,156.60565,156.60759502923977 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,100000,2004,0.249500998003992,fixed_full_OO_pool,0.4722045013370613,94394017382400000,204800000,51158272,163.130525,163.13249634502924 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,104000,2004,0.19960079840319359,fixed_full_OO_pool,0.49009520137372115,98169778077696000,212992000,53204736,169.654125,169.6585197368421 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,108000,2004,0.19960079840319359,fixed_full_OO_pool,0.5079863181958596,101945538772992000,221184000,55250944,176.18455,176.1826096491228 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,112000,2004,0.5489021956087825,fixed_full_OO_pool,0.525877316813502,105721299468288000,229376000,57297408,182.709075,182.70849780701755 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,116000,2004,0.249500998003992,fixed_full_OO_pool,0.5437685337642001,109497060163584000,237568000,59343616,189.233275,189.23349780701756 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,120000,2004,0.09980039920159679,fixed_full_OO_pool,0.5616591478894568,113272820858880000,245760000,61390080,195.763725,195.75851973684212 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,124000,2004,0.249500998003992,fixed_full_OO_pool,0.5795506223436031,117048581554176000,253952000,63436288,202.284825,202.28397295321636 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,128000,2004,0.249500998003992,fixed_full_OO_pool,0.5974386286031869,120824342249472000,262144000,65482752,208.811175,208.80959429824563 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,132000,2004,0.19960079840319359,fixed_full_OO_pool,0.615389685559397,124600102944768000,270336000,67528960,215.335825,215.33452850877194 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,136000,2004,0.09980039920159679,fixed_full_OO_pool,0.6333403321810894,128375863640064000,278528000,69575424,221.859925,221.8604788011696 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,140000,2004,0.19960079840319359,fixed_full_OO_pool,0.6512920211017545,132151624335360000,286720000,71621632,228.384975,228.38535453216375 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,144000,2004,0.09980039920159679,fixed_full_OO_pool,0.6692424122844305,135927385030656000,294912000,73668096,234.91125,234.91098684210527 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,148000,2004,0.29940119760479045,fixed_full_OO_pool,0.6871948753193848,139703145725952000,303104000,75714304,241.4382,241.43558479532163 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,152000,2004,0.29940119760479045,fixed_full_OO_pool,0.7051457172766742,143478906421248000,311296000,77760768,247.961725,247.96161915204678 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,156000,2004,0.249500998003992,fixed_full_OO_pool,0.7230977549165901,147254667116544000,319488000,79806976,254.4794,254.48757309941521 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,160000,2004,0.34930139720558884,fixed_full_OO_pool,0.7410483083263454,151030427811840000,327680000,81853184,261.01085,261.01151315789474 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,164000,2004,0.29940119760479045,fixed_full_OO_pool,0.7589989063402431,154806188507136000,335872000,83899648,267.540575,267.5366410818713 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,168000,2004,0.19960079840319359,fixed_full_OO_pool,0.7769499073446625,158581949202432000,344064000,85945856,274.0624,274.0619883040936 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,172000,2004,0.249500998003992,fixed_full_OO_pool,0.7949007386372735,162357709897728000,352256000,87992320,280.5924,280.58707602339183 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,176000,2004,0.09980039920159679,fixed_full_OO_pool,0.8128520887179507,166133470593024000,360448000,90038528,287.112375,287.1126937134503 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,180000,2004,0.249500998003992,fixed_full_OO_pool,0.8308031362760812,169909231288320000,368640000,92084992,293.6389,293.6382894736842 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,184000,2004,0.249500998003992,fixed_full_OO_pool,0.8487542615727418,173684991983616000,376832000,94131200,300.161475,300.1635270467836 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,188000,2004,0.39920159680638717,fixed_full_OO_pool,0.866704490871893,177460752678912000,385024000,96177664,306.690925,306.6886951754386 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,192000,2004,0.249500998003992,fixed_full_OO_pool,0.8846547386402057,181236513374208000,393216000,98223872,313.214825,313.2137390350877 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,196000,2004,0.249500998003992,fixed_full_OO_pool,0.9026055424236175,185012274069504000,401408000,100270336,319.7388,319.7397076023392 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,200000,2004,0.14970059880239522,fixed_full_OO_pool,0.9205557132346762,188788034764800000,409600000,102316544,326.26785,326.2639985380117 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,204000,2004,0.14970059880239522,fixed_full_OO_pool,0.9385059168976214,192563795460096000,417792000,104363008,332.790075,332.79022295321636 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,208000,2004,0.19960079840319359,fixed_full_OO_pool,0.9564564479701221,196339556155392000,425984000,106409216,339.3112,339.3156725146199 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,212000,2004,0.39920159680638717,fixed_full_OO_pool,0.9744067074379159,200115316850688000,434176000,108455680,345.838675,345.8411293859649 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,216000,2004,0.09980039920159679,fixed_full_OO_pool,0.9923585579130385,203891077545984000,442368000,110501888,352.36695,352.365533625731 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,220000,2004,0.049900199600798396,fixed_full_OO_pool,1.0103088243729952,207666838241280000,450560000,112548352,358.891375,358.89143640350875 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,224000,2004,0.049900199600798396,fixed_full_OO_pool,1.0282606582954112,211442598936576000,458752000,114594560,365.41325,365.4167763157895 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,228000,2004,0.249500998003992,fixed_full_OO_pool,1.0462108504027128,215218359631872000,466944000,116641024,371.944975,371.94161184210526 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,232000,2004,0.249500998003992,fixed_full_OO_pool,1.0641616925980069,218994120327168000,475136000,118687232,378.464275,378.46732821637426 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,236000,2004,0.249500998003992,fixed_full_OO_pool,1.0821120035969134,222769881022464000,483328000,120733696,384.9926,384.99266081871343 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,240000,2004,0.14970059880239522,fixed_full_OO_pool,1.1000635844489766,226545641717760000,491520000,122779904,391.5193,391.51729532163745 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,244000,2004,0.09980039920159679,fixed_full_OO_pool,1.1180138519633975,230321402413056000,499712000,124826112,398.042225,398.0424817251462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,248000,2004,0.34930139720558884,fixed_full_OO_pool,1.1359643375614865,234097163108352000,507904000,126872576,404.567575,404.56824926900583 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,252000,2004,0.19960079840319359,fixed_full_OO_pool,1.1539148615393788,237872923803648000,516096000,128918784,411.0936,411.09298245614036 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,256000,2004,0.499001996007984,fixed_full_OO_pool,1.1718647385740446,241648684498944000,524288000,130965248,417.61815,417.61886695906435 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,260000,2004,0.19960079840319359,fixed_full_OO_pool,1.1898024931177498,245424445194240000,532480000,133011456,424.142975,424.1437755847953 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,264000,2004,0.09980039920159679,fixed_full_OO_pool,1.207735815142385,249200205889536000,540672000,135057920,430.67075,430.6691885964912 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,268000,2004,0.049900199600798396,fixed_full_OO_pool,1.2256748180339734,252975966584832000,548864000,137104128,437.191275,437.194725877193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,272000,2004,0.09980039920159679,fixed_full_OO_pool,1.2436140864383842,256751727280128000,557056000,139150592,443.7231,443.71954678362573 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,276000,2004,0.249500998003992,fixed_full_OO_pool,1.2615532009748536,260527487975424000,565248000,141196800,450.245675,450.2447843567251 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,280000,2004,0.19960079840319359,fixed_full_OO_pool,1.2794922293588105,264303248670720000,573440000,143243264,456.769775,456.7707346491228 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,284000,2004,0.14970059880239522,fixed_full_OO_pool,1.2974317749341329,268079009366016000,581632000,145289472,463.2998,463.29488304093564 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,288000,2004,0.14970059880239522,fixed_full_OO_pool,1.315370389017173,271854770061312000,589824000,147335936,469.82105,469.82125 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,292000,2004,0.249500998003992,fixed_full_OO_pool,1.333310715376089,275630530756608000,598016000,149382144,476.347325,476.3459466374269 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,296000,2004,0.14970059880239522,fixed_full_OO_pool,1.3512496074185603,279406291451904000,606208000,151428608,482.872525,482.8717361111111 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,300000,2004,0.19960079840319359,fixed_full_OO_pool,1.3691889036560638,283182052147200000,614400000,153474816,489.39375,489.39717105263156 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,304000,2004,0.34930139720558884,fixed_full_OO_pool,1.3871273726349076,286957812842496000,622592000,155521280,495.924625,495.9221308479532 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,308000,2004,0.14970059880239522,fixed_full_OO_pool,1.4050673903348958,290733573537792000,630784000,157567488,502.44855,502.4471710526316 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,312000,2004,0.39920159680638717,fixed_full_OO_pool,1.4230049850615776,294509334233088000,638976000,159613952,508.97245,508.97315058479535 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,316000,2004,0.14970059880239522,fixed_full_OO_pool,1.4409447888491882,298285094928384000,647168000,161660160,515.499175,515.4977814327485 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,320000,2004,0.14970059880239522,fixed_full_OO_pool,1.4588829907443788,302060855623680000,655360000,163706368,522.02315,522.0228143274854 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,324000,2004,0.14970059880239522,fixed_full_OO_pool,1.4768208193520291,305836616318976000,663552000,165752832,528.550525,528.5482858187135 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,328000,2004,0.39920159680638717,fixed_full_OO_pool,1.494759292618061,309612377014272000,671744000,167799040,535.075275,535.0732054093568 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,332000,2004,0.19960079840319359,fixed_full_OO_pool,1.5126974914895577,313388137709568000,679936000,169845504,541.599425,541.5991483918128 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,336000,2004,0.09980039920159679,fixed_full_OO_pool,1.5306359113628665,317163898404864000,688128000,171891712,548.1241,548.1240789473684 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,340000,2004,0.249500998003992,fixed_full_OO_pool,1.5485742964792168,320939659100160000,696320000,173938176,554.6525,554.6494005847953 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,344000,2004,0.34930139720558884,fixed_full_OO_pool,1.5665122486702683,324715419795456000,704512000,175984384,561.176225,561.1744700292397 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,348000,2004,0.09980039920159679,fixed_full_OO_pool,1.5844498099055555,328491180490752000,712704000,178030848,567.6995,567.7005409356725 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,352000,2004,0.249500998003992,fixed_full_OO_pool,1.6023876615748223,332266941186048000,720896000,180077056,574.229,574.2247660818714 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,356000,2004,0.39920159680638717,fixed_full_OO_pool,1.620325613795883,336042701881344000,729088000,182123520,580.74945,580.75125 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,360000,2004,0.14970059880239522,fixed_full_OO_pool,1.638263512612838,339818462576640000,737280000,184169728,587.2773,587.275716374269 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,364000,2004,0.499001996007984,fixed_full_OO_pool,1.656201577100696,343594223271936000,745472000,186216192,593.80205,593.801571637427 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,368000,2004,0.29940119760479045,fixed_full_OO_pool,1.6741406125047555,347369983967232000,753664000,188262400,600.328575,600.3262317251462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,372000,2004,0.249500998003992,fixed_full_OO_pool,1.6920783231148704,351145744662528000,761856000,190308864,606.854025,606.8519846491228 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,376000,2004,0.29940119760479045,fixed_full_OO_pool,1.7100175430698112,354921505357824000,770048000,192355072,613.377875,613.3770358187135 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,380000,2004,0.39920159680638717,fixed_full_OO_pool,1.7279559138572465,358697266053120000,778240000,194401536,619.905425,619.9024817251462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,384000,2004,0.39920159680638717,fixed_full_OO_pool,1.7458951162381304,362473026748416000,786432000,196447744,626.429275,626.4275328947368 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,388000,2004,0.14970059880239522,fixed_full_OO_pool,1.763833101204493,366248787443712000,794624000,198494208,632.953,632.9535380116959 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,392000,2004,0.249500998003992,fixed_full_OO_pool,1.7817718992703078,370024548139008000,802816000,200540416,639.47635,639.4786622807018 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,396000,2004,0.14970059880239522,fixed_full_OO_pool,1.7997095872399707,373800308834304000,811008000,202586624,646.00355,646.0032236842105 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,400000,2004,0.19960079840319359,fixed_full_OO_pool,1.817648208824297,377576069529600000,819200000,204633088,652.52465,652.5296125730994 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,404000,2004,0.049900199600798396,fixed_full_OO_pool,1.8355862893484947,381351830224896000,827392000,206679296,659.053775,659.0538925438597 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,408000,2004,0.09980039920159679,fixed_full_OO_pool,1.8535243703259363,385127590920192000,835584000,208725760,665.582875,665.5791118421052 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,412000,2004,0.34930139720558884,fixed_full_OO_pool,1.8714625729299668,388903351615488000,843776000,210771968,672.1037,672.1046052631579 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,416000,2004,0.29940119760479045,fixed_full_OO_pool,1.8894008071917212,392679112310784000,851968000,212818432,678.629725,678.630274122807 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,420000,2004,0.19960079840319359,fixed_full_OO_pool,1.9073397292227794,396454873006080000,860160000,214864640,685.153725,685.1553033625731 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,424000,2004,0.34930139720558884,fixed_full_OO_pool,1.9252793107202484,400230633701376000,868352000,216911104,691.68155,691.6807090643275 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,428000,2004,0.29940119760479045,fixed_full_OO_pool,1.9432182554393593,404006394396672000,876544000,218957312,698.205125,698.2058004385965 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,432000,2004,0.249500998003992,fixed_full_OO_pool,1.9611563898405682,407782155091968000,884736000,221003776,704.73425,704.7310160818713 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,436000,2004,0.4491017964071856,fixed_full_OO_pool,1.9790949708782137,411557915787264000,892928000,223049984,711.25405,711.2566593567251 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,440000,2004,0.29940119760479045,fixed_full_OO_pool,1.9970334426893128,415333676482560000,901120000,225096448,717.782775,717.7819334795322 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,444000,2004,0.249500998003992,fixed_full_OO_pool,2.0149607017077504,419109437177856000,909312000,227142656,724.311975,724.3062024853801 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,448000,2004,0.14970059880239522,fixed_full_OO_pool,2.0328995715733615,422885197873152000,917504000,229189120,730.8328,730.8326315789474 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,452000,2004,0.34930139720558884,fixed_full_OO_pool,2.0508392205792996,426660958568448000,925696000,231235328,737.355575,737.3578399122807 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,456000,2004,0.049900199600798396,fixed_full_OO_pool,2.0687771935088355,430436719263744000,933888000,233281792,743.8846,743.8830701754385 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,460000,2004,0.249500998003992,fixed_full_OO_pool,2.086716075748619,434212479959040000,942080000,235328000,750.409,750.4080409356725 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,464000,2004,0.249500998003992,fixed_full_OO_pool,2.1046541888339236,437988240654336000,950272000,237374464,756.931775,756.9341849415205 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,468000,2004,0.19960079840319359,fixed_full_OO_pool,2.1225932085017365,441764001349632000,958464000,239420672,763.45835,763.4588377192982 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,472000,2004,0.29940119760479045,fixed_full_OO_pool,2.140531022346889,445539762044928000,966656000,241467136,769.984375,769.9845065789474 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,476000,2004,0.19960079840319359,fixed_full_OO_pool,2.1584705297338465,449315522740224000,974848000,243513344,776.5063,776.5098391812866 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,480000,2004,0.39920159680638717,fixed_full_OO_pool,2.176408382306496,453091283435520000,983040000,245559552,783.0342,783.0342982456141 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,484000,2004,0.34930139720558884,fixed_full_OO_pool,2.194346455834392,456867044130816000,991232000,247606016,789.559875,789.5600182748537 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,488000,2004,0.29940119760479045,fixed_full_OO_pool,2.2122845234111366,460642804826112000,999424000,249652224,796.08695,796.0845979532164 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,492000,2004,0.29940119760479045,fixed_full_OO_pool,2.230222384975188,464418565521408000,1007616000,251698688,802.611575,802.610471491228 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,496000,2004,0.14970059880239522,fixed_full_OO_pool,2.248160312709709,468194326216704000,1015808000,253744896,809.136325,809.1353910818714 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,500000,2004,0.14970059880239522,fixed_full_OO_pool,2.2660977033567096,471970086912000000,1024000000,255791360,815.660125,815.6613852339182 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,504000,2004,0.09980039920159679,fixed_full_OO_pool,2.284036270846716,475745847607296000,1032192000,257837568,822.185675,822.1861878654971 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,508000,2004,0.34930139720558884,fixed_full_OO_pool,2.301974667026144,479521608302592000,1040384000,259884032,828.71065,828.7120102339181 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,512000,2004,0.29940119760479045,fixed_full_OO_pool,2.3199126435454107,483297368997888000,1048576000,261930240,835.23295,835.2372880116959 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,516000,2004,0.14970059880239522,fixed_full_OO_pool,2.337848971095971,487073129693184000,1056768000,263976704,841.763075,841.7623574561403 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,520000,2004,0.09980039920159679,fixed_full_OO_pool,2.355786624129655,490848890388480000,1064960000,266022912,848.28965,848.2870102339182 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,524000,2004,0.14970059880239522,fixed_full_OO_pool,2.3737242778980483,494624651083776000,1073152000,268069376,854.814675,854.8128252923976 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,528000,2004,0.14970059880239522,fixed_full_OO_pool,2.3916633376023837,498400411779072000,1081344000,270115584,861.340575,861.337576754386 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,532000,2004,0.14970059880239522,fixed_full_OO_pool,2.409601041186187,502176172474368000,1089536000,272162048,867.8607,867.8641081871345 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,536000,2004,0.09980039920159679,fixed_full_OO_pool,2.4275400454333673,505951933169664000,1097728000,274208256,874.3878,874.3886842105263 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,540000,2004,0.09980039920159679,fixed_full_OO_pool,2.445477210924857,509727693864960000,1105920000,276254720,880.911925,880.9146308479532 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,544000,2004,0.14970059880239522,fixed_full_OO_pool,2.4634152373071347,513503454560256000,1114112000,278300928,887.4355,887.4397222222223 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,548000,2004,0.19960079840319359,fixed_full_OO_pool,2.481352999914024,517279215255552000,1122304000,280347392,893.965575,893.9647989766082 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,552000,2004,0.19960079840319359,fixed_full_OO_pool,2.499291911095174,521054975950848000,1130496000,282393600,900.4841,900.4906286549708 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,556000,2004,0.249500998003992,fixed_full_OO_pool,2.5172292508298737,524830736646144000,1138688000,284439808,907.014725,907.0146893274854 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,560000,2004,0.049900199600798396,fixed_full_OO_pool,2.535166768197798,528606497341440000,1146880000,286486272,913.539325,913.5405665204678 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,564000,2004,0.09980039920159679,fixed_full_OO_pool,2.553103692069029,532382258036736000,1155072000,288532480,920.064275,920.0654568713451 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,568000,2004,0.09980039920159679,fixed_full_OO_pool,2.571040633595031,536158018732032000,1163264000,290578944,926.594875,926.590456871345 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,572000,2004,0.29940119760479045,fixed_full_OO_pool,2.588978402123062,539933779427328000,1171456000,292625152,933.1148,933.116081871345 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,576000,2004,0.34930139720558884,fixed_full_OO_pool,2.606915924340073,543709540122624000,1179648000,294671616,939.638775,939.6420504385965 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,580000,2004,0.19960079840319359,fixed_full_OO_pool,2.6248529580380353,547485300817920000,1187840000,296717824,946.168025,946.166312134503 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,584000,2004,0.09980039920159679,fixed_full_OO_pool,2.6427902408813435,551261061513216000,1196032000,298764288,952.690725,952.6924671052632 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,588000,2004,0.09980039920159679,fixed_full_OO_pool,2.660727867902153,555036822208512000,1204224000,300810496,959.216975,959.2171673976608 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,592000,2004,0.049900199600798396,fixed_full_OO_pool,2.678665543370363,558812582903808000,1212416000,302856960,965.746525,965.7423209064327 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,596000,2004,0.29940119760479045,fixed_full_OO_pool,2.696602884830079,562588343599104000,1220608000,304903168,972.265375,972.2681030701755 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,600000,2004,0.049900199600798396,fixed_full_OO_pool,2.7145402816776185,566364104294400000,1228800000,306949632,978.793025,978.7935343567251 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,604000,2004,0.14970059880239522,fixed_full_OO_pool,2.732478917941658,570139864989696000,1236992000,308995840,985.318275,985.3183808479532 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,608000,2004,0.14970059880239522,fixed_full_OO_pool,2.750415970071529,573915625684992000,1245184000,311042304,991.843275,991.8441995614035 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,612000,2004,0.19960079840319359,fixed_full_OO_pool,2.768354018329539,577691386380288000,1253376000,313088512,998.367125,998.3692507309942 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,616000,2004,0.14970059880239522,fixed_full_OO_pool,2.786290782556559,581467147075584000,1261568000,315134976,1004.89305,1004.8949342105263 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,620000,2004,0.049900199600798396,fixed_full_OO_pool,2.8042291621180873,585242907770880000,1269760000,317181184,1011.419075,1011.4196673976609 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,624000,2004,0.19960079840319359,fixed_full_OO_pool,2.822166222460154,589018668466176000,1277952000,319227648,1017.94655,1017.9451242690059 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,628000,2004,0.09980039920159679,fixed_full_OO_pool,2.8401042654934443,592794429161472000,1286144000,321273856,1024.4692,1024.470350877193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,632000,2004,0.249500998003992,fixed_full_OO_pool,2.8580417849092434,596570189856768000,1294336000,323320320,1030.9954,1030.9959941520467 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,636000,2004,0.09980039920159679,fixed_full_OO_pool,2.8759804291433344,600345950552064000,1302528000,325366528,1037.51875,1037.5211184210527 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,640000,2004,0.09980039920159679,fixed_full_OO_pool,2.893917308892641,604121711247360000,1310720000,327412736,1044.046025,1044.0456688596491 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,644000,2004,0.09980039920159679,fixed_full_OO_pool,2.9118543899121385,607897471942656000,1318912000,329459200,1050.569475,1050.5717141812866 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,648000,2004,0.14970059880239522,fixed_full_OO_pool,2.929790923644064,611673232637952000,1327104000,331505408,1057.095525,1057.0964437134503 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,652000,2004,0.14970059880239522,fixed_full_OO_pool,2.947728538101332,615448993333248000,1335296000,333551872,1063.6214,1063.622134502924 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,656000,2004,0.0,fixed_full_OO_pool,2.965665584626711,619224754028544000,1343488000,335598080,1070.148925,1070.146648391813 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,660000,2004,0.29940119760479045,fixed_full_OO_pool,2.98360240092708,623000514723840000,1351680000,337644544,1076.674075,1076.6724451754385 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,664000,2004,0.049900199600798396,fixed_full_OO_pool,3.001538887614798,626776275419136000,1359872000,339690752,1083.19835,1083.1974342105264 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,668000,2004,0.19960079840319359,fixed_full_OO_pool,3.01947597685477,630552036114432000,1368064000,341737216,1089.72275,1089.723340643275 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,672000,2004,0.14970059880239522,fixed_full_OO_pool,3.037412726968113,634327796809728000,1376256000,343783424,1096.2529,1096.247470760234 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,676000,2004,0.0,fixed_full_OO_pool,3.055349004974382,638103557505024000,1384448000,345829888,1102.7743,1102.7738157894737 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,680000,2004,0.249500998003992,fixed_full_OO_pool,3.073286376066713,641879318200320000,1392640000,347876096,1109.302275,1109.2982638888889 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,684000,2004,0.09980039920159679,fixed_full_OO_pool,3.091222084224638,645655078895616000,1400832000,349922560,1115.822275,1115.8248135964911 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,688000,2004,0.19960079840319359,fixed_full_OO_pool,3.1091607701374837,649430839590912000,1409024000,351968768,1122.351,1122.3491520467837 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,692000,2004,0.19960079840319359,fixed_full_OO_pool,3.1270976242919764,653206600286208000,1417216000,354015232,1128.875075,1128.8751059941521 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,696000,2004,0.14970059880239522,fixed_full_OO_pool,3.1450355527581024,656982360981504000,1425408000,356061440,1135.395625,1135.4006396198831 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,700000,2004,0.09980039920159679,fixed_full_OO_pool,3.162972076896371,660758121676800000,1433600000,358107904,1141.9251,1141.9258040935672 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,704000,2004,0.09980039920159679,fixed_full_OO_pool,3.180909007149231,664533882372096000,1441792000,360154112,1148.44995,1148.4507090643274 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,708000,2004,0.29940119760479045,fixed_full_OO_pool,3.1988454309819887,668309643067392000,1449984000,362200576,1154.97815,1154.9760599415204 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,712000,2004,0.29940119760479045,fixed_full_OO_pool,3.216783428532589,672085403762688000,1458176000,364246784,1161.502725,1161.501005116959 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,716000,2004,0.09980039920159679,fixed_full_OO_pool,3.2347208146150743,675861164457984000,1466368000,366292992,1168.026725,1168.0260343567252 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,720000,2004,0.09980039920159679,fixed_full_OO_pool,3.2526576413379775,679636925153280000,1474560000,368339456,1174.5495,1174.5521783625732 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,724000,2004,0.09980039920159679,fixed_full_OO_pool,3.2705948753861915,683412685848576000,1482752000,370385664,1181.07815,1181.0765277777778 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,728000,2004,0.0,fixed_full_OO_pool,3.288532246793103,687188446543872000,1490944000,372432128,1187.599725,1187.6028472222222 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,732000,2004,0.049900199600798396,fixed_full_OO_pool,3.306468968278625,690964207239168000,1499136000,374478336,1194.12625,1194.1275073099416 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,736000,2004,0.09980039920159679,fixed_full_OO_pool,3.3244060422366277,694739967934464000,1507328000,376524800,1200.653825,1200.6529495614036 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,740000,2004,0.049900199600798396,fixed_full_OO_pool,3.3423435959840813,698515728629760000,1515520000,378571008,1207.174725,1207.1784320175439 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,744000,2004,0.14970059880239522,fixed_full_OO_pool,3.360280029849253,702291489325056000,1523712000,380617472,1213.702075,1213.7039071637428 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,748000,2004,0.049900199600798396,fixed_full_OO_pool,3.378216783211877,706067250020352000,1531904000,382663680,1220.225675,1220.228994883041 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,752000,2004,0.19960079840319359,fixed_full_OO_pool,3.39615361841292,709843010715648000,1540096000,384710144,1226.75395,1226.7543347953217 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,756000,2004,0.049900199600798396,fixed_full_OO_pool,3.4140897327092374,713618771410944000,1548288000,386756352,1233.2791,1233.2791959064327 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,760000,2004,0.049900199600798396,fixed_full_OO_pool,3.4320266313519743,717394532106240000,1556480000,388802816,1239.804525,1239.8049524853802 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,764000,2004,0.049900199600798396,fixed_full_OO_pool,3.449964364995766,721170292801536000,1564672000,390849024,1246.3319,1246.3294883040935 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,768000,2004,0.049900199600798396,fixed_full_OO_pool,3.4679011217421953,724946053496832000,1572864000,392895488,1252.856725,1252.855332602339 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,772000,2004,0.09980039920159679,fixed_full_OO_pool,3.485839502300239,728721814192128000,1581056000,394941696,1259.380075,1259.3804568713451 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,776000,2004,0.14970059880239522,fixed_full_OO_pool,3.503776648602345,732497574887424000,1589248000,396988160,1265.9052,1265.9062573099416 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,780000,2004,0.09980039920159679,fixed_full_OO_pool,3.5217147378106084,736273335582720000,1597440000,399034368,1272.43,1272.4311695906433 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,784000,2004,0.0,fixed_full_OO_pool,3.539652091215054,740049096278016000,1605632000,401080832,1278.957575,1278.9566118421053 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,788000,2004,0.09980039920159679,fixed_full_OO_pool,3.5575896726641805,743824856973312000,1613824000,403127040,1285.480925,1285.481736111111 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,792000,2004,0.14970059880239522,fixed_full_OO_pool,3.5755155294843846,747600617668608000,1622016000,405173248,1292.006575,1292.006524122807 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,796000,2004,0.049900199600798396,fixed_full_OO_pool,3.593452414429436,751376378363904000,1630208000,407219712,1298.530425,1298.5325109649123 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,800000,2004,0.19960079840319359,fixed_full_OO_pool,3.611388596313902,755152139059200000,1638400000,409265920,1305.056825,1305.0571893274853 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,804000,2004,0.19960079840319359,fixed_full_OO_pool,3.629324303427711,758927899754496000,1646592000,411312384,1311.584675,1311.582591374269 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,808000,2004,0.14970059880239522,fixed_full_OO_pool,3.6472608088101777,762703660449792000,1654784000,413358592,1318.1077,1318.1077631578946 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,812000,2004,0.09980039920159679,fixed_full_OO_pool,3.665197216923245,766479421145088000,1662976000,415405056,1324.6323,1324.6336403508772 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,816000,2004,0.14970059880239522,fixed_full_OO_pool,3.6831335957772615,770255181840384000,1671168000,417451264,1331.1573,1331.1585233918129 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,820000,2004,0.0,fixed_full_OO_pool,3.701069602256434,774030942535680000,1679360000,419497728,1337.68455,1337.6840131578947 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,824000,2004,0.049900199600798396,fixed_full_OO_pool,3.7190059357095095,777806703230976000,1687552000,421543936,1344.2104,1344.2087719298245 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,828000,2004,0.14970059880239522,fixed_full_OO_pool,3.7369423262930166,781582463926272000,1695744000,423590400,1350.736375,1350.7344480994152 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,832000,2004,0.09980039920159679,fixed_full_OO_pool,3.754879075817557,785358224621568000,1703936000,425636608,1357.26155,1357.2593055555556 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,836000,2004,0.14970059880239522,fixed_full_OO_pool,3.7728153250366447,789133985316864000,1712128000,427683072,1363.786375,1363.7851498538012 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,840000,2004,0.09980039920159679,fixed_full_OO_pool,3.7907519175391644,792909746012160000,1720320000,429729280,1370.3079,1370.3105409356724 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,844000,2004,0.09980039920159679,fixed_full_OO_pool,3.808688191373108,796685506707456000,1728512000,431775744,1376.836875,1376.835778508772 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,848000,2004,0.14970059880239522,fixed_full_OO_pool,3.8266257434421114,800461267402752000,1736704000,433821952,1383.35955,1383.3610014619883 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,852000,2004,0.249500998003992,fixed_full_OO_pool,3.8445619464717393,804237028098048000,1744896000,435868416,1389.88515,1389.8867324561404 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,856000,2004,0.0,fixed_full_OO_pool,3.8624994989453505,808012788793344000,1753088000,437914624,1396.4091,1396.4117690058479 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,860000,2004,0.09980039920159679,fixed_full_OO_pool,3.8804356083273888,811788549488640000,1761280000,439961088,1402.935675,1402.9373574561403 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,864000,2004,0.19960079840319359,fixed_full_OO_pool,3.8983741200270337,815564310183936000,1769472000,442007296,1409.461675,1409.4620942982456 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,868000,2004,0.049900199600798396,fixed_full_OO_pool,3.916310279738779,819340070879232000,1777664000,444053760,1415.9872,1415.98783625731 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,872000,2004,0.19960079840319359,fixed_full_OO_pool,3.9342480956618155,823115831574528000,1785856000,446099968,1422.51175,1422.5127850877193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,876000,2004,0.19960079840319359,fixed_full_OO_pool,3.952183992926859,826891592269824000,1794048000,448146176,1429.037575,1429.03754751462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,880000,2004,0.0,fixed_full_OO_pool,3.9701194841176686,830667352965120000,1802240000,450192640,1435.563525,1435.5632273391814 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,884000,2004,0.09980039920159679,fixed_full_OO_pool,3.9880556056638143,834443113660416000,1810432000,452238848,1442.0886,1442.0880994152046 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,888000,2004,0.0,fixed_full_OO_pool,4.005992047335539,838218874355712000,1818624000,454285312,1448.613375,1448.6139510233918 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,892000,2004,0.049900199600798396,fixed_full_OO_pool,4.023928442187607,841994635051008000,1826816000,456331520,1455.135925,1455.139192251462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,896000,2004,0.09980039920159679,fixed_full_OO_pool,4.041864859702893,845770395746304000,1835008000,458377984,1461.66955,1461.66375 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,900000,2004,0.39920159680638717,fixed_full_OO_pool,4.059800877747023,849546156441600000,1843200000,460424192,1468.1904,1468.189239766082 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,904000,2004,0.09980039920159679,fixed_full_OO_pool,4.077737160795886,853321917136896000,1851392000,462470656,1474.7163,1474.7149269005847 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,908000,2004,0.14970059880239522,fixed_full_OO_pool,4.095673689500739,857097677832192000,1859584000,464516864,1481.23855,1481.240211988304 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,912000,2004,0.049900199600798396,fixed_full_OO_pool,4.1136094744244796,860873438527488000,1867776000,466563328,1487.766175,1487.7656469298245 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,916000,2004,0.09980039920159679,fixed_full_OO_pool,4.131545413997438,864649199222784000,1875968000,468609536,1494.294025,1494.2901133040937 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,920000,2004,0.09980039920159679,fixed_full_OO_pool,4.149481373485178,868424959918080000,1884160000,470656000,1500.817625,1500.8161366959064 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,924000,2004,0.14970059880239522,fixed_full_OO_pool,4.167418584903288,872200720613376000,1892352000,472702208,1507.339175,1507.341524122807 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,928000,2004,0.049900199600798396,fixed_full_OO_pool,4.185354598946869,875976481308672000,1900544000,474748672,1513.8643,1513.8673245614036 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,932000,2004,0.049900199600798396,fixed_full_OO_pool,4.203292155378602,879752242003968000,1908736000,476794880,1520.39315,1520.3916447368422 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,936000,2004,0.14970059880239522,fixed_full_OO_pool,4.221227832685949,883528002699264000,1916928000,478841344,1526.918675,1526.9173866959065 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,940000,2004,0.049900199600798396,fixed_full_OO_pool,4.239164874760641,887303763394560000,1925120000,480887552,1533.445425,1533.4420138888888 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,944000,2004,0.049900199600798396,fixed_full_OO_pool,4.2571012672388715,891079524089856000,1933312000,482934016,1539.96965,1539.9679459064328 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,948000,2004,0.19960079840319359,fixed_full_OO_pool,4.275037977075618,894855284785152000,1941504000,484980224,1546.4949,1546.4927923976609 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,952000,2004,0.0,fixed_full_OO_pool,4.292973408044006,898631045480448000,1949696000,487026432,1553.0175,1553.0180263157895 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,956000,2004,0.19960079840319359,fixed_full_OO_pool,4.310909058165012,902406806175744000,1957888000,489072896,1559.5433,1559.5437280701753 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,960000,2004,0.0,fixed_full_OO_pool,4.3288451000189205,906182566871040000,1966080000,491119104,1566.067025,1566.06879751462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,964000,2004,0.049900199600798396,fixed_full_OO_pool,4.346780861028367,909958327566336000,1974272000,493165568,1572.59525,1572.594144736842 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,968000,2004,0.049900199600798396,fixed_full_OO_pool,4.364716986606105,913734088261632000,1982464000,495211776,1579.121725,1579.1188121345028 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,972000,2004,0.049900199600798396,fixed_full_OO_pool,4.382653166165368,917509848956928000,1990656000,497258240,1585.641325,1585.6454203216374 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,976000,2004,0.049900199600798396,fixed_full_OO_pool,4.400588536622624,921285609652224000,1998848000,499304448,1592.16975,1592.169802631579 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,980000,2004,0.14970059880239522,fixed_full_OO_pool,4.418524057980006,925061370347520000,2007040000,501350912,1598.69315,1598.695855263158 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,984000,2004,0.0,fixed_full_OO_pool,4.436459985169479,928837131042816000,2015232000,503397120,1605.22065,1605.2203728070176 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,988000,2004,0.29940119760479045,fixed_full_OO_pool,4.454396100118756,932612891738112000,2023424000,505443584,1611.74645,1611.7460745614035 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,992000,2004,0.09980039920159679,fixed_full_OO_pool,4.472332431159707,936388652433408000,2031616000,507489792,1618.267875,1618.2714802631579 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,996000,2004,0.049900199600798396,fixed_full_OO_pool,4.49026873063503,940164413128704000,2039808000,509536256,1624.797525,1624.7966191520468 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1000000,2004,0.14970059880239522,fixed_full_OO_pool,4.508205640555049,943940173824000000,2048000000,511582464,1631.3245,1631.3212134502924 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1004000,2004,0.19960079840319359,fixed_full_OO_pool,4.526140592665308,947715934519296000,2056192000,513628928,1637.848,1637.8472514619882 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1008000,2004,0.09980039920159679,fixed_full_OO_pool,4.5440783396653,951491695214592000,2064384000,515675136,1644.377825,1644.3714290935673 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1012000,2004,0.09980039920159679,fixed_full_OO_pool,4.562014029347855,955267455909888000,2072576000,517721600,1650.897675,1650.8980007309942 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1016000,2004,0.14970059880239522,fixed_full_OO_pool,4.57995074367668,959043216605184000,2080768000,519767808,1657.4205,1657.423201754386 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1020000,2004,0.049900199600798396,fixed_full_OO_pool,4.597886311521547,962818977300480000,2088960000,521814272,1663.95055,1663.9482821637428 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1024000,2004,0.0,fixed_full_OO_pool,4.617149466253403,966594737995776000,2097152000,523860480,1670.47305,1670.4735307017545 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1028000,2004,0.049900199600798396,fixed_full_OO_pool,4.639719295766619,970370498691072000,2105344000,525906944,1676.999125,1676.999192251462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1032000,2004,0.049900199600798396,fixed_full_OO_pool,4.663612854560423,974146259386368000,2113536000,527953152,1683.52685,1683.5236769005849 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1036000,2004,0.29940119760479045,fixed_full_OO_pool,4.687392746809249,977922020081664000,2121728000,529999360,1690.048475,1690.0490533625732 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1040000,2004,0.049900199600798396,fixed_full_OO_pool,4.708725805164625,981697780776960000,2129920000,532045824,1696.57575,1696.5745394736841 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1044000,2004,0.09980039920159679,fixed_full_OO_pool,4.727527504010747,985473541472256000,2138112000,534092032,1703.1006,1703.0994444444445 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1048000,2004,0.14970059880239522,fixed_full_OO_pool,4.745462453433623,989249302167552000,2146304000,536138496,1709.626925,1709.6250694444445 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1052000,2004,0.19960079840319359,fixed_full_OO_pool,4.76339704470709,993025062862848000,2154496000,538184704,1716.15085,1716.150109649123 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1056000,2004,0.19960079840319359,fixed_full_OO_pool,4.781332437939321,996800823558144000,2162688000,540231168,1722.676175,1722.6758808479533 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1060000,2004,0.09980039920159679,fixed_full_OO_pool,4.799268194655371,1000576584253440000,2170880000,542277376,1729.20065,1729.200840643275 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1064000,2004,0.19960079840319359,fixed_full_OO_pool,4.817203889341197,1004352344948736000,2179072000,544323840,1735.7277,1735.7263596491227 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1068000,2004,0.049900199600798396,fixed_full_OO_pool,4.835137059646141,1008128105644032000,2187264000,546370048,1742.252225,1742.251312134503 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1072000,2004,0.09980039920159679,fixed_full_OO_pool,4.853070182957583,1011903866339328000,2195456000,548416512,1748.7758,1748.7773391812866 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1076000,2004,0.14970059880239522,fixed_full_OO_pool,4.87099797751858,1015679627034624000,2203648000,550462720,1755.302825,1755.3019261695906 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1080000,2004,0.09980039920159679,fixed_full_OO_pool,4.888923099112387,1019455387729920000,2211840000,552509184,1761.827875,1761.8277375730995 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1084000,2004,0.09980039920159679,fixed_full_OO_pool,4.906858098032988,1023231148425216000,2220032000,554555392,1768.352325,1768.3527010233918 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1088000,2004,0.049900199600798396,fixed_full_OO_pool,4.924783399233387,1027006909120512000,2228224000,556601856,1774.8786,1774.8783333333333 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1092000,2004,0.0,fixed_full_OO_pool,4.942709659501496,1030782669815808000,2236416000,558648064,1781.401475,1781.4035270467837 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1096000,2004,0.09980039920159679,fixed_full_OO_pool,4.960646021222281,1034558430511104000,2244608000,560694528,1787.9267,1787.929312865497 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1100000,2004,0.09980039920159679,fixed_full_OO_pool,4.978571801598494,1038334191206400000,2252800000,562740736,1794.454175,1794.4538340643276 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1104000,2004,0.049900199600798396,fixed_full_OO_pool,4.996496454546642,1042109951901696000,2260992000,564787200,1800.979075,1800.9796673976607 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1108000,2004,0.049900199600798396,fixed_full_OO_pool,5.014422303250887,1045885712596992000,2269184000,566833408,1807.505475,1807.504345760234 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1112000,2004,0.049900199600798396,fixed_full_OO_pool,5.03235807152258,1049661473292288000,2277376000,568879616,1814.0292,1814.0294152046783 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1116000,2004,0.049900199600798396,fixed_full_OO_pool,5.050283088542314,1053437233987584000,2285568000,570926080,1820.55255,1820.555475146199 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1120000,2004,0.049900199600798396,fixed_full_OO_pool,5.068210177878953,1057212994682880000,2293760000,572972288,1827.0793,1827.0801023391814 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1124000,2004,0.0,fixed_full_OO_pool,5.0861353679870565,1060988755378176000,2301952000,575018752,1833.60705,1833.605519005848 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1128000,2004,0.14970059880239522,fixed_full_OO_pool,5.104071282780626,1064764516073472000,2310144000,577064960,1840.1335,1840.1301900584795 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1132000,2004,0.09980039920159679,fixed_full_OO_pool,5.122001412869949,1068540276768768000,2318336000,579111424,1846.655175,1846.656494883041 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1136000,2004,0.14970059880239522,fixed_full_OO_pool,5.139926035385579,1072316037464064000,2326528000,581157632,1853.1819,1853.1811257309942 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1140000,2004,0.0,fixed_full_OO_pool,5.1578559718332775,1076091798159360000,2334720000,583204096,1859.7061,1859.7070614035088 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1144000,2004,0.19960079840319359,fixed_full_OO_pool,5.175791281382036,1079867558854656000,2342912000,585250304,1866.233425,1866.2316045321638 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1148000,2004,0.0,fixed_full_OO_pool,5.193727233673756,1083643319549952000,2351104000,587296768,1872.75915,1872.757317251462 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1152000,2004,0.0,fixed_full_OO_pool,5.211657994288124,1087419080245248000,2359296000,589342976,1879.282975,1879.2823720760234 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1156000,2004,0.09980039920159679,fixed_full_OO_pool,5.229586932944755,1091194840940544000,2367488000,591389440,1885.806675,1885.8083808479532 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1160000,2004,0.14970059880239522,fixed_full_OO_pool,5.247513173288769,1094970601635840000,2375680000,593435648,1892.3363,1892.3325877192983 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1164000,2004,0.0,fixed_full_OO_pool,5.265438722256157,1098746362331136000,2383872000,595482112,1898.854725,1898.8593676900584 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1168000,2004,0.0,fixed_full_OO_pool,5.2833758057591815,1102522123026432000,2392064000,597528320,1905.38405,1905.3836184210527 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1172000,2004,0.09980039920159679,fixed_full_OO_pool,5.301311328859172,1106297883721728000,2400256000,599574784,1911.9119,1911.9090204678362 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1176000,2004,0.0,fixed_full_OO_pool,5.3192479415817395,1110073644417024000,2408448000,601620992,1918.435525,1918.4341045321637 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1180000,2004,0.09980039920159679,fixed_full_OO_pool,5.337183307551054,1113849405112320000,2416640000,603667456,1924.95995,1924.9600073099416 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1184000,2004,0.14970059880239522,fixed_full_OO_pool,5.355109257535595,1117625165807616000,2424832000,605713664,1931.481875,1931.4853399122808 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1188000,2004,0.0,fixed_full_OO_pool,5.373044843197697,1121400926502912000,2433024000,607759872,1938.009425,1938.009850146199 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1192000,2004,0.049900199600798396,fixed_full_OO_pool,5.390980562575989,1125176687198208000,2441216000,609806336,1944.534275,1944.5356907894736 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1196000,2004,0.0,fixed_full_OO_pool,5.408916035606008,1128952447893504000,2449408000,611852544,1951.0621,1951.0601608187135 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1200000,2004,0.14970059880239522,fixed_full_OO_pool,5.426851613051776,1132728208588800000,2457600000,613899008,1957.584825,1957.586312134503 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1204000,2004,0.09980039920159679,fixed_full_OO_pool,5.444776063861532,1136503969284096000,2465792000,615945216,1964.108875,1964.1113340643276 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1208000,2004,0.09980039920159679,fixed_full_OO_pool,5.462704458758235,1140279729979392000,2473984000,617991680,1970.63505,1970.636980994152 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1212000,2004,0.0,fixed_full_OO_pool,5.480639485802708,1144055490674688000,2482176000,620037888,1977.162125,1977.1615606725147 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1216000,2004,0.09980039920159679,fixed_full_OO_pool,5.4985674109806615,1147831251369984000,2490368000,622084352,1983.6894,1983.6870467836256 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1220000,2004,0.09980039920159679,fixed_full_OO_pool,5.516503579294723,1151607012065280000,2498560000,624130560,1990.215475,1990.2117726608187 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1224000,2004,0.049900199600798396,fixed_full_OO_pool,5.5344388772847335,1155382772760576000,2506752000,626177024,1996.7373,1996.7380555555555 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1228000,2004,0.049900199600798396,fixed_full_OO_pool,5.552374369533112,1159158533455872000,2514944000,628223232,2003.262225,2003.2629495614035 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1232000,2004,0.049900199600798396,fixed_full_OO_pool,5.570302525323092,1162934294151168000,2523136000,630269696,2009.79055,2009.7882821637427 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1236000,2004,0.249500998003992,fixed_full_OO_pool,5.588227584079529,1166710054846464000,2531328000,632315904,2016.315575,2016.3131615497075 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1240000,2004,0.0,fixed_full_OO_pool,5.606162257350774,1170485815541760000,2539520000,634362368,2022.841425,2022.838855994152 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1244000,2004,0.0,fixed_full_OO_pool,5.624098582657882,1174261576237056000,2547712000,636408576,2029.3629,2029.3642543859648 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1248000,2004,0.19960079840319359,fixed_full_OO_pool,5.642033963034757,1178037336932352000,2555904000,638455040,2035.889075,2035.8899013157895 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1252000,2004,0.09980039920159679,fixed_full_OO_pool,5.659971066042781,1181813097627648000,2564096000,640501248,2042.414125,2042.4147770467837 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1256000,2004,0.09980039920159679,fixed_full_OO_pool,5.677905780785821,1185588858322944000,2572288000,642547712,2048.936625,2048.94096125731 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1260000,2004,0.049900199600798396,fixed_full_OO_pool,5.695831205484768,1189364619018240000,2580480000,644593920,2055.4625,2055.465716374269 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1264000,2004,0.0,fixed_full_OO_pool,5.713766846800637,1193140379713536000,2588672000,646640384,2061.990325,2061.991122076023 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1268000,2004,0.14970059880239522,fixed_full_OO_pool,5.7316943867494246,1196916140408832000,2596864000,648686592,2068.517525,2068.515683479532 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1272000,2004,0.09980039920159679,fixed_full_OO_pool,5.749629651415679,1200691901104128000,2605056000,650732800,2075.040975,2075.040793128655 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1276000,2004,0.049900199600798396,fixed_full_OO_pool,5.7675647413037305,1204467661799424000,2613248000,652779264,2081.566575,2081.566524122807 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1280000,2004,0.049900199600798396,fixed_full_OO_pool,5.785491786506027,1208243422494720000,2621440000,654825472,2088.094025,2088.0910489766084 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1284000,2004,0.0,fixed_full_OO_pool,5.803425422431901,1212019183190016000,2629632000,656871936,2094.62025,2094.6166885964913 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1288000,2004,0.09980039920159679,fixed_full_OO_pool,5.821360222000836,1215794943885312000,2637824000,658918144,2101.1387,2101.142529239766 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1292000,2004,0.049900199600798396,fixed_full_OO_pool,5.8392950705873465,1219570704580608000,2646016000,660964608,2107.668425,2107.6676571637427 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1296000,2004,0.0,fixed_full_OO_pool,5.857229973007407,1223346465275904000,2654208000,663010816,2114.193775,2114.192489035088 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1300000,2004,0.19960079840319359,fixed_full_OO_pool,5.875165121858526,1227122225971200000,2662400000,665057280,2120.717475,2120.7184978070177 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1304000,2004,0.049900199600798396,fixed_full_OO_pool,5.893100004928807,1230897986666496000,2670592000,667103488,2127.249425,2127.2423647660817 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1308000,2004,0.049900199600798396,fixed_full_OO_pool,5.911034622734619,1234673747361792000,2678784000,669149952,2133.767925,2133.76913377193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1312000,2004,0.049900199600798396,fixed_full_OO_pool,5.928969072611588,1238449508057088000,2686976000,671196160,2140.293825,2140.293885233918 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1316000,2004,0.249500998003992,fixed_full_OO_pool,5.946904008873842,1242225268752384000,2695168000,673242624,2146.8188,2146.8197076023393 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1320000,2004,0.14970059880239522,fixed_full_OO_pool,5.964840261825464,1246001029447680000,2703360000,675288832,2153.35105,2153.3435307017544 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1324000,2004,0.09980039920159679,fixed_full_OO_pool,5.982775665731687,1249776790142976000,2711552000,677335296,2159.869725,2159.870274122807 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1328000,2004,0.19960079840319359,fixed_full_OO_pool,6.000701291483517,1253552550838272000,2719744000,679381504,2166.39615,2166.3949488304092 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1332000,2004,0.049900199600798396,fixed_full_OO_pool,6.018636214897658,1257328311533568000,2727936000,681427968,2172.920625,2172.920844298246 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1336000,2004,0.14970059880239522,fixed_full_OO_pool,6.036572915449118,1261104072228864000,2736128000,683474176,2179.44505,2179.4458114035087 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1340000,2004,0.19960079840319359,fixed_full_OO_pool,6.054497358285719,1264879832924160000,2744320000,685520640,2185.970725,2185.9715314327486 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1344000,2004,0.049900199600798396,fixed_full_OO_pool,6.072433870163643,1268655593619456000,2752512000,687566848,2192.4966,2192.4962865497077 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1348000,2004,0.09980039920159679,fixed_full_OO_pool,6.090368374611975,1272431354314752000,2760704000,689613056,2199.02225,2199.0210745614036 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1352000,2004,0.09980039920159679,fixed_full_OO_pool,6.108303583900755,1276207115010048000,2768896000,691659520,2205.549225,2205.5466045321637 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1356000,2004,0.049900199600798396,fixed_full_OO_pool,6.126229359318192,1279982875705344000,2777088000,693705728,2212.071925,2212.0718238304094 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1360000,2004,0.09980039920159679,fixed_full_OO_pool,6.144160743338159,1283758636400640000,2785280000,695752192,2218.5972,2218.5976023391813 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1364000,2004,0.0,fixed_full_OO_pool,6.162095722124602,1287534397095936000,2793472000,697798400,2225.11965,2225.1228581871346 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1368000,2004,0.049900199600798396,fixed_full_OO_pool,6.18003089674645,1291310157791232000,2801664000,699844864,2231.646725,2231.6483735380116 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1372000,2004,0.049900199600798396,fixed_full_OO_pool,6.197965322344874,1295085918486528000,2809856000,701891072,2238.171425,2238.1733004385965 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1376000,2004,0.049900199600798396,fixed_full_OO_pool,6.215899675300138,1298861679181824000,2818048000,703937536,2244.698475,2244.6988194444443 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1380000,2004,0.249500998003992,fixed_full_OO_pool,6.23383375790591,1302637439877120000,2826240000,705983744,2251.225825,2251.2233589181287 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1384000,2004,0.09980039920159679,fixed_full_OO_pool,6.251768203754392,1306413200572416000,2834432000,708030208,2257.75135,2257.749100877193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1388000,2004,0.249500998003992,fixed_full_OO_pool,6.269702960413157,1310188961267712000,2842624000,710076416,2264.274525,2264.274250730994 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1392000,2004,0.09980039920159679,fixed_full_OO_pool,6.287637503569325,1313964721963008000,2850816000,712122880,2270.802725,2270.799601608187 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1396000,2004,0.049900199600798396,fixed_full_OO_pool,6.305573378549889,1317740482658304000,2859008000,714169088,2277.325425,2277.3248209064327 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1400000,2004,0.19960079840319359,fixed_full_OO_pool,6.323508348239379,1321516243353600000,2867200000,716215552,2283.849875,2283.8507200292397 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1404000,2004,0.049900199600798396,fixed_full_OO_pool,6.3414451354628225,1325292004048896000,2875392000,718261760,2290.376375,2290.37538377193 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1408000,2004,0.049900199600798396,fixed_full_OO_pool,6.359369626670248,1329067764744192000,2883584000,720308224,2296.901125,2296.9012390350877 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1412000,2004,0.09980039920159679,fixed_full_OO_pool,6.3773057717136625,1332843525439488000,2891776000,722354432,2303.423775,2303.4264656432747 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1416000,2004,0.049900199600798396,fixed_full_OO_pool,6.395240410524938,1336619286134784000,2899968000,724400896,2309.950975,2309.951962719298 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1420000,2004,0.19960079840319359,fixed_full_OO_pool,6.413175711380318,1340395046830080000,2908160000,726447104,2316.4738,2316.47716374269 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1424000,2004,0.14970059880239522,fixed_full_OO_pool,6.431110404658441,1344170807525376000,2916352000,728493312,2323.001475,2323.0016557017543 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1428000,2004,0.09980039920159679,fixed_full_OO_pool,6.4490455967798415,1347946568220672000,2924544000,730539776,2329.526925,2329.527408625731 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1432000,2004,0.0,fixed_full_OO_pool,6.466980896468999,1351722328915968000,2932736000,732585984,2336.05215,2336.0522587719297 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1436000,2004,0.0,fixed_full_OO_pool,6.484916341600733,1355498089611264000,2940928000,734632448,2342.57685,2342.578121345029 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1440000,2004,0.09980039920159679,fixed_full_OO_pool,6.50285091392075,1359273850306560000,2949120000,736678656,2349.1014,2349.1030701754385 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1444000,2004,0.09980039920159679,fixed_full_OO_pool,6.520785178263775,1363049611001856000,2957312000,738725120,2355.6274,2355.6287426900585 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1448000,2004,0.049900199600798396,fixed_full_OO_pool,6.538722577538962,1366825371697152000,2965504000,740771328,2362.15255,2362.1536038011695 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1452000,2004,0.39920159680638717,fixed_full_OO_pool,6.556636449072717,1370601132392448000,2973696000,742817792,2368.679725,2368.679104532164 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1456000,2004,0.14970059880239522,fixed_full_OO_pool,6.574549024499332,1374376893087744000,2981888000,744864000,2375.204275,2375.204053362573 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1460000,2004,0.14970059880239522,fixed_full_OO_pool,6.592462130584237,1378152653783040000,2990080000,746910464,2381.726575,2381.7302668128655 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1464000,2004,0.09980039920159679,fixed_full_OO_pool,6.610370388227619,1381928414478336000,2998272000,748956672,2388.25755,2388.2542763157894 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1468000,2004,0.09980039920159679,fixed_full_OO_pool,6.628280977611947,1385704175173632000,3006464000,751003136,2394.7818,2394.7802046783627 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1472000,2004,0.09980039920159679,fixed_full_OO_pool,6.646192981343096,1389479935868928000,3014656000,753049344,2401.3038,2401.3055263157894 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1476000,2004,0.19960079840319359,fixed_full_OO_pool,6.664103796627994,1393255696564224000,3022848000,755095808,2407.83105,2407.8310160818714 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1480000,2004,0.14970059880239522,fixed_full_OO_pool,6.682016832925793,1397031457259520000,3031040000,757142016,2414.353925,2414.356209795322 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1484000,2004,0.09980039920159679,fixed_full_OO_pool,6.699927913641764,1400807217954816000,3039232000,759188480,2420.880325,2420.8818238304093 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1488000,2004,0.0,fixed_full_OO_pool,6.717841198919341,1404582978650112000,3047424000,761234688,2427.40705,2427.4064546783625 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1492000,2004,0.049900199600798396,fixed_full_OO_pool,6.735750305606052,1408358739345408000,3055616000,763281152,2433.932325,2433.9322331871344 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1496000,2004,0.049900199600798396,fixed_full_OO_pool,6.75365993058102,1412134500040704000,3063808000,765327360,2440.456625,2440.4572185672514 +synthetic,standard8-phi7.2-wd0.3,standard8,791101,0.0001,0.3,7.2,1500000,2004,0.0,fixed_full_OO_pool,6.771571062275519,1415910260736000000,3072000000,767373824,2446.9826,2446.982894736842 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,1000,64,3.125,fixed_panel,0.02228873894756867,9260419841349120,21867096,510884,4.184437909289352,4.184618948343757 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,2000,64,3.125,fixed_panel,0.04445229992063509,18518153601074688,43731592,1021768,8.368648435605142,8.369505176315462 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,4000,64,9.375,fixed_panel,0.08870742158343395,37028569788228096,87461320,2043536,16.73957070094591,16.736337556351454 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,8000,64,7.8125,fixed_panel,0.17732683974628646,74037749644486656,174839984,4086793,33.47186514673781,33.47625665971739 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,16000,64,14.0625,fixed_panel,0.35453378348714776,148090769767134720,349741408,8173586,66.94861144797477,66.94677571675487 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,32000,64,10.9375,fixed_panel,0.7083676767432028,296104226508965376,699326432,16346893,133.8924175357749,133.89422854190053 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,64000,64,14.0625,fixed_panel,1.4169371627188392,592170710105170944,1398497584,32693507,267.7832585495998,267.785338821475 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,128000,64,15.625,fixed_panel,2.8331757211405786,1184413056448209408,2797405552,65386735,535.568048144555,535.563906559042 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,200000,64,17.1875,fixed_panel,4.426370209434794,1850408247199408128,4370292584,102166756,836.8199581615329,836.8243081912296 +real_native,confirmation-loop4x2-init1,loop4x2,811201,5e-05,0.1,,300000,64,18.75,fixed_panel,6.636754266745928,2775487015724686848,6555176928,153249855,1255.2305814940578,1255.2307335934854 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,1000,64,1.5625,fixed_panel,0.022338114315643906,9268359675084288,21897632,510884,4.185317123453796,4.183585467115696 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,2000,64,4.6875,fixed_panel,0.044573705808983906,18522912799383552,43766592,1021768,8.369633761823914,8.368346964594359 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,4000,64,7.8125,fixed_panel,0.08885639423814913,37004869396445184,87377536,2043536,16.737994178995876,16.73819069510522 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,8000,64,10.9375,fixed_panel,0.17744039842031067,73988370907232256,174689168,4086793,33.4746998544749,33.47292457368899 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,16000,64,10.9375,fixed_panel,0.35470222381564476,148012554097774080,349527656,8173586,66.94824763521707,66.94720336415958 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,32000,64,12.5,fixed_panel,0.7091205508179135,296022176994281472,699072848,16346893,133.89387278680573,133.89251795228168 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,64000,64,17.1875,fixed_panel,1.417827679094755,592047522277157376,1398201936,32693507,267.78281894251757,267.78585556208907 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,128000,64,14.0625,fixed_panel,2.8347031834597387,1184054694765958656,2796471272,65386735,535.564713194276,535.567826660252 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,200000,64,15.625,fixed_panel,4.4300069244330125,1850142491230537728,4369685960,102166756,836.8214134125636,836.8225976016108 +real_native,confirmation-loop4x2-init2,loop4x2,811202,5e-05,0.1,,300000,64,17.1875,fixed_panel,6.642358209469045,2775118595566491648,6554444824,153249855,1255.2311120543293,1255.2301099410204 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,1000,64,1.5625,fixed_panel,0.022309419465147785,9284420599050240,21922208,510884,4.186514673781227,4.18217779440851 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,2000,64,4.6875,fixed_panel,0.044432957938147916,18523186413949440,43760632,1021768,8.369785350472956,8.368168778175727 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,4000,64,4.6875,fixed_panel,0.08874037046502861,37027899583736832,87475840,2043536,16.739358476837253,16.736587017337538 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,8000,64,9.375,fixed_panel,0.177279048246435,74045072091409920,174912216,4086793,33.47404802328402,33.47369077528911 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,16000,64,15.625,fixed_panel,0.3543287268156807,148052981785347072,349687768,8173586,66.94755032743149,66.94802302168529 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,32000,64,17.1875,fixed_panel,0.7083120104670525,296059043093054976,699259008,16346893,133.89288746058696,133.89367616400278 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,64000,64,14.0625,fixed_panel,1.4166684452951368,592166642074661376,1398664736,32693507,267.78350109143827,267.78505372320524 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,128000,64,14.0625,fixed_panel,2.832417859882116,1184121275330732544,2796746392,65386735,535.5668505942275,535.5653142317493 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,200000,64,14.0625,fixed_panel,4.426071972963918,1850228693887431168,4369994584,102166756,836.8221258792141,836.8217601254432 +real_native,confirmation-loop4x2-init3,loop4x2,811203,5e-05,0.1,,300000,64,21.875,fixed_panel,6.636981699868209,2775312255025967616,6554773168,153249855,1255.2295203735143,1255.231980898416 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,1000,64,1.5625,fixed_panel,0.014556795394875937,5510812180502016,21867096,510884,4.184437909289352,4.184618948343757 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,2000,64,3.125,fixed_panel,0.028984759436506365,11019387057587712,43731592,1021768,8.368648435605142,8.369505176315462 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,4000,64,7.8125,fixed_panel,0.05773482915117509,22031348621419008,87461320,2043536,16.73957070094591,16.736337556351454 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,8000,64,6.25,fixed_panel,0.1155179052406715,44057519327766528,174839984,4086793,33.47186514673781,33.47625665971739 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,16000,64,14.0625,fixed_panel,0.23038100480515925,88119747943331328,349741408,8173586,66.94861144797477,66.94677571675487 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,32000,64,15.625,fixed_panel,0.46046649649842747,176189273708889600,699326432,16346893,133.8924175357749,133.89422854190053 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,64000,64,14.0625,fixed_panel,0.9205038651461817,352367818000671744,1398497584,32693507,267.7832585495998,267.785338821475 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,128000,64,17.1875,fixed_panel,1.8406062863001393,704736437307056640,2797405552,65386735,535.568048144555,535.563906559042 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,200000,64,17.1875,fixed_panel,2.8755003711922713,1101026553491496960,4370292584,102166756,836.8199581615329,836.8243081912296 +real_native,confirmation-standard4-init1,standard4,811201,5e-05,0.1,,300000,64,18.75,fixed_panel,4.311865449844756,1651459843050610176,6555176928,153249855,1255.2305814940578,1255.2307335934854 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,1000,64,3.125,fixed_panel,0.014505431950092317,5513483836030464,21897632,510884,4.185317123453796,4.183585467115696 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,2000,64,4.6875,fixed_panel,0.02886166985767583,11018085972369408,43766592,1021768,8.369633761823914,8.368346964594359 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,4000,64,9.375,fixed_panel,0.05757096206251946,22022107337963520,87377536,2043536,16.737994178995876,16.73819069510522 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,8000,64,7.8125,fixed_panel,0.11495190266519785,44034231507056640,174689168,4086793,33.4746998544749,33.47292457368899 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,16000,64,15.625,fixed_panel,0.22990210199211206,88078499806957056,349527656,8173586,66.94824763521707,66.94720336415958 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,32000,64,18.75,fixed_panel,0.4595834456032349,176151147575887872,699072848,16346893,133.89387278680573,133.89251795228168 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,64000,64,14.0625,fixed_panel,0.9190684403375619,352295785542117888,1398201936,32693507,267.78281894251757,267.78585556208907 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,128000,64,23.4375,fixed_panel,1.838409626768488,704539553470649856,2796471272,65386735,535.564713194276,535.567826660252 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,200000,64,20.3125,fixed_panel,2.871965420049512,1100865561641551872,4369685960,102166756,836.8214134125636,836.8225976016108 +real_native,confirmation-standard4-init2,standard4,811202,5e-05,0.1,,300000,64,20.3125,fixed_panel,4.306228105037784,1651217730075777024,6554444824,153249855,1255.2311120543293,1255.2301099410204 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,1000,64,1.5625,fixed_panel,0.019166102168253728,5525297574211584,21922208,510884,4.186514673781227,4.18217779440851 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,2000,64,4.6875,fixed_panel,0.03813062183869382,11019397490790912,43760632,1021768,8.369785350472956,8.368168778175727 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,4000,64,4.6875,fixed_panel,0.07611251984412472,22028184138525696,87475840,2043536,16.739358476837253,16.736587017337538 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,8000,64,4.6875,fixed_panel,0.1447147233194361,44052427940064768,174912216,4086793,33.47404802328402,33.47369077528911 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,16000,64,18.75,fixed_panel,0.25950769659338724,88091345913431040,349687768,8173586,66.94755032743149,66.94802302168529 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,32000,64,14.0625,fixed_panel,0.4890922908071015,176155884616582656,699259008,16346893,133.89288746058696,133.89367616400278 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,64000,64,18.75,fixed_panel,0.9488196933714466,352334781222105600,1398664736,32693507,267.78350109143827,267.78505372320524 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,128000,64,15.625,fixed_panel,1.8678605710601228,704558473255199232,2796746392,65386735,535.5668505942275,535.5653142317493 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,200000,64,20.3125,fixed_panel,2.901721885163958,1100898365460263424,4369994584,102166756,836.8221258792141,836.8217601254432 +real_native,confirmation-standard4-init3,standard4,811203,5e-05,0.1,,300000,64,17.1875,fixed_panel,4.338233347138804,1651354498478928384,6554773168,153249855,1255.2295203735143,1255.231980898416 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,1000,64,3.125,fixed_panel,0.022623708758296238,9260419841349120,21867096,510884,4.184437909289352,4.184618948343757 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,2000,64,3.125,fixed_panel,0.04507237584330141,18518153601074688,43731592,1021768,8.368648435605142,8.369505176315462 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,4000,64,7.8125,fixed_panel,0.08988247311881019,37028569788228096,87461320,2043536,16.73957070094591,16.736337556351454 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,8000,64,7.8125,fixed_panel,0.17969685862047804,74037749644486656,174839984,4086793,33.47186514673781,33.47625665971739 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,16000,64,14.0625,fixed_panel,0.3591253252844844,148090769767134720,349741408,8173586,66.94861144797477,66.94677571675487 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,32000,64,17.1875,fixed_panel,0.7176632881847521,296104226508965376,699326432,16346893,133.8924175357749,133.89422854190053 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,64000,64,21.875,fixed_panel,1.435031522354111,592170710105170944,1398497584,32693507,267.7832585495998,267.785338821475 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,128000,64,18.75,fixed_panel,2.8699546294348934,1184413056448209408,2797405552,65386735,535.568048144555,535.563906559042 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,200000,64,21.875,fixed_panel,4.483479647414966,1850408247199408128,4370292584,102166756,836.8199581615329,836.8243081912296 +real_native,confirmation-standard8-init1,standard8,811201,5e-05,0.1,,300000,64,18.75,fixed_panel,6.723028642990523,2775487015724686848,6555176928,153249855,1255.2305814940578,1255.2307335934854 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,1000,64,1.5625,fixed_panel,0.022494084262806507,9268359675084288,21897632,510884,4.185317123453796,4.183585467115696 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,2000,64,6.25,fixed_panel,0.04488213702518907,18522912799383552,43766592,1021768,8.369633761823914,8.368346964594359 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,4000,64,9.375,fixed_panel,0.089563416575806,37004869396445184,87377536,2043536,16.737994178995876,16.73819069510522 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,8000,64,10.9375,fixed_panel,0.17901978286293646,73988370907232256,174689168,4086793,33.4746998544749,33.47292457368899 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,16000,64,14.0625,fixed_panel,0.35795272102372516,148012554097774080,349527656,8173586,66.94824763521707,66.94720336415958 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,32000,64,14.0625,fixed_panel,0.7158020187065833,296022176994281472,699072848,16346893,133.89387278680573,133.89251795228168 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,64000,64,18.75,fixed_panel,1.4316426220298228,592047522277157376,1398201936,32693507,267.78281894251757,267.78585556208907 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,128000,64,18.75,fixed_panel,2.8627967061609443,1184054694765958656,2796471272,65386735,535.564713194276,535.567826660252 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,200000,64,18.75,fixed_panel,4.474601013899471,1850142491230537728,4369685960,102166756,836.8214134125636,836.8225976016108 +real_native,confirmation-standard8-init2,standard8,811202,5e-05,0.1,,300000,64,21.875,fixed_panel,6.7091564928398775,2775118595566491648,6554444824,153249855,1255.2311120543293,1255.2301099410204 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,0,64,0.0,fixed_panel,0.0,0,0,0,0.0,0.0 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,1000,64,1.5625,fixed_panel,0.02265964069093267,9284420599050240,21922208,510884,4.186514673781227,4.18217779440851 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,2000,64,3.125,fixed_panel,0.045186504002453554,18523186413949440,43760632,1021768,8.369785350472956,8.368168778175727 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,4000,64,4.6875,fixed_panel,0.08996607470119165,37027899583736832,87475840,2043536,16.739358476837253,16.736587017337538 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,8000,64,4.6875,fixed_panel,0.17937321389300956,74045072091409920,174912216,4086793,33.47404802328402,33.47369077528911 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,16000,64,15.625,fixed_panel,0.3582245022689717,148052981785347072,349687768,8173586,66.94755032743149,66.94802302168529 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,32000,64,10.9375,fixed_panel,0.7160406312098105,296059043093054976,699259008,16346893,133.89288746058696,133.89367616400278 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,64000,64,12.5,fixed_panel,1.4320194121667493,592166642074661376,1398664736,32693507,267.78350109143827,267.78505372320524 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,128000,64,20.3125,fixed_panel,2.863654817836359,1184121275330732544,2796746392,65386735,535.5668505942275,535.5653142317493 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,200000,64,17.1875,fixed_panel,4.474285229415529,1850228693887431168,4369994584,102166756,836.8221258792141,836.8217601254432 +real_native,confirmation-standard8-init3,standard8,811203,5e-05,0.1,,300000,64,18.75,fixed_panel,6.712122530073135,2775312255025967616,6554773168,153249855,1255.2295203735143,1255.231980898416 diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/recount-audit.json b/docs/development-artifacts/oo-budget-attribution-20261005/recount-audit.json new file mode 100644 index 0000000000000000000000000000000000000000..9cbdbcabec2f1dab155bd4e38f5bdd45baf1f6e9 --- /dev/null +++ b/docs/development-artifacts/oo-budget-attribution-20261005/recount-audit.json @@ -0,0 +1,619 @@ +{ + "passed": true, + "raw_pools_recounted": 81, + "records": [ + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 32000, + "n": 2004, + "correct": 0 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 64000, + "n": 2004, + "correct": 9 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 128000, + "n": 2004, + "correct": 31 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 200000, + "n": 2004, + "correct": 56 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 300000, + "n": 2004, + "correct": 84 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 500000, + "n": 2004, + "correct": 304 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 700000, + "n": 2004, + "correct": 527 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 1000000, + "n": 2004, + "correct": 857 + }, + { + "run": "loop4x2-phi12.6-wd0.1", + "step": 1500000, + "n": 2004, + "correct": 1326 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 32000, + "n": 2004, + "correct": 5 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 64000, + "n": 2004, + "correct": 4 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 128000, + "n": 2004, + "correct": 4 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 200000, + "n": 2004, + "correct": 11 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 300000, + "n": 2004, + "correct": 12 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 500000, + "n": 2004, + "correct": 10 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 700000, + "n": 2004, + "correct": 22 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 1000000, + "n": 2004, + "correct": 72 + }, + { + "run": "loop4x2-phi3.6-wd0.1", + "step": 1500000, + "n": 2004, + "correct": 514 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 32000, + "n": 2004, + "correct": 5 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 64000, + "n": 2004, + "correct": 5 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 128000, + "n": 2004, + "correct": 14 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 200000, + "n": 2004, + "correct": 47 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 300000, + "n": 2004, + "correct": 70 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 500000, + "n": 2004, + "correct": 231 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 700000, + "n": 2004, + "correct": 426 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 1000000, + "n": 2004, + "correct": 689 + }, + { + "run": "loop4x2-phi7.2-wd0.1", + "step": 1500000, + "n": 2004, + "correct": 1068 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 32000, + "n": 2004, + "correct": 6 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 64000, + "n": 2004, + "correct": 9 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 128000, + "n": 2004, + "correct": 94 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 200000, + "n": 2004, + "correct": 216 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 300000, + "n": 2004, + "correct": 490 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 500000, + "n": 2004, + "correct": 1028 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 700000, + "n": 2004, + "correct": 1352 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 1000000, + "n": 2004, + "correct": 1522 + }, + { + "run": "loop4x2-phi7.2-wd0.3", + "step": 1500000, + "n": 2004, + "correct": 1630 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 32000, + "n": 2004, + "correct": 0 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 64000, + "n": 2004, + "correct": 0 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 128000, + "n": 2004, + "correct": 3 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 200000, + "n": 2004, + "correct": 3 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 300000, + "n": 2004, + "correct": 2 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 500000, + "n": 2004, + "correct": 6 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 700000, + "n": 2004, + "correct": 3 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 1000000, + "n": 2004, + "correct": 2 + }, + { + "run": "standard8-phi12.6-wd0.1", + "step": 1500000, + "n": 2004, + "correct": 0 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 32000, + "n": 2004, + "correct": 2 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 64000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 128000, + "n": 2004, + "correct": 5 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 200000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 300000, + "n": 2004, + "correct": 5 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 500000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 700000, + "n": 2004, + "correct": 7 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 1000000, + "n": 2004, + "correct": 1 + }, + { + "run": "standard8-phi3.6-wd0.1", + "step": 1500000, + "n": 2004, + "correct": 8 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 32000, + "n": 2004, + "correct": 7 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 64000, + "n": 2004, + "correct": 1 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 128000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 200000, + "n": 2004, + "correct": 2 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 300000, + "n": 2004, + "correct": 2 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 500000, + "n": 2004, + "correct": 5 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 700000, + "n": 2004, + "correct": 6 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 1000000, + "n": 2004, + "correct": 8 + }, + { + "run": "standard8-phi7.2-wd0.1", + "step": 1500000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 32000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 64000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 128000, + "n": 2004, + "correct": 5 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 200000, + "n": 2004, + "correct": 3 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 300000, + "n": 2004, + "correct": 4 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 500000, + "n": 2004, + "correct": 3 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 700000, + "n": 2004, + "correct": 2 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 1000000, + "n": 2004, + "correct": 3 + }, + { + "run": "standard8-phi7.2-wd0.3", + "step": 1500000, + "n": 2004, + "correct": 0 + }, + { + "run": "confirmation-loop4x2-init1", + "step": 300000, + "n": 1283, + "correct": 219 + }, + { + "run": "confirmation-loop4x2-init2", + "step": 300000, + "n": 1283, + "correct": 220 + }, + { + "run": "confirmation-loop4x2-init3", + "step": 300000, + "n": 1283, + "correct": 205 + }, + { + "run": "confirmation-standard4-init1", + "step": 300000, + "n": 1283, + "correct": 217 + }, + { + "run": "confirmation-standard4-init2", + "step": 300000, + "n": 1283, + "correct": 226 + }, + { + "run": "confirmation-standard4-init3", + "step": 300000, + "n": 1283, + "correct": 212 + }, + { + "run": "confirmation-standard8-init1", + "step": 300000, + "n": 1283, + "correct": 227 + }, + { + "run": "confirmation-standard8-init2", + "step": 300000, + "n": 1283, + "correct": 245 + }, + { + "run": "confirmation-standard8-init3", + "step": 300000, + "n": 1283, + "correct": 211 + } + ], + "sources_sha256": { + "results/grokking-reproduction-v1/data/complete.json": "c60b3c65e6ab889d78b2b0fa6b17cf82ee8739ce14cb2ae18897fe3b10cfda83", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/run.json": "62c593fe5dc85f6a17e5a447e1b25f6c76d0dd6a5cf612283a9185138c884f05", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/learning.json": "5ec2979a7d81bfcf71c8d009b410f06b39b9053fb1282a1a5c65e266290edcfd", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0032000-test_oo.npz": "a272fe5b30e5c251f4a2f5aa6f280fa23ffc6b1e30a38b7644a7054a48b489e2", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0064000-test_oo.npz": "c31fd027ad2284a9dd66fe4f83dd7129820b66dcfc2f3bb7f92e8c26181d7d05", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0128000-test_oo.npz": "586380b3f777488a86708aedbc8ab6922ee1f67ff7dad2f0d4116d1d3062db88", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0200000-test_oo.npz": "df645588cbd33fae6312da6817f4a3872c9085ddf15a03b48e58464d2894dedc", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0300000-test_oo.npz": "b7d6608fc66a83ecf2e86c367b7f73c985ce7c6dac42055d88289acad37340b9", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0500000-test_oo.npz": "9c9362b6e6e41d4df6ed1ca1cb7697284802bc7e06c492e8ebc6d819d2538665", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-0700000-test_oo.npz": "77d9e7d41d1bb9ffecc989a2319a0470c504de2c13fbd5808edaf93f46c56977", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-1000000-test_oo.npz": "7b92d86add226d179bd0cea94740728b30d6ce9e91a3acc456de5de2d47d1845", + "results/grokking-reproduction-v1/development/loop4x2-phi12.6-wd0.1/predictions-1500000-test_oo.npz": "e89a82f6ff41ebd6166de73e4d90547446ef6e141e06162e47de5ba75b169ea4", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/run.json": "8b0d1ef4aa8a68cc65b3b20ba57147598618beacbc21c30c68f40a4eae4459ba", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/learning.json": "95a44a719606c3d43a8323a5813b8c22f48a0ce88cf57ee2378fef7cdcdabf01", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0032000-test_oo.npz": "e1de7070988bffe16dd420362ae3cfc30ea8858b4a878d4b5432c16cb17d5c7e", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0064000-test_oo.npz": "03a91a328e2a3d5a6d4477c3e396e6c895e0e5d633f3fcaa078f8586db2b7b92", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0128000-test_oo.npz": "b93be84721dde34cc887e68baa2851165fe4640e4ef037b054ec7eb581509419", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0200000-test_oo.npz": "d1ea80aeae192e1628932d805990e416db3f0f15a0fd3f3407398c7f1a6eaba3", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0300000-test_oo.npz": "be1d16c2703bb5790387f289734c2ccc72c9f04105214f372e866a4323783ad4", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0500000-test_oo.npz": "26b9adb9f8e08ae2e7843917622b4ed390181f208279a6dea7a2033495e28b43", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-0700000-test_oo.npz": "de2ff55207351f1c0ea8cf8f73969bcf956d0055bef18cc744fcdabb5a2aed1f", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-1000000-test_oo.npz": "f99173107a99738b0a21644679de9ca147892d972b0b86d95c87b1e57f7e8283", + "results/grokking-reproduction-v1/development/loop4x2-phi3.6-wd0.1/predictions-1500000-test_oo.npz": "7c2adacf7e90a6e5808825cf6c546d9ad386f17ecd4a20a764403ed0de8eddf9", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/run.json": "46c6a2e5aaa17363b778072faf5f6a220a5928dbd8f2c3c4b425c939247ad369", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/learning.json": "05a659a625d60c606dd15e45c48269ff58d5e000f6c5e30eb15d43a56eb78b35", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0032000-test_oo.npz": "de9d3f81439e6f23b4cc5370b6007b63cb9958d8e67eb7c2b8e8c72d9e824790", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0064000-test_oo.npz": "ea0ce38033b2dfe1c4b92570b2432e02857e066c0936726d668170eb8453eafe", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0128000-test_oo.npz": "18542eeccca5b59390c42b3ba2c20253ce69defd29f766983c0fde8ef150bb01", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0200000-test_oo.npz": "56c805a50d43e28f31b33dfc14ff04c92e5dcbb2d711f9e2101cd88999368271", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0300000-test_oo.npz": "e02bd7345478544fd00715919490c3aad3a55db3651636055069483bd3f36a99", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0500000-test_oo.npz": "62e86937272a395a3898c539e9f9b45859c68d20e36da4e380e97d900b2f056b", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-0700000-test_oo.npz": "540118de2d3ca1dffbe0588e1d0748651a8b43bd63dd361cbbb8a89b36b172d4", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-1000000-test_oo.npz": "ed60ef14b9713eeec1ec029be238eafcce14fe43224c9a9ff0cc6e807e909027", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.1/predictions-1500000-test_oo.npz": "7be587982acb77c4056a4192ee9ad365606e5319ec45ead3155297af39ae0db5", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/run.json": "83c0bfa5e5cb042734b29243c10f6d3faff005103a97b8180ae79da462b26504", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/learning.json": "265aa27765acb98a17db0af0e304d23436be75cf88a0cbf7f71d802eebdc431b", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0032000-test_oo.npz": "33ecea27acc46a6d5d04ff0e9ccd358e68d8e8791f0c1c1d6fa7e90a963cbd91", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0064000-test_oo.npz": "7e9d52ab94f47c790c608c07c2be756013636a7c6dab7b5d5e1fea56cdee0409", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0128000-test_oo.npz": "7f3cfae50269936f5624fa9fc61c7f9eaf120a5d4c28724980c5ddcbd9e16975", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0200000-test_oo.npz": "1cd33df3479903b85133bfca39dc5bffa27c4a64ff2130eb18346cacf7cdfb2e", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0300000-test_oo.npz": "1d28d9ad2ff6ce42b1736f1e9a41ead08cd651c06e1a28fe8c0d954a26abb023", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0500000-test_oo.npz": "f82b1dc268b63e636f589126516eb5e82be25e458e9ee360a38d51f5d12a3d30", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-0700000-test_oo.npz": "89286f3fdd871f395efc7f2cce4f67b819f7b79c7279676ae3af9354c19332d4", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-1000000-test_oo.npz": "fbd8d490ae2a1c5f06cbb37a61a2f720f0f7f46d4e9c9d465049fd3490cc3099", + "results/grokking-reproduction-v1/development/loop4x2-phi7.2-wd0.3/predictions-1500000-test_oo.npz": "15d16f7c1f039530076abed4e86148bcad772f059a716b74d563964a7a5dbf3b", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/run.json": "c68dbd61ea91244860d35f7e852b70dcd7f9168a4fb27516c1b73e00412212b2", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/learning.json": "8e021c7007ecf13ff4ecbfc723ac7d6bc2ab00bfa6b1e75a27fcd80410df64f3", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0032000-test_oo.npz": "40edb2432dc398b082a8e65f88dc10dcc5da7a9e7668bed94eaf9157fe068b5c", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0064000-test_oo.npz": "a323ced50b1a91e4ee02b2d9d7ab7e3ea50c2e65ec615b2b6c573bdb620e21d7", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0128000-test_oo.npz": "b69f4269dd704950750deabc30f874cccf0bd59d24dd9a1a3d5835f18f85fa2a", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0200000-test_oo.npz": "632c7e40da95c37cc5573be5d93f072031ddec4fe7bc575a7e2b7eb38127c90b", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0300000-test_oo.npz": "3a826b97e142699e634a059a61e13492c1687bbd4bfb854ce18ead25a5a65276", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0500000-test_oo.npz": "f695a111d1bb4ac76e2661838e448f8ea17f0cdf9b3995c77354f0baf58206df", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-0700000-test_oo.npz": "55b657ae8bbf22a42ed4bb8e18e70508ae50e2b57d647e8046a077b500c48718", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-1000000-test_oo.npz": "59d52aca1af2b394f091d50a5425af407b39aa206ccc38a03ca20dc416e019a4", + "results/grokking-reproduction-v1/development/standard8-phi12.6-wd0.1/predictions-1500000-test_oo.npz": "634f391c2efb311260dfca1c0d933aad911a7d77ac1984e253932779f4ee7169", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/run.json": "fd03256d8f10c9bbbcf2f9b42f5c0d68743992d7a025eb7b2d159b628193f372", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/learning.json": "d81a7441a5dd2d877216e50e9ea9378f9b270e282caf7b08d54b71fb9f34f8ab", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0032000-test_oo.npz": "fcfd417607ae26f26a7bc01f20090dd527e21693a097f6887bfc7af32c796d6f", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0064000-test_oo.npz": "1bf8a51b2d1cc5e3fc47fbede357bab8e0fa21e576c34b661022861408672c12", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0128000-test_oo.npz": "e0a6146778a34e97bed606a49f3059b2cfcdd5c2a59645847ce523744eb473e0", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0200000-test_oo.npz": "3a16c38a0cf7ba3f8d0a1f2ea49f6f79504d0870f4ce0a61bc21666463d67636", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0300000-test_oo.npz": "54ff1dceec1ab82fdd3d5097354ce193ec8941f66edd499e8761fc7bdbbdc065", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0500000-test_oo.npz": "c7a2404097433f8d93c2ed6c9d7d3503ea76ba447e8090ee820eec7e76846731", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-0700000-test_oo.npz": "9b1135b8db8c0fd71bd5d7579a29dc0d8cf5baa77a66171f0b7eb3aeef1a14ff", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-1000000-test_oo.npz": "b9dc9ed7de4eb7a6c9018b92868c04e98a275bebfda4a8008902e94ea5737a8a", + "results/grokking-reproduction-v1/development/standard8-phi3.6-wd0.1/predictions-1500000-test_oo.npz": "f21a49a8e05bd18cf61a43960a560d73290173d5fc2da95fc5e5a012bd731121", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/run.json": "bd83c908ebd9b52a3988cf1edaa6a43f25684782b5ddeab46883ef7de7b56999", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/learning.json": "5848e79a0890de6ef91960475c86665446ffea3d651eb88c7206af6bf10a27f2", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0032000-test_oo.npz": "12980e13ef40e83a0088285ae55d964ef709979f31e932da3c0f6331940f8660", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0064000-test_oo.npz": "77e1afb758ca100d49e123cfbc4f585283eefedc26159a8d53450ba5b0ffa8ae", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0128000-test_oo.npz": "4953d8a97ecf2cfbd94722f2bd832b356bb5f823c954f41f830baeb9aac089ef", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0200000-test_oo.npz": "7d969674c5f471c58ccc1d90406f6ed05fb1fa81c6e08131d483867873970b64", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0300000-test_oo.npz": "9dd384900c93b6a9c4cb31dba52ebff30455580e156a5f2ece652735af496415", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0500000-test_oo.npz": "6b1382e0db5e70393c9d17d77212bb414cf081a998f0c54c5778c76da041c82b", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-0700000-test_oo.npz": "1a11875e664200de8f035da18fc1db4972153b62b1f19a18bb9435035aaa7066", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-1000000-test_oo.npz": "9600c18eeb8c1fb5caacac92fbcfc448e7d6491e41f0a2044da5fcb1139b2e11", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.1/predictions-1500000-test_oo.npz": "6ce4c1071c0576a5060a7c30b4d22263fb102e6df63e3d60fa8885552c224b04", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/run.json": "b5406855d2b5c80c7346f1614b45a2a301ec470b40c0a73e0bcb0aa3ac614411", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/learning.json": "bcc0087f153515d71d6f1ff2ce51b0c14d41d054b320c959d76f27017e9be893", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0032000-test_oo.npz": "3a5eae216f217b5be7d8a91e96cc33951bc626de296b95fe8d25d24b261d9329", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0064000-test_oo.npz": "64cf49e27b8195343bfc8b16fc7629a43e135477475b747b51da2c41c49ca11a", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0128000-test_oo.npz": "f923c264b8f4e74671eeade976e76c09b34ab0a3cbc70c8d4c7758824430362d", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0200000-test_oo.npz": "492fcc96fab6011695534d98da541c9b046d81076882e51060b6e4c934f32330", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0300000-test_oo.npz": "606b09064520dc28ca0f5ad1f5de23ce0b5fd4de69ed7a63fbc4c3ab20e37376", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0500000-test_oo.npz": "7205738fa226f7cd4d4c3805c1f79f49553867c73a176dd5b83e08af39294c70", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-0700000-test_oo.npz": "d81f167040fb988813ab68691de03cee5c9dcb26c40c9c070c0f41007bc77cbd", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-1000000-test_oo.npz": "af428d27a5bc0b856f49645e779a40b0636c1d0f014e8dbcba5e778d8c8e870e", + "results/grokking-reproduction-v1/development/standard8-phi7.2-wd0.3/predictions-1500000-test_oo.npz": "cc9f6258133f83436a639e33d292c0086c091e1673e61bc63f1892d36e831aad", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/run.json": "f8fd280022b2d40edc717a7c908da922c5f4e75b24b24ae87f8bcea4e68ffaca", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/learning.json": "8e045439cc66d0aad1cf20a3fc633117bcb095dacc929b43c514217cb36d1f98", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/endpoint-predictions.json": "b398a209a41b70eca35f49127131ee5e0204f1b06205e9c6cf5e19f9dfc92c26", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1/endpoint.json": "96f329a5597797d5f70621138c7b46c0a346e38cdbd63d52875151969bb3a966", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/run.json": "c185f8a370caa84baf8a5ffff8c830d70ed18a8788dbfb0c39b3fccfb5d7a144", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/learning.json": "c07a77df26c6e4e9f8e3a6e229b5d8c8af7ea31e93ed984a9a9c4e521734a48d", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/endpoint-predictions.json": "6f19e925d39316f7cda5ae461047c48a881a57cb25afae2c660d248fb9766a58", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2/endpoint.json": "93a5cee6e0f93a88ace0c6520af2e5a5a4a3542e7da91c4cbad1cc67d50b5f4c", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/run.json": "92acf8f03ed1e6bdb5699f248e6aef03c40596f9f817acff255b59fbf789f555", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/learning.json": "10af8613533149838027e0d64bda4d46364b0d0e1f5851fd58857425c7d4db01", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/endpoint-predictions.json": "e37fddfe344ceb3324ce1807b3d459eaee5d089445ab644a0d738ce11bb3cb59", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init3/endpoint.json": "bba44c72fc8a16ff140c92a70e9c74b599e5e5d941cd346e0979d2e472c0adf7", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/run.json": "e1d0f26e708cdb11884f3a73c9c5770f91dedb0f87590b7957f9d771f37b18f6", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/learning.json": "934bfe84758d069ed9b6140eb6b93767e4eac81e12e88baeb5ed6fa7f5709894", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/endpoint-predictions.json": "cbfabe574fa68fbef5ee1ce8636dda07f2c4dc05601262479d24dec38e868652", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init1/endpoint.json": "d2a2b1d4dea5f0f44975c60f659c98d120b8e16da8d101f34aab91d4f049ff52", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/run.json": "c14c6ffa44556abc2075d732f67f1a7ff64b41b47da3c794f3122ea277619c66", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/learning.json": "010486fd17963c46ac8493d1ac2a19ae437f33bf56540cadb6e18907996ba540", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/endpoint-predictions.json": "7b5c9bbc21b9c2adc1b9d1d3228354a0333ba9a3918abc9b74e2c17362b59b42", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init2/endpoint.json": "a439df47ed9a0f515f29795c234402cde7adf4f595e8462a40e8848aa4ae78c0", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/run.json": "d44315713c460614d377c9d66fb964eefc412d59bcfb03bdec9e8cc5fddb664f", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/learning.json": "d8193f28e73a49d319d3539cd6bc89e604c0a48f6ef796dd4a0c49dfd95039bc", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/endpoint-predictions.json": "4c43f61d01bfc684bc3b9af49bb15ec45819a93fd1e13b8f266f0e92826ccf25", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard4-init3/endpoint.json": "88a07f66aae6e15ba2c30ebe5c9475193189a448b99d00a0ebaf6add09c9f17e", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/run.json": "c20f15d7ea290881e114e8f24f3d53798c79d1ee14a9c1d6fa72062c1bc74c7c", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/learning.json": "b0b2b1c401b896518324fa16227a1cc2072b894ca48b1569f0108b2304baa81a", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/endpoint-predictions.json": "827ae62858fcddf436b24eb331f308304c957b7c04cf4429dd9a30882a96695b", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init1/endpoint.json": "52b08c70b82458de76fcb3b5c94b3f7b1c1e8e5570d0e253a39a8cc1cd00cb84", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/run.json": "cd4df24357259f187c4212bfd21e55f16336dfc8182c94b21937b6940e6093ea", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/learning.json": "86b41da13c8fe6438b8a12b2645fd5b2f13051a74f5c7caab35ebc61c6a52627", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/endpoint-predictions.json": "dd2a4fca6ddb6f4a2b5763f194b1fbd8e7f40003ec4593e98e23feb2c8c45425", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init2/endpoint.json": "19ebb12cce35e9ee26ba7069cdd0eb59cbeda72cd94166c4a22f3a1498730642", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/run.json": "bf45cdb24a989a287f48d5d2dd40435f02756187095b6eccfd2a1e0dcbafcc36", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/learning.json": "28d1a7641e0323dbcfeaaa47cb0d78c62b7473d8c576d654b25b4038b7c93baa", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/endpoint-predictions.json": "f8ddfcafc4296554d803f6078de3472e3a4f7c31f702004ba28c15c6aae26493", + "results/realworld-composition-confirmation-v1/confirmation/confirmation-standard8-init3/endpoint.json": "b590152f4206e2c2106c369781907795d1114ef4061526d8a43c0b19c575f4cd" + } +} diff --git a/docs/development-artifacts/oo-budget-attribution-20261005/summary.json b/docs/development-artifacts/oo-budget-attribution-20261005/summary.json new file mode 100644 index 0000000000000000000000000000000000000000..2360fe27148f2b3d3de048f24a458bee918d6ef4 --- /dev/null +++ b/docs/development-artifacts/oo-budget-attribution-20261005/summary.json @@ -0,0 +1,205 @@ +{ + "analysis": "retrospective_read_only_recount", + "same_300k_updates": [ + { + "dataset": "synthetic", + "run": "loop4x2-phi12.6-wd0.1", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "phi": 12.6, + "step": 300000, + "oo_n": 2004, + "oo_percent": 4.191616766467066, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.314970107605267, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153491440, + "atomic_epochs": 295.857875, + "composition_epochs": 295.85865705931496 + }, + { + "dataset": "synthetic", + "run": "loop4x2-phi3.6-wd0.1", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "phi": 3.6, + "step": 300000, + "oo_n": 2004, + "oo_percent": 0.5988023952095809, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.2975357177926021, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153294816, + "atomic_epochs": 867.052825, + "composition_epochs": 867.0519225146198 + }, + { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.1", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "phi": 7.2, + "step": 300000, + "oo_n": 2004, + "oo_percent": 3.493013972055888, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.2955957310543291, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153474816, + "atomic_epochs": 489.39375, + "composition_epochs": 489.39717105263156 + }, + { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 300000, + "oo_n": 2004, + "oo_percent": 24.451097804391217, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.3134469647612423, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153474816, + "atomic_epochs": 489.39375, + "composition_epochs": 489.39717105263156 + }, + { + "dataset": "synthetic", + "run": "standard8-phi12.6-wd0.1", + "architecture": "standard8", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "phi": 12.6, + "step": 300000, + "oo_n": 2004, + "oo_percent": 0.09980039920159679, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.354255857601141, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153491440, + "atomic_epochs": 295.857875, + "composition_epochs": 295.85865705931496 + }, + { + "dataset": "synthetic", + "run": "standard8-phi3.6-wd0.1", + "architecture": "standard8", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "phi": 3.6, + "step": 300000, + "oo_n": 2004, + "oo_percent": 0.249500998003992, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.4251112236020467, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153294816, + "atomic_epochs": 867.052825, + "composition_epochs": 867.0519225146198 + }, + { + "dataset": "synthetic", + "run": "standard8-phi7.2-wd0.1", + "architecture": "standard8", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "phi": 7.2, + "step": 300000, + "oo_n": 2004, + "oo_percent": 0.09980039920159679, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.3470063004373676, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153474816, + "atomic_epochs": 489.39375, + "composition_epochs": 489.39717105263156 + }, + { + "dataset": "synthetic", + "run": "standard8-phi7.2-wd0.3", + "architecture": "standard8", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 300000, + "oo_n": 2004, + "oo_percent": 0.19960079840319359, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 1.3691889036560638, + "estimated_matmul_training_flops": 283182052147200000, + "executed_input_tokens": 614400000, + "examples": 153474816, + "atomic_epochs": 489.39375, + "composition_epochs": 489.39717105263156 + } + ], + "real_loop_300k_full_endpoint_mean": { + "oo_percent": 16.73161860223435, + "training_hours": 6.638698058694394, + "estimated_matmul_training_flops": 2775305955439048704, + "executed_input_tokens": 6554798306.666667, + "examples": 153249855, + "atomic_epochs": 1255.2304046406339, + "composition_epochs": 1255.2309414776405, + "n_initializations": 3, + "oo_n_each": 1283, + "oo_sample_sd": 0.6536630618555017 + }, + "synthetic_loop_wd03_1500k": { + "dataset": "synthetic", + "run": "loop4x2-phi7.2-wd0.3", + "architecture": "loop4x2", + "initialization": 791101, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "phi": 7.2, + "step": 1500000, + "oo_n": 2004, + "oo_percent": 81.3373253493014, + "evaluation_scope": "fixed_full_OO_pool", + "training_hours": 6.5032488311454655, + "estimated_matmul_training_flops": 1415910260736000000, + "executed_input_tokens": 3072000000, + "examples": 767373824, + "atomic_epochs": 2446.9826, + "composition_epochs": 2446.982894736842 + }, + "real_300k_over_synthetic_1500k": { + "training_hours": 1.020827932478953, + "estimated_matmul_training_flops": 1.9600860537562779, + "executed_input_tokens": 2.1337234071180555, + "examples": 0.1997069097316512, + "atomic_epochs": 0.5129707112100568 + }, + "limits": [ + "Same optimizer steps are not the same FLOPs, token exposure, epochs or GPU time.", + "FLOPs share a dense-matmul/attention convention, approximate backward as 2x forward, and exclude elementwise ops, optimizer, evaluation and system overhead.", + "Recorded GPU time comes from separate runs and execution implementations; it is an engineering budget, not a causal control.", + "Synthetic is one graph/initialization; real is one graph with three initializations. Neither query count nor seeds are independent worlds.", + "Real intermediate points use 64 OO queries; only real 300k uses the full 1283 pool. Synthetic uses its fixed 2004-query OO pool throughout.", + "Synthetic strict token+stop accuracy and real official-alias EM are different scoring protocols.", + "Dataset, entity representation, support, sampling, initialization, LR and WD remain confounded across historical batches.", + "Retrospective threshold/cross-budget views do not change the frozen endpoints. No interpolated accuracy or extrapolated 3M synthetic score is reported." + ] +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/amendment.md b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/amendment.md new file mode 100644 index 0000000000000000000000000000000000000000..0cc1ff71b9454fce9287a923cc0218a117b489a1 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/amendment.md @@ -0,0 +1,13 @@ +# OO优化归因：GPU 6–7并行调度修订 + +2026-10-05，用户在终止D157/OpenTinker并释放GPU 6、7后，要求把排队的LM任务优先放到这两张卡并行运行。 + +本修订将已冻结的六条优化归因运行安排到GPU 6、7，与GPU 2–5的架构主实验并行。原等待关卡用于串行复用GPU；本实验的数据、初始化和两个历史Loop基线均已存在，不使用正在运行的架构实验结果选择配置。原架构控制器、四个运行容器及其队列保持原样。 + +执行配置与原冻结配置的差异仅为GPU列表改为[6,7]、使用新的执行锁、移除等待架构批次的两个调度字段。六条运行的顺序、每条300k更新、学习率/权重衰减矩阵、数据、种子、镜像、全部冻结源码、终点与全池曲线评价、历史复用和独立审计均保持一致；新增预算为0。原冻结配置与源码不改写。 + +使用LM专属Docker context和固定镜像，每个实验独立容器、4 CPU、48 GiB内存及持久输出；W&B继续使用原批次组。新控制器取得同一批次排他锁，原等待控制器停止后才启动；仍由冻结调度器核对源码、空闲GPU及重复容器。每条训练前在独立进程执行8步CUDA预飞并核对历史初始化与step0全部预测，工程更新不进入科学训练。 + +并行运行可能影响共享CPU和I/O下的墙钟时间，资源记录需按实际GPU和运行时间解释。仅移除资源等待，不改变科学结论、样本曝光或计算预算。出现预飞、追踪或审计失败时沿用原停止追加运行规则。 + +调度配置：execution-config.json；入口：source/scripts/execute_oo_parallel.py --schedule schedule.json。新调度与现有矩阵/历史复用/训练契约共40项测试通过；静态检查通过。 diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/controller-launch.json b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/controller-launch.json new file mode 100644 index 0000000000000000000000000000000000000000..9efebdaada86db87a869250212b6aecb7f670cb2 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/controller-launch.json @@ -0,0 +1,12 @@ +{ + "pid": 337337, + "command": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/scripts/execute_oo_parallel.py", + "--schedule", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/schedule.json" + ], + "schedule": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/schedule.json", + "supersedes_pid": 345388 +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-config.json b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-config.json new file mode 100644 index 0000000000000000000000000000000000000000..61cde74de136d980e25f8aa66c6b1cd3040e94a3 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-config.json @@ -0,0 +1,360 @@ +{ + "data_file": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/confirmation-v1.json", + "data_sha256": "f9df622fe531a77aea397d9ac5e46768e175a13c9d60f8ae3b687fdb0274be27", + "tokenizer": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/tokenizer", + "model": { + "vocab_size": 50257, + "positions": 1024, + "hidden_size": 768, + "attention_heads": 12, + "dropout": 0.1, + "mlp_ratio": 4, + "sequence_limit": 256, + "generation_limit": 64 + }, + "evaluation_nodes": [ + 0, + 1000, + 2000, + 4000, + 8000, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "resume_checkpoint_interval": 5000, + "batch": "oo-optimizer-attribution-v1", + "experiment": "oo-optimizer-attribution-v1", + "phase": "runs", + "results_root": "/ossfs/workspace/llm-memory-editability/results/oo-optimizer-attribution-v1", + "gpus": [ + 6, + 7 + ], + "runtime": { + "docker_context": "lm-memory", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "python": "/opt/conda/bin/python", + "cpus": 4, + "memory": "48g" + }, + "tracking": { + "enabled": true, + "entity": "zhusq20", + "project": "llm-memory-editability", + "group": "oo-optimizer-attribution-v1", + "mode": "online" + }, + "historical_config": "/ossfs/workspace/llm-memory-editability/configs/realworld-composition-confirmation-v1.json", + "historical_config_sha256": "e07ca3d7cfe0d14d3d3f36d2a778afd1dc2a688753117aee8008a7ec324d508e", + "full_curve_nodes": [ + 0, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "scope": "Exploratory 2x2 LR/decay attribution on a previously examined real graph; two paired initializations, 300k steps each. Six new training runs and two immutable reused baselines.", + "additional_sources": [ + "scripts/execute_oo_optimizer_attribution.py", + "scripts/analyze_oo_budget_attribution.py", + "tests/test_oo_optimizer_attribution.py", + "docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md", + "configs/oo-optimizer-attribution-v1.json", + "tests/test_realworld_composition.py", + "tests/test_parametric_architecture_controller.py" + ], + "runs": [ + { + "name": "loop-lr1e4-wd03-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd01-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr5e5-wd03-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd03-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd01-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr5e5-wd03-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + } + ], + "reused_baselines": [ + { + "spec": { + "name": "confirmation-loop4x2-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + "path": "/ossfs/workspace/llm-memory-editability/results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1", + "files_sha256": { + "run.json": "f8fd280022b2d40edc717a7c908da922c5f4e75b24b24ae87f8bcea4e68ffaca", + "audit.json": "65dd2501f545ba6a5f4e29a6f5707039c04756c01a2afd8ca5a6bc7363bc5b67", + "complete.json": "302fd8420cb4e54e2d144fe51665d5e6f21f8f2f6619677f3f409857f1b10049", + "learning.json": "8e045439cc66d0aad1cf20a3fc633117bcb095dacc929b43c514217cb36d1f98", + "endpoint.json": "96f329a5597797d5f70621138c7b46c0a346e38cdbd63d52875151969bb3a966", + "endpoint-predictions.json": "b398a209a41b70eca35f49127131ee5e0204f1b06205e9c6cf5e19f9dfc92c26", + "predictions-0000000.json": "7c46eb5f120c43519b45faf46a8879669a5d253931c1a208216151ea740788af" + } + }, + { + "spec": { + "name": "confirmation-loop4x2-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + "path": "/ossfs/workspace/llm-memory-editability/results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2", + "files_sha256": { + "run.json": "c185f8a370caa84baf8a5ffff8c830d70ed18a8788dbfb0c39b3fccfb5d7a144", + "audit.json": "e5974adfa9bc5ba6e1c8cf8fd80fcefcf84d6341c218f0f12afc4a0efa697a2a", + "complete.json": "1d495b341e72191527cac14e9cfdf0cb80fafb6fe617c8d98761884f6a2d387c", + "learning.json": "c07a77df26c6e4e9f8e3a6e229b5d8c8af7ea31e93ed984a9a9c4e521734a48d", + "endpoint.json": "93a5cee6e0f93a88ace0c6520af2e5a5a4a3542e7da91c4cbad1cc67d50b5f4c", + "endpoint-predictions.json": "6f19e925d39316f7cda5ae461047c48a881a57cb25afae2c660d248fb9766a58", + "predictions-0000000.json": "1d82aa7ad1af2ccc1eb0913c461b0330ea0e2f8438823a5c552bc96fe67e7657" + } + } + ], + "baseline_curve_carriers": [ + "loop-lr1e4-wd03-init1", + "loop-lr1e4-wd03-init2" + ], + "repository": "/ossfs/workspace/llm-memory-editability", + "source_root": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source", + "frozen_utc": "2026-10-05T00:24:15.877388+00:00", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/oo-optimizer-attribution-v1.json": "cde54cc58098c3749207da3351abce5e8f8e7d0c0dc0005c3b896c12fc59d5b2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md": "03d0b8f817a6d5606f58d0b8683f5cb6e62b856b813b82c45e9d30a8f5d68304", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/analyze_oo_budget_attribution.py": "760ddc29866ecdea7943813f4a294e69a668b4463d75d30a3780b37f1938d16a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_oo_optimizer_attribution.py": "558794e36671e2c3d9c0de61531b132c911eda2796b291e28b5bd7b6a775cd84", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/run_parametric_architecture.py": "d3ea0e39702fb375342fe2b82c0abfa9d07f7e34e1efd3050c7ac2148755be8f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_oo_optimizer_attribution.py": "be7d911a62c7f70f0ed8ff07c5c4ce17bc41987e88ad75b06e33bc77b1830307", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_parametric_architecture_controller.py": "493d45cf05261840cfba728e21ba6e7a1ddd84aa7d2c60d1bcf1998d8f374648", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_realworld_composition.py": "d76487b2e3cb868c40379522ac7468e6d4037ac51fb7cdc5e9bbfda98818a7bd" + }, + "execution_lock": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-lock.json", + "git_commit": "b7b1741e5c840b68612c4eeb4fb2248ad5f2be61", + "tokenizer_sha256": { + "merges.txt": "1ce1664773c50f3e0cc8842619a93edc4624525b728b188a9e0be33b7726adc5", + "special_tokens_map.json": "8bcf4e58d0970bbcb3b111a4c1e297c082fbf61253b14b3c0c8f2972ccb61ba4", + "tokenizer.json": "a6aa29bf8416d74ad795a73262b1aa3f985564ee338adbee7ffbc5861f78b6b8", + "tokenizer_config.json": "f7cd5e1168079212fdf834ed8113826afe1384b42c39024753c09d3eac9335c0", + "vocab.json": "3ba3c3109ff33976c4bd966589c11ee14fcaa1f4c9e5e154c2ed7f99d80709e7" + } +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-lock.json b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..8c5c47bb40d0d360267e5bef55a9eaa549c5dcb9 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-lock.json @@ -0,0 +1,10 @@ +{ + "config_sha256": "28c784732267977f5280b92b81d40b31ab4eb58ff70b7eb6fc8ee12879a910d9", + "base_config_sha256": "a14506ae6216ee957729ec3e5b05757861a1991a67c53dc74ecb4005cc17cc52", + "frozen_utc": "2026-10-05T05:23:31.527065+00:00", + "environment": { + "torch": "2.6.0+cu126", + "transformers": "4.40.0" + }, + "scheduling_only": true +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/handoff.json b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/handoff.json new file mode 100644 index 0000000000000000000000000000000000000000..2e1fdd5517c963f4a6fa14c5466dccbcd13d18b9 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/handoff.json @@ -0,0 +1,54 @@ +{ + "utc": "2026-10-05T05:24:10.802509+00:00", + "old_controller": { + "pid": 345388, + "command": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_oo_optimizer_attribution.py", + "controller", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/frozen-config.json" + ] + }, + "old_state": { + "state": "waiting_for_predecessor", + "gpus": [ + 2, + 3, + 4, + 5 + ], + "completed": [], + "failed": [], + "active": {}, + "queued": [ + "loop-lr1e4-wd03-init1", + "loop-lr1e4-wd01-init1", + "loop-lr5e5-wd03-init1", + "loop-lr1e4-wd03-init2", + "loop-lr1e4-wd01-init2", + "loop-lr5e5-wd03-init2" + ], + "predecessor_completed": 6, + "predecessor_total": 15, + "updated_utc": "2026-10-05T05:23:55.653136+00:00" + }, + "existing_running_containers": { + "default": [ + "8facd57261789b718a05ead6f9e39289338f0795e79205fc5d9885441b5e8125 2026-10-05T01:47:41.119572271Z", + "e3ec77aa9e4d3dca1499d2b4e1663a763606fd1adf00b8542562a2c6136a6e6e 2026-10-05T01:46:27.406004898Z" + ], + "lm-memory": [ + "7de3805fdbaab536113fe546ade619c7ad123ba49ab0a78492f1a76522b4aea7 2026-10-05T00:14:11.573592705Z", + "d26dcad2c2c311fb59ee24febe5ff9863566995d841e38e281629c62b7474cae 2026-10-04T19:53:15.538500848Z", + "3b278b0907ad93e6d3f8358c82c8a0aa0497235642bf72eb0a5e3a38c2bc3ea8 2026-10-04T17:44:49.381429969Z", + "2b7a8055ea7c1550f70d954041f59242542045ec46e8fb92912a4e391e2dd31b 2026-10-04T16:25:21.582226094Z" + ] + }, + "old_signal": "SIGTERM", + "gpus": [ + 6, + 7 + ] +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/launch-verification.json b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/launch-verification.json new file mode 100644 index 0000000000000000000000000000000000000000..859e840707922a52d053015b26aeca770d3a8573 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/launch-verification.json @@ -0,0 +1,56 @@ +{ + "passed": true, + "utc": "2026-10-05T05:26:34.404797+00:00", + "schedule_sha256": "507d206efdb6a823b6d3ba4e815889d8574e423f03d9c1697cdc20c9c2614604", + "controller": { + "pid": 337337, + "command": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/scripts/execute_oo_parallel.py", + "--schedule", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/schedule.json" + ], + "schedule": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/schedule.json", + "supersedes_pid": 345388 + }, + "old_waiting_controller_exited": true, + "other_containers_and_start_times_unchanged": true, + "frozen_files_unchanged": true, + "runs": [ + { + "name": "loop-lr1e4-wd03-init1", + "physical_gpu": 6, + "step": 1000, + "cuda_preflight_passed": true, + "historical_step_zero_exact_replay": true, + "container_id": "3dd59509d033abf8833b02e2131b382f319fc17a1e763dfc6b18649a7cd7318e" + }, + { + "name": "loop-lr1e4-wd01-init1", + "physical_gpu": 7, + "step": 1000, + "cuda_preflight_passed": true, + "historical_step_zero_exact_replay": true, + "container_id": "9c0d0acbc5d1e8795767fe68b0d5ac5d803bcaab60aaa7bf598a7dcabf30462a" + } + ], + "queued": [ + "loop-lr5e5-wd03-init1", + "loop-lr1e4-wd03-init2", + "loop-lr1e4-wd01-init2", + "loop-lr5e5-wd03-init2" + ], + "tracking_process": 337405, + "wandb_runs": [ + { + "run": "loop-lr1e4-wd01-init1", + "url": "https://wandb.ai/zhusq20/llm-memory-editability/runs/24bb2d4e026ccf48" + }, + { + "run": "loop-lr1e4-wd03-init1", + "url": "https://wandb.ai/zhusq20/llm-memory-editability/runs/00dbbc0c2c98ad14" + } + ], + "tests": "40 passed; targeted ruff check and format passed" +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/prelaunch-input-verification.json b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/prelaunch-input-verification.json new file mode 100644 index 0000000000000000000000000000000000000000..4bf68151a4bef797db79e0e7201632fb556d7c26 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/prelaunch-input-verification.json @@ -0,0 +1,16 @@ +{ + "passed": true, + "utc": "2026-10-05T05:23:32.793823+00:00", + "trainer_dependency_sha256": { + "src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be" + }, + "baseline_initializations": [ + 811201, + 811202 + ], + "limits": "Source/data/tokenizer compatibility; GPU calibration is still required." +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/schedule.json b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/schedule.json new file mode 100644 index 0000000000000000000000000000000000000000..4d07325a7d5421f20656ff8f0fb3acdf0d29e178 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/schedule.json @@ -0,0 +1,15 @@ +{ + "base_config": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/frozen-config.json", + "execution_config": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-config.json", + "predecessor_barrier": "waived_for_disjoint_gpus_by_user", + "authorization": "用户要求排队的LM Memory Editability任务在新释放的GPU6、7优先并行运行", + "files_sha256": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/frozen-config.json": "a14506ae6216ee957729ec3e5b05757861a1991a67c53dc74ecb4005cc17cc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/execution-lock.json": "591c379968685ef5f633795969c182adbc413a2db4a9922e2e89817e10932364", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-config.json": "28c784732267977f5280b92b81d40b31ab4eb58ff70b7eb6fc8ee12879a910d9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-lock.json": "055a3680590375ae6b4365ab70a427f9cdf45eff0da794070dc08b914a80b38d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/scripts/execute_oo_parallel.py": "c1dbd4f150c484c4348dadf69f3993bd33c540bfdfe7d49976df033f29c4aa4e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/tests/test_oo_parallel.py": "f66d4f1d2f7129c41f879af80a5fbc35e01e4d9e8877bada177334600d918704", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/amendment.md": "569c2f04296228772b2380de1adfcb74a74e42feddea1801fd69006012c22fc5" + } +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/scripts/execute_oo_parallel.py b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/scripts/execute_oo_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..50f22a297e8a4d54eb453c8716f2878193c86454 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/scripts/execute_oo_parallel.py @@ -0,0 +1,108 @@ +"""Run the frozen optimizer attribution on separately authorized GPU slots.""" + +from __future__ import annotations + +import argparse +import copy +import fcntl +import hashlib +import importlib.util +import json +import sys +import traceback +from pathlib import Path + + +def read(path): + return json.loads(Path(path).read_text()) + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def validate_override(base, execution, architecture): + """Permit only the authorized resource change, retaining the entire experiment.""" + assert base["batch"] == "oo-optimizer-attribution-v1" + assert base["phase"] == "runs" and base["gpus"] == [2, 3, 4, 5] + assert execution["gpus"] == [6, 7] + assert execution["execution_lock"] != base["execution_lock"] + expected = copy.deepcopy(base) + expected.update(gpus=[6, 7], execution_lock=execution["execution_lock"]) + expected.pop("wait_for_results_root") + expected.pop("wait_for_runs") + assert execution == expected, "Scheduling amendment changed the scientific configuration" + assert execution["runtime"]["docker_context"] == "lm-memory" + assert not set(execution["gpus"]) & set(architecture["gpus"]) + predecessor = Path(base["wait_for_results_root"]).resolve() + for baseline in execution["reused_baselines"]: + assert not Path(baseline["path"]).resolve().is_relative_to(predecessor) + + +def load_frozen_controller(base): + scripts = Path(base["source_root"]) / "scripts" + sys.path.insert(0, str(scripts)) + spec = importlib.util.spec_from_file_location( + "frozen_oo_controller", scripts / "execute_oo_optimizer_attribution.py" + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + assert ( + Path(module.scheduler.__file__).resolve() + == (scripts / "execute_parametric_architecture.py").resolve() + ) + return module + + +def run(schedule_path): + schedule = read(schedule_path) + assert schedule["predecessor_barrier"] == "waived_for_disjoint_gpus_by_user" + for path, expected in schedule["files_sha256"].items(): + assert digest(path) == expected, f"Scheduling artifact changed: {path}" + assert str(Path(__file__).resolve()) in schedule["files_sha256"] + base_path = Path(schedule["base_config"]) + base = read(base_path) + assert digest(base_path) == read(base["execution_lock"])["config_sha256"] + execution_path = Path(schedule["execution_config"]) + execution = read(execution_path) + architecture = read(Path(base["wait_for_results_root"]) / "frozen-config.json") + validate_override(base, execution, architecture) + controller = load_frozen_controller(base) + root = Path(execution["results_root"]) + with (root / "controller.lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + try: + controller.write( + root / "schedule-amendment.json", + { + "schedule": str(Path(schedule_path).resolve()), + "schedule_sha256": digest(schedule_path), + "base_config_sha256": digest(base_path), + "execution_config_sha256": digest(execution_path), + "gpus": execution["gpus"], + "predecessor_barrier": schedule["predecessor_barrier"], + "utc": controller.now(), + }, + ) + # The original validator still checks all six runs and both old baselines. + evidence = controller.verify_inputs(base, Path(base["source_root"])) + controller.write(root / "parallel-input-verification.json", evidence) + controller.scheduler.control_locked( + execution, execution_path, root, command_builder=controller.container_command + ) + if read(root / "controller-state.json")["state"] == "complete": + controller.report(execution) + except BaseException: + state_path = root / "controller-state.json" + state = read(state_path) if state_path.exists() else {} + state.update( + state="controller_error", error=traceback.format_exc(), updated_utc=controller.now() + ) + controller.write(state_path, state) + raise + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--schedule", required=True, type=Path) + run(parser.parse_args().schedule.resolve()) diff --git a/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/tests/test_oo_parallel.py b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/tests/test_oo_parallel.py new file mode 100644 index 0000000000000000000000000000000000000000..5a7ee33a03831c3fec70d18e237ca7cf91eb922d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-parallel-20261005/source/tests/test_oo_parallel.py @@ -0,0 +1,60 @@ +"""A scheduling amendment cannot change treatments or overlap the running batch.""" + +import copy +import importlib.util +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parents[1] +SPEC = importlib.util.spec_from_file_location( + "oo_parallel", ROOT / "scripts/execute_oo_parallel.py" +) +module = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(module) + + +def configs(): + base = module.read(ROOT / "configs/oo-optimizer-attribution-v1.json") + base["execution_lock"] = "original-lock.json" + execution = copy.deepcopy(base) + execution.update(gpus=[6, 7], execution_lock="parallel-lock.json") + execution.pop("wait_for_results_root") + execution.pop("wait_for_runs") + return base, execution, {"gpus": [2, 3, 4, 5]} + + +def test_resource_change_preserves_full_matrix_and_order(): + base, execution, architecture = configs() + module.validate_override(base, execution, architecture) + assert execution["runs"] == base["runs"] + assert sum(s["steps"] for s in execution["runs"]) == 1_800_000 + + +@pytest.mark.parametrize("change", ["budget", "seed", "missing_arm", "image", "data", "gpu"]) +def test_reject_scientific_or_unapproved_resource_changes(change): + base, execution, architecture = configs() + if change == "budget": + execution["runs"][0]["steps"] += 1 + elif change == "seed": + execution["runs"][0]["sampling_seed"] += 1 + elif change == "missing_arm": + execution["runs"].pop() + elif change == "image": + execution["runtime"]["image"] = "different-image" + elif change == "data": + execution["data_file"] = "other.json" + elif change == "gpu": + execution["gpus"] = [5, 6] + with pytest.raises(AssertionError): + module.validate_override(base, execution, architecture) + + +def test_reject_gpu_overlap_and_real_predecessor_dependency(): + base, execution, architecture = configs() + with pytest.raises(AssertionError): + module.validate_override(base, execution, {"gpus": [2, 3, 4, 5, 6]}) + base["reused_baselines"][0]["path"] = base["wait_for_results_root"] + "/runs/live" + execution["reused_baselines"] = copy.deepcopy(base["reused_baselines"]) + with pytest.raises(AssertionError): + module.validate_override(base, execution, architecture) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/cpu-preflight.json b/docs/development-artifacts/oo-optimizer-attribution-v1/cpu-preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..0b3c7beea380f1b6f6d84b9a1dff376563428d13 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/cpu-preflight.json @@ -0,0 +1,20 @@ +{ + "passed": true, + "torch": "2.6.0+cu126", + "transformers": "4.40.0", + "checks": [ + { + "initialization": 811201, + "initial_sha256": "c5396f2844cc38df75ee3ef3aa743378abfd007634d21031af6bfbd272fc9645", + "parameters": 67736832, + "finite_cpu_forward": true + }, + { + "initialization": 811202, + "initial_sha256": "87384ad1ddad7c1bbf44329f0d3eefd415cba3ccac580b6b5aa3fe14d02b3573", + "parameters": 67736832, + "finite_cpu_forward": true + } + ], + "gpu_checks": "Deferred until assigned GPU is free; mandatory before each training run." +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/execution-lock.json b/docs/development-artifacts/oo-optimizer-attribution-v1/execution-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..dbc47350a31a5e3c7109b0ba047cdc11693fc5fa --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/execution-lock.json @@ -0,0 +1,8 @@ +{ + "config_sha256": "a14506ae6216ee957729ec3e5b05757861a1991a67c53dc74ecb4005cc17cc52", + "frozen_utc": "2026-10-05T00:24:22.892014+00:00", + "environment": { + "torch": "2.6.0+cu126", + "transformers": "4.40.0" + } +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/frozen-config.json b/docs/development-artifacts/oo-optimizer-attribution-v1/frozen-config.json new file mode 100644 index 0000000000000000000000000000000000000000..550b7b6252d61d5ba6a7d6d91f9ee71698344f1d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/frozen-config.json @@ -0,0 +1,380 @@ +{ + "data_file": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/confirmation-v1.json", + "data_sha256": "f9df622fe531a77aea397d9ac5e46768e175a13c9d60f8ae3b687fdb0274be27", + "tokenizer": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/tokenizer", + "model": { + "vocab_size": 50257, + "positions": 1024, + "hidden_size": 768, + "attention_heads": 12, + "dropout": 0.1, + "mlp_ratio": 4, + "sequence_limit": 256, + "generation_limit": 64 + }, + "evaluation_nodes": [ + 0, + 1000, + 2000, + 4000, + 8000, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "resume_checkpoint_interval": 5000, + "batch": "oo-optimizer-attribution-v1", + "experiment": "oo-optimizer-attribution-v1", + "phase": "runs", + "results_root": "/ossfs/workspace/llm-memory-editability/results/oo-optimizer-attribution-v1", + "gpus": [ + 2, + 3, + 4, + 5 + ], + "runtime": { + "docker_context": "lm-memory", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "python": "/opt/conda/bin/python", + "cpus": 4, + "memory": "48g" + }, + "tracking": { + "enabled": true, + "entity": "zhusq20", + "project": "llm-memory-editability", + "group": "oo-optimizer-attribution-v1", + "mode": "online" + }, + "historical_config": "/ossfs/workspace/llm-memory-editability/configs/realworld-composition-confirmation-v1.json", + "historical_config_sha256": "e07ca3d7cfe0d14d3d3f36d2a778afd1dc2a688753117aee8008a7ec324d508e", + "wait_for_results_root": "/ossfs/workspace/llm-memory-editability/results/parametric-architecture-main-v1", + "wait_for_runs": [ + "m8-init1", + "w8-init1", + "ihc8-init1", + "hc8-init1", + "d8-init1", + "m8-init2", + "w8-init2", + "ihc8-init2", + "hc8-init2", + "d8-init2", + "m8-init3", + "w8-init3", + "ihc8-init3", + "hc8-init3", + "d8-init3" + ], + "full_curve_nodes": [ + 0, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "scope": "Exploratory 2x2 LR/decay attribution on a previously examined real graph; two paired initializations, 300k steps each. Six new training runs and two immutable reused baselines.", + "additional_sources": [ + "scripts/execute_oo_optimizer_attribution.py", + "scripts/analyze_oo_budget_attribution.py", + "tests/test_oo_optimizer_attribution.py", + "docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md", + "configs/oo-optimizer-attribution-v1.json", + "tests/test_realworld_composition.py", + "tests/test_parametric_architecture_controller.py" + ], + "runs": [ + { + "name": "loop-lr1e4-wd03-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd01-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr5e5-wd03-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd03-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd01-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr5e5-wd03-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + } + ], + "reused_baselines": [ + { + "spec": { + "name": "confirmation-loop4x2-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + "path": "/ossfs/workspace/llm-memory-editability/results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1", + "files_sha256": { + "run.json": "f8fd280022b2d40edc717a7c908da922c5f4e75b24b24ae87f8bcea4e68ffaca", + "audit.json": "65dd2501f545ba6a5f4e29a6f5707039c04756c01a2afd8ca5a6bc7363bc5b67", + "complete.json": "302fd8420cb4e54e2d144fe51665d5e6f21f8f2f6619677f3f409857f1b10049", + "learning.json": "8e045439cc66d0aad1cf20a3fc633117bcb095dacc929b43c514217cb36d1f98", + "endpoint.json": "96f329a5597797d5f70621138c7b46c0a346e38cdbd63d52875151969bb3a966", + "endpoint-predictions.json": "b398a209a41b70eca35f49127131ee5e0204f1b06205e9c6cf5e19f9dfc92c26", + "predictions-0000000.json": "7c46eb5f120c43519b45faf46a8879669a5d253931c1a208216151ea740788af" + } + }, + { + "spec": { + "name": "confirmation-loop4x2-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + "path": "/ossfs/workspace/llm-memory-editability/results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2", + "files_sha256": { + "run.json": "c185f8a370caa84baf8a5ffff8c830d70ed18a8788dbfb0c39b3fccfb5d7a144", + "audit.json": "e5974adfa9bc5ba6e1c8cf8fd80fcefcf84d6341c218f0f12afc4a0efa697a2a", + "complete.json": "1d495b341e72191527cac14e9cfdf0cb80fafb6fe617c8d98761884f6a2d387c", + "learning.json": "c07a77df26c6e4e9f8e3a6e229b5d8c8af7ea31e93ed984a9a9c4e521734a48d", + "endpoint.json": "93a5cee6e0f93a88ace0c6520af2e5a5a4a3542e7da91c4cbad1cc67d50b5f4c", + "endpoint-predictions.json": "6f19e925d39316f7cda5ae461047c48a881a57cb25afae2c660d248fb9766a58", + "predictions-0000000.json": "1d82aa7ad1af2ccc1eb0913c461b0330ea0e2f8438823a5c552bc96fe67e7657" + } + } + ], + "baseline_curve_carriers": [ + "loop-lr1e4-wd03-init1", + "loop-lr1e4-wd03-init2" + ], + "repository": "/ossfs/workspace/llm-memory-editability", + "source_root": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source", + "frozen_utc": "2026-10-05T00:24:15.877388+00:00", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/oo-optimizer-attribution-v1.json": "cde54cc58098c3749207da3351abce5e8f8e7d0c0dc0005c3b896c12fc59d5b2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md": "03d0b8f817a6d5606f58d0b8683f5cb6e62b856b813b82c45e9d30a8f5d68304", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/analyze_oo_budget_attribution.py": "760ddc29866ecdea7943813f4a294e69a668b4463d75d30a3780b37f1938d16a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_oo_optimizer_attribution.py": "558794e36671e2c3d9c0de61531b132c911eda2796b291e28b5bd7b6a775cd84", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/run_parametric_architecture.py": "d3ea0e39702fb375342fe2b82c0abfa9d07f7e34e1efd3050c7ac2148755be8f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_oo_optimizer_attribution.py": "be7d911a62c7f70f0ed8ff07c5c4ce17bc41987e88ad75b06e33bc77b1830307", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_parametric_architecture_controller.py": "493d45cf05261840cfba728e21ba6e7a1ddd84aa7d2c60d1bcf1998d8f374648", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_realworld_composition.py": "d76487b2e3cb868c40379522ac7468e6d4037ac51fb7cdc5e9bbfda98818a7bd" + }, + "execution_lock": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/execution-lock.json", + "git_commit": "b7b1741e5c840b68612c4eeb4fb2248ad5f2be61", + "tokenizer_sha256": { + "merges.txt": "1ce1664773c50f3e0cc8842619a93edc4624525b728b188a9e0be33b7726adc5", + "special_tokens_map.json": "8bcf4e58d0970bbcb3b111a4c1e297c082fbf61253b14b3c0c8f2972ccb61ba4", + "tokenizer.json": "a6aa29bf8416d74ad795a73262b1aa3f985564ee338adbee7ffbc5861f78b6b8", + "tokenizer_config.json": "f7cd5e1168079212fdf834ed8113826afe1384b42c39024753c09d3eac9335c0", + "vocab.json": "3ba3c3109ff33976c4bd966589c11ee14fcaa1f4c9e5e154c2ed7f99d80709e7" + } +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md b/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md new file mode 100644 index 0000000000000000000000000000000000000000..6bf5cbd45e0455c672621c6f3af35b3f2b861e04 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md @@ -0,0 +1,40 @@ +# 真实图 OO：固定预算的优化配置归因 + +2026-10-05。用户要求先核对合成数据在相同预算下的OO，再以归因实验解释与真实图的差别，并确认继续使用GPU2–5。本轮固定一个问题：**在数据、模型、样本流、监督和更新预算一致时，学习率与weight decay的变化能解释多少真实图OO差距？** 这是对已观察真实图的探索性归因，不重新包装成未见世界上的确认研究。 + +## 已有证据与方法来源 + +原论文[Grokked Transformers are Implicit Reasoners](https://arxiv.org/html/2405.15071v3)的方法及附录C/E区分关系图、组合覆盖、实体词元化和共享计算；weight decay影响泛化学习时间，不能把旧合成与真实图的差异全部称为数据效应。本轮复用已审计的模型和训练实现，不增加架构、世界或规模网格。 + +[历史预算复算](../oo-budget-attribution-20261005/summary.json)与[原始预测审计](../oo-budget-attribution-20261005/recount-audit.json)覆盖81个预测池。合成φ7.2/Loop在300k步、lr=1e-4时，wd=.1/.3的严格OO分别3.49%/24.45%；真实图Loop在300k、lr=5e-5/wd=.1时为16.73%（三个初始化）。旧合成最高81.34%来自1500k，不是300k。 + +但旧合成1500k的训练段为6.50 GPU小时，真实300k均值6.64小时，均为L20X；真实输入执行词元约为前者2.13倍，按一致乘法计数口径估计的训练FLOPs约1.96倍。合成使用CUDA graphs，真实使用动态序列；两者GPU时间不是受控因果比较。更新数、事实曝光与实际资源必须分开报告，不能简单以延长墙钟解释失败，也不能将所有词元都解释成等量知识曝光。 + +## 冻结矩阵 + +| 学习率 | weight decay | init1 / init2 | 用途 | +| --- | --- | --- | --- | +| 5e-5 | 0.1 | 复用 / 复用 | 原真实图基线 | +| 1e-4 | 0.1 | 新训 / 新训 | 只改变学习率 | +| 5e-5 | 0.3 | 新训 / 新训 | 只改变weight decay | +| 1e-4 | 0.3 | 新训 / 新训 | 旧合成最高分的两项优化设置及交互 | + +每格300,000更新、batch/microbatch均512、warmup2000后恒定学习率。固定Loop4×2、d768、12头、dropout=.1、GPT-2词表和原答案/EOS监督。初始化811201/811202，采样812201/812202，dropout813201/813202；同初始化四格逐例样本流相同。总8条轨迹，**新增6条、1,800,000更新**；另有两条旧基线的只读全池曲线补评。粗估新增训练段约40 GPU小时，评估、审计和I/O时间另记，不能据此承诺墙钟完成时间。 + +复用保留旧配置、原始预测和审计不变。执行前核对完整本地训练依赖闭包、模型、tokenizer、数据、种子、预算与评分；每个新容器在独立子进程核对历史初始化哈希、step0逐项预测/NLL，并实际进行8次有限值CUDA训练更新。这些工程更新不进入正式权重、优化器、RNG或曝光计数。若核验失败，保留失败并停止追加任务，不自动修改参数或换基线。归因矩阵不按OO选超参或淘汰格点。 + +## 评价与解释 + +主终点为300k完整1283道OO的官方别名EM；并列规范答案EM、II/IO/OI、全部组合、单跳原子、训练组合、自主两次单跳。保留全部生成，结束后独立进程重载并要求完整预测及分数一致。主比较按初始化配对报告：两档wd下的LR效应、两档LR下的wd效应、交互，以及联合设置相对原基线的差；报告每个初始化，不把两个种子当两个世界。 + +训练保留原11个固定面板节点，OO面板仅64题。另在0/16k/32k/64k/128k/200k/300k检查点，按原全组合池顺序补评全部3729题（其中OO1283），两条旧基线同样补评；评价在训练结束后的独立进程进行，不改变训练随机流。全池300k补评必须逐项复现原终点。不会把64题面板跳动描述为全池grokking。是否出现延迟泛化，应并列训练拟合与完整OO曲线；单个终点上涨不是grokking，300k未出现也不证明任意更长预算都不会出现。 + +固定更新是本轮主比较。因同模型、数据和配对样本流，逐节点核对全部曝光，终点核对有效/执行/监督词元与估算训练FLOPs完全相等；实际GPU小时作为实现性能附报，不预设相等。历史跨数据比较保留已存预算上下节点与间隙，不插值准确率，不外推合成3M结果。 + +若联合配置改善且单因素/交互方向一致，支持优化方案是该图有限预算OO的原因之一；不证明是合成与真实全部差距的唯一原因。若没有改善或损害事实拟合，保留负结果，优先结合已完成的实体编码和地址分配控制，下一轮再单独改变表示或组合覆盖。当前不自动追加1500k长跑、不铺开表示×结构×优化的全矩阵。 + +## 调度与记录 + +等`parametric-architecture-main-v1`全部15条完成并审计、GPU2–5空闲后自动开始；不改写或停止旧队列。专属`docker --context lm-memory`，固定镜像，每条训练独立容器、4 CPU/48 GiB内存和独立临时目录；主机输出持久化到本批`results/`。W&B随正式队列启动，entity `zhusq20`、project `llm-memory-editability`。等待阶段不声称训练已开始。 + +源码与配置封存在本目录`source/`及`frozen-config.json`，使用`execution-lock.json`核验。启动命令为主机设置`LD_LIBRARY_PATH=/lib64...`后运行`python scripts/execute_oo_optimizer_attribution.py freeze --config configs/oo-optimizer-attribution-v1.json`，然后对生成的冻结配置执行`launch`。实时状态在`results/oo-optimizer-attribution-v1/controller-state.json`，完成后自动写配对结果`report.json`。 diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/reuse-verification.json b/docs/development-artifacts/oo-optimizer-attribution-v1/reuse-verification.json new file mode 100644 index 0000000000000000000000000000000000000000..97f12c3d087dd08046d986c227350adaee205709 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/reuse-verification.json @@ -0,0 +1,16 @@ +{ + "passed": true, + "utc": "2026-10-05T00:24:15.865696+00:00", + "trainer_dependency_sha256": { + "src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be" + }, + "baseline_initializations": [ + 811201, + 811202 + ], + "limits": "Source/data/tokenizer compatibility; GPU calibration is still required." +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/experiment-tracking-defaults.json b/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/experiment-tracking-defaults.json new file mode 100644 index 0000000000000000000000000000000000000000..92273f717dfdee8e79a02a1a3fd47f874f8435f8 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/experiment-tracking-defaults.json @@ -0,0 +1,11 @@ +{ + "enabled": true, + "provider": "wandb", + "sdk_version": "0.30.0", + "entity": "zhusq20", + "project": "llm-memory-editability", + "mode": "online", + "poll_seconds": 15, + "system_metrics": true, + "scope": "Future experiment batches; do not attach to existing frozen runs without a request" +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/oo-optimizer-attribution-v1.json b/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/oo-optimizer-attribution-v1.json new file mode 100644 index 0000000000000000000000000000000000000000..b90d0d1159d770deb97c0ffc8032db7434f059a2 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/configs/oo-optimizer-attribution-v1.json @@ -0,0 +1,244 @@ +{ + "data_file": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/confirmation-v1.json", + "data_sha256": "f9df622fe531a77aea397d9ac5e46768e175a13c9d60f8ae3b687fdb0274be27", + "tokenizer": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/tokenizer", + "model": { + "vocab_size": 50257, + "positions": 1024, + "hidden_size": 768, + "attention_heads": 12, + "dropout": 0.1, + "mlp_ratio": 4, + "sequence_limit": 256, + "generation_limit": 64 + }, + "evaluation_nodes": [ + 0, + 1000, + 2000, + 4000, + 8000, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "resume_checkpoint_interval": 5000, + "batch": "oo-optimizer-attribution-v1", + "experiment": "oo-optimizer-attribution-v1", + "phase": "runs", + "results_root": "/ossfs/workspace/llm-memory-editability/results/oo-optimizer-attribution-v1", + "gpus": [ + 2, + 3, + 4, + 5 + ], + "runtime": { + "docker_context": "lm-memory", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "python": "/opt/conda/bin/python", + "cpus": 4, + "memory": "48g" + }, + "tracking": { + "enabled": true, + "entity": "zhusq20", + "project": "llm-memory-editability", + "group": "oo-optimizer-attribution-v1", + "mode": "online" + }, + "historical_config": "/ossfs/workspace/llm-memory-editability/configs/realworld-composition-confirmation-v1.json", + "historical_config_sha256": "e07ca3d7cfe0d14d3d3f36d2a778afd1dc2a688753117aee8008a7ec324d508e", + "wait_for_results_root": "/ossfs/workspace/llm-memory-editability/results/parametric-architecture-main-v1", + "wait_for_runs": [ + "m8-init1", + "w8-init1", + "ihc8-init1", + "hc8-init1", + "d8-init1", + "m8-init2", + "w8-init2", + "ihc8-init2", + "hc8-init2", + "d8-init2", + "m8-init3", + "w8-init3", + "ihc8-init3", + "hc8-init3", + "d8-init3" + ], + "full_curve_nodes": [ + 0, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "scope": "Exploratory 2x2 LR/decay attribution on a previously examined real graph; two paired initializations, 300k steps each. Six new training runs and two immutable reused baselines.", + "additional_sources": [ + "scripts/execute_oo_optimizer_attribution.py", + "scripts/analyze_oo_budget_attribution.py", + "tests/test_oo_optimizer_attribution.py", + "docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md", + "configs/oo-optimizer-attribution-v1.json", + "tests/test_realworld_composition.py", + "tests/test_parametric_architecture_controller.py" + ], + "runs": [ + { + "name": "loop-lr1e4-wd03-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd01-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr5e5-wd03-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd03-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr1e4-wd01-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + { + "name": "loop-lr5e5-wd03-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.3, + "warmup_steps": 2000, + "architecture": "loop4x2" + } + ], + "reused_baselines": [ + { + "spec": { + "name": "confirmation-loop4x2-init1", + "unique_layers": 4, + "repeats": 2, + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + "path": "/ossfs/workspace/llm-memory-editability/results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init1", + "files_sha256": { + "run.json": "f8fd280022b2d40edc717a7c908da922c5f4e75b24b24ae87f8bcea4e68ffaca", + "audit.json": "65dd2501f545ba6a5f4e29a6f5707039c04756c01a2afd8ca5a6bc7363bc5b67", + "complete.json": "302fd8420cb4e54e2d144fe51665d5e6f21f8f2f6619677f3f409857f1b10049", + "learning.json": "8e045439cc66d0aad1cf20a3fc633117bcb095dacc929b43c514217cb36d1f98", + "endpoint.json": "96f329a5597797d5f70621138c7b46c0a346e38cdbd63d52875151969bb3a966", + "endpoint-predictions.json": "b398a209a41b70eca35f49127131ee5e0204f1b06205e9c6cf5e19f9dfc92c26", + "predictions-0000000.json": "7c46eb5f120c43519b45faf46a8879669a5d253931c1a208216151ea740788af" + } + }, + { + "spec": { + "name": "confirmation-loop4x2-init2", + "unique_layers": 4, + "repeats": 2, + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "architecture": "loop4x2" + }, + "path": "/ossfs/workspace/llm-memory-editability/results/realworld-composition-confirmation-v1/confirmation/confirmation-loop4x2-init2", + "files_sha256": { + "run.json": "c185f8a370caa84baf8a5ffff8c830d70ed18a8788dbfb0c39b3fccfb5d7a144", + "audit.json": "e5974adfa9bc5ba6e1c8cf8fd80fcefcf84d6341c218f0f12afc4a0efa697a2a", + "complete.json": "1d495b341e72191527cac14e9cfdf0cb80fafb6fe617c8d98761884f6a2d387c", + "learning.json": "c07a77df26c6e4e9f8e3a6e229b5d8c8af7ea31e93ed984a9a9c4e521734a48d", + "endpoint.json": "93a5cee6e0f93a88ace0c6520af2e5a5a4a3542e7da91c4cbad1cc67d50b5f4c", + "endpoint-predictions.json": "6f19e925d39316f7cda5ae461047c48a881a57cb25afae2c660d248fb9766a58", + "predictions-0000000.json": "1d82aa7ad1af2ccc1eb0913c461b0330ea0e2f8438823a5c552bc96fe67e7657" + } + } + ], + "baseline_curve_carriers": [ + "loop-lr1e4-wd03-init1", + "loop-lr1e4-wd03-init2" + ] +} diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md b/docs/development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md new file mode 100644 index 0000000000000000000000000000000000000000..6bf5cbd45e0455c672621c6f3af35b3f2b861e04 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md @@ -0,0 +1,40 @@ +# 真实图 OO：固定预算的优化配置归因 + +2026-10-05。用户要求先核对合成数据在相同预算下的OO，再以归因实验解释与真实图的差别，并确认继续使用GPU2–5。本轮固定一个问题：**在数据、模型、样本流、监督和更新预算一致时，学习率与weight decay的变化能解释多少真实图OO差距？** 这是对已观察真实图的探索性归因，不重新包装成未见世界上的确认研究。 + +## 已有证据与方法来源 + +原论文[Grokked Transformers are Implicit Reasoners](https://arxiv.org/html/2405.15071v3)的方法及附录C/E区分关系图、组合覆盖、实体词元化和共享计算；weight decay影响泛化学习时间，不能把旧合成与真实图的差异全部称为数据效应。本轮复用已审计的模型和训练实现，不增加架构、世界或规模网格。 + +[历史预算复算](../oo-budget-attribution-20261005/summary.json)与[原始预测审计](../oo-budget-attribution-20261005/recount-audit.json)覆盖81个预测池。合成φ7.2/Loop在300k步、lr=1e-4时，wd=.1/.3的严格OO分别3.49%/24.45%；真实图Loop在300k、lr=5e-5/wd=.1时为16.73%（三个初始化）。旧合成最高81.34%来自1500k，不是300k。 + +但旧合成1500k的训练段为6.50 GPU小时，真实300k均值6.64小时，均为L20X；真实输入执行词元约为前者2.13倍，按一致乘法计数口径估计的训练FLOPs约1.96倍。合成使用CUDA graphs，真实使用动态序列；两者GPU时间不是受控因果比较。更新数、事实曝光与实际资源必须分开报告，不能简单以延长墙钟解释失败，也不能将所有词元都解释成等量知识曝光。 + +## 冻结矩阵 + +| 学习率 | weight decay | init1 / init2 | 用途 | +| --- | --- | --- | --- | +| 5e-5 | 0.1 | 复用 / 复用 | 原真实图基线 | +| 1e-4 | 0.1 | 新训 / 新训 | 只改变学习率 | +| 5e-5 | 0.3 | 新训 / 新训 | 只改变weight decay | +| 1e-4 | 0.3 | 新训 / 新训 | 旧合成最高分的两项优化设置及交互 | + +每格300,000更新、batch/microbatch均512、warmup2000后恒定学习率。固定Loop4×2、d768、12头、dropout=.1、GPT-2词表和原答案/EOS监督。初始化811201/811202，采样812201/812202，dropout813201/813202；同初始化四格逐例样本流相同。总8条轨迹，**新增6条、1,800,000更新**；另有两条旧基线的只读全池曲线补评。粗估新增训练段约40 GPU小时，评估、审计和I/O时间另记，不能据此承诺墙钟完成时间。 + +复用保留旧配置、原始预测和审计不变。执行前核对完整本地训练依赖闭包、模型、tokenizer、数据、种子、预算与评分；每个新容器在独立子进程核对历史初始化哈希、step0逐项预测/NLL，并实际进行8次有限值CUDA训练更新。这些工程更新不进入正式权重、优化器、RNG或曝光计数。若核验失败，保留失败并停止追加任务，不自动修改参数或换基线。归因矩阵不按OO选超参或淘汰格点。 + +## 评价与解释 + +主终点为300k完整1283道OO的官方别名EM；并列规范答案EM、II/IO/OI、全部组合、单跳原子、训练组合、自主两次单跳。保留全部生成，结束后独立进程重载并要求完整预测及分数一致。主比较按初始化配对报告：两档wd下的LR效应、两档LR下的wd效应、交互，以及联合设置相对原基线的差；报告每个初始化，不把两个种子当两个世界。 + +训练保留原11个固定面板节点，OO面板仅64题。另在0/16k/32k/64k/128k/200k/300k检查点，按原全组合池顺序补评全部3729题（其中OO1283），两条旧基线同样补评；评价在训练结束后的独立进程进行，不改变训练随机流。全池300k补评必须逐项复现原终点。不会把64题面板跳动描述为全池grokking。是否出现延迟泛化，应并列训练拟合与完整OO曲线；单个终点上涨不是grokking，300k未出现也不证明任意更长预算都不会出现。 + +固定更新是本轮主比较。因同模型、数据和配对样本流，逐节点核对全部曝光，终点核对有效/执行/监督词元与估算训练FLOPs完全相等；实际GPU小时作为实现性能附报，不预设相等。历史跨数据比较保留已存预算上下节点与间隙，不插值准确率，不外推合成3M结果。 + +若联合配置改善且单因素/交互方向一致，支持优化方案是该图有限预算OO的原因之一；不证明是合成与真实全部差距的唯一原因。若没有改善或损害事实拟合，保留负结果，优先结合已完成的实体编码和地址分配控制，下一轮再单独改变表示或组合覆盖。当前不自动追加1500k长跑、不铺开表示×结构×优化的全矩阵。 + +## 调度与记录 + +等`parametric-architecture-main-v1`全部15条完成并审计、GPU2–5空闲后自动开始；不改写或停止旧队列。专属`docker --context lm-memory`，固定镜像，每条训练独立容器、4 CPU/48 GiB内存和独立临时目录；主机输出持久化到本批`results/`。W&B随正式队列启动，entity `zhusq20`、project `llm-memory-editability`。等待阶段不声称训练已开始。 + +源码与配置封存在本目录`source/`及`frozen-config.json`，使用`execution-lock.json`核验。启动命令为主机设置`LD_LIBRARY_PATH=/lib64...`后运行`python scripts/execute_oo_optimizer_attribution.py freeze --config configs/oo-optimizer-attribution-v1.json`，然后对生成的冻结配置执行`launch`。实时状态在`results/oo-optimizer-attribution-v1/controller-state.json`，完成后自动写配对结果`report.json`。 diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/analyze_oo_budget_attribution.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/analyze_oo_budget_attribution.py new file mode 100644 index 0000000000000000000000000000000000000000..8492edf0feb7099f48ca0106ce9ba10e7a792402 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/analyze_oo_budget_attribution.py @@ -0,0 +1,291 @@ +"""Recount archived OO predictions and compare measured training budgets.""" + +from __future__ import annotations + +import argparse +import csv +import hashlib +import json +import statistics +from pathlib import Path + +import numpy as np + +ROOT = Path(__file__).resolve().parents[1] +BATCH = "oo-budget-attribution-20261005" +STEPS = (32000, 64000, 128000, 200000, 300000, 500000, 700000, 1000000, 1500000) + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, value): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n") + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def main(out): + out.mkdir(parents=True, exist_ok=True) + sources, flat, endpoints, recounts = {}, [], [], [] + + def register(path): + sources[str(path.relative_to(ROOT))] = sha(path) + + meta_path = ROOT / "results/grokking-reproduction-v1/data/complete.json" + metadata = read(meta_path) + register(meta_path) + synthetic = ROOT / "results/grokking-reproduction-v1/development" + real = ROOT / "results/realworld-composition-confirmation-v1/confirmation" + for dataset, parent in [("synthetic", synthetic), ("real_native", real)]: + for run in sorted(parent.iterdir()): + if not (run / "learning.json").exists(): + continue + runmeta = read(run / "run.json") + spec = runmeta["spec"] + register(run / "run.json") + register(run / "learning.json") + history = read(run / "learning.json") + architecture = "loop4x2" if "loop4x2" in run.name else "standard8" + if "standard4" in run.name: + architecture = "standard4" + local = [] + for point in history: + metrics = point["metrics"] + row = { + "dataset": dataset, + "run": run.name, + "architecture": architecture, + "initialization": spec["initialization"], + "learning_rate": spec.get("lr", spec.get("learning_rate")), + "weight_decay": spec["weight_decay"], + "phi": spec.get("phi"), + "step": point["step"], + "oo_n": metrics["test_oo"]["n"], + "oo_percent": 100 + * metrics["test_oo"]["accuracy" if dataset == "synthetic" else "alias_em"], + "evaluation_scope": "fixed_full_OO_pool" + if dataset == "synthetic" + else "fixed_panel", + "training_hours": point["training_seconds"] / 3600, + "estimated_matmul_training_flops": point["estimated_matmul_training_flops"], + "executed_input_tokens": point["executed_input_tokens"], + "examples": point["examples"], + "atomic_epochs": point["atomic_epochs"], + "composition_epochs": point["composition_epochs"], + } + if dataset == "synthetic" and point["step"] in STEPS: + path = run / f"predictions-{point['step']:07d}-test_oo.npz" + with np.load(path) as raw: + correct = raw["answer"] == raw["rows"][:, -1] + metadata["entity_offset"] + correct &= raw["stop"] == metadata["end_marker"] + assert len(correct) == row["oo_n"] + assert abs(float(correct.mean()) * 100 - row["oo_percent"]) < 1e-10 + register(path) + recounts.append( + { + "run": run.name, + "step": point["step"], + "n": len(correct), + "correct": int(correct.sum()), + } + ) + local.append(row) + final = dict(local[-1]) + if dataset == "real_native": + path = run / "endpoint-predictions.json" + raw = [r for r in read(path)["test_all"] if r["role"] == "OO"] + expected = read(run / "endpoint.json")["test_oo"] + assert len(raw) == expected["n"] == 1283 + correct = sum(r["alias_em"] for r in raw) + assert abs(correct / len(raw) - expected["alias_em"]) < 1e-12 + final.update( + oo_n=len(raw), + oo_percent=100 * correct / len(raw), + evaluation_scope="full_endpoint", + ) + register(path) + register(run / "endpoint.json") + recounts.append( + {"run": run.name, "step": final["step"], "n": len(raw), "correct": int(correct)} + ) + endpoints.append(final) + flat.extend(local) + + synthetic_300k = [r for r in flat if r["dataset"] == "synthetic" and r["step"] == 300000] + real_loop = [ + r for r in endpoints if r["dataset"] == "real_native" and r["architecture"] == "loop4x2" + ] + synthetic_loop = [r for r in endpoints if r["run"] == "loop4x2-phi7.2-wd0.3"][0] + real_summary = { + key: statistics.mean(r[key] for r in real_loop) + for key in [ + "oo_percent", + "training_hours", + "estimated_matmul_training_flops", + "executed_input_tokens", + "examples", + "atomic_epochs", + "composition_epochs", + ] + } + real_summary.update( + n_initializations=3, + oo_n_each=1283, + oo_sample_sd=statistics.stdev(r["oo_percent"] for r in real_loop), + ) + temporal_brackets = [] + for endpoint in real_loop: + for key in [ + "training_hours", + "estimated_matmul_training_flops", + "examples", + "atomic_epochs", + ]: + target = endpoint[key] + candidates = [r for r in flat if r["run"] == synthetic_loop["run"]] + lower = [r for r in candidates if r[key] <= target] + upper = [r for r in candidates if r[key] >= target] + temporal_brackets.append( + { + "real_run": endpoint["run"], + "budget": key, + "real_value": target, + "synthetic_below": max(lower, key=lambda r: r[key]) if lower else None, + "synthetic_above": min(upper, key=lambda r: r[key]) if upper else None, + "extrapolated": False, + } + ) + summary = { + "analysis": "retrospective_read_only_recount", + "same_300k_updates": synthetic_300k, + "real_loop_300k_full_endpoint_mean": real_summary, + "synthetic_loop_wd03_1500k": synthetic_loop, + "real_300k_over_synthetic_1500k": { + key: real_summary[key] / synthetic_loop[key] + for key in [ + "training_hours", + "estimated_matmul_training_flops", + "executed_input_tokens", + "examples", + "atomic_epochs", + ] + }, + "limits": [ + "Same optimizer steps are not the same FLOPs, token exposure, epochs or GPU time.", + "FLOPs share a dense-matmul/attention convention, approximate backward as 2x forward, " + "and exclude elementwise ops, optimizer, evaluation and system overhead.", + "Recorded GPU time comes from separate runs and execution implementations; " + "it is an engineering budget, not a causal control.", + "Synthetic is one graph/initialization; real is one graph with three initializations. " + "Neither query count nor seeds are independent worlds.", + "Real intermediate points use 64 OO queries; only real 300k uses the full 1283 pool. " + "Synthetic uses its fixed 2004-query OO pool throughout.", + "Synthetic strict token+stop accuracy and real official-alias EM " + "are different scoring protocols.", + "Dataset, entity representation, support, sampling, initialization, LR and WD " + "remain confounded across historical batches.", + "Retrospective threshold/cross-budget views do not change the frozen endpoints. " + "No interpolated accuracy or extrapolated 3M synthetic score is reported.", + ], + } + write(out / "summary.json", summary) + write(out / "budget-brackets.json", temporal_brackets) + write( + out / "recount-audit.json", + { + "passed": True, + "raw_pools_recounted": len(recounts), + "records": recounts, + "sources_sha256": sources, + }, + ) + with (out / "learning-budgets.csv").open("w") as stream: + writer = csv.DictWriter(stream, fieldnames=list(flat[0])) + writer.writeheader() + writer.writerows(flat) + with (out / "endpoints.csv").open("w") as stream: + writer = csv.DictWriter(stream, fieldnames=list(flat[0])) + writer.writeheader() + writer.writerows(endpoints) + plot(flat, real_loop, out) + print( + json.dumps( + { + "real_loop": real_summary, + "synthetic_loop_wd03": synthetic_loop, + "ratios": summary["real_300k_over_synthetic_1500k"], + "recounted_pools": len(recounts), + }, + indent=2, + ) + ) + + +def plot(rows, real_loop, out): + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + + fig, axes = plt.subplots(1, 3, figsize=(13.5, 4), layout="constrained") + colors = {0.1: "#3679b5", 0.3: "#d3544b"} + for decay, color in colors.items(): + run = f"loop4x2-phi7.2-wd{decay}" + values = [r for r in rows if r["run"] == run] + for ax, key, scale, label in zip( + axes, + ["step", "training_hours", "estimated_matmul_training_flops"], + [1000, 1, 1e18], + [ + "Updates (thousands)", + "Measured training GPU hours", + "Estimated matmul training FLOPs (1e18)", + ], + strict=True, + ): + ax.plot( + [r[key] / scale for r in values], + [r["oo_percent"] for r in values], + color=color, + lw=1.2, + label=f"Synthetic Loop, wd={decay}", + ) + ax.set_xlabel(label) + for ax, key, scale in zip( + axes, + ["step", "training_hours", "estimated_matmul_training_flops"], + [1000, 1, 1e18], + strict=True, + ): + ax.scatter( + [r[key] / scale for r in real_loop], + [r["oo_percent"] for r in real_loop], + marker="D", + color="#282828", + s=35, + label="Real names, 300k: 3 seeds", + zorder=5, + ) + ax.set_ylim(-2, 103) + ax.set_ylabel("Strict OO / official-alias EM (%)") + ax.spines[["top", "right"]].set_visible(False) + ax.grid(alpha=0.18) + axes[0].legend(frameon=False, fontsize=8) + fig.suptitle( + "Historical budget comparison: different datasets / LR / scoring; no causal ranking", + fontsize=12, + ) + fig.savefig(out / "budget-comparison.png", dpi=170) + fig.savefig(out / "budget-comparison.pdf") + plt.close(fig) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--out", type=Path, default=ROOT / "docs/development-artifacts" / BATCH) + main(parser.parse_args().out) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_oo_optimizer_attribution.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_oo_optimizer_attribution.py new file mode 100644 index 0000000000000000000000000000000000000000..f6afb0b8d54ddc1a856b8a84fadcc8d113c2a392 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_oo_optimizer_attribution.py @@ -0,0 +1,456 @@ +"""Queue a paired LR/decay attribution after the existing architecture batch.""" + +from __future__ import annotations + +import argparse +import ast +import fcntl +import math +import statistics +import subprocess +import sys +import time +import traceback +from pathlib import Path + +import execute_parametric_architecture as scheduler + +read, write, digest, now = scheduler.read, scheduler.write, scheduler.digest, scheduler.now + + +def trainer_dependencies(source): + """Include transitive local imports, not only the top-level trainer file.""" + found = set() + + def visit(module): + path = Path(source) / "src/llm_memory_editability" / (module + ".py") + if path in found or not path.exists(): + return + found.add(path) + for node in ast.walk(ast.parse(path.read_text())): + if isinstance(node, ast.ImportFrom) and node.level == 1 and node.module: + visit(node.module) + + visit("realworld_composition") + return sorted(found) + + +def validate_matrix(config, historical): + assert config["gpus"] == [2, 3, 4, 5] + assert config["runtime"]["docker_context"] == "lm-memory" + assert config["phase"] == "runs" + for key in ["data_file", "data_sha256", "tokenizer", "model", "evaluation_nodes"]: + assert config[key] == historical[key], key + expected = { + (seed, lr, wd) for seed in [811201, 811202] for lr in [5e-5, 1e-4] for wd in [0.1, 0.3] + } + specs = [item["spec"] for item in config["reused_baselines"]] + config["runs"] + observed = [(s["initialization"], s["learning_rate"], s["weight_decay"]) for s in specs] + assert len(observed) == len(set(observed)) == len(expected) and set(observed) == expected + assert len(config["reused_baselines"]) == 2 and len(config["runs"]) == 6 + for spec in specs: + base = next( + s + for s in historical["runs"] + if s["architecture"] == "loop4x2" and s["initialization"] == spec["initialization"] + ) + assert set(spec) == set(base) + for key in base.keys() - {"name", "learning_rate", "weight_decay"}: + assert spec[key] == base[key], (spec["name"], key) + for baseline in config["reused_baselines"]: + assert baseline["spec"]["learning_rate"] == 5e-5 + assert baseline["spec"]["weight_decay"] == 0.1 + assert config["full_curve_nodes"] == [0, 16000, 32000, 64000, 128000, 200000, 300000] + + +def verify_inputs(config, source): + historical = read(config["historical_config"]) + assert digest(config["historical_config"]) == config["historical_config_sha256"] + validate_matrix(config, historical) + assert digest(config["data_file"]) == config["data_sha256"] + hashes = {} + for path in trainer_dependencies(source): + relative = path.relative_to(source) + old = Path(historical["source_snapshot"]) / relative + expected = historical["source_files"][str(old)] + assert digest(path) == digest(old) == expected, str(relative) + hashes[str(relative)] = expected + for path, expected in historical["tokenizer_files"].items(): + assert digest(path) == expected + for baseline in config["reused_baselines"]: + root = Path(baseline["path"]) + assert read(root / "run.json")["spec"] == baseline["spec"] + assert read(root / "audit.json")["passed"] is True + assert read(root / "complete.json")["independently_reloaded"] is True + for filename, expected in baseline["files_sha256"].items(): + assert digest(root / filename) == expected, (root, filename) + for step in config["full_curve_nodes"]: + assert (root / f"checkpoint-{step:07d}.pt").is_file() + return { + "passed": True, + "utc": now(), + "trainer_dependency_sha256": hashes, + "baseline_initializations": [811201, 811202], + "limits": "Source/data/tokenizer compatibility; GPU calibration is still required.", + } + + +def freeze(config_path): + config = read(config_path) + evidence = verify_inputs(config, Path.cwd()) + scheduler.freeze(config_path) + write( + Path("docs/development-artifacts") / config["batch"] / "reuse-verification.json", evidence + ) + + +def launch(config_path): + config = read(config_path) + root = Path(config["results_root"]) + root.mkdir(parents=True, exist_ok=True) + script = Path(config["source_root"]) / "scripts" / Path(__file__).name + command = [sys.executable, "-u", str(script), "controller", "--config", str(config_path)] + with (root / "controller.log").open("a") as log: + proc = subprocess.Popen( + command, + env=scheduler.host_env(config["source_root"]), + stdout=log, + stderr=subprocess.STDOUT, + start_new_session=True, + ) + write(root / "controller-process.json", {"pid": proc.pid, "command": command}) + print({"pid": proc.pid, "results": str(root)}) + + +def predecessor_ready(config): + root = Path(config["wait_for_results_root"]) + state = read(root / "controller-state.json") + if state.get("failed") or state["state"] in {"controller_error", "finished_with_failures"}: + raise RuntimeError("Predecessor failed; attribution remains unstarted for review") + if state["state"] != "complete": + return False, state + expected = set(config["wait_for_runs"]) + assert set(state["completed"]) == expected and not state.get("active") + for name in expected: + assert read(root / "runs" / name / "audit.json")["passed"] is True + return True, state + + +def container_command(config, config_path, spec, out, gpu, attempt): + name, command = scheduler.container_command(config, config_path, spec, out, gpu, attempt) + previous = str(Path(config["source_root"]) / "scripts/execute_parametric_architecture.py") + command[command.index(previous)] = str( + Path(config["source_root"]) / "scripts" / Path(__file__).name + ) + return name, command + + +def controller(config_path): + config = read(config_path) + root = Path(config["results_root"]) + with (root / "controller.lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + try: + while True: + ready, previous = predecessor_ready(config) + write( + root / "controller-state.json", + { + "state": "waiting_for_free_gpus" if ready else "waiting_for_predecessor", + "gpus": config["gpus"], + "completed": [], + "failed": [], + "active": {}, + "queued": [s["name"] for s in config["runs"]], + "predecessor_completed": len(previous.get("completed", [])), + "predecessor_total": len(config["wait_for_runs"]), + "updated_utc": now(), + }, + ) + if ready: + devices = subprocess.check_output( + [ + "nvidia-smi", + "--query-gpu=index,memory.used", + "--format=csv,noheader,nounits", + ], + text=True, + ) + memory = { + int(i.strip()): int(m.strip()) + for i, m in (line.split(",") for line in devices.splitlines()) + } + if all(memory[g] <= 1024 for g in config["gpus"]): + break + time.sleep(20) + verify_inputs(config, Path(config["source_root"])) + scheduler.control_locked(config, config_path, root, command_builder=container_command) + if read(root / "controller-state.json")["state"] == "complete": + report(config) + except BaseException: + write(root / "controller-error.json", {"utc": now(), "error": traceback.format_exc()}) + state = read(root / "controller-state.json") + state.update(state="controller_error", updated_utc=now()) + write(root / "controller-state.json", state) + raise + + +def baseline_for(config, spec): + return next( + b + for b in config["reused_baselines"] + if b["spec"]["initialization"] == spec["initialization"] + ) + + +def preflight(config, spec, out): + """Actual isolated CUDA updates; exact historical initialization and step-0 replay.""" + import torch + import transformers + + from llm_memory_editability import realworld_composition as rw + + assert torch.__version__ == "2.6.0+cu126" and transformers.__version__ == "4.40.0" + torch.set_num_threads(4) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.cuda.set_device(0) + data = read(config["data_file"]) + tokenizer = rw.GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + model = rw.construct(config["model"], spec, "cuda:0") + baseline = Path(baseline_for(config, spec)["path"]) + initial = rw.model_digest(model) + assert initial == read(baseline / "run.json")["initial_model_sha256"] + metrics, predictions = rw.evaluate_dataset(model, data, tokenizer, "cuda:0") + assert predictions == read(baseline / "predictions-0000000.json") + assert metrics == read(baseline / "learning.json")[0]["metrics"] + optimizer = rw.optimizer_for(model, spec["learning_rate"], spec["weight_decay"]) + records = data["atoms"] + data["train_compositions"] + stream = rw.BatchStream(len(records), spec["sampling_seed"]) + torch.manual_seed(spec["dropout_seed"]) + values = [] + for _ in range(8): + ids = stream.batch(spec["batch_size"]) + values.append( + rw.update( + model, optimizer, [records[i] for i in ids], spec, "cuda:0", tokenizer.eos_token_id + ) + ) + torch.cuda.synchronize() + assert all(math.isfinite(v["loss"]) and math.isfinite(v["gradient_norm"]) for v in values) + write( + out / "gpu-preflight.json", + { + "passed": True, + "utc": now(), + "gpu": torch.cuda.get_device_name(), + "historical_initial_sha256": initial, + "historical_step_zero_exact_replay": True, + "engineering_updates_excluded_from_training": values, + }, + ) + + +def trajectory(config, spec, out, *, historical=False): + """Re-evaluate the same full composition pool/order at predetermined checkpoints.""" + import torch + + from llm_memory_editability import realworld_composition as rw + + torch.set_num_threads(4) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.cuda.set_device(0) + source = Path(baseline_for(config, spec)["path"]) if historical else out + target = out / ("historical-baseline-curve" if historical else "full-curve") + data = read(config["data_file"]) + tokenizer = rw.GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + model = rw.construct(config["model"], spec, "cuda:0") + curve = [] + started = time.perf_counter() + for step in config["full_curve_nodes"]: + checkpoint = source / f"checkpoint-{step:07d}.pt" + state = torch.load(checkpoint, map_location="cpu", weights_only=False) + assert state["step"] == step + model.load_state_dict(state["model"]) + del state + _, raw = rw.evaluate(model, data["evaluation_compositions"], tokenizer, "cuda:0") + if step == spec["steps"]: + assert raw == read(source / "endpoint-predictions.json")["test_all"] + write(target / f"predictions-{step:07d}.json", raw) + curve.append( + { + "step": step, + "oo": rw.aggregate([r for r in raw if r["role"] == "OO"]), + "all": rw.aggregate(raw), + "checkpoint_sha256": digest(checkpoint), + } + ) + write(target / "curve.json", curve) + write( + target / "complete.json", + { + "passed": True, + "source": str(source), + "utc": now(), + "evaluation_seconds": time.perf_counter() - started, + "full_oo_n": 1283, + "full_compositions_n": len(raw), + }, + ) + + +def container_worker(config_path, run_name): + config = read(config_path) + assert run_name in {s["name"] for s in config["runs"]} + out = Path(config["results_root"]) / "runs" / run_name + script = Path(config["source_root"]) / "scripts" / Path(__file__).name + base = ["--config", str(config_path), "--run", run_name] + actions = ["preflight", "train", "trajectory"] + if run_name in config["baseline_curve_carriers"]: + actions.append("baseline-trajectory") + actions.append("audit") + try: + for action in actions: + subprocess.run([sys.executable, "-u", str(script), action, *base], check=True) + assert read(out / "audit.json")["passed"] is True + except BaseException: + write(out / "failure.json", {"traceback": traceback.format_exc(), "utc": now()}) + raise + + +def report(config): + import numpy as np + + rows, cells = [], {} + sources = [(b["spec"], Path(b["path"]), True) for b in config["reused_baselines"]] + sources += [ + (s, Path(config["results_root"]) / "runs" / s["name"], False) for s in config["runs"] + ] + for spec, out, reused in sources: + assert read(out / "audit.json")["passed"] is True + predictions = read(out / "endpoint-predictions.json")["test_all"] + oo = [p for p in predictions if p["role"] == "OO"] + assert len(oo) == 1283 + score = sum(p["alias_em"] for p in oo) / len(oo) + assert abs(score - read(out / "endpoint.json")["test_oo"]["alias_em"]) < 1e-12 + base = Path(baseline_for(config, spec)["path"]) + assert ( + read(out / "run.json")["initial_model_sha256"] + == read(base / "run.json")["initial_model_sha256"] + ) + for step in config["evaluation_nodes"]: + filename = f"exposure-{step:07d}.npz" + with np.load(out / filename) as actual, np.load(base / filename) as reference: + np.testing.assert_array_equal(actual["counts"], reference["counts"]) + latest = read(out / "learning.json")[-1] + reference = read(base / "learning.json")[-1] + for key in [ + "examples", + "supervised_tokens", + "executed_input_tokens", + "effective_input_tokens", + "estimated_matmul_training_flops", + ]: + assert latest[key] == reference[key], (spec["name"], key) + cells[spec["initialization"], spec["learning_rate"], spec["weight_decay"]] = 100 * score + curve_root = out / "full-curve" + if reused: + carrier = next( + s + for s in config["runs"] + if s["name"] in config["baseline_curve_carriers"] + and s["initialization"] == spec["initialization"] + ) + curve_root = ( + Path(config["results_root"]) + / "runs" + / carrier["name"] + / "historical-baseline-curve" + ) + assert read(curve_root / "complete.json")["passed"] is True + rows.append( + { + "spec": spec, + "reused": reused, + "oo_percent": 100 * score, + "endpoint": read(out / "endpoint.json"), + "training_budget": latest, + "full_curve": read(curve_root / "curve.json"), + } + ) + contrasts = [] + for seed in [811201, 811202]: + a, b, c, d = [ + cells[seed, lr, wd] for lr, wd in [(5e-5, 0.1), (1e-4, 0.1), (5e-5, 0.3), (1e-4, 0.3)] + ] + contrasts.append( + { + "initialization": seed, + "lr_at_wd01_pp": b - a, + "lr_at_wd03_pp": d - c, + "wd_at_lr5e5_pp": c - a, + "wd_at_lr1e4_pp": d - b, + "interaction_pp": d - c - b + a, + "joint_recipe_minus_baseline_pp": d - a, + } + ) + summary = { + "passed": True, + "utc": now(), + "cells": rows, + "paired_contrasts": contrasts, + "mean_contrasts": { + k: statistics.mean(r[k] for r in contrasts) + for k in contrasts[0] + if k != "initialization" + }, + "scope": "Exploratory attribution on one previously evaluated graph; " + "two paired initializations, not two worlds.", + } + write(Path(config["results_root"]) / "report.json", summary) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument( + "action", + choices=[ + "freeze", + "launch", + "controller", + "container-worker", + "preflight", + "train", + "audit", + "trajectory", + "baseline-trajectory", + "report", + ], + ) + parser.add_argument("--config", required=True, type=Path) + parser.add_argument("--run") + args = parser.parse_args() + path = args.config.resolve() + if args.action in {"freeze", "launch", "controller"}: + globals()[args.action](path) + elif args.action == "container-worker": + container_worker(path, args.run) + else: + config = read(path) + if args.action == "report": + return report(config) + spec = next(s for s in config["runs"] if s["name"] == args.run) + out = Path(config["results_root"]) / "runs" / spec["name"] + if args.action in {"train", "audit"}: + from llm_memory_editability import realworld_composition as rw + + (rw.worker if args.action == "train" else rw.audit)(config, spec, 0) + elif args.action == "preflight": + preflight(config, spec, out) + else: + trajectory(config, spec, out, historical=args.action == "baseline-trajectory") + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_parametric_architecture.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_parametric_architecture.py new file mode 100644 index 0000000000000000000000000000000000000000..cab8b2e3780ee0773069b7b865891a25793beb5a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/execute_parametric_architecture.py @@ -0,0 +1,498 @@ +"""Freeze and run the staged architecture comparison in four isolated GPU slots.""" + +from __future__ import annotations + +import argparse +import fcntl +import hashlib +import json +import math +import os +import shutil +import subprocess +import sys +import time +import traceback +from datetime import datetime, timezone +from pathlib import Path + + +def write(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(".tmp") + temporary.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n") + temporary.replace(path) + + +def read(path): + return json.loads(Path(path).read_text()) + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def host_env(source): + env = dict(os.environ) + env["LD_LIBRARY_PATH"] = "/lib64" + ( + ":" + env["LD_LIBRARY_PATH"] if env.get("LD_LIBRARY_PATH") else "" + ) + env.update(PYTHONPATH=str(Path(source) / "src"), OMP_NUM_THREADS="1", MKL_NUM_THREADS="1") + return env + + +def freeze(input_path): + config = read(input_path) + repo = Path.cwd().resolve() + artifact = repo / "docs/development-artifacts" / config["batch"] + source = artifact / "source" + if source.exists(): + raise FileExistsError(source) + assert config["runtime"]["docker_context"] == "lm-memory" + assert config["gpus"] == [2, 3, 4, 5] + files = sorted( + list(Path("src/llm_memory_editability").glob("*.py")) + + [Path(__file__).relative_to(repo), Path("scripts/run_parametric_architecture.py")] + + [Path("configs/experiment-tracking-defaults.json")] + + [Path(p) for p in config.get("additional_sources", [])] + ) + config.update( + repository=str(repo), + source_root=str(source), + frozen_utc=now(), + source_files={}, + execution_lock=str(artifact / "execution-lock.json"), + git_commit=subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip(), + ) + for path in files: + target = source / path + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copy2(path, target) + config["source_files"][str(target)] = digest(target) + config["tokenizer_sha256"] = { + str(p.relative_to(config["tokenizer"])): digest(p) + for p in sorted(Path(config["tokenizer"]).rglob("*")) + if p.is_file() + } + assert digest(config["data_file"]) == config["data_sha256"] + path = artifact / "frozen-config.json" + write(path, config) + write( + config["execution_lock"], + { + "config_sha256": digest(path), + "frozen_utc": now(), + "environment": {"torch": "2.6.0+cu126", "transformers": "4.40.0"}, + }, + ) + print(json.dumps({"config": str(path), "runs": len(config["runs"])})) + + +def launch(config_path): + config = read(config_path) + root = Path(config["results_root"]) + root.mkdir(parents=True, exist_ok=True) + script = Path(config["source_root"]) / "scripts" / Path(__file__).name + command = [sys.executable, "-u", str(script), "controller", "--config", str(config_path)] + with (root / "controller.log").open("a") as log: + proc = subprocess.Popen( + command, + env=host_env(config["source_root"]), + stdout=log, + stderr=subprocess.STDOUT, + start_new_session=True, + ) + write(root / "controller-process.json", {"pid": proc.pid, "command": command}) + print(json.dumps({"pid": proc.pid, "results": str(root)})) + + +def container_command(config, config_path, spec, out, gpu, attempt): + runtime = config["runtime"] + identity = f"{config['batch']}:{spec['name']}:{attempt}" + name = "lm-architecture-" + hashlib.sha256(identity.encode()).hexdigest()[:20] + command = [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + name, + "--label", + "project=llm-memory-editability", + "--label", + "batch=" + config["batch"], + "--network=none", + "--gpus", + f"device={gpu}", + "--cpus", + str(runtime["cpus"]), + "--memory", + runtime["memory"], + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + f"type=bind,src={config['repository']},dst={config['repository']},readonly", + "--mount", + f"type=bind,src={out},dst={out}", + "--workdir", + config["repository"], + ] + env = { + "PHYSICAL_GPU": str(gpu), + "PYTHONDONTWRITEBYTECODE": "1", + "OMP_NUM_THREADS": "4", + "MKL_NUM_THREADS": "4", + "PYTHONPATH": str(Path(config["source_root"]) / "src"), + "XDG_CACHE_HOME": "/tmp/cache", + "TORCH_HOME": "/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR": "/tmp/torchinductor", + "TRITON_CACHE_DIR": "/tmp/triton", + } + for key, value in env.items(): + command += ["--env", f"{key}={value}"] + command += [ + runtime["image"], + runtime["python"], + "-u", + str(Path(config["source_root"]) / "scripts" / Path(__file__).name), + "container-worker", + "--config", + str(config_path), + "--run", + spec["name"], + ] + return name, command + + +def container_worker(config_path, run_name): + config = read(config_path) + out = Path(config["results_root"]) / "runs" / run_name + cli = Path(config["source_root"]) / "scripts/run_parametric_architecture.py" + base = [ + "--config", + str(config_path), + "--run", + run_name, + "--out", + str(out), + "--device", + "cuda:0", + ] + try: + subprocess.run([sys.executable, "-u", str(cli), "train", *base], check=True) + subprocess.run([sys.executable, "-u", str(cli), "audit", *base], check=True) + assert read(out / "audit.json")["passed"] is True + except BaseException: + write(out / "failure.json", {"traceback": traceback.format_exc(), "utc": now()}) + raise + + +def controller(config_path): + config = read(config_path) + root = Path(config["results_root"]) + root.mkdir(parents=True, exist_ok=True) + with (root / "controller.lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + return control_locked(config, config_path, root) + + +def control_locked(config, config_path, root, *, command_builder=None): + command_builder = command_builder or container_command + assert digest(config_path) == read(config["execution_lock"])["config_sha256"] + for path, expected in config["source_files"].items(): + assert digest(path) == expected, f"Frozen source changed: {path}" + existing = subprocess.check_output( + [ + "docker", + "--context", + "lm-memory", + "ps", + "--filter", + "label=batch=" + config["batch"], + "--format", + "{{.Names}}", + ], + text=True, + ).strip() + if existing: + raise RuntimeError( + f"Existing containers still own this batch; do not duplicate: {existing}" + ) + devices = subprocess.check_output( + ["nvidia-smi", "--query-gpu=index,memory.used", "--format=csv,noheader,nounits"], + text=True, + ) + for line in devices.splitlines(): + index, memory = (int(v.strip()) for v in line.split(",")) + if index in config["gpus"] and memory > 1024: + raise RuntimeError(f"GPU {index} is already occupied ({memory} MiB)") + state = { + "state": "running", + "started_utc": now(), + "gpus": config["gpus"], + "completed": [], + "failed": [], + "active": {}, + "phase": config["phase"], + } + write(root / "controller-state.json", state) + shutil.copyfile(config_path, root / "frozen-config.json") + tracking = [ + str(Path(config["repository"]) / ".venv-wandb/bin/python"), + "-u", + "-m", + "llm_memory_editability.interface_tracking", + "--root", + str(root), + "--defaults", + str(Path(config["source_root"]) / "configs/experiment-tracking-defaults.json"), + ] + tracking_log = (root / "tracking.log").open("a") + tracker = subprocess.Popen( + tracking, env=host_env(config["source_root"]), stdout=tracking_log, stderr=subprocess.STDOUT + ) + write(root / "tracking-process.json", {"pid": tracker.pid, "command": tracking}) + queue, active = list(config["runs"]), {} + try: + deadline = time.monotonic() + 45 + while not (root / "tracking-ready.json").exists() and tracker.poll() is None: + if time.monotonic() > deadline: + raise RuntimeError("W&B sidecar did not become ready") + time.sleep(0.2) + while queue or active: + if tracker.poll() is not None: + state["tracking_failure"] = f"W&B sidecar exited {tracker.returncode}" + for gpu, item in list(active.items()): + if item["process"].poll() is None: + continue + item["log"].close() + out = root / "runs" / item["name"] + result = subprocess.run( + ["docker", "--context", "lm-memory", "inspect", item["container"]], + capture_output=True, + text=True, + ) + if result.returncode == 0: + write(out / "container-inspect.json", json.loads(result.stdout)) + passed = item["process"].returncode == 0 and (out / "audit.json").exists() + passed = passed and read(out / "audit.json").get("passed") is True + state["completed" if passed else "failed"].append(item["name"]) + del active[gpu] + if state["failed"] or state.get("tracking_failure"): + queue.clear() + for gpu in config["gpus"]: + if gpu in active or not queue: + continue + spec = queue.pop(0) + out = root / "runs" / spec["name"] + if (out / "audit.json").exists() and read(out / "audit.json").get("passed"): + state["completed"].append(spec["name"]) + continue + if (out / "failure.json").exists(): + raise RuntimeError(f"Review recorded failure before resuming {spec['name']}") + out.mkdir(parents=True, exist_ok=True) + attempt = len(list(out.glob("container-command-*.json"))) + 1 + name, command = command_builder(config, config_path, spec, out, gpu, attempt) + write(out / f"container-command-{attempt}.json", {"name": name, "command": command}) + log = (out / "worker.log").open("a") + proc = subprocess.Popen(command, stdout=log, stderr=subprocess.STDOUT) + active[gpu] = {"process": proc, "name": spec["name"], "container": name, "log": log} + for _ in range(60): + result = subprocess.run( + ["docker", "--context", "lm-memory", "inspect", name], + capture_output=True, + text=True, + ) + if result.returncode == 0: + info = json.loads(result.stdout)[0] + if info["State"].get("Running"): + write( + out / "container-runtime.json", + { + "physical_gpu": gpu, + "host_pid": info["State"]["Pid"], + "container_id": info["Id"], + "image": info["Image"], + "cpus": config["runtime"]["cpus"], + "memory": config["runtime"]["memory"], + }, + ) + break + if proc.poll() is not None: + break + time.sleep(0.2) + state.update( + active={ + str(g): { + "name": x["name"], + "container": x["container"], + "pid": x["process"].pid, + } + for g, x in active.items() + }, + queued=[s["name"] for s in queue], + updated_utc=now(), + ) + write(root / "controller-state.json", state) + time.sleep(3) + if not state["failed"] and not state.get("tracking_failure") and config["phase"] == "main": + subprocess.run( + [ + sys.executable, + str(Path(config["source_root"]) / "scripts/report_parametric_architecture.py"), + "--config", + str(config_path), + "--out", + str(root / "report"), + ], + env=host_env(config["source_root"]), + check=True, + ) + state.update( + state="finished_with_failures" + if state["failed"] or state.get("tracking_failure") + else "complete", + finished_utc=now(), + ) + write(root / "controller-state.json", state) + if state["state"] == "complete" and config.get("transition"): + next_path = select_main(config, root) + launch(next_path) + except BaseException: + state.update(state="controller_error", error=traceback.format_exc(), updated_utc=now()) + write(root / "controller-state.json", state) + raise + finally: + tracking_log.close() + + +def select_main(config, root): + """Select only by the predeclared development fit score, retaining every candidate.""" + transition = config["transition"] + choices = {} + candidates = [] + expected = {(a, lr) for a in ["M8", "W8", "IHC8", "HC8"] for lr in [5e-5, 1e-4]} + expected.add(("D8", 1e-4)) + observed = [(s["architecture"], s["learning_rate"]) for s in config["runs"]] + assert len(observed) == len(expected) and set(observed) == expected + for spec in config["runs"]: + out = root / "runs" / spec["name"] + assert read(out / "audit.json")["passed"] + record = read(out / "learning.json")[-1] + assert record["step"] == spec["steps"] == 32000 + metrics = record["metrics"] + score = 0.5 * metrics["atomic"]["nll"] + 0.5 * metrics["train_composition"]["nll"] + assert math.isfinite(score) + candidates.append( + { + "architecture": spec["architecture"], + "learning_rate": spec["learning_rate"], + "score": score, + "run": spec["name"], + } + ) + historical = transition["historical_development"] + assert digest(historical["path"]) == historical["sha256"] + historical_node = next(r for r in read(historical["path"]) if r["step"] == 32000) + historical_metrics = historical_node["metrics"] + historical_score = ( + historical_metrics["atomic"]["nll"] + historical_metrics["train_composition"]["nll"] + ) / 2 + assert math.isfinite(historical_score) + assert historical_score == historical["selection_score"] + candidates.append( + { + "architecture": "D8", + "learning_rate": 5e-5, + "score": historical_score, + "run": "D8_hist_development", + } + ) + for architecture in ["M8", "W8", "IHC8", "HC8", "D8"]: + rows = [r for r in candidates if r["architecture"] == architecture] + choices[architecture] = min(rows, key=lambda r: (r["score"], r["learning_rate"])) + write( + root / "development-selection.json", + {"rule": transition["selection_rule"], "candidates": candidates, "choices": choices}, + ) + main = dict(config) + main.pop("transition") + main.update( + batch=transition["batch"], + phase="main", + data_file=transition["data_file"], + data_sha256=transition["data_sha256"], + results_root=transition["results_root"], + evaluation_nodes=[0, 1000, 2000, 4000, 8000, 16000, 32000, 64000, 128000, 200000, 300000], + development_selection=str(root / "development-selection.json"), + tracking={**config["tracking"], "group": transition["batch"]}, + runs=[], + ) + main["reporting"] = { + **transition.get("reporting", {}), + "historical_reuse_verified": transition["historical_reuse_verified"], + } + arms = ["M8", "W8", "IHC8", "HC8"] + if choices["D8"]["learning_rate"] != 5e-5 or not transition["historical_reuse_verified"]: + arms.append("D8") + for seed_index in range(3): + for architecture in arms: + selected = choices[architecture] + spec = dict( + next( + s + for s in config["runs"] + if s["name"] == selected["run"] + or (selected["run"] == "D8_hist_development" and s["architecture"] == "D8") + ) + ) + spec.update( + name=f"{architecture.lower()}-init{seed_index + 1}", + steps=300000, + initialization=811201 + seed_index, + sampling_seed=812201 + seed_index, + dropout_seed=813201 + seed_index, + learning_rate=choices[architecture]["learning_rate"], + ) + main["runs"].append(spec) + artifact = Path(config["repository"]) / "docs/development-artifacts" / transition["batch"] + main["execution_lock"] = str(artifact / "execution-lock.json") + path = artifact / "frozen-config.json" + if path.exists(): + raise FileExistsError("Main stage has already been frozen") + assert digest(main["data_file"]) == main["data_sha256"] + write(path, main) + write( + main["execution_lock"], + { + "config_sha256": digest(path), + "frozen_utc": now(), + "development_config_sha256": digest(root / "frozen-config.json"), + "environment": {"torch": "2.6.0+cu126", "transformers": "4.40.0"}, + }, + ) + write(root / "next-stage.json", {"config": str(path), "runs": len(main["runs"])}) + return path + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("action", choices=["freeze", "launch", "controller", "container-worker"]) + parser.add_argument("--config", required=True, type=Path) + parser.add_argument("--run") + args = parser.parse_args() + if args.action == "container-worker": + container_worker(args.config.resolve(), args.run) + else: + globals()[args.action](args.config.resolve()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/run_parametric_architecture.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/run_parametric_architecture.py new file mode 100644 index 0000000000000000000000000000000000000000..e91134d9c34f3ec4b5dd7bd890e43ec8ba28b4d7 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/scripts/run_parametric_architecture.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +"""Run or independently audit one candidate from a frozen architecture config.""" + +import argparse +import json +import traceback +from pathlib import Path + +from llm_memory_editability.grok_depth import utc +from llm_memory_editability.parametric_architecture_train import audit, run, verify +from llm_memory_editability.realworld_composition_data import write_json + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("command", choices=("train", "audit")) + parser.add_argument("--config", type=Path, required=True) + parser.add_argument("--run", required=True) + parser.add_argument("--out", type=Path) + parser.add_argument("--device", default="cuda:0") + args = parser.parse_args() + config = json.loads(args.config.read_text()) + verify(config, args.config) + matching = [spec for spec in config["runs"] if spec["name"] == args.run] + if len(matching) != 1: + parser.error("--run must select exactly one frozen candidate") + spec = matching[0] + out = args.out or Path(config["results_root"]) / "runs" / spec["name"] + out.mkdir(parents=True, exist_ok=True) + try: + result = {"train": run, "audit": audit}[args.command](config, spec, out, args.device) + except Exception: + write_json( + out / "failure.json", + { + "command": args.command, + "error": traceback.format_exc(), + "created_utc": utc(), + }, + ) + raise + print(json.dumps(result), flush=True) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__init__.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c606cfd654948ec99bedce5244b7c6608a801a1d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__init__.py @@ -0,0 +1,19 @@ +"""Analytical examples for research on shared structure and editability.""" + +from .experiments import run_minimal_example +from .low_rank import ( + best_rank_approximation, + evaluate_update, + numerical_rank, + representation_gap, +) + +__version__ = "0.1.0" + +__all__ = [ + "best_rank_approximation", + "evaluate_update", + "numerical_rank", + "representation_gap", + "run_minimal_example", +] diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__main__.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..860f4f8babf02fc2d6920b26bf4ac11a3e254766 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/__main__.py @@ -0,0 +1,5 @@ +"""Support ``python -m llm_memory_editability``.""" + +from .cli import main + +raise SystemExit(main()) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/alignment_coverage.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/alignment_coverage.py new file mode 100644 index 0000000000000000000000000000000000000000..6efacd7bf323dd87ad027292dee80a9f665032fa --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/alignment_coverage.py @@ -0,0 +1,503 @@ +"""Paired geometric-supervision coverage in the established complete GPT task. + +All arms retain full-token CE and all-example first-hop CE. Coverage changes +only a multiplicative mask on the per-example geometric objective; every arm +executes the same forward and backward operations, including the zero mask. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import shutil +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import EpochStream, GraphStep, make_optimizer, utc, write_json +from .grok_loop_model import flops +from .latent_scaling import build_world, model_digest +from .representation_alignment import new_model +from .representation_alignment import pack_training as pack_base_training +from .storage_composition import data_digest, evaluate, file_hash +from .storage_frontier import learning_rate + +COVERAGES = ("none", "composition_only", "all_atomic_and_composition") +NORMALIZATIONS = ("selected_mean", "batch_mean") +STRATA = ("common_atomic", "train_composite", "anchor_atomic") +COMPONENTS = ( + "text_ce", + "bridge_ce", + "alignment_loss", + "alignment_all_mean", + "alignment_selected_mean", + "alignment_batch_mean", + "alignment_selected_count", + "alignment_denominator", +) + + +def make_specs(phase="development"): + """Return the proposed paired matrix without freezing files or starting jobs.""" + if phase not in ("development", "confirmation"): + raise ValueError("Phase must be development or confirmation") + worlds = [810011] if phase == "development" else [810101, 810102, 810103] + initializations = [811011] if phase == "development" else [811101, 811102] + base = { + "phase": phase, + "stream_seed": 812011 if phase == "development" else 812101, + "heads_n": 256, + "bridges_n": 128, + "tails_n": 64, + "familiar_n": 64, + "strict_n": 32, + "anchor_n": 32, + "holdout_fraction": 0.25, + "low_extra": "anchors", + "composition_count": 256, + "width": 128, + "heads": 4, + "layers": 1, + "repeats": 2, + "dropout": 0.0, + "batch_size": 192, + "lr": 0.001, + "weight_decay": 0.01, + "warmup": 200, + "schedule": "cosine", + "min_lr_ratio": 0.1, + "steps": 16000, + "nodes": [0, 256, 1000, 2000, 4000, 8000, 16000], + "bridge_weight": 0.3, + "alignment_weight": 0.3, + } + arms = ( + ("none", "none", "batch_mean"), + ("composition_batch", "composition_only", "batch_mean"), + ("composition_selected", "composition_only", "selected_mean"), + ("all_batch", "all_atomic_and_composition", "batch_mean"), + ) + return [ + { + **base, + "nodes": list(base["nodes"]), + "world": world, + "initialization": initialization, + "arm": arm, + "alignment_coverage": coverage, + "alignment_normalization": normalization, + } + for world in worlds + for initialization in initializations + for arm, coverage, normalization in arms + ] + + +def validate_spec(spec): + if spec["alignment_coverage"] not in COVERAGES: + raise ValueError(f"Unknown alignment coverage: {spec['alignment_coverage']}") + if spec["alignment_normalization"] not in NORMALIZATIONS: + raise ValueError(f"Unknown alignment normalization: {spec['alignment_normalization']}") + if spec["bridge_weight"] != 0.3: + raise ValueError("This comparison fixes all-example first-hop CE weight at 0.3") + if not np.isfinite(spec["alignment_weight"]) or spec["alignment_weight"] < 0: + raise ValueError("Alignment weight must be finite and nonnegative") + if spec["batch_size"] <= 0 or spec["batch_size"] % 3: + raise ValueError("Batch size must divide equally into the three fixed streams") + nodes = spec["nodes"] + if not nodes or nodes[0] != 0 or nodes[-1] != spec["steps"]: + raise ValueError("Nodes must include initialization and the fixed endpoint") + if nodes != sorted(set(nodes)) or any(type(n) is not int or n < 0 for n in nodes): + raise ValueError("Nodes must be strictly increasing nonnegative integer steps") + if spec["steps"] <= 0: + raise ValueError("Training needs a positive fixed step budget") + + +def pack_training(world, coverage): + """Keep base data byte-identical and append an explicit geometry mask.""" + if coverage not in COVERAGES: + raise ValueError(f"Unknown alignment coverage: {coverage}") + arrays, sizes = pack_base_training(world) + if min(sizes) <= 0: + raise ValueError("All three training strata must be nonempty") + mask = np.zeros(sum(sizes), dtype=np.float32) + if coverage == "composition_only": + mask[sizes[0] : sizes[0] + sizes[1]] = 1 + elif coverage == "all_atomic_and_composition": + mask[:] = 1 + return (*arrays, mask), sizes + + +def objective( + model, + tokens, + labels, + targets, + geometry_mask, + bridge_weight=0.3, + alignment_weight=0.3, + normalization="selected_mean", +): + """Return the training loss and named, unweighted objective components. + + selected_mean divides by selected examples (clamped to one for an empty + mask). batch_mean divides by all examples. Both reductions are always + evaluated, and mask coverage is recorded separately from loss strength. + """ + if normalization not in NORMALIZATIONS: + raise ValueError(f"Unknown alignment normalization: {normalization}") + logits, bridge = model(tokens, return_bridge=True) + text_ce = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + bridge_logits = F.linear(model.ln_final(bridge), model.token.weight) + bridge_ce = F.cross_entropy(bridge_logits, targets) + canonical = model.token(targets).detach() + per_example = (F.normalize(bridge, dim=-1) - F.normalize(canonical, dim=-1)).square().sum(-1) + mask = geometry_mask.to(dtype=per_example.dtype) + selected_count = mask.sum() + numerator = (per_example * mask).sum() + selected_denominator = selected_count.clamp_min(1) + # Avoid creating a device scalar from host data during CUDA graph capture. + batch_denominator = torch.ones_like(selected_count) * per_example.numel() + selected_mean = numerator / selected_denominator + batch_mean = numerator / batch_denominator + use_selected = float(normalization == "selected_mean") + denominator = use_selected * selected_denominator + (1 - use_selected) * batch_denominator + alignment = numerator / denominator + parts = torch.stack( + ( + text_ce, + bridge_ce, + alignment, + per_example.mean(), + selected_mean, + batch_mean, + selected_count, + denominator, + ) + ) + return text_ce + bridge_weight * bridge_ce + alignment_weight * alignment, parts + + +class CoverageStep(GraphStep): + def __init__(self, model, optimizer, table, batch_size, spec): + self.spec = spec + super().__init__(model, optimizer, table, batch_size) + + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + tokens, labels, targets, mask = (part[self.index] for part in self.table) + loss, self.components = objective( + self.model, + tokens, + labels, + targets, + mask, + self.spec["bridge_weight"], + self.spec["alignment_weight"], + self.spec["alignment_normalization"], + ) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def run_name(spec): + return ( + f"{spec['phase']}-w{spec['world']}-i{spec['initialization']}-" + f"{spec['alignment_coverage']}-{spec['alignment_normalization']}" + ) + + +def _draw_indices(streams, offsets, counts, steps, batch_size): + indices = [] + for j, stream in enumerate(streams): + drawn = stream.take(steps * batch_size // 3).reshape(steps, -1) + counts[j] += np.bincount(drawn.ravel(), minlength=len(counts[j])) + indices.append(drawn + offsets[j]) + return np.concatenate(indices, axis=1) + + +def _coverage_presentations(counts, mask, sizes): + offset, result = 0, {} + for name, count, size in zip(STRATA, counts, sizes, strict=True): + result[name] = int(np.dot(count, mask[offset : offset + size].astype(np.int64))) + offset += size + result["total"] = sum(result.values()) + return result + + +def train(spec, out, source, device): + """Train one immutable attempt; save weights and exposures at every node.""" + validate_spec(spec) + out, device = Path(out), torch.device(device) + out.mkdir(parents=True, exist_ok=True) + if any((out / name).exists() for name in ("run.json", "model.pt", "complete.json")): + raise FileExistsError(f"Do not overwrite an attempt: {out}") + if device.type != "cuda": + raise ValueError("The captured training step requires an explicitly allocated CUDA device") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(device) + started = time.perf_counter() + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + arrays, sizes = pack_training(world, spec["alignment_coverage"]) + mask = arrays[-1] + model = new_model(spec, device) + initial_hash, world_hash = model_digest(model), data_digest(world) + identity = { + "spec": spec, + "source": source, + "implementation_sha256": file_hash(Path(__file__)), + "world_sha256": world_hash, + "initial_model_sha256": initial_hash, + } + write_json( + out / "run.json", + { + **identity, + "pid": os.getpid(), + "gpu": device.index, + "gpu_name": torch.cuda.get_device_name(device), + "dtype": "float32", + "allow_tf32": True, + "parameters": sum(p.numel() for p in model.parameters()), + "atomic_examples": sizes[0] + sizes[2], + "composition_examples": sizes[1], + "vocab_size": model.config.vocab_size, + "strata": dict(zip(STRATA, sizes, strict=True)), + "geometry_unique_examples": _coverage_presentations( + [np.ones(n, dtype=np.int64) for n in sizes], mask, sizes + ), + "geometry_definition": ( + "squared distance of normalized early state and detached input embedding" + ), + "bridge_ce_coverage": "all_atomic_and_composition", + "geometry_normalization": spec["alignment_normalization"], + "tracking_owner": "external read-only batch runner", + }, + ) + table = tuple(torch.as_tensor(a, device=device) for a in arrays) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + model.train() + graph = CoverageStep(model, optimizer, table, spec["batch_size"], spec) + assert model_digest(model) == initial_hash, "CUDA capture changed initialization" + streams = [EpochStream(n, spec["stream_seed"] + j) for j, n in enumerate(sizes)] + offsets = np.cumsum([0, *sizes[:-1]]) + counts = [np.zeros(n, dtype=np.int64) for n in sizes] + input_hash = hashlib.sha256() + history, checkpoints, step, training_seconds = [], [], 0, 0.0 + flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 9, output_positions=9) + flop_step += 6 * spec["batch_size"] * model.config.width * model.config.vocab_size + + def measure(): + metrics, predictions = evaluate(model, world, "low", device) + parts = graph.components.detach().cpu().tolist() if step else [None] * len(COMPONENTS) + coverage = _coverage_presentations(counts, mask, sizes) + row = { + "step": step, + "metrics": metrics, + **dict(zip(COMPONENTS, parts, strict=True)), + "alignment_normalization": spec["alignment_normalization"], + "alignment_weight": spec["alignment_weight"], + "geometry_target_presentations": coverage, + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "examples": step * spec["batch_size"], + "supervised_tokens": step * spec["batch_size"] // 3 * (7 + 9 + 7), + "auxiliary_target_presentations": step * spec["batch_size"], + "estimated_matmul_training_flops": step * flop_step, + "composition_epochs": step * spec["batch_size"] / 3 / sizes[1], + "sample_stream_sha256": input_hash.hexdigest(), + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + np.savez_compressed( + out / f"exposures-{step:06d}.npz", **{f"stratum{j}": c for j, c in enumerate(counts)} + ) + checkpoint = out / f"model-{step:06d}.pt" + torch.save( + { + **identity, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "sample_stream_sha256": input_hash.hexdigest(), + "geometry_target_presentations": coverage, + }, + checkpoint, + ) + checkpoints.append({"step": step, "file": checkpoint.name, "sha256": file_hash(checkpoint)}) + write_json(out / "checkpoints.json", checkpoints) + write_json(out / "status.json", {"state": "running", "step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["common_atomic"]["accuracy"], + "train": metrics["train_composite"]["accuracy"], + "familiar": metrics["familiar_test"]["accuracy"], + "strict": metrics["strict_test"]["accuracy"], + } + ), + flush=True, + ) + model.train() + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize(device) + began = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = _draw_indices(streams, offsets, counts, n, spec["batch_size"]) + input_hash.update(indices.tobytes()) + indices = torch.as_tensor(indices, device=device) + for j in range(n): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += n + torch.cuda.synchronize(device) + training_seconds += time.perf_counter() - began + if not np.isfinite(float(loss)): + raise FloatingPointError(f"Nonfinite objective at {step}") + measure() + # Keep the established downstream loader interface on filesystems without links. + shutil.copyfile(out / f"model-{step:06d}.pt", out / "model.pt") + np.savez_compressed(out / "exposures.npz", **{f"stratum{j}": c for j, c in enumerate(counts)}) + write_json( + out / "complete.json", + { + **identity, + "finished_utc": utc(), + "metrics": history[-1]["metrics"], + "training_seconds": training_seconds, + "sample_stream_sha256": input_hash.hexdigest(), + "geometry_target_presentations": history[-1]["geometry_target_presentations"], + "model_sha256": file_hash(out / "model.pt"), + "nodes_saved": spec["nodes"], + }, + ) + write_json(out / "status.json", {"state": "complete", "step": step}) + + +def audit(out, device, *, all_nodes=False): + """Verify all artifacts; independently reload the endpoint (or all nodes).""" + out, device = Path(out), torch.device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + if device.type == "cuda": + torch.cuda.set_device(device) + run = json.loads((out / "run.json").read_text()) + complete = json.loads((out / "complete.json").read_text()) + history = json.loads((out / "learning.json").read_text()) + manifest = json.loads((out / "checkpoints.json").read_text()) + spec = run["spec"] + validate_spec(spec) + assert spec == complete["spec"] + assert [row["step"] for row in history] == spec["nodes"] + assert [entry["step"] for entry in manifest] == spec["nodes"] + assert complete["nodes_saved"] == spec["nodes"] + assert file_hash(out / "model.pt") == complete["model_sha256"] == manifest[-1]["sha256"] + world = build_world(spec) + assert data_digest(world) == run["world_sha256"] == complete["world_sha256"] + with np.load(out / "world.npz") as saved_world: + assert set(saved_world.files) == set(world) + for key, value in world.items(): + np.testing.assert_array_equal(value, saved_world[key]) + arrays, sizes = pack_training(world, spec["alignment_coverage"]) + mask, offsets = arrays[-1], np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(n, spec["stream_seed"] + j) for j, n in enumerate(sizes)] + counts = [np.zeros(n, dtype=np.int64) for n in sizes] + input_hash, step, audits = hashlib.sha256(), 0, [] + model = new_model(spec, device) + assert model_digest(model) == run["initial_model_sha256"] == complete["initial_model_sha256"] + for entry, row in zip(manifest, history, strict=True): + while step < entry["step"]: + n = min(128, entry["step"] - step) + indices = _draw_indices(streams, offsets, counts, n, spec["batch_size"]) + input_hash.update(indices.tobytes()) + step += n + checkpoint = out / entry["file"] + assert file_hash(checkpoint) == entry["sha256"] + payload = torch.load(checkpoint, map_location="cpu", weights_only=False) + assert payload["spec"] == spec and payload["step"] == step + for key in ("source", "implementation_sha256", "world_sha256", "initial_model_sha256"): + assert payload[key] == run[key] == complete[key] + assert ( + payload["sample_stream_sha256"] == row["sample_stream_sha256"] == input_hash.hexdigest() + ) + coverage = _coverage_presentations(counts, mask, sizes) + assert ( + payload["geometry_target_presentations"] + == row["geometry_target_presentations"] + == coverage + ) + with np.load(out / f"exposures-{step:06d}.npz") as saved_counts: + for j, count in enumerate(counts): + np.testing.assert_array_equal(count, saved_counts[f"stratum{j}"]) + np.testing.assert_array_equal(count, payload["counts"][j]) + if step == 0: + model.load_state_dict(payload["model"]) + assert model_digest(model) == run["initial_model_sha256"] + if not all_nodes and step != spec["steps"]: + audits.append({"step": step, "passed": True, "predictions_recomputed": False}) + continue + model.load_state_dict(payload["model"]) + metrics, predictions = evaluate(model, world, "low", device) + max_nll_error = 0.0 + with np.load(out / f"predictions-{step:06d}.npz") as saved: + assert set(saved.files) == set(predictions) + for key, actual in predictions.items(): + if key.endswith("nll"): + max_nll_error = max(max_nll_error, float(np.max(np.abs(actual - saved[key])))) + np.testing.assert_allclose(actual, saved[key], rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(actual, saved[key]) + for split, values in metrics.items(): + for key, actual in values.items(): + expected = row["metrics"][split][key] + if actual is None: + assert expected is None + else: + np.testing.assert_allclose(actual, expected, rtol=1e-5, atol=1e-5) + audits.append( + { + "step": step, + "passed": True, + "predictions_recomputed": True, + "max_nll_error": max_nll_error, + } + ) + assert complete["sample_stream_sha256"] == input_hash.hexdigest() + assert complete["geometry_target_presentations"] == _coverage_presentations(counts, mask, sizes) + with np.load(out / "exposures.npz") as saved_counts: + for j, count in enumerate(counts): + np.testing.assert_array_equal(count, saved_counts[f"stratum{j}"]) + result = { + "passed": True, + "metrics": metrics, + "nodes": audits, + "max_nll_error": max(a.get("max_nll_error", 0.0) for a in audits), + "all_nodes": all_nodes, + "allow_tf32": True, + "world_sha256": data_digest(world), + "sample_stream_sha256": input_hash.hexdigest(), + "geometry_target_presentations": _coverage_presentations(counts, mask, sizes), + } + write_json(out / "audit.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..3d611f12f7be01721c8f453b8981605455e4b585 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge.py @@ -0,0 +1,549 @@ +"""Paired interventions on MLP output and same-layer sequence cache. + +Oracle bridge hints define an assisted diagnostic, not an identified natural +reasoning circuit. Cache interventions do not change model parameters. +""" + +from __future__ import annotations + +import contextlib +import copy +import hashlib +import json +import re +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch + +ROOT = Path(__file__).resolve().parents[2] +DATA = ROOT / "data/architecture-bridge-v1" +ART = ROOT / "docs/development-artifacts/architecture-bridge-v1" +RESULTS = ROOT / "results/architecture-bridge-v1" +CONFIG = ROOT / "configs/architecture-bridge-v1.json" + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temp = path.with_suffix(path.suffix + ".tmp") + temp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n") + temp.replace(path) + + +def digest(path): + h = hashlib.sha256() + with Path(path).open("rb") as f: + for block in iter(lambda: f.read(1024 * 1024), b""): + h.update(block) + return h.hexdigest() + + +def order(value): + return hashlib.sha256(f"142935:{value}".encode()).hexdigest() + + +def normalize(value): + import string + + value = value.lower().translate(str.maketrans("", "", string.punctuation)) + return " ".join(re.sub(r"\b(a|an|the)\b", " ", value).split()) + + +def grade(text, answer, aliases=()): + value = text.rsplit("Final answer:", 1)[-1].strip() + value = re.sub(r"^(?:Answer|Bridge):\s*", "", value, flags=re.I).strip().strip('"*') + predicted, gold = normalize(value), normalize(answer) + a, b = Counter(predicted.split()), Counter(gold.split()) + common = sum((a & b).values()) + return { + "em": predicted == gold, + "f1": 2 * common / (sum(a.values()) + sum(b.values())) if common else 0.0, + "alias_em": predicted in {normalize(x) for x in [answer, *aliases]}, + } + + +def base_prompt(row, question=None): + context = row.get("support_context", "") + parts = ["Question: What is 2 + 2?\nAnswer: 4", "Output only the short answer."] + if context: + parts.append("Use the supplied passages.\nPassages:\n" + context) + parts.append("Question: " + (question if question is not None else row["question"])) + return "\n\n".join(parts) + + +def prefix(row, bridge): + return base_prompt(row) + "\nIntermediate entity: " + bridge + "\n" + + +def prepare(): + from transformers import AutoTokenizer + + if (ART / "data-lock.json").exists(): + raise FileExistsError("This data selection is already frozen") + cfg = read(CONFIG) + toks = { + k: AutoTokenizer.from_pretrained(ROOT / v["path"], local_files_only=True) + for k, v in cfg["models"].items() + } + source_path = ROOT / "data/twohop-frozen-v1/cases.json" + source, selected, audit = read(source_path), [], {} + for dataset in cfg["datasets"]: + for split, count in cfg["cases_per_dataset"].items(): + pool = sorted( + [x for x in source if x["dataset"] == dataset and x["split"] == split], + key=lambda x: order(x["id"]), + ) + for row in pool[:count]: + r = copy.deepcopy(row) + names = sorted({p["bridge"] for p in pool}, key=order) + forbidden = {normalize(x) for x in [r["bridge"], *r.get("bridge_aliases", [])]} + gold = {normalize(x) for x in [r["answer"], *r.get("aliases", [])]} + target = {k: len(t.encode(prefix(r, r["bridge"]))) for k, t in toks.items()} + chosen = [] + for name in names: + norm = normalize(name) + if norm in forbidden or any(g and g in norm for g in gold): + continue + if all(len(t.encode(prefix(r, name))) == target[k] for k, t in toks.items()): + chosen.append(name) + if len(chosen) == 2: + break + reason = None + if len(chosen) < 2: + reason = "fewer_than_two_length_matched_wrong_bridges" + if max(target.values()) > cfg["max_prefix_tokens"]: + reason = "prefix_exceeds_budget" + if any(g and g in normalize(r["bridge"]) for g in gold): + reason = "correct_bridge_contains_final_answer" + competitors = [ + x["answer"] for x in pool if normalize(x["answer"]) != normalize(r["answer"]) + ] + r.update( + prefix_tokens=target, + corrupted_bridge=chosen[0] if chosen else None, + control_bridge=chosen[1] if len(chosen) > 1 else None, + exclusion_reason=reason, + competitor=(r.get("wrong_donor") or {}).get("answer", competitors[0]), + ) + selected.append(r) + audit[f"{dataset}:{split}"] = { + "selected": count, + "eligible": sum( + x["exclusion_reason"] is None + for x in selected + if x["dataset"] == dataset and x["split"] == split + ), + } + # E comes from selected evaluation rows; R and U are independent source groups + # from the unused historical pool. D is never used to choose a direction. + edits = [r for r in selected if r["dataset"] == "2wiki" and r["split"] == "evaluation"] + used = {r["group"] for r in selected if r["dataset"] == "2wiki"} + reserves = sorted( + [ + r + for r in source + if r["dataset"] == "2wiki" and r["split"] == "evaluation" and r["group"] not in used + ], + key=lambda r: order("keep:" + r["id"]), + ) + lc = cfg["local_learning"] + learning = { + "E": edits[: lc["episodes"]], + "R": reserves[: lc["keep_R"]], + "U": reserves[lc["keep_R"] : lc["keep_R"] + lc["unseen_U"]], + } + assert len(learning["U"]) == lc["unseen_U"] + write(DATA / "cases.json", selected) + write(DATA / "learning.json", learning) + write( + ART / "data-lock.json", + { + "config": cfg, + "config_sha256": digest(CONFIG), + "source_sha256": digest(source_path), + "cases_sha256": digest(DATA / "cases.json"), + "learning_sha256": digest(DATA / "learning.json"), + "audit": audit, + "selection": ( + "Fixed hash before outputs; excluded cases are retained without replacement." + ), + }, + ) + return audit + + +def cache_fields(cache, layer): + obj = cache.layers[layer] + if hasattr(obj, "recurrent_states"): + return [("conv_states", 0), ("recurrent_states", 0)] + return [("keys", None), ("values", None)] + + +def field_get(obj, name, index): + value = getattr(obj, name) + return value if index is None else value[index] + + +def field_set(obj, name, index, value): + if index is None: + setattr(obj, name, value) + else: + getattr(obj, name)[index] = value + + +def matched_random(delta, seed): + generator = torch.Generator(device=delta.device).manual_seed(seed) + random = torch.randn(delta.shape, device=delta.device, dtype=delta.dtype, generator=generator) + return random * (delta.norm() / random.norm().clamp_min(torch.finfo(delta.dtype).tiny)) + + +def change_cache(target, donor, layer, random_seed=None): + # Keep recipient metadata and update only equal-shaped tensors. Prefix length + # and token positions are identical across donors in the frozen selection. + stats = {} + for i, (name, index) in enumerate(cache_fields(target, layer)): + a = field_get(target.layers[layer], name, index) + b = field_get(donor.layers[layer], name, index) + if a.shape != b.shape: + raise ValueError(f"Unequal cache shapes for {name}: {a.shape} != {b.shape}") + delta = b - a + if random_seed is not None: + delta = matched_random(delta, random_seed + i) + stats[name + "_delta_norm"] = float(delta.norm()) + field_set( + target.layers[layer], name, index, b.clone() if random_seed is None else a + delta + ) + return stats + + +class Engine: + def __init__(self, key, device=None): + from transformers import ( + AutoTokenizer, + PreTrainedTokenizerFast, + Qwen3_5ForCausalLM, + Qwen3ForCausalLM, + ) + + self.cfg = read(CONFIG) + self.key, self.mc = key, self.cfg["models"][key] + self.device = torch.device(device or self.cfg["device"]) + torch.set_num_threads(2) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + if self.device.type == "cuda": + torch.cuda.set_per_process_memory_fraction(self.cfg["gpu_memory_fraction"], self.device) + cls = Qwen3ForCausalLM if key == "qwen3" else Qwen3_5ForCausalLM + # In transformers 5.17 Qwen2Tokenizer rebuilds Qwen3.5's regex and drops + # Unicode combining marks. Load the official tokenizer.json unchanged. + tokenizer_cls = AutoTokenizer if key == "qwen3" else PreTrainedTokenizerFast + self.tok = tokenizer_cls.from_pretrained(ROOT / self.mc["path"], local_files_only=True) + self.model = ( + cls.from_pretrained( + ROOT / self.mc["path"], + local_files_only=True, + dtype=torch.float32, + attn_implementation="eager", + ) + .to(self.device) + .eval() + .requires_grad_(False) + ) + self.layers = self.model.model.layers + self.stats = Counter() + self.eos = self.tok.eos_token_id + + def ids(self, text): + return torch.tensor([self.tok.encode(text, add_special_tokens=False)], device=self.device) + + def forward(self, ids, cache=None, total=None): + total = ids.shape[1] if total is None else total + self.stats["forward_calls"] += 1 + self.stats["input_tokens"] += ids.numel() + return self.model( + input_ids=ids, + attention_mask=torch.ones((1, total), device=self.device, dtype=torch.long), + past_key_values=cache, + use_cache=True, + logits_to_keep=1, + ) + + @contextlib.contextmanager + def mlp_hook(self, layer, replacement=None, capture=None): + def hook(module, args, output): + if capture is not None: + capture[layer] = output[0, -1].detach().clone() + if replacement is None: + return None + modified = output.clone() + modified[0, -1] = replacement + return modified + + handle = self.layers[layer].mlp.register_forward_hook(hook) + try: + yield + finally: + handle.remove() + + @torch.no_grad() + def prefill(self, text, layer=None, replacement=None): + ids, captured = self.ids(text), {} + if ids.shape[1] > self.cfg["max_prefix_tokens"]: + raise ValueError("Prefix exceeds budget; truncation is forbidden") + with contextlib.ExitStack() as stack: + for li in self.mc["layers"]: + stack.enter_context( + self.mlp_hook(li, replacement if li == layer else None, captured) + ) + out = self.forward(ids) + return out.past_key_values, captured, ids.shape[1] + + @torch.no_grad() + def continuation_score(self, logits, cache, total, answer): + targets = self.tok.encode(" " + answer, add_special_tokens=False) + [self.eos] + values = [] + for index, token in enumerate(targets): + values.append(float(logits[0, -1].log_softmax(-1)[token])) + if index + 1 < len(targets): + total += 1 + out = self.forward(torch.tensor([[token]], device=self.device), cache, total) + logits, cache = out.logits, out.past_key_values + return {"sum_logp": sum(values), "mean_logp": float(np.mean(values)), "tokens": targets} + + @torch.no_grad() + def finish(self, cache, n_prefix, row, suffix=None): + suffix_ids = self.ids(self.cfg["suffix"] if suffix is None else suffix) + total = n_prefix + suffix_ids.shape[1] + out = self.forward(suffix_ids, cache, total) + logits, cache = out.logits, out.past_key_values + scores = {} + for name, answer in [("correct", row["answer"]), ("competitor", row["competitor"])]: + scores[name] = self.continuation_score(logits, copy.deepcopy(cache), total, answer) + scores["margin"] = scores["correct"]["mean_logp"] - scores["competitor"]["mean_logp"] + tokens = [] + for _ in range(self.cfg["generation_tokens"]): + token = int(logits[0, -1].argmax()) + tokens.append(token) + if token == self.eos: + break + total += 1 + out = self.forward(torch.tensor([[token]], device=self.device), cache, total) + logits, cache = out.logits, out.past_key_values + text = self.tok.decode(tokens, skip_special_tokens=True) + self.stats["generated_tokens"] += len(tokens) + return { + "text": text, + "tokens": tokens, + "ended_eos": tokens[-1] == self.eos, + **grade(text, row["answer"], row.get("unambiguous_aliases", row.get("aliases", []))), + "scores": scores, + } + + def direct(self, row, question=None, answer=None): + qrow = dict(row) + if answer is not None: + qrow.update(answer=answer, aliases=[], unambiguous_aliases=[]) + cache, _, length = self.prefill(base_prompt(row, question)) + return self.finish(cache, length, qrow) + + @torch.no_grad() + def case(self, row): + started = time.monotonic() + before_stats = self.stats.copy() + result = { + "id": row["id"], + "dataset": row["dataset"], + "split": row["split"], + "group": row["group"], + "exclusion_reason": row["exclusion_reason"], + "unassisted": self.direct(row), + "first_hop": self.direct(row, row["q1"], row["bridge"]), + "second_hop": self.direct(row, row["q2"]), + "interventions": [], + } + if row["exclusion_reason"]: + result["seconds"] = time.monotonic() - started + result["resources"] = dict(self.stats - before_stats) + return result + caches, activations, lengths = {}, {}, {} + for name, bridge in [ + ("correct", row["bridge"]), + ("corrupt", row["corrupted_bridge"]), + ("wrong", row["control_bridge"]), + ]: + caches[name], activations[name], lengths[name] = self.prefill(prefix(row, bridge)) + if len(set(lengths.values())) != 1: + raise AssertionError("Token-length matching contract broken") + n = lengths["corrupt"] + if n != row["prefix_tokens"][self.key]: + raise AssertionError("Tokenizer revision changed the frozen prefix length") + result["oracle_input"] = self.finish(copy.deepcopy(caches["correct"]), n, row) + for layer in self.mc["layers"]: + baseline = None + for condition in self.cfg["conditions"]: + donor = "wrong" if condition.endswith("wrong") else "correct" + seed = int(order(row["id"] + str(layer))[:8], 16) + use_mlp = condition.startswith(("mlp_", "joint_")) + use_state = condition.startswith(("state_", "joint_")) + stats = {} + if use_mlp: + delta = activations[donor][layer] - activations["corrupt"][layer] + if condition.endswith("random"): + delta = matched_random(delta, seed) + replacement = ( + activations["corrupt"][layer] + delta + if condition.endswith("random") + else activations[donor][layer] + ) + stats["mlp_delta_norm"] = float(delta.norm()) + cache, _, _ = self.prefill( + prefix(row, row["corrupted_bridge"]), layer, replacement + ) + else: + cache = copy.deepcopy(caches["corrupt"]) + if use_state or condition == "identity": + source = caches["corrupt"] if condition == "identity" else caches[donor] + stats.update( + change_cache( + cache, source, layer, seed + 1 if condition.endswith("random") else None + ) + ) + prediction = self.finish(cache, n, row) + if condition == "baseline": + baseline = prediction + if condition == "identity": + if prediction["tokens"] != baseline["tokens"]: + raise AssertionError("Identity cache changed generated tokens") + if abs(prediction["scores"]["margin"] - baseline["scores"]["margin"]) > 1e-5: + raise AssertionError("Identity cache changed scores") + result["interventions"].append( + { + "layer": layer, + "condition": condition, + "cache_kind": self.mc["kind"], + **stats, + **prediction, + } + ) + result["seconds"] = time.monotonic() - started + result["resources"] = dict(self.stats - before_stats) + return result + + def prompt_suffix_ids(self, prompt): + # Match prefill(prompt) followed by finish(suffix), including BPE boundaries. + return torch.cat([self.ids(prompt), self.ids(self.cfg["suffix"])], dim=1) + + def next_logits(self, prompt): + ids = self.prompt_suffix_ids(prompt) + self.stats["forward_calls"] += 1 + self.stats["input_tokens"] += ids.numel() + if torch.is_grad_enabled(): + self.stats["backward_input_tokens"] += ids.numel() + return self.model(input_ids=ids, use_cache=False, logits_to_keep=1).logits[0, -1] + + def target_loss(self, row): + x = self.prompt_suffix_ids(base_prompt(row, row["q1"])) + target = self.tok.encode(" " + row["bridge"], add_special_tokens=False) + [self.eos] + y = torch.tensor([target], device=self.device) + inputs = torch.cat([x, y[:, :-1]], dim=1) + self.stats["forward_calls"] += 1 + self.stats["input_tokens"] += inputs.numel() + self.stats["backward_input_tokens"] += inputs.numel() + self.stats["supervised_tokens"] += y.numel() + logits = self.model(input_ids=inputs, use_cache=False, logits_to_keep=len(target)).logits + return torch.nn.functional.cross_entropy(logits.flatten(0, 1), y.flatten()) + + def learning(self, episode, output_dir): + before_stats = self.stats.copy() + lc = self.cfg["local_learning"] + pools = read(DATA / "learning.json") + target = pools["E"][episode] + parameter = self.layers[lc["layer"]].mlp.down_proj.weight + original = parameter.detach().clone() + teacher = {} + for role in ["R", "U"]: + with torch.no_grad(): + teacher[role] = [ + self.next_logits(base_prompt(r, r["q1"])).log_softmax(-1).detach() + for r in pools[role] + ] + result = {"episode": episode, "target_id": target["id"], "nodes": [], "training": []} + started = time.monotonic() + try: + parameter.requires_grad_(True) + optimizer = torch.optim.SGD([parameter], lr=lc["lr"]) + for step in range(lc["steps"] + 1): + if step in lc["nodes"]: + node = { + "step": step, + "E": self.direct(target, target["q1"], target["bridge"]), + "D": self.direct(target), + "R": [], + "U": [], + "parameter_delta_norm": float((parameter.detach() - original).norm()), + } + for role in ["R", "U"]: + for r, old_lp in zip(pools[role], teacher[role], strict=True): + r = dict(r, competitor=target["bridge"]) + with torch.no_grad(): + lp = self.next_logits(base_prompt(r, r["q1"])).log_softmax(-1) + kl = float((old_lp.exp() * (old_lp - lp)).sum()) + node[role].append( + { + "id": r["id"], + "kl": kl, + **self.direct(r, r["q1"], r["bridge"]), + } + ) + result["nodes"].append(node) + write(output_dir / "progress.json", result) + if step == lc["steps"]: + break + optimizer.zero_grad(set_to_none=True) + loss = self.target_loss(target) + target_value = float(loss.detach()) + loss.backward() + replay_value = 0.0 + for r, old_lp in zip(pools["R"], teacher["R"], strict=True): + lp = self.next_logits(base_prompt(r, r["q1"])).log_softmax(-1) + kl = (old_lp.exp() * (old_lp - lp)).sum() + replay_value += float(kl.detach()) / len(pools["R"]) + (lc["replay_KL_weight"] * kl / len(pools["R"])).backward() + norm = float(torch.nn.utils.clip_grad_norm_([parameter], lc["gradient_clip"])) + if not np.isfinite(target_value + replay_value + norm): + raise FloatingPointError("Nonfinite local learning response") + optimizer.step() + result["training"].append( + { + "step": step + 1, + "target_ce": target_value, + "R_kl": replay_value, + "gradient_norm": norm, + } + ) + torch.save( + { + "down_weight": parameter.detach().cpu(), + "target_id": target["id"], + "layer": lc["layer"], + "steps": lc["steps"], + }, + output_dir / "endpoint.pt", + ) + finally: + with torch.no_grad(): + parameter.copy_(original) + parameter.requires_grad_(False) + if not torch.equal(parameter, original): + raise AssertionError("Episode failed to restore original weight") + result["seconds"] = time.monotonic() - started + result["restored_original"] = True + result["resources"] = dict(self.stats - before_stats) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge_toy.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge_toy.py new file mode 100644 index 0000000000000000000000000000000000000000..a406337c9f1b455c1c07183ec90de18541f7d03b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/architecture_bridge_toy.py @@ -0,0 +1,410 @@ +"""A frozen small GQA / gated-delta mechanism experiment. + +Both models use RMSNorm, SwiGLU and tied token embeddings. The hybrid is a +deliberately small mechanism model, NOT an implementation of any Qwen release. +Its delta mixer has a genuine recurrent matrix, causal q/k/v convolution, +normalized q/k, input-dependent decay/write gates, and a headwise output gate. +""" + +from __future__ import annotations + +import hashlib +import math +from pathlib import Path + +import numpy as np +import torch +from torch import nn +from torch.nn import functional as F + +from llm_memory_editability.twohop_depth import BOS, ENTITY, EOS + + +class RMSNorm(nn.Module): + def __init__(self, width, eps): + super().__init__() + self.weight = nn.Parameter(torch.ones(width)) + self.eps = eps + + def forward(self, x): + return x * torch.rsqrt(x.square().mean(-1, keepdim=True) + self.eps) * self.weight + + +def rope(x, offset): + """Full rotary position embedding; head width is even.""" + width = x.shape[-1] + positions = torch.arange(offset, offset + x.shape[-2], device=x.device, dtype=x.dtype) + inverse = 10000.0 ** (-torch.arange(0, width, 2, device=x.device, dtype=x.dtype) / width) + phase = positions[:, None] * inverse[None, :] + even, odd = x[..., 0::2], x[..., 1::2] + return torch.stack( + (even * phase.cos() - odd * phase.sin(), even * phase.sin() + odd * phase.cos()), + dim=-1, + ).flatten(-2) + + +class GQA(nn.Module): + def __init__(self, cfg): + super().__init__() + width, self.heads, self.kv_heads = cfg["width"], cfg["heads"], cfg["kv_heads"] + self.dim = width // self.heads + self.q = nn.Linear(width, width, bias=False) + self.k = nn.Linear(width, self.kv_heads * self.dim, bias=False) + self.v = nn.Linear(width, self.kv_heads * self.dim, bias=False) + self.out = nn.Linear(width, width, bias=False) + self.q_norm = RMSNorm(self.dim, cfg["norm_eps"]) + self.k_norm = RMSNorm(self.dim, cfg["norm_eps"]) + + def forward(self, x, cache=None): + batch, length, width = x.shape + offset = 0 if cache is None else cache["k"].shape[2] + q = self.q(x).view(batch, length, self.heads, self.dim).transpose(1, 2) + k = self.k(x).view(batch, length, self.kv_heads, self.dim).transpose(1, 2) + v = self.v(x).view(batch, length, self.kv_heads, self.dim).transpose(1, 2) + q, k = rope(self.q_norm(q), offset), rope(self.k_norm(k), offset) + if cache is not None: + k, v = torch.cat((cache["k"], k), 2), torch.cat((cache["v"], v), 2) + new_cache = {"k": k, "v": v} + repeat = self.heads // self.kv_heads + keys, values = k.repeat_interleave(repeat, 1), v.repeat_interleave(repeat, 1) + scores = (q @ keys.transpose(-2, -1)) / math.sqrt(self.dim) + allowed = ( + torch.arange(k.shape[2], device=x.device)[None, :] + <= torch.arange(offset, offset + length, device=x.device)[:, None] + ) + scores = scores.masked_fill(~allowed, float("-inf")) + out = (scores.softmax(-1) @ values).transpose(1, 2).reshape(batch, length, width) + return self.out(out), new_cache + + +class GatedDelta(nn.Module): + def __init__(self, cfg): + super().__init__() + width, self.heads = cfg["width"], cfg["heads"] + self.dim, self.kernel = width // self.heads, cfg["conv_kernel"] + self.qkv = nn.Linear(width, 3 * width, bias=False) + self.conv_weight = nn.Parameter(torch.empty(self.kernel, 3 * width)) + self.decay = nn.Linear(width, self.heads, bias=True) + self.write = nn.Linear(width, self.heads, bias=True) + self.gate = nn.Linear(width, self.heads, bias=True) + self.out_norm = RMSNorm(self.dim, cfg["norm_eps"]) + self.out = nn.Linear(width, width, bias=False) + + def forward(self, x, cache=None): + batch, length, width = x.shape + raw = self.qkv(x) + if cache is None: + history = raw.new_zeros(batch, self.kernel - 1, 3 * width) + state = raw.new_zeros(batch, self.heads, self.dim, self.dim) + else: + history, state = cache["conv"], cache["state"] + full = torch.cat((history, raw), 1) + convolved = sum(full[:, j : j + length] * self.conv_weight[j] for j in range(self.kernel)) + q, k, v = F.silu(convolved).chunk(3, -1) + q = F.normalize(q.view(batch, length, self.heads, self.dim), dim=-1, eps=1e-6) + k = F.normalize(k.view(batch, length, self.heads, self.dim), dim=-1, eps=1e-6) + v = v.view(batch, length, self.heads, self.dim) + alpha = torch.exp(-F.softplus(self.decay(x))) + beta, gate = self.write(x).sigmoid(), self.gate(x).sigmoid() + outputs = [] + for t in range(length): + # S_t = alpha S_(t-1)(I-beta kk^T) + beta vk^T. + state = alpha[:, t, :, None, None] * state + read_at_key = (state * k[:, t, :, None, :]).sum(-1) + error = v[:, t] - read_at_key + state = state + beta[:, t, :, None, None] * (error[..., :, None] * k[:, t, :, None, :]) + outputs.append((state * q[:, t, :, None, :]).sum(-1)) + out = self.out_norm(torch.stack(outputs, 1)) * gate[..., None] + new_cache = {"conv": full[:, -(self.kernel - 1) :], "state": state} + return self.out(out.reshape(batch, length, width)), new_cache + + +class SwiGLU(nn.Module): + def __init__(self, cfg): + super().__init__() + self.up = nn.Linear(cfg["width"], cfg["mlp_hidden"], bias=False) + self.gate = nn.Linear(cfg["width"], cfg["mlp_hidden"], bias=False) + self.down = nn.Linear(cfg["mlp_hidden"], cfg["width"], bias=False) + + def forward(self, x): + return self.down(self.up(x) * F.silu(self.gate(x))) + + +class Block(nn.Module): + def __init__(self, kind, cfg): + super().__init__() + self.norm_mixer = RMSNorm(cfg["width"], cfg["norm_eps"]) + self.mixer = GQA(cfg) if kind == "gqa" else GatedDelta(cfg) + self.norm_mlp = RMSNorm(cfg["width"], cfg["norm_eps"]) + self.mlp = SwiGLU(cfg) + + +def apply_patch(output, patch): + if patch is None: + return output + result = output.clone() + result[:, patch["positions"]] = patch["value"].to(output) + return result + + +class ToyLM(nn.Module): + def __init__(self, architecture, cfg): + super().__init__() + self.config = cfg + self.architecture = architecture + self.token = nn.Embedding(ENTITY + cfg["entities"] + cfg["relations"], cfg["width"]) + self.blocks = nn.ModuleList(Block(kind, cfg) for kind in architecture["mixers"]) + self.norm_final = RMSNorm(cfg["width"], cfg["norm_eps"]) + + def forward( + self, tokens, positions=None, *, cache=None, patches=None, capture=False, return_cache=False + ): + h, states, trace = self.token(tokens), [], {} + patches = {} if patches is None else patches + for layer, block in enumerate(self.blocks): + past = None if cache is None else cache[layer] + mixer, state = block.mixer(block.norm_mixer(h), past) + mixer = apply_patch(mixer, patches.get(("mixer", layer))) + h = h + mixer + mlp = apply_patch(block.mlp(block.norm_mlp(h)), patches.get(("mlp", layer))) + h = h + mlp + states.append(state) + if capture: + trace[("mixer", layer)], trace[("mlp", layer)] = mixer, mlp + h = self.norm_final(h) + if positions is not None: + h = h[torch.arange(len(h), device=h.device)[:, None], positions] + logits = F.linear(h, self.token.weight) + return (logits, states, trace) if capture or return_cache else logits + + +def initialize(model, seed): + """Pair every common named and shaped parameter without RNG-order effects.""" + with torch.no_grad(): + for name, parameter in model.named_parameters(): + if name.endswith(".bias"): + parameter.zero_() + elif "norm" in name and name.endswith(".weight"): + parameter.fill_(1) + else: + key = hashlib.sha256(f"{seed}:{name}".encode()).digest() + generator = torch.Generator().manual_seed(int.from_bytes(key[:8], "little")) + std = 0.02 + if name.endswith("mixer.out.weight") or name.endswith("mlp.down.weight"): + std /= math.sqrt(2 * len(model.blocks)) + parameter.copy_(torch.randn(parameter.shape, generator=generator) * std) + + +def parameter_digest(model): + h = hashlib.sha256() + for name, parameter in model.named_parameters(): + h.update(name.encode()) + h.update(parameter.detach().cpu().contiguous().numpy().tobytes()) + return h.hexdigest() + + +def exposure(cfg, steps): + count = cfg["batch_per_kind"] * steps + return { + "steps": steps, + "atomic_examples": count, + "training_composite_examples": count, + "valid_input_tokens": count * 11, + "processed_tokens_including_padding": count * 12, + "supervised_answer_eos_tokens": count * 4, + } + + +def flops_estimate(model, cfg, steps): + """Conventional 6*N*T estimate plus transparent small mixer correction.""" + params = sum(p.numel() for p in model.parameters()) + tokens = exposure(cfg, steps)["processed_tokens_including_padding"] + n_gqa = model.architecture["mixers"].count("gqa") + n_delta = model.architecture["mixers"].count("delta") + length, width, heads = 6, cfg["width"], cfg["heads"] + dim = width // heads + mixing = tokens * (n_gqa * 12 * length * width + n_delta * 24 * heads * dim * dim) + return { + "parameter_count": params, + "conventional_6_parameter_token_flops": 6 * params * tokens, + "additional_mixing_flops_approx": mixing, + "total_approx": 6 * params * tokens + mixing, + "limitation": ( + "Rough training estimate, not profiler measurements; 6NT includes embeddings " + "and excludes detailed normalization/activation costs." + ), + } + + +@torch.no_grad() +def generate(model, x, y, device, batch=128, patches=None): + result = {key: [] for key in ("pred", "eos", "logp", "logits")} + for start in range(0, len(x), batch): + tokens = torch.as_tensor(x[start : start + batch], device=device) + target = torch.as_tensor(y[start : start + batch], device=device) + part = None + if patches is not None: + part = { + key: { + "positions": value["positions"], + "value": value["value"][start : start + batch], + } + for key, value in patches.items() + } + logits = model(tokens, patches=part)[:, -1] + prediction = logits.argmax(-1) + stop = model(torch.cat((tokens, prediction[:, None]), 1), patches=part)[:, -1].argmax(-1) + result["pred"].append(prediction.cpu().numpy()) + result["eos"].append(stop.cpu().numpy()) + result["logp"].append(logits.log_softmax(-1).gather(1, target[:, None]).cpu().numpy()[:, 0]) + result["logits"].append(logits.cpu().numpy()) + return {key: np.concatenate(value) for key, value in result.items()} + + +@torch.no_grad() +def evaluate(model, world, cfg, device): + model.eval() + arrays, metrics = {}, {} + for name, key, mask in ( + ("atomic", "atomic", slice(None)), + ("train", "composite", world["train_mask"]), + ("test", "composite", ~world["train_mask"]), + ): + x, y = world[key + "_x"][mask], world[key + "_y"][mask] + output = generate(model, x, y, device, cfg["eval_batch"]) + for field, value in output.items(): + arrays[f"{name}_{field}"] = value + correct = (output["pred"] == y) & (output["eos"] == EOS) + metrics[name] = { + "n": len(y), + "answer_accuracy": float(np.mean(output["pred"] == y)), + "exact_answer_eos": float(correct.mean()), + "answer_nll": float(-output["logp"].mean()), + } + indices = np.flatnonzero(~world["train_mask"]) + a, r1, r2 = world["comps"][indices].T + bridge = arrays["atomic_pred"][a * cfg["relations"] + r1] + bridge_eos = arrays["atomic_eos"][a * cfg["relations"] + r1] + second = np.c_[np.full(len(a), BOS), bridge, ENTITY + cfg["entities"] + r2] + y = world["composite_y"][indices] + output = generate(model, second, y, device, cfg["eval_batch"]) + arrays.update({f"two_call_{field}": value for field, value in output.items()}) + arrays["two_call_bridge"], arrays["two_call_bridge_eos"] = bridge, bridge_eos + correct = (output["pred"] == y) & (output["eos"] == EOS) & (bridge_eos == EOS) + metrics["two_call"] = {"n": len(y), "exact_answer_eos": float(correct.mean())} + atom_ok = (arrays["atomic_pred"] == world["atomic_y"]) & (arrays["atomic_eos"] == EOS) + gold_bridge = world["maps"][r1, a] + both = atom_ok[a * cfg["relations"] + r1] & atom_ok[gold_bridge * cfg["relations"] + r2] + direct_ok = (arrays["test_pred"] == y) & (arrays["test_eos"] == EOS) + arrays["test_both_atoms_correct"] = both + metrics["test_given_both_atoms"] = { + "n": int(both.sum()), + "coverage": float(both.mean()), + "exact_answer_eos": float(direct_ok[both].mean()) if both.any() else None, + } + return metrics, arrays + + +def intervention_conditions(traces, cfg, device): + """Same orthogonal transform for both donor norms; no fitted direction.""" + rng = np.random.default_rng(cfg["random_control_seed"]) + perm = torch.as_tensor(rng.permutation(cfg["width"]), device=device) + signs = torch.as_tensor(rng.choice([-1.0, 1.0], cfg["width"]), device=device) + sites = { + "mlp": (cfg["mlp_layer"], cfg["mlp_position"]), + "mixer": (cfg["mixer_layer"], cfg["mixer_position"]), + } + conditions, norms = {}, {} + for target in cfg["patch_targets"]: + kinds = ("mlp", "mixer") if target == "joint" else (target,) + for donor in cfg["patch_donors"]: + patches, measurements = {}, {} + for kind in kinds: + layer, position = sites[kind] + base = traces["identity"][(kind, layer)][:, [position]] + source = donor.replace("random_", "") + delta = traces[source][(kind, layer)][:, [position]] - base + if donor.startswith("random_"): + delta = delta[..., perm] * signs.to(delta) + patches[(kind, layer)] = {"positions": [position], "value": base + delta} + measurements[kind] = delta.flatten(1).norm(dim=-1).cpu().numpy() + key = f"{target}_{donor}" + conditions[key], norms[key] = patches, measurements + return conditions, norms + + +@torch.no_grad() +def diagnostics(model, world, cfg, device): + model.eval() + cases = world["cases"] + query = world["composite_x"][cases[:, 0]] + correct = np.c_[ + np.full(len(cases), BOS), + ENTITY + cases[:, 9], + ENTITY + cfg["entities"] + cases[:, 10], + ENTITY + cfg["entities"] + cases[:, 3], + ] + wrong = np.c_[ + np.full(len(cases), BOS), + ENTITY + cases[:, 6], + ENTITY + cfg["entities"] + cases[:, 2], + ENTITY + cfg["entities"] + cases[:, 3], + ] + traces = {} + for key, x in (("identity", query), ("correct", correct), ("wrong", wrong)): + _, _, traces[key] = model(torch.as_tensor(x, device=device), capture=True) + conditions, norms = intervention_conditions(traces, cfg, device) + target, competitor = ENTITY + cases[:, 5], ENTITY + cases[:, 8] + arrays = { + "case_ids": cases[:, 0], + "target": target, + "wrong_target": competitor, + "query": query, + "correct_donor": correct, + "wrong_donor": wrong, + } + baseline = generate(model, query, target, device, cfg["eval_batch"]) + base_ok = (baseline["pred"] == target) & (baseline["eos"] == EOS) + metrics = {} + for name, patches in {"baseline": None, **conditions}.items(): + output = ( + baseline + if patches is None + else generate(model, query, target, device, cfg["eval_batch"], patches) + ) + for field, value in output.items(): + arrays[f"{name}_{field}"] = value + row = np.arange(len(target)) + margin = output["logits"][row, target] - output["logits"][row, competitor] + arrays[f"{name}_margin"] = margin + exact = (output["pred"] == target) & (output["eos"] == EOS) + wrong_ok = (output["pred"] == competitor) & (output["eos"] == EOS) + metrics[name] = { + "n": len(target), + "correct_exact": float(exact.mean()), + "wrong_exact": float(wrong_ok.mean()), + "rescued": int((exact & ~base_ok).sum()), + "damaged": int((~exact & base_ok).sum()), + "baseline_correct_n": int(base_ok.sum()), + "baseline_incorrect_n": int((~base_ok).sum()), + "mean_correct_minus_wrong_margin": float(margin.mean()), + "max_logit_change": float(np.max(np.abs(output["logits"] - baseline["logits"]))), + } + for kind, value in norms.get(name, {}).items(): + arrays[f"{name}_{kind}_norm"] = value + # Functional interaction in the 2x2 channel intervention, not an attribution percentage. + for donor in ("correct", "wrong", "random_correct", "random_wrong"): + interaction = ( + arrays[f"joint_{donor}_margin"] + - arrays[f"mlp_{donor}_margin"] + - arrays[f"mixer_{donor}_margin"] + + arrays["baseline_margin"] + ) + arrays[f"interaction_{donor}"] = interaction + return metrics, arrays + + +def save_npz(path, arrays): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + np.savez_compressed(path, **arrays) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_analysis.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_analysis.py new file mode 100644 index 0000000000000000000000000000000000000000..5ae07fb7fccdec9430d5e69bc1b304a9fcebe914 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_analysis.py @@ -0,0 +1,399 @@ +"""Audit saved edit predictions and describe failures without selecting successes.""" + +import argparse +import csv +import hashlib +import json +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from .bios_data import N_BASE, RELATIONS, load_world, write_json + +RETENTION_GROUPS = ("0", "1", "2", "3", "2_base", "2_derived") + + +def read(path): + return json.loads(path.read_text()) + + +def failure_flags(point, accuracy=0.95, damage=0.01): + rates = [point["U_heldout_destruction"][g]["rate"] for g in RETENTION_GROUPS] + return { + "E": point["E_root"] < 1 or point["E_member"] < accuracy, + "D": point["D"] < accuracy, + "U": any(r is not None and r > damage for r in rates), + "unevaluable": any(r is None for r in rates), + } + + +def failure_signature(flags): + if flags["unevaluable"]: + return "unevaluable" + return "+".join(k for k in ("E", "D", "U") if flags[k]) or "pass" + + +def propagation_errors(world, sets, prediction): + ids = sets["D"] + value, ended = prediction["prediction"][ids], prediction["ended"][ids] + target = sets["target"][ids] + actual = sets["target"][2112 + world.person[ids]] + correct = (value == target) & ended + remaining = ~correct + counts = {"correct": int(correct.sum())} + for name, mask in ( + ("nontermination", ~ended), + ("old_default", value == world.answers[ids]), + ("personal_city_instead_of_company_default", value == actual), + ): + counts[name] = int((remaining & mask).sum()) + remaining &= ~mask + counts["other_wrong_value"] = int(remaining.sum()) + assert sum(counts.values()) == len(ids) + strata = {} + old_exception = world.exceptions[world.person[ids]] + for name, mask in ( + ("old_exception", old_exception), + ("updated_personal_equals_default", ~old_exception & (actual == target)), + ("updated_personal_differs_from_default", ~old_exception & (actual != target)), + ): + strata[name] = {"n": int(mask.sum()), "correct": int(correct[mask].sum())} + return {"counts": counts, "strata": strata} + + +def retention_masks(sets, old_correct, view="heldout"): + eligible = old_correct.copy() + if view != "full": + selected = np.zeros(len(eligible), dtype=bool) + selected[sets[view]] = True + eligible &= selected + masks = {str(g): eligible & (sets["strata"] == g) for g in range(4)} + masks["2_base"] = masks["2"] & (np.arange(len(eligible)) < N_BASE) + masks["2_derived"] = masks["2"] & (np.arange(len(eligible)) >= N_BASE) + return masks + + +def retention_counts(sets, correct, old_correct, view="heldout"): + return { + group: { + "known": int(mask.sum()), + "broken": int((mask & ~correct).sum()), + "rate": float((~correct[mask]).mean()) if mask.any() else None, + } + for group, mask in retention_masks(sets, old_correct, view).items() + } + + +def dump_csv(path, rows): + if not rows: + return + with path.open("w") as stream: + writer = csv.DictWriter(stream, fieldnames=list(rows[0])) + writer.writeheader() + writer.writerows(rows) + + +def summarize_group(cases): + n = len(cases) + result = {"n": n} + for field in ("E", "E_root", "E_member", "D", "U_accuracy", "E_target_value_nll"): + result[f"mean_{field}"] = float(np.mean([c["final"][field] for c in cases])) + result.update( + final_pass=sum(c["final"]["joint_pass"] is True for c in cases), + ever_pass=sum(c["first_observed_joint_step"] is not None for c in cases), + regressed=sum( + c["first_observed_joint_step"] is not None and not c["final"]["joint_pass"] + for c in cases + ), + signatures=dict(Counter(c["failure_signature"] for c in cases)), + **{f"fail_{k}": sum(c["failure_flags"][k] for c in cases) for k in ("E", "D", "U")}, + ) + for g in RETENTION_GROUPS: + rates = [c["final"]["U_heldout_destruction"][g]["rate"] for c in cases] + result[f"fail_U{g}"] = sum(r is not None and r > 0.01 for r in rates) + result[f"mean_U{g}_damage"] = float(np.mean([r for r in rates if r is not None])) + result["D_error_counts"] = dict( + sum((Counter(c["propagation"]["counts"]) for c in cases), Counter()) + ) + result["mean_initial_new_answer_nll"] = float(np.mean([c["initial_nll"] for c in cases])) + return result + + +def run(args): + root, out = Path(args.root), Path(args.output) + out.mkdir(parents=True, exist_ok=True) + worlds = {i: load_world(f"data/bios-work-v1/world-{i}") for i in (0, 1)} + cases, audit, timelines = [], [], [] + lookup = {} + for run_dir in sorted(root.glob("world-*-seed-*-*")): + config = read(run_dir / "config.json") + world = worlds[config["world_seed"]] + for dirname, window in (("edits", 3), ("edits-window0", 0)): + completed = read(run_dir / dirname / "complete.json") + assert completed["status"] == "complete" and len(completed["cases"]) == 16 + for path in sorted((run_dir / dirname).glob("*/complete.json")): + c = read(path) + assert c["status"] == "complete" and c["final"]["step"] == 512 + assert c["window_zero_based"] == list(range(window, window + 3)) + sets = dict(np.load(path.parent / "sets.npz")) + pred = dict(np.load(path.parent / "predictions-512.npz")) + correct = (pred["prediction"] == sets["target"]) & pred["ended"] + np.testing.assert_array_equal(correct, pred["correct"]) + retention = retention_counts(sets, correct, sets["old_correct"]) + assert retention == c["final"]["U_heldout_destruction"] + for name, ids in ( + ("E", sets["E"]), + ("D", sets["D"]), + ("E_root", sets["E"][world.relation[sets["E"]] == 1]), + ("E_member", sets["E"][world.relation[sets["E"]] == 2]), + ): + assert float(correct[ids].mean()) == c["final"][name] + trajectory = read(path.parent / "trajectory.json") + for point in trajectory: + flags = failure_flags(point) + expected = None if flags["unevaluable"] else not any(flags.values()) + assert point["joint_pass"] == expected + flags = failure_flags(c["final"]) + damaged_by_relation = {} + for group, mask in retention_masks(sets, sets["old_correct"]).items(): + broken = mask & ~correct + damaged_by_relation[group] = { + name: int((broken & (world.relation == relation)).sum()) + for relation, name in enumerate((*RELATIONS, "derived_default_city")) + } + assert sum(damaged_by_relation[group].values()) == int(broken.sum()) + method = f"FT-{c['scope'].upper()}" + if c["branch"]: + method += f"+{c['branch']}" + meta = { + "run": run_dir.name, + "world": world.seed, + "seed": config["seed"], + "order": config["order"], + "window": window, + "method": method, + "kind": c["kind"], + "support": c["support"], + } + c.update( + meta, + directory=str(path.parent), + failure_flags=flags, + failure_signature=failure_signature(flags), + heldout_damage_by_relation=damaged_by_relation, + propagation=propagation_errors(world, sets, pred), + replay_retention=retention_counts(sets, correct, sets["old_correct"], "replay"), + initial_nll=trajectory[0]["E_target_value_nll"], + ever_E=any(not failure_flags(p)["E"] for p in trajectory), + ever_D=any(not failure_flags(p)["D"] for p in trajectory), + ever_U=any(not failure_flags(p)["U"] for p in trajectory), + last_failure_free_E_step=max( + (p["step"] for p in trajectory if not failure_flags(p)["E"]), default=None + ), + down_calibration=c["final"].get("down_calibration"), + ) + cases.append(c) + lookup[(run_dir.name, window, method, c["kind"], c["support"])] = (c, sets, pred) + audit.append( + {"path": str(path), "sha256": hashlib.sha256(path.read_bytes()).hexdigest()} + ) + timelines.extend( + {**meta, **p, "failure_flags": failure_flags(p)} for p in trajectory + ) + assert len(cases) == 256 + groups = defaultdict(list) + for c in cases: + groups[(c["window"], c["method"], c["order"], c["kind"])].append(c) + aggregates = [ + {"window": w, "method": m, "order": o, "kind": k, **summarize_group(cs)} + for (w, m, o, k), cs in sorted(groups.items()) + ] + common, duplicates, branch_pairs = [], [], [] + for (run_name, window, method, kind, support), (case, sets, pred) in lookup.items(): + if case["order"] == "SA": + other, other_sets, other_pred = lookup[ + (run_name[:-2] + "AS", window, method, kind, support) + ] + for field in ( + "E", + "D", + "target", + "heldout", + "replay", + "strata", + "edit_sampling", + "replay_sampling", + ): + np.testing.assert_array_equal(sets[field], other_sets[field]) + known = sets["old_correct"] & other_sets["old_correct"] + sa = retention_counts(sets, pred["correct"], known) + ass = retention_counts(sets, other_pred["correct"], known) + common.append( + { + "world": case["world"], + "seed": case["seed"], + "window": window, + "method": method, + "kind": kind, + "support": support, + "SA": sa, + "AS": ass, + } + ) + if method == "FT-ALL" and window == 3: + _, _, duplicate = lookup[(run_name, 0, method, kind, support)] + duplicates.append( + { + "run": run_name, + "kind": kind, + "support": support, + "identical_final_predictions": bool( + all(np.array_equal(pred[k], duplicate[k]) for k in pred) + ), + } + ) + if case["branch"]: + baseline, _, baseline_pred = lookup[(run_name, window, "FT-MLP", kind, support)] + branch_pairs.append( + { + "run": run_name, + "window": window, + "method": method, + "kind": kind, + "support": support, + **{f"delta_{k}": case["final"][k] - baseline["final"][k] for k in ("E", "D")}, + "baseline_joint": baseline["final"]["joint_pass"], + "branch_joint": case["final"]["joint_pass"], + "changed_predictions_vs_baseline": int( + (pred["prediction"] != baseline_pred["prediction"]).sum() + ), + "max_value_nll_difference_vs_baseline": float( + np.max(np.abs(pred["value_nll"] - baseline_pred["value_nll"])) + ), + } + ) + sensitivity = [] + for (window, method, order, kind), cs in sorted(groups.items()): + for accuracy in (0.90, 0.95, 0.99): + for damage in (0.0, 0.01, 0.02, 0.05): + sensitivity.append( + { + "window": window, + "method": method, + "order": order, + "kind": kind, + "accuracy_threshold": accuracy, + "damage_threshold": damage, + "n": len(cs), + "final_pass": sum( + not any(failure_flags(c["final"], accuracy, damage).values()) + for c in cs + ), + } + ) + quality = [] + for world in (0, 1): + for seed in (0, 1): + sa, ass = [ + read(root / f"world-{world}-seed-{seed}-{order}" / "complete.json")["final"] + for order in ("SA", "AS") + ] + quality.append( + { + "world": world, + "seed": seed, + "base_difference_pp": 100 * (sa["base_accuracy"] - ass["base_accuracy"]), + "derived_difference_pp": 100 + * (sa["derived_accuracy"] - ass["derived_accuracy"]), + "passed": bool( + min( + sa["base_accuracy"], + ass["base_accuracy"], + sa["derived_accuracy"], + ass["derived_accuracy"], + ) + >= 0.99 + and abs(sa["base_accuracy"] - ass["base_accuracy"]) <= 0.005 + and abs(sa["derived_accuracy"] - ass["derived_accuracy"]) <= 0.005 + and abs(sa["value_nll"] - ass["value_nll"]) <= 0.1 + ), + } + ) + quality_keys = {(q["world"], q["seed"]) for q in quality if q["passed"]} + quality_aggregates = [] + for (w, m, o, k), cs in sorted(groups.items()): + subset = [c for c in cs if (c["world"], c["seed"]) in quality_keys] + quality_aggregates.append( + {"window": w, "method": m, "order": o, "kind": k, **summarize_group(subset)} + ) + report = { + "phase": "symbolic development; descriptive; not independent edit replicates", + "cases": cases, + "groups": aggregates, + "common_known_retention": common, + "branch_paired_support0": branch_pairs, + "ft_all_window_duplicates": duplicates, + "quality_pairs": quality, + "quality_subset_groups": quality_aggregates, + "sensitivity": sensitivity, + "source_audit": audit, + "expected_cases": 256, + "audited_cases": len(cases), + } + write_json(out / "failure-analysis.json", report) + write_json(out / "edit-trajectories.json", timelines) + dump_csv( + out / "failure-summary.csv", + [{k: v for k, v in row.items() if not isinstance(v, dict)} for row in aggregates], + ) + dump_csv(out / "threshold-sensitivity.csv", sensitivity) + dump_csv(out / "branch-paired-support0.csv", branch_pairs) + dump_csv( + out / "case-failures.csv", + [ + { + **{ + k: c[k] + for k in ( + "run", + "world", + "seed", + "order", + "window", + "method", + "kind", + "support", + "failure_signature", + "first_observed_joint_step", + "initial_nll", + ) + }, + **{k: c["final"][k] for k in ("E", "E_root", "E_member", "D", "joint_pass")}, + } + for c in cases + ], + ) + print( + json.dumps( + { + "audited_cases": len(cases), + "groups": len(aggregates), + "quality_pairs_passed": len(quality_keys), + "FT_ALL_identical_duplicate_cases": sum( + d["identical_final_predictions"] for d in duplicates + ), + } + ) + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", default="results/bios-dev-v1") + parser.add_argument("--output", default="results/bios-dev-v1/failure-analysis-20260926") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_branch.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_branch.py new file mode 100644 index 0000000000000000000000000000000000000000..f4c6ebef8f0f501ac43d2d94de8f4f59b954208b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_branch.py @@ -0,0 +1,127 @@ +"""Equal-parameter residual branches from old-world activation directions.""" + +import time + +import numpy as np +import torch +from torch import nn + +from .bios_data import ANS +from .bios_train import precision + + +class ResidualBranch(nn.Module): + def __init__(self, q, mean, scale, width=32, seed=73): + super().__init__() + self.register_buffer("q", q) + self.register_buffer("mean", mean) + self.register_buffer("scale", scale) + # Explicit local RNG: same A in all arms without changing training RNG state. + generator = torch.Generator(device=q.device).manual_seed(seed) + self.a = nn.Parameter( + torch.randn(width, q.shape[1], generator=generator, device=q.device) / q.shape[1] ** 0.5 + ) + self.b = nn.Parameter(torch.zeros(q.shape[0], width, device=q.device)) + + def forward(self, v): + s = (v.float() @ self.q - self.mean) / self.scale + return (torch.nn.functional.gelu(s @ self.a.T) @ self.b.T).to(v.dtype) + + +@torch.no_grad() +def build_bases(model, world, data, layer=4, rank=32): + device = data["tokens"].device + values = [] + + def capture(_module, _inputs, output): + values.append(output[:, 3].float()) + + handle = model.blocks[layer].register_forward_hook(capture) + started = time.perf_counter() + try: + with precision(device): + for begin in range(2112, 4160, 256): + model( + data["prompts"][begin : begin + 256], + data["lengths"][begin : begin + 256, None] - 1, + ) + finally: + handle.remove() + v = torch.cat(values) + group_means = torch.stack( + [v[torch.as_tensor(world.employers == c, device=device)].mean(0) for c in range(64)] + ) + centered_means = group_means - v.mean(0) + _, shared_s, shared_vh = torch.linalg.svd(centered_means, full_matrices=False) + q_shared = shared_vh[:rank].T.contiguous() + residual = v - group_means[torch.as_tensor(world.employers, device=device)] + residual = residual - (residual @ q_shared) @ q_shared.T + _, independent_s, independent_vh = torch.linalg.svd(residual, full_matrices=False) + q_independent = independent_vh[:rank].T.contiguous() + valid = bool( + shared_s[rank - 1] > shared_s[0] * 1e-6 + and independent_s[rank - 1] > independent_s[0] * 1e-6 + ) + if not valid: + return None, {"available": False, "reason": "fewer than 32 nondegenerate directions"} + generator = torch.Generator(device=device).manual_seed(74) + q_random = torch.linalg.qr(torch.randn(v.shape[1], rank, generator=generator, device=device)).Q + bases, checks = {}, {} + for kind, q in (("shared", q_shared), ("independent", q_independent), ("random", q_random)): + projected = v @ q + mean, std = projected.mean(0), projected.std(0, correction=0) + std = std.clamp_min(0.01 * std.square().mean().sqrt()) + normalized = (projected - mean) / std + # Equal total variance across all branches (one, not dependent on their rank). + scale = std * normalized.square().sum(-1).mean().sqrt() + bases[kind] = (q, mean, scale) + normalized = (projected - mean) / scale + within = [] + for c in range(64): + mask = (world.employers == c) & ~world.exceptions + z = normalized[torch.as_tensor(mask, device=device)] + within.append((z - z.mean(0)).square().sum(-1).mean().item()) + checks[kind] = { + "same_company_relation_old_answer_identity_variance": float(np.mean(within)), + "total_variance": normalized.square().sum(-1).mean().item(), + } + if device.type == "cuda": + torch.cuda.synchronize(device) + return bases, { + "available": True, + "construction_seconds": time.perf_counter() - started, + "rank": rank, + "shared_32nd_relative_singular_value": (shared_s[rank - 1] / shared_s[0]).item(), + "independent_32nd_relative_singular_value": ( + independent_s[rank - 1] / independent_s[0] + ).item(), + "checks": checks, + } + + +def attach_branch(model, basis, layer=4, width=32): + branch = ResidualBranch(*basis, width=width) + model.add_module("edit_branch", branch) + + def save_position(_module, args): + branch.positions = args[0].eq(ANS).long().argmax(-1) + + def add(_module, _inputs, output): + rows = torch.arange(len(output), device=output.device) + result = output.clone() + result[rows, branch.positions] = result[rows, branch.positions] + branch( + output[rows, branch.positions] + ) + return result + + handles = [ + model.register_forward_pre_hook(save_position), + model.blocks[layer].register_forward_hook(add), + ] + return branch, handles + + +def remove_branch(model, handles): + for handle in handles: + handle.remove() + delattr(model, "edit_branch") diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_capacity.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_capacity.py new file mode 100644 index 0000000000000000000000000000000000000000..d07d84eb1c19bc5055e15255b0de00799b8713c5 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_capacity.py @@ -0,0 +1,48 @@ +"""Predeclared splits and query-level capacity diagnostics.""" + +import numpy as np + +from .bios_data import N_BASE, N_QUERIES, rng_for + + +def qa_split(world, mode): + if mode == "all": + return np.arange(N_BASE, N_QUERIES), np.array([], dtype=np.int64) + if mode != "half": + raise ValueError("Unknown QA split") + rng = rng_for(world.seed, 910) + train, heldout = [], [] + for company in np.unique(world.employers): + for exception in (False, True): + people = np.flatnonzero((world.employers == company) & (world.exceptions == exception)) + people = rng.permutation(people) + train.extend((N_BASE + people[: len(people) // 2]).tolist()) + heldout.extend((N_BASE + people[len(people) // 2 :]).tolist()) + return np.sort(train), np.sort(heldout) + + +def split_metrics(world, arrays, train_ids, heldout_ids): + correct, nll = arrays["correct"], arrays["value_nll"] + # The derivation needs the person's employer and that employer's default city. + # Build by semantic IDs rather than assuming a base-fact row layout. + employer = {int(world.person[i]): i for i in np.flatnonzero(world.relation == 0)} + defaults = {int(world.company[i]): i for i in np.flatnonzero(world.relation == 1)} + result = {} + for name, ids in (("trained", train_ids), ("heldout", heldout_ids)): + result[f"derived_{name}_count"] = len(ids) + result[f"derived_{name}_accuracy"] = float(correct[ids].mean()) if len(ids) else None + result[f"derived_{name}_nll"] = float(nll[ids].mean()) if len(ids) else None + eligible = np.array( + [ + i + for i in ids + if correct[employer[int(world.person[i])]] + and correct[defaults[int(world.company[i])]] + ], + dtype=np.int64, + ) + result[f"derived_{name}_known_components_count"] = len(eligible) + result[f"derived_{name}_known_components_accuracy"] = ( + float(correct[eligible].mean()) if len(eligible) else None + ) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_causal_paths.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_causal_paths.py new file mode 100644 index 0000000000000000000000000000000000000000..ab2d8963ce2c5db80362fdd38cc80e83c8415b53 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_causal_paths.py @@ -0,0 +1,455 @@ +"""Offline donor-state interventions on frozen crossover models. + +Truth is used to match donor/recipient pairs and score outputs, never supplied as +an answer or bridge to the model. This is a causal diagnostic, not an editor. +""" + +import csv +import json +from pathlib import Path + +import numpy as np + +from .bios_cross import CHAINS, make_cross_world +from .bios_data import EOS, array_hash, rng_for, write_json +from .bios_path_diagnostics import ( + INDISTINGUISHABLE, + classify_answers, + file_sha256, + free_generate_values, +) + +PAIR_TYPES = ( + "same_group_different_actual", + "different_group_same_actual_different_default", + "same_group_same_actual_different_person", + "different_group_different_actual_different_default", +) +POSITIONS = (2, 3, 4) +ANSWER_ROLES = ("recipient_default", "recipient_actual", "donor_default", "donor_actual") + + +def make_donor_plan(world, chain, per_population=64): + """Select using truth and train/heldout membership only, with fixed RNG. + + A missing donor stays -1. No prediction- or success-based replacement occurs. + The same world yields identical pairs across sizes, conditions and model seeds. + """ + heldout = world.person[world.heldout_ids[chain]] + train = world.person[world.train_ids[chain]] + rng = rng_for(world.seed, 971, chain) + recipients = [] + for exceptional in (False, True): + pool = heldout[world.exceptions[chain, heldout] == exceptional] + if len(pool) < per_population: + raise ValueError("Not enough heldout recipients for predeclared sample") + recipients.extend(rng.choice(pool, per_population, replace=False)) + recipients = np.asarray(recipients, dtype=np.int64) + group = world.memberships[chain] + default = world.answers[world.root_ids[chain, group]] + actual = world.answers[world.actual_ids[chain]] + recipient_rows, donor_rows, type_rows, candidate_counts = [], [], [], [] + for recipient in recipients: + same_group = group[train] == group[recipient] + same_actual = actual[train] == actual[recipient] + same_default = default[train] == default[recipient] + masks = ( + same_group & ~same_actual, + ~same_group & same_actual & ~same_default, + same_group & same_actual & (train != recipient), + ~same_group & ~same_actual & ~same_default, + ) + for pair_type, mask in enumerate(masks): + candidates = train[mask] + recipient_rows.append(recipient) + donor_rows.append(rng.choice(candidates) if len(candidates) else -1) + type_rows.append(pair_type) + candidate_counts.append(len(candidates)) + donor_rows = np.asarray(donor_rows, dtype=np.int64) + complete = (donor_rows.reshape(-1, len(PAIR_TYPES)) >= 0).all(axis=1) + return { + "case_id": np.arange(len(donor_rows), dtype=np.int64), + "recipient": np.asarray(recipient_rows, dtype=np.int64), + "donor": donor_rows, + "pair_type": np.asarray(type_rows, dtype=np.int8), + "candidate_count": np.asarray(candidate_counts, dtype=np.int32), + "common_recipient": np.repeat(complete, len(PAIR_TYPES)), + "recipient_old_exception": world.exceptions[chain, recipient_rows], + } + + +def intervention_state(recipient_state, donor_state, intervention, seed): + """Random control matches the donor-minus-recipient perturbation norm per row.""" + if recipient_state.shape != donor_state.shape: + raise ValueError("Activation shapes do not match") + delta = donor_state.astype(np.float64) - recipient_state.astype(np.float64) + norms = np.linalg.norm(delta, axis=-1) + if intervention == "donor": + patched = donor_state.copy() + elif intervention == "sham": + patched = recipient_state.copy() + elif intervention == "matched_random": + noise = np.random.default_rng(seed).standard_normal(delta.shape) + noise /= np.maximum(np.linalg.norm(noise, axis=-1, keepdims=True), 1e-30) + patched = (recipient_state + noise * norms[:, None]).astype(recipient_state.dtype) + else: + raise ValueError("Unknown intervention") + actual_norms = np.linalg.norm(patched.astype(np.float64) - recipient_state, axis=-1) + return patched, norms, actual_norms + + +def cache_clean_states(model, prompts, lengths, device, batch_size=256): + """Capture post-block residuals at fixed positions for clean prompt passes.""" + import torch + + from .bios_train import precision + + states = [[] for _ in model.blocks] + hooks = [] + for layer, block in enumerate(model.blocks): + + def capture(module, inputs, output, layer=layer): + states[layer].append(output[:, POSITIONS, :].detach().float().cpu().numpy()) + + hooks.append(block.register_forward_hook(capture)) + model.eval() + try: + with torch.no_grad(): + for start in range(0, len(prompts), batch_size): + p = torch.as_tensor(prompts[start : start + batch_size], device=device) + n = torch.as_tensor(lengths[start : start + batch_size], device=device) + with precision(device): + model(p, (n - 1)[:, None]) + finally: + for hook in hooks: + hook.remove() + return np.stack([np.concatenate(layer_states) for layer_states in states]) + + +def generate_with_state_patch( + model, prompts, lengths, replacements, layer, position, device, batch_size=256 +): + """Apply the same pre-answer state patch in value and EOS generation passes. + + Positions <= 4 cannot depend on the generated token at position 5 under the + causal mask, so the clean prompt cache contains no teacher-forced answer. + """ + import torch + + from .bios_train import precision + + if position not in POSITIONS or np.any(lengths != 5): + raise ValueError("This diagnostic is restricted to five-token derived queries") + predictions, ended = [], [] + model.eval() + with torch.no_grad(): + for start in range(0, len(prompts), batch_size): + p = torch.as_tensor(prompts[start : start + batch_size], device=device) + n = torch.as_tensor(lengths[start : start + batch_size], device=device) + replacement = torch.as_tensor(replacements[start : start + batch_size], device=device) + + def patch(module, inputs, output, replacement=replacement): + changed = output.clone() + changed[:, position] = replacement.to(output.dtype) + return changed + + hook = model.blocks[layer].register_forward_hook(patch) + try: + with precision(device): + first = model(p, (n - 1)[:, None])[:, 0].float().argmax(-1) + continuation = torch.zeros((len(p), 6), device=device, dtype=torch.long) + continuation[:, :5] = p + continuation[:, 5] = first + second = model(continuation, n[:, None])[:, 0].argmax(-1) + predictions.append(first.cpu().numpy()) + ended.append(second.eq(EOS).cpu().numpy()) + finally: + hook.remove() + return {"prediction": np.concatenate(predictions), "ended": np.concatenate(ended)} + + +def _candidate_values(world, chain, recipients, donors): + default = world.answers[world.root_ids[chain, world.memberships[chain]]] + actual = world.answers[world.actual_ids[chain]] + return np.column_stack( + [default[recipients], actual[recipients], default[donors], actual[donors]] + ) + + +def _node_rows(arrays, identity): + rows = [] + for pair_type, label in enumerate(PAIR_TYPES): + for population in ("all", "ordinary", "old_exception"): + for common_only in (False, True): + selected = arrays["pair_type"] == pair_type + if population != "all": + selected &= arrays["recipient_old_exception"] == (population == "old_exception") + if common_only: + selected &= arrays["common_recipient"] + n = int(selected.sum()) + before = arrays["baseline_correct"][selected] + after = arrays["correct"][selected] + row = { + **identity, + "pair_type": label, + "population": population, + "common_recipients_only": common_only, + "n": n, + "baseline_correct": int(before.sum()), + "correct": int(after.sum()), + "known_became_wrong": int((before & ~after).sum()), + "wrong_became_correct": int((~before & after).sum()), + "termination_error": int((~arrays["ended"][selected]).sum()), + "prediction_changed": int( + ( + arrays["prediction"][selected] + != arrays["baseline_prediction"][selected] + ).sum() + ), + "indistinguishable": int( + (arrays["class_code"][selected] == INDISTINGUISHABLE).sum() + ), + "mean_perturbation_norm": float(arrays["perturbation_norm"][selected].mean()) + if n + else None, + } + for i, role in enumerate(ANSWER_ROLES): + row[f"matches_{role}"] = int( + ( + ((arrays["matched_role_bits"][selected] & (1 << i)) != 0) + & arrays["ended"][selected] + ).sum() + ) + rows.append(row) + return rows + + +def diagnose_causal_run(run, output, step=15360, device="cuda", batch_size=256, per_population=64): + """One model, both relations, all layers/positions with fixed donor controls.""" + import torch + + from .bios_model import CausalLM, ModelConfig + from .bios_organization_train import atomic_numpy_save + + repository = Path(__file__).resolve().parents[2] + run, output = Path(run).resolve(), Path(output).resolve() + if output == run or run in output.parents: + raise ValueError("Never write causal diagnostics inside frozen training runs") + output.mkdir(parents=True, exist_ok=True) + config = json.loads((run / "config.json").read_text()) + if config["world"] not in (0, 1) or config["model"]["width"] not in (256, 768): + raise ValueError("This development diagnostic is frozen to worlds 0/1, widths 256/768") + checkpoint = run / f"model-{step}.pt" + device = torch.device(device) + world = make_cross_world(config["world"], repository / "data/bios-organization-v1") + if array_hash(world.answers) != config["truth_sha256"]: + raise ValueError("World truth mismatch") + identity = { + "run": str(run), + "checkpoint": str(checkpoint), + "step": step, + "checkpoint_sha256": file_sha256(checkpoint), + "config_sha256": file_sha256(run / "config.json"), + "diagnostic_source_sha256": file_sha256(__file__), + "generation_helper_sha256": file_sha256( + repository / "src/llm_memory_editability/bios_path_diagnostics.py" + ), + "world": config["world"], + "seed": config["seed"], + "condition": config["condition"], + "width": config["model"]["width"], + "per_population": per_population, + "positions": list(POSITIONS), + "device_type": device.type, + "batch_size": batch_size, + "torch": torch.__version__, + "offline_truth_matching": True, + "role": "candidate_localization" if config["world"] == 0 else "development_replication", + } + config_path = output / "config.json" + if config_path.exists(): + if json.loads(config_path.read_text()) != identity: + raise ValueError("Causal diagnostic identity changed") + else: + write_json(config_path, identity) + if (output / "complete.json").exists(): + return + saved = torch.load(checkpoint, map_location="cpu", weights_only=False) + model = CausalLM(ModelConfig(**saved["config"])) + model.load_state_dict(saved["model"]) + model.to(device).eval() + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + rows, plan_rows = [], [] + source_output_hashes = {} + for chain, name in enumerate(CHAINS): + dest = output / name + dest.mkdir(exist_ok=True) + plan = make_donor_plan(world, chain, per_population) + plan_path = dest / "plan.npz" + if plan_path.exists(): + with np.load(plan_path) as existing: + if any(not np.array_equal(existing[k], v) for k, v in plan.items()): + raise ValueError("Saved donor plan differs") + else: + atomic_numpy_save(plan_path, **plan) + source_output_hashes[str(plan_path.relative_to(output))] = file_sha256(plan_path) + valid = plan["donor"] >= 0 + selected = {k: v[valid] for k, v in plan.items()} + recipients, donors = selected["recipient"], selected["donor"] + for pair_type, label in enumerate(PAIR_TYPES): + for exceptional in (False, True): + matching = (plan["pair_type"] == pair_type) & ( + plan["recipient_old_exception"] == exceptional + ) + plan_rows.append( + { + "chain": name, + "pair_type": label, + "population": "old_exception" if exceptional else "ordinary", + "requested": int(matching.sum()), + "valid": int((matching & valid).sum()), + "missing": int((matching & ~valid).sum()), + } + ) + people = np.unique(np.concatenate([recipients, donors])) + ids = world.derived_ids[chain, people] + cache_path = dest / "clean-cache.npz" + if cache_path.exists(): + with np.load(cache_path) as cache: + states = cache["states"] + baseline = {k: cache[k] for k in ("prediction", "ended")} + if not np.array_equal(cache["people"], people): + raise ValueError("Clean cache people mismatch") + else: + states = cache_clean_states( + model, world.prompts[ids], world.lengths[ids], device, batch_size + ) + baseline = free_generate_values( + model, world.prompts[ids], world.lengths[ids], device, batch_size + ) + atomic_numpy_save(cache_path, people=people, states=states, **baseline) + source_output_hashes[str(cache_path.relative_to(output))] = file_sha256(cache_path) + ri, di = np.searchsorted(people, recipients), np.searchsorted(people, donors) + recipient_queries = world.derived_ids[chain, recipients] + candidates = _candidate_values(world, chain, recipients, donors) + base = { + **selected, + "recipient_query": recipient_queries, + "donor_query": world.derived_ids[chain, donors], + "candidate_tokens": candidates, + "baseline_prediction": baseline["prediction"][ri], + "baseline_ended": baseline["ended"][ri], + "baseline_correct": (baseline["prediction"][ri] == candidates[:, 0]) + & baseline["ended"][ri], + } + for layer in range(len(model.blocks)): + for position_index, position in enumerate(POSITIONS): + receiver_states = states[layer, ri, position_index] + donor_states = states[layer, di, position_index] + seed = [world.seed, 972, chain, layer, position] + for intervention in ("donor", "matched_random", "sham"): + node = dest / f"layer-{layer}-position-{position}-{intervention}.npz" + if node.exists(): + with np.load(node) as existing: + arrays = dict(existing) + if not np.array_equal(arrays["case_id"], selected["case_id"]): + raise ValueError("Saved node case mismatch") + else: + replacement, donor_norm, actual_norm = intervention_state( + receiver_states, donor_states, intervention, seed + ) + generated = generate_with_state_patch( + model, + world.prompts[recipient_queries], + world.lengths[recipient_queries], + replacement, + layer, + position, + device, + batch_size, + ) + classes, bits = classify_answers( + generated["prediction"], generated["ended"], candidates + ) + arrays = { + **base, + **generated, + "class_code": classes, + "matched_role_bits": bits, + "correct": (generated["prediction"] == candidates[:, 0]) + & generated["ended"], + "donor_delta_norm": donor_norm, + "perturbation_norm": actual_norm, + } + atomic_numpy_save(node, **arrays) + source_output_hashes[str(node.relative_to(output))] = file_sha256(node) + node_identity = { + "world": world.seed, + "seed": config["seed"], + "width": config["model"]["width"], + "condition": config["condition"], + "chain": name, + "layer": layer, + "position": position, + "intervention": intervention, + "terminal_control": layer == len(model.blocks) - 1, + } + rows.extend(_node_rows(arrays, node_identity)) + print( + json.dumps( + { + "event": "causal_node_complete", + "run": str(run), + "chain": name, + "layer": layer, + "position": position, + } + ), + flush=True, + ) + for filename, contents in (("summary.csv", rows), ("pair-coverage.csv", plan_rows)): + with (output / filename).open("w") as stream: + writer = csv.DictWriter(stream, fieldnames=list(contents[0])) + writer.writeheader() + writer.writerows(contents) + write_json( + output / "schema.json", + { + "pair_types": PAIR_TYPES, + "answer_roles": ANSWER_ROLES, + "state": "post-transformer-block residual stream", + "positions": { + "2": "membership relation", + "3": "default relation", + "4": "answer marker", + }, + "world_roles": { + "0": "candidate localization", + "1": "development replication, not confirmation", + }, + "random_control": "Random vector matched per case to ||donor_state-recipient_state||_2", + "matching": "True group/actual/default answers select pairs offline; prompts contain " + "no true answer or true bridge entity.", + "missing": "No donor replacement across types; no prediction-based recipient selection", + "common_recipients": "Auxiliary rows require all four donor types; truth-selected", + "last_layer_controls": "Positions 2/3 cannot affect other tokens after final block; " + "position 4 directly changes value readout and is not routing evidence.", + "causal_scope": "Single-state replacement establishes an intervention effect, not a " + "unique mechanism or strict necessity. Same-point restoration equals sham.", + "eos": "Value and EOS are independently generated with identical intervention; " + "non-terminated values are failures even if an answer candidate matches.", + "overlap": "All matched roles retained; multiple roles remain indistinguishable", + }, + ) + write_json(output / "artifacts.json", source_output_hashes) + write_json( + output / "complete.json", + { + "complete": True, + "identity": identity, + "node_files": 2 * len(model.blocks) * len(POSITIONS) * 3, + "plan_rows": plan_rows, + "artifacts_sha256": file_sha256(output / "artifacts.json"), + }, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_confirmation_stats.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_confirmation_stats.py new file mode 100644 index 0000000000000000000000000000000000000000..27d0d82cc96b250b88771946b569218a090bee50 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_confirmation_stats.py @@ -0,0 +1,280 @@ +"""Locked world-level inference for the narrower shortcut confirmation. + +This module consumes independently audited endpoint counts, never query outcomes +for selecting hypotheses. Nested seeds, organizations, chains and supports are +averaged within a world before any inferential calculation. +""" + +import itertools +import math + +DEFAULT_STATISTICS = { + "revision": "shortcut-confirmation-statistics-v1", + "scope": "training-correlation behavioral confirmation, not organization-path mediation", + "worlds": list(range(100, 108)), + "seeds": [0, 1], + "conditions": ["company", "project", "neither"], + "chains": ["company", "project"], + "prevalences": ["low", "high"], + "supports": [0, 1], + "kinds": ["coherent", "exception"], + "width": 256, + "learning_step": 15360, + "editing_step": 512, + "learning_denominator": 64, + "editing_denominator": 9, + "primary_endpoint": "editing_exception_fixed9", + "confirmatory_family": [ + "editing_exception_fixed9", + "learning_original_exception", + "editing_coherent_fixed9", + ], + "contrast": "high-minus-low", + "unit": "world; all nested pairs equally weighted within each world", + "test": "two-sided one-sample t on eight world-level paired differences, df=7", + "assumption": "independent generated worlds; approximately normal world-level differences", + "multiplicity": "Holm across the three confirmatory endpoints, family alpha=0.05", + "intervals": ["95% marginal t", "98.33333333333333% Bonferroni simultaneous t"], + "sensitivity": "all 256 world sign flips; valid under null sign symmetry, not an " + "unconditional randomized-treatment test", + "zero_sd": "all-zero differences: t=0,p=1,CI=[0,0], degenerate/no equivalence; " + "constant nonzero differences: t/p/CI=null, Holm input=1, adjusted p=1", + "stopping": "fixed eight worlds; no interim outcome inspection or optional extension", + "publication": "all three endpoints, signs, all E/U/global-D/base checks published " + "regardless of significance; no automatic natural-language or editor-method trigger", +} + + +def _beta_fraction(a, b, x): + tiny, tolerance = 1e-300, 3e-14 + qab, qap, qam = a + b, a + 1, a - 1 + c, d = 1.0, 1.0 - qab * x / qap + d = 1 / (d if abs(d) >= tiny else tiny) + h = d + for m in range(1, 401): + double = 2 * m + aa = m * (b - m) * x / ((qam + double) * (a + double)) + d, c = 1 + aa * d, 1 + aa / c + d = 1 / (d if abs(d) >= tiny else tiny) + c = c if abs(c) >= tiny else tiny + h *= d * c + aa = -(a + m) * (qab + m) * x / ((a + double) * (qap + double)) + d, c = 1 + aa * d, 1 + aa / c + d = 1 / (d if abs(d) >= tiny else tiny) + c = c if abs(c) >= tiny else tiny + factor = d * c + h *= factor + if abs(factor - 1) <= tolerance: + return h + raise ArithmeticError("Incomplete beta continued fraction did not converge") + + +def regularized_beta(x, a, b): + if not (0 <= x <= 1 and a > 0 and b > 0): + raise ValueError("Invalid beta arguments") + if x in (0, 1): + return float(x) + scale = math.exp( + math.lgamma(a + b) - math.lgamma(a) - math.lgamma(b) + a * math.log(x) + b * math.log1p(-x) + ) + if x < (a + 1) / (a + b + 2): + result = scale * _beta_fraction(a, b, x) / a + else: + result = 1 - scale * _beta_fraction(b, a, 1 - x) / b + return min(1.0, max(0.0, result)) + + +def t_two_sided_p(statistic, degrees): + if degrees <= 0 or not math.isfinite(statistic): + raise ValueError("Finite t and positive degrees of freedom required") + return regularized_beta(degrees / (degrees + statistic**2), degrees / 2, 0.5) + + +def t_critical(alpha, degrees): + if not (0 < alpha < 1 and degrees > 0): + raise ValueError("Invalid t quantile arguments") + lower, upper = 0.0, 1.0 + while t_two_sided_p(upper, degrees) > alpha: + upper *= 2 + for _ in range(100): + middle = (lower + upper) / 2 + if t_two_sided_p(middle, degrees) > alpha: + lower = middle + else: + upper = middle + return (lower + upper) / 2 + + +def holm(p_values): + """Unavailable p-values conservatively occupy a place in the family as 1.""" + values = [1.0 if p is None else float(p) for p in p_values] + if any(not math.isfinite(p) or not 0 <= p <= 1 for p in values): + raise ValueError("p-values must be finite and in [0,1], or None") + order = sorted(range(len(values)), key=lambda i: (values[i], i)) + result, previous = [None] * len(values), 0.0 + for rank, index in enumerate(order): + previous = max(previous, min(1.0, (len(values) - rank) * values[index])) + result[index] = previous + return result + + +def sign_flip_sensitivity(values): + if len(values) != 8 or not all(math.isfinite(x) for x in values): + raise ValueError("Exactly eight finite world differences required") + observed = abs(math.fsum(values)) + tolerance = 1e-12 * max(1.0, math.fsum(abs(x) for x in values)) + extreme = sum( + abs(math.fsum(s * x for s, x in zip(signs, values, strict=True))) >= observed - tolerance + for signs in itertools.product((-1, 1), repeat=8) + ) + return {"p": extreme / 256, "extreme": extreme, "enumerated": 256} + + +def world_t_statistics(values): + values = [float(x) for x in values] + if len(values) != 8 or not all(math.isfinite(x) for x in values): + raise ValueError("Exactly eight finite world differences required") + mean = math.fsum(values) / 8 + variance = math.fsum((value - mean) ** 2 for value in values) / 7 + sd = math.sqrt(variance) + result = { + "worlds": 8, + "df": 7, + "mean": mean, + "sd": sd, + "sign_flip_sensitivity": sign_flip_sensitivity(values), + } + if max(values) == min(values): + zero = values[0] == 0 + result.update( + status="degenerate_zero" if zero else "degenerate_nonzero", + t=0.0 if zero else None, + p=1.0 if zero else None, + ci95=[0.0, 0.0] if zero else None, + ci_bonferroni=[0.0, 0.0] if zero else None, + ) + return result + standard_error = sd / math.sqrt(8) + statistic = mean / standard_error + result.update(status="estimable", t=statistic, p=t_two_sided_p(statistic, 7)) + for key, alpha in [("ci95", 0.05), ("ci_bonferroni", 0.05 / 3)]: + half = t_critical(alpha, 7) * standard_error + result[key] = [mean - half, mean + half] + return result + + +def _integer(value, label): + if isinstance(value, bool): + raise ValueError(f"Boolean integer for {label}") + parsed = int(value) + if isinstance(value, str) and str(parsed) != value: + raise ValueError(f"Noncanonical integer for {label}: {value!r}") + if not isinstance(value, str) and parsed != value: + raise ValueError(f"Noninteger value for {label}: {value!r}") + return parsed + + +def validate_endpoints(rows, editing=False): + keys = ["world", "seed", "condition", "chain", "prevalence"] + if editing: + keys += ["support", "kind"] + indexed = {} + for raw in rows: + row = dict(raw) + if not editing and "support" in row: + raise ValueError("Learning endpoints must not be repeated or labeled by support") + for name in ["world", "seed", "step", "n", "correct"] + (["support"] if editing else []): + row[name] = _integer(row[name], name) + if "width" in row and _integer(row["width"], "width") != 256: + raise ValueError("Unexpected model width") + if row["step"] != (512 if editing else 15360): + raise ValueError("Endpoint step differs from the fixed budget") + if row["n"] != (9 if editing else 64) or not 0 <= row["correct"] <= row["n"]: + raise ValueError("Fixed cohort count is invalid") + if not editing and (row["cohort"] != "original_exception" or row["split"] != "heldout"): + raise ValueError("Wrong learning cohort or split") + key = tuple(row[k] for k in keys) + if key in indexed: + raise ValueError(f"Duplicate endpoint: {key}") + indexed[key] = row + dimensions = [ + range(100, 108), + (0, 1), + ("company", "project", "neither"), + ("company", "project"), + ("low", "high"), + ] + if editing: + dimensions += [(0, 1), ("coherent", "exception")] + expected = set(itertools.product(*dimensions)) + if set(indexed) != expected: + raise ValueError( + f"Endpoint matrix mismatch: missing {len(expected - set(indexed))}, " + f"unexpected {len(set(indexed) - expected)}" + ) + return indexed + + +def analyze_endpoints(learning, editing): + learning = validate_endpoints(learning) + editing = validate_endpoints(editing, editing=True) + world_rows, case_rows = [], [] + for endpoint in DEFAULT_STATISTICS["confirmatory_family"]: + kind = None if endpoint == "learning_original_exception" else endpoint.split("_")[1] + source, denominator = (learning, 64) if kind is None else (editing, 9) + for world in range(100, 108): + pairs = [] + for seed, condition, chain in itertools.product( + (0, 1), ("company", "project", "neither"), ("company", "project") + ): + for support in [None] if kind is None else (0, 1): + base = (world, seed, condition, chain) + suffix = () if kind is None else (support, kind) + low = source[(*base, "low", *suffix)] + high = source[(*base, "high", *suffix)] + row = { + "endpoint": endpoint, + "world": world, + "seed": seed, + "condition": condition, + "chain": chain, + "support": support, + "kind": kind, + "n": denominator, + "low_correct": low["correct"], + "high_correct": high["correct"], + "correct_difference": high["correct"] - low["correct"], + } + row["accuracy_difference"] = row["correct_difference"] / denominator + pairs.append(row) + case_rows.append(row) + n = len(pairs) * denominator + world_rows.append( + { + "endpoint": endpoint, + "world": world, + "paired_cases": len(pairs), + "nested_query_count_descriptive": n, + "low_accuracy": sum(r["low_correct"] for r in pairs) / n, + "high_accuracy": sum(r["high_correct"] for r in pairs) / n, + "difference": sum(r["correct_difference"] for r in pairs) / n, + } + ) + results = [] + for endpoint in DEFAULT_STATISTICS["confirmatory_family"]: + values = [row["difference"] for row in world_rows if row["endpoint"] == endpoint] + results.append({"endpoint": endpoint, **world_t_statistics(values)}) + adjusted = holm([result["p"] for result in results]) + for result, value in zip(results, adjusted, strict=True): + result.update( + holm_input=1.0 if result["p"] is None else result["p"], + holm_adjusted_p=value, + reject_two_sided_family_05=result["p"] is not None and value <= 0.05, + ) + return { + "contract": DEFAULT_STATISTICS, + "results": results, + "world_effects": world_rows, + "paired_cases": case_rows, + "input_rows": {"learning": len(learning), "editing": len(editing)}, + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_control.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_control.py new file mode 100644 index 0000000000000000000000000000000000000000..26c20f349951ff08ba251e2e61c158ad8f4c0f85 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_control.py @@ -0,0 +1,250 @@ +"""Conditional P3 control: block cross-fact document attention during training. + +The frozen document tensors, absolute positions, loss masks, optimizer, QA stream, +and inference path are unchanged. Only document attention edges are removed. +This module is prepared for conditional execution; importing it does not train. +""" + +import argparse +import fcntl +import hashlib +import json +import os +import time +from contextlib import contextmanager +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from . import bios_cross_train as frozen_trainer +from .bios_cross import CHAINS, CONDITIONS, audit, documents, make_cross_world, qa_schedule +from .bios_data import array_hash, write_json +from .bios_model import Attention, CausalLM +from .bios_organization_train import atomic_numpy_save +from .bios_path_diagnostics import autonomous_two_step + +RECORD_LENGTH = 6 +DOCUMENT_LENGTH = 60 +CHECKPOINTS = (0, 1280, 2560, 5120, 10240, 15360) + + +def fact_causal_mask(length=DOCUMENT_LENGTH, record_length=RECORD_LENGTH, device=None): + """SDPA Boolean True means an allowed edge: same record and causal order.""" + if length <= 0 or record_length <= 0 or length % record_length: + raise ValueError("Document length must contain complete fact records") + position = torch.arange(length, device=device) + return (position[:, None] // record_length == position[None, :] // record_length) & ( + position[None, :] <= position[:, None] + ) + + +class FactIsolatedAttention(Attention): + """An existing Attention object's parameters are retained without reinitializing.""" + + def forward(self, x): + if not self.document_attention_isolated: + return super().forward(x) + batch, length, width = x.shape + if length != DOCUMENT_LENGTH: + raise ValueError("Document-only attention entered with a non-document tensor") + q, k, v = self.qkv(x).view(batch, length, 3, self.heads, width // self.heads).unbind(2) + output = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + attn_mask=self.fact_mask, + is_causal=False, + ) + return self.proj(output.transpose(1, 2).reshape(batch, length, width)) + + +class FactIsolatedCausalLM(CausalLM): + """Use the original initializer, forward, position IDs, and state-dict schema. + + In the frozen trainer the only 60-token training input is a document; QA + training inputs contain six tokens. Evaluation always uses the original + attention path, including an unusually long inference input. No dropout, + extra trainable parameter, random draw, or reset of position IDs is added. + """ + + def __init__(self, config): + super().__init__(config) + mask = fact_causal_mask() + for block in self.blocks: + attention = block.attention + attention.__class__ = FactIsolatedAttention + attention.document_attention_isolated = False + attention.register_buffer("fact_mask", mask, persistent=False) + + def forward(self, tokens, positions=None): + isolate = self.training and tokens.shape[1] == DOCUMENT_LENGTH + if self.training and tokens.shape[1] not in (RECORD_LENGTH, DOCUMENT_LENGTH): + raise ValueError("Unexpected training input length; document/QA dispatch is unsafe") + if isolate: + if positions is None or positions.shape[1] != 20: + raise ValueError("Document training must preserve all twenty supervised positions") + expected = torch.arange(DOCUMENT_LENGTH, device=tokens.device).view(10, 6)[:, 3:5] + if not torch.equal(positions, expected.reshape(1, 20).expand(len(tokens), -1)): + raise ValueError("Document supervision positions changed") + for block in self.blocks: + block.attention.document_attention_isolated = isolate + try: + return super().forward(tokens, positions) + finally: + for block in self.blocks: + block.attention.document_attention_isolated = False + + +@contextmanager +def isolated_model_factory(): + """Patch only this worker's factory while retaining the frozen trainer body.""" + original = frozen_trainer.CausalLM + if original is not CausalLM: + raise RuntimeError("The frozen trainer already has a modified model factory") + frozen_trainer.CausalLM = FactIsolatedCausalLM + try: + yield + finally: + frozen_trainer.CausalLM = original + + +def context_sources(): + directory = Path(__file__).parent + return { + **frozen_trainer.source_hashes(), + **{ + name: hashlib.sha256((directory / name).read_bytes()).hexdigest() + for name in ("bios_context_control.py", "bios_path_diagnostics.py") + }, + } + + +def validate_study(study): + expected = { + "width": 256, + "layers": 8, + "heads": 4, + "steps": 15360, + "checkpoints": list(CHECKPOINTS), + "lr": 0.0001, + "documents_per_step": 16, + "facts_per_document": 10, + "QA_per_chain_per_step": 20, + "document_QA_weights": [0.8, 0.2], + "worlds": [0, 1], + "seeds": [0, 1], + "conditions": list(CONDITIONS), + "learning_runs": 12, + "edit_cases": 0, + } + for key, value in expected.items(): + if study.get(key) != value: + raise ValueError(f"Context control changed its frozen study setting: {key}") + + +def run(args): + study = json.loads(Path(args.config).read_text()) + validate_study(study) + if args.world not in study["worlds"] or args.seed not in study["seeds"]: + raise ValueError("Context control is restricted to the development matrix") + output = Path(args.output).resolve() + output.mkdir(parents=True, exist_ok=True) + with (output / ".lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + world = make_cross_world(args.world) + world_audit = audit(world) + docs, schedule = documents(world, args.condition), qa_schedule(world, study["steps"]) + contract = { + "protocol": "v2.8-p3-context-control", + "world": args.world, + "seed": args.seed, + "condition": args.condition, + "study": study, + "sources": context_sources(), + "intervention": { + "training_document_attention": "causal within each six-token fact only", + "absolute_positions": "unchanged 0 through 59; never reset within facts", + "document_tokens_batches_and_supervision": "unchanged", + "QA_training_attention": "original causal attention", + "all_inference_attention": "original causal attention", + "mask_sha256": array_hash(fact_causal_mask().numpy()), + }, + "data": { + "truth_sha256": world_audit["truth_sha256"], + "prompts_sha256": world_audit["prompts_sha256"], + "documents_sha256": array_hash(docs), + "qa_sha256": array_hash(schedule), + }, + "environment": { + "torch": torch.__version__, + "cuda": torch.version.cuda, + "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES"), + }, + } + path = output / "launch-contract.json" + if path.exists(): + old = json.loads(path.read_text()) + for key in contract.keys() - {"environment"}: + if old[key] != contract[key]: + raise ValueError(f"Context control contract changed: {key}") + else: + write_json(path, contract) + if (output / "complete.json").exists(): + return + torch.set_num_threads(args.threads) + device = torch.device(args.device) + controlled_study = { + **study, + "context_contract": contract["sources"], + "context_intervention": contract["intervention"], + } + try: + with isolated_model_factory(): + model, _ = frozen_trainer.learning(args, world, output, controlled_study, device) + # Inference must be the original unrestricted forward path. + model.eval() + with np.load(output / f"predictions-{study['steps']}.npz") as saved: + direct = {key: saved[key] for key in ("prediction", "ended", "correct")} + for chain, name in enumerate(CHAINS): + arrays = autonomous_two_step(model, world, chain, device) + ids = world.derived_ids[chain] + arrays.update({f"direct_{key}": value[ids] for key, value in direct.items()}) + atomic_numpy_save(output / f"two-step-{name}.npz", **arrays) + write_json( + output / "complete.json", + { + "status": "complete", + "phase": "P3-context-control-learning-only", + "learning_steps": study["steps"], + "edit_cases": 0, + "finished": time.time(), + }, + ) + except Exception as error: + write_json( + output / "failure.json", + { + "type": type(error).__name__, + "message": str(error), + "time": time.time(), + }, + ) + raise + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--world", required=True, type=int) + parser.add_argument("--seed", required=True, type=int) + parser.add_argument("--condition", required=True, choices=CONDITIONS) + parser.add_argument("--config", default="configs/bios-context-control-v1.json") + parser.add_argument("--output", required=True) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_gradient.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_gradient.py new file mode 100644 index 0000000000000000000000000000000000000000..89f78f244a71569026fd75d76ac6b10b702fed9d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_context_gradient.py @@ -0,0 +1,669 @@ +"""Prospectively frozen context-statistic prediction of common-state gradients. + +The predictor contracts supervised target/context co-occurrences with fixed +embeddings and first-layer value weights. It uses neither real gradients nor +contextual activations, and has no fitted scale. It is a new residual-path +approximation, not a theorem for the project's Transformer or AdamW updates. +""" + +import argparse +import hashlib +import itertools +import json +import platform +import time +from contextlib import contextmanager +from datetime import datetime, timezone +from pathlib import Path +from types import MethodType + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_cross import ( + CONDITIONS, + documents, + epoch_documents, + make_cross_world, + qa_schedule, + render, +) +from .bios_cross_train import tensor_queries +from .bios_data import array_hash, write_json +from .bios_model import CausalLM, ModelConfig + +TARGET = "blocks.0.attention.proj.weight" +CONTRASTS = (("company", "neither"), ("project", "neither"), ("company", "project")) + + +def sha(path): + digest = hashlib.sha256() + with Path(path).open("rb") as stream: + for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def stamp(): + return datetime.now(timezone.utc).isoformat() + + +def allowed_mask(length, isolated, device=None): + pos = torch.arange(length, device=device) + mask = pos[None, :] <= pos[:, None] + if isolated: + mask &= pos[None, :] // 6 == pos[:, None] // 6 + return mask + + +def _isolated_forward(self, x): + batch, length, width = x.shape + q, k, v = self.qkv(x).view(batch, length, 3, self.heads, width // self.heads).unbind(2) + output = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + attn_mask=allowed_mask(length, True, x.device), + ) + return self.proj(output.transpose(1, 2).reshape(batch, length, width)) + + +@contextmanager +def attention_mode(model, isolated): + originals = [] + if isolated: + for block in model.blocks: + attention = block.attention + originals.append((attention, attention.forward)) + attention.forward = MethodType(_isolated_forward, attention) + try: + yield + finally: + for attention, forward in originals: + attention.forward = forward + + +def ln_vjp(x, upstream, layer): + """Exact input VJP of LayerNorm, without reading a real model gradient.""" + centered = x - x.mean(-1, keepdim=True) + inverse = torch.rsqrt(centered.square().mean(-1, keepdim=True) + layer.eps) + normalized = centered * inverse + affine = upstream * layer.weight + return inverse * ( + affine + - affine.mean(-1, keepdim=True) + - normalized * (affine * normalized).mean(-1, keepdim=True) + ) + + +@torch.no_grad() +def statistic_predictors(model, tokens, positions, labels, shuffled, isolated): + """Gradients of a zero-residual baseline plus one infinitesimal OV branch. + + x_j = E[token_j] + P[j] (or E[token_j] for the token-only control). + m_t = average_{j allowed at t} (Wv LN1(x_j) + bv). + epsilon_t = J_LNfinal(x_t)^T E^T (softmax(E LNfinal(x_t)) - onehot(y_t)). + Ghat = mean_t epsilon_t m_t^T. This is a contraction of position/mask + weighted token-target counts; all other residual branches are omitted. + The answer and EOS means returned here are separately normalized. + """ + width = model.config.width + result = {} + for position_aware in (True, False): + x = model.token(tokens) + if position_aware: + x = x + model.position(torch.arange(tokens.shape[1], device=tokens.device)) + value = F.linear( + model.blocks[0].ln1(x), + model.blocks[0].attention.qkv.weight[2 * width :], + model.blocks[0].attention.qkv.bias[2 * width :], + ) + mask = allowed_mask(tokens.shape[1], isolated, tokens.device).to(x.dtype) + mask /= mask.sum(-1, keepdim=True) + mean_value = (mask @ value)[:, positions] + query = x[:, positions] + probability = F.linear(model.ln_final(query), model.token.weight).softmax(-1) + expected = probability @ model.token.weight + variants = ( + (("position", labels), ("shuffled", shuffled)) + if position_aware + else (("token", labels),) + ) + for name, targets in variants: + epsilon = ln_vjp(query, expected - model.token(targets), model.ln_final) + for offset, kind in enumerate(("answer", "eos")): + left, right = epsilon[:, offset::2], mean_value[:, offset::2] + result[f"{name}/{kind}"] = torch.einsum("btd,bte->de", left, right) / ( + left.shape[0] * left.shape[1] + ) + return result + + +def vector_metrics(actual, predicted): + actual = np.asarray(actual, dtype=np.float64).ravel() + predicted = np.asarray(predicted, dtype=np.float64).ravel() + an, pn = np.linalg.norm(actual), np.linalg.norm(predicted) + return { + "actual_norm": float(an), + "predicted_norm": float(pn), + "cosine": float(np.dot(actual, predicted) / (an * pn)) if an and pn else None, + "relative_error": float(np.linalg.norm(actual - predicted) / an) if an else None, + "norm_ratio": float(pn / an) if an else None, + } + + +def module_name(name): + if name.startswith("blocks."): + parts = name.split(".") + if parts[2] == "attention" and parts[3] == "qkv": + return ".".join(parts[:4]) + return ".".join(parts[:3]) + return name.split(".")[0] + + +def module_differences(first, second): + sums = {} + for name in first: + # The concatenated qkv parameter is additionally split by role. + pieces = [(module_name(name), first[name], second[name])] + if ".attention.qkv." in name: + pieces = [ + (name.split(".qkv.")[0] + "." + role, a, b) + for role, a, b in zip( + ("query", "key", "value"), + np.split(first[name], 3), + np.split(second[name], 3), + strict=True, + ) + ] + for group, left, right in pieces: + values = sums.setdefault(group, np.zeros(3, dtype=np.float64)) + left, right = left.astype(np.float64), right.astype(np.float64) + values += (np.sum((left - right) ** 2), np.sum(left**2), np.sum(right**2)) + return { + group: { + "difference_norm": float(np.sqrt(value[0])), + "relative_to_mean_arm_norm": float( + np.sqrt(value[0]) / ((np.sqrt(value[1]) + np.sqrt(value[2])) / 2) + ) + if value[1] + value[2] + else None, + } + for group, value in sums.items() + } + + +def source_files(root, config): + names = [ + "bios_context_gradient.py", + "bios_cross.py", + "bios_cross_train.py", + "bios_data.py", + "bios_model.py", + "bios_train.py", + "bios_organization_train.py", + "bios_organization.py", + ] + paths = [root / "src/llm_memory_editability" / name for name in names] + paths += [ + root / "scripts/run_bios_context_gradient.py", + root / "tests/test_bios_context_gradient.py", + ] + paths += [root / "configs/bios-context-gradient-v1.json"] + for world in config["worlds"]: + paths += [ + root / config["source_world_root"] / f"world-{world}" / name + for name in ("world.npz", "metadata.json", "audit.json") + ] + return paths + + +def freeze(root, config): + out = root / config["artifacts"] + lockpath = out / "preregistration-lock.json" + if lockpath.exists(): + raise FileExistsError("An existing prospective lock must not be replaced") + protocol = (root / "docs/experimental-protocol.md").read_text().split("## 16. ", 1)[1] + out.mkdir(parents=True, exist_ok=True) + (out / "preregistration.md").write_text("## 16. " + protocol) + sources = {} + for path in source_files(root, config): + relative = path.relative_to(root) + sources[str(relative)] = sha(path) + # Data stay in their original location, hash-bound by the lock. + if relative.parts[0] != "data": + copy = out / "frozen-files" / relative + copy.parent.mkdir(parents=True, exist_ok=True) + copy.write_bytes(path.read_bytes()) + write_json( + lockpath, + { + "created_at": stamp(), + "config": config, + "sources": sources, + "protocol_sha256": sha(out / "preregistration.md"), + "torch": torch.__version__, + "numpy": np.__version__, + "python": platform.python_version(), + }, + ) + return {"lock": str(lockpath), "sha256": sha(lockpath)} + + +def verify_lock(root, config): + lockpath = root / config["artifacts"] / "preregistration-lock.json" + lock = json.loads(lockpath.read_text()) + if lock["config"] != config: + raise ValueError("Configuration differs from prospective lock") + for path, expected in lock["sources"].items(): + if sha(root / path) != expected: + raise ValueError("Frozen source changed: " + path) + if sha(root / config["artifacts"] / "preregistration.md") != lock["protocol_sha256"]: + raise ValueError("Prospective protocol changed") + return sha(lockpath) + + +def context_audit(world, config): + """Exact exposure/bigram audit plus a centered city-by-person Phi subblock.""" + people = [i for i, label in enumerate(world.token_labels) if label.startswith("person:")] + cities = np.unique(world.city_tokens) + pi, ci = np.full(world.vocab_size, -1), np.full(world.vocab_size, -1) + pi[people], ci[cities] = np.arange(len(people)), np.arange(len(cities)) + histograms, contexts, receipts = {}, {}, {} + for condition in CONDITIONS: + docs = documents(world, condition) + receipts[condition] = {"documents_sha256": array_hash(docs)} + counts = np.bincount(docs.ravel(), minlength=world.n_base) + receipts[condition]["exposure_sha256"] = array_hash(counts) + for isolated in (False, True): + joint = np.zeros((len(cities), len(people))) + marginal = np.zeros(len(people)) + bigrams = np.zeros((2, world.vocab_size), dtype=np.int64) + for epoch in range(config["rotations"]): + batch = render(world, epoch_documents(docs, world.seed, epoch)) + for col, pos in enumerate(batch["positions"][0]): + targets = batch["labels"][:, col] + # All answer predictors use ANS; EOS predictors use answer tokens. + values = targets if col % 2 == 0 else batch["tokens"][:, pos] + bigrams[col % 2] += np.bincount(values, minlength=world.vocab_size) + left = int(pos) // 6 * 6 if isolated else 0 + weight = 1 / (int(pos) - left + 1) + rows = ci[targets] + for prefix in range(left, int(pos) + 1): + columns = pi[batch["tokens"][:, prefix]] + valid = columns >= 0 + np.add.at(marginal, columns[valid], weight) + valid &= rows >= 0 + np.add.at(joint, (rows[valid], columns[valid]), weight) + contexts[condition, isolated] = (joint - marginal[None] / world.vocab_size) / ( + config["rotations"] * len(docs) * 20 + ) + histograms[condition] = bigrams + result = {"receipts": receipts, "comparisons": []} + for a, b in CONTRASTS: + equal = np.array_equal(histograms[a], histograms[b]) + if not equal or receipts[a]["exposure_sha256"] != receipts[b]["exposure_sha256"]: + raise ValueError("Organization exposure or supervised bigrams differ") + for isolated in (False, True): + first, second = contexts[a, isolated], contexts[b, isolated] + difference = np.max(np.abs(first - second)) + if isolated and difference > 1e-14: + raise ValueError("Isolated context statistics differ") + result["comparisons"].append( + { + "first": a, + "second": b, + "isolated": isolated, + "supervised_bigram_equal": equal, + "context_max_abs_difference": float(difference), + "context_relative_difference": float( + np.linalg.norm(first - second) / np.linalg.norm(second) + ), + } + ) + result["bigram_sha256"] = array_hash(histograms["neither"]) + result["qa_ids_sha256"] = array_hash(world.train_ids) + return result + + +def numpy_gradients(accumulators): + return {name: value.cpu().numpy().astype(np.float32) for name, value in accumulators.items()} + + +def measure_arm(model, world, condition, isolated, config, device, out): + docs = documents(world, condition) + named = dict(model.named_parameters()) + params = tuple(named.values()) + accumulators = { + kind: {name: torch.zeros_like(value, dtype=torch.float64) for name, value in named.items()} + for kind in ("answer", "eos") + } + predictions = { + f"{predictor}/{kind}": torch.zeros( + (model.config.width, model.config.width), dtype=torch.float64, device=device + ) + for predictor in config["predictors"] + for kind in ("answer", "eos") + } + losses = {"answer": 0.0, "eos": 0.0} + total_documents = len(docs) * config["rotations"] + started = time.perf_counter() + model.eval() + with attention_mode(model, isolated): + for epoch in range(config["rotations"]): + batch = render(world, epoch_documents(docs, world.seed, epoch)) + shuffled = batch["labels"].copy() + rng = np.random.default_rng( + np.random.SeedSequence([config["shuffle_seed"], world.seed, epoch]) + ) + # Each column is one relation at one absolute position. Marginals + # are exactly preserved, with the same permutations in every arm. + for col in range(shuffled.shape[1]): + shuffled[:, col] = shuffled[rng.permutation(len(docs)), col] + for begin in range(0, len(docs), config["measurement_batch"]): + end = min(begin + config["measurement_batch"], len(docs)) + tokens = torch.as_tensor(batch["tokens"][begin:end], device=device) + labels = torch.as_tensor(batch["labels"][begin:end], device=device) + positions = torch.as_tensor(batch["positions"][0], device=device) + shuffled_batch = torch.as_tensor(shuffled[begin:end], device=device) + weight = config["document_weight"] * 0.5 * (end - begin) / total_documents + predictors = statistic_predictors( + model, tokens, positions, labels, shuffled_batch, isolated + ) + for name, prediction in predictors.items(): + predictions[name].add_(prediction.double(), alpha=weight) + logits = model(tokens, positions[None].expand(len(tokens), -1)) + for offset, kind in enumerate(("answer", "eos")): + loss = F.cross_entropy( + logits[:, offset::2].flatten(0, 1), labels[:, offset::2].flatten() + ) + gradients = torch.autograd.grad(loss, params, retain_graph=offset == 0) + for name, gradient in zip(named, gradients, strict=True): + accumulators[kind][name].add_(gradient.double(), alpha=weight) + losses[kind] += float(loss.detach()) * (end - begin) / total_documents + print( + json.dumps({"event": "rotation", "arm": out.name, "rotation": epoch + 1}), + flush=True, + ) + result = {kind: numpy_gradients(accumulators[kind]) for kind in accumulators} + result["predictions"] = numpy_gradients(predictions) + out.mkdir(parents=True, exist_ok=False) + np.savez(out / "answer.npz", **result["answer"]) + np.savez(out / "eos.npz", **result["eos"]) + np.savez(out / "predictions.npz", **result["predictions"]) + metadata = { + "condition": condition, + "isolated": isolated, + "documents": total_documents, + "supervised_tokens": total_documents * 20, + "losses": losses, + "seconds": time.perf_counter() - started, + "files": {name: sha(out / name) for name in ("answer.npz", "eos.npz", "predictions.npz")}, + } + if any(not np.isfinite(value).all() for part in result.values() for value in part.values()): + raise FloatingPointError("Nonfinite gradients or predictions") + write_json(out / "receipt.json", metadata) + return result + + +def arm_data(path): + return { + kind: dict(np.load(path / f"{filename}.npz")) + for kind, filename in (("answer", "answer"), ("eos", "eos"), ("predictions", "predictions")) + } + + +def common_training_step(model, optimizer, world, config, step, device, schedule, data): + epoch, offset = divmod(step, 128) + arranged = epoch_documents(documents(world, "neither"), world.seed, epoch) + batch = render(world, arranged[offset * 16 : (offset + 1) * 16]) + tokens = torch.as_tensor(batch["tokens"], device=device) + positions = torch.as_tensor(batch["positions"], device=device) + labels = torch.as_tensor(batch["labels"], device=device) + qa = torch.as_tensor(schedule[step], device=device) + model.train() + optimizer.zero_grad(set_to_none=True) + for group in optimizer.param_groups: + group["lr"] = config["lr"] * min((epoch + 1) / config["warmup_epochs"], 1) + loss = F.cross_entropy(model(tokens, positions).flatten(0, 1), labels.flatten()) + (config["document_weight"] * loss).backward() + qa_loss = F.cross_entropy( + model(data["tokens"][qa], data["positions"][qa]).flatten(0, 1), data["labels"][qa].flatten() + ) + (config["qa_weight"] * qa_loss).backward() + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), config["clip_norm"]) + if not torch.isfinite(loss + qa_loss + norm): + raise FloatingPointError("Nonfinite common training step") + optimizer.step() + return { + "step": step + 1, + "document_loss": float(loss.detach()), + "qa_loss": float(qa_loss.detach()), + } + + +def run(root, config, world_seed, seed, device): + lock_hash = verify_lock(root, config) + if world_seed not in config["worlds"] or seed not in config["seeds"]: + raise ValueError("World/initialization is outside the frozen matrix") + torch.set_num_threads(2) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.manual_seed(seed) + world = make_cross_world(world_seed, root / config["source_world_root"]) + out = root / config["output"] / f"world-{world_seed}-seed-{seed}" + out.mkdir(parents=True, exist_ok=True) + if (out / "complete.json").exists(): + raise FileExistsError("Completed run cannot be overwritten") + audit_path = out / "data-audit.json" + if not audit_path.exists(): + write_json(audit_path, context_audit(world, config)) + model = CausalLM( + ModelConfig( + world.vocab_size, config["width"], config["layers"], config["heads"], config["context"] + ) + ).to(device) + optimizer = torch.optim.AdamW( + model.parameters(), + lr=config["lr"], + weight_decay=config["weight_decay"], + fused=device.type == "cuda", + ) + schedule = qa_schedule(world, max(config["states"])) + data = tensor_queries(world, device) + trajectory = [] + write_json( + out / "identity.json", + { + "world": world_seed, + "seed": seed, + "lock_sha256": lock_hash, + "created_at": stamp(), + "model": model.config_dict(), + "parameters": sum(p.numel() for p in model.parameters()), + "device": str(device), + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "torch": torch.__version__, + "numpy": np.__version__, + "qa_schedule_sha256": array_hash(schedule), + }, + ) + for step in range(max(config["states"]) + 1): + if step in config["states"]: + state_path = out / f"state-{step}.pt" + if state_path.exists(): + # Resumption reconstructs the exact common trajectory and verifies + # weights before using any existing diagnostic artifacts. + saved = torch.load(state_path, map_location=device, weights_only=False) + if any( + not torch.equal(v, saved["model"][k]) for k, v in model.state_dict().items() + ): + raise ValueError("Reconstructed reference weights differ") + else: + torch.save( + { + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "step": step, + "config": model.config_dict(), + }, + state_path, + ) + for mask in config["masks"]: + for condition in config["conditions"]: + path = out / f"step-{step}-{mask}-{condition}" + if (path / "receipt.json").exists(): + receipt = json.loads((path / "receipt.json").read_text()) + if any( + sha(path / name) != digest for name, digest in receipt["files"].items() + ): + raise ValueError("Existing gradient artifact hash mismatch") + continue + if path.exists(): + raise FileExistsError("Incomplete output must be retained and audited") + print( + json.dumps( + { + "event": "arm_start", + "world": world_seed, + "seed": seed, + "step": step, + "mask": mask, + "condition": condition, + } + ), + flush=True, + ) + measure_arm(model, world, condition, mask == "isolated", config, device, path) + write_json(out / "trajectory.json", trajectory) + if step < max(config["states"]): + trajectory.append( + common_training_step(model, optimizer, world, config, step, device, schedule, data) + ) + verify_lock(root, config) + files = {str(path.relative_to(out)): sha(path) for path in out.rglob("*") if path.is_file()} + write_json( + out / "complete.json", {"completed_at": stamp(), "lock_sha256": lock_hash, "files": files} + ) + + +def summarize(root, config): + verify_lock(root, config) + rows, modules, checks = [], [], [] + for world_seed, seed in itertools.product(config["worlds"], config["seeds"]): + runpath = root / config["output"] / f"world-{world_seed}-seed-{seed}" + completion = json.loads((runpath / "complete.json").read_text()) + for name, digest in completion["files"].items(): + if sha(runpath / name) != digest: + raise ValueError("Completed run artifact changed: " + name) + for step, mask in itertools.product(config["states"], config["masks"]): + arms = {c: arm_data(runpath / f"step-{step}-{mask}-{c}") for c in CONDITIONS} + for a, b in CONTRASTS: + identity = { + "world": world_seed, + "seed": seed, + "step": step, + "mask": mask, + "first": a, + "second": b, + } + for kind in ("answer", "eos", "combined"): + kinds = ("answer", "eos") if kind == "combined" else (kind,) + ga = {n: sum(arms[a][k][n] for k in kinds) for n in arms[a]["answer"]} + gb = {n: sum(arms[b][k][n] for k in kinds) for n in arms[b]["answer"]} + modules.append( + {**identity, "kind": kind, "modules": module_differences(ga, gb)} + ) + for predictor in config["predictors"]: + pred = sum( + arms[a]["predictions"][f"{predictor}/{k}"] + - arms[b]["predictions"][f"{predictor}/{k}"] + for k in kinds + ) + row = { + **identity, + "kind": kind, + "predictor": predictor, + **vector_metrics(ga[TARGET] - gb[TARGET], pred), + } + # Near-zero isolated contrasts are cancellation controls; + # cosine between rounding residues has no scientific meaning. + if mask == "isolated": + row["cosine"] = None + rows.append(row) + norm = np.linalg.norm(ga[TARGET] - gb[TARGET]) + reference = (np.linalg.norm(ga[TARGET]) + np.linalg.norm(gb[TARGET])) / 2 + if mask == "isolated": + checks.append( + { + **identity, + "kind": kind, + "relative_cancellation_residue": float(norm / reference), + } + ) + if any(c["relative_cancellation_residue"] > 1e-4 for c in checks): + raise ValueError("Isolated common-state gradient cancellation failed") + out = root / config["artifacts"] + write_json(out / "metrics.json", rows) + write_json(out / "module-metrics.json", modules) + write_json( + out / "audit.json", + {"passed": True, "runs": 4, "arms": 72, "isolated_checks": checks, "completed_at": stamp()}, + ) + primary = [ + r + for r in rows + if r["step"] == 0 + and r["mask"] == "open" + and r["kind"] == "answer" + and r["second"] == "neither" + ] + lines = [ + "# Context statistics and common-state gradients", + "", + "Descriptive development experiment; no fitted scale or significance tests.", + "", + "| World | Seed | Contrast | Predictor | Cosine | Relative error | Norm ratio |", + "| --- | --- | --- | --- | ---: | ---: | ---: |", + ] + for row in primary: + lines.append( + f"| {row['world']} | {row['seed']} | {row['first']}−{row['second']} | " + f"{row['predictor']} | {row['cosine']:.6f} | {row['relative_error']:.6f} | " + f"{row['norm_ratio']:.6f} |" + ) + (out / "report.md").write_text("\n".join(lines) + "\n") + print( + json.dumps( + { + "report": str(out / "report.md"), + "rows": len(rows), + "max_isolated_residue": max(c["relative_cancellation_residue"] for c in checks), + } + ) + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("mode", choices=("freeze", "run", "summarize")) + parser.add_argument("--world", type=int) + parser.add_argument("--seed", type=int) + parser.add_argument("--device", default="cuda:0") + parser.add_argument( + "--config", type=Path, default=Path("configs/bios-context-gradient-v1.json") + ) + args = parser.parse_args() + root = Path(__file__).resolve().parents[2] + config = json.loads((root / args.config).read_text()) + if args.mode == "freeze": + print(json.dumps(freeze(root, config))) + elif args.mode == "run": + run(root, config, args.world, args.seed, torch.device(args.device)) + else: + summarize(root, config) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross.py new file mode 100644 index 0000000000000000000000000000000000000000..960ef7e03dd29b834df68149d8aca7cbcd077a10 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross.py @@ -0,0 +1,330 @@ +"""Two-chain organization crossover: shared facts, symmetric relational tasks. + +This is a new development world, not an alteration of the archived A/B/C runs. +Company and project each have 64 groups of 32 people and two old exceptions. +""" + +from dataclasses import dataclass +from pathlib import Path + +import numpy as np + +from .bios_data import ANS, BOS, EOS, N_BASE, N_PEOPLE, array_hash, load_world, rng_for, write_json + +CONDITIONS = ("company", "project", "neither") +CHAINS = ("company", "project") +SLOTS = 10 + + +@dataclass +class CrossWorld: + seed: int + prompts: np.ndarray + lengths: np.ndarray + answers: np.ndarray + relation: np.ndarray + person: np.ndarray + memberships: np.ndarray + defaults: np.ndarray + exceptions: np.ndarray + membership_ids: np.ndarray + root_ids: np.ndarray + actual_ids: np.ndarray + derived_ids: np.ndarray + train_ids: np.ndarray + heldout_ids: np.ndarray + city_tokens: np.ndarray + token_labels: list + n_base: int + + @property + def vocab_size(self): + return len(self.token_labels) + + +def make_cross_world(seed, source_root="data/bios-organization-v1"): + old = load_world(Path(source_root) / f"world-{seed}") + labels = ( + old.token_labels + + [f"project:{i}" for i in range(64)] + + ["relation:project", "relation:project_default", "relation:project_actual"] + ) + token = {name: i for i, name in enumerate(labels)} + rng = rng_for(seed, 901) + memberships = np.stack([old.employers, rng.permutation(np.repeat(np.arange(64), 32))]) + defaults = np.stack([old.defaults, rng.permutation(old.defaults)]) + exceptions = np.stack([old.exceptions, np.zeros(N_PEOPLE, dtype=bool)]) + actual = defaults[1, memberships[1]].copy() + for group in range(64): + people = rng.choice(np.flatnonzero(memberships[1] == group), 2, replace=False) + exceptions[1, people] = True + choices = np.unique(defaults[1][defaults[1] != defaults[1, group]]) + actual[people] = rng.choice(choices, 2) + n_base = N_BASE + 2 * N_PEOPLE + 64 + size = n_base + 2 * N_PEOPLE + prompts = np.zeros((size, 5), dtype=np.int64) + answers = np.zeros(size, dtype=np.int64) + lengths = np.full(size, 4, dtype=np.int64) + relation = np.zeros(size, dtype=np.int64) + person = np.full(size, -1, dtype=np.int64) + prompts[:N_BASE], answers[:N_BASE] = old.prompts[:N_BASE], old.answers[:N_BASE] + relation[:N_BASE], person[:N_BASE] = old.relation[:N_BASE], old.person[:N_BASE] + membership_ids = np.stack([np.arange(N_PEOPLE), N_BASE + np.arange(N_PEOPLE)]) + root_ids = np.stack([N_PEOPLE + np.arange(64), N_BASE + N_PEOPLE + np.arange(64)]) + actual_ids = np.stack( + [N_PEOPLE + 64 + np.arange(N_PEOPLE), N_BASE + N_PEOPLE + 64 + np.arange(N_PEOPLE)] + ) + person_tokens = np.array([token[f"person:{i}"] for i in range(N_PEOPLE)]) + new_values = [ + np.array([token[f"project:{i}"] for i in memberships[1]]), + old.city_tokens[defaults[1]], + old.city_tokens[actual], + ] + for rel, ids, values in zip( + (7, 8, 9), (membership_ids[1], root_ids[1], actual_ids[1]), new_values, strict=True + ): + subjects = ( + np.array([token[f"project:{i}"] for i in range(64)]) if rel == 8 else person_tokens + ) + rtoken = token[ + ("relation:project", "relation:project_default", "relation:project_actual")[rel - 7] + ] + prompts[ids, :4] = np.column_stack( + [np.full(len(ids), BOS), subjects, np.full(len(ids), rtoken), np.full(len(ids), ANS)] + ) + answers[ids], relation[ids] = values, rel + if rel != 8: + person[ids] = np.arange(N_PEOPLE) + derived_ids = n_base + np.arange(2 * N_PEOPLE).reshape(2, N_PEOPLE) + trained, heldout = [], [] + for chain in range(2): + ids = derived_ids[chain] + prompts[ids] = np.column_stack( + [ + np.full(N_PEOPLE, BOS), + person_tokens, + np.full(N_PEOPLE, token["relation:employer" if chain == 0 else "relation:project"]), + np.full( + N_PEOPLE, + token["relation:default_city" if chain == 0 else "relation:project_default"], + ), + np.full(N_PEOPLE, ANS), + ] + ) + answers[ids] = old.city_tokens[defaults[chain, memberships[chain]]] + lengths[ids], relation[ids], person[ids] = 5, 10 + chain, np.arange(N_PEOPLE) + split_rng = rng_for(seed, 902, chain) + included = [] + for group in range(64): + for exception in (False, True): + candidates = np.flatnonzero( + (memberships[chain] == group) & (exceptions[chain] == exception) + ) + included.extend(split_rng.permutation(candidates)[: len(candidates) // 2]) + trained.append(np.sort(ids[included])) + heldout.append(np.setdiff1d(ids, trained[-1])) + # Randomize the complete vocabulary, so appended token numbers carry no task order. + permutation = np.arange(len(labels)) + permutation[4:] = rng_for(seed, 903).permutation(permutation[4:]) + new_labels = [""] * len(labels) + for index, label in enumerate(labels): + new_labels[permutation[index]] = label + return CrossWorld( + seed, + permutation[prompts], + lengths, + permutation[answers], + relation, + person, + memberships, + defaults, + exceptions, + membership_ids, + root_ids, + actual_ids, + derived_ids, + np.stack(trained), + np.stack(heldout), + permutation[old.city_tokens], + new_labels, + n_base, + ) + + +def documents(world, condition): + if condition not in CONDITIONS: + raise ValueError("Unknown crossover condition") + docs = np.empty((N_PEOPLE, SLOTS), dtype=np.int64) + for rel in range(SLOTS): + if rel in (1, 8): + continue + ids = np.flatnonzero(world.relation[: world.n_base] == rel) + docs[world.person[ids], rel] = ids + for chain, slot in enumerate((1, 8)): + membership = world.memberships[chain] + group = membership.copy() + if condition != CHAINS[chain]: + rng = rng_for(world.seed, 904, chain) + members = np.stack( + [rng.permutation(np.flatnonzero(membership == g)) for g in range(64)] + ) + for lane in range(32): + cycle = rng.permutation(64) + group[members[cycle, lane]] = np.roll(cycle, -1) + docs[:, slot] = world.root_ids[chain, group] + return docs + + +def epoch_documents(docs, seed, epoch): + rows = rng_for(seed, 905, epoch).permutation(N_PEOPLE) + return np.roll(docs[rows], epoch % SLOTS, axis=1) + + +def render(world, ids): + tokens = np.empty((*ids.shape, 6), dtype=np.int64) + tokens[:, :, :4] = world.prompts[ids, :4] + tokens[:, :, 4], tokens[:, :, 5] = world.answers[ids], EOS + positions = (np.arange(SLOTS)[:, None] * 6 + np.array([3, 4])).ravel() + labels = np.stack([world.answers[ids], np.full_like(ids, EOS)], axis=-1) + return { + "tokens": tokens.reshape(len(ids), SLOTS * 6), + "positions": np.broadcast_to(positions, (len(ids), SLOTS * 2)).copy(), + "labels": labels.reshape(len(ids), SLOTS * 2), + } + + +def qa_schedule(world, steps): + streams = [] + for chain in range(2): + rng = rng_for(world.seed, 906, chain) + pool = world.train_ids[chain] + streams.append( + np.concatenate( + [rng.permutation(pool) for _ in range((steps * 20 + len(pool) - 1) // len(pool))] + )[: steps * 20].reshape(steps, 20) + ) + return np.concatenate(streams, axis=1) + + +def audit(world): + expected = np.ones(world.n_base, dtype=np.int64) + expected[world.root_ids.ravel()] = 32 + report = {} + for condition in CONDITIONS: + docs = documents(world, condition) + if not np.array_equal(np.bincount(docs.ravel(), minlength=world.n_base), expected): + raise ValueError("Unequal fact exposure") + personal = world.person[docs[:, [0, 2, 3, 4, 5, 6, 7, 9]]] + if not np.all(personal == np.arange(N_PEOPLE)[:, None]): + raise ValueError("Person grouping changed") + for chain, slot in enumerate((1, 8)): + linked = docs[:, slot] == world.root_ids[chain, world.memberships[chain]] + if not np.all(linked == (condition == CHAINS[chain])): + raise ValueError("Incorrect linked/unlinked manipulation") + slots = np.zeros((world.n_base, SLOTS), dtype=np.int64) + for epoch in range(SLOTS): + arranged = epoch_documents(docs, world.seed, epoch) + np.add.at(slots, (arranged, np.arange(SLOTS)[None, :]), 1) + if not np.array_equal(slots, np.repeat(expected[:, None], SLOTS, axis=1)): + raise ValueError("Unequal position exposure") + report[condition] = { + "documents_sha256": array_hash(docs), + "exposure_sha256": array_hash(expected), + } + for chain in range(2): + if not np.array_equal(np.bincount(world.memberships[chain]), np.full(64, 32)): + raise ValueError("Unequal group sizes") + for group in range(64): + members = world.memberships[chain] == group + if world.exceptions[chain, members].sum() != 2: + raise ValueError("Unequal exceptions") + if len(np.intersect1d(world.train_ids[chain], world.heldout_ids[chain])): + raise ValueError("QA leakage") + truth = world.city_tokens[world.defaults[chain, world.memberships[chain]]] + np.testing.assert_array_equal(world.answers[world.derived_ids[chain]], truth) + np.testing.assert_array_equal(np.sort(world.defaults[0]), np.sort(world.defaults[1])) + return { + "passed": True, + "world": world.seed, + "conditions": report, + "base_facts": world.n_base, + "queries": len(world.answers), + "truth_sha256": array_hash(world.answers), + "prompts_sha256": array_hash(world.prompts), + "QA_train_per_chain": 1024, + "QA_heldout_per_chain": 1024, + } + + +def save_world(world, directory): + directory = Path(directory) + directory.mkdir(parents=True, exist_ok=True) + np.savez_compressed( + directory / "world.npz", + **{key: value for key, value in vars(world).items() if isinstance(value, np.ndarray)}, + ) + write_json( + directory / "metadata.json", + {"seed": world.seed, "n_base": world.n_base, "token_labels": world.token_labels}, + ) + write_json(directory / "audit.json", audit(world)) + + +def edit_pair(world, chain, support=0): + rng = rng_for(world.seed, 907, chain * 100 + support) + while True: + groups = rng.choice(64, 3, replace=False) + if len(set(world.defaults[chain, groups])) == 3: + break + coherent, exception = world.answers.copy(), world.answers.copy() + conflict_people = [] + for j, group in enumerate(groups): + new, alt = world.city_tokens[world.defaults[chain, groups[[(j + 1) % 3, (j + 2) % 3]]]] + root = world.root_ids[chain, group] + coherent[root] = exception[root] = new + members = rng.permutation( + np.flatnonzero((world.memberships[chain] == group) & ~world.exceptions[chain]) + ) + ids = world.actual_ids[chain, members] + coherent[ids] = new + exception[ids[:15]], exception[ids[15:]] = new, alt + conflict_people.extend(members[15:]) + derived = world.derived_ids[chain, world.memberships[chain] == group] + coherent[derived] = exception[derived] = new + changed = coherent != world.answers + np.testing.assert_array_equal(changed, exception != world.answers) + e, d = np.flatnonzero(changed[: world.n_base]), np.flatnonzero(changed & (world.relation >= 10)) + assert len(e) == 93 and len(d) == 96 + np.testing.assert_array_equal(np.sort(coherent[e]), np.sort(exception[e])) + # Disjoint retention strata: old exceptions, other facts of affected people, + # remaining task-chain facts, and remaining independent/cross-chain facts. + selected_people = np.isin(world.memberships[chain], groups) + selected_facts = (world.person >= 0) & selected_people[np.maximum(world.person, 0)] + old_exceptions = np.zeros(len(world.answers), dtype=bool) + old_exceptions[world.actual_ids[chain, selected_people & world.exceptions[chain]]] = True + relevant = np.isin(world.relation, [0, 1, 2, 10] if chain == 0 else [7, 8, 9, 11]) + strata = np.full(len(world.answers), -1, dtype=np.int64) + strata[~changed & old_exceptions] = 0 + strata[~changed & selected_facts & ~old_exceptions] = 1 + strata[~changed & ~selected_facts & relevant] = 2 + strata[~changed & ~selected_facts & ~relevant] = 3 + assert np.array_equal(strata >= 0, ~changed) + heldout, replay_pool = [], [] + for g in range(4): + ids = rng.permutation(np.flatnonzero((strata == g) & (world.relation < 10))) + n = max(1, int(np.ceil(0.2 * len(ids)))) + heldout.extend(ids[:n]) + replay_pool.extend(ids[n:]) + heldout.extend(np.flatnonzero((strata >= 0) & (world.relation >= 10))) + replay = rng.choice(replay_pool, min(4096, len(replay_pool)), replace=False) + return { + "coherent": coherent, + "exception": exception, + "E": e, + "D": d, + "conflict_D": world.derived_ids[chain, conflict_people], + "strata": strata, + "heldout": np.array(sorted(heldout)), + "replay": replay, + "groups": groups, + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_continue.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_continue.py new file mode 100644 index 0000000000000000000000000000000000000000..df0a21278c640164306e05b7465e24cc0e6d0df8 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_continue.py @@ -0,0 +1,627 @@ +"""Protocol v2.8 P2: audited continuation of frozen crossover checkpoints.""" + +import argparse +import copy +import fcntl +import hashlib +import json +import os +import platform +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_cross import ( + CHAINS, + audit, + documents, + edit_pair, + epoch_documents, + make_cross_world, + qa_schedule, + render, +) +from .bios_cross_train import edit_metrics as original_edit_metrics +from .bios_cross_train import evaluate, learning_metrics, source_hashes, tensor_queries +from .bios_data import array_hash, rng_for, write_json +from .bios_model import CausalLM, ModelConfig, matmul_flops, select_parameters +from .bios_organization_train import atomic_numpy_save, atomic_torch_save, state_hash +from .bios_train import precision + +PARENT_STEP = 15360 +FINAL_STEP = 30720 +CHECKPOINTS = (15360, 20480, 25600, 30720) +EDIT_CHECKPOINTS = (0, 32, 128, 512) + + +def file_hash(path): + digest = hashlib.sha256() + with Path(path).open("rb") as stream: + for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def continuation_sources(): + return {**source_hashes(), Path(__file__).name: file_hash(__file__)} + + +def tree_hash(value): + """Stable audit hash for nested optimizer/RNG states, without pickle metadata.""" + digest = hashlib.sha256() + + def visit(item): + if isinstance(item, torch.Tensor): + item = item.detach().cpu().contiguous() + digest.update(f"tensor:{item.dtype}:{tuple(item.shape)}:".encode()) + digest.update(item.reshape(-1).view(torch.uint8).numpy().tobytes()) + elif isinstance(item, np.ndarray): + digest.update(f"numpy:{item.dtype}:{item.shape}:".encode()) + digest.update(np.ascontiguousarray(item).tobytes()) + elif isinstance(item, dict): + digest.update(b"dict[") + for key in sorted(item, key=lambda key: (type(key).__name__, str(key))): + visit(key) + visit(item[key]) + digest.update(b"]") + elif isinstance(item, (list, tuple)): + digest.update(type(item).__name__.encode() + b"[") + for child in item: + visit(child) + digest.update(b"]") + else: + digest.update(f"{type(item).__name__}:{item!r};".encode()) + + visit(value) + return digest.hexdigest() + + +def continuation_lr(base_lr, absolute_step): + """Use the original absolute epoch; never restart warmup at a branch point.""" + return base_lr * min((absolute_step // 128 + 1) / 16, 1) + + +def validate_optimizer(optimizer_state, step, learning_rate): + states = optimizer_state["state"] + groups = optimizer_state["param_groups"] + if not states or sum(len(group["params"]) for group in groups) != len(states): + raise ValueError("Missing parent optimizer moments") + for state in states.values(): + if not {"step", "exp_avg", "exp_avg_sq"} <= state.keys(): + raise ValueError("Incomplete AdamW state") + if int(state["step"]) != step: + raise ValueError("Optimizer update count differs from checkpoint step") + for group in groups: + if group["lr"] != learning_rate or group["weight_decay"] != 0.1: + raise ValueError("Parent optimizer learning rate or decay changed") + + +def expected_exposure(world, docs, schedule, step, base_lr): + """Reconstruct original full-epoch exposure, positions, and LR-weighted exposure.""" + epochs, remainder = divmod(step, 128) + if remainder: + raise ValueError("Parent must end on a complete document epoch") + occurrence = np.bincount(docs.ravel(), minlength=world.n_base) + counts = np.bincount(schedule[:step].ravel(), minlength=len(world.answers)) + counts[: world.n_base] += epochs * occurrence + slots = np.repeat((occurrence * (epochs // 10))[:, None], 10, axis=1) + for epoch in range(epochs % 10): + arranged = np.roll(docs, epoch, axis=1) + np.add.at(slots, (arranged, np.arange(10)[None, :]), 1) + weighted = np.zeros(len(world.answers), dtype=np.float64) + weighted[: world.n_base] = occurrence * sum( + continuation_lr(base_lr, epoch * 128) for epoch in range(epochs) + ) + rates = np.repeat([continuation_lr(base_lr, i) for i in range(step)], 40) + np.add.at(weighted, schedule[:step].ravel(), rates) + return counts, slots, weighted + + +def validate_parent(parent, world, new_lr): + """Verify immutable parent provenance and the longer stream before any updates.""" + parent = Path(parent).resolve() + config = json.loads((parent / "config.json").read_text()) + study = config["study"] + if study["width"] not in (128, 256) or config["world"] not in (0, 1): + raise ValueError("P2 includes only the two declared sizes and development worlds") + if config["seed"] not in (0, 1) or config["condition"] not in ("company", "project", "neither"): + raise ValueError("Unexpected P2 initialization or organization") + if new_lr not in (0.0001, 0.0003) or (new_lr == 0.0003 and config["seed"] != 0): + raise ValueError("The sensitivity branch contains only initialization zero") + if study["steps"] != PARENT_STEP or study["lr"] != 0.0001: + raise ValueError("P2 must fork the original 15360-step, 1e-4 trajectory") + if config["sources"] != source_hashes(): + raise ValueError("Frozen parent training sources changed") + if config["torch"] != torch.__version__ or config["numpy"] != np.__version__: + raise ValueError("Parent Torch/NumPy versions differ from continuation") + if config["world"] != world.seed or config["truth_sha256"] != array_hash(world.answers): + raise ValueError("Parent world/truth mismatch") + if config["prompts_sha256"] != array_hash(world.prompts): + raise ValueError("Parent query prompts changed") + for name, expected in { + "layers": 8, + "heads": study["width"] // 64, + "documents_per_step": 16, + "facts_per_document": 10, + "QA_per_chain_per_step": 20, + "document_QA_weights": [0.8, 0.2], + "edit_steps": 512, + "edit_lr": 0.00003, + "retention_kl": 1.0, + }.items(): + if study[name] != expected: + raise ValueError(f"Unexpected frozen parent setting: {name}") + docs, schedule = documents(world, config["condition"]), qa_schedule(world, FINAL_STEP) + with np.load(parent / "schedule.npz") as old: + np.testing.assert_array_equal(docs, old["documents"]) + np.testing.assert_array_equal(schedule[:PARENT_STEP], old["qa"]) + if array_hash(docs) != config["documents_sha256"]: + raise ValueError("Parent document hash mismatch") + if array_hash(schedule[:PARENT_STEP]) != config["qa_sha256"]: + raise ValueError("Extended QA stream does not preserve the original prefix") + resume = torch.load(parent / "resume.pt", map_location="cpu", weights_only=False) + if resume["step"] != PARENT_STEP or resume["config_sha256"] != file_hash( + parent / "config.json" + ): + raise ValueError("Parent resume step/config mismatch") + validate_optimizer(resume["optimizer"], PARENT_STEP, study["lr"]) + saved_model = torch.load( + parent / f"model-{PARENT_STEP}.pt", map_location="cpu", weights_only=False + ) + completed = json.loads((parent / "learning-complete.json").read_text()) + model_hash = state_hash(resume["model"]) + if ( + model_hash != state_hash(saved_model["model"]) + or model_hash != completed["model_sha256"] + or saved_model["step"] != PARENT_STEP + or saved_model["config"] != config["model"] + ): + raise ValueError("Parent final model and resume state disagree") + expected = expected_exposure(world, docs, schedule, PARENT_STEP, study["lr"]) + with np.load(parent / f"predictions-{PARENT_STEP}.npz") as predictions: + for key, wanted in zip(("counts", "slots", "weighted"), expected, strict=True): + if key == "weighted": + np.testing.assert_allclose(resume[key], wanted, rtol=0, atol=1e-10) + else: + np.testing.assert_array_equal(resume[key], wanted) + stored_key = "exposure" if key == "counts" else key + np.testing.assert_array_equal(resume[key], predictions[stored_key]) + if resume["timeline"][-1]["step"] != PARENT_STEP: + raise ValueError("Parent learning history lacks the final checkpoint") + if not isinstance(resume["torch_rng"], torch.Tensor): + raise ValueError("Parent torch RNG is missing") + files = ( + "config.json", + "resume.pt", + f"model-{PARENT_STEP}.pt", + "schedule.npz", + f"predictions-{PARENT_STEP}.npz", + "learning-complete.json", + ) + provenance = { + "directory": str(parent), + "files_sha256": {name: file_hash(parent / name) for name in files}, + "model_sha256": model_hash, + "optimizer_sha256": tree_hash(resume["optimizer"]), + "torch_rng_sha256": tree_hash(resume["torch_rng"]), + "cuda_rng_sha256": tree_hash(resume["cuda_rng"]), + "qa_prefix_verified": True, + "exposure_reconstruction_verified": True, + } + return config, resume, docs, schedule, provenance + + +def restore_state(model, optimizer, saved, device): + model.load_state_dict(saved["model"]) + # load_state_dict may alias CPU tensors; branch updates must not mutate the parent. + optimizer.load_state_dict(copy.deepcopy(saved["optimizer"])) + torch.set_rng_state(saved["torch_rng"].cpu()) + if device.type == "cuda": + if saved["cuda_rng"] is None: + raise ValueError("CUDA parent/resume RNG state is missing") + torch.cuda.set_rng_state(saved["cuda_rng"].cpu(), device) + + +def capture_state(model, optimizer, device, **metadata): + return { + **metadata, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "torch_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device) if device.type == "cuda" else None, + } + + +def learning_update(model, optimizer, cache, data, qa, start, end, lr, device): + """The original arithmetic/gradient order, with an absolute-step learning rate.""" + for group in optimizer.param_groups: + group["lr"] = lr + model.train() + optimizer.zero_grad(set_to_none=True) + with precision(device): + logits = model(cache["tokens"][start:end], cache["positions"][start:end]) + doc_loss = F.cross_entropy( + logits.float().flatten(0, 1), cache["labels"][start:end].flatten() + ) + (0.8 * doc_loss).backward() + with precision(device): + logits = model(data["tokens"][qa], data["positions"][qa]) + qa_loss = F.cross_entropy(logits.float().flatten(0, 1), data["labels"][qa].flatten()) + (0.2 * qa_loss).backward() + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1) + if not torch.isfinite(doc_loss + qa_loss + norm): + raise FloatingPointError("Nonfinite continuation update") + optimizer.step() + + +def learning(parent, out, world, base_lr, device): + old_config, parent_resume, docs, schedule, provenance = validate_parent(parent, world, base_lr) + study = { + **old_config["study"], + "protocol": "v2.8-development-p2-continuation", + "steps": FINAL_STEP, + "checkpoints": list(CHECKPOINTS), + "lr": base_lr, + "edit_scopes": ["mlp"], + "seeds": [0] if base_lr == 0.0003 else [0, 1], + "learning_runs": 6 if base_lr == 0.0003 else 12, + "edit_cases": 24 if base_lr == 0.0003 else 48, + "edit_cases_per_run": 4, + "parent_step": PARENT_STEP, + "warmup": "original absolute epoch; no restart", + "primary_learning": ( + "heldout full-answer accuracy at 30720 absolute steps; " + "preserve all prespecified earlier checkpoints" + ), + "aggregation": ( + "pair organizations within world/initialization; " + "development worlds are not confirmatory replications" + ), + } + identity = { + "world": old_config["world"], + "seed": old_config["seed"], + "condition": old_config["condition"], + "study": study, + "sources": continuation_sources(), + "parent": provenance, + "model": old_config["model"], + "initial_sha256": old_config["initial_sha256"], + "truth_sha256": array_hash(world.answers), + "prompts_sha256": array_hash(world.prompts), + "documents_sha256": array_hash(docs), + "qa_sha256": array_hash(schedule), + "torch": torch.__version__, + "numpy": np.__version__, + "device_type": device.type, + "cuda": torch.version.cuda, + "gpu_type": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + } + config_path = out / "config.json" + if config_path.exists(): + existing = json.loads(config_path.read_text()) + if any(existing.get(key) != value for key, value in identity.items()): + raise ValueError("Continuation identity, parent, software or sources changed") + else: + write_json( + config_path, + { + **identity, + "python": platform.python_version(), + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES"), + "precision": "BF16 autocast; FP32 weights and optimizer", + "parameters": old_config["parameters"], + }, + ) + atomic_numpy_save(out / "schedule.npz", documents=docs, qa=schedule) + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + model_config = ModelConfig(**old_config["model"]) + model = CausalLM(model_config).to(device) + optimizer = torch.optim.AdamW( + model.parameters(), lr=base_lr, weight_decay=0.1, fused=device.type == "cuda" + ) + if (out / "resume.pt").exists(): + saved = torch.load(out / "resume.pt", map_location="cpu", weights_only=False) + if saved["config_sha256"] != file_hash(config_path): + raise ValueError("Continuation resume configuration mismatch") + else: + saved = {**parent_resume, "timeline": [], "config_sha256": file_hash(config_path)} + restore_state(model, optimizer, saved, device) + first, seconds = saved["step"], saved["seconds"] + timeline = saved["timeline"] + counts, slots, weighted = saved["counts"], saved["slots"], saved["weighted"] + if not PARENT_STEP <= first <= FINAL_STEP: + raise ValueError("Continuation resume step is outside its frozen interval") + data = tensor_queries(world, device) + + def save_resume(step): + atomic_torch_save( + capture_state( + model, + optimizer, + device, + step=step, + timeline=timeline, + seconds=seconds, + counts=counts, + slots=slots, + weighted=weighted, + config_sha256=file_hash(config_path), + ), + out / "resume.pt", + ) + + epoch_cached = -1 + for step in range(first, FINAL_STEP + 1): + if step in CHECKPOINTS and (not timeline or timeline[-1]["step"] != step): + if step == PARENT_STEP: + with np.load(Path(parent) / f"predictions-{PARENT_STEP}.npz") as old: + arrays = { + key: old[key] for key in ("prediction", "ended", "correct", "value_nll") + } + else: + arrays = evaluate(model, data, world.answers) + point = { + "step": step, + **learning_metrics(world, arrays), + "train_seconds": seconds, + "exposure_sha256": array_hash(counts), + "slots_sha256": array_hash(slots), + "weighted_sha256": array_hash(weighted), + "train_matmul_flops_estimate": step + * (matmul_flops(model_config, 16, 60, 20) + matmul_flops(model_config, 40, 6, 2)), + } + timeline.append(point) + atomic_numpy_save( + out / f"predictions-{step}.npz", + **arrays, + exposure=counts, + slots=slots, + weighted=weighted, + ) + atomic_torch_save( + { + "model": {k: v.detach().cpu() for k, v in model.state_dict().items()}, + "config": model.config_dict(), + "step": step, + }, + out / f"model-{step}.pt", + ) + write_json(out / "learning.json", timeline) + save_resume(step) + print(json.dumps({"event": "checkpoint", **point}), flush=True) + if step == FINAL_STEP: + break + epoch, offset = divmod(step, 128) + if epoch != epoch_cached: + arranged = epoch_documents(docs, world.seed, epoch) + cache = { + key: torch.as_tensor(value, device=device) + for key, value in render(world, arranged).items() + } + epoch_cached = epoch + start, end = offset * 16, (offset + 1) * 16 + qa = torch.as_tensor(schedule[step], device=device) + lr = continuation_lr(base_lr, step) + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + learning_update(model, optimizer, cache, data, qa, start, end, lr, device) + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - started + fact_ids = arranged[start:end] + np.add.at(counts, fact_ids.ravel(), 1) + np.add.at(counts, schedule[step], 1) + np.add.at(slots, (fact_ids, np.arange(10)[None, :]), 1) + np.add.at(weighted, fact_ids.ravel(), lr) + np.add.at(weighted, schedule[step], lr) + if (step + 1) % 256 == 0 and step + 1 not in CHECKPOINTS: + save_resume(step + 1) + print( + json.dumps({"event": "progress", "step": step + 1, "seconds": seconds}), flush=True + ) + write_json( + out / "learning-complete.json", + { + "status": "complete", + "final": timeline[-1], + "model_sha256": state_hash(model.state_dict()), + }, + ) + return model, data, study + + +def edit_metrics(world, pair, arrays, old_correct): + metrics = original_edit_metrics(world, pair, arrays, old_correct) + heldout = np.intersect1d(pair["conflict_D"], world.heldout_ids.ravel()) + metrics["D_conflict_heldout_n"] = len(heldout) + metrics["D_conflict_heldout"] = ( + float(arrays["correct"][heldout].mean()) if len(heldout) else None + ) + for label, ids in (("default", world.root_ids.ravel()), ("actual", world.actual_ids.ravel())): + subset = np.intersect1d(pair["E"], ids) + metrics[f"E_{label}_n"] = len(subset) + metrics[f"E_{label}"] = float(arrays["correct"][subset].mean()) + return metrics + + +def edit_update(model, optimizer, selected, data, new_data, references, ei, ri, choices, device): + model.train() + optimizer.zero_grad(set_to_none=True) + with precision(device): + logits = model(new_data["tokens"][ei], new_data["positions"][ei]).float() + ce = F.cross_entropy(logits.flatten(0, 1), new_data["labels"][ei].flatten()) + replay_logits = model(data["tokens"][ri], data["positions"][ri]).float() + kl = ( + F.kl_div( + F.log_softmax(replay_logits, -1), + F.softmax(references[choices].float(), -1), + reduction="none", + ) + .sum(-1) + .mean() + ) + loss = ce + kl + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(selected, 1) + if not torch.isfinite(loss + norm): + raise FloatingPointError("Nonfinite continuation edit") + optimizer.step() + + +def edits(world, model, data, out, study, device): + baseline = {key: value.detach().cpu().clone() for key, value in model.state_dict().items()} + old_arrays = evaluate(model, data, world.answers) + config_sha = file_hash(out / "config.json") + for chain, name in enumerate(CHAINS): + pair = edit_pair(world, chain) + rng = rng_for(world.seed, 908, chain) + e_choices = rng.integers(len(pair["E"]), size=(512, 128)) + r_choices = rng.integers(len(pair["replay"]), size=(512, 128)) + for kind in ("coherent", "exception"): + dest = out / "edits" / f"{name}-{kind}-mlp" + if (dest / "complete.json").exists(): + continue + dest.mkdir(parents=True, exist_ok=True) + model.load_state_dict(baseline) + selected = select_parameters(model, "mlp", 3) + model.eval() + references = [] + with torch.no_grad(), precision(device): + for begin in range(0, len(pair["replay"]), 256): + ids = torch.as_tensor(pair["replay"][begin : begin + 256], device=device) + references.append(model(data["tokens"][ids], data["positions"][ids]).detach()) + references = torch.cat(references) + target = pair[kind] + new_data = tensor_queries(world, device, target) + atomic_numpy_save( + dest / "sets.npz", + **pair, + old_correct=old_arrays["correct"], + edit_sampling=e_choices, + replay_sampling=r_choices, + ) + optimizer = torch.optim.AdamW( + selected, lr=study["edit_lr"], weight_decay=0.1, fused=device.type == "cuda" + ) + timeline, seconds, first = [], 0.0, 0 + if (dest / "resume.pt").exists(): + saved = torch.load(dest / "resume.pt", map_location="cpu", weights_only=False) + if saved["config_sha256"] != config_sha or saved["case"] != dest.name: + raise ValueError("Editing resume identity mismatch") + restore_state(model, optimizer, saved, device) + timeline, seconds, first = saved["timeline"], saved["seconds"], saved["step"] + for step in range(first, 513): + if step in EDIT_CHECKPOINTS and (not timeline or timeline[-1]["step"] != step): + arrays = evaluate(model, data, target) + point = { + "step": step, + **edit_metrics(world, pair, arrays, old_arrays["correct"]), + "edit_seconds": seconds, + } + timeline.append(point) + atomic_numpy_save(dest / f"predictions-{step}.npz", **arrays) + write_json(dest / "trajectory.json", timeline) + if step % 32 == 0: + atomic_torch_save( + capture_state( + model, + optimizer, + device, + step=step, + timeline=timeline, + seconds=seconds, + config_sha256=config_sha, + case=dest.name, + ), + dest / "resume.pt", + ) + if step == 512: + break + ei = torch.as_tensor(pair["E"][e_choices[step]], device=device) + ri = torch.as_tensor(pair["replay"][r_choices[step]], device=device) + choices = torch.as_tensor(r_choices[step], device=device) + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + edit_update( + model, optimizer, selected, data, new_data, references, ei, ri, choices, device + ) + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - started + atomic_torch_save( + {"model": model.state_dict(), "config": model.config_dict()}, + dest / "model-final.pt", + ) + write_json( + dest / "complete.json", + { + "status": "complete", + "chain": name, + "kind": kind, + "scope": "mlp", + "final": timeline[-1], + }, + ) + print( + json.dumps( + { + "event": "edit_complete", + "case": dest.name, + "E": timeline[-1]["E"], + "D": timeline[-1]["D"], + } + ), + flush=True, + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--parent", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--lr", type=float, choices=(0.0001, 0.0003), default=0.0001) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + parser.add_argument("--learning-only", action="store_true") + args = parser.parse_args() + parent, out = Path(args.parent).resolve(), Path(args.output).resolve() + if parent == out or parent in out.parents or out in parent.parents: + raise ValueError("Continuation output must be separate from its immutable parent") + out.mkdir(parents=True, exist_ok=True) + with (out / ".lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + torch.set_num_threads(args.threads) + world = make_cross_world(json.loads((parent / "config.json").read_text())["world"]) + audit(world) + device = torch.device(args.device) + try: + model, data, study = learning(parent, out, world, args.lr, device) + if not args.learning_only: + edits(world, model, data, out, study, device) + write_json( + out / "complete.json", + { + "status": "complete", + "learning_steps": FINAL_STEP, + "edit_cases": 4, + "finished": time.time(), + }, + ) + except Exception as error: + write_json( + out / "failure.json", + {"type": type(error).__name__, "message": str(error), "time": time.time()}, + ) + raise + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_scale.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_scale.py new file mode 100644 index 0000000000000000000000000000000000000000..af5c92edca554475a9bdf9dee9b46438455b1f96 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_scale.py @@ -0,0 +1,51 @@ +"""Contracts and denominator-aware summaries for the frozen crossover size extension.""" + +from itertools import product + +import numpy as np + + +def validate_size_study(reference, study, width, heads): + expected = {**reference, "width": width, "heads": heads} + if study != expected: + changed = sorted(k for k in set(expected) | set(study) if expected.get(k) != study.get(k)) + raise ValueError(f"Non-size study changes: {changed}") + if width // heads != 64 or study["layers"] != 8: + raise ValueError("Expected eight layers and head dimension 64") + + +def validate_run_grid(configs, study, require_complete): + expected = set(product(study["worlds"], study["seeds"], study["conditions"])) + keys = [(c["world"], c["seed"], c["condition"]) for c in configs] + if len(keys) != len(set(keys)) or set(keys) - expected: + raise ValueError("Duplicate or unexpected experimental units") + if require_complete and set(keys) != expected: + raise ValueError("Missing experimental units") + + +def retention_coverage(pair, old_correct, row): + """Keep unknown facts outside the damage denominator and expose their coverage.""" + result = {} + for pool_name, pool in ( + ("full", np.arange(len(old_correct))), + ("heldout", pair["heldout"]), + ): + totals, knowns, brokens = [], [], [] + for group in range(4): + ids = np.intersect1d(pool, np.flatnonzero(pair["strata"] == group)) + prefix = f"U_{pool_name}_{group}" + total, known, broken = len(ids), int(old_correct[ids].sum()), row[f"{prefix}_broken"] + if known != row[f"{prefix}_known"] or not 0 <= broken <= known: + raise ValueError("Retention denominator or broken count mismatch") + totals.append(total) + knowns.append(known) + brokens.append(broken) + result[f"{prefix}_total"] = total + result[f"{prefix}_coverage"] = known / total if total else None + total, known, broken = sum(totals), sum(knowns), sum(brokens) + result[f"U_{pool_name}_total"] = total + result[f"U_{pool_name}_coverage"] = known / total if total else None + result[f"U_{pool_name}_micro_damage"] = broken / known if known else None + result["E_old_accuracy"] = float(old_correct[pair["E"]].mean()) + result["D_old_accuracy"] = float(old_correct[pair["D"]].mean()) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_train.py new file mode 100644 index 0000000000000000000000000000000000000000..6c5f3f45a169e643c408f1044eaa766b79a595fd --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_cross_train.py @@ -0,0 +1,474 @@ +"""Frozen learning and editing runs for the two-relation crossover.""" + +import argparse +import fcntl +import hashlib +import json +import os +import platform +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_cross import ( + CHAINS, + CONDITIONS, + audit, + documents, + edit_pair, + epoch_documents, + make_cross_world, + qa_schedule, + render, +) +from .bios_data import EOS, array_hash, rng_for, write_json +from .bios_model import CausalLM, ModelConfig, matmul_flops, select_parameters +from .bios_organization_train import atomic_numpy_save, atomic_torch_save, state_hash +from .bios_train import precision + + +def tensor_queries(world, device, answers=None): + answers = world.answers if answers is None else answers + prompts = torch.as_tensor(world.prompts, device=device) + lengths = torch.as_tensor(world.lengths, device=device) + targets = torch.as_tensor(answers, device=device) + tokens = torch.zeros((len(answers), 6), device=device, dtype=torch.long) + tokens[:, :5] = prompts + tokens[torch.arange(len(answers), device=device), lengths] = targets + tokens[lengths == 4, 5] = EOS + return { + "prompts": prompts, + "lengths": lengths, + "tokens": tokens, + "positions": torch.stack([lengths - 1, lengths], -1), + "labels": torch.stack([targets, torch.full_like(targets, EOS)], -1), + } + + +@torch.no_grad() +def evaluate(model, data, answers, batch_size=512): + model.eval() + device = data["tokens"].device + predictions, ended, nll = [], [], [] + for begin in range(0, len(answers), batch_size): + end = min(begin + batch_size, len(answers)) + lengths = data["lengths"][begin:end] + with precision(device): + logits = model(data["prompts"][begin:end], (lengths - 1)[:, None])[:, 0].float() + first = logits.argmax(-1) + continuation = torch.zeros((end - begin, 6), device=device, dtype=torch.long) + continuation[:, :5] = data["prompts"][begin:end] + continuation[torch.arange(end - begin, device=device), lengths] = first + second = model(continuation, lengths[:, None])[:, 0].argmax(-1) + predictions.append(first.cpu().numpy()) + ended.append(second.eq(EOS).cpu().numpy()) + targets = torch.as_tensor(answers[begin:end], device=device) + nll.append(F.cross_entropy(logits, targets, reduction="none").cpu().numpy()) + prediction, ended = np.concatenate(predictions), np.concatenate(ended) + return { + "prediction": prediction, + "ended": ended, + "correct": (prediction == answers) & ended, + "value_nll": np.concatenate(nll), + } + + +def learning_metrics(world, arrays): + correct = arrays["correct"] + result = { + "base_accuracy": float(correct[: world.n_base].mean()), + "base_nll": float(arrays["value_nll"][: world.n_base].mean()), + } + for chain, name in enumerate(CHAINS): + for split, ids in ( + ("trained", world.train_ids[chain]), + ("heldout", world.heldout_ids[chain]), + ): + result[f"{name}_{split}"] = float(correct[ids].mean()) + result[f"{name}_{split}_nll"] = float(arrays["value_nll"][ids].mean()) + for label, ids in ( + ("membership", world.membership_ids[chain]), + ("default", world.root_ids[chain]), + ("actual", world.actual_ids[chain]), + ): + result[f"{name}_{label}"] = float(correct[ids].mean()) + # A conditional diagnostic, never a replacement for the whole test pool. + prerequisites = ( + correct[world.membership_ids[chain]] + & correct[world.root_ids[chain, world.memberships[chain]]] + ) + known_ids = np.intersect1d( + world.heldout_ids[chain], world.derived_ids[chain, prerequisites] + ) + result[f"{name}_known_heldout_n"] = len(known_ids) + result[f"{name}_known_heldout"] = ( + float(correct[known_ids].mean()) if len(known_ids) else None + ) + result["mean_heldout"] = (result["company_heldout"] + result["project_heldout"]) / 2 + return result + + +def source_hashes(): + root = Path(__file__).parent + return { + name: hashlib.sha256((root / name).read_bytes()).hexdigest() + for name in ( + "bios_cross.py", + "bios_cross_train.py", + "bios_model.py", + "bios_data.py", + "bios_train.py", + "bios_organization_train.py", + ) + } + + +def learning(args, world, out, study, device): + torch.manual_seed(args.seed) + if device.type == "cuda": + torch.cuda.manual_seed_all(args.seed) + torch.backends.cuda.matmul.allow_tf32 = True + config = ModelConfig(world.vocab_size, study["width"], study["layers"], study["heads"]) + model = CausalLM(config).to(device) + initial_hash = state_hash(model.state_dict()) + docs, schedule = documents(world, args.condition), qa_schedule(world, study["steps"]) + identity = { + "world": args.world, + "seed": args.seed, + "condition": args.condition, + "study": study, + "sources": source_hashes(), + "model": model.config_dict(), + "initial_sha256": initial_hash, + "truth_sha256": array_hash(world.answers), + "prompts_sha256": array_hash(world.prompts), + "documents_sha256": array_hash(docs), + "qa_sha256": array_hash(schedule), + } + config_path = out / "config.json" + if config_path.exists(): + saved = json.loads(config_path.read_text()) + if any(saved[k] != v for k, v in identity.items()): + raise ValueError("Frozen run identity or sources changed") + else: + write_json( + config_path, + { + **identity, + "torch": torch.__version__, + "cuda": torch.version.cuda, + "python": platform.python_version(), + "numpy": np.__version__, + "device": str(device), + "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES"), + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "precision": "BF16 autocast; FP32 weights and optimizer", + "parameters": sum(p.numel() for p in model.parameters()), + }, + ) + atomic_numpy_save(out / "schedule.npz", documents=docs, qa=schedule) + data = tensor_queries(world, device) + optimizer = torch.optim.AdamW( + model.parameters(), lr=study["lr"], weight_decay=0.1, fused=device.type == "cuda" + ) + timeline, first, seconds = [], 0, 0.0 + counts = np.zeros(len(world.answers), dtype=np.int64) + slots = np.zeros((world.n_base, 10), dtype=np.int64) + weighted = np.zeros(len(world.answers), dtype=np.float64) + if (out / "resume.pt").exists(): + resume = torch.load(out / "resume.pt", map_location="cpu", weights_only=False) + if resume["config_sha256"] != hashlib.sha256(config_path.read_bytes()).hexdigest(): + raise ValueError("Resume configuration mismatch") + model.load_state_dict(resume["model"]) + optimizer.load_state_dict(resume["optimizer"]) + first, timeline, seconds = resume["step"], resume["timeline"], resume["seconds"] + counts, slots, weighted = resume["counts"], resume["slots"], resume["weighted"] + torch.set_rng_state(resume["torch_rng"]) + if device.type == "cuda": + torch.cuda.set_rng_state(resume["cuda_rng"], device) + epoch_cached, cache = -1, None + for step in range(first, study["steps"] + 1): + if step in study["checkpoints"] and (not timeline or step != first): + arrays = evaluate(model, data, world.answers) + point = { + "step": step, + **learning_metrics(world, arrays), + "train_seconds": seconds, + "exposure_sha256": array_hash(counts), + "slots_sha256": array_hash(slots), + "weighted_sha256": array_hash(weighted), + "train_matmul_flops_estimate": step + * (matmul_flops(config, 16, 60, 20) + matmul_flops(config, 40, 6, 2)), + } + timeline.append(point) + atomic_numpy_save( + out / f"predictions-{step}.npz", + **arrays, + exposure=counts, + slots=slots, + weighted=weighted, + ) + atomic_torch_save( + { + "model": {k: v.detach().cpu() for k, v in model.state_dict().items()}, + "config": model.config_dict(), + "step": step, + }, + out / f"model-{step}.pt", + ) + write_json(out / "learning.json", timeline) + atomic_torch_save( + { + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "step": step, + "timeline": timeline, + "seconds": seconds, + "counts": counts, + "slots": slots, + "weighted": weighted, + "torch_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device) if device.type == "cuda" else None, + "config_sha256": hashlib.sha256(config_path.read_bytes()).hexdigest(), + }, + out / "resume.pt", + ) + print(json.dumps({"event": "checkpoint", **point}), flush=True) + if step == study["steps"]: + break + epoch, offset = divmod(step, 128) + if epoch != epoch_cached: + arranged = epoch_documents(docs, world.seed, epoch) + cache = { + k: torch.as_tensor(v, device=device) for k, v in render(world, arranged).items() + } + epoch_cached = epoch + start, end = offset * 16, (offset + 1) * 16 + fact_ids = arranged[start:end] + qa = torch.as_tensor(schedule[step], device=device) + lr = study["lr"] * min((epoch + 1) / 16, 1) + for group in optimizer.param_groups: + group["lr"] = lr + model.train() + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with precision(device): + logits = model(cache["tokens"][start:end], cache["positions"][start:end]) + doc_loss = F.cross_entropy( + logits.float().flatten(0, 1), cache["labels"][start:end].flatten() + ) + (0.8 * doc_loss).backward() + with precision(device): + logits = model(data["tokens"][qa], data["positions"][qa]) + qa_loss = F.cross_entropy(logits.float().flatten(0, 1), data["labels"][qa].flatten()) + (0.2 * qa_loss).backward() + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1) + if not torch.isfinite(doc_loss + qa_loss + norm): + raise FloatingPointError("Nonfinite learning update") + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - started + np.add.at(counts, fact_ids.ravel(), 1) + np.add.at(counts, schedule[step], 1) + np.add.at(slots, (fact_ids, np.arange(10)[None, :]), 1) + np.add.at(weighted, fact_ids.ravel(), lr) + np.add.at(weighted, schedule[step], lr) + if (step + 1) % 256 == 0: + print( + json.dumps({"event": "progress", "step": step + 1, "seconds": seconds}), flush=True + ) + write_json( + out / "learning-complete.json", + { + "status": "complete", + "final": timeline[-1], + "model_sha256": state_hash(model.state_dict()), + }, + ) + return model, data + + +def edit_metrics(world, pair, arrays, old_correct): + correct = arrays["correct"] + metrics = { + "E": float(correct[pair["E"]].mean()), + "D": float(correct[pair["D"]].mean()), + "D_conflict": float(correct[pair["conflict_D"]].mean()), + } + for split, ids in ( + ("trained", world.train_ids.ravel()), + ("heldout", world.heldout_ids.ravel()), + ): + subset = np.intersect1d(pair["D"], ids) + metrics[f"D_{split}_n"] = len(subset) + metrics[f"D_{split}"] = float(correct[subset].mean()) if len(subset) else None + for name, pool in (("full", np.arange(len(correct))), ("heldout", pair["heldout"])): + strata = {} + for group in range(4): + ids = np.intersect1d(pool, np.flatnonzero((pair["strata"] == group) & old_correct)) + strata[str(group)] = { + "known": len(ids), + "broken": int((~correct[ids]).sum()), + "rate": float((~correct[ids]).mean()) if len(ids) else None, + } + metrics[f"U_{name}"] = strata + return metrics + + +def edits(args, world, model, data, out, study, device): + baseline = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()} + old_arrays = evaluate(model, data, world.answers) + for chain, name in enumerate(CHAINS): + pair = edit_pair(world, chain) + rng = rng_for(world.seed, 908, chain) + e_choices = rng.integers(len(pair["E"]), size=(study["edit_steps"], 128)) + r_choices = rng.integers(len(pair["replay"]), size=(study["edit_steps"], 128)) + for kind in ("coherent", "exception"): + target = pair[kind] + new_data = tensor_queries(world, device, target) + for scope in ("mlp", "all"): + dest = out / "edits" / f"{name}-{kind}-{scope}" + if (dest / "complete.json").exists(): + continue + dest.mkdir(parents=True, exist_ok=True) + model.load_state_dict(baseline) + selected = select_parameters(model, scope, 3) + model.eval() + references = [] + with torch.no_grad(), precision(device): + for begin in range(0, len(pair["replay"]), 256): + ids = torch.as_tensor(pair["replay"][begin : begin + 256], device=device) + references.append( + model(data["tokens"][ids], data["positions"][ids]).detach() + ) + references = torch.cat(references) + atomic_numpy_save( + dest / "sets.npz", + **pair, + old_correct=old_arrays["correct"], + edit_sampling=e_choices, + replay_sampling=r_choices, + ) + optimizer = torch.optim.AdamW( + selected, lr=study["edit_lr"], weight_decay=0.1, fused=device.type == "cuda" + ) + timeline = [] + seconds = 0.0 + for step in range(study["edit_steps"] + 1): + if step in study["edit_checkpoints"]: + arrays = evaluate(model, data, target) + point = { + "step": step, + **edit_metrics(world, pair, arrays, old_arrays["correct"]), + "edit_seconds": seconds, + } + timeline.append(point) + atomic_numpy_save(dest / f"predictions-{step}.npz", **arrays) + write_json(dest / "trajectory.json", timeline) + if step == study["edit_steps"]: + break + model.train() + ei = torch.as_tensor(pair["E"][e_choices[step]], device=device) + choices = torch.as_tensor(r_choices[step], device=device) + ri = torch.as_tensor(pair["replay"][r_choices[step]], device=device) + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with precision(device): + logits = model(new_data["tokens"][ei], new_data["positions"][ei]).float() + ce = F.cross_entropy(logits.flatten(0, 1), new_data["labels"][ei].flatten()) + replay_logits = model(data["tokens"][ri], data["positions"][ri]).float() + kl = ( + F.kl_div( + F.log_softmax(replay_logits, -1), + F.softmax(references[choices].float(), -1), + reduction="none", + ) + .sum(-1) + .mean() + ) + loss = ce + study["retention_kl"] * kl + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(selected, 1) + if not torch.isfinite(loss + norm): + raise FloatingPointError("Nonfinite edit") + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - started + atomic_torch_save( + {"model": model.state_dict(), "config": model.config_dict()}, + dest / "model-final.pt", + ) + write_json( + dest / "complete.json", + { + "status": "complete", + "chain": name, + "kind": kind, + "scope": scope, + "final": timeline[-1], + }, + ) + print( + json.dumps( + { + "event": "edit_complete", + "case": dest.name, + "E": timeline[-1]["E"], + "D": timeline[-1]["D"], + } + ), + flush=True, + ) + del references, optimizer + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--world", type=int, required=True) + parser.add_argument("--seed", type=int, required=True) + parser.add_argument("--condition", choices=CONDITIONS, required=True) + parser.add_argument("--config", default="configs/bios-cross-development-v1.json") + parser.add_argument("--output", required=True) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + args = parser.parse_args() + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + with (out / ".lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + study = json.loads(Path(args.config).read_text()) + torch.set_num_threads(args.threads) + device = torch.device(args.device) + world = make_cross_world(args.world) + audit(world) + try: + model, data = learning(args, world, out, study, device) + edits(args, world, model, data, out, study, device) + write_json( + out / "complete.json", + { + "status": "complete", + "learning_steps": study["steps"], + "edit_cases": 8, + "finished": time.time(), + }, + ) + except Exception as error: + write_json( + out / "failure.json", + {"type": type(error).__name__, "message": str(error), "time": time.time()}, + ) + raise + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_data.py new file mode 100644 index 0000000000000000000000000000000000000000..3acf9b51a11985eb747a2c2565bc551ae803fd9b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_data.py @@ -0,0 +1,367 @@ +"""bioS-Work-v1 truth, equal-exposure curricula and paired counterfactual worlds. + +Official files remain unmodified in data/bios-source; this is a new adapter. +The symbolic experiment does not imply that the natural-language audit is complete. +""" + +import calendar +import hashlib +import json +from dataclasses import dataclass +from pathlib import Path + +import numpy as np + +REVISION = "211b28f2e9d453114ca5a1cbbb2d5a632ac60fcf" +SOURCE_FOLDER = "data-synthetic-pretrain/Capo-bioS-bioR" +RELATIONS = ( + "employer", + "default_city", + "actual_city", + "birth_date", + "birth_city", + "university", + "major", +) +N_PEOPLE, N_COMPANIES, N_BASE, N_QUERIES = 2048, 64, 12352, 14400 +PAD, BOS, ANS, EOS = range(4) + + +def rng_for(seed, purpose, index=0): + return np.random.default_rng(np.random.SeedSequence([seed, purpose, index])) + + +def array_hash(array): + return hashlib.sha256(np.ascontiguousarray(array).tobytes()).hexdigest() + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n") + temporary.replace(path) + + +@dataclass +class World: + seed: int + prompts: np.ndarray + lengths: np.ndarray + answers: np.ndarray + relation: np.ndarray + person: np.ndarray + company: np.ndarray + employers: np.ndarray + defaults: np.ndarray + actual: np.ndarray + exceptions: np.ndarray + city_tokens: np.ndarray + token_labels: list + names: dict + + @property + def vocab_size(self): + return len(self.token_labels) + + def save(self, directory): + directory = Path(directory) + directory.mkdir(parents=True, exist_ok=True) + arrays = {k: v for k, v in vars(self).items() if isinstance(v, np.ndarray)} + np.savez_compressed(directory / "world.npz", **arrays) + write_json( + directory / "metadata.json", + {"seed": self.seed, "token_labels": self.token_labels, "names": self.names}, + ) + write_json(directory / "audit.json", audit_world(self)) + + +def load_world(directory): + directory = Path(directory) + metadata = json.loads((directory / "metadata.json").read_text()) + with np.load(directory / "world.npz", allow_pickle=False) as arrays: + return World(**metadata, **dict(arrays)) + + +def make_world(seed, source_root="data/bios-source"): + source_root = Path(source_root) + manifest = json.loads((source_root / "manifest.json").read_text()) + if manifest["revision"] != REVISION: + raise ValueError("Unexpected official source revision") + for entry in manifest["files"]: + if ( + hashlib.sha256((source_root / entry["path"]).read_bytes()).hexdigest() + != entry["sha256"] + ): + raise ValueError("Source hash mismatch: " + entry["path"]) + + def field(name): + return (source_root / SOURCE_FOLDER / "fields" / (name + ".txt")).read_text().splitlines() + + cities, universities, majors = field("city"), field("university"), field("field") + first, middle, last = field("first_name"), field("middle_name"), field("last_name") + names_rng, group_rng, value_rng = (rng_for(seed, i) for i in (11, 12, 13)) + + def unique_names(count): + result, used = [], set() + while len(result) < count: + value = f"{names_rng.choice(first)} {names_rng.choice(middle)} {names_rng.choice(last)}" + if value.casefold() not in used: + result.append(value) + used.add(value.casefold()) + return result + + person_names = unique_names(2 * N_PEOPLE) + syllables = ("va", "ne", "ri", "lo", "sa", "tu", "mi", "ze", "ka", "po", "da", "fi") + company_names, used = [], set() + while len(company_names) < 2 * N_COMPANIES: + value = "".join(names_rng.choice(syllables, 4)).capitalize() + " Labs" + if value not in used: + used.add(value) + company_names.append(value) + employers = group_rng.permutation(np.repeat(np.arange(N_COMPANIES), 32)) + work_cities = value_rng.choice(len(cities), 32, replace=False) + defaults = value_rng.permutation(np.repeat(work_cities, 2)) + exceptions = np.zeros(N_PEOPLE, dtype=bool) + actual = defaults[employers].copy() + for c in range(N_COMPANIES): + selected = group_rng.choice(np.flatnonzero(employers == c), 2, replace=False) + exceptions[selected] = True + actual[selected] = value_rng.choice(work_cities[work_cities != defaults[c]], 2) + attributes_rng = rng_for(seed, 14) + years = attributes_rng.integers(1900, 2100, N_PEOPLE) + months = attributes_rng.integers(1, 13, N_PEOPLE) + days = attributes_rng.integers(1, 29, N_PEOPLE) + dates = [ + f"{calendar.month_name[m]} {d}, {y}" for y, m, d in zip(years, months, days, strict=True) + ] + birth_cities = attributes_rng.integers(0, len(cities), N_PEOPLE) + university = attributes_rng.integers(0, len(universities), N_PEOPLE) + major = attributes_rng.integers(0, len(majors), N_PEOPLE) + labels = ( + [f"person:{i}" for i in range(N_PEOPLE)] + + [f"company:{i}" for i in range(N_COMPANIES)] + + [f"city:{i}" for i in range(len(cities))] + + [f"date:{d}" for d in sorted(set(dates))] + + [f"university:{i}" for i in range(len(universities))] + + [f"major:{i}" for i in range(len(majors))] + + [f"relation:{r}" for r in RELATIONS] + ) + labels = list(rng_for(seed, 15).permutation(labels)) + token_labels = ["", "", "", ""] + labels + token = {label: i for i, label in enumerate(token_labels)} + city_tokens = np.array([token[f"city:{i}"] for i in range(len(cities))]) + prompts = np.full((N_QUERIES, 5), PAD, dtype=np.int64) + lengths = np.full(N_QUERIES, 4, dtype=np.int64) + answers = np.empty(N_QUERIES, dtype=np.int64) + relation = np.empty(N_QUERIES, dtype=np.int64) + person = np.full(N_QUERIES, -1, dtype=np.int64) + company = np.empty(N_QUERIES, dtype=np.int64) + values = [ + [token[f"company:{c}"] for c in employers], + city_tokens[defaults], + city_tokens[actual], + [token[f"date:{d}"] for d in dates], + city_tokens[birth_cities], + [token[f"university:{u}"] for u in university], + [token[f"major:{m}"] for m in major], + ] + offset = 0 + for rel, rel_values in enumerate(values): + for i, value in enumerate(rel_values): + q = offset + i + is_company = rel == 1 + subject = token[f"company:{i}" if is_company else f"person:{i}"] + prompts[q, :4] = [BOS, subject, token[f"relation:{RELATIONS[rel]}"], ANS] + answers[q], relation[q] = value, rel + company[q] = i if is_company else employers[i] + if not is_company: + person[q] = i + offset += len(rel_values) + for i in range(N_PEOPLE): + q = N_BASE + i + prompts[q] = [ + BOS, + token[f"person:{i}"], + token["relation:employer"], + token["relation:default_city"], + ANS, + ] + answers[q] = city_tokens[defaults[employers[i]]] + lengths[q], relation[q], person[q], company[q] = 5, 7, i, employers[i] + names = { + "people": person_names[:N_PEOPLE], + "people_aliases": person_names[N_PEOPLE:], + "companies": company_names[:N_COMPANIES], + "company_aliases": company_names[N_COMPANIES:], + "company_source_ids": names_rng.choice( + len(field("company")), N_COMPANIES, replace=False + ).tolist(), + "cities": cities, + "universities": universities, + "majors": majors, + "work_city_ids": work_cities.tolist(), + } + world = World( + seed, + prompts, + lengths, + answers, + relation, + person, + company, + employers, + defaults, + actual, + exceptions, + city_tokens, + token_labels, + names, + ) + audit_world(world) + return world + + +def curriculum(world, order, total_steps, batch_size=128): + if order not in {"SA", "AS"} or total_steps < 5280 or batch_size != 128: + raise ValueError("Protocol curriculum requires SA/AS, >=5280 steps and batch 128") + s = np.flatnonzero(np.isin(world.relation[:N_BASE], [0, 1])) + a = np.flatnonzero(~np.isin(world.relation[:N_BASE], [0, 1])) + parts = {} + for name, ids, repeats, purpose in (("S", s, 160, 21), ("A", a, 33, 22)): + rng = rng_for(world.seed, purpose) + parts[name] = np.concatenate([rng.permutation(ids) for _ in range(repeats)]) + assert len(parts[name]) == 337920 + rng = rng_for(world.seed, 23) + n_mix = (total_steps - 5280) * batch_size + # Exact 80:20 across each five-step block; final partial block is recorded. + n_derived = n_mix // 5 + n_atomic = n_mix - n_derived + atomic = np.concatenate([rng.permutation(N_BASE) for _ in range(n_atomic // N_BASE + 1)])[ + :n_atomic + ] + derived = N_BASE + np.tile(rng.permutation(N_PEOPLE), n_derived // N_PEOPLE + 1)[:n_derived] + mixed = np.empty(n_mix, dtype=np.int64) + derived_positions = np.arange(4, n_mix, 5) + mixed[derived_positions] = derived + is_atomic = np.ones(n_mix, dtype=bool) + is_atomic[derived_positions] = False + mixed[is_atomic] = atomic + return np.concatenate([parts[order[0]], parts[order[1]], mixed]).reshape( + total_steps, batch_size + ) + + +def paired_edit(world, support=0, k=1): + if k not in (1, 4, 16): + raise ValueError("Protocol scales are 1, 4 and 16") + rng = rng_for(world.seed, 31, support + 100 * k) + # Draw whole disjoint supports until every triple has three different defaults. + for _ in range(100000): + companies = rng.choice(N_COMPANIES, 3 * k, replace=False).reshape(k, 3) + if all(len(set(world.defaults[t])) == 3 for t in companies): + break + else: + raise RuntimeError("No valid support") + coherent, exception = world.answers.copy(), world.answers.copy() + for triple in companies: + old = world.defaults[triple] + for j, c in enumerate(triple): + next_city, alternate = old[(j + 1) % 3], old[(j + 2) % 3] + root = 2048 + c + coherent[root] = exception[root] = world.city_tokens[next_city] + members = rng.permutation(np.flatnonzero((world.employers == c) & ~world.exceptions)) + rows = 2112 + members + coherent[rows] = world.city_tokens[next_city] + exception[rows[:15]], exception[rows[15:]] = ( + world.city_tokens[next_city], + world.city_tokens[alternate], + ) + derived = N_BASE + np.flatnonzero(world.employers == c) + coherent[derived] = exception[derived] = world.city_tokens[next_city] + edit_mask = coherent != world.answers + assert np.array_equal(edit_mask, exception != world.answers) + e = np.flatnonzero(edit_mask & (np.arange(N_QUERIES) < N_BASE)) + d = np.flatnonzero(edit_mask & (np.arange(N_QUERIES) >= N_BASE)) + u = ~edit_mask + selected = np.isin(world.company, companies.ravel()) + old_exception = (world.relation == 2) & world.exceptions[np.maximum(world.person, 0)] + strata = np.full(N_QUERIES, -1, dtype=np.int64) + strata[u & selected & old_exception] = 0 + strata[u & selected & ~old_exception] = 1 + strata[u & ~selected & np.isin(world.relation, [1, 2, 7])] = 2 + strata[u & ~selected & np.isin(world.relation, [0, 3, 4, 5, 6])] = 3 + assert np.array_equal(strata >= 0, u) + assert len(e) == 93 * k and len(d) == 96 * k + assert np.array_equal( + np.bincount(coherent[e], minlength=world.vocab_size), + np.bincount(exception[e], minlength=world.vocab_size), + ) + split_rng = rng_for(world.seed, 32, support + 100 * k) + replay_pool, heldout = [], [] + for group in range(4): + ids = split_rng.permutation( + np.flatnonzero((strata == group) & (np.arange(N_QUERIES) < N_BASE)) + ) + n_test = max(1, int(np.ceil(0.2 * len(ids)))) + heldout.extend(ids[:n_test]) + replay_pool.extend(ids[n_test:]) + heldout.extend(np.flatnonzero(u & (np.arange(N_QUERIES) >= N_BASE))) + replay = split_rng.choice(replay_pool, min(4096, len(replay_pool)), replace=False) + return { + "companies": companies, + "coherent": coherent, + "exception": exception, + "E": e, + "D": d, + "strata": strata, + "replay": replay, + "heldout": np.array(sorted(heldout)), + "support": support, + "k": k, + "selection": "prespecified_unmatched", + } + + +def audit_world(world): + assert world.prompts.shape == (N_QUERIES, 5) + assert len(set(map(tuple, world.prompts))) == N_QUERIES + assert np.array_equal(np.bincount(world.employers), np.full(N_COMPANIES, 32)) + assert np.array_equal(np.unique(world.defaults, return_counts=True)[1], np.full(32, 2)) + assert world.exceptions.sum() == 128 + assert np.array_equal( + np.bincount(world.employers[world.exceptions], minlength=64), np.full(64, 2) + ) + assert np.array_equal(world.actual != world.defaults[world.employers], world.exceptions) + assert np.array_equal(world.answers[2112:4160], world.city_tokens[world.actual]) + assert np.array_equal( + world.answers[N_BASE:], world.city_tokens[world.defaults[world.employers]] + ) + for key, alias in (("people", "people_aliases"), ("companies", "company_aliases")): + names = world.names[key] + world.names[alias] + assert len(set(n.casefold().strip() for n in names)) == len(names) + baseline = {} + for relation in range(7): + values = world.answers[world.relation == relation] + answer = int(np.bincount(values, minlength=world.vocab_size).argmax()) + baseline[RELATIONS[relation]] = { + "answer_token": answer, + "accuracy": float(np.mean(values == answer)), + } + return { + "version": "bioS-Work-v1", + "world_seed": world.seed, + "source_revision": REVISION, + "base_facts": N_BASE, + "derived_queries": N_PEOPLE, + "people": N_PEOPLE, + "companies": N_COMPANIES, + "old_exceptions": 128, + "vocab_size": world.vocab_size, + "truth_sha256": array_hash(world.answers), + "queries_sha256": array_hash(world.prompts), + "majority_baseline": baseline, + "oracle_default_baseline": {"overall": 0.9375, "old_exception": 0.0, "nonexception": 1.0}, + "symbolic_truth_audit": "passed", + "natural_language_audit": "not_complete; not used in symbolic run", + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction.py new file mode 100644 index 0000000000000000000000000000000000000000..15e8d1db07bd56a73048608a8d9dfb99e5737a7a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction.py @@ -0,0 +1,617 @@ +"""Target-complete direction experiments; batched independent down-only editors. + +The randomized generalized Gauss--Newton sketch is a diagnostic solver, not +AlphaEdit/CrispEdit. Every finite hard-constraint proposal is checked against the +original parent. Training batches contain E/R only; evaluation has no gradients. +""" + +import hashlib +import itertools +import json +import time +from dataclasses import dataclass +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_data import write_json +from .bios_model import CausalLM, ModelConfig + +ROOT = Path(__file__).resolve().parents[2] +NODES = (0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024) +ARMS = tuple( + "-".join(x) for x in itertools.product(("func", "repr"), ("soft", "hard"), ("adam", "gn")) +) + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def stable_order(values, *key): + return sorted(values, key=lambda i: hashlib.sha256(f"{key}:{int(i)}".encode()).hexdigest()) + + +def load_parent(path, device): + saved = torch.load(path, map_location=device, weights_only=False) + model = CausalLM(ModelConfig(**saved["config"])).to(device).eval() + model.load_state_dict(saved["model"]) + for parameter in model.parameters(): + parameter.requires_grad_(False) + return model + + +@dataclass +class Task: + name: str + tokens: torch.Tensor + positions: torch.Tensor + labels: torch.Tensor + old_labels: torch.Tensor + sets: dict + metadata: dict + + def manifest(self): + return { + "name": self.name, + "sets": self.sets, + "metadata": self.metadata, + "labels": self.labels.cpu().tolist(), + "old_labels": self.old_labels.cpu().tolist(), + "tokens_sha256": hashlib.sha256(self.tokens.cpu().numpy().tobytes()).hexdigest(), + } + + +def minimal_task(seed, person, kind, device, labels=None): + people = torch.arange(32, device=device).repeat_interleave(3) + relation = torch.arange(3, device=device).repeat(32) + tokens = torch.stack( + (torch.ones_like(people), 3 + people, 35 + relation, torch.full_like(people, 2)), -1 + ) + old = 38 + (people + (relation == 2)) % 3 if labels is None else labels.to(device) + old = old[:, None] + desired = old.clone() + first, second = (0, 1) if seed % 2 == 0 else (1, 0) + i, j, k = 3 * person + first, 3 * person + second, 3 * person + 2 + c = int(old[i, 0]) + assert int(old[j, 0]) == c + a, b = 38 + (c - 38 + 1) % 3, 38 + (c - 38 + 2) % 3 + desired[i] = a if kind == "coherent" else b + e, local = [i], [k] + if kind != "selective": + desired[j] = a + e.append(j) + else: + local.append(j) + remaining = stable_order([x for x in range(32) if x != person], "split", person, 271520) + + def expand(xs): + return [3 * p + r for p in xs for r in range(3)] + + sets = { + "E": e, + "R": local + expand(remaining[:15]), + "V": expand(remaining[15:23]), + "U": expand(remaining[23:]), + "local": local, + } + return Task( + f"seed-{seed}-person-{person}-{kind}", + tokens, + torch.full((96, 1), 3, device=device), + desired, + old, + sets, + {"seed": seed, "person": person, "kind": kind, "a": a, "b": b, "c": c, "pair": [i, j]}, + ) + + +class Suffix: + """Frozen prefix cached for independent weight matrices (batch axis zero).""" + + def __init__(self, model, layer, tokens, positions): + self.model, self.layer, self.positions = model, layer, positions + if tokens.ndim == 2: + tokens = tokens[None] + self.positions = positions[None] + self.n, self.q, self.t = tokens.shape + with torch.no_grad(): + flat = tokens.reshape(-1, self.t) + x = model.token(flat) + model.position(torch.arange(self.t, device=flat.device)) + for block in model.blocks[:layer]: + x = block(x) + block = model.blocks[layer] + x = x + block.attention(block.ln1(x)) + self.base = (x + block.mlp.down.bias).reshape(self.n, self.q, self.t, -1).detach() + self.z = ( + block.mlp.activation(block.mlp.up(block.ln2(x))) + .reshape(self.n, self.q, self.t, -1) + .detach() + ) + self.forward_calls = 0 + + def __call__(self, w): + self.forward_calls += 1 + n = w.shape[0] + x = self.base + torch.einsum("nqtk,ndk->nqtd", self.z.expand(n, -1, -1, -1), w) + x = x.reshape(n * self.q, self.t, -1) + for block in self.model.blocks[self.layer + 1 :]: + x = block(x) + x = self.model.ln_final(x).reshape(n, self.q, self.t, -1) + positions = self.positions.expand(n, -1, -1) + x = x.gather(2, positions[..., None].expand(-1, -1, -1, x.shape[-1])) + return F.linear(x, self.model.token.weight) + + +def candidate_configs(arm): + obj, form, solver = arm.split("-") + rates = (1e-4, 1e-3, 1e-2) if solver == "adam" else (0.1, 0.3, 1.0) + levels = ( + (0.0, 1.0, 10.0, 100.0) + if form == "soft" + else ((0.0, 1e-6, 1e-4, 1e-2) if obj == "repr" else (1e-6, 1e-4, 1e-2, 0.1)) + ) + return [ + dict(lr=lr, level=level, damping=0.01, rank=8, refresh=16, trust_fraction=0.05) + for lr, level in itertools.product(rates, levels) + ] + + +def gaussian_newton_sketch(logits, w, weights, rank, generator): + """E[U^T U] = weighted CE GGN; independent probes per example/logit. + + B = diag(sqrt(p)) - p sqrt(p)^T satisfies BB^T = diag(p)-pp^T. + Frozen probes are differentiated through logits only, never through p. + """ + probability = logits.detach().softmax(-1) + result = [] + for _ in range(rank): + noise = torch.randn(probability.shape, device=w.device, dtype=w.dtype, generator=generator) + raw = probability.sqrt() * noise + probe = raw - probability * raw.sum(-1, keepdim=True) + probe *= weights.sqrt()[..., None] / np.sqrt(rank) + result.append( + torch.autograd.grad(logits, w, probe, retain_graph=True)[0].detach().flatten(1) + ) + return torch.stack(result, 1) + + +def inverse_sketch(v, sketch, damping): + """(damping I + U^T U)^-1 v via an exact rank-r dual solve.""" + shape = v.shape + flat = v.flatten(1) + if sketch is None: + return v / damping + k = sketch @ sketch.transpose(-1, -2) + k.diagonal(dim1=-2, dim2=-1).add_(damping) + coeff = torch.linalg.solve(k.double(), (sketch @ flat[..., None]).double()).to(v.dtype) + return ((flat - (sketch.transpose(-1, -2) @ coeff)[..., 0]) / damping).reshape(shape) + + +def representation_geometry(suffix, rmask, w0): + z = suffix.z + mask = rmask[..., None].expand(-1, -1, z.shape[2]) + # Fixed sequence length; in cross tasks only positions <= last supervised index. + valid = ( + torch.arange(z.shape[2], device=z.device)[None, None, :] + <= suffix.positions.max(-1).values[..., None] + ) + mask = mask * valid + covariance = ( + torch.einsum("nqtk,nqtl,nqt->nkl", z.double(), z.double(), mask.double()) + / mask.sum((1, 2))[:, None, None] + ) + output = torch.einsum("nqtk,dk->nqtd", z, w0) + suffix.model.blocks[suffix.layer].mlp.down.bias + scale = (output.square().sum(-1) * mask).sum((1, 2)) / mask.sum((1, 2)) + covariance = covariance / scale[:, None, None].clamp_min(1e-12) + suffix.repr_factor = ( + z * (mask / (mask.sum((1, 2)) * scale).clamp_min(1e-12)[:, None, None]).sqrt()[..., None] + ) + vals, vecs = torch.linalg.eigh(covariance.double()) + threshold = vals[:, -1:] * 1e-10 + keep = vals > threshold + null = (vecs * (~keep)[:, None, :]) @ vecs.transpose(-1, -2) + return covariance.to(w0.dtype), null.to(w0.dtype), keep.sum(-1), vals + + +def batch_setup(model, layer, tasks, configs): + ids = [t.sets["E"] + t.sets["R"] for t in tasks] + assert len(set(map(len, ids))) == 1 + toks = torch.stack([t.tokens[i] for t, i in zip(tasks, ids, strict=True)]) + positions = torch.stack([t.positions[i] for t, i in zip(tasks, ids, strict=True)]) + labels = torch.stack([t.labels[i] for t, i in zip(tasks, ids, strict=True)]) + suffix = Suffix(model, layer, toks, positions) + n, q, o = labels.shape + ermask = torch.zeros((n, q), device=toks.device) + for row, task in enumerate(tasks): + ermask[row, : len(task.sets["E"])] = 1 + rmask = 1 - ermask + eweight, rweight = ermask / ermask.sum(-1, keepdim=True), rmask / rmask.sum(-1, keepdim=True) + w0 = model.blocks[layer].mlp.down.weight.detach().clone() + with torch.no_grad(): + ref = suffix(w0[None].expand(n, -1, -1)).double().log_softmax(-1) + covariance, null, ranks, spectrum = representation_geometry(suffix, rmask, w0) + return suffix, labels, eweight, rweight, ref, covariance, null, ranks, spectrum, w0 + + +def quantities(logits, w, w0, labels, eweight, rweight, ref, covariance, obj, repr_factor): + logp = logits.double().log_softmax(-1) + ce = -logp.gather(-1, labels[..., None])[..., 0].mean(-1) + le, lr = (ce * eweight).sum(-1), (ce * rweight).sum(-1) + if obj == "func": + distance = ((ref.exp() * (ref - logp)).sum(-1).mean(-1) * rweight).sum(-1).clamp_min(0) + else: + delta = w - w0 + change = torch.einsum("nqtk,ndk->nqtd", repr_factor, delta) + distance = change.double().square().sum((1, 2, 3)) + return le, lr, distance + + +@torch.no_grad() +def evaluate_weights(model, layer, tasks, weights): + result = [] + # One run at a time keeps evaluation memory bounded for the 8-layer model. + for task, w in zip(tasks, weights, strict=True): + suffix = Suffix(model, layer, task.tokens, task.positions) + logits = suffix(w[None])[0] + parent_logits = suffix(model.blocks[layer].mlp.down.weight[None])[0] + pred = logits.argmax(-1) + old_pred = parent_logits.argmax(-1) + correct = pred.eq(task.labels).all(-1) + old_correct = old_pred.eq(task.old_labels).all(-1) + if task.labels.shape[1] == 2: + # EOS must be generated after the model's own answer, not the target. + tokens = task.tokens.clone() + lengths = task.positions[:, 0] + 1 + tokens[torch.arange(len(tokens), device=tokens.device), lengths] = pred[:, 0] + generated = Suffix(model, layer, tokens, lengths[:, None])(w[None])[0, :, 0].argmax(-1) + tokens[torch.arange(len(tokens), device=tokens.device), lengths] = old_pred[:, 0] + old_generated = Suffix(model, layer, tokens, lengths[:, None])( + model.blocks[layer].mlp.down.weight[None] + )[0, :, 0].argmax(-1) + correct = pred[:, 0].eq(task.labels[:, 0]) & generated.eq(3) + old_correct = old_pred[:, 0].eq(task.old_labels[:, 0]) & old_generated.eq(3) + nll = -logits.log_softmax(-1).gather(-1, task.labels[..., None])[..., 0].mean(-1) + row = {"sets": {}, "prediction": pred[:, 0].cpu().tolist()} + for key, ids in task.sets.items(): + indices = torch.tensor(ids, device=w.device, dtype=torch.long) + known = old_correct[indices] + row["sets"][key] = { + "n": len(ids), + "correct": int(correct[indices].sum()), + "old_known": int(known.sum()), + "broken": int((known & ~correct[indices]).sum()), + "nll": float(nll[indices].mean()) if ids else None, + } + e, local, u = (row["sets"][x] for x in ("E", "local", "U")) + row["joint"] = e["correct"] == e["n"] and local["broken"] == 0 and u["broken"] == 0 + row["e_joint"] = e["correct"] == e["n"] + pair = task.metadata.get("pair", task.sets["E"][:2]) + a, b, c = (task.metadata[x] for x in ("a", "b", "c")) + row["margins"] = { + "ab": (logits[pair, 0, a] - logits[pair, 0, b]).cpu().tolist(), + "ac": (logits[pair, 0, a] - logits[pair, 0, c]).cpu().tolist(), + "bc": (logits[pair, 0, b] - logits[pair, 0, c]).cpu().tolist(), + } + result.append(row) + return result + + +def edit_batch(model, layer, tasks, arm, configs, steps, directory, evaluate=True): + """Each batch member is an independent run; no cross-run loss/normalization.""" + directory = Path(directory) + if (directory / "complete.json").exists(): + return json.loads((directory / "metrics.json").read_text()) + directory.mkdir(parents=True, exist_ok=True) + obj, form, solver = arm.split("-") + setup = batch_setup(model, layer, tasks, configs) + suffix, labels, ew, rw, ref, cov, null, ranks, spectrum, w0 = setup + device = w0.device + n = len(tasks) + w = w0[None].expand(n, -1, -1).clone().requires_grad_() + m, v = torch.zeros_like(w), torch.zeros_like(w) + lr = torch.tensor([c["lr"] for c in configs], device=device) + level = torch.tensor([c["level"] for c in configs], device=device) + damping = configs[0]["damping"] + rank, refresh = configs[0]["rank"], configs[0]["refresh"] + strict = (level == 0) & (form == "hard") & (obj == "repr") + age = torch.zeros(n, device=device, dtype=torch.long) + failed = torch.zeros_like(age) + active = torch.ones(n, device=device, dtype=torch.bool) + sketch = None + generator = torch.Generator(device=device).manual_seed(271521) + records = [ + dict(task=t.manifest(), config=c, arm=arm, timeline=[]) + for t, c in zip(tasks, configs, strict=True) + ] + traces, checkpoints = [], {} + pair_columns = torch.tensor( + [[(t.sets["E"] + t.sets["R"]).index(i) for i in t.metadata["pair"]] for t in tasks], + device=device, + ) + answers_a = torch.tensor([t.metadata["a"] for t in tasks], device=device) + answers_b = torch.tensor([t.metadata["b"] for t in tasks], device=device) + rows = torch.arange(n, device=device) + counters = dict( + forward_batches=0, + backward_batches=0, + ggn_vjps=0, + line_search_batches=0, + covariance_eigh=1, + train_examples_per_batch=labels.shape[1], + batch_runs=n, + ) + if device.type == "cuda": + torch.cuda.synchronize(device) + start = time.monotonic() + limit = 11 * steps + 10 + for attempt in range(limit + 1): + if ( + attempt == 0 + or (attempt in NODES and attempt <= steps) + or not active.any() + or attempt == limit + ): + if device.type == "cuda": + torch.cuda.synchronize(device) + metrics = ( + evaluate_weights(model, layer, tasks, w.detach()) + if evaluate + else [dict() for _ in tasks] + ) + for j, metric in enumerate(metrics): + records[j]["timeline"].append( + dict( + attempt=attempt, + accepted=int(age[j]), + seconds=time.monotonic() - start, + **metric, + ) + ) + checkpoints[str(attempt)] = w.detach().cpu().clone() + if attempt and (not active.any() or attempt == limit): + break + if attempt >= steps and torch.all((age >= steps) | ~active): + break + logits = suffix(w) + le, lretain, distance = quantities( + logits, w, w0, labels, ew, rw, ref, cov, obj, suffix.repr_factor + ) + pair_gradients = None + if attempt in NODES: + pair_margin = torch.stack( + [ + logits[rows, pair_columns[:, i], 0, answers_a] + - logits[rows, pair_columns[:, i], 0, answers_b] + for i in range(2) + ], + -1, + ) + pair_gradients = torch.stack( + [ + torch.autograd.grad(pair_margin[:, i].sum(), w, retain_graph=True)[0].detach() + for i in range(2) + ], + 1, + ) + counters["backward_batches"] += 2 + data_loss = le + lretain + objective = data_loss + level * distance if form == "soft" else data_loss + if solver == "gn" and (sketch is None or attempt % refresh == 0 or failed.any()): + weights = ((ew + rw) / labels.shape[2])[..., None].expand_as(labels) + if form == "soft" and obj == "func": + weights = ((ew + (1 + level[:, None]) * rw) / labels.shape[2])[..., None].expand_as( + labels + ) + sketch = gaussian_newton_sketch(logits, w, weights, rank, generator) + if strict.any(): + projected = (sketch.reshape(n, rank, *w0.shape) @ null[:, None]).flatten(2) + sketch = torch.where(strict[:, None, None], projected, sketch) + counters["ggn_vjps"] += rank + g = torch.autograd.grad(objective.sum(), w, retain_graph=form == "hard")[0] + counters["backward_batches"] += 1 + if form == "hard": + a = torch.autograd.grad(distance.sum(), w)[0] + counters["backward_batches"] += 1 + else: + a = None + if solver == "adam": + m_new = 0.9 * m + 0.1 * g + v_new = 0.999 * v + 0.001 * g.square() + t = (age + 1).float()[:, None, None] + raw = -(m_new / (1 - 0.9**t)) / ((v_new / (1 - 0.999**t)).sqrt() + 1e-8) + proposal = lr[:, None, None] * raw + else: + if strict.any(): + g = torch.where(strict[:, None, None], g @ null, g) + if obj == "repr" and form == "soft": + # Exact representation Hessian plus damped sketched data GGN, CG. + def hv(x, sketch=sketch): + flat = x.flatten(1) + return ( + damping * x + + (sketch.transpose(-1, -2) @ (sketch @ flat[..., None]))[ + ..., 0 + ].reshape_as(x) + + 2 * level[:, None, None] * (x @ cov) + ) + + direction = torch.zeros_like(g) + residual, search = -g.clone(), -g.clone() + rr = residual.square().sum((-1, -2)) + for _ in range(16): + hp = hv(search) + alpha = rr / (search * hp).sum((-1, -2)).clamp_min(1e-30) + direction += alpha[:, None, None] * search + residual -= alpha[:, None, None] * hp + new_rr = residual.square().sum((-1, -2)) + search = residual + (new_rr / rr.clamp_min(1e-30))[:, None, None] * search + rr = new_rr + proposal = lr[:, None, None] * direction + else: + proposal = -lr[:, None, None] * inverse_sketch(g, sketch, damping) + # Fixed Euclidean trust radius, no hidden per-run gradient scaling. + radius = configs[0]["trust_fraction"] * w0.norm() + proposal *= (radius / proposal.flatten(1).norm(dim=1).clamp_min(1e-12)).clamp(max=1)[ + :, None, None + ] + m_new, v_new = m, v + if form == "hard": + if strict.any(): + proposal = torch.where(strict[:, None, None], proposal @ null, proposal) + metric_a = a if solver == "adam" else inverse_sketch(a, sketch, damping) + # Sequential quadratic subproblem with a linearized ORIGINAL distance. + # Interior restoration avoids accumulating positive second-order drift. + slack = torch.where(distance > 0.8 * level, -0.05 * level, 0.8 * (level - distance)) + excess = (a * proposal).sum((-1, -2)) - slack + correction = excess.clamp_min(0) / (a * metric_a).sum((-1, -2)).clamp_min(1e-20) + adjusted = proposal - correction[:, None, None] * metric_a + proposal = torch.where(strict[:, None, None], proposal, adjusted).to(w.dtype) + proposal = torch.where(active[:, None, None], proposal, torch.zeros_like(proposal)) + accepted = torch.zeros_like(active) + chosen = w.detach().clone() + chosen_logits = logits.detach().clone() + picked_scale = torch.zeros(n, device=device) + actual_d = distance.detach().clone() + for backtrack in range(10): + with torch.no_grad(): + candidate = w.detach() + (0.5**backtrack) * proposal + if strict.any(): + exact = w0 + (candidate - w0) @ null + candidate = torch.where(strict[:, None, None], exact, candidate) + candidate_logits = suffix(candidate) + cle, clr, cd = quantities( + candidate_logits, + candidate, + w0, + labels, + ew, + rw, + ref, + cov, + obj, + suffix.repr_factor, + ) + co = cle + clr + level * cd if form == "soft" else cle + clr + tolerance = torch.where(strict, torch.full_like(level, 1e-10), 1e-8 + 1e-5 * level) + feasible = torch.ones_like(active) if form == "soft" else cd <= level + tolerance + descent = co <= objective.detach() + 1e-7 if solver == "gn" else torch.isfinite(co) + if form == "hard" and solver == "gn": + restoration = ( + (distance.detach() > 0.8 * level) + & (cd < distance.detach() - 1e-4 * level) + & (co <= 1.05 * objective.detach() + 1e-6) + & ~strict + ) + descent = descent | restoration + good = feasible & descent & active & ~accepted & torch.isfinite(co) + chosen[good] = candidate[good] + chosen_logits[good] = candidate_logits[good] + actual_d[good] = cd[good] + picked_scale[good] = 0.5**backtrack + accepted |= good + counters["line_search_batches"] += 1 + if torch.all(accepted | ~active): + break + delta = chosen - w.detach() + if pair_gradients is not None: + predicted = (pair_gradients * delta[:, None]).sum((-1, -2)) + updated_margin = torch.stack( + [ + chosen_logits[rows, pair_columns[:, i], 0, answers_a] + - chosen_logits[rows, pair_columns[:, i], 0, answers_b] + for i in range(2) + ], + -1, + ) + observed = updated_margin - pair_margin.detach() + flat = pair_gradients.flatten(2) + kernel = flat @ flat.transpose(-1, -2) + for j in range(n): + records[j]["timeline"][-1]["local_step"] = { + "kernel": kernel[j].cpu().tolist(), + "predicted_margin_change": predicted[j].cpu().tolist(), + "observed_margin_change": observed[j].cpu().tolist(), + "actual_delta_norm": float(delta[j].norm()), + } + + with torch.no_grad(): + w.copy_(chosen) + m.copy_(torch.where(accepted[:, None, None], m_new, m)) + v.copy_(torch.where(accepted[:, None, None], v_new, v)) + age += accepted + failed = torch.where(accepted, torch.zeros_like(failed), failed + 1) + active = (age < steps) & (failed < 10) + traces.append( + torch.stack( + ( + le.detach(), + lretain.detach(), + distance.detach(), + actual_d, + delta.flatten(1).norm(dim=1), + picked_scale, + accepted.float(), + age.float(), + ), + -1, + ).cpu() + ) + if device.type == "cuda": + torch.cuda.synchronize(device) + elapsed = time.monotonic() - start + counters["forward_batches"] = suffix.forward_calls + counters["elapsed_seconds_including_evaluation"] = elapsed + for j, record in enumerate(records): + record.update( + accepted=int(age[j]), + failed=bool(failed[j] >= 10), + elapsed_batch_seconds=elapsed, + representation_rank=int(ranks[j]), + representation_spectrum=spectrum[j].cpu().tolist(), + ) + write_json(directory / "metrics.json", records) + torch.save( + dict( + weights=w.detach().cpu(), + parent=w0.cpu(), + checkpoints=checkpoints, + m=m.cpu(), + v=v.cpu(), + age=age.cpu(), + sketch=None if sketch is None else sketch.cpu(), + generator_state=generator.get_state(), + arm=arm, + configs=configs, + ), + directory / "state.pt", + ) + np.savez_compressed( + directory / "steps.npz", + values=torch.stack(traces).numpy(), + columns=np.array( + [ + "E_CE", + "R_CE", + "distance_before", + "distance_after", + "delta_norm", + "backtrack_scale", + "accepted", + "accepted_count", + ] + ), + ) + write_json(directory / "cost.json", counters) + write_json( + directory / "complete.json", + dict( + files={ + name: digest(directory / name) + for name in ("metrics.json", "state.pt", "steps.npz", "cost.json") + } + ), + ) + return records diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_cross.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_cross.py new file mode 100644 index 0000000000000000000000000000000000000000..27051c00db64d66676d95dc16a1351dff5d797a6 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_cross.py @@ -0,0 +1,149 @@ +"""Target-complete edits on the original two-chain, eight-layer task.""" + +import numpy as np +import torch + +from .bios_cross import edit_pair, make_cross_world +from .bios_cross_train import tensor_queries +from .bios_direction import ROOT, Task, stable_order + +CROSS_ARMS = ("func-soft-adam", "repr-hard-adam", "func-hard-gn", "func-soft-gn") + + +def cross_tasks(world_id, seed, device): + world = make_cross_world(world_id, ROOT / "data/bios-organization-v1") + tasks = [] + for chain in (0, 1): + edits = edit_pair(world, chain) + for group_index, group in enumerate(edits["groups"]): + members = np.flatnonzero(world.memberships[chain] == group) + eligible = [ + int(p) + for p in members + if not world.exceptions[chain, p] + and world.derived_ids[chain, p] in world.heldout_ids[chain] + ] + person = stable_order(eligible, "focal", world_id, chain, int(group))[0] + root, actual = int(world.root_ids[chain, group]), int(world.actual_ids[chain, person]) + c = int(world.answers[root]) + a = int( + world.city_tokens[world.defaults[chain, edits["groups"][(group_index + 1) % 3]]] + ) + b = int( + world.city_tokens[world.defaults[chain, edits["groups"][(group_index + 2) % 3]]] + ) + assert len({a, b, c}) == 3 and int(world.answers[actual]) == c + e = [root, actual] + d = world.derived_ids[chain, members].tolist() + focal = int(world.derived_ids[chain, person]) + assert focal in world.heldout_ids[chain] + membership = int(world.membership_ids[chain, person]) + local = np.flatnonzero( + (world.person == person) & (np.arange(len(world.answers)) < world.n_base) + ).tolist() + local = [i for i in local if i not in e + [membership]] + # Near facts exclude all direct edits and all affected compositions. + near_pool = list( + set( + world.actual_ids[chain, members].tolist() + + world.membership_ids[chain, members].tolist() + ) + - set(e + [membership] + local) + ) + near = stable_order(near_pool, "near", world_id, chain, int(group))[:48] + reserved = set(e + d + local + near + [membership]) + base_pool = stable_order( + [i for i in range(world.n_base) if i not in reserved], + "base", + world_id, + chain, + int(group), + ) + r = [membership] + base_pool[:47] + v = base_pool[47:95] + far_base = base_pool[95:175] + other_d = stable_order( + [int(i) for i in world.heldout_ids.flatten() if i not in reserved], + "far-d", + world_id, + chain, + int(group), + )[:16] + far = far_base + other_d + u = local + near + far + included = e + r + v + u + d + assert len(included) == len(set(included)) + mapping = {old: new for new, old in enumerate(included)} + sets = { + "E": e, + "R": r, + "V": v, + "U": u, + "local": local, + "U_near": near, + "U_far": far, + "D": d, + "D_heldout": [i for i in d if i in world.heldout_ids[chain]], + "D_focal": [focal], + } + for kind in ("coherent", "independent"): + truth = world.answers.copy() + truth[root], truth[actual], truth[d] = a, a if kind == "coherent" else b, a + assert set(np.flatnonzero(truth != world.answers)) == set(e + d) + data = tensor_queries(world, device, truth) + old = torch.stack( + [ + torch.as_tensor(world.answers[included], device=device), + torch.full((len(included),), 3, device=device), + ], + -1, + ) + tasks.append( + Task( + f"world-{world_id}-seed-{seed}-chain-{chain}-group-{int(group)}-{kind}", + data["tokens"][included], + data["positions"][included], + data["labels"][included], + old, + {k: [mapping[i] for i in ids] for k, ids in sets.items()}, + dict( + world=world_id, + seed=seed, + chain=chain, + group=int(group), + group_index=group_index, + person=person, + kind=kind, + a=a, + b=b, + c=c, + pair=[mapping[actual], mapping[root]], + original_ids=included, + ), + ) + ) + return tasks + + +def bounded_representation_geometry(suffix, rmask, w0): + """Same FP64 covariance as the core; avoid a huge four-axis outer product.""" + z = suffix.z + mask = rmask[..., None].expand(-1, -1, z.shape[2]) + valid = ( + torch.arange(z.shape[2], device=z.device)[None, None, :] + <= suffix.positions.max(-1).values[..., None] + ) + mask = mask * valid + flat = z.double().flatten(1, 2) + covariance = flat.transpose(-1, -2) @ (flat * mask.flatten(1)[..., None]) + covariance = covariance / mask.sum((1, 2))[:, None, None] + output = torch.einsum("nqtk,dk->nqtd", z, w0) + suffix.model.blocks[suffix.layer].mlp.down.bias + scale = (output.square().sum(-1) * mask).sum((1, 2)) / mask.sum((1, 2)) + covariance = covariance / scale[:, None, None].clamp_min(1e-12) + suffix.repr_factor = ( + z * (mask / (mask.sum((1, 2)) * scale).clamp_min(1e-12)[:, None, None]).sqrt()[..., None] + ) + vals, vecs = torch.linalg.eigh(covariance) + keep = vals > vals[:, -1:] * 1e-10 + null = (vecs * (~keep)[:, None, :]) @ vecs.transpose(-1, -2) + return covariance.to(w0.dtype), null.to(w0.dtype), keep.sum(-1), vals diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_formation.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_formation.py new file mode 100644 index 0000000000000000000000000000000000000000..96a3aa141c344b0fea47995c861792eb5d95398a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_formation.py @@ -0,0 +1,241 @@ +"""Prospective learning-rate interventions and factor measurements on new worlds.""" + +import copy +import json +from pathlib import Path + +import numpy as np +import torch +from torch import nn +from torch.nn import functional as F + +from .bios_data import write_json +from .bios_direction import ROOT, digest, edit_batch, minimal_task +from .bios_direction_cross import CROSS_ARMS +from .bios_model import CausalLM, ModelConfig + +TRAIN_NODES = (0, 8, 32, 128, 256, 512, 1024) +TRAIN_ARMS = ("baseline", "qk-0.25", "qk-4", "up-0.25", "up-4", "post-0.25", "post-4") + + +def world_labels(world): + rng = np.random.default_rng(np.random.SeedSequence([271523, world])) + r1 = np.r_[ + np.arange(3), rng.permutation(np.r_[np.repeat(0, 10), np.repeat(1, 10), np.repeat(2, 9)]) + ] + exceptions = np.concatenate( + [ + rng.choice(np.flatnonzero((r1 == v) & (np.arange(32) >= 3)), n, replace=False) + for v, n in enumerate((3, 3, 2)) + ] + ) + r2 = r1.copy() + r2[exceptions] = np.roll(r1[exceptions], -3) + r3 = rng.permutation(np.arange(32) % 3) + labels = np.stack((r1, r2, r3), -1) + assert (r1 == r2).sum() == 24 and np.all(r1[:3] == r2[:3]) + for col in labels.T: + assert np.ptp(np.bincount(col, minlength=3)) <= 1 + return torch.tensor(labels.flatten() + 38, dtype=torch.long) + + +def optimizer_views(model): + """Separate Q/K and V learning rates without changing forward computation. + + Optimizer leaf views share parameter storage; their gradients are assigned + from the original model's autograd gradients. A frozen view gets grad=None, + so its optimizer moments and step count genuinely stop. + """ + groups = {k: [] for k in ("qk", "up", "post", "other")} + mapping = [] + for name, p in model.named_parameters(): + if name.startswith("blocks.0.attention.qkv."): + pieces = [("qk", slice(0, 128)), ("other", slice(128, None))] + else: + group = ( + "up" + if name.startswith("blocks.0.mlp.up.") + else ("post" if name.startswith("blocks.1.") else "other") + ) + pieces = [(group, slice(None))] + for group, region in pieces: + view = nn.Parameter(p.detach()[region]) + groups[group].append(view) + mapping.append((group, p, region, view)) + optimizer = torch.optim.AdamW( + [dict(params=params, lr=0.001, name=name) for name, params in groups.items()], + weight_decay=0.1, + foreach=True, + ) + return optimizer, mapping + + +def multiplier(arm, step): + if arm == "baseline": + return None, 1.0 + group, mode = arm.split("-") + if mode == "freezeearly": + return group, 0.0 if step < 256 else 1.0 + if mode == "freezelate": + return group, 0.0 if step >= 768 else 1.0 + if mode == "freezeall": + return group, 0.0 + return group, float(mode) if step < 256 else 1.0 + + +def factor_measure(model, seed, labels, device): + records = [] + for person in (0, 1, 2): + task = minimal_task(seed, person, "independent", device, labels) + ids = task.metadata["pair"] + captured = {} + + def capture(module, inputs, output, captured=captured): + captured.update(z=inputs[0], h=output) + + handle = model.blocks[0].mlp.down.register_forward_hook(capture) + tokens = task.tokens[ids] + logits = model(tokens)[:, -1] + handle.remove() + a, b, c = (task.metadata[x] for x in ("a", "b", "c")) + margin = logits[:, a] - logits[:, b] + gradients = [] + deltas = [] + for i in range(2): + g, d = torch.autograd.grad( + margin[i], (model.blocks[0].mlp.down.weight, captured["h"]), retain_graph=True + ) + gradients.append(g.detach()) + deltas.append(d[i].detach()) + g = torch.stack(gradients).flatten(1) + kernel = g @ g.T + z = captured["z"].detach() + d = torch.stack(deltas) + rebuilt = torch.einsum("itd,itk->idk", d, z).flatten(1) + error = (rebuilt - g).norm() / g.norm().clamp_min(1e-20) + common = float((kernel[0, 0] + kernel[1, 1] + 2 * kernel[0, 1]) / 2) + difference = float((kernel[0, 0] + kernel[1, 1] - 2 * kernel[0, 1]) / 2) + # Actual GELU slope at the preactivation, not a binary activation mask. + pre = model.blocks[0].mlp.up + activations = {} + + def pre_hook(module, inputs, output, activations=activations): + activations.update(input=inputs[0], pre=output) + + handle = pre.register_forward_hook(pre_hook) + model(tokens) + handle.remove() + y = activations["pre"] + gate = torch.autograd.grad(model.blocks[0].mlp.activation(y).sum(), y)[0].detach() + + def cosine(x): + return float(F.cosine_similarity(x[0].flatten(), x[1].flatten(), dim=0)) + + records.append( + dict( + person=person, + common=common, + difference=difference, + ratio=difference / max(common, 1e-20), + mixing=float((kernel[0, 0] - kernel[1, 1]) / 2), + eigenvalues=torch.linalg.eigvalsh(kernel.double()).tolist(), + feature_cos=cosine(z), + downstream_cos=cosine(d), + gate_cos=cosine(gate), + relation_input_difference=float( + (activations["input"][0] - activations["input"][1]).detach().norm() + ), + feature_difference=float((z[0] - z[1]).norm()), + gate_difference=float((gate[0] - gate[1]).norm()), + reconstruction_error=float(error), + new_target_nll=float(F.cross_entropy(logits, task.labels[ids, 0]).detach()), + margin_ab=margin.detach().tolist(), + kernel=kernel.detach().cpu().tolist(), + ) + ) + return records + + +def train(world, seed, arm, device, out): + out = Path(out) + if (out / "complete.json").exists(): + return + out.mkdir(parents=True, exist_ok=True) + labels = world_labels(world).to(device) + torch.manual_seed(seed) + model = CausalLM(ModelConfig(41, width=64, layers=2, heads=2, context=8)).to(device) + tokens = minimal_task(seed, 0, "independent", device, labels).tokens + opt, mapping = optimizer_views(model) + timeline = [] + for step in range(1025): + if step in TRAIN_NODES: + with torch.no_grad(): + logits = model(tokens)[:, -1] + acc = float(logits.argmax(-1).eq(labels).float().mean()) + loss = float(F.cross_entropy(logits, labels)) + factors = factor_measure(model, seed, labels, device) + timeline.append(dict(step=step, accuracy=acc, loss=loss, factors=factors)) + torch.save( + dict( + model={k: v.detach().cpu() for k, v in model.state_dict().items()}, + config=model.config_dict(), + optimizer=opt.state_dict(), + step=step, + world=world, + seed=seed, + arm=arm, + labels=labels.cpu(), + ), + out / f"model-{step}.pt", + ) + if step == 1024: + break + model.zero_grad(set_to_none=True) + opt.zero_grad(set_to_none=True) + loss = F.cross_entropy(model(tokens)[:, -1], labels) + loss.backward() + selected, factor = multiplier(arm, step) + for group in opt.param_groups: + group["lr"] = 0.001 * (factor if group["name"] == selected else 1.0) + for group, p, region, view in mapping: + view.grad = None if group == selected and factor == 0 else p.grad[region] + opt.step() + write_json(out / "learning.json", timeline) + write_json( + out / "complete.json", + dict( + world=world, + seed=seed, + arm=arm, + files={p.name: digest(p) for p in out.iterdir() if p.suffix in (".json", ".pt")}, + ), + ) + + +def edit_parent(world, seed, train_arm, device, out, edit_arms=CROSS_ARMS, steps=1024): + from .bios_direction import load_parent + + out = Path(out) + saved = torch.load(out / "model-1024.pt", map_location="cpu", weights_only=False) + labels = saved["labels"].to(device) + model = load_parent(out / "model-1024.pt", device) + selected = json.loads( + (ROOT / "docs/development-artifacts/direction-v1/selected.json").read_text() + )["choices"] + tasks = [ + minimal_task(seed, p, k, device, labels) + for p in (0, 1, 2) + for k in ("coherent", "independent") + ] + for task in tasks: + task.metadata.update(world=world, train_arm=train_arm) + for arm in edit_arms: + edit_batch( + model, + 0, + tasks, + arm, + [copy.deepcopy(selected[arm]) for _ in tasks], + steps, + out / "edits" / arm, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_refresh.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_refresh.py new file mode 100644 index 0000000000000000000000000000000000000000..5f48462e2c66886ef8e483fa7e48986d075ad3fb --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_direction_refresh.py @@ -0,0 +1,355 @@ +"""V1 numerical audit: refresh curvature per trajectory and freeze idle counters. + +This keeps the original randomized batched probe stream, finite objectives, +constraints and solver settings. Unused fresh probe rows are discarded rather +than changing another trajectory's sketch. Frozen v1 artifacts are untouched. +""" + +import json +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_data import write_json +from .bios_direction import ( + NODES, + batch_setup, + digest, + evaluate_weights, + gaussian_newton_sketch, + inverse_sketch, + quantities, +) + + +def refresh_mask(active, failed, attempt, refresh, missing): + due = missing or attempt % refresh == 0 + return active & (torch.full_like(active, due) | (failed > 0)) + + +def update_failure_counts(active, accepted, failed): + return torch.where(active, torch.where(accepted, torch.zeros_like(failed), failed + 1), failed) + + +def edit_batch(model, layer, tasks, arm, configs, steps, directory, evaluate=True): + """Each batch member is an independent run; no cross-run loss/normalization.""" + directory = Path(directory) + if (directory / "complete.json").exists(): + return json.loads((directory / "metrics.json").read_text()) + directory.mkdir(parents=True, exist_ok=True) + obj, form, solver = arm.split("-") + setup = batch_setup(model, layer, tasks, configs) + suffix, labels, ew, rw, ref, cov, null, ranks, spectrum, w0 = setup + device = w0.device + n = len(tasks) + w = w0[None].expand(n, -1, -1).clone().requires_grad_() + m, v = torch.zeros_like(w), torch.zeros_like(w) + lr = torch.tensor([c["lr"] for c in configs], device=device) + level = torch.tensor([c["level"] for c in configs], device=device) + damping = configs[0]["damping"] + rank, refresh = configs[0]["rank"], configs[0]["refresh"] + strict = (level == 0) & (form == "hard") & (obj == "repr") + age = torch.zeros(n, device=device, dtype=torch.long) + failed = torch.zeros_like(age) + active = torch.ones(n, device=device, dtype=torch.bool) + sketch = None + generator = torch.Generator(device=device).manual_seed(271521) + records = [ + dict(task=t.manifest(), config=c, arm=arm, timeline=[]) + for t, c in zip(tasks, configs, strict=True) + ] + traces, checkpoints = [], {} + pair_columns = torch.tensor( + [[(t.sets["E"] + t.sets["R"]).index(i) for i in t.metadata["pair"]] for t in tasks], + device=device, + ) + answers_a = torch.tensor([t.metadata["a"] for t in tasks], device=device) + answers_b = torch.tensor([t.metadata["b"] for t in tasks], device=device) + rows = torch.arange(n, device=device) + counters = dict( + forward_batches=0, + backward_batches=0, + ggn_vjps=0, + line_search_batches=0, + covariance_eigh=1, + train_examples_per_batch=labels.shape[1], + batch_runs=n, + ) + if device.type == "cuda": + torch.cuda.synchronize(device) + start = time.monotonic() + limit = 11 * steps + 10 + for attempt in range(limit + 1): + if ( + attempt == 0 + or (attempt in NODES and attempt <= steps) + or not active.any() + or attempt == limit + ): + if device.type == "cuda": + torch.cuda.synchronize(device) + metrics = ( + evaluate_weights(model, layer, tasks, w.detach()) + if evaluate + else [dict() for _ in tasks] + ) + for j, metric in enumerate(metrics): + records[j]["timeline"].append( + dict( + attempt=attempt, + accepted=int(age[j]), + seconds=time.monotonic() - start, + **metric, + ) + ) + checkpoints[str(attempt)] = w.detach().cpu().clone() + if attempt and (not active.any() or attempt == limit): + break + if attempt >= steps and torch.all((age >= steps) | ~active): + break + logits = suffix(w) + le, lretain, distance = quantities( + logits, w, w0, labels, ew, rw, ref, cov, obj, suffix.repr_factor + ) + pair_gradients = None + if attempt in NODES: + pair_margin = torch.stack( + [ + logits[rows, pair_columns[:, i], 0, answers_a] + - logits[rows, pair_columns[:, i], 0, answers_b] + for i in range(2) + ], + -1, + ) + pair_gradients = torch.stack( + [ + torch.autograd.grad(pair_margin[:, i].sum(), w, retain_graph=True)[0].detach() + for i in range(2) + ], + 1, + ) + counters["backward_batches"] += 2 + data_loss = le + lretain + objective = data_loss + level * distance if form == "soft" else data_loss + refresh_rows = refresh_mask(active, failed, attempt, refresh, sketch is None) + if solver == "gn" and refresh_rows.any(): + weights = ((ew + rw) / labels.shape[2])[..., None].expand_as(labels) + if form == "soft" and obj == "func": + weights = ((ew + (1 + level[:, None]) * rw) / labels.shape[2])[..., None].expand_as( + labels + ) + fresh = gaussian_newton_sketch(logits, w, weights, rank, generator) + if strict.any(): + projected = (fresh.reshape(n, rank, *w0.shape) @ null[:, None]).flatten(2) + fresh = torch.where(strict[:, None, None], projected, fresh) + sketch = ( + fresh if sketch is None else torch.where(refresh_rows[:, None, None], fresh, sketch) + ) + counters["ggn_vjps"] += rank + g = torch.autograd.grad(objective.sum(), w, retain_graph=form == "hard")[0] + counters["backward_batches"] += 1 + if form == "hard": + a = torch.autograd.grad(distance.sum(), w)[0] + counters["backward_batches"] += 1 + else: + a = None + if solver == "adam": + m_new = 0.9 * m + 0.1 * g + v_new = 0.999 * v + 0.001 * g.square() + t = (age + 1).float()[:, None, None] + raw = -(m_new / (1 - 0.9**t)) / ((v_new / (1 - 0.999**t)).sqrt() + 1e-8) + proposal = lr[:, None, None] * raw + else: + if strict.any(): + g = torch.where(strict[:, None, None], g @ null, g) + if obj == "repr" and form == "soft": + # Exact representation Hessian plus damped sketched data GGN, CG. + def hv(x, sketch=sketch): + flat = x.flatten(1) + return ( + damping * x + + (sketch.transpose(-1, -2) @ (sketch @ flat[..., None]))[ + ..., 0 + ].reshape_as(x) + + 2 * level[:, None, None] * (x @ cov) + ) + + direction = torch.zeros_like(g) + residual, search = -g.clone(), -g.clone() + rr = residual.square().sum((-1, -2)) + for _ in range(16): + hp = hv(search) + alpha = rr / (search * hp).sum((-1, -2)).clamp_min(1e-30) + direction += alpha[:, None, None] * search + residual -= alpha[:, None, None] * hp + new_rr = residual.square().sum((-1, -2)) + search = residual + (new_rr / rr.clamp_min(1e-30))[:, None, None] * search + rr = new_rr + proposal = lr[:, None, None] * direction + else: + proposal = -lr[:, None, None] * inverse_sketch(g, sketch, damping) + # Fixed Euclidean trust radius, no hidden per-run gradient scaling. + radius = configs[0]["trust_fraction"] * w0.norm() + proposal *= (radius / proposal.flatten(1).norm(dim=1).clamp_min(1e-12)).clamp(max=1)[ + :, None, None + ] + m_new, v_new = m, v + if form == "hard": + if strict.any(): + proposal = torch.where(strict[:, None, None], proposal @ null, proposal) + metric_a = a if solver == "adam" else inverse_sketch(a, sketch, damping) + # Sequential quadratic subproblem with a linearized ORIGINAL distance. + # Interior restoration avoids accumulating positive second-order drift. + slack = torch.where(distance > 0.8 * level, -0.05 * level, 0.8 * (level - distance)) + excess = (a * proposal).sum((-1, -2)) - slack + correction = excess.clamp_min(0) / (a * metric_a).sum((-1, -2)).clamp_min(1e-20) + adjusted = proposal - correction[:, None, None] * metric_a + proposal = torch.where(strict[:, None, None], proposal, adjusted).to(w.dtype) + proposal = torch.where(active[:, None, None], proposal, torch.zeros_like(proposal)) + accepted = torch.zeros_like(active) + chosen = w.detach().clone() + chosen_logits = logits.detach().clone() + picked_scale = torch.zeros(n, device=device) + actual_d = distance.detach().clone() + for backtrack in range(10): + with torch.no_grad(): + candidate = w.detach() + (0.5**backtrack) * proposal + if strict.any(): + exact = w0 + (candidate - w0) @ null + candidate = torch.where(strict[:, None, None], exact, candidate) + candidate_logits = suffix(candidate) + cle, clr, cd = quantities( + candidate_logits, + candidate, + w0, + labels, + ew, + rw, + ref, + cov, + obj, + suffix.repr_factor, + ) + co = cle + clr + level * cd if form == "soft" else cle + clr + tolerance = torch.where(strict, torch.full_like(level, 1e-10), 1e-8 + 1e-5 * level) + feasible = torch.ones_like(active) if form == "soft" else cd <= level + tolerance + descent = co <= objective.detach() + 1e-7 if solver == "gn" else torch.isfinite(co) + if form == "hard" and solver == "gn": + restoration = ( + (distance.detach() > 0.8 * level) + & (cd < distance.detach() - 1e-4 * level) + & (co <= 1.05 * objective.detach() + 1e-6) + & ~strict + ) + descent = descent | restoration + good = feasible & descent & active & ~accepted & torch.isfinite(co) + chosen[good] = candidate[good] + chosen_logits[good] = candidate_logits[good] + actual_d[good] = cd[good] + picked_scale[good] = 0.5**backtrack + accepted |= good + counters["line_search_batches"] += 1 + if torch.all(accepted | ~active): + break + delta = chosen - w.detach() + if pair_gradients is not None: + predicted = (pair_gradients * delta[:, None]).sum((-1, -2)) + updated_margin = torch.stack( + [ + chosen_logits[rows, pair_columns[:, i], 0, answers_a] + - chosen_logits[rows, pair_columns[:, i], 0, answers_b] + for i in range(2) + ], + -1, + ) + observed = updated_margin - pair_margin.detach() + flat = pair_gradients.flatten(2) + kernel = flat @ flat.transpose(-1, -2) + for j in range(n): + records[j]["timeline"][-1]["local_step"] = { + "kernel": kernel[j].cpu().tolist(), + "predicted_margin_change": predicted[j].cpu().tolist(), + "observed_margin_change": observed[j].cpu().tolist(), + "actual_delta_norm": float(delta[j].norm()), + } + + with torch.no_grad(): + w.copy_(chosen) + m.copy_(torch.where(accepted[:, None, None], m_new, m)) + v.copy_(torch.where(accepted[:, None, None], v_new, v)) + age += accepted + failed = update_failure_counts(active, accepted, failed) + active = (age < steps) & (failed < 10) + traces.append( + torch.stack( + ( + le.detach(), + lretain.detach(), + distance.detach(), + actual_d, + delta.flatten(1).norm(dim=1), + picked_scale, + accepted.float(), + age.float(), + ), + -1, + ).cpu() + ) + if device.type == "cuda": + torch.cuda.synchronize(device) + elapsed = time.monotonic() - start + counters["forward_batches"] = suffix.forward_calls + counters["elapsed_seconds_including_evaluation"] = elapsed + for j, record in enumerate(records): + record.update( + accepted=int(age[j]), + failed=bool(failed[j] >= 10 and age[j] < steps), + elapsed_batch_seconds=elapsed, + representation_rank=int(ranks[j]), + representation_spectrum=spectrum[j].cpu().tolist(), + ) + write_json(directory / "metrics.json", records) + torch.save( + dict( + weights=w.detach().cpu(), + parent=w0.cpu(), + checkpoints=checkpoints, + m=m.cpu(), + v=v.cpu(), + age=age.cpu(), + sketch=None if sketch is None else sketch.cpu(), + generator_state=generator.get_state(), + arm=arm, + configs=configs, + ), + directory / "state.pt", + ) + np.savez_compressed( + directory / "steps.npz", + values=torch.stack(traces).numpy(), + columns=np.array( + [ + "E_CE", + "R_CE", + "distance_before", + "distance_after", + "delta_norm", + "backtrack_scale", + "accepted", + "accepted_count", + ] + ), + ) + write_json(directory / "cost.json", counters) + write_json( + directory / "complete.json", + dict( + files={ + name: digest(directory / name) + for name in ("metrics.json", "state.pt", "steps.npz", "cost.json") + } + ), + ) + return records diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_edit.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_edit.py new file mode 100644 index 0000000000000000000000000000000000000000..685a33d6157d090f0afdfaa38b5c2d731eda4d0e --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_edit.py @@ -0,0 +1,381 @@ +"""Fixed-budget development edits with held-out retention and full-answer scoring.""" + +import argparse +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_branch import attach_branch, build_bases, remove_branch +from .bios_data import N_BASE, N_QUERIES, load_world, paired_edit, rng_for, write_json +from .bios_model import CausalLM, ModelConfig, matmul_flops, select_parameters +from .bios_train import code_fingerprint, evaluate, precision, tensor_data + +EDIT_CHECKPOINTS = (0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512) + + +def score_edit(world, pair, target, arrays, old_correct): + correct = arrays["correct"] + e, d = pair["E"], pair["D"] + root = e[world.relation[e] == 1] + members = e[world.relation[e] == 2] + unseen = np.zeros(N_QUERIES, dtype=bool) + unseen[pair["heldout"]] = True + retention, full_retention = {}, {} + for g in range(4): + ids = (pair["strata"] == g) & old_correct + full_retention[str(g)] = { + "known": int(ids.sum()), + "broken": int((ids & ~correct).sum()), + "rate": float((~correct[ids]).mean()) if ids.any() else None, + } + held = ids & unseen + retention[str(g)] = { + "known": int(held.sum()), + "broken": int((held & ~correct).sum()), + "rate": float((~correct[held]).mean()) if held.any() else None, + } + for name, base in (("2_base", True), ("2_derived", False)): + ids = ( + (pair["strata"] == 2) & old_correct & unseen & ((np.arange(N_QUERIES) < N_BASE) == base) + ) + retention[name] = { + "known": int(ids.sum()), + "broken": int((ids & ~correct).sum()), + "rate": float((~correct[ids]).mean()) if ids.any() else None, + } + rates = [v["rate"] for v in retention.values()] + root_acc, member_acc, d_acc = (float(correct[ids].mean()) for ids in (root, members, d)) + joint = ( + None + if any(rate is None for rate in rates) + else bool( + root_acc == 1 + and member_acc >= 0.95 + and d_acc >= 0.95 + and all(rate <= 0.01 for rate in rates) + ) + ) + return { + "E": float(correct[e].mean()), + "E_root": root_acc, + "E_member": member_acc, + "D": d_acc, + "U_accuracy": float(correct[pair["strata"] >= 0].mean()), + "U_heldout_destruction": retention, + "U_full_destruction": full_retention, + "joint_pass": joint, + "E_target_value_nll": float(arrays["value_nll"][e].mean()), + } + + +def reference_logits(model, data, ids, device): + result = [] + with torch.no_grad(), precision(device): + for begin in range(0, len(ids), 256): + subset = torch.as_tensor(ids[begin : begin + 256], device=device) + result.append(model(data["tokens"][subset], data["positions"][subset]).detach()) + return torch.cat(result) + + +@torch.no_grad() +def capture_down(model, tokens, positions, layer): + captured = {} + + def capture(module, inputs, output): + captured.update( + z=inputs[0].float().clone(), + h=output.float().clone(), + weight=module.weight.detach().float().clone(), + ) + + handle = model.blocks[layer].mlp.down.register_forward_hook(capture) + try: + model(tokens, positions) + finally: + handle.remove() + return captured + + +def edit_case( + model, + baseline, + world, + data_old, + pair, + kind, + scope, + args, + old_correct, + branch_kind=None, + basis=None, +): + suffix = "" if branch_kind is None else f"-{branch_kind}-branch" + out = Path(args.output) / f"support-{pair['support']}-{kind}-{scope}{suffix}" + if (out / "complete.json").exists(): + return json.loads((out / "complete.json").read_text()) + out.mkdir(parents=True, exist_ok=True) + device = data_old["tokens"].device + model.load_state_dict(baseline) + selected = select_parameters(model, scope, args.window) + branch, handles, zero_error = None, [], None + if basis is not None: + probe = torch.as_tensor(pair["E"][:32], device=device) + with torch.no_grad(), precision(device): + before = model(data_old["tokens"][probe], data_old["positions"][probe]) + branch, handles = attach_branch(model, basis, layer=args.window + 1) + selected.extend(branch.parameters()) + with torch.no_grad(), precision(device): + after = model(data_old["tokens"][probe], data_old["positions"][probe]) + zero_error = (before - after).abs().max().item() + if zero_error != 0: + raise ValueError("Branch was not function-preserving at initialization") + target = pair[kind] + data_new = tensor_data(world, device, target) + if device.type == "cuda": + torch.cuda.synchronize(device) + setup_start = time.perf_counter() + calibration = None + if scope == "down": + calibration_ids = torch.as_tensor( + np.concatenate([pair["E"][:32], pair["replay"][:32]]), device=device + ) + calibration = capture_down( + model, + data_old["tokens"][calibration_ids], + data_old["positions"][calibration_ids], + args.window + 1, + ) + old_logits = reference_logits(model, data_old, pair["replay"], device) + if device.type == "cuda": + torch.cuda.synchronize(device) + setup_seconds = time.perf_counter() - setup_start + basis_seconds = getattr(args, "branch_preparation_seconds", 0.0) if basis else 0.0 + setup_flops = matmul_flops(model.config, len(pair["replay"]), backward=False) + optimizer = torch.optim.AdamW( + selected, lr=args.lr, weight_decay=0.1, fused=device.type == "cuda" + ) + sample_rng = rng_for(world.seed, 41, pair["support"]) + e_choices = sample_rng.integers(0, len(pair["E"]), size=(args.steps, 128)) + r_choices = sample_rng.integers(0, len(pair["replay"]), size=(args.steps, 128)) + timeline, train_seconds = [], 0.0 + case_config = { + "scope": scope, + "branch": branch_kind, + "branch_parameters": sum(p.numel() for p in branch.parameters()) if branch else 0, + "branch_zero_initialization_max_logit_difference": zero_error, + "kind": kind, + "support": pair["support"], + "selection": pair["selection"], + "steps": args.steps, + "lr": args.lr, + "retention_kl_weight": args.retention, + "window_zero_based": list(range(args.window, args.window + 3)), + "trainable_parameters": sum(p.numel() for p in selected), + "setup_seconds": setup_seconds, + "shared_basis_preparation_seconds": basis_seconds, + "preparation_accounting": ( + "Basis construction is executed once per old checkpoint. Standalone cold-start time " + "below charges that entire common construction; do not sum it across reused branches." + ), + "setup_matmul_flops_estimate": setup_flops, + "flops_limitation": ( + "backward dense matmul upper approximation; not exact frozen-scope operation count" + ), + } + write_json(out / "config.json", case_config) + np.savez_compressed( + out / "sets.npz", + E=pair["E"], + D=pair["D"], + strata=pair["strata"], + replay=pair["replay"], + heldout=pair["heldout"], + target=target, + old_correct=old_correct, + edit_sampling=e_choices, + replay_sampling=r_choices, + ) + checkpoints = sorted({s for s in EDIT_CHECKPOINTS if s <= args.steps} | {args.steps}) + for step in range(args.steps + 1): + if step in checkpoints: + eval_start = time.perf_counter() + _, arrays = evaluate(model, data_old, world, answers=target) + metrics = score_edit(world, pair, target, arrays, old_correct) + np.savez_compressed(out / f"predictions-{step}.npz", **arrays) + point = { + "step": step, + **metrics, + "edit_seconds": train_seconds, + "setup_plus_edit_seconds": setup_seconds + train_seconds, + "cold_start_including_basis_seconds": basis_seconds + setup_seconds + train_seconds, + "setup_plus_edit_matmul_flops_estimate": setup_flops + + step * matmul_flops(model.config, 256), + "target_supervised_tokens": step * 256, + "replay_supervised_tokens": step * 256, + "eval_seconds": time.perf_counter() - eval_start, + } + if calibration is not None: + current = capture_down( + model, + data_old["tokens"][calibration_ids], + data_old["positions"][calibration_ids], + args.window + 1, + ) + observed = current["h"] - calibration["h"] + predicted = F.linear(calibration["z"], current["weight"] - calibration["weight"]) + point["down_calibration"] = { + "feature_max_change": (current["z"] - calibration["z"]).abs().max().item(), + "delta_h_max_error": (observed - predicted).abs().max().item(), + "delta_h_rms_error": (observed - predicted).square().mean().sqrt().item(), + "fixed_prefix_tokens": int( + calibration["z"].shape[0] * calibration["z"].shape[1] + ), + } + timeline.append(point) + write_json(out / "trajectory.json", timeline) + print( + json.dumps( + { + "event": "edit", + "case": out.name, + "step": step, + "E": metrics["E"], + "D": metrics["D"], + "joint": metrics["joint_pass"], + } + ), + flush=True, + ) + if step == args.steps: + break + model.train() + ei = torch.as_tensor(pair["E"][e_choices[step]], device=device) + ri = torch.as_tensor(pair["replay"][r_choices[step]], device=device) + reference = old_logits[torch.as_tensor(r_choices[step], device=device)].float() + if device.type == "cuda": + torch.cuda.synchronize(device) + start = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with precision(device): + logits_e = model(data_new["tokens"][ei], data_new["positions"][ei]).float() + logits_r = model(data_old["tokens"][ri], data_old["positions"][ri]).float() + ce = F.cross_entropy( + logits_e.reshape(-1, world.vocab_size), data_new["labels"][ei].reshape(-1) + ) + kl = ( + F.kl_div( + F.log_softmax(logits_r, dim=-1), F.softmax(reference, dim=-1), reduction="none" + ) + .sum(-1) + .mean() + ) + loss = ce + args.retention * kl + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(selected, 1.0) + if not torch.isfinite(loss) or not torch.isfinite(norm): + write_json(out / "failure.json", {"step": step, "reason": "nonfinite loss or gradient"}) + raise FloatingPointError("Nonfinite edit") + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + train_seconds += time.perf_counter() - start + passed = [p for p in timeline if p["joint_pass"] is True] + result = { + **case_config, + "status": "complete", + "final": timeline[-1], + "first_observed_joint_step": passed[0]["step"] if passed else None, + "budget_censored": (not bool(passed) if timeline[-1]["joint_pass"] is not None else None), + "joint_evaluable": timeline[-1]["joint_pass"] is not None, + } + write_json(out / "complete.json", result) + if handles: + remove_branch(model, handles) + return result + + +def run(args): + torch.set_num_threads(args.threads) + torch.manual_seed(0) + device = torch.device(args.device) + world = load_world(args.world) + checkpoint = torch.load(args.checkpoint, map_location="cpu", weights_only=True) + model = CausalLM(ModelConfig(**checkpoint["config"])).to(device) + model.load_state_dict(checkpoint["model"]) + data = tensor_data(world, device) + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + write_json( + out / "run.json", {**vars(args), "world_step": checkpoint["step"], **code_fingerprint()} + ) + _, old_arrays = evaluate(model, data, world) + bases = None + if args.branches: + bases, operation_checks = build_bases(model, world, data, layer=args.window + 1) + write_json(out / "branch-operation-checks.json", operation_checks) + args.branch_preparation_seconds = operation_checks.get("construction_seconds", 0.0) + results = [] + for support in args.supports: + pair = paired_edit(world, support=support, k=1) + scopes = getattr(args, "scopes", None) + if scopes is None: + scopes = ["mlp", "all"] + (["down"] if support == 0 else []) + for scope in scopes: + for kind in ("coherent", "exception"): + results.append( + edit_case( + model, + checkpoint["model"], + world, + data, + pair, + kind, + scope, + args, + old_arrays["correct"], + ) + ) + if support == 0 and bases is not None: + for branch_kind, basis in bases.items(): + for kind in ("coherent", "exception"): + results.append( + edit_case( + model, + checkpoint["model"], + world, + data, + pair, + kind, + "mlp", + args, + old_arrays["correct"], + branch_kind, + basis, + ) + ) + write_json(out / "complete.json", {"status": "complete", "cases": results}) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--world", required=True) + parser.add_argument("--checkpoint", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--supports", type=int, nargs="+", default=[0, 1]) + parser.add_argument("--scopes", choices=["mlp", "all", "down"], nargs="+") + parser.add_argument("--steps", type=int, default=512) + parser.add_argument("--window", type=int, default=3) + parser.add_argument("--lr", type=float, default=3e-5) + parser.add_argument("--retention", type=float, default=1.0) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=4) + parser.add_argument("--branches", action="store_true") + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_followup.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_followup.py new file mode 100644 index 0000000000000000000000000000000000000000..c90b76331ad0bbd37276b4a9fe14b865360e7a60 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_followup.py @@ -0,0 +1,381 @@ +"""Small, paired follow-ups using frozen editing and gradient implementations. + +Historical source files are left intact. A process-local, scoped adapter supplies +only a new supervised weight vector to the established P1 training loop. +""" + +import argparse +import fcntl +import itertools +import json +import os +import subprocess +import sys +import time +from contextlib import contextmanager +from pathlib import Path +from types import MethodType + +import numpy as np +import torch + +from . import bios_context_gradient as gradient +from . import bios_mechanism_edit as editing +from .bios_cross import make_cross_world +from .bios_data import write_json +from .bios_model import CausalLM, ModelConfig + +ROOT = Path(__file__).resolve().parents[2] +CONFIG = "configs/bios-followup-v1.json" +ROOT_MASSES = {"root125": 0.125, "root250": 0.25, "root500": 0.5} +ORIGINAL_MAKE_ARM = editing.make_arm +ORIGINAL_SOURCE_HASHES = editing.source_hashes + + +def mixture_spec(world, chain, arm, pair=None): + if "-root" not in arm: + return ORIGINAL_MAKE_ARM(world, chain, arm, pair) + kind, tag = arm.split("-", 1) + if kind not in ("coherent", "exception") or tag not in ROOT_MASSES: + raise ValueError("Unknown mixture arm") + spec = ORIGINAL_MAKE_ARM(world, chain, kind, pair) + mass = ROOT_MASSES[tag] + mask = spec["S_root_mask"] + spec["S_weights"] = np.where( + mask, mass * len(mask) / mask.sum(), (1 - mass) * len(mask) / (~mask).sum() + ) + return spec + + +def production_hashes(): + return {**ORIGINAL_SOURCE_HASHES(), Path(__file__).name: editing.file_hash(__file__)} + + +@contextmanager +def mixture_adapter(): + old_make, old_hash = editing.make_arm, editing.source_hashes + editing.make_arm, editing.source_hashes = mixture_spec, production_hashes + try: + yield + finally: + editing.make_arm, editing.source_hashes = old_make, old_hash + + +def uniform_forward(self, x): + """First-layer uniform causal attention, with the full value/projection path.""" + width = x.shape[-1] + value = self.qkv(x)[..., 2 * width :] + mask = gradient.allowed_mask(x.shape[1], False, x.device).to(x.dtype) + mask = mask / mask.sum(-1, keepdim=True) + return self.proj(mask @ value) + + +@contextmanager +def uniform_first_layer(model): + attention = model.blocks[0].attention + original = attention.forward + attention.forward = MethodType(uniform_forward, attention) + try: + yield + finally: + attention.forward = original + + +def load_config(): + config = json.loads((ROOT / CONFIG).read_text()) + if config["root_mass"] != {"uniform": 1 / 31, **ROOT_MASSES}: + raise ValueError("The declared mixture weights differ from the implementation") + return config + + +def frozen_paths(config): + paths = [ + ROOT / CONFIG, + Path(__file__), + ROOT / "scripts/run_bios_followup.py", + ROOT / "tests/test_bios_followup.py", + ROOT / "src/llm_memory_editability/bios_context_gradient.py", + ROOT / "src/llm_memory_editability/bios_mechanism_edit.py", + ROOT / "scripts/run_bios_mechanism_edit.py", + ROOT / config["gradient_config"], + ROOT / "docs/development-artifacts/context-gradient-v1/preregistration-lock.json", + ] + paths += [ROOT / "src/llm_memory_editability" / name for name in editing.parent_source_hashes()] + for world, seed, condition in itertools.product( + config["worlds"], config["seeds"], config["conditions"] + ): + name = f"world-{world}-seed-{seed}-{condition}" + paths += [ROOT / config["parent_root"] / name / "config.json"] + paths += [ROOT / config["balanced_root"] / name / "contract.json"] + return sorted(set(paths)) + + +def freeze(config): + artifacts = ROOT / config["artifacts"] + artifacts.mkdir(parents=True, exist_ok=True) + lock = artifacts / "preregistration-lock.json" + if lock.exists(): + raise FileExistsError("Existing prospective lock cannot be replaced") + protocol = (ROOT / "docs/experimental-protocol.md").read_text().split("## 17. ", 1)[1] + (artifacts / "preregistration.md").write_text("## 17. " + protocol) + sources = {} + for path in frozen_paths(config): + relative = path.relative_to(ROOT) + sources[str(relative)] = editing.file_hash(path) + if relative.parts[0] not in ("results", "data"): + destination = artifacts / "frozen-files" / relative + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_bytes(path.read_bytes()) + write_json( + lock, + { + "created_at": gradient.stamp(), + "config": config, + "sources": sources, + "protocol_sha256": editing.file_hash(artifacts / "preregistration.md"), + "torch": torch.__version__, + "numpy": np.__version__, + }, + ) + return {"lock": str(lock), "sha256": editing.file_hash(lock)} + + +def verify_lock(config): + artifacts = ROOT / config["artifacts"] + path = artifacts / "preregistration-lock.json" + lock = json.loads(path.read_text()) + if lock["config"] != config or lock["torch"] != torch.__version__: + raise ValueError("Frozen configuration/runtime mismatch") + for source, digest in lock["sources"].items(): + if editing.file_hash(ROOT / source) != digest: + raise ValueError("Frozen source mismatch: " + source) + if editing.file_hash(artifacts / "preregistration.md") != lock["protocol_sha256"]: + raise ValueError("Frozen protocol mismatch") + return editing.file_hash(path) + + +def run_edit(config, world, seed, condition, device): + verify_lock(config) + if (world, seed, condition) not in itertools.product( + config["worlds"], config["seeds"], config["conditions"] + ): + raise ValueError("Edit worker is outside the frozen matrix") + name = f"world-{world}-seed-{seed}-{condition}" + destination = ROOT / config["output"] / "editing" / name + destination.mkdir(parents=True, exist_ok=True) + with (destination / ".lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + with mixture_adapter(): + editing.run_model( + ROOT / config["parent_root"] / name, destination, config["edit"], device + ) + + +def verify_receipt(path): + receipt = json.loads((path / "receipt.json").read_text()) + for name, digest in receipt["files"].items(): + if editing.file_hash(path / name) != digest: + raise ValueError("Gradient receipt mismatch: " + str(path / name)) + + +def run_gradient(config, world_seed, seed, device): + lock_hash = verify_lock(config) + if world_seed not in config["worlds"] or seed not in config["seeds"]: + raise ValueError("Gradient worker is outside the frozen matrix") + original = json.loads((ROOT / config["gradient_config"]).read_text()) + gradient.verify_lock(ROOT, original) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + world = make_cross_world(world_seed, ROOT / original["source_world_root"]) + name = f"world-{world_seed}-seed-{seed}" + source = ROOT / config["gradient_parent"] / name + destination = ROOT / config["output"] / "gradient" / name + destination.mkdir(parents=True, exist_ok=True) + seal = json.loads((source / "complete.json").read_text()) + consumed = {"complete.json": editing.file_hash(source / "complete.json")} + with (destination / ".lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + if (destination / "complete.json").exists(): + raise FileExistsError("Completed gradient worker cannot be overwritten") + for step in config["gradient"]["states"]: + checkpoint = source / f"state-{step}.pt" + digest = editing.file_hash(checkpoint) + if digest != seal["files"][checkpoint.name]: + raise ValueError("Archived common state hash mismatch") + consumed[checkpoint.name] = digest + saved = torch.load(checkpoint, map_location="cpu", weights_only=False) + if saved["step"] != step: + raise ValueError("Common state step mismatch") + model = CausalLM(ModelConfig(**saved["config"])).to(device) + model.load_state_dict(saved["model"]) + sham = config["gradient"]["sham"] + if (world_seed, seed, step) == (sham["world"], sham["seed"], sham["step"]): + path = destination / "sham" + if not (path / "receipt.json").exists(): + gradient.measure_arm( + model, world, sham["condition"], False, original, device, path + ) + verify_receipt(path) + before = source / f"step-{step}-open-{sham['condition']}" + verify_receipt(before) + errors = {} + for kind in ("answer", "eos"): + with np.load(before / f"{kind}.npz") as a, np.load(path / f"{kind}.npz") as b: + for parameter in a.files: + reference = np.linalg.norm(a[parameter].astype(np.float64)) + difference = np.linalg.norm( + b[parameter].astype(np.float64) - a[parameter] + ) + error = ( + float(difference / reference) if reference else float(difference) + ) + errors[f"{kind}/{parameter}"] = error + if max(errors.values()) > config["gradient"]["sham_relative_tolerance"]: + raise ValueError("Historical-gradient sham failed") + write_json(destination / "sham-check.json", errors) + for condition in config["conditions"]: + path = destination / f"step-{step}-uniform-{condition}" + if not (path / "receipt.json").exists(): + with uniform_first_layer(model): + gradient.measure_arm(model, world, condition, False, original, device, path) + verify_receipt(path) + print(json.dumps({"event": "gradient_arm_complete", "path": str(path)}), flush=True) + del model, saved + verify_lock(config) + write_json( + destination / "complete.json", + { + "complete": True, + "created_at": gradient.stamp(), + "lock_sha256": lock_hash, + "parent": str(source), + "consumed": consumed, + "world": world_seed, + "seed": seed, + "device": str(device), + "gpu": torch.cuda.get_device_name(device), + "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES"), + "new_uniform_arms": 9, + "files": { + str(p.relative_to(destination)): editing.file_hash(p) + for p in sorted(destination.rglob("*")) + if p.is_file() and p.suffix in ("npz", ".npz", ".json") + }, + }, + ) + + +def jobs(config): + result = [] + for world, seed in itertools.product(config["worlds"], config["seeds"]): + name = f"world-{world}-seed-{seed}" + result.append(("gradient/" + name, ["run-gradient", "--world", world, "--seed", seed])) + for condition in config["conditions"]: + result.append( + ( + "editing/" + name + "-" + condition, + ["run-edit", "--world", world, "--seed", seed, "--condition", condition], + ) + ) + return result + + +def dispatch(config, gpus, slots): + if not gpus or len(set(gpus)) != len(gpus) or slots < 1 or 0 in gpus: + raise ValueError( + "Unique healthy GPUs and positive concurrency required; GPU0 has ECC errors" + ) + lock_hash = verify_lock(config) + destination = ROOT / config["output"] + destination.mkdir(parents=True, exist_ok=True) + with (destination / ".dispatcher.lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + pending, complete, failed, active = [], [], [], [] + for name, arguments in jobs(config): + if (destination / name / "complete.json").exists(): + complete.append(name) + else: + pending.append((name, arguments)) + while pending or active: + for item in active[:]: + code = item["process"].poll() + if code is None: + continue + item["log"].close() + good = code == 0 and (destination / item["name"] / "complete.json").exists() + (complete if good else failed).append(item["name"]) + active.remove(item) + if not failed: + for gpu in gpus: + while pending and sum(i["gpu"] == gpu for i in active) < slots: + name, arguments = pending.pop(0) + out = destination / name + out.mkdir(parents=True, exist_ok=True) + command = [sys.executable, "-m", "llm_memory_editability.bios_followup"] + command += [str(a) for a in arguments] + log = (out / "run.log").open("a") + env = { + **os.environ, + "PYTHONPATH": str(ROOT / "src"), + "CUDA_VISIBLE_DEVICES": str(gpu), + "OMP_NUM_THREADS": "2", + "OPENBLAS_NUM_THREADS": "2", + } + process = subprocess.Popen( + command, cwd=ROOT, env=env, stdout=log, stderr=log + ) + write_json( + out / "launch.json", + { + "pid": process.pid, + "gpu": gpu, + "command": command, + "started": gradient.stamp(), + }, + ) + active.append({"name": name, "gpu": gpu, "process": process, "log": log}) + write_json( + destination / "status.json", + { + "state": "failed" if failed else "running" if active or pending else "complete", + "lock_sha256": lock_hash, + "complete": complete, + "failed": failed, + "pending": len(pending), + "active": [ + {"name": i["name"], "gpu": i["gpu"], "pid": i["process"].pid} + for i in active + ], + "updated": gradient.stamp(), + }, + ) + if failed and not active: + raise RuntimeError("Worker failure; unstarted jobs retained") + if pending or active: + time.sleep(5) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("mode", choices=("freeze", "dispatch", "run-edit", "run-gradient")) + parser.add_argument("--world", type=int) + parser.add_argument("--seed", type=int) + parser.add_argument("--condition") + parser.add_argument("--gpus", type=int, nargs="+") + parser.add_argument("--slots-per-gpu", type=int, default=1) + parser.add_argument("--device", default="cuda:0") + args = parser.parse_args() + torch.set_num_threads(2) + config = load_config() + if args.mode == "freeze": + print(json.dumps(freeze(config))) + elif args.mode == "dispatch": + dispatch(config, args.gpus, args.slots_per_gpu) + elif args.mode == "run-edit": + run_edit(config, args.world, args.seed, args.condition, torch.device(args.device)) + else: + run_gradient(config, args.world, args.seed, torch.device(args.device)) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_measure.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_measure.py new file mode 100644 index 0000000000000000000000000000000000000000..5bf7c45f10b2be179635d21d0f3a7fde2ee6ca6c --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_measure.py @@ -0,0 +1,286 @@ +"""Pre-edit activation geometry and controlled mean-component interventions. + +Company means are candidate shared components, not assumed learned mechanisms. +All donors, recipients and controls depend only on the old world and fixed seeds. +""" + +import argparse +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_data import EOS, load_world, rng_for, write_json +from .bios_model import CausalLM, ModelConfig +from .bios_train import code_fingerprint, precision, tensor_data + + +@torch.no_grad() +def activation_summary(model, world, data): + device = data["tokens"].device + collected = [[] for _ in model.blocks] + detailed = {} + first_batch = [True] + handles = [] + # Actual-city atomic queries have final prompt position 3. + for layer, block in enumerate(model.blocks): + + def capture(_module, _inputs, output, layer=layer): + collected[layer].append(output[:, 3].float().cpu()) + if first_batch[0]: + detailed[f"z_positions_layer_{layer}"] = ( + output[:128, [1, 2, 3]].float().cpu().numpy() + ) + + handles.append(block.mlp.activation.register_forward_hook(capture)) + + def capture_mlp(_module, inputs, output, layer=layer): + if first_batch[0]: + detailed[f"x_positions_layer_{layer}"] = ( + inputs[0][:128, [1, 2, 3]].float().cpu().numpy() + ) + detailed[f"h_positions_layer_{layer}"] = ( + output[:128, [1, 2, 3]].float().cpu().numpy() + ) + + handles.append(block.mlp.register_forward_hook(capture_mlp)) + with precision(device): + for begin in range(2112, 4160, 256): + model( + data["prompts"][begin : begin + 256], data["lengths"][begin : begin + 256, None] - 1 + ) + first_batch[0] = False + for handle in handles: + handle.remove() + activations = [torch.cat(parts) for parts in collected] + summaries, means = [], [] + for layer, z in enumerate(activations): + mu = torch.stack([z[world.employers == c].mean(0) for c in range(64)]) + centered = mu - z.mean(0) + residual = z - mu[world.employers] + shared_variance = centered.square().mean().item() + individual_variance = residual.square().mean().item() + cosine = F.cosine_similarity(z, mu[world.employers], dim=-1) + summaries.append( + { + "layer": layer, + "mean_norm": z.norm(dim=-1).mean().item(), + "company_mean_variance": shared_variance, + "within_company_variance": individual_variance, + "shared_variance_fraction": shared_variance + / (shared_variance + individual_variance + 1e-20), + "member_to_company_cosine": cosine.mean().item(), + } + ) + means.append(mu) + detailed["query_ids"] = np.arange(2112, 2240) + detailed["token_positions"] = np.array([1, 2, 3]) + return summaries, means, activations, detailed + + +def probe_plan(world): + rng = rng_for(world.seed, 51) + recipients = rng.permutation(64)[:8] + result = [] + for c in recipients: + same = np.flatnonzero((world.defaults == world.defaults[c]) & (np.arange(64) != c))[0] + donor = rng.choice(np.flatnonzero(world.defaults != world.defaults[c])) + wrong = rng.choice( + np.flatnonzero(~np.isin(world.defaults, [world.defaults[c], world.defaults[donor]])) + ) + unrelated = rng.choice(np.flatnonzero(~np.isin(np.arange(64), [c, donor, same, wrong]))) + members = np.flatnonzero(world.employers == c) + other = np.flatnonzero(world.employers == unrelated) + ids = np.concatenate([2112 + members, 6208 + members, 2112 + other]) + # 6208 is the first birth-city row: employer 2048 + defaults 64 + actual/date 4096. + group = np.concatenate( + [np.where(world.exceptions[members], 1, 0), np.full(32, 2), np.full(32, 3)] + ) + result.append( + { + "recipient": int(c), + "donor": int(donor), + "same_answer": int(same), + "wrong_donor": int(wrong), + "unrelated": int(unrelated), + "ids": ids, + "group": group, + } + ) + return result + + +@torch.no_grad() +def causal_probes(model, world, data, means, behavior=False): + device = data["tokens"].device + results = [] + for plan_index, plan in enumerate(probe_plan(world)): + ids = torch.as_tensor(plan["ids"], device=device) + tokens = data["prompts"][ids] + positions = data["lengths"][ids, None] - 1 + donor_answer = int(world.city_tokens[world.defaults[plan["donor"]]]) + + def observe( + tokens=tokens, positions=positions, donor_answer=donor_answer, ids=ids, plan=plan + ): + with precision(device): + logits = model(tokens, positions)[:, 0].float() + probability = logits.softmax(-1)[:, donor_answer] + if not behavior: + return probability, None + first = logits.argmax(-1) + continuation = torch.zeros((len(ids), 6), dtype=torch.long, device=device) + continuation[:, :5] = tokens + rows = torch.arange(len(ids), device=device) + lengths = data["lengths"][ids] + continuation[rows, lengths] = first + ended = model(continuation, lengths[:, None])[:, 0].argmax(-1).eq(EOS) + truth = torch.as_tensor(world.answers[plan["ids"]], device=device) + return probability, { + "old_correct": (first.eq(truth) & ended).cpu().numpy(), + "donor_generated": (first.eq(donor_answer) & ended).cpu().numpy(), + "ended": ended.cpu().numpy(), + } + + baseline, baseline_behavior = observe() + for layer, mu_cpu in enumerate(means): + mu = mu_cpu.to(device) + c = plan["recipient"] + desired = mu[plan["donor"]] - mu[c] + generator = torch.Generator(device=device).manual_seed( + world.seed * 10000 + 100 * plan_index + layer + ) + random = torch.randn(desired.shape, generator=generator, device=device) + random = random * (desired.norm() / random.norm().clamp_min(1e-20)) + shifts = { + "donor": desired, + "same_answer_donor": mu[plan["same_answer"]] - mu[c], + "wrong_donor": mu[plan["wrong_donor"]] - mu[c], + "random_equal_norm": random, + "ablation": -(mu[c] - mu.mean(0)), + } + for kind, shift in shifts.items(): + + def patch(_module, _inputs, output, shift=shift): + edited = output.clone() + edited[:, 3] = edited[:, 3] + shift.to(output.dtype) + return edited + + handle = model.blocks[layer].mlp.activation.register_forward_hook(patch) + try: + changed, changed_behavior = observe() + finally: + handle.remove() + delta = (changed - baseline).cpu().numpy() + by_group = { + name: float(delta[plan["group"] == group].mean()) + for group, name in enumerate( + ( + "same_company_nonexception", + "old_exception", + "independent_attribute", + "unrelated_company", + ) + ) + } + result = { + "recipient": c, + "donor": plan["donor"], + "layer": layer, + "intervention": kind, + "shift_norm": shift.norm().item(), + **by_group, + "selective_shared_score": by_group["same_company_nonexception"] + - (by_group["independent_attribute"] + by_group["unrelated_company"]) / 2, + } + if behavior: + result["generation"] = {} + for group, name in enumerate(by_group): + mask = plan["group"] == group + known = mask & baseline_behavior["old_correct"] + result["generation"][name] = { + "n": int(mask.sum()), + "baseline_old_accuracy": float( + baseline_behavior["old_correct"][mask].mean() + ), + "changed_old_accuracy": float( + changed_behavior["old_correct"][mask].mean() + ), + "donor_generated_delta": float( + changed_behavior["donor_generated"][mask].mean() + - baseline_behavior["donor_generated"][mask].mean() + ), + "old_known": int(known.sum()), + "old_broken": int((known & ~changed_behavior["old_correct"]).sum()), + "nontermination_rate": float((~changed_behavior["ended"][mask]).mean()), + } + results.append(result) + return results + + +def run(args): + started = time.perf_counter() + torch.set_num_threads(4) + device = torch.device(args.device) + world = load_world(args.world) + checkpoint = torch.load(args.checkpoint, map_location="cpu", weights_only=True) + model = CausalLM(ModelConfig(**checkpoint["config"])).to(device) + model.load_state_dict(checkpoint["model"]) + model.eval() + data = tensor_data(world, device) + summary, means, activations, detailed = activation_summary(model, world, data) + probes = causal_probes(model, world, data, means, behavior=args.behavior) + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + np.savez_compressed( + out / "actual-city-activations.npz", + **{f"z_{i}": z.numpy() for i, z in enumerate(activations)}, + ) + np.savez_compressed(out / "input-activation-output-position-sample.npz", **detailed) + write_json( + out / "measurements.json", + { + "step": checkpoint["step"], + "device": str(device), + "precision": "BF16 autocast" if device.type == "cuda" else "FP32 CPU diagnostic", + "checkpoint": str(args.checkpoint), + "checkpoint_sha256": hashlib.sha256(Path(args.checkpoint).read_bytes()).hexdigest(), + "measurement_seconds": time.perf_counter() - started, + "torch_version": torch.__version__, + "hardware": torch.cuda.get_device_name(device) if device.type == "cuda" else "CPU", + "behavior": args.behavior, + **code_fingerprint(), + "geometry": summary, + "probes": probes, + "scope": ( + "candidate company-mean components at final query token; " + "exploratory development measurement" + ), + }, + ) + print( + json.dumps( + {"event": "measurement_complete", "step": checkpoint["step"], "probes": len(probes)} + ), + flush=True, + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--world", required=True) + parser.add_argument("--checkpoint", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--device", default="cuda") + parser.add_argument( + "--behavior", action="store_true", help="Also score complete generated answers" + ) + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal.py new file mode 100644 index 0000000000000000000000000000000000000000..8ac824d1ef628725bf1ee9ca778d381516508a80 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal.py @@ -0,0 +1,969 @@ +"""Locked P4 necessity and downstream restoration diagnostics. + +Q is fitted only on actual queries in an archived exception case's S union R, +grouped by the model's own membership predictions. Truth-matched donor queries +are a subsequent diagnostic, never calibration. Restoring a same-query clean +downstream signal tests recovery from an artificial lesion, not edit repair. +""" + +import csv +import json +from pathlib import Path + +import numpy as np +import torch + +from .bios_causal_paths import make_donor_plan +from .bios_cross import CHAINS, edit_pair, make_cross_world +from .bios_data import EOS, array_hash, rng_for, write_json +from .bios_mechanism_interventions import ( + Site, + attach_state_operation, + calibration_plan, + downstream_routing_site, + fit_predicted_group_bases, + match_delta_norm, + projection_component, + query_site_roles, + remove_projection, + restore_projection, + valid_predicted_groups, +) +from .bios_model import CausalLM, ModelConfig +from .bios_organization_train import atomic_numpy_save, state_hash +from .bios_path_diagnostics import file_sha256 +from .bios_train import precision + +SOURCE = Site(0, 2) +DOWNSTREAM = Site(1, 2) +RANK = 32 +FAMILIES = ( + "default", + "actual", + "other_chain_default", + "attribute_3", + "attribute_4", + "attribute_5", + "attribute_6", + "membership", + "other_chain_actual", + "group_root", +) +ARMS = ( + "clean", + "sham", + "target_remove", + "random_remove", + "complement_remove", + "rescue_only", + "remove_rescue", + "remove_wrong_source_rescue", + "remove_random_rescue", +) +TRANSFER_TYPES = ( + "different_group_same_actual_different_default", + "different_group_same_default", + "different_group_same_default_same_actual", +) +TRANSFER_ARMS = ( + "sham", + "full_donor", + "full_norm_random", + "projected_target", + "projected_random", + "projected_complement", +) + + +def _freeze_json(path, value): + if path.exists(): + if json.loads(path.read_text()) != value: + raise ValueError(f"Frozen diagnostic contract changed: {path}") + else: + write_json(path, value) + + +def _same_arrays(path, arrays): + if path.exists(): + with np.load(path) as existing: + if set(existing.files) != set(arrays) or any( + not np.array_equal(existing[key], value) for key, value in arrays.items() + ): + raise ValueError(f"Diagnostic plan changed: {path}") + else: + atomic_numpy_save(path, **arrays) + + +def _sources(): + directory = Path(__file__).parent + names = ( + "bios_mechanism_causal.py", + "bios_mechanism_interventions.py", + "bios_causal_paths.py", + "bios_cross.py", + "bios_data.py", + "bios_model.py", + "bios_train.py", + "bios_organization_train.py", + "bios_path_diagnostics.py", + ) + sources = {name: file_sha256(directory / name) for name in names} + runner = directory.parents[1] / "scripts/analyze_bios_mechanism_causal.py" + sources["runner"] = file_sha256(runner) + return sources + + +def validate_lock(lock): + if (lock.get("mechanism"), lock.get("layer"), lock.get("position")) != ("default_path", 0, 2): + raise ValueError("This runner only instantiates the locked default_path L0/pos2 candidate") + if lock.get("known_only") is not False or not lock.get("locked_at_utc"): + raise ValueError("An all-eligible, timestamped candidate lock is required") + + +def make_probe_plan(world, chain, recipients): + """Same people and fixed queries in every intervention, without knowledge filtering.""" + recipients = np.asarray(recipients, dtype=np.int64) + ids = [ + world.derived_ids[chain, recipients], + world.actual_ids[chain, recipients], + world.derived_ids[1 - chain, recipients], + ] + for relation in (3, 4, 5, 6): + candidates = np.flatnonzero(world.relation == relation) + by_person = np.full(len(world.actual_ids[chain]), -1, dtype=np.int64) + by_person[world.person[candidates]] = candidates + if (by_person[recipients] < 0).any(): + raise ValueError("An independent control query is missing") + ids.append(by_person[recipients]) + ids.extend([world.membership_ids[chain, recipients], world.actual_ids[1 - chain, recipients]]) + person_families = len(ids) + roots = world.root_ids[chain] + query_ids = np.concatenate([*ids, roots]) + return { + "query_id": query_ids, + "person": np.r_[np.tile(recipients, person_families), np.full(len(roots), -1)], + "family": np.r_[ + np.repeat(np.arange(person_families), len(recipients)), + np.full(len(roots), person_families), + ], + # -1 means not applicable; root facts are not ordinary people. + "recipient_old_exception": np.r_[ + np.tile(world.exceptions[chain, recipients].astype(np.int8), person_families), + np.full(len(roots), -1, dtype=np.int8), + ], + "answer": world.answers[query_ids], + } + + +def wrong_source_indices(families): + """Fixed one-person cyclic shift within each family, never chosen by answers.""" + families = np.asarray(families) + index = np.arange(len(families)) + for family in np.unique(families): + selected = np.flatnonzero(families == family) + if len(selected) < 2: + raise ValueError("Wrong-source controls require at least two queries per family") + index[selected] = np.roll(selected, 1) + return index + + +def make_transfer_plan(world, chain, per_population=64): + """Truth matching is restricted to this explicitly labeled offline diagnostic.""" + old = make_donor_plan(world, chain, per_population) + original = old["pair_type"] == 1 + recipients = old["recipient"][original] + train = world.person[world.train_ids[chain]] + group = world.memberships[chain] + default = world.answers[world.root_ids[chain, group]] + actual = world.answers[world.actual_ids[chain]] + rng = rng_for(world.seed, 978, chain) + donor_rows = [old["donor"][original]] + count_rows = [old["candidate_count"][original]] + for same_actual in (False, True): + donors, counts = [], [] + for recipient in recipients: + mask = (group[train] != group[recipient]) & (default[train] == default[recipient]) + if same_actual: + mask &= actual[train] == actual[recipient] + candidates = train[mask] + donors.append(rng.choice(candidates) if len(candidates) else -1) + counts.append(len(candidates)) + donor_rows.append(np.asarray(donors)) + count_rows.append(np.asarray(counts)) + donor = np.concatenate(donor_rows).astype(np.int64) + recipient = np.tile(recipients, len(TRANSFER_TYPES)) + safe = np.maximum(donor, 0) + return { + "case_id": np.arange(len(donor)), + "recipient": recipient, + "donor": donor, + "pair_type": np.repeat(np.arange(len(TRANSFER_TYPES)), len(recipients)), + "candidate_count": np.concatenate(count_rows), + "recipient_old_exception": world.exceptions[chain, recipient], + "same_actual": (actual[safe] == actual[recipient]) & (donor >= 0), + "same_default": (default[safe] == default[recipient]) & (donor >= 0), + "recipient_default": default[recipient], + "recipient_actual": actual[recipient], + "donor_default": np.where(donor >= 0, default[safe], -1), + "donor_actual": np.where(donor >= 0, actual[safe], -1), + } + + +def generate_queries( + model, prompts, lengths, device, batch_size=256, *, operations=None, capture_sites=() +): + """Two free generation passes with identical pre-answer operations, no answer input. + + operations(begin,end) returns (label, site, operation) triples. Every operation + returns its intended delta and availability; realized post-cast norms are + measured separately. Both passes are retained so norm matching is auditable. + """ + if len(prompts) == 0 or batch_size < 1: + raise ValueError("Generation needs nonempty queries and a positive batch size") + lengths = np.asarray(lengths) + if prompts.shape != (len(lengths), 5) or not np.isin(lengths, [4, 5]).all(): + raise ValueError("Unexpected symbolic query shape") + arrays = {"prediction": [], "ended": []} + for site in capture_sites: + query_site_roles(lengths, site.position) + arrays[f"state_{site.layer}_{site.position}"] = [] + calls = 0 + model.eval() + with torch.no_grad(): + for begin in range(0, len(prompts), batch_size): + end = min(begin + batch_size, len(prompts)) + p = torch.as_tensor(prompts[begin:end], device=device) + n = torch.as_tensor(lengths[begin:end], device=device) + hooks, traces, captures = [], {}, {} + try: + for label, site, operation in () if operations is None else operations(begin, end): + query_site_roles(lengths[begin:end], site.position) + + def measured(value, operation=operation): + changed, trace = operation(value) + return changed, {**trace, "realized_delta": changed.float() - value.float()} + + hook, trace = attach_state_operation(model, site, measured) + hooks.append(hook) + traces[label] = trace + for site in capture_sites: + key = f"state_{site.layer}_{site.position}" + captures[key] = [] + + def capture( + _module, _inputs, output, key=key, position=site.position, captures=captures + ): + captures[key].append(output[:, position].detach().float()) + + hooks.append(model.blocks[site.layer].register_forward_hook(capture)) + with precision(device): + first = model(p, (n - 1)[:, None])[:, 0].float().argmax(-1) + continuation = torch.zeros((len(p), 6), dtype=torch.long, device=device) + continuation[:, :5] = p + continuation[torch.arange(len(p), device=device), n] = first + second = model(continuation, n[:, None])[:, 0].argmax(-1) + calls += 2 + arrays["prediction"].append(first.cpu().numpy()) + arrays["ended"].append(second.eq(EOS).cpu().numpy()) + for key, states in captures.items(): + arrays[key].append(states[0].cpu().numpy()) + drift = torch.linalg.vector_norm(states[1] - states[0], dim=-1) + arrays.setdefault(f"{key}_pass_drift", []).append(drift.cpu().numpy()) + for label, trace in traces.items(): + if len(trace) != 2: + raise ValueError( + "Every intervention must occur in both free-generation passes" + ) + for kind in ("delta", "realized_delta"): + norms = torch.stack( + [torch.linalg.vector_norm(t[kind].float(), dim=-1) for t in trace], + dim=1, + ) + arrays.setdefault(f"{label}_{kind}_norm", []).append(norms.cpu().numpy()) + valid = torch.stack([t["valid"] for t in trace], dim=1) + arrays.setdefault(f"{label}_valid", []).append(valid.cpu().numpy()) + finally: + for hook in hooks: + hook.remove() + result = {key: np.concatenate(value) for key, value in arrays.items()} + result.update( + forward_calls=np.asarray(calls), + forward_examples=np.asarray(2 * len(prompts)), + padded_token_positions=np.asarray(11 * len(prompts)), + logical_token_positions=np.asarray(int((2 * lengths + 1).sum())), + ) + return result + + +def _identity_trace(value): + return value, { + "delta": torch.zeros_like(value, dtype=torch.float32), + "valid": torch.ones(len(value), dtype=torch.bool, device=value.device), + } + + +def lesion_operations( + arm, source_bases, downstream_bases, clean_downstream, wrong_index, seed, device +): + """Return a deterministic batch factory. Wrong-source choice never sees truth.""" + if arm not in ARMS: + raise ValueError("Unknown necessity/restoration arm") + if arm == "clean": + return lambda _begin, _end: [] + if arm == "sham": + return lambda _begin, _end: [("source", SOURCE, _identity_trace)] + source = {key: basis.tensors(device) for key, basis in source_bases.items()} + downstream = ( + None + if downstream_bases is None + else {key: basis.tensors(device) for key, basis in downstream_bases.items()} + ) + needs_downstream = "rescue" in arm + if needs_downstream and downstream is None: + raise ValueError("Downstream basis is unavailable; recovery cannot be estimated") + wrong_index = np.asarray(wrong_index) + if len(wrong_index) != len(clean_downstream): + raise ValueError("Wrong-source plan length mismatch") + coefficients = ( + np.random.default_rng(seed) + .standard_normal((len(clean_downstream), source_bases["random"].rank)) + .astype(np.float32) + ) + + def factory(begin, end): + ops = [] + if arm == "clean": + return ops + if arm == "sham": + return [("source", SOURCE, _identity_trace)] + if arm != "rescue_only": + kind = ( + arm.removesuffix("_remove") + if arm in ("random_remove", "complement_remove") + else "target" + ) + q, mean, _ = source[kind] + tq, tm, _ = source["target"] + + def remove(value): + reference = ( + None + if kind == "target" + else torch.linalg.vector_norm(projection_component(value, tq, tm), dim=-1) + ) + return remove_projection(value, q, mean, reference) + + ops.append(("source", SOURCE, remove)) + if needs_downstream: + clean = torch.as_tensor(clean_downstream[begin:end], device=device) + wrong = torch.as_tensor(clean_downstream[wrong_index[begin:end]], device=device) + tq = downstream["target"][0] + rq = downstream["random"][0] + noise = torch.as_tensor(coefficients[begin:end], device=device) @ rq.T + + def recover(value): + _, same_query_trace = restore_projection(value, clean, tq) + correct_delta = same_query_trace["delta"] + reference = torch.linalg.vector_norm(correct_delta, dim=-1) + if arm == "remove_wrong_source_rescue": + return restore_projection(value, wrong, tq, reference) + if arm == "remove_random_rescue": + delta, valid = match_delta_norm(noise, reference) + return value + delta.to(value.dtype), {"delta": delta, "valid": valid} + return restore_projection(value, clean, tq) + + ops.append(("downstream", DOWNSTREAM, recover)) + return ops + + return factory + + +def transfer_operations(arm, bases, recipient, donor, seed, device): + """A locked-basis manipulation check, never a basis-fitting input.""" + if arm not in TRANSFER_ARMS or recipient.shape != donor.shape: + raise ValueError("Invalid donor manipulation") + if arm.startswith("projected_") and bases is None: + raise ValueError("Projected donor diagnostic requires an available source basis") + full_delta = donor.astype(np.float32) - recipient.astype(np.float32) + if arm == "sham": + delta, valid = np.zeros_like(full_delta), np.ones(len(donor), dtype=bool) + elif arm == "full_donor": + delta, valid = full_delta, np.ones(len(donor), dtype=bool) + else: + if arm == "full_norm_random": + raw = np.random.default_rng(seed).standard_normal(full_delta.shape).astype(np.float32) + reference = np.linalg.norm(full_delta, axis=-1) + else: + tq = bases["target"].q + target_delta = (full_delta @ tq) @ tq.T + reference = np.linalg.norm(target_delta, axis=-1) + q = bases[arm.removeprefix("projected_")].q + raw = (full_delta @ q) @ q.T + matched, available = match_delta_norm(torch.from_numpy(raw), torch.from_numpy(reference)) + delta, valid = matched.numpy(), available.numpy() + + def factory(begin, end): + change = torch.as_tensor(delta[begin:end], device=device) + available = torch.as_tensor(valid[begin:end], device=device) + + def operation(value): + return value + change.to(value.dtype), {"delta": change, "valid": available} + + return [("source", SOURCE, operation)] + + return factory + + +def _availability(arrays): + valid = np.ones(len(arrays["prediction"]), dtype=bool) + for key, value in arrays.items(): + if key.endswith("_valid"): + valid &= value.all(axis=1) + return valid + + +def score_rows(arrays, baseline, plan, arm, labels=FAMILIES, label_key="family"): + """All eligible rows first; original-correct strata remain descriptive only.""" + base_correct = (baseline["prediction"] == plan["answer"]) & baseline["ended"] + correct = (arrays["prediction"] == plan["answer"]) & arrays["ended"] + available = _availability(arrays) + rows = [] + for code, family in enumerate(labels): + for population in ("all", "ordinary", "old_exception"): + requested = plan[label_key] == code + if population != "all": + requested &= plan["recipient_old_exception"] == (population == "old_exception") + chosen = requested & available + n, nb = int(chosen.sum()), int((chosen & base_correct).sum()) + before, after = int((chosen & base_correct).sum()), int((chosen & correct).sum()) + row = { + "arm": arm, + "family": family, + "population": population, + "requested": int(requested.sum()), + "available": n, + "unavailable": int((requested & ~available).sum()), + "baseline_correct": before, + "correct": after, + "accuracy": after / n if n else None, + "delta_accuracy": (after - before) / n if n else None, + "known_became_wrong": int((chosen & base_correct & ~correct).sum()), + "wrong_became_correct": int((chosen & ~base_correct & correct).sum()), + "known_denominator": nb, + "known_retention": int((chosen & base_correct & correct).sum()) / nb + if nb + else None, + "termination_error": int((chosen & ~arrays["ended"]).sum()), + "prediction_changed": int( + ( + chosen + & ( + (arrays["prediction"] != baseline["prediction"]) + | (arrays["ended"] != baseline["ended"]) + ) + ).sum() + ), + } + for label in ("source", "downstream"): + for kind in ("delta", "realized_delta"): + key = f"{label}_{kind}_norm" + row[f"mean_{key}"] = ( + float(arrays[key][chosen, 0].mean()) if n and key in arrays else None + ) + rows.append(row) + return rows + + +def paired_score_rows( + left, right, baseline, plan, left_name, right_name, labels=FAMILIES, label_key="family" +): + """Contrasts use a common availability mask, never unmatched denominators.""" + correct_left = (left["prediction"] == plan["answer"]) & left["ended"] + correct_right = (right["prediction"] == plan["answer"]) & right["ended"] + correct_clean = (baseline["prediction"] == plan["answer"]) & baseline["ended"] + available_left, available_right = _availability(left), _availability(right) + rows = [] + for code, family in enumerate(labels): + for population in ("all", "ordinary", "old_exception"): + requested = plan[label_key] == code + if population != "all": + requested &= plan["recipient_old_exception"] == (population == "old_exception") + chosen = requested & available_left & available_right + n = int(chosen.sum()) + nl, nr = int((chosen & correct_left).sum()), int((chosen & correct_right).sum()) + known_right_wrong = chosen & correct_clean & ~correct_right + denominator = int(known_right_wrong.sum()) + rows.append( + { + "left": left_name, + "right": right_name, + "family": family, + "population": population, + "requested": int(requested.sum()), + "common_available": n, + "left_unavailable": int((requested & ~available_left).sum()), + "right_unavailable": int((requested & ~available_right).sum()), + "left_correct": nl, + "right_correct": nr, + "accuracy_difference": (nl - nr) / n if n else None, + "right_wrong_left_correct": int((chosen & ~correct_right & correct_left).sum()), + "right_correct_left_wrong": int((chosen & correct_right & ~correct_left).sum()), + "original_known_right_wrong": denominator, + "original_known_right_wrong_left_recovered": int( + (known_right_wrong & correct_left).sum() + ), + "conditional_recovery_auxiliary": int((known_right_wrong & correct_left).sum()) + / denominator + if denominator + else None, + } + ) + return rows + + +def _check_predictions(generated, archived, ids): + for key in ("prediction", "ended"): + if not np.array_equal(generated[key], archived[key][ids]): + raise ValueError(f"Clean frozen-model generation differs from archive: {key}") + + +def _cost(arrays): + return { + key: int(arrays[key]) + for key in ( + "forward_calls", + "forward_examples", + "padded_token_positions", + "logical_token_positions", + ) + } + + +def _cached_generate(path, model, world, ids, device, batch_size, **kwargs): + if path.exists(): + with np.load(path) as stored: + result = dict(stored) + if not np.array_equal(result.pop("query_id"), ids): + raise ValueError("Cached generation query plan differs") + return result + result = generate_queries( + model, world.prompts[ids], world.lengths[ids], device, batch_size, **kwargs + ) + atomic_numpy_save(path, query_id=ids, **result) + return result + + +def _fit_chain(model, world, chain, pair, dest, device, batch_size, archived): + plan = calibration_plan( + world.actual_ids[chain], + world.person, + world.membership_ids[chain], + pair["E"], + pair["replay"], + ) + _same_arrays( + dest / "calibration-plan.npz", {key: np.asarray(value) for key, value in plan.items()} + ) + actual = _cached_generate( + dest / "calibration-actual.npz", + model, + world, + plan["actual_query_ids"], + device, + batch_size, + capture_sites=(SOURCE, DOWNSTREAM), + ) + membership = _cached_generate( + dest / "calibration-membership.npz", + model, + world, + plan["membership_query_ids"], + device, + batch_size, + ) + _check_predictions(actual, archived, plan["actual_query_ids"]) + _check_predictions(membership, archived, plan["membership_query_ids"]) + prefix = f"{CHAINS[chain]}:" + allowed = np.array( + [i for i, label in enumerate(world.token_labels) if label.startswith(prefix)] + ) + groups, valid = valid_predicted_groups(membership["prediction"], membership["ended"], allowed) + _same_arrays(dest / "self-predicted-groups.npz", {"prediction": groups, "valid": valid}) + bases, reports, basis_arrays = {}, {}, {} + for label, site in (("source", SOURCE), ("downstream", DOWNSTREAM)): + basis, report = fit_predicted_group_bases( + actual[f"state_{site.layer}_{site.position}"], groups, valid, rank=RANK, seed=74 + chain + ) + bases[label], reports[label] = basis, report + if basis is not None: + for kind, value in basis.items(): + for field in ("q", "mean", "scale"): + basis_arrays[f"{label}_{kind}_{field}"] = getattr(value, field) + _same_arrays(dest / "bases.npz", basis_arrays) + information = { + "S_count": len(pair["E"]), + "R_count": len(pair["replay"]), + "actual_queries": len(plan["actual_query_ids"]), + "additional_membership_queries": len(plan["membership_query_ids"]), + "derived_calibration_queries": 0, + "true_memberships_supplied": False, + "membership_syntax_rule": prefix, + "invalid_groups_never_replaced": True, + "calibration_cost": {"actual": _cost(actual), "membership": _cost(membership)}, + "basis_reports": reports, + "variant": "group_means", + "basis_sha256": file_sha256(dest / "bases.npz"), + } + _freeze_json(dest / "calibration.json", information) + # Truth is read only after Q and its information contract are frozen. These + # labels score calibration quality; they never select rows or alter Q. + membership_correct = ( + membership["prediction"] == world.answers[plan["membership_query_ids"]] + ) & membership["ended"] + _freeze_json( + dest / "calibration-diagnostics.json", + { + "role": "offline scoring after frozen Q; never fitting or row selection", + "queries": len(groups), + "valid_predictions": int(valid.sum()), + "valid_rate": float(valid.mean()), + "correct_predictions": int(membership_correct.sum()), + "accuracy": float(membership_correct.mean()), + "accuracy_given_valid_auxiliary": float(membership_correct[valid].mean()) + if valid.any() + else None, + "basis_sha256": information["basis_sha256"], + }, + ) + return bases + + +def run_chain(model, world, chain, pair, dest, device, batch_size, per_population, archived): + dest.mkdir(parents=True, exist_ok=True) + bases = _fit_chain(model, world, chain, pair, dest, device, batch_size, archived) + transfer = make_transfer_plan(world, chain, per_population) + _same_arrays(dest / "transfer-plan.npz", transfer) + recipients = transfer["recipient"][transfer["pair_type"] == 0] + plan = make_probe_plan(world, chain, recipients) + plan["wrong_source_index"] = wrong_source_indices(plan["family"]) + plan["wrong_source_query_id"] = plan["query_id"][plan["wrong_source_index"]] + plan["wrong_source_same_answer"] = plan["answer"] == plan["answer"][plan["wrong_source_index"]] + _same_arrays(dest / "probe-plan.npz", plan) + ids = plan["query_id"] + query_site_roles(world.lengths[ids], SOURCE.position) + if downstream_routing_site(SOURCE, len(model.blocks), world.lengths[ids] - 1) != DOWNSTREAM: + raise ValueError("Candidate/downstream site mismatch") + clean = _cached_generate( + dest / "clean.npz", + model, + world, + ids, + device, + batch_size, + capture_sites=(SOURCE, DOWNSTREAM), + ) + _check_predictions(clean, archived, ids) + rows, states, costs, arm_arrays = [], {}, {"clean": _cost(clean)}, {} + clean_down = clean[f"state_{DOWNSTREAM.layer}_{DOWNSTREAM.position}"] + for arm in ARMS: + if arm not in ("clean", "sham") and bases["source"] is None: + states[arm] = "unavailable_source_rank" + continue + if "rescue" in arm and bases["downstream"] is None: + states[arm] = "unavailable_downstream_rank" + continue + if arm == "clean": + generated = clean + else: + operations = lesion_operations( + arm, + bases["source"], + bases["downstream"], + clean_down, + plan["wrong_source_index"], + [world.seed, 979, chain], + device, + ) + generated = _cached_generate( + dest / f"{arm}.npz", model, world, ids, device, batch_size, operations=operations + ) + if arm in ("sham", "rescue_only"): + for key in ("prediction", "ended"): + if not np.array_equal(generated[key], clean[key]): + raise ValueError(f"No-lesion control changed output: {arm}/{key}") + rows.extend(score_rows(generated, clean, plan, arm)) + costs[arm], states[arm] = _cost(generated), "complete" + arm_arrays[arm] = generated + comparisons = [ + (arm, "clean") + for arm in ("sham", "target_remove", "random_remove", "complement_remove", "rescue_only") + ] + comparisons += [("target_remove", arm) for arm in ("random_remove", "complement_remove")] + comparisons += [ + (arm, "target_remove") + for arm in ("remove_rescue", "remove_wrong_source_rescue", "remove_random_rescue") + ] + comparisons += [ + ("remove_rescue", arm) for arm in ("remove_wrong_source_rescue", "remove_random_rescue") + ] + paired_rows = [] + for left, right in comparisons: + if left in arm_arrays and right in arm_arrays: + paired_rows.extend( + paired_score_rows(arm_arrays[left], arm_arrays[right], clean, plan, left, right) + ) + # Donor activations are read only after both bases and their provenance are frozen. + valid = transfer["donor"] >= 0 + selected = {key: value[valid] for key, value in transfer.items()} + people = np.unique(np.r_[selected["recipient"], selected["donor"]]) + donor_ids = world.derived_ids[chain, people] + donor_clean = _cached_generate( + dest / "transfer-clean.npz", + model, + world, + donor_ids, + device, + batch_size, + capture_sites=(SOURCE,), + ) + _check_predictions(donor_clean, archived, donor_ids) + ri, di = ( + np.searchsorted(people, selected["recipient"]), + np.searchsorted(people, selected["donor"]), + ) + source_state = donor_clean[f"state_{SOURCE.layer}_{SOURCE.position}"] + donor_baseline = {key: donor_clean[key][ri] for key in ("prediction", "ended")} + donor_plan = {**selected, "answer": selected["recipient_default"]} + transfer_rows, transfer_status = [], {} + costs["transfer_clean"] = _cost(donor_clean) + for arm in TRANSFER_ARMS: + if arm.startswith("projected_") and bases["source"] is None: + transfer_status[arm] = "unavailable_source_rank" + continue + ops = transfer_operations( + arm, + bases["source"], + source_state[ri], + source_state[di], + [world.seed, 980, chain], + device, + ) + generated = _cached_generate( + dest / f"transfer-{arm}.npz", + model, + world, + world.derived_ids[chain, selected["recipient"]], + device, + batch_size, + operations=ops, + ) + if arm == "sham": + for key in ("prediction", "ended"): + if not np.array_equal(generated[key], donor_baseline[key]): + raise ValueError("Transfer sham changed output") + scored = score_rows( + generated, donor_baseline, donor_plan, arm, labels=TRANSFER_TYPES, label_key="pair_type" + ) + for row in scored: + code = TRANSFER_TYPES.index(row["family"]) + chosen = (selected["pair_type"] == code) & _availability(generated) + requested = transfer["pair_type"] == code + if row["population"] != "all": + exception = row["population"] == "old_exception" + chosen &= selected["recipient_old_exception"] == exception + requested &= transfer["recipient_old_exception"] == exception + row["plan_requested"] = int(requested.sum()) + row["missing_donors"] = int((requested & ~valid).sum()) + for role in ("recipient_actual", "donor_default", "donor_actual"): + matched = (generated["prediction"] == selected[role]) & generated["ended"] + base_matched = (donor_baseline["prediction"] == selected[role]) & donor_baseline[ + "ended" + ] + row[f"matches_{role}"] = int((chosen & matched).sum()) + row[f"baseline_matches_{role}"] = int((chosen & base_matched).sum()) + # Donor's own clean response is descriptive, not an eligibility filter. + row["donor_answered_default"] = int( + ( + chosen + & donor_clean["ended"][di] + & (donor_clean["prediction"][di] == selected["donor_default"]) + ).sum() + ) + transfer_rows.extend(scored) + transfer_status[arm], costs[f"transfer_{arm}"] = "complete", _cost(generated) + for filename, contents in ( + ("necessity.csv", rows), + ("paired-necessity.csv", paired_rows), + ("transfer.csv", transfer_rows), + ): + with (dest / filename).open("w") as stream: + writer = csv.DictWriter(stream, fieldnames=list(contents[0])) + writer.writeheader() + writer.writerows(contents) + write_json( + dest / "status.json", + { + "arms": states, + "transfer_arms": transfer_status, + "evaluation_cost": costs, + "information_boundary": "truth-matched donor states are diagnostic only", + }, + ) + return {"chain": CHAINS[chain], "arms": states, "transfer_arms": transfer_status} + + +def scientific_outputs(output): + """Seal only producer-owned artifacts, excluding mutable queue logs and locks.""" + names = { + "calibration-plan.npz", + "calibration-actual.npz", + "calibration-membership.npz", + "self-predicted-groups.npz", + "bases.npz", + "calibration.json", + "calibration-diagnostics.json", + "transfer-plan.npz", + "probe-plan.npz", + "transfer-clean.npz", + "necessity.csv", + "paired-necessity.csv", + "transfer.csv", + "status.json", + } + names.update(f"{arm}.npz" for arm in ARMS) + names.update(f"transfer-{arm}.npz" for arm in TRANSFER_ARMS) + paths = [output / "contract.json"] + for chain in CHAINS: + paths.extend( + output / chain / name for name in sorted(names) if (output / chain / name).exists() + ) + return {str(path.relative_to(output)): file_sha256(path) for path in paths} + + +def run_model(run, output, lock_path, *, device="cuda", batch_size=256, per_population=64): + """One original pre-edit checkpoint, both chains; separate outputs, restartable nodes.""" + run, output, lock_path = Path(run).resolve(), Path(output).resolve(), Path(lock_path).resolve() + if output == run or run in output.parents: + raise ValueError("Never write diagnostics inside the frozen parent") + lock = json.loads(lock_path.read_text()) + validate_lock(lock) + config = json.loads((run / "config.json").read_text()) + if ( + config["world"] not in (0, 1) + or config["model"]["width"] not in (256, 768) + or config["seed"] not in (0, 1) + or config["condition"] not in (*CHAINS, "neither") + ): + raise ValueError("The original 24-model development matrix is required") + step = config["study"]["steps"] + if step != 15360 or per_population != 64: + raise ValueError("The parent step and 64+64 recipient budget are fixed") + for key, current in (("torch", torch.__version__), ("cuda", torch.version.cuda)): + if config[key] != current: + raise ValueError(f"Parent runtime differs: {key}") + device = torch.device(device) + weights = run / f"model-{step}.pt" + contract = { + "run": str(run), + "step": step, + "world": config["world"], + "seed": config["seed"], + "width": config["model"]["width"], + "condition": config["condition"], + "parent_config_sha256": file_sha256(run / "config.json"), + "parent_weights_sha256": file_sha256(weights), + "lock": lock, + "lock_sha256": file_sha256(lock_path), + "sources": _sources(), + "source_site": [0, 2], + "downstream_site": [1, 2], + "rank": RANK, + "per_population": per_population, + "batch_size": batch_size, + "torch": torch.__version__, + "cuda": torch.version.cuda, + "numpy": np.__version__, + "device_type": device.type, + "checkpoint_role": "pre_edit_clean_only", + "calibration": "S_union_R_actual_queries_with_self_predicted_membership_groups", + "families": list(FAMILIES), + "arms": list(ARMS), + "transfer_types": list(TRANSFER_TYPES), + "transfer_arms": list(TRANSFER_ARMS), + "wrong_source_rule": "cyclic_previous_query_within_family_no_truth_or_prediction_selection", + "cross_query_reference": "The actual-calibration mean is reused for all query families", + "recovery_source": "Same checkpoint and same query clean post-L1/pos2 target projection", + "rescue_only_role": "No-lesion downstream sham; cannot establish necessity", + "random_recovery": "Random rank32 downstream basis; same-query recovery delta norm", + "rank_failure": "Unavailable, never padded or replaced; report coverage by organization", + "interpretation": ( + "Artificial-lesion behavior recovery; no claim of edit repair " + "or organizational specificity" + ), + } + output.mkdir(parents=True, exist_ok=True) + _freeze_json(output / "contract.json", contract) + complete_path = output / "complete.json" + if complete_path.exists(): + complete = json.loads(complete_path.read_text()) + for name, digest in complete["outputs"].items(): + if file_sha256(output / name) != digest: + raise ValueError(f"Completed diagnostic artifact changed: {name}") + return complete + repository = Path(__file__).resolve().parents[2] + world = make_cross_world(config["world"], repository / "data/bios-organization-v1") + if ( + array_hash(world.answers) != config["truth_sha256"] + or array_hash(world.prompts) != config["prompts_sha256"] + ): + raise ValueError("Parent generated world changed") + saved = torch.load(weights, map_location="cpu", weights_only=False) + final = json.loads((run / "learning-complete.json").read_text()) + if ( + saved["config"] != config["model"] + or saved["step"] != step + or state_hash(saved["model"]) != final["model_sha256"] + ): + raise ValueError("Parent model identity mismatch") + model = CausalLM(ModelConfig(**saved["config"])) + model.load_state_dict(saved["model"]) + model.to(device).eval() + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + with np.load(run / f"predictions-{step}.npz") as stored: + archived = {key: stored[key] for key in ("prediction", "ended")} + completed = [] + for chain, name in enumerate(CHAINS): + pair = edit_pair(world, chain) + reference = run / "edits" / f"{name}-exception-mlp" + with np.load(reference / "sets.npz") as old: + for key in ("E", "replay", "exception"): + if not np.array_equal(old[key], pair[key]): + raise ValueError( + f"Original exception calibration permission changed: {name}/{key}" + ) + if not (reference / "complete.json").exists(): + raise ValueError("Original exception case is incomplete") + completed.append( + run_chain( + model, + world, + chain, + pair, + output / name, + device, + batch_size, + per_population, + archived, + ) + ) + print( + json.dumps({"event": "necessity_chain_complete", "run": str(run), "chain": name}), + flush=True, + ) + if _sources() != contract["sources"]: + raise ValueError("Diagnostic implementation changed during execution") + outputs = scientific_outputs(output) + complete = {"status": "complete", "chains": completed, "outputs": outputs} + write_json(complete_path, complete) + return complete diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py new file mode 100644 index 0000000000000000000000000000000000000000..322ecd4a965475d9878cbb14cb7a3eee131cf9ca --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py @@ -0,0 +1,1082 @@ +"""P4 v2: unchanged interventions with explicit local numerical baselines. + +Q is fitted only on actual queries in an archived exception case's S union R, +grouped by the model's own membership predictions. Truth-matched donor queries +are a subsequent diagnostic, never calibration. Restoring a same-query clean +downstream signal tests recovery from an artificial lesion, not edit repair. +""" + +import csv +import json +from pathlib import Path + +import numpy as np +import torch + +from .bios_causal_paths import make_donor_plan +from .bios_cross import CHAINS, edit_pair, make_cross_world +from .bios_data import EOS, array_hash, rng_for, write_json +from .bios_mechanism_interventions import ( + Site, + attach_state_operation, + calibration_plan, + downstream_routing_site, + fit_predicted_group_bases, + match_delta_norm, + projection_component, + query_site_roles, + remove_projection, + restore_projection, + valid_predicted_groups, +) +from .bios_model import CausalLM, ModelConfig +from .bios_organization_train import atomic_numpy_save, state_hash +from .bios_path_diagnostics import file_sha256 +from .bios_train import precision + +SOURCE = Site(0, 2) +DOWNSTREAM = Site(1, 2) +RANK = 32 +NUMERICAL_POLICY = { + "version": "p4-numerical-policy-v2", + "original_identity_gate": "20608 queries; original order/batch512; exact archive values/EOS", + "subset_baseline": "Same query/order/batch local clean for every causal contrast", + "archive_subset_difference": "All queries and both outputs retained; no exclusions", + "donor_baseline": "Extra clean replay in duplicated recipient order and intervention batch", + "local_sham_and_rescue_only": "Strict exact value/EOS equality; never relaxed", + "restore_reference": "Unchanged v1 first-pass pre-answer source; pass drift remains recorded", + "scientific_design": "Candidate, rank, calibration, intervention, pairing, strata unchanged", + "precision": "Unchanged BF16 autocast; FP32 weights; TF32 allowed as in original training", +} +FAMILIES = ( + "default", + "actual", + "other_chain_default", + "attribute_3", + "attribute_4", + "attribute_5", + "attribute_6", + "membership", + "other_chain_actual", + "group_root", +) +ARMS = ( + "clean", + "sham", + "target_remove", + "random_remove", + "complement_remove", + "rescue_only", + "remove_rescue", + "remove_wrong_source_rescue", + "remove_random_rescue", +) +TRANSFER_TYPES = ( + "different_group_same_actual_different_default", + "different_group_same_default", + "different_group_same_default_same_actual", +) +TRANSFER_ARMS = ( + "sham", + "full_donor", + "full_norm_random", + "projected_target", + "projected_random", + "projected_complement", +) + + +def _freeze_json(path, value): + if path.exists(): + if json.loads(path.read_text()) != value: + raise ValueError(f"Frozen diagnostic contract changed: {path}") + else: + write_json(path, value) + + +def _same_arrays(path, arrays): + if path.exists(): + with np.load(path) as existing: + if set(existing.files) != set(arrays) or any( + not np.array_equal(existing[key], value) for key, value in arrays.items() + ): + raise ValueError(f"Diagnostic plan changed: {path}") + else: + atomic_numpy_save(path, **arrays) + + +def _sources(): + directory = Path(__file__).parent + names = ( + "bios_mechanism_causal_v2.py", + "bios_mechanism_causal.py", + "bios_mechanism_interventions.py", + "bios_causal_paths.py", + "bios_cross.py", + "bios_data.py", + "bios_model.py", + "bios_train.py", + "bios_organization_train.py", + "bios_path_diagnostics.py", + ) + sources = {name: file_sha256(directory / name) for name in names} + runner = directory.parents[1] / "scripts/analyze_bios_mechanism_causal_v2.py" + sources["runner"] = file_sha256(runner) + return sources + + +def validate_lock(lock): + if (lock.get("mechanism"), lock.get("layer"), lock.get("position")) != ("default_path", 0, 2): + raise ValueError("This runner only instantiates the locked default_path L0/pos2 candidate") + if lock.get("known_only") is not False or not lock.get("locked_at_utc"): + raise ValueError("An all-eligible, timestamped candidate lock is required") + + +def make_probe_plan(world, chain, recipients): + """Same people and fixed queries in every intervention, without knowledge filtering.""" + recipients = np.asarray(recipients, dtype=np.int64) + ids = [ + world.derived_ids[chain, recipients], + world.actual_ids[chain, recipients], + world.derived_ids[1 - chain, recipients], + ] + for relation in (3, 4, 5, 6): + candidates = np.flatnonzero(world.relation == relation) + by_person = np.full(len(world.actual_ids[chain]), -1, dtype=np.int64) + by_person[world.person[candidates]] = candidates + if (by_person[recipients] < 0).any(): + raise ValueError("An independent control query is missing") + ids.append(by_person[recipients]) + ids.extend([world.membership_ids[chain, recipients], world.actual_ids[1 - chain, recipients]]) + person_families = len(ids) + roots = world.root_ids[chain] + query_ids = np.concatenate([*ids, roots]) + return { + "query_id": query_ids, + "person": np.r_[np.tile(recipients, person_families), np.full(len(roots), -1)], + "family": np.r_[ + np.repeat(np.arange(person_families), len(recipients)), + np.full(len(roots), person_families), + ], + # -1 means not applicable; root facts are not ordinary people. + "recipient_old_exception": np.r_[ + np.tile(world.exceptions[chain, recipients].astype(np.int8), person_families), + np.full(len(roots), -1, dtype=np.int8), + ], + "answer": world.answers[query_ids], + } + + +def wrong_source_indices(families): + """Fixed one-person cyclic shift within each family, never chosen by answers.""" + families = np.asarray(families) + index = np.arange(len(families)) + for family in np.unique(families): + selected = np.flatnonzero(families == family) + if len(selected) < 2: + raise ValueError("Wrong-source controls require at least two queries per family") + index[selected] = np.roll(selected, 1) + return index + + +def make_transfer_plan(world, chain, per_population=64): + """Truth matching is restricted to this explicitly labeled offline diagnostic.""" + old = make_donor_plan(world, chain, per_population) + original = old["pair_type"] == 1 + recipients = old["recipient"][original] + train = world.person[world.train_ids[chain]] + group = world.memberships[chain] + default = world.answers[world.root_ids[chain, group]] + actual = world.answers[world.actual_ids[chain]] + rng = rng_for(world.seed, 978, chain) + donor_rows = [old["donor"][original]] + count_rows = [old["candidate_count"][original]] + for same_actual in (False, True): + donors, counts = [], [] + for recipient in recipients: + mask = (group[train] != group[recipient]) & (default[train] == default[recipient]) + if same_actual: + mask &= actual[train] == actual[recipient] + candidates = train[mask] + donors.append(rng.choice(candidates) if len(candidates) else -1) + counts.append(len(candidates)) + donor_rows.append(np.asarray(donors)) + count_rows.append(np.asarray(counts)) + donor = np.concatenate(donor_rows).astype(np.int64) + recipient = np.tile(recipients, len(TRANSFER_TYPES)) + safe = np.maximum(donor, 0) + return { + "case_id": np.arange(len(donor)), + "recipient": recipient, + "donor": donor, + "pair_type": np.repeat(np.arange(len(TRANSFER_TYPES)), len(recipients)), + "candidate_count": np.concatenate(count_rows), + "recipient_old_exception": world.exceptions[chain, recipient], + "same_actual": (actual[safe] == actual[recipient]) & (donor >= 0), + "same_default": (default[safe] == default[recipient]) & (donor >= 0), + "recipient_default": default[recipient], + "recipient_actual": actual[recipient], + "donor_default": np.where(donor >= 0, default[safe], -1), + "donor_actual": np.where(donor >= 0, actual[safe], -1), + } + + +def generate_queries( + model, prompts, lengths, device, batch_size=256, *, operations=None, capture_sites=() +): + """Two free generation passes with identical pre-answer operations, no answer input. + + operations(begin,end) returns (label, site, operation) triples. Every operation + returns its intended delta and availability; realized post-cast norms are + measured separately. Both passes are retained so norm matching is auditable. + """ + if len(prompts) == 0 or batch_size < 1: + raise ValueError("Generation needs nonempty queries and a positive batch size") + lengths = np.asarray(lengths) + if prompts.shape != (len(lengths), 5) or not np.isin(lengths, [4, 5]).all(): + raise ValueError("Unexpected symbolic query shape") + arrays = {"prediction": [], "ended": []} + for site in capture_sites: + query_site_roles(lengths, site.position) + arrays[f"state_{site.layer}_{site.position}"] = [] + calls = 0 + model.eval() + with torch.no_grad(): + for begin in range(0, len(prompts), batch_size): + end = min(begin + batch_size, len(prompts)) + p = torch.as_tensor(prompts[begin:end], device=device) + n = torch.as_tensor(lengths[begin:end], device=device) + hooks, traces, captures = [], {}, {} + try: + for label, site, operation in () if operations is None else operations(begin, end): + query_site_roles(lengths[begin:end], site.position) + + def measured(value, operation=operation): + changed, trace = operation(value) + return changed, {**trace, "realized_delta": changed.float() - value.float()} + + hook, trace = attach_state_operation(model, site, measured) + hooks.append(hook) + traces[label] = trace + for site in capture_sites: + key = f"state_{site.layer}_{site.position}" + captures[key] = [] + + def capture( + _module, _inputs, output, key=key, position=site.position, captures=captures + ): + captures[key].append(output[:, position].detach().float()) + + hooks.append(model.blocks[site.layer].register_forward_hook(capture)) + with precision(device): + first = model(p, (n - 1)[:, None])[:, 0].float().argmax(-1) + continuation = torch.zeros((len(p), 6), dtype=torch.long, device=device) + continuation[:, :5] = p + continuation[torch.arange(len(p), device=device), n] = first + second = model(continuation, n[:, None])[:, 0].argmax(-1) + calls += 2 + arrays["prediction"].append(first.cpu().numpy()) + arrays["ended"].append(second.eq(EOS).cpu().numpy()) + for key, states in captures.items(): + arrays[key].append(states[0].cpu().numpy()) + drift = torch.linalg.vector_norm(states[1] - states[0], dim=-1) + arrays.setdefault(f"{key}_pass_drift", []).append(drift.cpu().numpy()) + for label, trace in traces.items(): + if len(trace) != 2: + raise ValueError( + "Every intervention must occur in both free-generation passes" + ) + for kind in ("delta", "realized_delta"): + norms = torch.stack( + [torch.linalg.vector_norm(t[kind].float(), dim=-1) for t in trace], + dim=1, + ) + arrays.setdefault(f"{label}_{kind}_norm", []).append(norms.cpu().numpy()) + valid = torch.stack([t["valid"] for t in trace], dim=1) + arrays.setdefault(f"{label}_valid", []).append(valid.cpu().numpy()) + finally: + for hook in hooks: + hook.remove() + result = {key: np.concatenate(value) for key, value in arrays.items()} + result.update( + forward_calls=np.asarray(calls), + forward_examples=np.asarray(2 * len(prompts)), + padded_token_positions=np.asarray(11 * len(prompts)), + logical_token_positions=np.asarray(int((2 * lengths + 1).sum())), + ) + return result + + +def _identity_trace(value): + return value, { + "delta": torch.zeros_like(value, dtype=torch.float32), + "valid": torch.ones(len(value), dtype=torch.bool, device=value.device), + } + + +def lesion_operations( + arm, source_bases, downstream_bases, clean_downstream, wrong_index, seed, device +): + """Return a deterministic batch factory. Wrong-source choice never sees truth.""" + if arm not in ARMS: + raise ValueError("Unknown necessity/restoration arm") + if arm == "clean": + return lambda _begin, _end: [] + if arm == "sham": + return lambda _begin, _end: [("source", SOURCE, _identity_trace)] + source = {key: basis.tensors(device) for key, basis in source_bases.items()} + downstream = ( + None + if downstream_bases is None + else {key: basis.tensors(device) for key, basis in downstream_bases.items()} + ) + needs_downstream = "rescue" in arm + if needs_downstream and downstream is None: + raise ValueError("Downstream basis is unavailable; recovery cannot be estimated") + wrong_index = np.asarray(wrong_index) + if len(wrong_index) != len(clean_downstream): + raise ValueError("Wrong-source plan length mismatch") + coefficients = ( + np.random.default_rng(seed) + .standard_normal((len(clean_downstream), source_bases["random"].rank)) + .astype(np.float32) + ) + + def factory(begin, end): + ops = [] + if arm == "clean": + return ops + if arm == "sham": + return [("source", SOURCE, _identity_trace)] + if arm != "rescue_only": + kind = ( + arm.removesuffix("_remove") + if arm in ("random_remove", "complement_remove") + else "target" + ) + q, mean, _ = source[kind] + tq, tm, _ = source["target"] + + def remove(value): + reference = ( + None + if kind == "target" + else torch.linalg.vector_norm(projection_component(value, tq, tm), dim=-1) + ) + return remove_projection(value, q, mean, reference) + + ops.append(("source", SOURCE, remove)) + if needs_downstream: + clean = torch.as_tensor(clean_downstream[begin:end], device=device) + wrong = torch.as_tensor(clean_downstream[wrong_index[begin:end]], device=device) + tq = downstream["target"][0] + rq = downstream["random"][0] + noise = torch.as_tensor(coefficients[begin:end], device=device) @ rq.T + + def recover(value): + _, same_query_trace = restore_projection(value, clean, tq) + correct_delta = same_query_trace["delta"] + reference = torch.linalg.vector_norm(correct_delta, dim=-1) + if arm == "remove_wrong_source_rescue": + return restore_projection(value, wrong, tq, reference) + if arm == "remove_random_rescue": + delta, valid = match_delta_norm(noise, reference) + return value + delta.to(value.dtype), {"delta": delta, "valid": valid} + return restore_projection(value, clean, tq) + + ops.append(("downstream", DOWNSTREAM, recover)) + return ops + + return factory + + +def transfer_operations(arm, bases, recipient, donor, seed, device): + """A locked-basis manipulation check, never a basis-fitting input.""" + if arm not in TRANSFER_ARMS or recipient.shape != donor.shape: + raise ValueError("Invalid donor manipulation") + if arm.startswith("projected_") and bases is None: + raise ValueError("Projected donor diagnostic requires an available source basis") + full_delta = donor.astype(np.float32) - recipient.astype(np.float32) + if arm == "sham": + delta, valid = np.zeros_like(full_delta), np.ones(len(donor), dtype=bool) + elif arm == "full_donor": + delta, valid = full_delta, np.ones(len(donor), dtype=bool) + else: + if arm == "full_norm_random": + raw = np.random.default_rng(seed).standard_normal(full_delta.shape).astype(np.float32) + reference = np.linalg.norm(full_delta, axis=-1) + else: + tq = bases["target"].q + target_delta = (full_delta @ tq) @ tq.T + reference = np.linalg.norm(target_delta, axis=-1) + q = bases[arm.removeprefix("projected_")].q + raw = (full_delta @ q) @ q.T + matched, available = match_delta_norm(torch.from_numpy(raw), torch.from_numpy(reference)) + delta, valid = matched.numpy(), available.numpy() + + def factory(begin, end): + change = torch.as_tensor(delta[begin:end], device=device) + available = torch.as_tensor(valid[begin:end], device=device) + + def operation(value): + return value + change.to(value.dtype), {"delta": change, "valid": available} + + return [("source", SOURCE, operation)] + + return factory + + +def _availability(arrays): + valid = np.ones(len(arrays["prediction"]), dtype=bool) + for key, value in arrays.items(): + if key.endswith("_valid"): + valid &= value.all(axis=1) + return valid + + +def score_rows(arrays, baseline, plan, arm, labels=FAMILIES, label_key="family"): + """All eligible rows first; original-correct strata remain descriptive only.""" + base_correct = (baseline["prediction"] == plan["answer"]) & baseline["ended"] + correct = (arrays["prediction"] == plan["answer"]) & arrays["ended"] + available = _availability(arrays) + rows = [] + for code, family in enumerate(labels): + for population in ("all", "ordinary", "old_exception"): + requested = plan[label_key] == code + if population != "all": + requested &= plan["recipient_old_exception"] == (population == "old_exception") + chosen = requested & available + n, nb = int(chosen.sum()), int((chosen & base_correct).sum()) + before, after = int((chosen & base_correct).sum()), int((chosen & correct).sum()) + row = { + "arm": arm, + "family": family, + "population": population, + "requested": int(requested.sum()), + "available": n, + "unavailable": int((requested & ~available).sum()), + "baseline_correct": before, + "correct": after, + "accuracy": after / n if n else None, + "delta_accuracy": (after - before) / n if n else None, + "known_became_wrong": int((chosen & base_correct & ~correct).sum()), + "wrong_became_correct": int((chosen & ~base_correct & correct).sum()), + "known_denominator": nb, + "known_retention": int((chosen & base_correct & correct).sum()) / nb + if nb + else None, + "termination_error": int((chosen & ~arrays["ended"]).sum()), + "prediction_changed": int( + ( + chosen + & ( + (arrays["prediction"] != baseline["prediction"]) + | (arrays["ended"] != baseline["ended"]) + ) + ).sum() + ), + } + for label in ("source", "downstream"): + for kind in ("delta", "realized_delta"): + key = f"{label}_{kind}_norm" + row[f"mean_{key}"] = ( + float(arrays[key][chosen, 0].mean()) if n and key in arrays else None + ) + rows.append(row) + return rows + + +def paired_score_rows( + left, right, baseline, plan, left_name, right_name, labels=FAMILIES, label_key="family" +): + """Contrasts use a common availability mask, never unmatched denominators.""" + correct_left = (left["prediction"] == plan["answer"]) & left["ended"] + correct_right = (right["prediction"] == plan["answer"]) & right["ended"] + correct_clean = (baseline["prediction"] == plan["answer"]) & baseline["ended"] + available_left, available_right = _availability(left), _availability(right) + rows = [] + for code, family in enumerate(labels): + for population in ("all", "ordinary", "old_exception"): + requested = plan[label_key] == code + if population != "all": + requested &= plan["recipient_old_exception"] == (population == "old_exception") + chosen = requested & available_left & available_right + n = int(chosen.sum()) + nl, nr = int((chosen & correct_left).sum()), int((chosen & correct_right).sum()) + known_right_wrong = chosen & correct_clean & ~correct_right + denominator = int(known_right_wrong.sum()) + rows.append( + { + "left": left_name, + "right": right_name, + "family": family, + "population": population, + "requested": int(requested.sum()), + "common_available": n, + "left_unavailable": int((requested & ~available_left).sum()), + "right_unavailable": int((requested & ~available_right).sum()), + "left_correct": nl, + "right_correct": nr, + "accuracy_difference": (nl - nr) / n if n else None, + "right_wrong_left_correct": int((chosen & ~correct_right & correct_left).sum()), + "right_correct_left_wrong": int((chosen & correct_right & ~correct_left).sum()), + "original_known_right_wrong": denominator, + "original_known_right_wrong_left_recovered": int( + (known_right_wrong & correct_left).sum() + ), + "conditional_recovery_auxiliary": int((known_right_wrong & correct_left).sum()) + / denominator + if denominator + else None, + } + ) + return rows + + +def _check_predictions(generated, archived, ids): + for key in ("prediction", "ended"): + if not np.array_equal(generated[key], archived[key][ids]): + raise ValueError(f"Clean frozen-model generation differs from archive: {key}") + + +def record_archive_comparison(path, generated, archived, ids): + """Archive differences are audited, never used for calibration or row selection.""" + ids = np.asarray(ids) + if generated["prediction"].shape != ids.shape or generated["ended"].shape != ids.shape: + raise ValueError("Local generation shape differs from its declared query plan") + if generated["ended"].dtype != bool or archived["ended"].dtype != bool: + raise ValueError("Archive and local termination masks must be boolean") + _same_arrays( + path, + { + "query_id": ids, + "local_prediction": generated["prediction"], + "local_ended": generated["ended"], + "archive_prediction": archived["prediction"][ids], + "archive_ended": archived["ended"][ids], + "prediction_changed": generated["prediction"] != archived["prediction"][ids], + "ended_changed": generated["ended"] != archived["ended"][ids], + }, + ) + + +def verify_original_replay(model, world, archived, output, device): + """Strong identity/numerical gate; original query order and batch remain exact.""" + ids = np.arange(len(world.answers)) + replay = _cached_generate(output / "original-replay.npz", model, world, ids, device, 512) + _check_predictions(replay, archived, ids) + _freeze_json( + output / "original-replay.json", + { + "status": "exact_archive_value_and_EOS_replay", + "queries": len(ids), + "batch_size": 512, + "prediction_differences": 0, + "ended_differences": 0, + "extra_identity_gate_cost": _cost(replay), + "raw_sha256": file_sha256(output / "original-replay.npz"), + }, + ) + return replay + + +def _cost(arrays): + return { + key: int(arrays[key]) + for key in ( + "forward_calls", + "forward_examples", + "padded_token_positions", + "logical_token_positions", + ) + } + + +def _cached_generate(path, model, world, ids, device, batch_size, **kwargs): + if path.exists(): + with np.load(path) as stored: + result = dict(stored) + if not np.array_equal(result.pop("query_id"), ids): + raise ValueError("Cached generation query plan differs") + return result + result = generate_queries( + model, world.prompts[ids], world.lengths[ids], device, batch_size, **kwargs + ) + atomic_numpy_save(path, query_id=ids, **result) + return result + + +def _fit_chain(model, world, chain, pair, dest, device, batch_size, archived): + plan = calibration_plan( + world.actual_ids[chain], + world.person, + world.membership_ids[chain], + pair["E"], + pair["replay"], + ) + _same_arrays( + dest / "calibration-plan.npz", {key: np.asarray(value) for key, value in plan.items()} + ) + actual = _cached_generate( + dest / "calibration-actual.npz", + model, + world, + plan["actual_query_ids"], + device, + batch_size, + capture_sites=(SOURCE, DOWNSTREAM), + ) + membership = _cached_generate( + dest / "calibration-membership.npz", + model, + world, + plan["membership_query_ids"], + device, + batch_size, + ) + record_archive_comparison( + dest / "archive-calibration-actual.npz", actual, archived, plan["actual_query_ids"] + ) + record_archive_comparison( + dest / "archive-calibration-membership.npz", + membership, + archived, + plan["membership_query_ids"], + ) + prefix = f"{CHAINS[chain]}:" + allowed = np.array( + [i for i, label in enumerate(world.token_labels) if label.startswith(prefix)] + ) + groups, valid = valid_predicted_groups(membership["prediction"], membership["ended"], allowed) + _same_arrays(dest / "self-predicted-groups.npz", {"prediction": groups, "valid": valid}) + bases, reports, basis_arrays = {}, {}, {} + for label, site in (("source", SOURCE), ("downstream", DOWNSTREAM)): + basis, report = fit_predicted_group_bases( + actual[f"state_{site.layer}_{site.position}"], groups, valid, rank=RANK, seed=74 + chain + ) + bases[label], reports[label] = basis, report + if basis is not None: + for kind, value in basis.items(): + for field in ("q", "mean", "scale"): + basis_arrays[f"{label}_{kind}_{field}"] = getattr(value, field) + _same_arrays(dest / "bases.npz", basis_arrays) + information = { + "S_count": len(pair["E"]), + "R_count": len(pair["replay"]), + "actual_queries": len(plan["actual_query_ids"]), + "additional_membership_queries": len(plan["membership_query_ids"]), + "derived_calibration_queries": 0, + "true_memberships_supplied": False, + "membership_syntax_rule": prefix, + "invalid_groups_never_replaced": True, + "calibration_cost": {"actual": _cost(actual), "membership": _cost(membership)}, + "basis_reports": reports, + "variant": "group_means", + "basis_sha256": file_sha256(dest / "bases.npz"), + } + _freeze_json(dest / "calibration.json", information) + # Truth is read only after Q and its information contract are frozen. These + # labels score calibration quality; they never select rows or alter Q. + membership_correct = ( + membership["prediction"] == world.answers[plan["membership_query_ids"]] + ) & membership["ended"] + _freeze_json( + dest / "calibration-diagnostics.json", + { + "role": "offline scoring after frozen Q; never fitting or row selection", + "queries": len(groups), + "valid_predictions": int(valid.sum()), + "valid_rate": float(valid.mean()), + "correct_predictions": int(membership_correct.sum()), + "accuracy": float(membership_correct.mean()), + "accuracy_given_valid_auxiliary": float(membership_correct[valid].mean()) + if valid.any() + else None, + "basis_sha256": information["basis_sha256"], + }, + ) + return bases + + +def run_chain(model, world, chain, pair, dest, device, batch_size, per_population, archived): + dest.mkdir(parents=True, exist_ok=True) + bases = _fit_chain(model, world, chain, pair, dest, device, batch_size, archived) + transfer = make_transfer_plan(world, chain, per_population) + _same_arrays(dest / "transfer-plan.npz", transfer) + recipients = transfer["recipient"][transfer["pair_type"] == 0] + plan = make_probe_plan(world, chain, recipients) + plan["wrong_source_index"] = wrong_source_indices(plan["family"]) + plan["wrong_source_query_id"] = plan["query_id"][plan["wrong_source_index"]] + plan["wrong_source_same_answer"] = plan["answer"] == plan["answer"][plan["wrong_source_index"]] + _same_arrays(dest / "probe-plan.npz", plan) + ids = plan["query_id"] + query_site_roles(world.lengths[ids], SOURCE.position) + if downstream_routing_site(SOURCE, len(model.blocks), world.lengths[ids] - 1) != DOWNSTREAM: + raise ValueError("Candidate/downstream site mismatch") + clean = _cached_generate( + dest / "clean.npz", + model, + world, + ids, + device, + batch_size, + capture_sites=(SOURCE, DOWNSTREAM), + ) + record_archive_comparison(dest / "archive-probe-clean.npz", clean, archived, ids) + rows, states, costs, arm_arrays = [], {}, {"clean": _cost(clean)}, {} + clean_down = clean[f"state_{DOWNSTREAM.layer}_{DOWNSTREAM.position}"] + for arm in ARMS: + if arm not in ("clean", "sham") and bases["source"] is None: + states[arm] = "unavailable_source_rank" + continue + if "rescue" in arm and bases["downstream"] is None: + states[arm] = "unavailable_downstream_rank" + continue + if arm == "clean": + generated = clean + else: + operations = lesion_operations( + arm, + bases["source"], + bases["downstream"], + clean_down, + plan["wrong_source_index"], + [world.seed, 979, chain], + device, + ) + generated = _cached_generate( + dest / f"{arm}.npz", model, world, ids, device, batch_size, operations=operations + ) + if arm in ("sham", "rescue_only"): + for key in ("prediction", "ended"): + if not np.array_equal(generated[key], clean[key]): + raise ValueError(f"No-lesion control changed output: {arm}/{key}") + rows.extend(score_rows(generated, clean, plan, arm)) + costs[arm], states[arm] = _cost(generated), "complete" + arm_arrays[arm] = generated + comparisons = [ + (arm, "clean") + for arm in ("sham", "target_remove", "random_remove", "complement_remove", "rescue_only") + ] + comparisons += [("target_remove", arm) for arm in ("random_remove", "complement_remove")] + comparisons += [ + (arm, "target_remove") + for arm in ("remove_rescue", "remove_wrong_source_rescue", "remove_random_rescue") + ] + comparisons += [ + ("remove_rescue", arm) for arm in ("remove_wrong_source_rescue", "remove_random_rescue") + ] + paired_rows = [] + for left, right in comparisons: + if left in arm_arrays and right in arm_arrays: + paired_rows.extend( + paired_score_rows(arm_arrays[left], arm_arrays[right], clean, plan, left, right) + ) + # Donor activations are read only after both bases and their provenance are frozen. + valid = transfer["donor"] >= 0 + selected = {key: value[valid] for key, value in transfer.items()} + people = np.unique(np.r_[selected["recipient"], selected["donor"]]) + donor_ids = world.derived_ids[chain, people] + donor_clean = _cached_generate( + dest / "transfer-clean.npz", + model, + world, + donor_ids, + device, + batch_size, + capture_sites=(SOURCE,), + ) + record_archive_comparison(dest / "archive-transfer-cache.npz", donor_clean, archived, donor_ids) + ri, di = ( + np.searchsorted(people, selected["recipient"]), + np.searchsorted(people, selected["donor"]), + ) + source_state = donor_clean[f"state_{SOURCE.layer}_{SOURCE.position}"] + # v2: the causal baseline has exactly the intervention query order and batch shape. + # The donor/recipient source cache and intervention delta definitions stay unchanged. + local_ids = world.derived_ids[chain, selected["recipient"]] + transfer_local = _cached_generate( + dest / "transfer-local-clean.npz", + model, + world, + local_ids, + device, + batch_size, + capture_sites=(SOURCE,), + ) + record_archive_comparison( + dest / "archive-transfer-local-clean.npz", transfer_local, archived, local_ids + ) + _same_arrays( + dest / "transfer-reference-drift.npz", + { + "query_id": local_ids, + "cache_vs_local_state_norm": np.linalg.norm( + source_state[ri] - transfer_local["state_0_2"], axis=1 + ), + "cache_prediction": donor_clean["prediction"][ri], + "cache_ended": donor_clean["ended"][ri], + "local_prediction": transfer_local["prediction"], + "local_ended": transfer_local["ended"], + }, + ) + donor_baseline = {key: transfer_local[key] for key in ("prediction", "ended")} + donor_plan = {**selected, "answer": selected["recipient_default"]} + transfer_rows, transfer_status = [], {} + costs["transfer_clean"] = _cost(donor_clean) + costs["transfer_local_clean"] = _cost(transfer_local) + for arm in TRANSFER_ARMS: + if arm.startswith("projected_") and bases["source"] is None: + transfer_status[arm] = "unavailable_source_rank" + continue + ops = transfer_operations( + arm, + bases["source"], + source_state[ri], + source_state[di], + [world.seed, 980, chain], + device, + ) + generated = _cached_generate( + dest / f"transfer-{arm}.npz", + model, + world, + world.derived_ids[chain, selected["recipient"]], + device, + batch_size, + operations=ops, + ) + if arm == "sham": + for key in ("prediction", "ended"): + if not np.array_equal(generated[key], donor_baseline[key]): + raise ValueError("Transfer sham changed output") + scored = score_rows( + generated, donor_baseline, donor_plan, arm, labels=TRANSFER_TYPES, label_key="pair_type" + ) + for row in scored: + code = TRANSFER_TYPES.index(row["family"]) + chosen = (selected["pair_type"] == code) & _availability(generated) + requested = transfer["pair_type"] == code + if row["population"] != "all": + exception = row["population"] == "old_exception" + chosen &= selected["recipient_old_exception"] == exception + requested &= transfer["recipient_old_exception"] == exception + row["plan_requested"] = int(requested.sum()) + row["missing_donors"] = int((requested & ~valid).sum()) + for role in ("recipient_actual", "donor_default", "donor_actual"): + matched = (generated["prediction"] == selected[role]) & generated["ended"] + base_matched = (donor_baseline["prediction"] == selected[role]) & donor_baseline[ + "ended" + ] + row[f"matches_{role}"] = int((chosen & matched).sum()) + row[f"baseline_matches_{role}"] = int((chosen & base_matched).sum()) + # Donor's own clean response is descriptive, not an eligibility filter. + row["donor_answered_default"] = int( + ( + chosen + & donor_clean["ended"][di] + & (donor_clean["prediction"][di] == selected["donor_default"]) + ).sum() + ) + transfer_rows.extend(scored) + transfer_status[arm], costs[f"transfer_{arm}"] = "complete", _cost(generated) + for filename, contents in ( + ("necessity.csv", rows), + ("paired-necessity.csv", paired_rows), + ("transfer.csv", transfer_rows), + ): + with (dest / filename).open("w") as stream: + writer = csv.DictWriter(stream, fieldnames=list(contents[0])) + writer.writeheader() + writer.writerows(contents) + write_json( + dest / "status.json", + { + "arms": states, + "transfer_arms": transfer_status, + "evaluation_cost": costs, + "information_boundary": "truth-matched donor states are diagnostic only", + }, + ) + archive_rows = {} + for path in sorted(dest.glob("archive-*.npz")): + with np.load(path) as comparison: + archive_rows[path.stem] = { + "queries": len(comparison["query_id"]), + "prediction_differences": int(comparison["prediction_changed"].sum()), + "ended_differences": int(comparison["ended_changed"].sum()), + "case_exclusion": False, + } + write_json(dest / "archive-discrepancies.json", archive_rows) + return {"chain": CHAINS[chain], "arms": states, "transfer_arms": transfer_status} + + +def scientific_outputs(output): + """Seal only producer-owned artifacts, excluding mutable queue logs and locks.""" + names = { + "archive-calibration-actual.npz", + "archive-calibration-membership.npz", + "archive-probe-clean.npz", + "archive-transfer-cache.npz", + "archive-transfer-local-clean.npz", + "archive-discrepancies.json", + "transfer-local-clean.npz", + "transfer-reference-drift.npz", + "calibration-plan.npz", + "calibration-actual.npz", + "calibration-membership.npz", + "self-predicted-groups.npz", + "bases.npz", + "calibration.json", + "calibration-diagnostics.json", + "transfer-plan.npz", + "probe-plan.npz", + "transfer-clean.npz", + "necessity.csv", + "paired-necessity.csv", + "transfer.csv", + "status.json", + } + names.update(f"{arm}.npz" for arm in ARMS) + names.update(f"transfer-{arm}.npz" for arm in TRANSFER_ARMS) + paths = [ + output / "contract.json", + output / "original-replay.npz", + output / "original-replay.json", + ] + for chain in CHAINS: + paths.extend( + output / chain / name for name in sorted(names) if (output / chain / name).exists() + ) + return {str(path.relative_to(output)): file_sha256(path) for path in paths} + + +def run_model(run, output, lock_path, *, device="cuda", batch_size=256, per_population=64): + """One original pre-edit checkpoint, both chains; separate outputs, restartable nodes.""" + run, output, lock_path = Path(run).resolve(), Path(output).resolve(), Path(lock_path).resolve() + if output == run or run in output.parents: + raise ValueError("Never write diagnostics inside the frozen parent") + lock = json.loads(lock_path.read_text()) + validate_lock(lock) + config = json.loads((run / "config.json").read_text()) + if ( + config["world"] not in (0, 1) + or config["model"]["width"] not in (256, 768) + or config["seed"] not in (0, 1) + or config["condition"] not in (*CHAINS, "neither") + ): + raise ValueError("The original 24-model development matrix is required") + step = config["study"]["steps"] + if step != 15360 or per_population != 64: + raise ValueError("The parent step and 64+64 recipient budget are fixed") + for key, current in (("torch", torch.__version__), ("cuda", torch.version.cuda)): + if config[key] != current: + raise ValueError(f"Parent runtime differs: {key}") + device = torch.device(device) + weights = run / f"model-{step}.pt" + contract = { + "numerical_policy": NUMERICAL_POLICY, + "run": str(run), + "step": step, + "world": config["world"], + "seed": config["seed"], + "width": config["model"]["width"], + "condition": config["condition"], + "parent_config_sha256": file_sha256(run / "config.json"), + "parent_weights_sha256": file_sha256(weights), + "lock": lock, + "lock_sha256": file_sha256(lock_path), + "sources": _sources(), + "source_site": [0, 2], + "downstream_site": [1, 2], + "rank": RANK, + "per_population": per_population, + "batch_size": batch_size, + "torch": torch.__version__, + "cuda": torch.version.cuda, + "numpy": np.__version__, + "device_type": device.type, + "checkpoint_role": "pre_edit_clean_only", + "calibration": "S_union_R_actual_queries_with_self_predicted_membership_groups", + "families": list(FAMILIES), + "arms": list(ARMS), + "transfer_types": list(TRANSFER_TYPES), + "transfer_arms": list(TRANSFER_ARMS), + "wrong_source_rule": "cyclic_previous_query_within_family_no_truth_or_prediction_selection", + "cross_query_reference": "The actual-calibration mean is reused for all query families", + "recovery_source": "Same checkpoint and same query clean post-L1/pos2 target projection", + "rescue_only_role": "No-lesion downstream sham; cannot establish necessity", + "random_recovery": "Random rank32 downstream basis; same-query recovery delta norm", + "rank_failure": "Unavailable, never padded or replaced; report coverage by organization", + "interpretation": ( + "Artificial-lesion behavior recovery; no claim of edit repair " + "or organizational specificity" + ), + } + output.mkdir(parents=True, exist_ok=True) + _freeze_json(output / "contract.json", contract) + complete_path = output / "complete.json" + if complete_path.exists(): + complete = json.loads(complete_path.read_text()) + for name, digest in complete["outputs"].items(): + if file_sha256(output / name) != digest: + raise ValueError(f"Completed diagnostic artifact changed: {name}") + return complete + repository = Path(__file__).resolve().parents[2] + world = make_cross_world(config["world"], repository / "data/bios-organization-v1") + if ( + array_hash(world.answers) != config["truth_sha256"] + or array_hash(world.prompts) != config["prompts_sha256"] + ): + raise ValueError("Parent generated world changed") + saved = torch.load(weights, map_location="cpu", weights_only=False) + final = json.loads((run / "learning-complete.json").read_text()) + if ( + saved["config"] != config["model"] + or saved["step"] != step + or state_hash(saved["model"]) != final["model_sha256"] + ): + raise ValueError("Parent model identity mismatch") + model = CausalLM(ModelConfig(**saved["config"])) + model.load_state_dict(saved["model"]) + model.to(device).eval() + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + with np.load(run / f"predictions-{step}.npz") as stored: + archived = {key: stored[key] for key in ("prediction", "ended")} + verify_original_replay(model, world, archived, output, device) + completed = [] + for chain, name in enumerate(CHAINS): + pair = edit_pair(world, chain) + reference = run / "edits" / f"{name}-exception-mlp" + with np.load(reference / "sets.npz") as old: + for key in ("E", "replay", "exception"): + if not np.array_equal(old[key], pair[key]): + raise ValueError( + f"Original exception calibration permission changed: {name}/{key}" + ) + if not (reference / "complete.json").exists(): + raise ValueError("Original exception case is incomplete") + completed.append( + run_chain( + model, + world, + chain, + pair, + output / name, + device, + batch_size, + per_population, + archived, + ) + ) + print( + json.dumps({"event": "necessity_chain_complete", "run": str(run), "chain": name}), + flush=True, + ) + if _sources() != contract["sources"]: + raise ValueError("Diagnostic implementation changed during execution") + outputs = scientific_outputs(output) + complete = {"status": "complete", "chains": completed, "outputs": outputs} + write_json(complete_path, complete) + return complete diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_edit.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_edit.py new file mode 100644 index 0000000000000000000000000000000000000000..6e51c693528d73250f62b70686f96b42b7eb9e4f --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_edit.py @@ -0,0 +1,611 @@ +"""P1 counterfactual edits with frozen parent models and exact restart state. + +The supervised pool S is fixed at 93 facts. E_changed, propagation D, and +unchanged U are recomputed from each arm's truth, independently of that pool. +""" + +import argparse +import fcntl +import hashlib +import json +import os +import platform +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_cross import CHAINS, CONDITIONS, edit_pair, make_cross_world +from .bios_cross_train import evaluate, tensor_queries +from .bios_cross_train import source_hashes as parent_source_hashes +from .bios_data import array_hash, rng_for, write_json +from .bios_model import CausalLM, ModelConfig, select_parameters +from .bios_organization_train import atomic_numpy_save, atomic_torch_save, state_hash +from .bios_train import precision + +ARMS = ("old-fact-rehearsal", "root-only", "actual-only", "class-balanced-exception") +OPTIONAL_ARM = "all-freeze-embedding" +REFERENCE_ARMS = ("coherent", "exception") +DEFAULT_STUDY = { + "protocol": "v2.8-development-mechanism-P1", + "widths": [256, 768], + "worlds": [0, 1], + "seeds": [0, 1], + "conditions": list(CONDITIONS), + "arms": list(ARMS), + "edit_steps": 512, + "edit_checkpoints": [0, 32, 128, 512], + "edit_lr": 3e-5, + "retention_kl": 1.0, + "batch_size": 128, + "save_every": 32, + "gradient_steps": [0, 31, 127, 511], +} + + +def load_study(path=None, arms=None): + study = json.loads(json.dumps(DEFAULT_STUDY)) + if path: + supplied = json.loads(Path(path).read_text()) + unknown = set(supplied) - set(study) + if unknown: + raise ValueError(f"Unknown P1 configuration keys: {sorted(unknown)}") + study.update(supplied) + if arms is not None: + study["arms"] = list(arms) + if not study["arms"] or len(set(study["arms"])) != len(study["arms"]): + raise ValueError("At least one unique arm is required") + if set(study["arms"]) - set((*ARMS, OPTIONAL_ARM)): + raise ValueError("Unknown P1 arm") + if study["edit_steps"] < 1 or study["batch_size"] != 128 or study["save_every"] < 1: + raise ValueError("Positive budgets and the original batch size 128 are required") + checkpoints = study["edit_checkpoints"] + if not checkpoints or checkpoints != sorted(set(checkpoints)) or checkpoints[0] != 0: + raise ValueError("Checkpoints must be unique, ordered, and include zero") + if checkpoints[-1] != study["edit_steps"]: + raise ValueError("The final checkpoint must equal the fixed edit budget") + if study["edit_lr"] <= 0 or study["retention_kl"] < 0: + raise ValueError("Invalid optimization settings") + for key in ("widths", "worlds", "seeds", "conditions"): + if not study[key] or len(set(study[key])) != len(study[key]): + raise ValueError(f"Nonempty, unique matrix entries required: {key}") + if set(study["conditions"]) - set(CONDITIONS): + raise ValueError("Unknown organization condition") + return study + + +def file_hash(path): + digest = hashlib.sha256() + with Path(path).open("rb") as stream: + for chunk in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def source_hashes(): + result = parent_source_hashes() + result[Path(__file__).name] = file_hash(__file__) + runner = Path(__file__).resolve().parents[2] / "scripts/run_bios_mechanism_edit.py" + result[runner.name] = file_hash(runner) + return result + + +def sampling_streams(world, chain, steps=512, batch_size=128): + """Match the original generator, including the order of its two draws.""" + pair = edit_pair(world, chain) + rng = rng_for(world.seed, 908, chain) + supervised = rng.integers(len(pair["E"]), size=(steps, batch_size)) + replay = rng.integers(len(pair["replay"]), size=(steps, batch_size)) + return supervised, replay + + +def make_arm(world, chain, arm, pair=None): + if arm not in (*ARMS, OPTIONAL_ARM, *REFERENCE_ARMS): + raise ValueError(f"Unknown arm: {arm}") + pair = edit_pair(world, chain) if pair is None else pair + supervised = pair["E"].copy() + root = np.intersect1d(supervised, world.root_ids[chain]) + actual = np.intersect1d(supervised, world.actual_ids[chain]) + assert (len(supervised), len(root), len(actual)) == (93, 3, 90) + target = world.answers.copy() + if arm == "root-only": + target[root] = pair["exception"][root] + elif arm == "actual-only": + target[actual] = pair["exception"][actual] + elif arm in ("exception", "class-balanced-exception", OPTIONAL_ARM): + target[supervised] = pair["exception"][supervised] + elif arm == "coherent": + target[supervised] = pair["coherent"][supervised] + # Recompute derived truth, rather than copying the original D declaration. + for task in range(2): + target[world.derived_ids[task]] = target[world.root_ids[task, world.memberships[task]]] + changed = target != world.answers + e = np.flatnonzero(changed & (world.relation < 10)) + d = np.flatnonzero(changed & (world.relation >= 10)) + u = np.flatnonzero(~changed) + if not np.isin(e, supervised).all() or not np.array_equal( + target[pair["replay"]], world.answers[pair["replay"]] + ): + raise ValueError("Supervision or common retention pool violates the truth contract") + if np.intersect1d(pair["replay"], supervised).size: + raise ValueError("The replay pool overlaps S") + selected_people = np.isin(world.memberships[chain], pair["groups"]) + selected_facts = (world.person >= 0) & selected_people[np.maximum(world.person, 0)] + old_exceptions = np.zeros(len(world.answers), dtype=bool) + old_exceptions[world.actual_ids[chain, selected_people & world.exceptions[chain]]] = True + relevant = np.isin(world.relation, [0, 1, 2, 10] if chain == 0 else [7, 8, 9, 11]) + strata = np.full(len(world.answers), -1, dtype=np.int64) + strata[~changed & old_exceptions] = 0 + strata[~changed & selected_facts & ~old_exceptions] = 1 + strata[~changed & ~selected_facts & relevant] = 2 + strata[~changed & ~selected_facts & ~relevant] = 3 + assert np.array_equal(strata >= 0, ~changed) + supervised_unchanged = np.intersect1d(supervised, u) + probe_unchanged = np.intersect1d(pair["D"], u) + supplied = np.union1d(supervised, pair["replay"]) + # Keep the archived heldout pool; add newly unchanged D, which is never trained. + heldout = np.setdiff1d( + np.intersect1d(np.union1d(pair["heldout"], probe_unchanged), u), supplied + ) + weights = np.ones(len(supervised), dtype=np.float64) + root_mask = np.isin(supervised, root) + if arm == "class-balanced-exception": + weights[root_mask] = len(supervised) / (2 * len(root)) + weights[~root_mask] = len(supervised) / (2 * len(actual)) + return { + "target": target, + "S": supervised, + "S_root": root, + "S_actual": actual, + "S_root_mask": root_mask, + "S_weights": weights, + "E_changed": e, + "E_changed_root": np.intersect1d(e, root), + "E_changed_actual": np.intersect1d(e, actual), + "D": d, + "D_conflict": np.intersect1d(d, pair["conflict_D"]), + "D_probe": pair["D"], + "D_probe_conflict": pair["conflict_D"], + "D_probe_unchanged": probe_unchanged, + "U": u, + "strata": strata, + "heldout": heldout, + "unseen": np.setdiff1d(u, supplied), + "S_unchanged": supervised_unchanged, + "replay": pair["replay"], + "other_chain": np.flatnonzero( + ~changed & np.isin(world.relation, [7, 8, 9, 11] if chain == 0 else [0, 1, 2, 10]) + ), + "independent": np.flatnonzero(~changed & np.isin(world.relation, [3, 4, 5, 6])), + "groups": pair["groups"], + } + + +def accuracy(correct, ids): + return { + "n": len(ids), + "correct": int(correct[ids].sum()), + "accuracy": float(correct[ids].mean()) if len(ids) else None, + } + + +def retention(correct, old_correct, ids): + known = ids[old_correct[ids]] + broken = int((~correct[known]).sum()) + return { + "n": len(ids), + "known": len(known), + "unknown": len(ids) - len(known), + "broken": broken, + "rate": broken / len(known) if len(known) else None, + } + + +def arm_metrics(world, spec, arrays, old_correct): + correct = arrays["correct"] + result = { + name: accuracy(correct, spec[name]) + for name in ( + "S", + "S_root", + "S_actual", + "E_changed", + "E_changed_root", + "E_changed_actual", + "D", + "D_conflict", + "D_probe", + ) + } + for name in ("D", "D_conflict", "D_probe", "D_probe_conflict"): + for split, pool in (("trained", world.train_ids), ("heldout", world.heldout_ids)): + result[f"{name}_{split}"] = accuracy(correct, np.intersect1d(spec[name], pool)) + for name, pool in ( + ("full", spec["U"]), + ("heldout", spec["heldout"]), + ("unseen", spec["unseen"]), + ): + result[f"U_{name}"] = retention(correct, old_correct, pool) + result[f"U_{name}_strata"] = { + str(group): retention( + correct, old_correct, np.intersect1d(pool, np.flatnonzero(spec["strata"] == group)) + ) + for group in range(4) + } + for name in ("S_unchanged", "D_probe_unchanged", "replay", "other_chain", "independent"): + result[f"U_{name}"] = retention(correct, old_correct, spec[name]) + return result + + +def weighted_supervision(logits, labels, weights): + """Average over sampled examples, never renormalize observed class mass.""" + losses = F.cross_entropy(logits.float().flatten(0, 1), labels.flatten(), reduction="none") + per_example = losses.reshape(len(labels), -1).mean(-1) + return (per_example * weights).mean(), per_example + + +def select_edit_parameters(model, arm): + if arm != OPTIONAL_ARM: + return select_parameters(model, "mlp", 3) + selected = select_parameters(model, "all") + model.token.weight.requires_grad_(False) + return [parameter for parameter in selected if parameter.requires_grad] + + +def _gradient_norm(loss, selected): + gradients = torch.autograd.grad(loss, selected, retain_graph=True, allow_unused=True) + total = sum(g.detach().float().square().sum() for g in gradients if g is not None) + return float(torch.sqrt(total)) if isinstance(total, torch.Tensor) else 0.0 + + +def _freeze_json(path, value): + if path.exists(): + if json.loads(path.read_text()) != value: + raise ValueError(f"Frozen contract mismatch: {path}") + else: + write_json(path, value) + + +def _contract_hash(contract): + return hashlib.sha256(json.dumps(contract, sort_keys=True).encode()).hexdigest() + + +def _checkpoint(model, optimizer, step, contract, timeline, stats, seconds, device): + return { + "model": model.state_dict(), + "config": model.config_dict(), + "optimizer": optimizer.state_dict(), + "step": step, + "contract_sha256": _contract_hash(contract), + "timeline": timeline, + "update_stats": stats, + "seconds": seconds, + "torch_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device) if device.type == "cuda" else None, + } + + +def run_case(model, baseline_state, world, data, old_arrays, chain, arm, dest, study, parent): + """Run or resume one fixed-budget case; no evaluation result changes training.""" + dest = Path(dest) + dest.mkdir(parents=True, exist_ok=True) + device = data["tokens"].device + spec = make_arm(world, chain, arm) + e_choices, r_choices = sampling_streams(world, chain, study["edit_steps"], study["batch_size"]) + contract = { + "parent": parent, + "study": study, + "chain": CHAINS[chain], + "arm": arm, + "sources": source_hashes(), + "sets_sha256": {key: array_hash(value) for key, value in spec.items()}, + "edit_sampling_sha256": array_hash(e_choices), + "replay_sampling_sha256": array_hash(r_choices), + "old_correct_sha256": array_hash(old_arrays["correct"]), + } + _freeze_json(dest / "contract.json", contract) + if (dest / "complete.json").exists(): + completed = json.loads((dest / "complete.json").read_text()) + if completed["contract_sha256"] != _contract_hash(contract): + raise ValueError("Completion contract mismatch") + return completed + model.load_state_dict(baseline_state) + selected = select_edit_parameters(model, arm) + model.eval() + references = [] + with torch.no_grad(), precision(device): + for begin in range(0, len(spec["replay"]), 256): + ids = torch.as_tensor(spec["replay"][begin : begin + 256], device=device) + references.append(model(data["tokens"][ids], data["positions"][ids]).detach()) + references = torch.cat(references) + new_data = tensor_queries(world, device, spec["target"]) + atomic_numpy_save( + dest / "sets.npz", + **spec, + old_correct=old_arrays["correct"], + edit_sampling=e_choices, + replay_sampling=r_choices, + ) + optimizer = torch.optim.AdamW( + selected, lr=study["edit_lr"], weight_decay=0.1, fused=device.type == "cuda" + ) + first, timeline, stats, seconds = 0, [], [], 0.0 + resume_path = dest / "resume.pt" + if resume_path.exists(): + state = torch.load(resume_path, map_location="cpu", weights_only=False) + if state["contract_sha256"] != _contract_hash(contract): + raise ValueError("Resume contract mismatch") + model.load_state_dict(state["model"]) + optimizer.load_state_dict(state["optimizer"]) + first, timeline, stats, seconds = ( + state["step"], + state["timeline"], + state["update_stats"], + state["seconds"], + ) + if len(stats) != first or first > study["edit_steps"]: + raise ValueError("Invalid restart progress") + torch.set_rng_state(state["torch_rng"]) + if device.type == "cuda": + torch.cuda.set_rng_state(state["cuda_rng"], device) + weights = torch.as_tensor(spec["S_weights"], device=device, dtype=torch.float32) + root_mask = torch.as_tensor(spec["S_root_mask"], device=device) + for step in range(first, study["edit_steps"] + 1): + if step in study["edit_checkpoints"] and not any(p["step"] == step for p in timeline): + arrays = evaluate(model, data, spec["target"]) + atomic_numpy_save(dest / f"predictions-{step}.npz", **arrays) + timeline.append( + { + "step": step, + **arm_metrics(world, spec, arrays, old_arrays["correct"]), + "edit_seconds": seconds, + } + ) + write_json(dest / "trajectory.json", timeline) + if step % study["save_every"] == 0 or step in study["edit_checkpoints"]: + atomic_torch_save( + _checkpoint(model, optimizer, step, contract, timeline, stats, seconds, device), + resume_path, + ) + write_json(dest / "update-stats.json", stats) + if step == study["edit_steps"]: + break + model.train() + optimizer.zero_grad(set_to_none=True) + choices = torch.as_tensor(e_choices[step], device=device) + ei = torch.as_tensor(spec["S"][e_choices[step]], device=device) + replay_choices = torch.as_tensor(r_choices[step], device=device) + ri = torch.as_tensor(spec["replay"][r_choices[step]], device=device) + roots = root_mask[choices] + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + with precision(device): + logits = model(new_data["tokens"][ei], new_data["positions"][ei]).float() + ce, per_example = weighted_supervision(logits, new_data["labels"][ei], weights[choices]) + replay_logits = model(data["tokens"][ri], data["positions"][ri]).float() + kl = ( + F.kl_div( + F.log_softmax(replay_logits, -1), + F.softmax(references[replay_choices].float(), -1), + reduction="none", + ) + .sum(-1) + .mean() + ) + loss = ce + study["retention_kl"] * kl + point = { + "step": step + 1, + "root_samples": int(roots.sum()), + "actual_samples": int((~roots).sum()), + "ce": float(ce.detach()), + "kl": float(kl.detach()), + "loss": float(loss.detach()), + } + if step in study["gradient_steps"]: + for name, mask in (("root", roots), ("actual", ~roots)): + component = (per_example * weights[choices] * mask).mean() + point[f"{name}_ce_gradient_norm"] = _gradient_norm(component, selected) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(selected, 1) + if not torch.isfinite(loss + norm): + raise FloatingPointError("Nonfinite P1 edit") + point["total_gradient_norm"] = float(norm) + point["gradient_clipped"] = bool(norm > 1) + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - started + stats.append(point) + if (step + 1) % 128 == 0: + print( + json.dumps({"event": "progress", "case": dest.name, "step": step + 1}), flush=True + ) + atomic_torch_save( + {"model": model.state_dict(), "config": model.config_dict(), "step": study["edit_steps"]}, + dest / "model-final.pt", + ) + completed = { + "status": "complete", + "contract_sha256": _contract_hash(contract), + "final_model_sha256": state_hash(model.state_dict()), + "parameters_updated": sum(p.numel() for p in selected), + "final": timeline[-1], + "root_samples": sum(p["root_samples"] for p in stats), + "actual_samples": sum(p["actual_samples"] for p in stats), + "clipped_updates": sum(p["gradient_clipped"] for p in stats), + } + if source_hashes() != contract["sources"]: + raise ValueError("P1 source files changed during this edit") + write_json(dest / "complete.json", completed) + return completed + + +def rescore_references(world, baseline, out, study, old_correct, parent): + """Archive provenance and recompute metrics without mutating historical files.""" + for chain, name in enumerate(CHAINS): + e_choices, r_choices = sampling_streams(world, chain, study["edit_steps"]) + pair = edit_pair(world, chain) + for arm in REFERENCE_ARMS: + source = baseline / "edits" / f"{name}-{arm}-mlp" + spec = make_arm(world, chain, arm, pair) + with np.load(source / "sets.npz") as archived: + for key, expected in ( + ("E", spec["S"]), + ("replay", spec["replay"]), + ("edit_sampling", e_choices), + ("replay_sampling", r_choices), + ("old_correct", old_correct), + (arm, spec["target"]), + ): + if not np.array_equal(archived[key], expected): + raise ValueError(f"Reference reuse contract failed for {source}/{key}") + if not (source / "complete.json").exists(): + raise ValueError(f"Historical reference is incomplete: {source}") + timeline, hashes = [], {} + for step in study["edit_checkpoints"]: + path = source / f"predictions-{step}.npz" + with np.load(path) as stored: + arrays = {key: stored[key] for key in ("prediction", "ended", "correct")} + recomputed = (arrays["prediction"] == spec["target"]) & arrays["ended"] + if not np.array_equal(arrays["correct"], recomputed): + raise ValueError("Historical prediction correctness mismatch") + timeline.append({"step": step, **arm_metrics(world, spec, arrays, old_correct)}) + hashes[path.name] = file_hash(path) + dest = out / "references" / f"{name}-{arm}-mlp" + dest.mkdir(parents=True, exist_ok=True) + _freeze_json( + dest / "contract.json", {"parent": parent, "source": str(source), "files": hashes} + ) + atomic_numpy_save(dest / "sets.npz", **spec, old_correct=old_correct) + write_json(dest / "trajectory.json", timeline) + + +def run_model(baseline, output, study, device): + baseline, output = Path(baseline).resolve(), Path(output).resolve() + if output == baseline or baseline in output.parents: + raise ValueError("P1 results must not be written inside a frozen parent directory") + output.mkdir(parents=True, exist_ok=True) + config_path = baseline / "config.json" + config = json.loads(config_path.read_text()) + if config["sources"] != parent_source_hashes(): + raise ValueError("Frozen parent training sources have changed") + for key, current in (("torch", torch.__version__), ("cuda", torch.version.cuda)): + if config[key] != current: + raise ValueError(f"Parent and P1 runtime differ: {key}") + parent_study = config["study"] + for key in ("edit_steps", "edit_checkpoints", "edit_lr", "retention_kl"): + if study[key] != parent_study[key]: + raise ValueError(f"Historical reference configuration differs: {key}") + parent_step = parent_study["steps"] + weights_path = baseline / f"model-{parent_step}.pt" + saved = torch.load(weights_path, map_location="cpu", weights_only=False) + if saved["config"] != config["model"] or saved["step"] != parent_step: + raise ValueError("Parent weight configuration mismatch") + final = json.loads((baseline / "learning-complete.json").read_text()) + if state_hash(saved["model"]) != final["model_sha256"]: + raise ValueError("Parent model state hash mismatch") + world = make_cross_world(config["world"]) + if ( + array_hash(world.answers) != config["truth_sha256"] + or array_hash(world.prompts) != config["prompts_sha256"] + ): + raise ValueError("Parent world does not match the current generated truth") + parent = { + "directory": str(baseline), + "config_sha256": file_hash(config_path), + "weights_sha256": file_hash(weights_path), + "model_sha256": final["model_sha256"], + "width": config["model"]["width"], + "world": config["world"], + "seed": config["seed"], + "condition": config["condition"], + "step": parent_step, + } + runtime = { + "torch": torch.__version__, + "cuda": torch.version.cuda, + "python": platform.python_version(), + "numpy": np.__version__, + "device_type": device.type, + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "precision": "BF16 autocast; FP32 weights and optimizer" + if device.type == "cuda" + else "FP32", + } + contract = {"parent": parent, "study": study, "sources": source_hashes(), "runtime": runtime} + _freeze_json(output / "contract.json", contract) + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + torch.cuda.manual_seed_all(config["seed"]) + torch.manual_seed(config["seed"]) + model = CausalLM(ModelConfig(**saved["config"])).to(device) + model.load_state_dict(saved["model"]) + data = tensor_queries(world, device) + old_arrays = evaluate(model, data, world.answers) + with np.load(baseline / f"predictions-{parent_step}.npz") as archived: + for key in ("correct", "prediction", "ended"): + if not np.array_equal(old_arrays[key], archived[key]): + raise ValueError(f"Parent predictions changed under this runtime: {key}") + atomic_numpy_save(output / "baseline-predictions.npz", **old_arrays) + write_json( + output / "runtime.json", + {**runtime, "device": str(device), "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES")}, + ) + rescore_references(world, baseline, output, study, old_arrays["correct"], parent) + completed = [] + for chain, name in enumerate(CHAINS): + for arm in study["arms"]: + dest = output / "edits" / f"{name}-{arm}" + result = run_case( + model, saved["model"], world, data, old_arrays, chain, arm, dest, study, parent + ) + completed.append(f"{name}-{arm}") + write_json( + output / "status.json", + {"state": "running", "complete": completed, "updated": time.time()}, + ) + print( + json.dumps( + {"event": "edit_complete", "case": dest.name, "D": result["final"]["D"]} + ), + flush=True, + ) + write_json( + output / "complete.json", + { + "status": "complete", + "contract_sha256": _contract_hash(contract), + "edit_cases": len(completed), + "cases": completed, + "references": 4, + }, + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--baseline", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--config") + parser.add_argument("--arms", nargs="+", choices=(*ARMS, OPTIONAL_ARM)) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + args = parser.parse_args() + study = load_study(args.config, args.arms) + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + with (out / ".lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + torch.set_num_threads(args.threads) + try: + run_model(args.baseline, out, study, torch.device(args.device)) + except Exception as exc: + write_json(out / "failure.json", {"type": type(exc).__name__, "message": str(exc)}) + raise + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py new file mode 100644 index 0000000000000000000000000000000000000000..4d87971e01bb7f679239d58f88ea4ac1b054eb88 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py @@ -0,0 +1,375 @@ +"""Uninstantiated P4 projection diagnostics and equal-parameter branches. + +These operators do not choose a real layer, fit a real model's basis, read world +membership truth, or run an experiment. The caller must freeze a candidate and +an information budget first. Group means are not, by themselves, evidence of +an organizational representation. +""" + +from dataclasses import dataclass + +import numpy as np +import torch + + +@dataclass(frozen=True) +class Site: + layer: int + position: int + + +@dataclass(frozen=True) +class Basis: + q: np.ndarray + mean: np.ndarray + scale: np.ndarray + + @property + def rank(self): + return self.q.shape[1] + + def tensors(self, device): + return tuple( + torch.as_tensor(value, dtype=torch.float32, device=device) + for value in (self.q, self.mean, self.scale) + ) + + +def calibration_plan(actual_query_ids, person_by_query, membership_query_ids, supervised, replay): + """Only actual queries in S union R; bridge IDs specify additional self-queries. + + All arguments are query/identity metadata. No group truth or answers are + accepted. In particular this never constructs a derived query to fit Q. + """ + allowed = np.union1d(supervised, replay) + actual = np.intersect1d(actual_query_ids, allowed) + people = np.asarray(person_by_query)[actual] + if (people < 0).any() or len(np.unique(people)) != len(people): + raise ValueError("Calibration must contain one actual query per valid person") + membership = np.asarray(membership_query_ids)[people] + return { + "actual_query_ids": actual, + "person_ids": people, + "membership_query_ids": membership, + "logical_actual_queries": len(actual), + "logical_additional_membership_queries": len(membership), + "derived_calibration_queries": 0, + } + + +def valid_predicted_groups(prediction, ended, allowed_group_tokens): + prediction, ended = np.asarray(prediction), np.asarray(ended) + if prediction.ndim != 1 or ended.shape != prediction.shape or ended.dtype != bool: + raise ValueError("Group predictions require one value and a boolean termination mask") + valid = ended & np.isin(prediction, allowed_group_tokens) + # Invalid predictions are recorded, never replaced with the true group. + return np.where(valid, prediction, -1), valid + + +def _row_span(values, relative_tolerance=1e-6, absolute_tolerance=1e-8): + _, singular, vh = np.linalg.svd(values, full_matrices=False) + threshold = ( + max(absolute_tolerance, relative_tolerance * singular[0]) + if len(singular) + else absolute_tolerance + ) + numerical_rank = int((singular > threshold).sum()) + return vh[:numerical_rank].T, singular, numerical_rank + + +def _orthogonal_residual(values, q): + return values - (values @ q) @ q.T if q.shape[1] else values.copy() + + +def _normalized_basis(q, calibration): + projected = calibration @ q + mean, std = projected.mean(0), projected.std(0) + floor = max(float(np.sqrt(np.mean(std * std))) * 0.01, 1e-8) + std = np.maximum(std, floor) + unit = (projected - mean) / std + total_std = float(np.sqrt(np.mean(np.sum(unit * unit, axis=-1)))) + if not np.isfinite(total_std) or total_std <= 1e-8: + raise ValueError("A nonzero calibration variance is required") + basis = Basis( + q.astype(np.float32), mean.astype(np.float32), (std * total_std).astype(np.float32) + ) + if not np.allclose(basis.q.T @ basis.q, np.eye(q.shape[1]), atol=1e-5): + raise ValueError("The constructed basis is not orthonormal") + return basis + + +def fit_predicted_group_bases( + activations, + predicted_groups, + valid, + *, + rank=32, + seed=74, + variant="group_means", + predicted_answers=None, + answer_valid=None, +): + """Construct a target, orthogonal within-group complement, and random basis. + + Main method input: permitted actual-query states and model-predicted groups. + The optional answer-centered variant is a diagnostic until separately + preregistered. It uses model predictions from those same actual queries; + it does not request default/derived answer truth or extra derived states. + Rank failure returns unavailable; random directions never fill missing rank. + """ + x = np.asarray(activations, dtype=np.float64) + groups, used = np.asarray(predicted_groups), np.asarray(valid).copy() + if x.ndim != 2 or groups.shape != (len(x),) or used.shape != groups.shape or used.dtype != bool: + raise ValueError("Mismatched calibration arrays") + if not np.isfinite(x).all() or rank < 1 or rank > x.shape[1]: + raise ValueError("Finite activations and a feasible positive rank are required") + if (groups[used] < 0).any(): + raise ValueError("Invalid group predictions cannot be marked valid") + if variant not in ("group_means", "answer_centered_diagnostic"): + raise ValueError("Unknown basis variant") + answers = None + if variant == "answer_centered_diagnostic": + if predicted_answers is None or answer_valid is None: + raise ValueError("Answer centering requires model answers and validity flags") + answers, av = np.asarray(predicted_answers), np.asarray(answer_valid) + if answers.shape != groups.shape or av.shape != groups.shape or av.dtype != bool: + raise ValueError("Mismatched predicted answer arrays") + used &= av + report = { + "available": False, + "variant": variant, + "rank_requested": rank, + "calibration_rows": len(x), + "used_rows": int(used.sum()), + "invalid_rows": int((~used).sum()), + "uses_group_truth": False, + "uses_derived_calibration": False, + "random_seed": seed, + } + if not used.any(): + return None, {**report, "reason": "No valid model-predicted calibration groups"} + values, labels = x[used], groups[used] + unique, inverse = np.unique(labels, return_inverse=True) + group_means = np.stack([values[inverse == index].mean(0) for index in range(len(unique))]) + target_matrix = group_means - group_means.mean(0) + answer_span = np.empty((x.shape[1], 0)) + if answers is not None: + answer_labels = answers[used] + answer_means = np.stack( + [values[answer_labels == label].mean(0) for label in np.unique(answer_labels)] + ) + answer_span, _, _ = _row_span(answer_means - answer_means.mean(0)) + target_matrix = _orthogonal_residual(target_matrix, answer_span) + target_span, singular, target_rank = _row_span(target_matrix) + report.update( + predicted_groups=len(unique), + answer_span_rank=answer_span.shape[1], + target_numerical_rank=target_rank, + target_singular_values=singular.tolist(), + ) + if target_rank < rank: + return None, { + **report, + "reason": "Target has fewer than the required independent directions", + } + target = target_span[:, :rank] + residual = values - group_means[inverse] + residual = _orthogonal_residual(_orthogonal_residual(residual, answer_span), target) + complement_span, complement_singular, complement_rank = _row_span(residual) + report.update( + complement_numerical_rank=complement_rank, + complement_singular_values=complement_singular.tolist(), + ) + if complement_rank < rank: + return None, { + **report, + "reason": "Complement has fewer than the required independent directions", + } + if x.shape[1] - answer_span.shape[1] < rank: + return None, {**report, "reason": "Insufficient common admissible dimension"} + random_values = np.random.default_rng(seed).standard_normal((x.shape[1], rank)) + random_values = _orthogonal_residual(random_values.T, answer_span).T + random, triangular = np.linalg.qr(random_values, mode="reduced") + if (np.abs(np.diag(triangular)) < 1e-8).any(): + return None, {**report, "reason": "Random control is numerically rank deficient"} + bases = { + name: _normalized_basis(q, values) + for name, q in ( + ("target", target), + ("complement", complement_span[:, :rank]), + ("random", random), + ) + } + report["normalization"] = { + name: { + "rank": basis.rank, + "total_variance": float( + np.mean(np.sum(((values @ basis.q - basis.mean) / basis.scale) ** 2, axis=1)) + ), + "answer_span_overlap": float(np.linalg.norm(answer_span.T @ basis.q)), + } + for name, basis in bases.items() + } + return bases, {**report, "available": True, "reason": None} + + +def projection_component(values, q, mean): + # Explicit FP32 is necessary: .float() alone does not disable an outer + # autocast context for matrix products in a forward hook. + with torch.autocast(device_type=values.device.type, enabled=False): + return (values.float() @ q.float() - mean.float()) @ q.float().T + + +def match_delta_norm(delta, reference_norms, tolerance=1e-12): + """Zero-length controls with a positive target norm are explicitly unusable.""" + norms = torch.linalg.vector_norm(delta.float(), dim=-1) + reference_norms = torch.as_tensor(reference_norms, dtype=norms.dtype, device=norms.device) + if reference_norms.shape != norms.shape or bool((reference_norms < 0).any()): + raise ValueError("One nonnegative reference norm is required per case") + valid = (norms > tolerance) | (reference_norms <= tolerance) + scale = torch.where( + valid, reference_norms / norms.clamp_min(tolerance), torch.zeros_like(norms) + ) + return delta * scale[:, None], valid + + +def remove_projection(values, q, mean, reference_norms=None): + delta = -projection_component(values, q, mean) + valid = torch.ones(len(values), device=values.device, dtype=torch.bool) + if reference_norms is not None: + delta, valid = match_delta_norm(delta, reference_norms) + return values + delta.to(values.dtype), {"delta": delta, "valid": valid} + + +def restore_projection(values, clean_source, q, reference_norms=None): + """Restore only a fixed later-site projection, not an entire clean activation. + + clean_source must be from the same declared checkpoint and clean query, or + an explicitly labeled wrong-source control. A pre-edit source in an edited + model is a separate diagnostic and may undo the edit; it is never implicit. + """ + if values.shape != clean_source.shape: + raise ValueError("Restoration source and receiving states must have the same shape") + with torch.autocast(device_type=values.device.type, enabled=False): + delta = ((clean_source.float() - values.float()) @ q.float()) @ q.float().T + valid = torch.ones(len(values), device=values.device, dtype=torch.bool) + if reference_norms is not None: + delta, valid = match_delta_norm(delta, reference_norms) + return values + delta.to(values.dtype), {"delta": delta, "valid": valid} + + +def validate_restoration_sites(source, receiver, layers, answer_positions, allow_readout=False): + """A later relational post-block must still have a path to the value readout.""" + if not (0 <= source.layer < receiver.layer < layers): + raise ValueError("Restoration must be at a strictly later block, never the ablation point") + if source.position < 0 or receiver.position < 0: + raise ValueError("Token positions must be nonnegative") + if receiver.position < source.position: + raise ValueError("The receiving token is causally before the source token") + answer_positions = np.asarray(answer_positions) + if (answer_positions < receiver.position).any(): + raise ValueError("The receiving state cannot include an answer token") + if receiver.layer == layers - 1: + if (receiver.position < answer_positions).any(): + raise ValueError("Final-block earlier-token patches cannot affect value readout") + if not allow_readout: + raise ValueError("Final answer-marker restoration is a readout control, not routing") + return {"readout_control": receiver.layer == layers - 1} + + +def downstream_routing_site(source, layers, answer_positions): + """Prespecified L+1/same-token rescue; late candidates have no such rescue.""" + if source.layer > layers - 3: + raise ValueError("This late candidate has no nonterminal same-token routing rescue") + receiver = Site(source.layer + 1, source.position) + validate_restoration_sites(source, receiver, layers, answer_positions) + return receiver + + +def query_site_roles(lengths, position): + lengths = np.asarray(lengths) + if not np.isin(lengths, [4, 5]).all() or position not in (2, 3, 4): + raise ValueError("Only the declared basic/derived symbolic query forms are supported") + if (position >= lengths).any(): + raise ValueError("An intervention cannot use a future answer-token position") + return np.where( + position == lengths - 1, + "answer_marker", + "first_relation" if position == 2 else "second_relation", + ) + + +def attach_state_operation(model, site, operation): + """Attach a batch-local operation; caller supplies fixed source/control states. + + Operations return (new_state, diagnostics). Prompt and EOS passes may use + the same pre-answer operation; future answer tokens must never be sources. + """ + if site.layer < 0 or site.layer >= len(model.blocks) or site.position < 0: + raise ValueError("Invalid intervention site") + traces = [] + + def intervene(_module, _inputs, output): + if site.position >= output.shape[1]: + raise ValueError("Intervention site is outside this query") + changed, trace = operation(output[:, site.position]) + if changed.shape != output[:, site.position].shape: + raise ValueError("An intervention changed the residual dimension") + result = output.clone() + result[:, site.position] = changed + traces.append(trace) + return result + + return model.blocks[site.layer].register_forward_hook(intervene), traces + + +def attach_equal_branch(model, basis, site, bottleneck=32, seed=73): + """The main experiment adds this branch to a common trainable MLP scope.""" + from .bios_branch import ResidualBranch + + if hasattr(model, "edit_branch"): + raise ValueError("An edit branch is already attached") + if site.layer < 0 or site.layer >= len(model.blocks) or site.position < 0: + raise ValueError("Invalid branch site") + if site.position not in (2, 3): + raise ValueError("Method branches are restricted to locked relation candidates 2/3") + device = next(model.parameters()).device + branch = ResidualBranch(*basis.tensors(device), width=bottleneck, seed=seed) + model.add_module("edit_branch", branch) + + def add(_module, _inputs, output): + if site.position >= output.shape[1]: + raise ValueError("Branch site is outside this query") + changed = output.clone() + changed[:, site.position] += branch(output[:, site.position]) + return changed + + handle = model.blocks[site.layer].register_forward_hook(add) + expected = bottleneck * (basis.rank + model.config.width) + if sum(parameter.numel() for parameter in branch.parameters()) != expected: + raise ValueError("Unequal branch parameter count") + return branch, handle + + +def select_branch_parameters(model, branch, *, train_common_mlp=True, start=3): + from .bios_model import select_parameters + + if model.edit_branch is not branch: + raise ValueError("The branch is not attached to this model") + if train_common_mlp: + selected = select_parameters(model, "mlp", start) + else: + selected = [] + for parameter in model.parameters(): + parameter.requires_grad_(False) + parameter.grad = None + for parameter in branch.parameters(): + parameter.requires_grad_(True) + parameter.grad = None + selected.append(parameter) + return selected + + +def remove_equal_branch(model, handle): + handle.remove() + delattr(model, "edit_branch") diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_model.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_model.py new file mode 100644 index 0000000000000000000000000000000000000000..7190d562883dec0d900e7ac14e894975f76499fb --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_model.py @@ -0,0 +1,120 @@ +"""Ordinary causal GPT-2-style language model used by protocol v2.3.""" + +import math +from dataclasses import asdict, dataclass + +import torch +from torch import nn +from torch.nn import functional as F + + +@dataclass(frozen=True) +class ModelConfig: + vocab_size: int + width: int = 768 + layers: int = 8 + heads: int = 12 + context: int = 128 + + +class Attention(nn.Module): + def __init__(self, config): + super().__init__() + self.heads = config.heads + self.qkv = nn.Linear(config.width, 3 * config.width) + self.proj = nn.Linear(config.width, config.width) + + def forward(self, x): + batch, length, width = x.shape + q, k, v = self.qkv(x).view(batch, length, 3, self.heads, width // self.heads).unbind(2) + output = F.scaled_dot_product_attention( + q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2), is_causal=True + ) + return self.proj(output.transpose(1, 2).reshape(batch, length, width)) + + +class MLP(nn.Module): + def __init__(self, width): + super().__init__() + self.up = nn.Linear(width, 4 * width) + self.activation = nn.GELU(approximate="tanh") + self.down = nn.Linear(4 * width, width) + + def forward(self, x): + return self.down(self.activation(self.up(x))) + + +class Block(nn.Module): + def __init__(self, config): + super().__init__() + self.ln1, self.ln2 = nn.LayerNorm(config.width), nn.LayerNorm(config.width) + self.attention = Attention(config) + self.mlp = MLP(config.width) + + def forward(self, x): + x = x + self.attention(self.ln1(x)) + return x + self.mlp(self.ln2(x)) + + +class CausalLM(nn.Module): + def __init__(self, config): + super().__init__() + self.config = config + self.token = nn.Embedding(config.vocab_size, config.width) + self.position = nn.Embedding(config.context, config.width) + self.blocks = nn.ModuleList([Block(config) for _ in range(config.layers)]) + self.ln_final = nn.LayerNorm(config.width) + self.apply(self._initialize) + for block in self.blocks: + for module in (block.attention.proj, block.mlp.down): + nn.init.normal_(module.weight, std=0.02 / math.sqrt(2 * config.layers)) + + @staticmethod + def _initialize(module): + if isinstance(module, (nn.Linear, nn.Embedding)): + nn.init.normal_(module.weight, std=0.02) + if isinstance(module, nn.Linear): + nn.init.zeros_(module.bias) + elif isinstance(module, nn.LayerNorm): + nn.init.ones_(module.weight) + nn.init.zeros_(module.bias) + + def forward(self, tokens, positions=None): + x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device)) + for block in self.blocks: + x = block(x) + x = self.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + return F.linear(x, self.token.weight) + + def config_dict(self): + return asdict(self.config) + + +def select_parameters(model, scope, start=3): + if scope not in {"all", "mlp", "down"}: + raise ValueError("Scope must be all, mlp or down") + selected = list(model.parameters()) if scope == "all" else [] + if scope == "mlp": + selected = [p for block in model.blocks[start : start + 3] for p in block.mlp.parameters()] + elif scope == "down": + selected = [model.blocks[start + 1].mlp.down.weight] + ids = {id(p) for p in selected} + for parameter in model.parameters(): + parameter.requires_grad_(id(parameter) in ids) + parameter.grad = None + return selected + + +def matmul_flops(config, batch, sequence=6, output_positions=2, backward=True): + """Executed-shape dense/attention FLOPs estimate; excludes elementwise operations. + + Multiplication and addition each count as one. Backward uses a factor of two + forwards, a conventional upper approximation also used for frozen parameters. + This is not a hardware counter or a cross-editor exact FLOP measurement. + """ + d, layers, vocab = config.width, config.layers, config.vocab_size + forward = layers * (24 * batch * sequence * d * d + 4 * batch * sequence * sequence * d) + forward += 2 * batch * output_positions * d * vocab + return forward * (3 if backward else 1) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization.py new file mode 100644 index 0000000000000000000000000000000000000000..a64a674326bdc2e7202a987e0ac941b40640d912 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization.py @@ -0,0 +1,256 @@ +"""Equal-presentation bioS corpora differing only in document organization. + +A joins a person's six facts to the true employer default. B keeps the person's +facts together but supplies an unrelated company's default. C keeps B's exact +actual/default pair and moves the other five personal facts to distinct company +origins. No fact is falsified; every condition uses the same presentation pool. +""" + +import numpy as np + +from .bios_data import EOS, N_BASE, N_COMPANIES, N_PEOPLE, RELATIONS, array_hash, rng_for + +CONDITIONS = ("A", "B", "C") +CONDITION_NAMES = {"A": "relation_linked", "B": "person_grouped", "C": "shuffled"} +PERSONAL_RELATIONS = (0, 2, 3, 4, 5, 6) +N_PRESENTATIONS = N_PEOPLE * len(RELATIONS) + + +def _fact_lookup(world): + """Look up fact IDs without depending on the current contiguous numbering.""" + lookup = np.full((7, N_PEOPLE), -1, dtype=np.int64) + for relation in range(7): + ids = np.flatnonzero(world.relation[:N_BASE] == relation) + subjects = world.company[ids] if relation == 1 else world.person[ids] + lookup[relation, subjects] = ids + return lookup + + +def make_documents(world, condition, organization_seed=0): + """Return (2048, 7) fact IDs in canonical relation order. + + Organization is fixed across epochs. Random group ordering and within-group + assignment use a separate seed, shared across all three conditions. C's + seven company origins are distinct, including its unlinked default. + """ + if condition not in CONDITIONS: + raise ValueError(f"Unknown organization condition: {condition}") + if organization_seed < 0: + raise ValueError("organization_seed must be nonnegative") + lookup = _fact_lookup(world) + documents = np.empty((N_PEOPLE, 7), dtype=np.int64) + people = np.arange(N_PEOPLE) + for relation in PERSONAL_RELATIONS: + documents[:, relation] = lookup[relation, people] + documents[:, 1] = lookup[1, world.employers] + if condition == "A": + return documents + + rng = rng_for(world.seed, 101, organization_seed) + members = np.stack( + [rng.permutation(np.flatnonzero(world.employers == c)) for c in range(N_COMPANIES)] + ) + if members.shape != (N_COMPANIES, 32): + raise ValueError("Organization protocol requires 64 companies with 32 people each") + # Independent company cycles per employee-rank lane avoid a stable unrelated + # company partner. Every cycle is a derangement and visits every company. + cycles = np.stack([rng.permutation(N_COMPANIES) for _ in range(32)]) + lane = np.arange(32)[:, None] + anchors = members[cycles, lane] + documents[anchors, 1] = lookup[1, np.roll(cycles, -1, axis=1)] + if condition == "C": + for shift, relation in enumerate((0, 3, 4, 5, 6), start=2): + donor_members = members.copy() + # Each donor person contributes exactly one fact of this relation. + for row in donor_members: + rng.shuffle(row) + donors = donor_members[np.roll(cycles, -shift, axis=1), lane] + documents[anchors, relation] = lookup[relation, donors] + return documents + + +def apply_epoch(documents, world_seed, epoch): + """Apply a shared row permutation and cyclic slot rotation (zero-based epoch). + + Every seven complete epochs, every presentation visits all seven positions. + The permutation depends on the world and epoch, never on the condition. + """ + documents = np.asarray(documents) + if documents.shape != (N_PEOPLE, 7) or epoch < 0: + raise ValueError("Expected canonical (2048, 7) documents and nonnegative epoch") + rows = rng_for(world_seed, 102, epoch).permutation(N_PEOPLE) + return np.roll(documents[rows], epoch % 7, axis=1) + + +def document_epoch(world, condition, epoch, organization_seed=0): + return apply_epoch(make_documents(world, condition, organization_seed), world.seed, epoch) + + +def render_documents(world, ids): + """Render facts with cross-fact causal attention, answer/EOS-only supervision. + + Each row is one document, independently batched; no inter-document attention + is required. Positions select logits that predict the next answer/EOS token. + """ + ids = np.asarray(ids, dtype=np.int64) + if ids.ndim != 2 or ids.shape[1] != 7 or np.any((ids < 0) | (ids >= N_BASE)): + raise ValueError("Expected seven base fact IDs per document") + tokens = np.empty((*ids.shape, 6), dtype=np.int64) + tokens[:, :, :4] = world.prompts[ids, :4] + tokens[:, :, 4] = world.answers[ids] + tokens[:, :, 5] = EOS + positions = (np.arange(7)[:, None] * 6 + np.array([3, 4])).ravel() + labels = np.stack([world.answers[ids], np.full_like(ids, EOS)], axis=-1) + return { + "tokens": tokens.reshape(len(ids), 42), + "positions": np.broadcast_to(positions, (len(ids), 14)).copy(), + "labels": labels.reshape(len(ids), 14), + "fact_ids": ids.copy(), + } + + +def presentation_ids(world, documents): + """Assign each shared presentation to exactly one canonical document slot. + + Personal presentation IDs are 7*person+relation. The 32 default copies use + 7*employee+1, assigned in sorted row order. This assignment is made before + epoch rotation, and permits a fixed text/template for every presentation. + """ + documents = np.asarray(documents, dtype=np.int64) + if documents.shape != (N_PEOPLE, 7): + raise ValueError("Expected canonical (2048, 7) documents") + if not np.all(world.relation[documents] == np.arange(7)): + raise ValueError("Presentation assignment requires canonical relation order") + ids = world.person[documents] * 7 + world.relation[documents] + for company in range(N_COMPANIES): + rows = np.flatnonzero(world.company[documents[:, 1]] == company) + people = np.flatnonzero(world.employers == company) + if len(rows) != len(people): + raise ValueError("Each company default must have 32 presentations") + ids[rows, 1] = people * 7 + 1 + if not np.array_equal(np.sort(ids.ravel()), np.arange(N_PRESENTATIONS)): + raise ValueError("Presentations were lost or duplicated") + return ids + + +def audit_organizations(world, documents): + """Fail on confounds and report the measured organization intervention.""" + if set(documents) != set(CONDITIONS): + raise ValueError("Audit requires A, B and C") + expected_counts = np.where(world.relation[:N_BASE] == 1, 32, 1) + expected_answers = np.bincount( + world.answers[:N_BASE], weights=expected_counts, minlength=world.vocab_size + ).astype(np.int64) + conditions = {} + for condition, ids in documents.items(): + if ids.shape != (N_PEOPLE, 7) or not np.all(world.relation[ids] == np.arange(7)): + raise ValueError("Invalid document shape or relation slots") + counts = np.bincount(ids.ravel(), minlength=N_BASE) + if not np.array_equal(counts, expected_counts): + raise ValueError("Per-fact presentation counts differ") + answers = np.bincount(world.answers[ids].ravel(), minlength=world.vocab_size) + if not np.array_equal(answers, expected_answers): + raise ValueError("Answer-token presentation counts differ") + companies, people = world.company[ids], world.person[ids] + same_company = companies[:, :, None] == companies[:, None, :] + same_person = (people[:, :, None] == people[:, None, :]) & (people[:, :, None] >= 0) + personal = people[:, PERSONAL_RELATIONS] + all_personal_same = np.all(personal == personal[:, :1], axis=1) + if condition in ("A", "B") and not all_personal_same.all(): + raise ValueError("Person aggregation was broken") + if condition == "A" and not np.all(companies == companies[:, :1]): + raise ValueError("A contains a broken employer/default link") + if condition in ("B", "C") and np.any(companies[:, 1] == companies[:, 2]): + raise ValueError("Unrelated default accidentally matches actual person's employer") + if condition == "C" and np.any( + np.sort(companies, axis=1)[:, 1:] == np.sort(companies, axis=1)[:, :-1] + ): + raise ValueError("C contains two facts with the same company origin") + pids = presentation_ids(world, ids) + slots = np.zeros((N_BASE, 7), dtype=np.int64) + for epoch in range(7): + arranged = apply_epoch(ids, world.seed, epoch) + for slot in range(7): + np.add.at(slots[:, slot], arranged[:, slot], 1) + if not np.array_equal(slots, np.repeat(expected_counts[:, None], 7, axis=1)): + raise ValueError("Per-fact positions are not balanced over seven epochs") + default_actual_same = world.answers[ids[:, 1]] == world.answers[ids[:, 2]] + conditions[condition] = { + "name": CONDITION_NAMES[condition], + "documents": len(ids), + "presentations": int(ids.size), + "unique_base_facts": int(np.count_nonzero(counts)), + "document_tokens": 42, + "supervised_tokens_per_document": 14, + "total_input_tokens_per_epoch": int(ids.size * 6), + "total_supervised_tokens_per_epoch": int(ids.size * 2), + "facts_sha256": array_hash(ids), + "presentation_ids_sha256": array_hash(pids), + "exposure_sha256": array_hash(counts), + "answer_histogram_sha256": array_hash(answers), + "seven_epoch_fact_slot_sha256": array_hash(slots), + "company_origin_cooccurrence": same_company.mean(axis=0).tolist(), + "person_origin_cooccurrence": same_person.mean(axis=0).tolist(), + "all_personal_same_fraction": float(all_personal_same.mean()), + "default_actual_same_answer_count": int(default_actual_same.sum()), + "default_actual_same_answer_rate": float(default_actual_same.mean()), + "relation_counts": { + relation: int((world.relation[ids] == i).sum()) + for i, relation in enumerate(RELATIONS) + }, + } + if not np.array_equal(documents["B"][:, 1:3], documents["C"][:, 1:3]): + raise ValueError("B and C must share exactly the same default/actual fact pairs") + return { + "schema": "bios-organization-v1", + "world_seed": world.seed, + "truth_sha256": array_hash(world.answers), + "relation_slot_order": list(RELATIONS), + "same_truth_and_per_fact_presentations": True, + "position_balance_period_epochs": 7, + "same_default_actual_pairs_B_C": True, + "templates_and_aliases": "symbolic tokens fixed; English view uses common presentations", + "conditions": conditions, + } + + +def english_fact(world, fact_id, variant=0): + """Readable supplemental view; this text is not used in symbolic training.""" + if not 0 <= fact_id < N_BASE: + raise ValueError("Expected a base fact") + relation = int(world.relation[fact_id]) + subject = ( + world.names["companies"][int(world.company[fact_id])] + if relation == 1 + else (world.names["people"][int(world.person[fact_id])]) + ) + kind, raw = world.token_labels[int(world.answers[fact_id])].split(":", 1) + fields = { + "company": "companies", + "city": "cities", + "university": "universities", + "major": "majors", + } + value = raw if kind == "date" else world.names[fields[kind]][int(raw)] + templates = ( + ("{s} works for {v}.", "{s}'s employer is {v}.", "{v} employs {s}."), + ( + "{s}'s default work city is {v}.", + "{s} uses {v} as the default work city.", + "The default work city for {s} is {v}.", + ), + ( + "{s}'s actual work city is {v}.", + "{s} actually works in {v}.", + "The actual work city of {s} is {v}.", + ), + ("{s} was born on {v}.", "{s}'s birth date is {v}.", "The birth date of {s} is {v}."), + ("{s} was born in {v}.", "{s}'s birth city is {v}.", "The birth city of {s} is {v}."), + ("{s} attended {v}.", "{s}'s university is {v}.", "{s} studied at {v}."), + ( + "{s} majored in {v}.", + "{s}'s academic major is {v}.", + "The academic major of {s} is {v}.", + ), + ) + return templates[relation][variant % 3].format(s=subject, v=value) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization_train.py new file mode 100644 index 0000000000000000000000000000000000000000..7c5d2bba261629aecc04944afd599bb827c634a8 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_organization_train.py @@ -0,0 +1,521 @@ +"""Matched A/B/C organization training; independent of the legacy SA/AS runs. + +An update contains 16 separate seven-fact causal documents and 28 isolated old +derived queries. Their supervised tokens are weighted 80:20. Each document is +a separate batch row, so attention never crosses document boundaries. +""" + +import argparse +import fcntl +import hashlib +import json +import math +import os +import platform +import random +import time +import traceback +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_data import ( + N_BASE, + N_PEOPLE, + N_QUERIES, + RELATIONS, + array_hash, + load_world, + rng_for, + write_json, +) +from .bios_model import CausalLM, ModelConfig, matmul_flops +from .bios_organization import apply_epoch, make_documents, render_documents +from .bios_train import code_fingerprint, evaluate, precision, tensor_data + +DOCUMENT_BATCH = 16 +DERIVED_BATCH = 28 +STEPS_PER_EPOCH = N_PEOPLE // DOCUMENT_BATCH +DEFAULT_STEPS = 14336 +WARMUP_EPOCHS = 16 +CHECKPOINTS = (0, 896, 1792, 3584, 7168, 10752, 14336, 21504, 28672) + + +def checkpoint_steps(steps): + if steps < 1: + raise ValueError("steps must be positive") + return sorted({step for step in CHECKPOINTS if step <= steps} | {steps}) + + +def derived_schedule(world_seed, steps, pool=None): + """Condition-independent stream; exhaust each permutation before repeating.""" + rng = rng_for(world_seed, 702) + size = steps * DERIVED_BATCH + pool = np.arange(N_BASE, N_QUERIES) if pool is None else np.asarray(pool) + if not len(pool) or len(np.unique(pool)) != len(pool): + raise ValueError("Derived pool must be nonempty and unique") + if np.any(pool < N_BASE) or np.any(pool >= N_QUERIES): + raise ValueError("Derived pool contains non-derived queries") + cycles = [rng.permutation(pool) for _ in range(math.ceil(size / len(pool)))] + return np.concatenate(cycles)[:size].reshape(steps, DERIVED_BATCH) + + +def learning_rate(step, base_lr): + # A constant rate within each complete epoch also matches per-fact LR exposure. + return base_lr * min((step // STEPS_PER_EPOCH + 1) / WARMUP_EPOCHS, 1.0) + + +def state_hash(state): + digest = hashlib.sha256() + for name, tensor in sorted(state.items()): + value = tensor.detach().cpu().contiguous() + digest.update(name.encode()) + digest.update(str(value.dtype).encode()) + digest.update(str(tuple(value.shape)).encode()) + digest.update(value.numpy().tobytes()) + return digest.hexdigest() + + +def schedule_hash(documents, world_seed, epochs): + digest = hashlib.sha256() + for epoch in range(epochs): + digest.update(np.ascontiguousarray(apply_epoch(documents, world_seed, epoch)).tobytes()) + return digest.hexdigest() + + +def update_flops(config): + return matmul_flops(config, DOCUMENT_BATCH, sequence=42, output_positions=14) + matmul_flops( + config, DERIVED_BATCH, sequence=6, output_positions=2 + ) + + +def two_context_backward(model, documents, isolated, derived_ids, device): + """Compute the exact per-token joint objective without retaining both graphs.""" + with precision(device): + logits = model(documents["tokens"], documents["positions"]) + doc_loss = F.cross_entropy(logits.float().flatten(0, 1), documents["labels"].flatten()) + (0.8 * doc_loss).backward() + with precision(device): + logits = model(isolated["tokens"][derived_ids], isolated["positions"][derived_ids]) + derived_loss = F.cross_entropy( + logits.float().flatten(0, 1), isolated["labels"][derived_ids].flatten() + ) + (0.2 * derived_loss).backward() + return doc_loss.detach(), derived_loss.detach() + + +def atomic_torch_save(value, path): + temporary = path.with_suffix(path.suffix + ".tmp") + torch.save(value, temporary) + os.replace(temporary, path) + + +def atomic_numpy_save(path, **arrays): + temporary = path.with_suffix(path.suffix + ".tmp") + with temporary.open("wb") as handle: + np.savez_compressed(handle, **arrays) + os.replace(temporary, path) + + +def core_sources(): + directory = Path(__file__).resolve().parent + names = ( + "bios_data.py", + "bios_model.py", + "bios_train.py", + "bios_organization.py", + "bios_organization_train.py", + ) + return {name: hashlib.sha256((directory / name).read_bytes()).hexdigest() for name in names} + + +def make_config(args, world, model, documents, derived): + steps = args.steps + epochs = math.ceil(steps / STEPS_PER_EPOCH) + return { + "protocol": "v2.4", + "dataset": "bios-organization-v1", + "phase": "development", + "run_kind": "full" + if steps == DEFAULT_STEPS and (args.width, args.layers, args.heads) == (768, 8, 12) + else "smoke", + "condition": args.condition, + "world_seed": world.seed, + "seed": args.seed, + "organization_seed": args.organization_seed, + "steps": steps, + "model": model.config_dict(), + "parameters": sum(p.numel() for p in model.parameters()), + "model_initial_sha256": state_hash(model.state_dict()), + "lr": args.lr, + "optimizer": "AdamW", + "weight_decay": 0.1, + "gradient_clip_norm": 1.0, + "warmup_epochs": WARMUP_EPOCHS, + "warmup_steps": WARMUP_EPOCHS * STEPS_PER_EPOCH, + "lr_rule": "constant within epoch: base_lr * min((epoch + 1) / 16, 1)", + "documents_per_step": DOCUMENT_BATCH, + "facts_per_document": 7, + "derived_queries_per_step": DERIVED_BATCH, + "document_weight": 0.8, + "derived_weight": 0.2, + "document_shape": {"sequence": 42, "supervised_positions": 14}, + "derived_shape": {"sequence": 6, "supervised_positions": 2}, + "context_objective": "answer+EOS only; same-document preceding facts visible causally", + "isolated_objective": "old-world derived QA only; no supporting document", + "cross_document_attention": False, + "evaluation": "all 14400 isolated queries; greedy value then generated EOS", + "steps_per_epoch": STEPS_PER_EPOCH, + "epochs": steps / STEPS_PER_EPOCH, + "checkpoints": checkpoint_steps(steps), + "truth_sha256": array_hash(world.answers), + "prompts_sha256": array_hash(world.prompts), + "lengths_sha256": array_hash(world.lengths), + "documents_sha256": array_hash(documents), + "document_schedule_sha256": schedule_hash(documents, world.seed, epochs), + "derived_schedule_sha256": array_hash(derived), + "planned_atomic_presentations": steps * 112, + "planned_derived_presentations": steps * 28, + "planned_total_presentations": steps * 140, + "planned_document_presentations": steps * DOCUMENT_BATCH, + "planned_input_tokens_including_padding": steps * (16 * 42 + 28 * 6), + "planned_supervised_tokens": steps * (16 * 14 + 28 * 2), + "planned_train_matmul_flops_estimate": steps * update_flops(model.config), + "flops_method": "executed dense/attention shapes; backward=2x forward; excludes " + "elementwise operations, evaluation, padding-free reinterpretation", + "core_source_sha256": core_sources(), + } + + +def run_locked(args, out): + torch.set_num_threads(args.threads) + torch.manual_seed(args.seed) + random.seed(args.seed) + np.random.seed(args.seed) + device = torch.device(args.device) + if device.type == "cuda": + torch.cuda.manual_seed_all(args.seed) + torch.backends.cuda.matmul.allow_tf32 = True + world = load_world(args.world) + documents = make_documents(world, args.condition, args.organization_seed) + from .bios_capacity import qa_split, split_metrics + + split_mode = getattr(args, "qa_split", "all") + train_ids, heldout_ids = qa_split(world, split_mode) + derived = derived_schedule(world.seed, args.steps, train_ids) + model = CausalLM(ModelConfig(world.vocab_size, args.width, args.layers, args.heads)).to(device) + config = make_config(args, world, model, documents, derived) + if getattr(args, "study", "legacy") == "capacity-v1": + config["core_source_sha256"]["bios_capacity.py"] = hashlib.sha256( + Path(__file__).with_name("bios_capacity.py").read_bytes() + ).hexdigest() + config.update( + { + "protocol": "v2.5-development", + "run_kind": "capacity-development", + "qa_split": split_mode, + "qa_train_ids": train_ids.tolist(), + "qa_heldout_ids": heldout_ids.tolist(), + "qa_split_policy": "half within company and old-exception stratum; world seed only", + "evaluation": "all base plus separately reported trained/heldout derived queries", + } + ) + config_path = out / "config.json" + if args.resume: + if not config_path.exists() or not (out / "resume.pt").exists(): + raise ValueError("Resume requires config.json and an atomic resume.pt checkpoint") + original = json.loads(config_path.read_text()) + differences = [key for key, value in config.items() if original.get(key) != value] + if differences: + raise ValueError("Resume configuration mismatch: " + ", ".join(differences)) + elif config_path.exists() or any(out.glob("model-*.pt")) or (out / "resume.pt").exists(): + raise ValueError("Output already contains a run; use a fresh directory or --resume") + else: + config.update( + { + "world": str(Path(args.world).resolve()), + "output": str(out.resolve()), + "execution": { + "device": args.device, + "threads": args.threads, + "torch": torch.__version__, + "python": platform.python_version(), + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "visible_devices": os.environ.get("CUDA_VISIBLE_DEVICES"), + "precision": "BF16 autocast on CUDA; FP32 weights/loss/Adam moments", + "deterministic_algorithms": torch.are_deterministic_algorithms_enabled(), + "allow_tf32": torch.backends.cuda.matmul.allow_tf32, + }, + **code_fingerprint(), + } + ) + write_json(config_path, config) + atomic_numpy_save(out / "schedule.npz", documents=documents, derived=derived) + optimizer = torch.optim.AdamW( + model.parameters(), lr=args.lr, weight_decay=0.1, fused=device.type == "cuda" + ) + isolated = tensor_data(world, device) + counts = np.zeros(N_QUERIES, dtype=np.int64) + slot_counts = np.zeros((N_BASE, 7), dtype=np.int64) + weighted_exposure = np.zeros(N_QUERIES, dtype=np.float64) + timeline, losses = [], [] + train_seconds, first_step = 0.0, 0 + if args.resume: + state = torch.load(out / "resume.pt", map_location="cpu", weights_only=False) + if state["config_sha256"] != hashlib.sha256(config_path.read_bytes()).hexdigest(): + raise ValueError("Resume checkpoint configuration fingerprint mismatch") + model.load_state_dict(state["model"]) + optimizer.load_state_dict(state["optimizer"]) + torch.set_rng_state(state["torch_rng"]) + if device.type == "cuda" and state["cuda_rng"] is not None: + torch.cuda.set_rng_state(state["cuda_rng"], device) + random.setstate(state["python_rng"]) + np.random.set_state(state["numpy_rng"]) + counts, slot_counts = state["counts"], state["slot_counts"] + weighted_exposure = state["weighted_exposure"] + timeline, train_seconds, first_step = ( + state["timeline"], + state["train_seconds"], + state["step"], + ) + resumes_path = out / "resumes.json" + resumes = json.loads(resumes_path.read_text()) if resumes_path.exists() else [] + resumes.append({"from_step": first_step, "device": args.device, **code_fingerprint()}) + write_json(resumes_path, resumes) + if (out / "failure.json").exists(): + os.replace(out / "failure.json", out / f"failure-before-resume-{len(resumes)}.json") + if device.type == "cuda": + torch.cuda.reset_peak_memory_stats(device) + cached_epoch, cached_documents = None, None + active_step = first_step + try: + for step in range(first_step, args.steps + 1): + active_step = step + if step in checkpoint_steps(args.steps) and not (args.resume and step == first_step): + started = time.perf_counter() + metrics, arrays = evaluate(model, isolated, world, batch_size=args.eval_batch_size) + if getattr(args, "study", "legacy") == "capacity-v1": + metrics.update(split_metrics(world, arrays, train_ids, heldout_ids)) + atomic_numpy_save( + out / f"predictions-{step}.npz", + **arrays, + exposure=counts, + slot_exposure=slot_counts, + lr_weighted_exposure=weighted_exposure, + ) + atomic_torch_save( + { + "model": { + key: value.detach().cpu() for key, value in model.state_dict().items() + }, + "config": model.config_dict(), + "step": step, + }, + out / f"model-{step}.pt", + ) + record = { + "step": step, + "epoch": step / STEPS_PER_EPOCH, + **metrics, + "train_seconds": train_seconds, + "train_matmul_flops_estimate": step * update_flops(model.config), + "presentations": int(counts.sum()), + "document_presentations": step * DOCUMENT_BATCH, + "base_presentations": int(counts[:N_BASE].sum()), + "derived_presentations": int(counts[N_BASE:].sum()), + "coverage_base": float((counts[:N_BASE] > 0).mean()), + "coverage_derived": float((counts[N_BASE:] > 0).mean()), + "world_tokens": int((counts * (world.lengths + 2)).sum()), + "input_tokens_including_padding": step * (16 * 42 + 28 * 6), + "supervised_tokens": step * (16 * 14 + 28 * 2), + "exposure_sha256": array_hash(counts), + "slot_exposure_sha256": array_hash(slot_counts), + "lr_weighted_exposure_sha256": array_hash(weighted_exposure), + "lr_weighted_exposure_by_relation": { + relation: float(weighted_exposure[world.relation == i].sum()) + for i, relation in enumerate((*RELATIONS, "derived")) + }, + "peak_cuda_bytes": torch.cuda.max_memory_allocated(device) + if device.type == "cuda" + else 0, + "eval_and_checkpoint_seconds": time.perf_counter() - started, + "mean_training_loss_since_previous": float(np.mean([x[0] for x in losses])) + if losses + else None, + "mean_context_document_loss": float(np.mean([x[1] for x in losses])) + if losses + else None, + "mean_isolated_derived_loss": float(np.mean([x[2] for x in losses])) + if losses + else None, + } + timeline.append(record) + write_json(out / "learning.json", timeline) + atomic_torch_save( + { + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "torch_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device) + if device.type == "cuda" + else None, + "python_rng": random.getstate(), + "numpy_rng": np.random.get_state(), + "timeline": timeline, + "counts": counts, + "slot_counts": slot_counts, + "weighted_exposure": weighted_exposure, + "train_seconds": train_seconds, + "step": step, + "config_sha256": hashlib.sha256(config_path.read_bytes()).hexdigest(), + }, + out / "resume.pt", + ) + losses = [] + print( + json.dumps( + { + "event": "checkpoint", + "step": step, + "base": metrics["base_accuracy"], + "derived": metrics["derived_accuracy"], + "train_seconds": train_seconds, + } + ), + flush=True, + ) + if step == args.steps: + break + epoch = step // STEPS_PER_EPOCH + if cached_epoch != epoch: + ordered = apply_epoch(documents, world.seed, epoch) + rendered = render_documents(world, ordered) + # One small epoch tensor transfer; training slices never join documents. + cached_documents = { + key: torch.as_tensor(rendered[key], device=device) + for key in ("tokens", "positions", "labels") + } + cached_epoch = epoch + offset = (step % STEPS_PER_EPOCH) * DOCUMENT_BATCH + batch = { + key: value[offset : offset + DOCUMENT_BATCH] + for key, value in cached_documents.items() + } + fact_ids = ordered[offset : offset + DOCUMENT_BATCH] + derived_ids = torch.as_tensor(derived[step], device=device) + lr = learning_rate(step, args.lr) + for group in optimizer.param_groups: + group["lr"] = lr + model.train() + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + doc_loss, derived_loss = two_context_backward( + model, batch, isolated, derived_ids, device + ) + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) + if not torch.isfinite(doc_loss + derived_loss) or not torch.isfinite(norm): + raise FloatingPointError("Nonfinite document/derived loss or gradient norm") + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + train_seconds += time.perf_counter() - started + dloss, qloss = float(doc_loss), float(derived_loss) + losses.append((0.8 * dloss + 0.2 * qloss, dloss, qloss)) + np.add.at(counts, fact_ids.ravel(), 1) + np.add.at(counts, derived[step], 1) + np.add.at(slot_counts, (fact_ids, np.arange(7)[None, :]), 1) + np.add.at(weighted_exposure, fact_ids.ravel(), lr) + np.add.at(weighted_exposure, derived[step], lr) + if (step + 1) % 100 == 0: + print( + json.dumps( + { + "event": "progress", + "step": step + 1, + "epoch": (step + 1) / STEPS_PER_EPOCH, + "loss": float(np.mean([x[0] for x in losses[-100:]])), + "train_seconds": train_seconds, + } + ), + flush=True, + ) + write_json( + out / "complete.json", + { + "step": args.steps, + "status": "complete", + "final": timeline[-1], + "exposure_sha256": array_hash(counts), + "slot_exposure_sha256": array_hash(slot_counts), + "model_final_sha256": state_hash(model.state_dict()), + }, + ) + except BaseException as error: + write_json( + out / "failure.json", + { + "step": active_step, + "reason": str(error), + "type": type(error).__name__, + "traceback": traceback.format_exc(), + "train_seconds": train_seconds, + "last_committed_checkpoint": timeline[-1]["step"] if timeline else None, + }, + ) + raise + + +def train(args): + checkpoint_steps(args.steps) + if ( + getattr(args, "qa_split", "all") != "all" + and getattr(args, "study", "legacy") != "capacity-v1" + ): + raise ValueError("Heldout QA requires explicit capacity study") + if args.width < 1 or args.layers < 1 or args.heads < 1 or args.width % args.heads: + raise ValueError("Model dimensions must be positive and width divisible by heads") + if args.lr <= 0 or not math.isfinite(args.lr): + raise ValueError("Learning rate must be finite and positive") + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + with (out / ".train.lock").open("a") as lock: + try: + fcntl.flock(lock.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError as error: + raise RuntimeError("Another process is training in this output directory") from error + run_locked(args, out) + + +def parser(): + result = argparse.ArgumentParser(description=__doc__) + result.add_argument("--world", required=True) + result.add_argument("--output", required=True) + result.add_argument("--condition", choices=("A", "B", "C"), required=True) + result.add_argument("--seed", type=int, default=0) + result.add_argument("--organization-seed", type=int, default=0) + result.add_argument("--steps", type=int, default=DEFAULT_STEPS) + result.add_argument("--lr", type=float, default=1e-4) + result.add_argument("--device", default="cuda") + result.add_argument("--threads", type=int, default=4) + result.add_argument("--eval-batch-size", type=int, default=512) + result.add_argument("--width", type=int, default=768) + result.add_argument("--layers", type=int, default=8) + result.add_argument("--heads", type=int, default=12) + result.add_argument("--study", choices=("legacy", "capacity-v1"), default="legacy") + result.add_argument("--qa-split", choices=("all", "half"), default="all") + result.add_argument("--resume", action="store_true") + return result + + +def main(): + train(parser().parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_data.py new file mode 100644 index 0000000000000000000000000000000000000000..98352c46d29112ab2ac2be7212204897c13aea18 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_data.py @@ -0,0 +1,455 @@ +"""Pinned six-attribute bioS reconstruction for plan 14.27 (not the old graph).""" + +from __future__ import annotations + +import ast +import calendar +import hashlib +import json +import random +from collections import Counter +from pathlib import Path + +import numpy as np + +SOURCE = Path("data/bios-source") +MATERIAL = SOURCE / "data-synthetic-pretrain/Capo-bioS-bioR" +SOURCE_CODE = MATERIAL / "Capo-bioS-bioR.py" +MONTHS = list(calendar.month_name)[1:] +ATTRS = ("date", "birthcity", "university", "field", "workcity", "company") +TASKS = (*ATTRS, "year", "parity", "company_city", "city_company", "comparison") + +# View 0 of the first six tasks is the question wording in Part 3.1, section 2.2. +# Additional tasks and views are an explicit measurement adaptation. +QUESTIONS = { + "date": [ + "What is the birth date of {n}?", + "On what date was {n} born?", + "Give {n}'s full date of birth.", + "When was {n} born?", + "State the birthday, including the year, of {n}.", + "What is {n}'s complete birth date?", + ], + "birthcity": [ + "What is the birth city of {n}?", + "In which city was {n} born?", + "Give {n}'s city of birth.", + "Where was {n} born?", + "Name the birthplace city of {n}.", + "What city is {n}'s birthplace?", + ], + "university": [ + "Which university did {n} study?", + "Where did {n} attend university?", + "Give the university attended by {n}.", + "At which university did {n} study?", + "Name {n}'s university.", + "What university educated {n}?", + ], + "field": [ + "What major did {n} study?", + "What was {n}'s field of study?", + "Give {n}'s university major.", + "In what subject did {n} major?", + "Name the discipline studied by {n}.", + "Which subject did {n} study at university?", + ], + "company": [ + "Which company did {n} work for?", + "Who was {n}'s employer?", + "Give the company employing {n}.", + "At what company did {n} work?", + "Name {n}'s employer.", + "What is the name of the company where {n} worked?", + ], + "workcity": [ + "Where did {n} work?", + "In which city did {n} work?", + "Give {n}'s work city.", + "What city was {n}'s employer based in?", + "Name the city of {n}'s workplace.", + "What was {n}'s city of employment?", + ], + "year": [ + "What is the birth year of {n}?", + "In which year was {n} born?", + "Give only {n}'s birth year.", + "Name the year in {n}'s date of birth.", + "What year marks {n}'s birth?", + "State the year of birth for {n}.", + ], + "parity": [ + "Was {n} born in an even-numbered month?", + "Is {n}'s birth month number even?", + "Does the month of {n}'s birth have an even number?", + "Is the calendar month when {n} was born even-numbered?", + "For {n}, is the birth month one of months 2, 4, 6, 8, 10, or 12?", + "Is the number of {n}'s birth month divisible by two?", + ], + "company_city": [ + "Give {n}'s company, then work city.", + "Name the employer of {n}, followed by its city.", + "For {n}, list company before workplace city.", + "What company employed {n}, and in what city?", + "State {n}'s company and city, in that order.", + "Report {n}'s employer first and work city second.", + ], + "city_company": [ + "Give {n}'s work city, then company.", + "Name the work city of {n}, followed by the employer.", + "For {n}, list workplace city before company.", + "In what city did {n} work, and for what company?", + "State {n}'s work city and company, in that order.", + "Report {n}'s work city first and employer second.", + ], + "comparison": [ + "Who was born earlier, {a} or {b}?", + "Which was born first: {a} or {b}?", + "Between {a} and {b}, name the older person.", + "Whose date of birth is earlier, {a}'s or {b}'s?", + "Compare the birthdays of {a} and {b}. Who is older?", + "Of {a} and {b}, who has the earlier birthday including the year?", + ], +} + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def write_json(path, obj): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temp = path.with_suffix(path.suffix + ".tmp") + temp.write_text(json.dumps(obj, indent=2, ensure_ascii=False) + "\n") + temp.replace(path) + + +def load_json(path): + return json.loads(Path(path).read_text()) + + +def verify_source(): + manifest = load_json("configs/bios-source-manifest.json") + for row in manifest["files"]: + if digest(SOURCE / row["path"]) != row["sha256"]: + raise ValueError(f"Official source changed: {row['path']}") + return manifest + + +def source_templates(): + """Read literal templates without importing or changing the upstream source.""" + tree = ast.parse(SOURCE_CODE.read_text()) + fn = next( + n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == "get_text_simple3" + ) + values = {} + for node in fn.body: + if isinstance(node, ast.Assign) and isinstance(node.targets[0], ast.Name): + name = node.targets[0].id + if name.startswith("sentence_structures"): + values[int(name[-1]) - 1] = ast.literal_eval(node.value) + return [values[i] for i in range(6)] + + +def date(p): + return f"{MONTHS[p['month'] - 1]} {p['day']}, {p['year']}" + + +def date_key(p): + return p["year"], p["month"], p["day"] + + +def render_sentences(p, templates, ids, order=range(6)): + fields = dict( + birthday=date(p), + birthcity=p["birthcity"], + university=p["university"], + field=p["field"], + company1city=p["workcity"], + company1name=p["company"], + ) + return [ + " " + templates[a][ids[a]].format(name=p["name"] if j == 0 else p["pronoun"], **fields) + for j, a in enumerate(order) + ] + + +def make_people(seed, count): + if count % 10: + raise ValueError("Population must permit exact 50/10/40 splits") + rng = random.Random(seed) + pools = { + key: (MATERIAL / "fields" / f"{key}.txt").read_text().splitlines() + for key in ( + "first_name", + "middle_name", + "last_name", + "city", + "university", + "field", + "company", + ) + } + names, people = set(), [] + for i in range(count): + while True: + name_ids = [ + rng.randrange(len(pools[k])) for k in ("first_name", "middle_name", "last_name") + ] + name = " ".join( + pools[k][v] + for k, v in zip(("first_name", "middle_name", "last_name"), name_ids, strict=True) + ) + if name not in names: + names.add(name) + break + indices = { + k: rng.randrange(len(pools[k])) for k in ("city", "university", "field", "company") + } + company, city = [s.strip() for s in pools["company"][indices["company"]].split(";", 1)] + people.append( + dict( + id=i, + name=name, + name_ids=name_ids, + attribute_ids=indices, + year=rng.randrange(1900, 2100), + month=rng.randrange(1, 13), + day=rng.randrange(1, 29), + birthcity=pools["city"][indices["city"]], + university=pools["university"][indices["university"]], + field=pools["field"][indices["field"]], + company=company, + workcity=city, + pronoun="He" if i % 2 == 0 else "She", + ) + ) + ids = list(range(count)) + random.Random(seed + 1000000).shuffle(ids) + for j, i in enumerate(ids): + people[i]["split"] = ( + "train" if j < count // 2 else ("dev" if j < 6 * count // 10 else "test") + ) + # One balanced comparison row per person. Both participants stay in the same split. + for split in ("train", "dev", "test"): + indices = [p["id"] for p in people if p["split"] == split] + random.Random(seed + len(indices)).shuffle(indices) + for j in range(0, len(indices), 2): + a, b = indices[j : j + 2] + if date_key(people[a]) == date_key(people[b]): + for k in range(j + 2, len(indices)): + c = indices[k] + if date_key(people[a]) != date_key(people[c]): + indices[j + 1], indices[k] = indices[k], indices[j + 1] + b = c + break + else: + raise ValueError("Equal-date terminal pair; choose a new prespecified seed") + people[a]["partner"] = b + people[b]["partner"] = a + return people + + +def answer(p, task, other=None): + if task == "date": + return date(p) + if task == "year": + return str(p["year"]) + if task == "parity": + return "yes" if p["month"] % 2 == 0 else "no" + if task == "company_city": + return f"{p['company']}; {p['workcity']}" + if task == "city_company": + return f"{p['workcity']}; {p['company']}" + if task == "comparison": + return min((p, other), key=date_key)["name"] + return p[task] + + +def question(p, task, view=0, other=None, cot=False): + q = QUESTIONS[task][view].format(n=p["name"], a=p["name"], b=other["name"] if other else "") + return "Question: " + q + (" Explain briefly." if cot else "") + "\nAnswer:" + + +def reasoning(p, task, other=None): + value = answer(p, task, other) + if task == "parity": + return ( + f"{date(p)}; {MONTHS[p['month'] - 1]} is month {p['month']}; " + f"{p['month']} is {'even' if p['month'] % 2 == 0 else 'odd'}; Answer: {value}" + ) + if task == "comparison": + return f"{p['name']}: {date(p)}; {other['name']}: {date(other)}; Answer: {value}" + if task == "year": + return f"{date(p)}; the year is {p['year']}; Answer: {value}" + if task in ("company_city", "city_company"): + return f"company: {p['company']}; work city: {p['workcity']}; Answer: {value}" + return f"{task}: {value}; Answer: {value}" + + +def edit_cases(people, seed): + rng = random.Random(seed + 3000000) + groups = [ + [p for p in people if p["split"] == "test" and p["month"] % 2 == parity] + for parity in (0, 1) + ] + selected = rng.sample(groups[0], 8) + rng.sample(groups[1], 8) + result = [] + for p in selected: + month = rng.choice([m for m in range(1, 13) if m % 2 != p["month"] % 2]) + year = rng.choice([y for y in range(1900, 2100) if y != p["year"]]) + result.append( + dict( + person_id=p["id"], + old_month=p["month"], + old_year=p["year"], + new_month=month, + new_year=year, + day=p["day"], + cells=[ + dict(month=m, year=y) + for m, y in ( + (p["month"], p["year"]), + (month, p["year"]), + (p["month"], year), + (month, year), + ) + ], + ) + ) + return result + + +def prepare_world(cfg, seed, tokenizer): + root = Path(cfg["data_root"]) / f"world-{seed}" + if (root / "audit.json").exists(): + audit = load_json(root / "audit.json") + for f, h in audit["files"].items(): + if digest(root / f) != h: + raise ValueError(f"Data changed: {root / f}") + return audit + root.mkdir(parents=True, exist_ok=True) + manifest = verify_source() + source_hash = digest(SOURCE_CODE) + templates = source_templates() + people = make_people(seed, cfg["people"]) + write_json(root / "people.json", people) + write_json(root / "edit-cases.json", edit_cases(people, seed)) + write_json(root / "questions.json", QUESTIONS) + rng = random.Random(seed + 2000000) + template_ids = np.empty((len(people), 5, 6), dtype=np.int16) + # Store separately tokenized full-name/pronoun sentences; no splitting at periods. + # This preserves abbreviations in company names and city names. + all_ids, lengths = [], [] + with (root / "biographies.jsonl").open("w") as out: + for p in people: + for variant in range(5): + ids = [rng.randrange(len(t)) for t in templates] + template_ids[p["id"], variant] = ids + sentences = render_sentences(p, templates, ids) + out.write( + json.dumps( + dict( + person_id=p["id"], + variant=variant, + template_ids=ids, + order=list(ATTRS), + source_sha256=source_hash, + text="".join(sentences), + ) + ) + + "\n" + ) + for a in range(6): + # Force this attribute first, and then second, to obtain both name forms. + full = render_sentences(p, templates, ids, [a])[0] + pro = render_sentences(p, templates, ids, [(a + 1) % 6, a])[1] + for text in (full, pro): + enc = tokenizer.encode(text).ids + all_ids.append(enc) + lengths.append(len(enc)) + max_len = max(lengths) + packed = np.zeros((len(all_ids), max_len), dtype=np.uint16) + for i, tokens in enumerate(all_ids): + packed[i, : len(tokens)] = tokens + np.save(root / "sentence-tokens.npy", packed.reshape(len(people), 5, 6, 2, max_len)) + np.save( + root / "sentence-lengths.npy", + np.array(lengths, dtype=np.int16).reshape(len(people), 5, 6, 2), + ) + np.save(root / "template-ids.npy", template_ids) + assert len({p["name"] for p in people}) == len(people) + for p in people: + assert people[p["partner"]]["split"] == p["split"] + assert date_key(p) != date_key(people[p["partner"]]) + counts = Counter(p["split"] for p in people) + for task in TASKS: + assert len(QUESTIONS[task]) == len(set(QUESTIONS[task])) == 6 + files = [ + "people.json", + "edit-cases.json", + "questions.json", + "biographies.jsonl", + "sentence-tokens.npy", + "sentence-lengths.npy", + "template-ids.npy", + ] + audit = dict( + seed=seed, + people=len(people), + splits=dict(counts), + source_revision=manifest["revision"], + source_sha256=digest(SOURCE_CODE), + template_counts=dict(zip(ATTRS, map(len, templates), strict=True)), + variants=5, + facts_per_person=6, + passes=540, + tasks_per_train_person=11, + train_rows=counts["train"] * 11, + qa_training_views=[0], + globally_held_out_views=list(range(1, 6)), + equal_date_comparisons=0, + cross_split_comparisons=0, + comparison_first_answer_fraction={ + s: np.mean( + [date_key(p) < date_key(people[p["partner"]]) for p in people if p["split"] == s] + ).item() + for s in counts + }, + city_collisions=sum(p["birthcity"] == p["workcity"] for p in people), + max_sentence_tokens=max_len, + files={f: digest(root / f) for f in files}, + ) + write_json(root / "audit.json", audit) + return audit + + +class BioStream: + """One deterministic pass presents every person exactly once, including the tail.""" + + def __init__(self, root, seed, condition): + self.tokens = np.load(Path(root) / "sentence-tokens.npy", mmap_mode="r") + self.lengths = np.load(Path(root) / "sentence-lengths.npy", mmap_mode="r") + self.seed, self.condition = seed, condition + self.count = self.tokens.shape[0] + + def pass_tokens(self, epoch): + rng = np.random.default_rng(np.random.SeedSequence([self.seed, epoch, 1427])) + people = rng.permutation(self.count) + stream = [50256] + order_hash = hashlib.sha256() + for pid in people: + variant = 0 if self.condition == "S" else (epoch + int(pid)) % 5 + order = rng.permutation(6) if self.condition == "MP" else np.arange(6) + order_hash.update(np.array([pid, variant, *order], dtype=np.int64).tobytes()) + for j, attr in enumerate(order): + form = int(j != 0) + size = self.lengths[pid, variant, attr, form] + stream.extend(self.tokens[pid, variant, attr, form, :size]) + stream.append(50256) + return np.asarray(stream, dtype=np.int64), order_hash.hexdigest() + + def exact_token_budget(self, passes): + # Permuting only changes which sentence uses the full name; sum its exact sizes. + return sum(len(self.pass_tokens(e)[0]) - 1 for e in range(passes)) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_diagnostics.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_diagnostics.py new file mode 100644 index 0000000000000000000000000000000000000000..dc0de9f1aeb4e6e8a48ea33b265811985ebea4d8 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_diagnostics.py @@ -0,0 +1,463 @@ +"""Frozen endpoint diagnostics for bioS; no training and no ground-truth auto inputs.""" + +from __future__ import annotations + +import calendar +import json +import os +import random +import re +import time +from collections import defaultdict +from pathlib import Path + +import torch +from tokenizers import Tokenizer + +from .bios_original_data import ATTRS, TASKS, answer, date, digest, load_json, question, write_json +from .bios_original_train import ( + amp, + encode_row, + generate, + load_model, + normalize, + sequence_scores, + setup, +) + +DEFAULT_ROOT = "docs/development-artifacts/bios-original-diagnostics-v1" +TASK_PAIR = ("parity", "comparison") + + +def select_people(people, world, count=24): + """Sample whole development partner pairs without model-dependent filtering.""" + if count % 2: + raise ValueError("The development count must consist of whole pairs") + pairs = [ + (p["id"], p["partner"]) for p in people if p["split"] == "dev" and p["id"] < p["partner"] + ] + pairs = random.Random(world + 930001).sample(pairs, count // 2) + return sorted(i for pair in pairs for i in pair) + + +def parse_date(text): + """Strict full-string date parser; malformed generations remain failures.""" + text = normalize(text) + names = {name.casefold(): i for i, name in enumerate(calendar.month_name) if i} + match = re.fullmatch(r"([a-z]+) ([1-9]|1\d|2[0-8]), (\d{4})", text) + if match is None or match[1] not in names: + return None + return (int(match[3]), names[match[1]], int(match[2])) + + +def operation_prompt(task, first, second=None): + """Exact rule-training prompt; only supplied strings enter this function.""" + if task == "parity": + parsed = parse_date(first) + month = calendar.month_name[parsed[1]] if parsed else first + return f"Question: Is {month} an even-numbered month?\nAnswer:" + if task == "comparison": + return f"Question: Which date is earlier, {first} or {second}?\nAnswer:" + raise ValueError(task) + + +def decode_operation(task, generated, first, second=None, names=None): + """Map a model-selected supplied date to its name without consulting truth.""" + if task == "parity": + return normalize(generated) + chosen = normalize(generated) + values = [normalize(first), normalize(second)] + if values[0] == values[1] or chosen not in values: + return None + return names[values.index(chosen)] + + +def symbolic_operation(task, first, second=None, names=None): + """A separately labelled host-computation ceiling, never a model result.""" + a = parse_date(first) + if a is None: + return None + if task == "parity": + return "yes" if a[1] % 2 == 0 else "no" + b = parse_date(second) + if b is None or a == b: + return None + return names[0 if a < b else 1] + + +def audit_batches(people, tasks, cot, batch_size): + """Select one original physical batch per split, independent of predictions.""" + eligible = [p for p in people if p["split"] in ("dev", "test")] + rows_per_person = len(tasks) * 6 * (2 if cot else 1) + starts = set() + for split in ("dev", "test"): + person_index = next(i for i, p in enumerate(eligible) if p["split"] == split) + starts.add((person_index * rows_per_person // batch_size) * batch_size) + return sorted(starts) + + +def read_selected_batches(path, starts, batch_size): + batches = {s: [] for s in starts} + with Path(path).open() as stream: + for i, line in enumerate(stream): + for s in starts: + if s <= i < s + batch_size: + batches[s].append(dict(load_json_line=json.loads(line), source_row=i)) + if i >= max(starts) + batch_size - 1: + break + if any(len(rows) != batch_size for rows in batches.values()): + raise ValueError("Incomplete historical physical batch") + return [dict(start=s, rows=rows) for s, rows in batches.items()] + + +def prepare(config_path, root=DEFAULT_ROOT, count=24): + root = Path(root) + if (root / "plan.json").exists(): + raise FileExistsError("Diagnostic inputs already frozen") + cfg = load_json(config_path) + source_files = [ + "src/llm_memory_editability/bios_original_diagnostics.py", + "scripts/run_bios_original_diagnostics.py", + "src/llm_memory_editability/bios_original_data.py", + "src/llm_memory_editability/bios_original_model.py", + "src/llm_memory_editability/bios_original_train.py", + ] + # Loading current implementations is valid only if original implementations match. + frozen = Path(cfg["result_root"]) / "execution-source" + for file in source_files[2:]: + if digest(file) != digest(frozen / file): + raise ValueError(f"Original source changed: {file}") + plan = dict( + version=1, + created_unix=time.time(), + config_path=str(config_path), + config_sha256=digest(config_path), + config=cfg, + count=count, + views=[0, 1], + diagnostic_batch_size=16, + audit_batch_size=cfg["evaluation"]["batch_size"], + max_new_tokens=cfg["evaluation"]["max_new_tokens"], + source_sha256={f: digest(f) for f in source_files}, + tokenizer_sha256=digest(Path(cfg["data_root"]) / "tokenizer/tokenizer.json"), + worlds={}, + endpoints=[], + ) + for world in cfg["world_seeds"]: + data_path = Path(cfg["data_root"]) / f"world-{world}/people.json" + people = load_json(data_path) + plan["worlds"][str(world)] = dict( + person_ids=select_people(people, world, count), + people_path=str(data_path), + sha256=digest(data_path), + ) + for init in cfg["initialization_seeds"]: + for condition in cfg["task"]["conditions"]: + stages = ["adapt", "task"] if condition in ("S", "M", "MP") else ["task"] + for stage in stages: + path = ( + Path(cfg["result_root"]) / f"world-{world}/init-{init}/{condition}/{stage}" + ) + complete = load_json(path / "complete.json") + evaluation = load_json(path / "evaluation/evaluation-complete.json") + if complete["checkpoint_sha256"] != evaluation["checkpoint_sha256"]: + raise ValueError("Checkpoint/evaluation hash disagreement") + endpoint_id = f"world-{world}-{condition}-{stage}" + tasks = ATTRS if stage == "adapt" else TASKS + cot = stage == "task" and condition == "MP-CoT" + selected = read_selected_batches( + path / "evaluation/predictions.jsonl", + audit_batches(people, tasks, cot, plan["audit_batch_size"]), + plan["audit_batch_size"], + ) + sample = root / "audit-inputs" / f"{endpoint_id}.json" + write_json(sample, selected) + plan["endpoints"].append( + dict( + id=endpoint_id, + world=world, + init=init, + condition=condition, + stage=stage, + checkpoint=str(path / "final.pt"), + checkpoint_sha256=complete["checkpoint_sha256"], + audit_sample=str(sample), + audit_sample_sha256=digest(sample), + ) + ) + write_json(root / "plan.json", plan) + return plan + + +def verify_plan(plan): + for path, sha in plan["source_sha256"].items(): + if digest(path) != sha: + raise ValueError(f"Frozen diagnostic source changed: {path}") + for data in plan["worlds"].values(): + if digest(data["people_path"]) != data["sha256"]: + raise ValueError("People data changed") + + +def run_audit(model, tok, endpoint, plan, output, device): + sample = Path(endpoint["audit_sample"]) + if digest(sample) != endpoint["audit_sample_sha256"]: + raise ValueError("Audit inputs changed") + report = [] + for batch in load_json(sample): + rows = [r["load_json_line"] for r in batch["rows"]] + encoded = [encode_row(tok, r["prompt"], r["answer"]) for r in rows] + with torch.no_grad(), amp(device): + avg, full = sequence_scores(model, encoded, device) + generated, ended = generate( + model, tok, [r["prompt"] for r in rows], device, plan["max_new_tokens"] + ) + for original, text, eos, mean_lp, full_lp in zip( + batch["rows"], generated, ended, avg.tolist(), full.tolist(), strict=True + ): + old = original["load_json_line"] + extracted = text.rsplit("Answer:", 1)[-1].strip() if old["cot"] else text + report.append( + dict( + source_row=original["source_row"], + physical_batch_start=batch["start"], + original=old, + reloaded_generated=text, + reloaded_eos=eos, + generated_identical=text == old["generated"], + eos_identical=eos == old["eos"], + correctness_identical=(normalize(extracted) == normalize(old["answer"])) + == old["correct"], + mean_logp_difference=mean_lp - old["answer_mean_logp"], + full_logp_difference=full_lp - old["answer_full_logp"], + ) + ) + write_json(output / "audit-rows.json", report) + summary = dict( + rows=len(report), + generation_mismatches=sum(not r["generated_identical"] for r in report), + eos_mismatches=sum(not r["eos_identical"] for r in report), + correctness_mismatches=sum(not r["correctness_identical"] for r in report), + max_abs_full_logp_difference=max(abs(r["full_logp_difference"]) for r in report), + exact_original_batch=True, + precision="FP32 parameters, BF16 autocast, TF32 enabled", + ) + summary["status"] = ( + "passed" + if all( + summary[k] == 0 + for k in ("generation_mismatches", "eos_mismatches", "correctness_mismatches") + ) + and summary["max_abs_full_logp_difference"] <= 1e-4 + else "discrepancy" + ) + write_json(output / "audit-summary.json", summary) + return summary + + +def generate_rows(model, tok, rows, plan, device): + for start in range(0, len(rows), plan["diagnostic_batch_size"]): + batch = rows[start : start + plan["diagnostic_batch_size"]] + outputs, ended = generate( + model, tok, [r["prompt"] for r in batch], device, plan["max_new_tokens"] + ) + for row, text, eos in zip(batch, outputs, ended, strict=True): + row.update(generated=text, eos=eos) + print( + json.dumps( + dict(generation_done=min(start + len(batch), len(rows)), generation_total=len(rows)) + ), + flush=True, + ) + + +def run_diagnostics(model, tok, endpoint, plan, output, device): + world = plan["worlds"][str(endpoint["world"])] + people = load_json(world["people_path"]) + selected = [people[i] for i in world["person_ids"]] + extraction = [ + dict(person_id=p["id"], view=v, prompt=question(p, "date", v), target=date(p)) + for p in selected + for v in plan["views"] + ] + generate_rows(model, tok, extraction, plan, device) + lookup = {} + for row in extraction: + row.update( + parseable=parse_date(row["generated"]) is not None, + correct=normalize(row["generated"]) == normalize(row["target"]), + ) + lookup[row["person_id"], row["view"]] = row + write_json(output / "extractions.json", extraction) + rows = [] + for p in selected: + other = people[p["partner"]] + for task in TASK_PAIR: + for view in plan["views"]: + base = dict( + person_id=p["id"], + partner=other["id"], + view=view, + task=task, + target=answer(p, task, other), + ) + for cot in (False, True): + rows.append( + dict( + base, + mode="cot" if cot else "direct", + prompt=question(p, task, view, other, cot), + cot_trained=endpoint["condition"] == "MP-CoT", + ) + ) + for mode in ("oracle_rule", "autonomous_rule"): + a = date(p) if mode == "oracle_rule" else lookup[p["id"], view]["generated"] + b = ( + date(other) + if mode == "oracle_rule" + else lookup[other["id"], view]["generated"] + ) + parsed = parse_date(a) is not None and ( + task != "comparison" or parse_date(b) is not None + ) + valid = normalize(a) == normalize(date(p)) and ( + task != "comparison" or normalize(b) == normalize(date(other)) + ) + symbolic = symbolic_operation(task, a, b, (p["name"], other["name"])) + rows.append( + dict( + base, + mode=mode, + prompt=operation_prompt(task, a, b), + supplied_dates=[a, b] if task == "comparison" else [a], + inputs_parseable=parsed, + inputs_correct=valid, + symbolic_prediction=symbolic, + symbolic_correct=symbolic is not None + and normalize(symbolic) == normalize(base["target"]), + ) + ) + generate_rows(model, tok, rows, plan, device) + totals = defaultdict(lambda: defaultdict(int)) + for row in rows: + p, other = people[row["person_id"]], people[row["partner"]] + if row["mode"] in ("direct", "cot"): + pred = ( + row["generated"].rsplit("Answer:", 1)[-1].strip() + if row["mode"] == "cot" + else row["generated"] + ) + else: + dates = row["supplied_dates"] + pred = decode_operation( + row["task"], + row["generated"], + dates[0], + dates[1] if len(dates) == 2 else None, + (p["name"], other["name"]), + ) + row["prediction"] = pred + row["output_in_question_pair"] = ( + pred is not None and normalize(pred) in (normalize(p["name"]), normalize(other["name"])) + if row["task"] == "comparison" + else None + ) + if row["task"] == "comparison" and row["mode"] in ("oracle_rule", "autonomous_rule"): + row["output_is_supplied_date"] = normalize(row["generated"]) in { + normalize(value) for value in row["supplied_dates"] + } + row["correct"] = pred is not None and normalize(pred) == normalize(row["target"]) + row["correct_with_eos"] = row["correct"] and row["eos"] + key = f"{row['task']}/view-{row['view']}/{row['mode']}" + total = totals[key] + total["n"] += 1 + total["correct"] += row["correct"] + total["correct_with_eos"] += row["correct_with_eos"] + if row["task"] == "comparison": + total["output_in_question_pair"] += row["output_in_question_pair"] + if "output_is_supplied_date" in row: + total["output_is_supplied_date"] += row["output_is_supplied_date"] + if row["mode"] == "autonomous_rule": + for condition in ("inputs_parseable", "inputs_correct"): + total[condition + "_n"] += row[condition] + total[condition + "_correct"] += row[condition] and row["correct"] + total["symbolic_correct"] += row["symbolic_correct"] + with (output / "diagnostics.jsonl").open("w") as stream: + for row in rows: + stream.write(json.dumps(row) + "\n") + summary = dict( + rows=len(rows), + extraction_rows=len(extraction), + extraction_correct=sum(r["correct"] for r in extraction), + extraction_parseable=sum(r["parseable"] for r in extraction), + totals=dict(totals), + people=len(selected), + independent_partner_pairs=len(selected) // 2, + split="development", + no_training=True, + limitations=[ + "Oracle and autonomous rules use externally supplied text and a changed prompt.", + "Non-MP-CoT models did not train on the CoT instruction.", + "Host date-to-name mapping and symbolic ceilings are not model reasoning.", + "Twenty-four people are a fixed diagnostic subset, not population estimates.", + ], + ) + write_json(output / "diagnostic-summary.json", summary) + return summary + + +def run_endpoint(root, endpoint_id, device="cuda:0", memory_fraction=0.045): + root = Path(root) + plan = load_json(root / "plan.json") + verify_plan(plan) + endpoint = next(e for e in plan["endpoints"] if e["id"] == endpoint_id) + output = root / "endpoints" / endpoint_id + if (output / "complete.json").exists(): + return load_json(output / "complete.json") + output.mkdir(parents=True, exist_ok=True) + if digest(endpoint["checkpoint"]) != endpoint["checkpoint_sha256"]: + raise ValueError("Checkpoint changed") + cfg = plan["config"] + setup(endpoint["init"], device) + if str(device).startswith("cuda"): + torch.cuda.set_per_process_memory_fraction(memory_fraction, device) + torch.cuda.reset_peak_memory_stats(device) + tok_path = Path(cfg["data_root"]) / "tokenizer/tokenizer.json" + if digest(tok_path) != plan["tokenizer_sha256"]: + raise ValueError("Tokenizer changed") + tok = Tokenizer.from_file(str(tok_path)) + start = time.monotonic() + model = load_model(endpoint["checkpoint"], cfg, device, adapters=True).eval() + model.requires_grad_(False) + write_json( + output / "running.json", + dict( + endpoint=endpoint_id, + started_unix=time.time(), + pid=os.getpid(), + device=device, + cuda_visible_devices=os.environ.get("CUDA_VISIBLE_DEVICES"), + memory_fraction=memory_fraction, + shared_gpu=True, + torch_version=torch.__version__, + ), + ) + audit = run_audit(model, tok, endpoint, plan, output, device) + diagnostics = ( + run_diagnostics(model, tok, endpoint, plan, output, device) + if endpoint["stage"] == "task" + else None + ) + result = dict( + endpoint=endpoint, + seconds=time.monotonic() - start, + audit=audit, + diagnostics=diagnostics, + shared_gpu=True, + memory_fraction=memory_fraction, + cuda_visible_devices=os.environ.get("CUDA_VISIBLE_DEVICES"), + peak_allocated_bytes=torch.cuda.max_memory_allocated(device) + if str(device).startswith("cuda") + else None, + ) + write_json(output / "complete.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_model.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_model.py new file mode 100644 index 0000000000000000000000000000000000000000..039ceaef72cf7fefa38bb094dbefbe9f7e88d651 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_model.py @@ -0,0 +1,130 @@ +"""GPT-2 blocks, quarter-head NeoX RoPE, tied vocabulary, explicit Q/V/embedding LoRA.""" + +from __future__ import annotations + +import math + +import torch +from torch import nn +from torch.nn import functional as F + + +class Attention(nn.Module): + def __init__(self, cfg): + super().__init__() + width = cfg["width"] + self.heads = cfg["heads"] + self.dim = width // self.heads + self.rotary_dim = int(self.dim * cfg["rotary_fraction"]) + assert self.rotary_dim % 2 == 0 and self.rotary_dim > 0 + self.qkv = nn.Linear(width, 3 * width) + self.out = nn.Linear(width, width) + freq = 1.0 / ( + cfg["rotary_base"] ** (torch.arange(0, self.rotary_dim, 2).float() / self.rotary_dim) + ) + angle = torch.outer(torch.arange(cfg["context"]).float(), freq) + angle = torch.cat((angle, angle), dim=-1)[None, None] + self.register_buffer("cos", angle.cos(), persistent=False) + self.register_buffer("sin", angle.sin(), persistent=False) + self.dropout = cfg["dropout"] + self.rank = 0 + + def add_lora(self, rank): + self.rank = rank + width = self.heads * self.dim + self.q_a = nn.Parameter(torch.randn(rank, width) * 0.02) + self.q_b = nn.Parameter(torch.zeros(width, rank)) + self.v_a = nn.Parameter(torch.randn(rank, width) * 0.02) + self.v_b = nn.Parameter(torch.zeros(width, rank)) + + def rotate(self, x): + z, tail = x[..., : self.rotary_dim], x[..., self.rotary_dim :] + half = self.rotary_dim // 2 + swapped = torch.cat((-z[..., half:], z[..., :half]), dim=-1) + size = x.shape[-2] + z = z * self.cos[:, :, :size].to(x.dtype) + swapped * self.sin[:, :, :size].to(x.dtype) + return torch.cat((z, tail), dim=-1) + + def forward(self, x): + b, t, width = x.shape + q, k, v = self.qkv(x).chunk(3, dim=-1) + if self.rank: + q = q + F.linear(F.linear(x, self.q_a), self.q_b) + v = v + F.linear(F.linear(x, self.v_a), self.v_b) + q, k, v = [z.view(b, t, self.heads, self.dim).transpose(1, 2) for z in (q, k, v)] + y = F.scaled_dot_product_attention( + self.rotate(q), + self.rotate(k), + v, + is_causal=True, + dropout_p=self.dropout if self.training else 0, + ) + return self.out(y.transpose(1, 2).contiguous().view(b, t, width)) + + +class Block(nn.Module): + def __init__(self, cfg): + super().__init__() + width = cfg["width"] + self.ln1, self.ln2 = nn.LayerNorm(width), nn.LayerNorm(width) + self.attn = Attention(cfg) + self.up, self.down = nn.Linear(width, 4 * width), nn.Linear(4 * width, width) + self.dropout = nn.Dropout(cfg["dropout"]) + + def forward(self, x): + x = x + self.dropout(self.attn(self.ln1(x))) + return x + self.dropout(self.down(F.gelu(self.up(self.ln2(x)), approximate="tanh"))) + + +class GPT(nn.Module): + def __init__(self, cfg): + super().__init__() + self.cfg = cfg + self.embedding = nn.Embedding(cfg["vocab_size"], cfg["width"]) + self.blocks = nn.ModuleList([Block(cfg) for _ in range(cfg["layers"])]) + self.norm = nn.LayerNorm(cfg["width"]) + self.dropout = nn.Dropout(cfg["dropout"]) + self.embedding_rank = 0 + self.apply(self._init) + for block in self.blocks: + nn.init.normal_(block.attn.out.weight, std=0.02 / math.sqrt(2 * cfg["layers"])) + nn.init.normal_(block.down.weight, std=0.02 / math.sqrt(2 * cfg["layers"])) + + @staticmethod + def _init(module): + if isinstance(module, (nn.Linear, nn.Embedding)): + nn.init.normal_(module.weight, std=0.02) + if isinstance(module, nn.Linear): + nn.init.zeros_(module.bias) + + def add_lora(self, qv_rank, embedding_rank): + self.requires_grad_(False) + for b in self.blocks: + b.attn.add_lora(qv_rank) + self.embedding_rank = embedding_rank + self.emb_a = nn.Parameter(torch.randn(self.cfg["vocab_size"], embedding_rank) * 0.02) + self.emb_b = nn.Parameter(torch.zeros(embedding_rank, self.cfg["width"])) + + def hidden(self, ids): + x = self.embedding(ids) + if self.embedding_rank: + x = x + F.embedding(ids, self.emb_a) @ self.emb_b + x = self.dropout(x) + for block in self.blocks: + x = block(x) + return self.norm(x) + + def logits(self, hidden): + # Preserve input/output tying also for the embedding update. + logits = F.linear(hidden, self.embedding.weight) + if self.embedding_rank: + logits = logits + F.linear(F.linear(hidden, self.emb_b), self.emb_a) + return logits + + def forward(self, ids, targets=None): + h = self.hidden(ids) + if targets is None: + return self.logits(h) + # Avoid materializing logits at padded/unsupervised positions. + valid = targets != -100 + return F.cross_entropy(self.logits(h[valid]).float(), targets[valid], reduction="mean") diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_report.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_report.py new file mode 100644 index 0000000000000000000000000000000000000000..8aace2494390c65045a2d379beb42695d3b84c8e --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_report.py @@ -0,0 +1,685 @@ +"""Read-only, CPU aggregation of the completed original bioS development run.""" + +from __future__ import annotations + +import csv +import hashlib +import json +import math +import re +from collections import Counter +from datetime import datetime, timezone +from pathlib import Path + +from llm_memory_editability.bios_original_data import ( + ATTRS, + MONTHS, + TASKS, + answer, + question, +) + +DATE_PATTERN = re.compile( + "(?:" + "|".join(m.lower() for m in MONTHS) + r") (?:[1-9]|1\d|2[0-8]), \d{4}" +) +DIMENSIONS = ("world", "initialization", "condition", "stage", "split", "task", "view", "cot") +COUNTS = ( + "n", + "correct", + "eos", + "format_recognized", + "correct_eos", + "correct_unrecognized", + "wrong_recognized", + "wrong_unrecognized", + "terminal_answer_match", + "target_text_present", + "city_swap", + "comparison_outside_pair", + "sum_full_logp", + "sum_mean_logp", + "sum_answer_probability", +) + + +def normalize(text): + """Independently reproduce the historical frozen evaluator's normalization.""" + return " ".join(text.strip().rstrip(".").casefold().split()) + + +def extract(row): + text = row["generated"] + return text.rsplit("Answer:", 1)[-1].strip() if row["cot"] else text + + +def recognized(text, task, vocabulary): + value = normalize(text) + if task == "parity": + return value in ("yes", "no") + if task == "year": + return bool(re.fullmatch(r"\d{4}", value)) + if task == "date": + return bool(DATE_PATTERN.fullmatch(value)) + if task in ("company_city", "city_company"): + fields = ("company", "workcity") if task == "company_city" else ("workcity", "company") + parts = value.split(";") + return len(parts) == 2 and all( + part.strip() in vocabulary[field] for part, field in zip(parts, fields, strict=True) + ) + return value in vocabulary["name" if task == "comparison" else task] + + +def review_flags(row, person, vocabulary, partner=None): + """Mechanical error labels only; these do not replace the frozen score.""" + text, target = extract(row), normalize(row["answer"]) + correct = normalize(text) == target + form = recognized(text, row["task"], vocabulary) + suffix = row["generated"].rsplit("Answer:", 1)[-1] + terminal = not correct and "Answer:" in row["generated"] and normalize(suffix) == target + # A literal occurrence is an inspection cue, not a semantic-correctness claim. + present = not correct and bool( + re.search(r"(? 1e-5: + raise ValueError(f"Invalid log probability: {path}:{line_number}") + cell[target] += value + cell["sum_answer_probability"] += math.exp(row["answer_full_logp"]) + for category in ( + "terminal_answer_match", + "target_text_present", + "city_swap", + "comparison_outside_pair", + "wrong_recognized", + "wrong_unrecognized", + "correct_unrecognized", + ): + sample_key = (row["task"], row["view"] == 0, row["cot"], category) + if flags[category] and sample_counts[sample_key] < 2: + sample_counts[sample_key] += 1 + examples.append( + dict( + **meta, + category=category, + source=str(path), + line=line_number, + **row, + review_status="deterministic inspection sample; not human-labelled", + ) + ) + expected_cells = len(cfg["evaluation"]["splits"]) * len(tasks) * 6 * len(modes) + if len(cells) != expected_cells or len(completion["totals"]) != expected_cells: + raise ValueError(f"Incomplete evaluation cell matrix: {path}") + counts = Counter(p["split"] for p in people) + for (split, task, view, cot), cell in cells.items(): + if cell["n"] != counts[split]: + raise ValueError(f"Incomplete population: {path}: {split}/{task}/{view}/{cot}") + old = completion["totals"][f"{split}/{task}/view-{view}/cot-{cot}"] + if any(cell[k] != old[k] for k in ("n", "correct", "format_recognized")): + raise ValueError(f"Historical totals mismatch: {path}") + if not math.isclose(cell["sum_full_logp"], old["sum_full_logp"], abs_tol=1e-8): + raise ValueError(f"Historical logp total mismatch: {path}") + checks["cells_population_and_historical_totals_verified"] += 1 + provenance = dict( + **meta, + path=str(path), + sha256=digest.hexdigest(), + bytes=path.stat().st_size, + checkpoint_sha256=completion["checkpoint_sha256"], + checks=dict(checks), + completion_sha256=hashlib.sha256(completion_path.read_bytes()).hexdigest(), + ) + conditional = conditional_rows(seen, people, meta, modes) if meta["stage"] == "task" else [] + return [finalized(v) for v in cells.values()], examples, provenance, conditional + + +def pretrain_rows(cfg): + curves, inventory = [], [] + for world in cfg["world_seeds"]: + for init in cfg["initialization_seeds"]: + for condition in cfg["pretrain"]["conditions"]: + root = Path(cfg["result_root"]) / f"world-{world}/init-{init}/{condition}/pretrain" + path = root / "metrics.jsonl" + metrics = [json.loads(line) for line in path.read_text().splitlines()] + expected = list(range(1, cfg["pretrain"]["passes"] + 1)) + if [r["passes"] for r in metrics] != expected: + raise ValueError(f"Incomplete pretraining curve: {path}") + for row in metrics: + curves.append( + dict(world=world, initialization=init, condition=condition, **row) + ) + inventory.append( + dict( + world=world, + initialization=init, + condition=condition, + path=str(path), + sha256=hashlib.sha256(path.read_bytes()).hexdigest(), + passes=len(metrics), + final_nll=metrics[-1]["nll"], + nodes=[ + dict(passes=n, checkpoint_exists=(root / f"pass-{n:03d}.pt").exists()) + for n in cfg["pretrain"]["nodes"] + ], + ) + ) + return curves, inventory + + +def paired_differences(groups): + pairs = [("S", "M"), ("M", "MP"), ("MP", "MP-R"), ("MP-R", "MP-Random"), ("MP", "MP-CoT")] + lookup = {} + for row in groups: + key = tuple( + row[k] + for k in ("world", "initialization", "stage", "split", "task", "view_group", "cot") + ) + lookup.setdefault(key, {})[row["condition"]] = row + rows = [] + for key, conditions in lookup.items(): + for left, right in pairs: + if left not in conditions or right not in conditions: + continue + a, b = conditions[left], conditions[right] + if a["n"] != b["n"]: + raise ValueError("Unequal paired populations") + rows.append( + dict( + **dict( + zip( + ( + "world", + "initialization", + "stage", + "split", + "task", + "view_group", + "cot", + ), + key, + strict=True, + ) + ), + left=left, + right=right, + n_each=a["n"], + left_accuracy=a["correct_rate"], + right_accuracy=b["correct_rate"], + difference_pp=100 * (b["correct_rate"] - a["correct_rate"]), + ) + ) + return rows + + +def make_plots(output, curves, groups): + import matplotlib + + matplotlib.use("Agg") + import matplotlib.pyplot as plt + + fig, axes = plt.subplots(1, 2, figsize=(11, 4)) + for world in sorted({r["world"] for r in curves}): + for c, color in zip(("S", "M", "MP"), ("#9b5f1b", "#4477aa", "#228833"), strict=True): + subset = [r for r in curves if r["world"] == world and r["condition"] == c] + axes[0].plot( + [r["passes"] for r in subset], + [r["nll"] for r in subset], + color=color, + alpha=0.8, + label=f"{c}, world {world}", + ) + axes[0].set(xlabel="Biography exposures per person", ylabel="Training NLL", yscale="log") + axes[0].legend(fontsize=7) + for offset, view, color in [(-0.17, "canonical", "#4477aa"), (0.17, "heldout", "#cc6677")]: + means = [] + for c in ("S", "M", "MP"): + data = [ + r["correct_rate"] + for r in groups + if r["stage"] == "adapt" + and r["split"] == "test" + and r["condition"] == c + and r["view_group"] == view + and r["family"] == "six_attributes" + ] + means.append(100 * sum(data) / len(data)) + axes[1].bar([i + offset for i in range(3)], means, width=0.32, label=view, color=color) + axes[1].set( + xticks=range(3), + xticklabels=("S", "M", "MP"), + ylabel="QA extraction accuracy (%)", + ylim=(0, 105), + ) + axes[1].legend() + fig.suptitle("Original bioS development: training fit and later QA extraction") + fig.tight_layout() + for suffix in ("png", "pdf"): + fig.savefig(output / f"bios-pretrain-and-extraction.{suffix}", dpi=160) + plt.close(fig) + + +def report_text(overall, groups, endpoints): + def mean(rows, field="correct_rate"): + # Exactly one initialization per world in this development configuration. + per_world = {} + for row in rows: + per_world.setdefault(row["world"], []).append(row[field]) + values = [sum(v) / len(v) for v in per_world.values()] + return 100 * sum(values) / len(values) if values else float("nan") + + def select(rows, **conditions): + return [r for r in rows if all(r[k] == v for k, v in conditions.items())] + + lines = [ + "# 原版 bioS 开发预测复盘", + "", + "本报告独立复算两开发世界的 570 万条既有预测、18 个评价端点与全部 3240 个预训练" + "日志节点。没有新增训练、GPU 前向或更改历史预测。原始评分与完成文件逐单元一致。", + "", + "表中百分比先在每个世界内汇总，再对两个世界等权；这是开发结果，无新增独立确认。" + "同一人物的五个留出问法，以及同一比较人物对的两个问序，属于重复测量。", + "", + "## 六属性 QA 提取", + "", + "| BIO 条件 | 规范问法 | 五个留出问法均值 |", + "| --- | ---: | ---: |", + ] + for condition in ("S", "M", "MP"): + values = [ + mean( + select( + overall, + stage="adapt", + split="test", + condition=condition, + family="six_attributes", + view_group=v, + cot=False, + ) + ) + for v in ("canonical", "heldout") + ] + lines.append(f"| {condition} | {values[0]:.2f}% | {values[1]:.2f}% |") + lines += [ + "", + "S/M/MP 使用相同人物与语义事实曝光；M 增加表述，MP 再重排句序。" + "QA 适配使用训练人物，测试人物只参加 BIO 预训练。这里测的是经共同 QA 适配后的提取，" + "不能称为预训练终点未经适配的问答表现。工作城市已出现于传记，属于提取任务。", + "", + "## 任务适配后的规范问法", + "", + "| 模型 / 推理方式 | 日期 | 年份 | 月份奇偶 | 出生早晚比较 |", + "| --- | ---: | ---: | ---: | ---: |", + ] + for condition, cot in [ + ("MP", False), + ("MP-R", False), + ("MP-Random", False), + ("MP-CoT", False), + ("MP-CoT", True), + ]: + values = [ + mean( + select( + groups, + stage="task", + split="test", + condition=condition, + view_group="canonical", + cot=cot, + task=task, + ) + ) + for task in ("date", "year", "parity", "comparison") + ] + mode = "CoT" if cot else "直接" + lines.append(f"| {condition} / {mode} | " + " | ".join(f"{v:.2f}%" for v in values) + " |") + lines += [ + "", + "年份和奇偶需要从已知属性执行操作，不能与六属性提取的平均值混为一项。" + "MP-CoT 的两种推理方式使用同一适配端点，但解释提示、监督格式及输出计算不同。" + "MP-R 的收益须与匹配的 MP-Random 同时检查。", + "", + "## 错误与计分审阅", + "", + ] + for condition, cot in (("MP", False), ("MP-CoT", True)): + value = mean( + select( + groups, + stage="task", + split="test", + condition=condition, + view_group="canonical", + cot=cot, + task="comparison", + ), + "comparison_outside_pair_rate", + ) + lines.append( + f"- {condition} / {'CoT' if cot else '直接'} 的比较输出中，" + f"{value:.2f}% 未精确返回问题中任一人的名字；这不能只解释为日期运算错误。" + ) + suffix = mean( + select( + groups, + stage="task", + split="test", + condition="MP-CoT", + view_group="heldout", + cot=False, + task="date", + ), + "terminal_answer_match_rate", + ) + lines += [ + f"- MP-CoT 直接作答的留出日期问法中，{suffix:.2f}% 的全量输出虽未通过冻结评分，" + "最后一个 `Answer:` 后恰为目标日期。这是可复核的格式失分，保留为事后辅助统计；" + "没有改写主分数。", + "- `wrong_recognized` 只表示输出满足原格式规则但不等于标签；" + "`target_text_present` 只表示原输出出现目标文字，不认定语义正确。" + "城市互换与问题外人名由已知人物表确定。", + "- `error-review-samples.jsonl` 按任务、问法组、模式、错误标签保存最先两条，" + "是确定性审阅样本，不是错误率的随机估计，也不是全量人工语义标注。", + "- CoT 的历史 `answer_full_logp` 是解释提示后直接接短答案的概率，" + "不是所生成推理链或最终答案的概率，不用于判断 CoT 是否掌握知识。", + "- `conditional-task-scores.csv` 在同一人物、相同问法和输出模式下检查源属性是否答对；" + "比较题要求两个人的日期都答对。它是条件子集分析，覆盖率与全量分数同时保留，" + "不等同于把模型自产属性重新输入后的两次调用实验。", + "", + "## 预训练曲线与剩余工作", + "", + "`pretrain-curves.csv` 与图保留六条各 540 次曝光的训练 NLL。不同数据条件的文本" + "可预测性不同，NLL 不能当作统一知识量刻度。已保存权重节点存在不等于已测出各节点的" + "知识/推理能力；当前没有这样的语义学习曲线。", + "", + "本 CPU 报告没有完成独立权重重载、oracle 属性输入或自主提取后运算；" + "100k 正式矩阵与日期编辑也未执行。它们的后续结果应写入独立产物。", + "", + "复现：`PYTHONPATH=src .venv/bin/python scripts/report_bios_original.py`。" + "原预测、配置、数据及报告源码哈希见 `audit.json`。", + "", + f"已核验端点：{len(endpoints)}；完整单元表 `cells.csv`，按任务与问法组汇总" + " `task-view-groups.csv`，世界内配对差 `paired-world-differences.csv`。", + ] + return "\n".join(lines) + "\n" + + +def run_report(config_path, output): + cfg = json.loads(config_path.read_text()) + output.mkdir(parents=True, exist_ok=True) + cells, examples, endpoints, conditional = [], [], [], [] + for world in cfg["world_seeds"]: + people_path = Path(cfg["data_root"]) / f"world-{world}/people.json" + people = json.loads(people_path.read_text()) + if [p["id"] for p in people] != list(range(cfg["people"])): + raise ValueError("People index contract changed") + for init in cfg["initialization_seeds"]: + for stage, conditions in ( + ("adapt", cfg["pretrain"]["conditions"]), + ("task", cfg["task"]["conditions"]), + ): + for condition in conditions: + meta = dict(world=world, initialization=init, condition=condition, stage=stage) + root = ( + Path(cfg["result_root"]) / f"world-{world}/init-{init}/{condition}/{stage}" + ) + a, b, c, d = read_endpoint(root, meta, cfg, people) + cells.extend(a) + examples.extend(b) + endpoints.append(c) + conditional.extend(d) + print( + json.dumps(dict(**meta, rows=sum(r["n"] for r in a), status="verified")), + flush=True, + ) + groups = rollup(cells, views=True) + overall = overall_rows(groups) + curves, inventory = pretrain_rows(cfg) + write_csv(output / "cells.csv", cells) + write_csv(output / "task-view-groups.csv", groups) + write_csv(output / "overall.csv", overall) + write_csv(output / "paired-world-differences.csv", paired_differences(groups)) + write_csv(output / "conditional-task-scores.csv", conditional) + write_csv(output / "pretrain-curves.csv", curves) + with (output / "error-review-samples.jsonl").open("w") as stream: + for example in examples: + stream.write(json.dumps(example, ensure_ascii=False) + "\n") + save_json( + output / "audit.json", + dict( + created_at_utc=datetime.now(timezone.utc).isoformat(), + scope="CPU predictions/logs audit; no checkpoint reload or GPU inference", + config=str(config_path), + config_sha256=hashlib.sha256(config_path.read_bytes()).hexdigest(), + raw_prediction_rows=sum(r["n"] for r in cells), + endpoint_count=len(endpoints), + cells=len(cells), + pretraining_runs=len(inventory), + pretrain_nodes=len(curves), + endpoints=endpoints, + pretrain=inventory, + failures=[], + sources=[ + dict(path=str(p), sha256=hashlib.sha256(p.read_bytes()).hexdigest()) + for p in ( + Path(__file__), + Path("scripts/report_bios_original.py"), + Path("src/llm_memory_editability/bios_original_data.py"), + Path("src/llm_memory_editability/bios_original_train.py"), + *[ + Path(cfg["data_root"]) / f"world-{w}/people.json" + for w in cfg["world_seeds"] + ], + ) + ], + missing_scientific_deliverables=[ + "Independent GPU checkpoint reload remains unverified by this CPU report", + "Oracle-input and extract-then-operate inference are absent from these inputs", + "Pretraining semantic trajectories absent; existing curve is training NLL only", + "Sampled output inspection is separate from exhaustive human semantic adjudication", + ], + ), + ) + save_json( + output / "summary.json", + dict( + development_worlds=cfg["world_seeds"], + independent_worlds=len(cfg["world_seeds"]), + test_overall=[r for r in overall if r["split"] == "test"], + probability_caveat=( + "CoT logp scores the short gold answer immediately after the explanation prompt; " + "it is not the probability of the generated CoT or its final answer." + ), + scoring=( + "Historical answer EM; EOS is reported independently. Views and paired " + "comparison orientations are repeated measurements, not independent worlds." + ), + ), + ) + make_plots(output, curves, overall) + (output / "report.md").write_text(report_text(overall, groups, endpoints)) + return overall diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_train.py new file mode 100644 index 0000000000000000000000000000000000000000..eea8f0449758025224fd3bb37444cc7e54e7ef7c --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_original_train.py @@ -0,0 +1,669 @@ +"""Restartable development execution for the original bioS experiment, plan 14.27.""" + +from __future__ import annotations + +import contextlib +import json +import math +import os +import random +import re +import time +from collections import defaultdict +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_original_data import ( + ATTRS, + MATERIAL, + MONTHS, + TASKS, + BioStream, + answer, + date, + digest, + load_json, + question, + reasoning, + write_json, +) +from .bios_original_model import GPT + + +def setup(seed, device): + os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8") + torch.set_num_threads(4) + torch.manual_seed(seed) + random.seed(seed) + np.random.seed(seed) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.use_deterministic_algorithms(True) + if str(device).startswith("cuda"): + torch.cuda.set_device(device) + + +def amp(device): + return ( + torch.autocast("cuda", dtype=torch.bfloat16) + if str(device).startswith("cuda") + else contextlib.nullcontext() + ) + + +def append(path, record): + with Path(path).open("a") as out: + out.write(json.dumps(record) + "\n") + + +def atomic_save(path, obj): + path = Path(path) + tmp = path.with_suffix(".tmp") + torch.save(obj, tmp) + tmp.replace(path) + + +def pack_tokens(tokens, context=512): + """Adjacent chunks overlap by the context token only; every target is scored once.""" + n = len(tokens) - 1 + rows = math.ceil(n / context) + x = np.full((rows, context), 50256, dtype=np.int64) + y = np.full((rows, context), -100, dtype=np.int64) + x.flat[:n] = tokens[:-1] + y.flat[:n] = tokens[1:] + return torch.from_numpy(x), torch.from_numpy(y) + + +def optimizer_for(model, settings): + params = [p for p in model.parameters() if p.requires_grad] + groups = [ + dict(params=[p for p in params if p.ndim >= 2], weight_decay=settings["weight_decay"]), + dict(params=[p for p in params if p.ndim < 2], weight_decay=0.0), + ] + return torch.optim.AdamW( + groups, + lr=settings["learning_rate"], + betas=tuple(settings.get("adam_betas", [0.9, 0.999])), + eps=settings.get("adam_epsilon", 1e-6), + fused=next(model.parameters()).is_cuda, + ) + + +def parameter_count(model): + return sum(p.numel() for p in model.parameters()) + + +def pretrain(cfg, world, init, condition, device, stop_after_pass=None): + setup(init, device) + root = Path(cfg["result_root"]) / f"world-{world}" / f"init-{init}" / condition / "pretrain" + root.mkdir(parents=True, exist_ok=True) + settings = cfg["pretrain"] + data_root = Path(cfg["data_root"]) / f"world-{world}" + stream = BioStream(data_root, world, condition) + contract = dict( + config=cfg, + world=world, + init=init, + condition=condition, + data_audit_sha256=digest(data_root / "audit.json"), + ) + if (root / "contract.json").exists(): + if load_json(root / "contract.json") != contract: + raise ValueError("Run contract changed; use a new run directory") + else: + write_json(root / "contract.json", contract) + model = GPT(cfg["model"]).to(device) + opt = optimizer_for(model, settings) + start, step, seen, elapsed = 0, 0, 0, 0.0 + latest = root / "latest.pt" + if latest.exists(): + state = torch.load(latest, map_location=device, weights_only=False) + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + start, step, seen, elapsed = [state[k] for k in ("passes", "step", "tokens", "elapsed")] + del state + elif (root / "metrics.jsonl").exists(): + raise ValueError("Metrics without a resumable checkpoint require investigation") + if (root / "metrics.jsonl").exists(): + kept = [ + line + for line in (root / "metrics.jsonl").read_text().splitlines() + if json.loads(line)["passes"] <= start + ] + (root / "metrics.jsonl").write_text("".join(s + "\n" for s in kept)) + if start == 0 and not (root / "pass-000.pt").exists(): + atomic_save(root / "pass-000.pt", dict(model=model.state_dict(), config=cfg["model"])) + if not latest.exists(): + atomic_save( + latest, + dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + passes=0, + step=0, + tokens=0, + elapsed=0.0, + ), + ) + count = parameter_count(model) + write_json( + root / "model.json", + dict( + parameters=count, + trainable=count, + device=str(device), + gpu=torch.cuda.get_device_name(device) if "cuda" in str(device) else "cpu", + torch=torch.__version__, + resume_pass=start, + ), + ) + model.train() + runner = torch.compile(model) if settings.get("compile") else model + wall = time.monotonic() + for epoch in range(start, min(settings["passes"], stop_after_pass or settings["passes"])): + pass_start = time.monotonic() + tokens, order_hash = stream.pass_tokens(epoch) + xs, ys = pack_tokens(tokens, cfg["model"]["context"]) + total_loss, valid_tokens = 0.0, 0 + batch = settings["batch_size"] + micro = settings["micro_batch_size"] + for i in range(0, len(xs), batch): + # Learning rate follows complete-person exposure; no outcome-based stopping. + progress = (epoch + i / len(xs)) / settings["passes"] + cosine = ( + settings["minimum_lr_ratio"] + + (1 - settings["minimum_lr_ratio"]) * (1 + math.cos(math.pi * progress)) / 2 + ) + lr = ( + settings["learning_rate"] + * cosine + * min(1, (step + 1) / max(1, settings["warmup_steps"])) + ) + for group in opt.param_groups: + group["lr"] = lr + opt.zero_grad(set_to_none=True) + end = min(i + batch, len(xs)) + denom = int((ys[i:end] != -100).sum()) + batch_loss = 0.0 + for j in range(i, end, micro): + x, y = ( + xs[j : min(j + micro, end)].to(device), + ys[j : min(j + micro, end)].to(device), + ) + n = int((y != -100).sum()) + with amp(device): + loss = runner(x, y) + if not torch.isfinite(loss): + raise FloatingPointError(f"Nonfinite loss at pass {epoch}, step {step}") + (loss * (n / denom)).backward() + batch_loss += loss.detach().item() * n + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), settings["gradient_clip"]) + if not torch.isfinite(norm): + raise FloatingPointError(f"Nonfinite gradient at step {step}") + opt.step() + step += 1 + total_loss += batch_loss + valid_tokens += denom + if step % 10 == 0: + write_json( + root / "status.json", + dict( + state="running", + passes_completed=epoch, + pass_fraction=end / len(xs), + step=step, + learning_rate=lr, + last_batch_nll=batch_loss / denom, + tokens=seen + valid_tokens, + elapsed=elapsed + time.monotonic() - wall, + updated_unix=time.time(), + pid=os.getpid(), + ), + ) + assert valid_tokens == len(tokens) - 1 + seen += valid_tokens + duration = time.monotonic() - pass_start + record = dict( + passes=epoch + 1, + people_presented=(epoch + 1) * stream.count, + tokens=seen, + pass_tokens=valid_tokens, + nll=total_loss / valid_tokens, + seconds=duration, + tokens_per_second=valid_tokens / duration, + step=step, + learning_rate=lr, + presentation_sha256=order_hash, + estimated_training_flops=6 * count * seen, + elapsed=elapsed + time.monotonic() - wall, + ) + append(root / "metrics.jsonl", record) + print(json.dumps(record), flush=True) + if epoch + 1 in settings["nodes"]: + atomic_save( + root / f"pass-{epoch + 1:03d}.pt", + dict(model=model.state_dict(), config=cfg["model"], metrics=record), + ) + if (epoch + 1) % 10 == 0 or epoch + 1 == stop_after_pass or epoch + 1 == settings["passes"]: + atomic_save( + latest, + dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + passes=epoch + 1, + step=step, + tokens=seen, + elapsed=elapsed + time.monotonic() - wall, + ), + ) + write_json( + root / "status.json", + dict( + state="complete" if epoch + 1 == settings["passes"] else "running", + passes_completed=epoch + 1, + **record, + updated_unix=time.time(), + pid=os.getpid(), + ), + ) + return root / f"pass-{settings['passes']:03d}.pt" + + +def encode_row(tokenizer, prompt, target): + prefix = tokenizer.encode(prompt).ids + suffix = tokenizer.encode(" " + target).ids + [50256] + return dict(ids=prefix + suffix, answer_start=len(prefix)) + + +def supervised_batch(rows, device): + width = max(len(r["ids"]) for r in rows) - 1 + x = torch.full((len(rows), width), 50256, dtype=torch.long, device=device) + y = torch.full_like(x, -100) + for i, r in enumerate(rows): + ids = torch.tensor(r["ids"], device=device) + x[i, : len(ids) - 1] = ids[:-1] + y[i, r["answer_start"] - 1 : len(ids) - 1] = ids[r["answer_start"] :] + return x, y + + +def sequence_scores(model, rows, device): + x, y = supervised_batch(rows, device) + h = model.hidden(x) + b, t = torch.where(y != -100) + losses = F.cross_entropy(model.logits(h[b, t]).float(), y[b, t], reduction="none") + sums = torch.zeros(len(rows), device=device).scatter_add_(0, b, losses) + sizes = torch.bincount(b, minlength=len(rows)) + return -sums / sizes, -sums + + +def task_rows(people, tokenizer, tasks, condition, epoch, seed): + rng = random.Random(seed) + # Use the published label vocabulary, independent of held-out person attributes. + cities = sorted( + set((MATERIAL / "fields/city.txt").read_text().splitlines()) + | { + line.split(";", 1)[1].strip() + for line in (MATERIAL / "fields/company.txt").read_text().splitlines() + } + ) + bins = defaultdict(list) + for city in cities: + bins[len(tokenizer.encode(" " + city).ids)].append(city) + rows = [] + for p in people: + if p["split"] != "train": + continue + other = people[p["partner"]] + for j, task in enumerate(tasks): + cot = condition == "MP-CoT" and (p["id"] + j + epoch) % 2 == 0 + prompt = question(p, task, other=other, cot=cot) + target = reasoning(p, task, other) if cot else answer(p, task, other) + row = encode_row(tokenizer, prompt, target) + row.update(person_id=p["id"], task=task, cot=cot) + if task in ("birthcity", "workcity") and p["birthcity"] != p["workcity"]: + competing = p["workcity"] if task == "birthcity" else p["birthcity"] + candidates = [ + c + for c in bins[len(tokenizer.encode(" " + competing).ids)] + if c not in (p["birthcity"], p["workcity"]) + ] + if not candidates: + raise ValueError( + "No length-matched random city; cannot silently relax matching" + ) + negative = rng.choice(candidates) if condition == "MP-Random" else competing + row["negative"] = encode_row(tokenizer, prompt, negative) + rows.append(row) + return rows + + +def rule_rows(tokenizer): + rows = [] + for m, name in enumerate(MONTHS, 1): + rows.append( + encode_row( + tokenizer, + f"Question: Is {name} an even-numbered month?\nAnswer:", + "yes" if m % 2 == 0 else "no", + ) + ) + rng = random.Random(14270000) + for i in range(24): + a, b = [ + dict( + year=rng.randrange(1900, 2100), month=rng.randrange(1, 13), day=rng.randrange(1, 29) + ) + for _ in range(2) + ] + if i % 2: + a, b = ( + max((a, b), key=lambda p: (p["year"], p["month"], p["day"])), + min((a, b), key=lambda p: (p["year"], p["month"], p["day"])), + ) + else: + a, b = ( + min((a, b), key=lambda p: (p["year"], p["month"], p["day"])), + max((a, b), key=lambda p: (p["year"], p["month"], p["day"])), + ) + rows.append( + encode_row( + tokenizer, + f"Question: Which date is earlier, {date(a)} or {date(b)}?\nAnswer:", + date(b if i % 2 else a), + ) + ) + return rows + + +def load_model(path, cfg, device, adapters=False): + model = GPT(cfg["model"]) + if adapters: + model.add_lora(cfg["adapt"]["qv_rank"], cfg["adapt"]["embedding_rank"]) + state = torch.load(path, map_location="cpu", weights_only=False) + model.load_state_dict(state["model"]) + return model.to(device) + + +def finetune(cfg, world, init, condition, stage, parent, device, tokenizer): + setup(init + 1, device) + root = Path(cfg["result_root"]) / f"world-{world}" / f"init-{init}" / condition / stage + root.mkdir(parents=True, exist_ok=True) + people = load_json(Path(cfg["data_root"]) / f"world-{world}" / "people.json") + contract = dict( + config=cfg, + world=world, + init=init, + condition=condition, + stage=stage, + parent=str(parent), + parent_sha256=digest(parent), + ) + if (root / "contract.json").exists() and load_json(root / "contract.json") != contract: + raise ValueError("Finetuning contract changed") + write_json(root / "contract.json", contract) + if (root / "complete.json").exists(): + return root / "final.pt" + model = load_model(parent, cfg, device, adapters=stage == "task") + if stage == "adapt": + model.add_lora(cfg["adapt"]["qv_rank"], cfg["adapt"]["embedding_rank"]) + model.to(device) + opt = optimizer_for(model, cfg["adapt"]) + start, step = 0, 0 + if (root / "latest.pt").exists(): + ck = torch.load(root / "latest.pt", map_location=device, weights_only=False) + model.load_state_dict(ck["model"]) + opt.load_state_dict(ck["optimizer"]) + start, step = ck["epoch"], ck["step"] + del ck + if (root / "metrics.jsonl").exists(): + kept = [ + line + for line in (root / "metrics.jsonl").read_text().splitlines() + if json.loads(line)["epoch"] <= start + ] + (root / "metrics.jsonl").write_text("".join(s + "\n" for s in kept)) + write_json( + root / "parameters.json", + dict( + total=parameter_count(model), + trainable=sum(p.numel() for p in model.parameters() if p.requires_grad), + trainable_names=[n for n, p in model.named_parameters() if p.requires_grad], + ), + ) + epochs = cfg[stage]["epochs"] + model.train() + for epoch in range(start, epochs): + rows = task_rows( + people, + tokenizer, + ATTRS if stage == "adapt" else TASKS, + condition if stage == "task" else "MP", + epoch, + world + 1427, + ) + if stage == "task": + rows += rule_rows(tokenizer) * cfg["task"]["rule_repetitions_per_epoch"] + random.Random(world + epoch + 20000000).shuffle(rows) + batch, micro = cfg["adapt"]["batch_size"], cfg["adapt"]["micro_batch_size"] + ce_sum, ranking_sum, candidates, target_tokens = 0.0, 0.0, 0, 0 + wall = time.monotonic() + for i in range(0, len(rows), batch): + group = rows[i : i + batch] + lr = cfg["adapt"]["learning_rate"] * ( + 0.1 + 0.9 * (1 + math.cos(math.pi * (epoch + i / len(rows)) / epochs)) / 2 + ) + for pg in opt.param_groups: + pg["lr"] = lr + opt.zero_grad(set_to_none=True) + for j in range(0, len(group), micro): + part = group[j : j + micro] + with amp(device): + scores, _ = sequence_scores(model, part, device) + ce = -scores.mean() + neg_pairs = [(k, r["negative"]) for k, r in enumerate(part) if "negative" in r] + rank = scores.sum() * 0 + if stage == "task" and neg_pairs: + neg, _ = sequence_scores(model, [r for _, r in neg_pairs], device) + pos = scores[[k for k, _ in neg_pairs]] + # Normalize by all positive rows, including zero collision/non-city terms. + rank = F.softplus(cfg["task"]["margin"] - (pos - neg)).sum() / len(part) + candidates += len(neg_pairs) + coefficient = ( + cfg["task"]["ranking_coefficient"] + if condition in ("MP-R", "MP-Random") and stage == "task" + else 0.0 + ) + loss = ce + coefficient * rank + if not torch.isfinite(loss): + raise FloatingPointError("Nonfinite finetuning loss") + (loss * len(part) / len(group)).backward() + ce_sum += ce.item() * len(part) + ranking_sum += rank.item() * len(part) + target_tokens += sum(len(r["ids"]) - r["answer_start"] for r in part) + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) + if not torch.isfinite(norm): + raise FloatingPointError("Nonfinite finetuning gradient") + opt.step() + step += 1 + if step % 25 == 0: + write_json( + root / "status.json", + dict( + state="running", + epoch=epoch, + fraction=min(i + batch, len(rows)) / len(rows), + step=step, + last_ce=ce.item(), + pid=os.getpid(), + updated_unix=time.time(), + ), + ) + rec = dict( + epoch=epoch + 1, + rows=len(rows), + ce=ce_sum / len(rows), + rank=ranking_sum / len(rows), + scored_negative_candidates=candidates, + target_tokens=target_tokens, + seconds=time.monotonic() - wall, + ) + append(root / "metrics.jsonl", rec) + print(json.dumps(rec), flush=True) + atomic_save( + root / "latest.pt", + dict(model=model.state_dict(), optimizer=opt.state_dict(), epoch=epoch + 1, step=step), + ) + atomic_save(root / "final.pt", dict(model=model.state_dict(), config=cfg["model"])) + write_json( + root / "complete.json", + dict(epochs=epochs, step=step, checkpoint_sha256=digest(root / "final.pt")), + ) + return root / "final.pt" + + +@torch.no_grad() +def generate(model, tokenizer, prompts, device, max_tokens): + # Right padding; each row's final real position supplies its own next token. + sequences = [tokenizer.encode(p).ids for p in prompts] + outputs, finished = [[] for _ in prompts], [False] * len(prompts) + for _ in range(max_tokens): + width = max(map(len, sequences)) + if width > model.cfg["context"]: + break + ids = torch.full((len(prompts), width), 50256, dtype=torch.long, device=device) + for i, seq in enumerate(sequences): + ids[i, : len(seq)] = torch.tensor(seq, device=device) + with amp(device): + h = model.hidden(ids) + last = h[ + torch.arange(len(prompts), device=device), + torch.tensor([len(s) - 1 for s in sequences], device=device), + ] + pred = model.logits(last).argmax(-1).tolist() + for i, token in enumerate(pred): + if not finished[i]: + outputs[i].append(token) + sequences[i].append(token) + finished[i] = token == 50256 + if all(finished): + break + return [tokenizer.decode(ids, skip_special_tokens=True).strip() for ids in outputs], finished + + +def normalize(text): + return " ".join(text.strip().rstrip(".").casefold().split()) + + +def recognized_format(text, task, vocabulary): + value = normalize(text) + if task == "parity": + return value in ("yes", "no") + if task == "year": + return bool(re.fullmatch(r"\d{4}", value)) + if task == "date": + return bool( + re.fullmatch( + "(?:" + "|".join(m.lower() for m in MONTHS) + r") (?:[1-9]|1\d|2[0-8]), \d{4}", + value, + ) + ) + if task in ("company_city", "city_company"): + parts = value.split(";") + fields = ("company", "workcity") if task == "company_city" else ("workcity", "company") + return len(parts) == 2 and all( + part.strip() in vocabulary[field] for part, field in zip(parts, fields, strict=True) + ) + return value in vocabulary["name" if task == "comparison" else task] + + +@torch.no_grad() +def evaluate(cfg, world, checkpoint, output, device, tokenizer, tasks=TASKS, cot=False): + output = Path(output) + if (output / "evaluation-complete.json").exists(): + if load_json(output / "evaluation-complete.json")["checkpoint_sha256"] != digest( + checkpoint + ): + raise ValueError("Evaluated checkpoint changed") + return + output.mkdir(parents=True, exist_ok=True) + people = load_json(Path(cfg["data_root"]) / f"world-{world}" / "people.json") + vocabulary = {field: {normalize(p[field]) for p in people} for field in ("name", *ATTRS[1:])} + model = load_model(checkpoint, cfg, device, adapters=True).eval() + totals = defaultdict(lambda: defaultdict(float)) + batch = [] + with (output / "predictions.jsonl").open("w") as out: + + def flush(): + if not batch: + return + enc = [encode_row(tokenizer, r["prompt"], r["answer"]) for r in batch] + with amp(device): + avg, full = sequence_scores(model, enc, device) + generated, ended = generate( + model, + tokenizer, + [r["prompt"] for r in batch], + device, + cfg["evaluation"]["max_new_tokens"], + ) + for row, text, stop, av, lp in zip( + batch, generated, ended, avg.tolist(), full.tolist(), strict=True + ): + extracted = text.rsplit("Answer:", 1)[-1].strip() if row["cot"] else text + correct = normalize(extracted) == normalize(row["answer"]) + # Syntactic recognition is distinct from correctness; retain raw output. + recognized = recognized_format(extracted, row["task"], vocabulary) + row.update( + generated=text, + eos=stop, + correct=correct, + format_recognized=recognized, + answer_mean_logp=av, + answer_full_logp=lp, + ) + out.write(json.dumps(row) + "\n") + key = f"{row['split']}/{row['task']}/view-{row['view']}/cot-{row['cot']}" + t = totals[key] + t["n"] += 1 + t["correct"] += correct + t["format_recognized"] += recognized + t["sum_full_logp"] += lp + batch.clear() + write_json( + output / "evaluation-status.json", + dict( + rows=sum(t["n"] for t in totals.values()), + updated_unix=time.time(), + pid=os.getpid(), + ), + ) + + for p in people: + if p["split"] not in cfg["evaluation"]["splits"]: + continue + other = people[p["partner"]] + for task in tasks: + for view in cfg["evaluation"]["views"]: + for use_cot in [False, True] if cot else [False]: + batch.append( + dict( + person_id=p["id"], + split=p["split"], + task=task, + view=view, + cot=use_cot, + partner=other["id"] if task == "comparison" else None, + prompt=question(p, task, view, other, use_cot), + answer=answer(p, task, other), + ) + ) + if len(batch) == cfg["evaluation"]["batch_size"]: + flush() + flush() + write_json( + output / "evaluation-complete.json", + dict(checkpoint_sha256=digest(checkpoint), totals=dict(totals)), + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_diagnostics.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_diagnostics.py new file mode 100644 index 0000000000000000000000000000000000000000..219336bcde27c897b81d6c253255dca79eb11d1c --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_diagnostics.py @@ -0,0 +1,727 @@ +"""Read-only answer-source diagnostics for the frozen two-chain experiments. + +Matching an answer to a candidate is a behavioral description, not evidence that +the model used that internal path. Multiple matching roles are never tie-broken. +""" + +import csv +import hashlib +import json +from collections import defaultdict +from pathlib import Path + +import numpy as np + +from .bios_cross import CHAINS, CONDITIONS, edit_pair, make_cross_world +from .bios_data import EOS, array_hash, write_json + +LEARNING_ROLES = ("default", "actual", "other_default", "other_actual") +EDIT_ROLES = ( + "new_default", + "new_actual", + "old_default", + "old_actual", + "other_default", + "other_actual", +) +# Codes are shared across files. Role names differ between learning and editing. +NOT_APPLICABLE, TERMINATION_ERROR, OTHER, INDISTINGUISHABLE = -1, 0, 1, 2 +ROLE_CODE_START = 3 + + +def file_sha256(path): + digest = hashlib.sha256() + with Path(path).open("rb") as stream: + for block in iter(lambda: stream.read(1024 * 1024), b""): + digest.update(block) + return digest.hexdigest() + + +def classify_answers(prediction, ended, candidates): + """Return exclusive categories plus *all* matched role bits, including overlaps. + + An unfinished generation is a termination error even if its value matches. + Correctness is deliberately separate: a correct answer can have ambiguous roles. + """ + prediction, ended, candidates = map(np.asarray, (prediction, ended, candidates)) + if ( + candidates.ndim != 2 + or prediction.shape != ended.shape + or candidates.shape[0] != len(prediction) + ): + raise ValueError("Incompatible prediction/candidate shapes") + if not 1 <= candidates.shape[1] <= 8: + raise ValueError("Candidate role bitset requires one to eight roles") + matched = prediction[:, None] == candidates + n_matches = matched.sum(axis=1) + bits = (matched.astype(np.uint8) * (1 << np.arange(candidates.shape[1]))).sum(axis=1) + category = np.full(len(prediction), OTHER, dtype=np.int8) + unique = n_matches == 1 + category[unique] = ROLE_CODE_START + matched[unique].argmax(axis=1) + category[n_matches > 1] = INDISTINGUISHABLE + category[~ended.astype(bool)] = TERMINATION_ERROR + return category, bits.astype(np.uint8) + + +def candidate_answers(world, chain, target=None): + """Candidate values for all people, with no dependence on model predictions.""" + other = 1 - chain + old_default = world.answers[world.root_ids[chain, world.memberships[chain]]] + old_actual = world.answers[world.actual_ids[chain]] + current = world.answers if target is None else target + other_default = current[world.root_ids[other, world.memberships[other]]] + other_actual = current[world.actual_ids[other]] + if target is None: + roles = LEARNING_ROLES + values = (old_default, old_actual, other_default, other_actual) + else: + roles = EDIT_ROLES + values = ( + target[world.root_ids[chain, world.memberships[chain]]], + target[world.actual_ids[chain]], + old_default, + old_actual, + other_default, + other_actual, + ) + return roles, np.column_stack(values) + + +def score_saved_arrays(arrays, answers): + prediction, ended = arrays["prediction"], arrays["ended"] + if prediction.shape != answers.shape or ended.shape != answers.shape: + raise ValueError("Saved prediction length differs from truth") + if not np.isin(ended, [False, True]).all(): + raise ValueError("Invalid termination flags") + correct = (prediction == answers) & ended.astype(bool) + if not np.array_equal(correct, arrays["correct"]): + raise ValueError("Saved correctness differs from value-plus-EOS scoring") + return correct + + +def annotate_predictions(world, arrays, target=None): + """Full-query arrays plus candidate matrices aligned with derived_query_ids.""" + answers = world.answers if target is None else target + correct = score_saved_arrays(arrays, answers) + category = np.full(len(answers), NOT_APPLICABLE, dtype=np.int8) + bits = np.zeros(len(answers), dtype=np.uint8) + candidates = [] + for chain in range(2): + roles, values = candidate_answers(world, chain, target) + ids = world.derived_ids[chain] + category[ids], bits[ids] = classify_answers( + arrays["prediction"][ids], arrays["ended"][ids], values + ) + candidates.append(values) + return { + "query_id": np.arange(len(answers), dtype=np.int32), + "prediction": np.asarray(arrays["prediction"], dtype=np.int32), + "ended": np.asarray(arrays["ended"], dtype=bool), + "correct": correct, + "class_code": category, + "matched_role_bits": bits, + "derived_query_ids": world.derived_ids.astype(np.int32), + "candidate_tokens": np.stack(candidates).astype(np.int32), + "candidate_roles": np.array(roles), + } + + +def learning_subsets(world): + """Overlapping diagnostic groups; every row retains its own denominator.""" + yield "all_queries", np.arange(len(world.answers)) + yield "base", np.arange(world.n_base) + yield "independent_attributes", np.flatnonzero(np.isin(world.relation, [3, 4, 5, 6])) + for chain, name in enumerate(CHAINS): + for relation, ids in ( + ("membership", world.membership_ids[chain]), + ("default", world.root_ids[chain]), + ("actual", world.actual_ids[chain]), + ): + yield f"{name}/base/{relation}", ids + for split, ids in ( + ("all", world.derived_ids[chain]), + ("trained", world.train_ids[chain]), + ("heldout", world.heldout_ids[chain]), + ): + yield f"{name}/qa/{split}/all", ids + for label, mask in ( + ("ordinary", ~world.exceptions[chain]), + ("old_exception", world.exceptions[chain]), + ): + yield ( + f"{name}/qa/{split}/{label}", + np.intersect1d(ids, world.derived_ids[chain, mask]), + ) + + +def editing_subsets(world, pair, chain, target): + yield "E/all", pair["E"] + yield "E/default", np.intersect1d(pair["E"], world.root_ids[chain]) + yield "E/actual", np.intersect1d(pair["E"], world.actual_ids[chain]) + # Membership in the 45-person manipulated cohort differs from factual conflict: + # six old exceptions can also conflict; coherent edits have no *new* conflicts. + actual_conflict = target[world.derived_ids[chain]] != target[world.actual_ids[chain]] + for split, ids in ( + ("all", pair["D"]), + ("trained", np.intersect1d(pair["D"], world.train_ids[chain])), + ("heldout", np.intersect1d(pair["D"], world.heldout_ids[chain])), + ): + yield f"D/{split}/all", ids + for label, group in ( + ("manipulated_conflict_cohort", pair["conflict_D"]), + ("factual_conflict", world.derived_ids[chain, actual_conflict]), + ("no_factual_conflict", world.derived_ids[chain, ~actual_conflict]), + ("old_exception", world.derived_ids[chain, world.exceptions[chain]]), + ("ordinary", world.derived_ids[chain, ~world.exceptions[chain]]), + ): + yield f"D/{split}/{label}", np.intersect1d(ids, group) + for pool_name, pool in ( + ("full", np.flatnonzero(pair["strata"] >= 0)), + ("editor_heldout", pair["heldout"]), + ): + yield f"U/{pool_name}/all", pool + for stratum in range(4): + yield ( + f"U/{pool_name}/stratum_{stratum}", + np.intersect1d(pool, np.flatnonzero(pair["strata"] == stratum)), + ) + + +def summary_rows(world, annotations, subsets, identity, old_correct=None): + """Counts are sufficient to reaggregate without hiding empty or ambiguous cells.""" + classes, bits = annotations["class_code"], annotations["matched_role_bits"] + for label, ids in subsets: + ids = np.asarray(ids) + correct = annotations["correct"][ids] + row = { + **identity, + "subset": label, + "n": len(ids), + "correct": int(correct.sum()), + "accuracy": float(correct.mean()) if len(ids) else None, + "termination_error": int((~annotations["ended"][ids]).sum()), + "role_not_applicable": int((classes[ids] == NOT_APPLICABLE).sum()), + "other_answer": int((classes[ids] == OTHER).sum()), + "indistinguishable": int((classes[ids] == INDISTINGUISHABLE).sum()), + "indistinguishable_wrong": int(((classes[ids] == INDISTINGUISHABLE) & ~correct).sum()), + } + # Stable CSV schema, even though learning uses only four roles. + for role in dict.fromkeys((*LEARNING_ROLES, *EDIT_ROLES)): + role_names = list(annotations["candidate_roles"]) + if role in role_names: + index = role_names.index(role) + row[f"unique_{role}"] = int((classes[ids] == ROLE_CODE_START + index).sum()) + row[f"matches_{role}"] = int( + (((bits[ids] & (1 << index)) != 0) & annotations["ended"][ids]).sum() + ) + else: + row[f"unique_{role}"] = row[f"matches_{role}"] = 0 + if old_correct is not None: + known = old_correct[ids] + row["old_known"] = int(known.sum()) + row["old_known_coverage"] = float(known.mean()) if len(ids) else None + row["old_known_now_wrong"] = int((known & ~correct).sum()) + row["damage_rate"] = ( + (float((known & ~correct).sum() / known.sum()) if known.any() else None) + if label.startswith("U/") + else None + ) + else: + row.update( + old_known=None, old_known_coverage=None, old_known_now_wrong=None, damage_rate=None + ) + yield row + + +def _write_csv(path, rows): + with Path(path).open("w") as stream: + writer = csv.DictWriter(stream, fieldnames=list(rows[0])) + writer.writeheader() + writer.writerows(rows) + + +def _safe_output(output, source_roots): + output = Path(output).resolve() + if any(output == root or root in output.parents for root in source_roots): + raise ValueError("Diagnostics must not be written into source experiment directories") + output.mkdir(parents=True, exist_ok=True) + return output + + +def analyze_saved(repository, output, manifest_path="configs/bios-cross-scale-development-v1.json"): + """Re-score the complete matrix using CPU arrays; never invoke old summary writers.""" + repository = Path(repository).resolve() + manifest_path = repository / manifest_path + manifest = json.loads(manifest_path.read_text()) + source_roots = [(repository / size["output"]).resolve() for size in manifest["sizes"]] + output = _safe_output(output, source_roots) + ledger = {} + + def record(path): + path = Path(path).resolve() + key = str(path.relative_to(repository)) if repository in path.parents else str(path) + digest = file_sha256(path) + if key in ledger and ledger[key] != digest: + raise ValueError(f"Source changed during analysis: {path}") + ledger[key] = digest + + record(manifest_path) + worlds, pairs = {}, {} + learning_rows, editing_rows, error_rows = [], [], [] + counts = { + "models": 0, + "learning_checkpoints": 0, + "edit_cases": 0, + "edit_checkpoints": 0, + "scored_query_predictions": 0, + "classified_derived_predictions": 0, + } + for size, root in zip(manifest["sizes"], source_roots, strict=True): + contract_path = root / "launch-contract.json" + record(contract_path) + contract = json.loads(contract_path.read_text()) + study = contract["study"] + expected_runs = { + (w, seed, condition) + for w in study["worlds"] + for seed in study["seeds"] + for condition in CONDITIONS + } + seen_runs = set() + for config_path in sorted(root.glob("world-*/config.json")): + record(config_path) + config = json.loads(config_path.read_text()) + if config["sources"] != contract["sources"] or config["study"] != study: + raise ValueError(f"Run contract mismatch: {config_path}") + for name, digest in config["sources"].items(): + path = repository / "src/llm_memory_editability" / name + if file_sha256(path) != digest: + raise ValueError(f"Frozen source changed: {name}") + record(path) + run = config_path.parent + key = (config["world"], config["seed"], config["condition"]) + if key in seen_runs: + raise ValueError("Duplicate model") + seen_runs.add(key) + if not (run / "complete.json").exists(): + raise ValueError(f"Incomplete run: {run}") + record(run / "complete.json") + world_seed = config["world"] + if world_seed not in worlds: + worlds[world_seed] = make_cross_world( + world_seed, repository / "data/bios-organization-v1" + ) + world = worlds[world_seed] + if config["truth_sha256"] != array_hash(world.answers) or config[ + "prompts_sha256" + ] != array_hash(world.prompts): + raise ValueError("Generated data mismatch") + common = { + "width": size["width"], + "parameters": config["parameters"], + "world": world_seed, + "seed": config["seed"], + "condition": config["condition"], + } + out_run = output / "queries" / f"width-{size['width']}" / run.name + out_run.mkdir(parents=True, exist_ok=True) + baseline = None + for step in study["checkpoints"]: + prediction_path = run / f"predictions-{step}.npz" + record(prediction_path) + with np.load(prediction_path, allow_pickle=False) as loaded: + arrays = {name: loaded[name] for name in ("prediction", "ended", "correct")} + annotated = annotate_predictions(world, arrays) + np.savez_compressed(out_run / f"learning-{step}.npz", **annotated) + identity = { + **common, + "phase": "learning", + "chain": "", + "kind": "", + "scope": "", + "step": step, + } + learning_rows.extend( + summary_rows(world, annotated, learning_subsets(world), identity) + ) + counts["learning_checkpoints"] += 1 + counts["scored_query_predictions"] += len(world.answers) + counts["classified_derived_predictions"] += world.derived_ids.size + if step == study["steps"]: + baseline = arrays["correct"] + if baseline is None: + raise ValueError("Missing learning endpoint") + for chain, name in enumerate(CHAINS): + pair_key = (world_seed, chain) + if pair_key not in pairs: + pairs[pair_key] = edit_pair(world, chain) + pair = pairs[pair_key] + for kind in ("coherent", "exception"): + target = pair[kind] + for scope in ("mlp", "all"): + case = f"{name}-{kind}-{scope}" + dest = run / "edits" / case + record(dest / "complete.json") + record(dest / "sets.npz") + with np.load(dest / "sets.npz", allow_pickle=False) as loaded: + for field, expected in pair.items(): + if not np.array_equal(loaded[field], expected): + raise ValueError(f"Edit set mismatch: {dest}/{field}") + if not np.array_equal(loaded["old_correct"], baseline): + raise ValueError(f"Edit baseline mismatch: {dest}") + for step in study["edit_checkpoints"]: + prediction_path = dest / f"predictions-{step}.npz" + record(prediction_path) + with np.load(prediction_path, allow_pickle=False) as loaded: + arrays = {k: loaded[k] for k in ("prediction", "ended", "correct")} + annotated = annotate_predictions(world, arrays, target) + np.savez_compressed(out_run / f"{case}-{step}.npz", **annotated) + identity = { + **common, + "phase": "editing", + "chain": name, + "kind": kind, + "scope": scope, + "step": step, + } + editing_rows.extend( + summary_rows( + world, + annotated, + editing_subsets(world, pair, chain, target), + identity, + baseline, + ) + ) + # Readable per-D query ledger, with every ambiguity explicitly retained. + roles, values = candidate_answers(world, chain, target) + for query in pair["D"]: + person = world.person[query] + matches = [ + role + for i, role in enumerate(roles) + if annotated["matched_role_bits"][query] & (1 << i) + ] + code = int(annotated["class_code"][query]) + category = { + TERMINATION_ERROR: "termination_error", + OTHER: "other", + INDISTINGUISHABLE: "indistinguishable", + } + error_rows.append( + { + **identity, + "query": int(query), + "person": int(person), + "heldout": bool(query in world.heldout_ids[chain]), + "old_exception": bool(world.exceptions[chain, person]), + "manipulated_conflict_cohort": bool( + query in pair["conflict_D"] + ), + "factual_conflict": bool( + values[person, 0] != values[person, 1] + ), + "prediction": int(arrays["prediction"][query]), + "ended": bool(arrays["ended"][query]), + "correct": bool(arrays["correct"][query]), + "class": category.get( + code, + roles[code - ROLE_CODE_START] + if code >= ROLE_CODE_START + else "", + ), + "matched_roles": "|".join(matches), + **{ + role: int(values[person, i]) + for i, role in enumerate(roles) + }, + } + ) + counts["edit_checkpoints"] += 1 + counts["scored_query_predictions"] += len(world.answers) + counts["classified_derived_predictions"] += world.derived_ids.size + counts["edit_cases"] += 1 + counts["models"] += 1 + print(json.dumps({"event": "p0_model_scored", **common, **counts}), flush=True) + if seen_runs != expected_runs: + raise ValueError(f"Incomplete or unexpected model grid: width {size['width']}") + if ( + counts["models"] != manifest["learning_runs"] + or counts["edit_cases"] != manifest["edit_cases"] + ): + raise ValueError("Incomplete matrix") + _write_csv(output / "learning-strata.csv", learning_rows) + _write_csv(output / "editing-strata.csv", editing_rows) + _write_csv(output / "propagation-queries.csv", error_rows) + # Verify that reading/analysis did not mutate any source and that no parallel + # process changed this historical input batch while it was being analyzed. + for name, digest in ledger.items(): + if file_sha256(repository / name) != digest: + raise ValueError(f"Source changed during analysis: {name}") + write_json(output / "sources.json", ledger) + write_json( + output / "schema.json", + { + "class_codes": { + "not_applicable_to_base_query": -1, + "termination_error": 0, + "other": 1, + "indistinguishable": 2, + "unique_role_start": 3, + }, + "learning_roles": LEARNING_ROLES, + "editing_roles": EDIT_ROLES, + "matched_role_bits": "bit i indicates value matches role i; EOS checked separately", + "candidate_tokens_shape": "chain, person, role; " + "maps to derived_query_ids[chain, person]", + "interpretation": "Candidate answer agreement is not causal evidence for a path. " + "Overlapping roles are never assigned a preferred interpretation.", + "subset_rows_overlap": True, + "manipulated_conflict_cohort": "Original 45 people, also tagged in coherent controls; " + "factual_conflict is measured from actual target answers.", + }, + ) + code_hashes = { + str(path.relative_to(repository)): file_sha256(path) + for path in (Path(__file__).resolve(), repository / "scripts/analyze_bios_paths.py") + } + audit = { + "complete": True, + **counts, + "source_files": len(ledger), + "sources_sha256": file_sha256(output / "sources.json"), + "analysis_sources": code_hashes, + "errors": [], + "source_data_modified": False, + "source_hashes_rechecked_after_analysis": True, + } + write_json(output / "audit.json", audit) + _report(output, audit, learning_rows, editing_rows) + return audit + + +def _report(output, audit, learning_rows, editing_rows): + lines = [ + "# P0：已有预测的行为诊断", + "", + f"完成{audit['models']}个模型、{audit['edit_cases']}个编辑；" + f"重计分{audit['learning_checkpoints']}个学习和{audit['edit_checkpoints']}个编辑检查点。", + "", + "候选答案相同的角色记为不可区分；答案重合不能证明内部路径。" + "终止失败独立于答案值记录。下表为案例等权均值，非独立查询推断。", + "", + "| 宽度 | 编辑 | 案例 | 冲突留出D | 新实际城市匹配 | 不可区分 | 终止失败 |", + "|---:|---|---:|---:|---:|---:|---:|", + ] + grouped = defaultdict(list) + for row in editing_rows: + if ( + row["kind"] == "exception" + and row["step"] == 512 + and row["subset"] == "D/heldout/manipulated_conflict_cohort" + ): + grouped[row["width"], row["scope"]].append(row) + for (width, scope), rows in sorted(grouped.items()): + rates = [ + np.mean([r[key] / r["n"] for r in rows]) + for key in ("correct", "matches_new_actual", "indistinguishable", "termination_error") + ] + lines.append( + f"| {width} | {scope} | {len(rows)} | " + + " | ".join(f"{100 * rate:.2f}%" for rate in rates) + + " |" + ) + lines += [ + "", + "新实际城市匹配是允许与旧实际/另一条链答案重合的描述性比例；" + "唯一匹配和全部角色位图均另存，不能据此宣称捷径已证实。", + "", + "学习分层见 learning-strata.csv；编辑分层见 editing-strata.csv；" + "每条传播查询见 propagation-queries.csv；全部逐查询数组见 queries/。", + "自主两步前向诊断尚须单独执行并记录模型权重来源。", + "", + ] + (output / "report.md").write_text("\n".join(lines)) + + +def free_generate_values(model, prompts, lengths, device, batch_size=512): + """Exactly the frozen value-plus-EOS generation convention, without targets.""" + import torch + + from .bios_train import precision + + predictions, ended = [], [] + model.eval() + with torch.no_grad(): + for begin in range(0, len(prompts), batch_size): + p = torch.as_tensor(prompts[begin : begin + batch_size], device=device) + n = torch.as_tensor(lengths[begin : begin + batch_size], device=device) + with precision(device): + first = model(p, (n - 1)[:, None])[:, 0].float().argmax(-1) + continuation = torch.zeros((len(p), 6), dtype=torch.long, device=device) + continuation[:, :5] = p + continuation[torch.arange(len(p), device=device), n] = first + second = model(continuation, n[:, None])[:, 0].argmax(-1) + predictions.append(first.cpu().numpy()) + ended.append(second.eq(EOS).cpu().numpy()) + return {"prediction": np.concatenate(predictions), "ended": np.concatenate(ended)} + + +def autonomous_two_step(model, world, chain, device, batch_size=512, answers=None): + """Generate bridge identity, then query that predicted identity, never the true one. + + Truth is accessed only for scoring after both model calls. A wrong but valid + bridge may coincidentally lead to a correct city; keep that outcome and the + first-hop correctness separately. Invalid/unterminated bridges fail outright. + """ + membership_ids = world.membership_ids[chain] + first = free_generate_values( + model, world.prompts[membership_ids], world.lengths[membership_ids], device, batch_size + ) + allowed_subjects = world.prompts[world.root_ids[chain], 1] + valid = first["ended"] & np.isin(first["prediction"], allowed_subjects) + second_prediction = np.full(len(membership_ids), -1, dtype=np.int64) + second_ended = np.zeros(len(membership_ids), dtype=bool) + if valid.any(): + # Root queries have the same grammar and relation token. Do not choose a + # template using true membership; replace the subject using generated data. + root_template = world.prompts[world.root_ids[chain, 0]] + prompts = np.broadcast_to(root_template, (int(valid.sum()), 5)).copy() + prompts[:, 1] = first["prediction"][valid] + lengths = np.full(len(prompts), world.lengths[world.root_ids[chain, 0]], dtype=np.int64) + second = free_generate_values(model, prompts, lengths, device, batch_size) + second_prediction[valid], second_ended[valid] = second["prediction"], second["ended"] + target = world.answers if answers is None else answers + return { + "query_id": world.derived_ids[chain], + "bridge_prediction": first["prediction"], + "bridge_ended": first["ended"], + "bridge_valid": valid, + "bridge_correct": (first["prediction"] == target[membership_ids]) & first["ended"], + "prediction": second_prediction, + "ended": second_ended, + "correct": valid & second_ended & (second_prediction == target[world.derived_ids[chain]]), + } + + +def diagnose_two_step_run( + run, output, device="cuda", learning_steps=(15360,), include_edits=False, batch_size=512 +): + """Independent, resumable forward-only jobs; no optimizer or training mutations.""" + import torch + + from .bios_model import CausalLM, ModelConfig + + run, output = Path(run).resolve(), Path(output).resolve() + repository = Path(__file__).resolve().parents[2] + output = _safe_output(output, [run]) + config = json.loads((run / "config.json").read_text()) + world = make_cross_world(config["world"], repository / "data/bios-organization-v1") + if array_hash(world.answers) != config["truth_sha256"]: + raise ValueError("Two-step world differs from trained world") + device = torch.device(device) + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + jobs = [ + ( + f"learning-{step}", + run / f"model-{step}.pt", + world.answers, + run / f"predictions-{step}.npz", + ) + for step in learning_steps + ] + if include_edits: + for chain, name in enumerate(CHAINS): + pair = edit_pair(world, chain) + for kind in ("coherent", "exception"): + for scope in ("mlp", "all"): + dest = run / "edits" / f"{name}-{kind}-{scope}" + jobs.append( + ( + dest.name, + dest / "model-final.pt", + pair[kind], + dest / f"predictions-{config['study']['edit_steps']}.npz", + ) + ) + for label, checkpoint, answers, direct_path in jobs: + dest = output / label + dest.mkdir(parents=True, exist_ok=True) + identity = { + "run": str(run), + "checkpoint": str(checkpoint), + "checkpoint_sha256": file_sha256(checkpoint), + "direct_predictions_sha256": file_sha256(direct_path), + "config_sha256": file_sha256(run / "config.json"), + "diagnostic_source_sha256": file_sha256(__file__), + "answer_sha256": array_hash(answers), + "batch_size": batch_size, + "device_type": device.type, + "torch": torch.__version__, + "precision": "BF16 autocast; FP32 weights" if device.type == "cuda" else "FP32", + } + complete_path = dest / "complete.json" + if complete_path.exists(): + saved = json.loads(complete_path.read_text()) + if saved["identity"] != identity: + raise ValueError(f"Changed diagnostic identity: {dest}") + continue + saved = torch.load(checkpoint, map_location="cpu", weights_only=False) + model = CausalLM(ModelConfig(**saved["config"])) + model.load_state_dict(saved["model"]) + model.to(device).eval() + with np.load(direct_path) as data: + direct = {k: data[k] for k in ("prediction", "ended", "correct")} + score_saved_arrays(direct, answers) + rows = [] + for chain, name in enumerate(CHAINS): + arrays = autonomous_two_step(model, world, chain, device, batch_size, answers) + ids = world.derived_ids[chain] + arrays.update({f"direct_{k}": v[ids] for k, v in direct.items()}) + np.savez_compressed(dest / f"{name}.npz", **arrays) + for split, mask in ( + ("all", np.ones(len(ids), dtype=bool)), + ("trained", np.isin(ids, world.train_ids[chain])), + ("heldout", np.isin(ids, world.heldout_ids[chain])), + ): + for population, population_mask in ( + ("all", np.ones(len(ids), dtype=bool)), + ("ordinary", ~world.exceptions[chain]), + ("old_exception", world.exceptions[chain]), + ): + selected = mask & population_mask + n = int(selected.sum()) + rows.append( + { + "chain": name, + "split": split, + "population": population, + "n": n, + **{ + key: int(arrays[key][selected].sum()) + for key in ( + "correct", + "direct_correct", + "bridge_valid", + "bridge_correct", + ) + }, + } + ) + _write_csv(dest / "summary.csv", rows) + write_json( + complete_path, + { + "identity": identity, + "complete": True, + "queries": int(world.derived_ids.size), + "oracle_bridging": False, + }, + ) + del model, saved + if device.type == "cuda": + torch.cuda.empty_cache() + print( + json.dumps({"event": "two_step_complete", "run": str(run), "case": label}), flush=True + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_minimal.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_minimal.py new file mode 100644 index 0000000000000000000000000000000000000000..bc2ed53451de1a88abe78ee5e58cb49745597c2b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_minimal.py @@ -0,0 +1,379 @@ +"""Two-layer follow-up: common-error removal versus competing new answers.""" + +import argparse +import fcntl +import itertools +import json +import os +import subprocess +import sys +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_data import write_json +from .bios_model import CausalLM, ModelConfig +from .bios_path_transfer import ROOT, inner, norm, path_mode, sha, stamp, tensor_sha + +CONFIG = ROOT / "configs/bios-path-minimal-v1.json" + + +def toy_data(config, device): + people = config["people"] + person = torch.arange(people, device=device).repeat_interleave(3) + relation = torch.arange(3, device=device).repeat(people) + value_start = 3 + people + 3 + tokens = torch.stack( + (torch.ones_like(person), 3 + person, 3 + people + relation, torch.full_like(person, 2)), -1 + ) + labels = value_start + (person + (relation == 2)) % 3 + return tokens, labels, value_start + + +def probe_data(config, person, kind, device): + tokens, old, values = toy_data(config, device) + ids = torch.arange(person * 3, person * 3 + 3, device=device) + a, b, c = values + (person + 1) % 3, values + (person + 2) % 3, values + person % 3 + labels = old[ids].clone() + labels[0], labels[1] = a if kind == "coherent" else b, a + return tokens[ids], labels, (a, b, c) + + +def gradients(model, tokens, labels, arm): + projection = model.blocks[0].mlp.down + captured = {} + + def hook(module, inputs, output): + captured["z"], captured["h"] = inputs[0], output + + handle = projection.register_forward_hook(hook) + try: + with path_mode(model, 0, arm): + logits = model(tokens)[:, -1] + loss = F.cross_entropy(logits.double(), labels, reduction="none") + actual, delta = torch.autograd.grad(loss.sum(), (projection.weight, captured["h"])) + z, delta = captured["z"].detach(), delta.detach() + g = torch.einsum("btd,btk->btdk", delta, z).sum(1) + if norm(g.sum(0) - actual) / max(norm(actual), 1e-30) > 5e-5: + raise ValueError("Minimal-model gradient reconstruction failed") + return {"logits": logits.detach(), "loss": loss.detach(), "g": g, "z": z, "delta": delta} + finally: + handle.remove() + + +@torch.no_grad() +def evaluate(model, tokens, labels, values): + logits = model(tokens)[:, -1].double() + p = logits.softmax(-1) + a, b, c = values + return { + "loss": F.cross_entropy(logits, labels, reduction="none").cpu().tolist(), + "prediction": logits.argmax(-1).cpu().tolist(), + "probabilities_abc": p[:, [a, b, c]].cpu().tolist(), + "source_target_probability": p[0, labels[0]].item(), + "derived_margin_ab": (logits[1, a] - logits[1, b]).item(), + "isotropic_same_probability_reference": (p[1].square().sum() - p[1, a] - p[1, b]).item(), + } + + +def freeze(config): + directory = ROOT / config["artifacts"] + directory.mkdir(parents=True, exist_ok=True) + path = directory / "preregistration-lock.json" + if path.exists(): + raise FileExistsError("Cannot replace minimal-model prospective lock") + section = ( + "### 18.7 " + (ROOT / "docs/experimental-protocol.md").read_text().split("### 18.7 ", 1)[1] + ) + (directory / "preregistration.md").write_text(section) + files = [ + CONFIG, + Path(__file__), + ROOT / "scripts/run_bios_path_minimal.py", + ROOT / "scripts/analyze_bios_path_margin.py", + ROOT / "tests/test_bios_path_minimal.py", + ROOT / "src/llm_memory_editability/bios_path_transfer.py", + ROOT / "src/llm_memory_editability/bios_model.py", + ROOT / "docs/development-artifacts/path-transfer-v1/audit.json", + ] + sources = {} + for file in files: + relative = file.relative_to(ROOT) + sources[str(relative)] = sha(file) + destination = directory / "frozen-files" / relative + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_bytes(file.read_bytes()) + write_json( + path, + { + "created_at": stamp(), + "config": config, + "sources": sources, + "protocol_sha256": sha(directory / "preregistration.md"), + "torch": torch.__version__, + }, + ) + return {"lock": str(path), "sha256": sha(path)} + + +def verify(config): + directory = ROOT / config["artifacts"] + path = directory / "preregistration-lock.json" + lock = json.loads(path.read_text()) + if lock["config"] != config or lock["torch"] != torch.__version__: + raise ValueError("Minimal config/runtime changed") + for name, digest in lock["sources"].items(): + if sha(ROOT / name) != digest: + raise ValueError("Minimal frozen source changed: " + name) + if sha(directory / "preregistration.md") != lock["protocol_sha256"]: + raise ValueError("Minimal protocol changed") + return sha(path) + + +def learn(config, seed, device, out): + torch.manual_seed(seed) + tokens, labels, values = toy_data(config, device) + model = CausalLM(ModelConfig(values + 3, config["width"], 2, config["heads"], context=8)).to( + device + ) + if (out / "parent.pt").exists(): + saved = torch.load(out / "parent.pt", map_location=device, weights_only=False) + model.load_state_dict(saved["model"]) + return model + optimizer = torch.optim.AdamW( + model.parameters(), lr=config["train_lr"], weight_decay=config["train_weight_decay"] + ) + trajectory = [] + for step in range(config["train_steps"] + 1): + logits = model(tokens)[:, -1] + loss = F.cross_entropy(logits, labels) + if step in (0, 128, 512, config["train_steps"]): + trajectory.append( + { + "step": step, + "loss": loss.item(), + "accuracy": logits.argmax(-1).eq(labels).float().mean().item(), + } + ) + if step == config["train_steps"]: + break + optimizer.zero_grad(set_to_none=True) + loss.backward() + optimizer.step() + torch.save( + { + "model": {k: v.detach().cpu() for k, v in model.state_dict().items()}, + "config": model.config_dict(), + "step": config["train_steps"], + }, + out / "parent.pt", + ) + write_json(out / "learning.json", trajectory) + return model + + +def trajectory(model, parent, config, person, kind, arm, device, directory): + model.load_state_dict(parent) + model.eval() + for name, parameter in model.named_parameters(): + parameter.requires_grad_(name == config["target_parameter"]) + tokens, labels, values = probe_data(config, person, kind, device) + w = model.blocks[0].mlp.down.weight + timeline, steps, factors = [], [], [] + for step in range(config["edit_steps"] + 1): + measure = step % config["measure_every"] == 0 or step == config["edit_steps"] + full = gradients( + model, tokens if measure else tokens[:1], labels if measure else labels[:1], "full" + ) + source = full if arm == "full" else gradients(model, tokens[:1], labels[:1], arm) + if not torch.equal(full["logits"][:1], source["logits"][:1]): + # Different batch sizes allow only normal FP32 GEMM rounding. + if (full["logits"][:1] - source["logits"][:1]).abs().max().item() > 3e-5: + raise ValueError("Minimal forward mismatch") + raw, original = source["g"][0], full["g"][0] + direction = raw * (norm(original) / norm(raw)) if norm(raw) else raw + if measure: + row = { + "step": step, + **evaluate(model, tokens, labels, values), + "source_gradient_norm": norm(original), + "intervened_gradient_norm": norm(raw), + "kernel_source": inner(full["g"][0], direction), + "kernel_derived": inner(full["g"][1], direction), + "kernel_retention": inner(full["g"][2], direction), + "kernel_derived_full": inner(full["g"][1], original), + } + timeline.append(row) + factors.append( + { + key: value.detach().cpu().numpy() + for key, value in { + "z": full["z"], + "delta": full["delta"], + "source_z": source["z"][:1], + "source_delta": source["delta"][:1], + }.items() + } + ) + if step == config["edit_steps"]: + break + before_weight = w.detach().clone() if measure else None + with torch.no_grad(): + w.add_(direction, alpha=-config["edit_lr"]) + if measure: + after = evaluate(model, tokens, labels, values) + actual_delta = w.detach() - before_weight + row["one_step_observed_derived"] = after["loss"][1] - row["loss"][1] + row["one_step_predicted_derived"] = inner(full["g"][1], actual_delta) + row["one_step_margin_change"] = after["derived_margin_ab"] - row["derived_margin_ab"] + steps.append( + { + "step": step, + "source_loss": full["loss"][0].item(), + "direction_norm": norm(direction), + "source_gradient_norm": norm(original), + } + ) + for name, value in model.state_dict().items(): + if name != config["target_parameter"] and not torch.equal(value, parent[name]): + raise ValueError("Minimal frozen parameter changed") + directory.mkdir(parents=True, exist_ok=True) + write_json( + directory / "trajectory.json", + { + "person": person, + "kind": kind, + "arm": arm, + "values_abc": values, + "labels": labels.cpu().tolist(), + "timeline": timeline, + "steps": steps, + }, + ) + np.savez_compressed( + directory / "factors.npz", + **{key: np.stack([factor[key] for factor in factors]) for key in factors[0]}, + ) + torch.save(w.detach().cpu(), directory / "edited-weight.pt") + write_json( + directory / "complete.json", + { + "finished_at": stamp(), + "steps": len(steps), + "weight_sha256": tensor_sha(w), + "frozen_parameters_unchanged": True, + "files": { + name: sha(directory / name) + for name in ("trajectory.json", "factors.npz", "edited-weight.pt") + }, + }, + ) + + +def run(config, seed, device): + lock_hash = verify(config) + if seed not in config["seeds"]: + raise ValueError("Unknown seed") + torch.set_num_threads(2) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + out = ROOT / config["output"] / f"seed-{seed}" + out.mkdir(parents=True, exist_ok=True) + with (out / ".lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + write_json( + out / "runtime.json", + { + "started_at": stamp(), + "lock_sha256": lock_hash, + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES"), + }, + ) + model = learn(config, seed, device, out) + parent = {k: v.detach().clone() for k, v in model.state_dict().items()} + for person, kind, arm in itertools.product( + config["people_to_edit"], config["kinds"], config["arms"] + ): + directory = out / f"person-{person}-{kind}-{arm}" + if not (directory / "complete.json").exists(): + trajectory(model, parent, config, person, kind, arm, device, directory) + print( + json.dumps( + { + "event": "trajectory", + "seed": seed, + "person": person, + "kind": kind, + "arm": arm, + } + ), + flush=True, + ) + write_json( + out / "complete.json", + { + "finished_at": stamp(), + "lock_sha256": lock_hash, + "files": { + str(path.relative_to(out)): sha(path) + for path in out.rglob("*") + if path.is_file() and path != out / "complete.json" and path.name != ".lock" + }, + }, + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("command", choices=("freeze", "worker", "dispatch")) + parser.add_argument("--seed", type=int) + parser.add_argument("--device", default="cuda:0") + parser.add_argument("--gpus", nargs="+", type=int, default=[5, 8]) + args = parser.parse_args() + config = json.loads(CONFIG.read_text()) + if args.command == "freeze": + print(json.dumps(freeze(config))) + elif args.command == "worker": + run(config, args.seed, torch.device(args.device)) + else: + verify(config) + output = ROOT / config["output"] + output.mkdir(parents=True, exist_ok=True) + workers = [] + for index, seed in enumerate(config["seeds"]): + log = (output / f"seed-{seed}.log").open("a") + env = { + **os.environ, + "CUDA_VISIBLE_DEVICES": str(args.gpus[index % len(args.gpus)]), + "PYTHONPATH": str(ROOT / "src"), + "OMP_NUM_THREADS": "2", + "OPENBLAS_NUM_THREADS": "2", + } + proc = subprocess.Popen( + [ + sys.executable, + str(ROOT / "scripts/run_bios_path_minimal.py"), + "worker", + "--seed", + str(seed), + ], + env=env, + cwd=ROOT, + stdout=log, + stderr=subprocess.STDOUT, + ) + workers.append((proc, log)) + codes = [] + for proc, log in workers: + codes.append(proc.wait()) + log.close() + write_json(output / "dispatch.json", {"finished_at": stamp(), "returncodes": codes}) + if any(codes): + raise RuntimeError("Minimal worker failed; see retained logs") + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_transfer.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_transfer.py new file mode 100644 index 0000000000000000000000000000000000000000..0c54e9cfda468b9a153577dd716a037dde1577f1 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_path_transfer.py @@ -0,0 +1,653 @@ +"""Prospective v2.13: forward-preserving path interventions and local transfer. + +Only a single MLP output weight is differentiated/updated in production. +Downstream parameters are frozen; the custom attention paths alter its input VJP. +""" + +import argparse +import fcntl +import hashlib +import itertools +import json +import os +import platform +import subprocess +import sys +import time +from contextlib import contextmanager +from datetime import datetime, timezone +from pathlib import Path +from types import MethodType + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_cross import edit_pair, make_cross_world +from .bios_cross_train import tensor_queries +from .bios_data import EOS, array_hash, write_json +from .bios_model import CausalLM, ModelConfig + +ROOT = Path(__file__).resolve().parents[2] +CONFIG = ROOT / "configs/bios-path-transfer-v1.json" +ARMS = ("full", "no_cross", "no_mlp", "fixed_qk") + + +def stamp(): + return datetime.now(timezone.utc).isoformat() + + +def sha(path): + result = hashlib.sha256() + with Path(path).open("rb") as stream: + for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""): + result.update(chunk) + return result.hexdigest() + + +def tensor_sha(value): + return hashlib.sha256(value.detach().cpu().contiguous().numpy().tobytes()).hexdigest() + + +def inner(a, b): + return (a.double() * b.double()).sum().item() + + +def norm(a): + return a.double().norm().item() + + +def relative(a, b): + return norm(a - b) / max(norm(b), 1e-30) + + +def cosine(a, b): + return inner(a, b) / max(norm(a) * norm(b), 1e-30) + + +def attention_surrogate(module, x, mode): + """Correct input Jacobian for frozen QK, or only the diagonal position blocks. + + no_cross makes T copies of the input: copy s only differentiates x_s, + then computes output s with the full original causal context. Thus Q_s, + K_s and V_s derivatives survive; all x_t -> output_s, t != s vanish. + """ + batch, length, width = x.shape + heads, dim = module.heads, width // module.heads + if mode == "no_cross": + expanded = x[:, None].expand(batch, length, length, width) + diagonal = torch.eye(length, device=x.device, dtype=x.dtype)[None, :, :, None] + routed = expanded.detach() + diagonal * (expanded - expanded.detach()) + q, k, v = module.qkv(routed).reshape(batch, length, length, 3, heads, dim).unbind(3) + index = torch.arange(length, device=x.device) + q = q[:, index, index] # B, query, H, D + scores = torch.einsum("bshd,bsthd->bhst", q, k) / dim**0.5 + mask = torch.ones(length, length, device=x.device, dtype=torch.bool).tril() + a = scores.masked_fill(~mask, -torch.inf).softmax(-1) + output = torch.einsum("bhst,bsthd->bshd", a, v).reshape(batch, length, width) + else: + q, k, v = module.qkv(x).reshape(batch, length, 3, heads, dim).unbind(2) + scores = torch.einsum("bshd,bthd->bhst", q, k) / dim**0.5 + mask = torch.ones(length, length, device=x.device, dtype=torch.bool).tril() + a = scores.masked_fill(~mask, -torch.inf).softmax(-1) + if mode == "fixed_qk": + a = a.detach() + elif mode != "manual_full": + raise ValueError(mode) + output = torch.einsum("bhst,bthd->bshd", a, v).reshape(batch, length, width) + return module.proj(output) + + +@contextmanager +def path_mode(model, layer, arm): + if arm not in (*ARMS, "manual_full"): + raise ValueError(arm) + saved = [] + try: + for block in model.blocks[layer + 1 :]: + if arm == "no_mlp": + module = block.mlp + original = module.forward + + def stopped(self, x, original=original): + with torch.no_grad(): + return original(x) + + module.forward = MethodType(stopped, module) + saved.append((module, original)) + elif arm != "full": + module = block.attention + original = module.forward + + def altered(self, x, original=original, arm=arm): + with torch.no_grad(): + reference = original(x) + surrogate = attention_surrogate(self, x, arm) + return reference + (surrogate - surrogate.detach()) + + module.forward = MethodType(altered, module) + saved.append((module, original)) + yield + finally: + for module, original in saved: + module.forward = original + + +def cases(world): + result = [] + for chain in range(2): + pair = edit_pair(world, chain) + for group in pair["groups"]: + members = np.flatnonzero(world.memberships[chain] == group) + eligible = members[ + np.isin(world.derived_ids[chain, members], world.heldout_ids) + & np.isin(world.derived_ids[chain, members], pair["conflict_D"]) + ] + if not len(eligible): + raise ValueError("No prespecified heldout conflict person") + person = int(eligible[0]) + others = members[ + (members != person) + & ~world.exceptions[chain, members] + & np.isin(world.derived_ids[chain, members], world.heldout_ids) + ] + if not len(others): + raise ValueError("No prespecified second heldout person") + other = int(others[0]) + distant = int(np.flatnonzero(~np.isin(world.memberships[chain], pair["groups"]))[0]) + root = int(world.root_ids[chain, group]) + actual = int(world.actual_ids[chain, person]) + default = int(pair["coherent"][root]) + alternative = int(pair["exception"][actual]) + if default == alternative: + raise ValueError("Selected person is not a new conflict") + for kind in ("root", "coherent", "conflict"): + source = root if kind == "root" else actual + target = alternative if kind == "conflict" else default + associated = actual if kind == "root" else root + ids = [ + source, + int(world.derived_ids[chain, person]), + int(world.derived_ids[chain, other]), + associated, + int(world.actual_ids[1 - chain, person]), + int(world.actual_ids[chain, distant]), + ] + targets = [target, default, default, default, *world.answers[ids[-2:]].tolist()] + result.append( + { + "name": f"chain-{chain}-group-{int(group)}-{kind}", + "chain": chain, + "group": int(group), + "kind": kind, + "person": person, + "other_person": other, + "ids": ids, + "targets": targets, + "old_targets": world.answers[ids].tolist(), + "roles": [ + "source", + "derived_same", + "derived_other", + "associated", + "retention_local", + "retention_distant", + ], + } + ) + return result + + +def example_data(world, case, device): + # Use the original interface, including teacher-forced answer for EOS loss. + targets = world.answers.copy() + targets[case["ids"]] = case["targets"] + all_data = tensor_queries(world, device, targets) + ids = torch.tensor(case["ids"], device=device) + return {key: value[ids] for key, value in all_data.items()} + + +def subset(data, ids): + return {key: value[ids] for key, value in data.items()} + + +def losses(logits, labels): + return ( + F.cross_entropy( + logits.double().reshape(-1, logits.shape[-1]), labels.reshape(-1), reduction="none" + ) + .reshape(-1, 2) + .mean(-1) + ) + + +def measure(model, data, layer, arm): + projection = model.blocks[layer].mlp.down + captured = {} + + def hook(module, inputs, output): + captured["z"], captured["h"] = inputs[0], output + + handle = projection.register_forward_hook(hook) + try: + with path_mode(model, layer, arm): + logits = model(data["tokens"], data["positions"]) + loss = losses(logits, data["labels"]) + actual, delta = torch.autograd.grad(loss.sum(), (projection.weight, captured["h"])) + z = captured["z"].detach() + delta = delta.detach() + per_position = torch.einsum("btd,btk->btdk", delta, z) + mask = torch.zeros(z.shape[:2], device=z.device, dtype=torch.bool) + mask.scatter_(1, data["positions"], True) + g = per_position.sum(1) + supervised = (per_position * mask[:, :, None, None]).sum(1) + unsupervised = (per_position * ~mask[:, :, None, None]).sum(1) + return { + "z": z, + "delta": delta, + "g": g, + "supervised": supervised, + "unsupervised": unsupervised, + "mask": mask, + "loss": loss.detach(), + "logits": logits.detach(), + "reconstruction_error": relative(g.sum(0), actual), + "decomposition_error": relative(supervised + unsupervised, g), + } + finally: + handle.remove() + + +@torch.no_grad() +def assess(model, data): + logits = model(data["tokens"], data["positions"]) + loss = losses(logits, data["labels"]) + first = model(data["prompts"], (data["lengths"] - 1)[:, None])[:, 0].argmax(-1) + continuation = data["tokens"].clone() + rows = torch.arange(len(first), device=first.device) + continuation[rows, data["lengths"]] = first + ended = model(continuation, data["lengths"][:, None])[:, 0].argmax(-1).eq(EOS) + return loss, first, ended + + +def frozen_files(config): + paths = [ + CONFIG, + Path(__file__), + ROOT / "scripts/run_bios_path_transfer.py", + ROOT / "tests/test_bios_path_transfer.py", + ] + for name in ("bios_model.py", "bios_cross.py", "bios_cross_train.py", "bios_data.py"): + paths.append(ROOT / "src/llm_memory_editability" / name) + for world in config["worlds"]: + directory = ROOT / config["source_world_root"] / f"world-{world}" + paths += [ + directory / "world.npz", + directory / "metadata.json", + directory / "evaluation.npz", + ] + for world, seed in itertools.product(config["worlds"], config["seeds"]): + directory = ROOT / config["parent_root"] / f"world-{world}-seed-{seed}-neither" + paths += [directory / "config.json", directory / "learning-complete.json"] + paths += [directory / f"model-{step}.pt" for step in config["states"]] + return paths + + +def freeze(config): + directory = ROOT / config["artifacts"] + directory.mkdir(parents=True, exist_ok=True) + lock_path = directory / "preregistration-lock.json" + if lock_path.exists(): + raise FileExistsError("Cannot replace a prospective lock") + protocol = ( + "## 18. " + (ROOT / "docs/experimental-protocol.md").read_text().split("## 18. ", 1)[1] + ) + (directory / "preregistration.md").write_text(protocol) + manifests = {} + for world in config["worlds"]: + generated = make_cross_world(world, ROOT / config["source_world_root"]) + selected = cases(generated) + if len(selected) != config["cases_per_state"]: + raise ValueError("Case count mismatch") + manifests[str(world)] = { + "truth_sha256": array_hash(generated.answers), + "prompts_sha256": array_hash(generated.prompts), + "cases": selected, + } + write_json(directory / "cases.json", manifests) + sources = {} + for path in frozen_files(config): + relative_path = path.relative_to(ROOT) + sources[str(relative_path)] = sha(path) + if relative_path.parts[0] in ("src", "scripts", "tests", "configs"): + destination = directory / "frozen-files" / relative_path + destination.parent.mkdir(parents=True, exist_ok=True) + destination.write_bytes(path.read_bytes()) + lock = { + "created_at": stamp(), + "config": config, + "sources": sources, + "protocol_sha256": sha(directory / "preregistration.md"), + "cases_sha256": sha(directory / "cases.json"), + "torch": torch.__version__, + "numpy": np.__version__, + "python": platform.python_version(), + } + write_json(lock_path, lock) + return {"path": str(lock_path), "sha256": sha(lock_path)} + + +def verify_lock(config): + directory = ROOT / config["artifacts"] + path = directory / "preregistration-lock.json" + lock = json.loads(path.read_text()) + if lock["config"] != config or lock["torch"] != torch.__version__: + raise ValueError("Frozen config/runtime mismatch") + for name, digest in lock["sources"].items(): + if sha(ROOT / name) != digest: + raise ValueError("Frozen input changed: " + name) + for name, key in (("preregistration.md", "protocol_sha256"), ("cases.json", "cases_sha256")): + if sha(directory / name) != lock[key]: + raise ValueError("Prospective manifest changed") + return sha(path) + + +def save_factors(path, baseline, sources, data): + arrays = { + "positions": data["positions"].cpu().numpy(), + "labels": data["labels"].cpu().numpy(), + "tokens": data["tokens"].cpu().numpy(), + } + for prefix, result in [("evaluation", baseline), *sources.items()]: + for key in ("z", "delta", "loss"): + arrays[prefix + "_" + key] = result[key].cpu().numpy() + np.savez_compressed(path, **arrays) + + +def run_case(model, world, case, config, destination): + layer = config["target_layer"] + w = model.blocks[layer].mlp.down.weight + parent = w.detach().clone() + frozen_before = { + name: tensor_sha(value) + for name, value in model.state_dict().items() + if name != config["target_parameter"] + } + data = example_data(world, case, w.device) + baseline = measure(model, data, layer, "full") + before, old_prediction, old_ended = assess(model, data) + sources, diagnostics, updates = {}, [], [] + with torch.no_grad(): + if not torch.equal(before, baseline["loss"]): + raise ValueError("Evaluation/gradient forward mismatch") + for arm in config["arms"]: + source = measure(model, subset(data, slice(0, 1)), layer, arm) + sources[arm] = source + error = (source["logits"] - sources["full"]["logits"]).abs().max().item() + if error > config["forward_tolerance"]: + raise ValueError(f"Forward preservation failed: {error}") + if ( + max(source["reconstruction_error"], baseline["reconstruction_error"]) + > config["gradient_tolerance"] + ): + raise ValueError("Outer-product reconstruction failed") + direction = source["g"][0] + gfull = sources["full"]["g"][0] + if arm == "no_cross" and norm(source["unsupervised"]) > 1e-9: + raise ValueError("Cross-position cut did not eliminate unsupervised-position gradient") + for j, role in enumerate(case["roles"]): + row = { + "arm": arm, + "role": role, + "probe": j, + "forward_error": error, + "reconstruction_error": source["reconstruction_error"], + "gradient_norm": norm(direction), + "gradient_cosine_full": cosine(direction, gfull), + "supervised_norm": norm(source["supervised"]), + "unsupervised_norm": norm(source["unsupervised"]), + "kernel": inner(baseline["g"][j], direction), + "source_loss": source["loss"].item(), + "probe_loss": before[j].item(), + } + for left, right in itertools.product(("supervised", "unsupervised"), repeat=2): + row[f"kernel_{left}_{right}"] = inner(baseline[left][j], source[right][0]) + diagnostics.append(row) + for scale, fraction in itertools.product(config["scales"], config["step_fractions"]): + denominator = norm(gfull if scale == "shared_lr" else direction) + eta = fraction * norm(parent) / denominator if denominator else 0.0 + with torch.no_grad(): + w.copy_(parent - eta * direction) + displacement = w.detach() - parent + weight_hash = tensor_sha(w) + after, predicted_token, ended = assess(model, data) + predicted = (baseline["g"].double() * displacement.double()).sum((-1, -2)) + for j, role in enumerate(case["roles"]): + updates.append( + { + "arm": arm, + "scale": scale, + "fraction": fraction, + "eta": eta, + "update_norm": norm(displacement), + "weight_sha256": weight_hash, + "role": role, + "probe": j, + "id": case["ids"][j], + "target": case["targets"][j], + "old_target": case["old_targets"][j], + "before": before[j].item(), + "after": after[j].item(), + "observed_change": (after[j] - before[j]).item(), + "predicted_change": predicted[j].item(), + "ideal_predicted_change": -eta * inner(baseline["g"][j], direction), + "baseline_prediction": int(old_prediction[j]), + "baseline_ended": bool(old_ended[j]), + "prediction": int(predicted_token[j]), + "ended": bool(ended[j]), + } + ) + with torch.no_grad(): + w.copy_(parent) + if not torch.equal(w, parent): + raise ValueError("Parent weight was not restored") + frozen_after = { + name: tensor_sha(value) + for name, value in model.state_dict().items() + if name != config["target_parameter"] + } + if frozen_before != frozen_after: + raise ValueError("A frozen parameter changed") + destination.mkdir(parents=True, exist_ok=True) + save_factors(destination / "factors.npz", baseline, sources, data) + write_json( + destination / "measurements.json", + {"case": case, "diagnostics": diagnostics, "updates": updates}, + ) + write_json( + destination / "receipt.json", + { + "finished_at": stamp(), + "files": { + name: sha(destination / name) for name in ("factors.npz", "measurements.json") + }, + "baseline_reconstruction_error": baseline["reconstruction_error"], + "frozen_parameters_unchanged": True, + "parent_restored": True, + }, + ) + + +def verify_receipt(directory): + receipt = json.loads((directory / "receipt.json").read_text()) + for name, digest in receipt["files"].items(): + if sha(directory / name) != digest: + raise ValueError("Receipt mismatch: " + str(directory / name)) + + +def run(config, world_id, seed, device): + lock_hash = verify_lock(config) + if world_id not in config["worlds"] or seed not in config["seeds"]: + raise ValueError("Worker outside the frozen matrix") + torch.set_num_threads(2) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + world = make_cross_world(world_id, ROOT / config["source_world_root"]) + name = f"world-{world_id}-seed-{seed}-neither" + source = ROOT / config["parent_root"] / name + out = ROOT / config["output"] / name + out.mkdir(parents=True, exist_ok=True) + with (out / ".lock").open("a") as stream: + fcntl.flock(stream, fcntl.LOCK_EX | fcntl.LOCK_NB) + started = time.monotonic() + write_json( + out / "runtime.json", + { + "started_at": stamp(), + "lock_sha256": lock_hash, + "device": str(device), + "gpu": torch.cuda.get_device_name(device) if "cuda" in str(device) else None, + "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES"), + "torch": torch.__version__, + }, + ) + for step in config["states"]: + checkpoint = torch.load( + source / f"model-{step}.pt", map_location="cpu", weights_only=False + ) + if checkpoint["step"] != step: + raise ValueError("Parent step mismatch") + model = CausalLM(ModelConfig(**checkpoint["config"])).to(device) + model.load_state_dict(checkpoint["model"]) + model.eval() + for pname, parameter in model.named_parameters(): + parameter.requires_grad_(pname == config["target_parameter"]) + selected = cases(world) + state_out = out / f"step-{step}" + state_out.mkdir(exist_ok=True) + # Original-forward repeated gradient, not a new scientific sample. + sham_data = subset(example_data(world, selected[0], device), slice(0, 1)) + first = measure(model, sham_data, config["target_layer"], "full") + second = measure(model, sham_data, config["target_layer"], "full") + sham_error = relative(first["g"], second["g"]) + if sham_error > config["gradient_tolerance"]: + raise ValueError("Sham gradient failed") + write_json(state_out / "sham.json", {"relative_gradient_error": sham_error}) + for case in selected: + destination = state_out / case["name"] + if (destination / "receipt.json").exists(): + verify_receipt(destination) + else: + run_case(model, world, case, config, destination) + print( + json.dumps( + { + "event": "case", + "world": world_id, + "seed": seed, + "step": step, + "case": case["name"], + } + ), + flush=True, + ) + del model, checkpoint + files = { + str(path.relative_to(out)): sha(path) + for path in out.rglob("*") + if path.is_file() and path.name not in (".lock", "complete.json") + } + write_json( + out / "complete.json", + { + "finished_at": stamp(), + "seconds": time.monotonic() - started, + "lock_sha256": lock_hash, + "cases": len(config["states"]) * len(selected), + "files": files, + }, + ) + + +def dispatch(config, gpus): + verify_lock(config) + output = ROOT / config["output"] + output.mkdir(parents=True, exist_ok=True) + jobs = list(itertools.product(config["worlds"], config["seeds"])) + active, finished = [], [] + with (output / ".dispatch.lock").open("a") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + while jobs or active: + for gpu in gpus: + if jobs and not any(item["gpu"] == gpu for item in active): + world, seed = jobs.pop(0) + path = output / f"world-{world}-seed-{seed}-neither" + if (path / "complete.json").exists(): + finished.append({"world": world, "seed": seed, "reused": True}) + continue + log = (output / f"world-{world}-seed-{seed}.log").open("a") + env = { + **os.environ, + "CUDA_VISIBLE_DEVICES": str(gpu), + "PYTHONPATH": str(ROOT / "src"), + "OMP_NUM_THREADS": "2", + "OPENBLAS_NUM_THREADS": "2", + } + command = [ + sys.executable, + str(ROOT / "scripts/run_bios_path_transfer.py"), + "worker", + "--world", + str(world), + "--seed", + str(seed), + "--device", + "cuda:0", + ] + proc = subprocess.Popen( + command, cwd=ROOT, env=env, stdout=log, stderr=subprocess.STDOUT + ) + active.append( + {"gpu": gpu, "world": world, "seed": seed, "process": proc, "log": log} + ) + for item in active[:]: + code = item["process"].poll() + if code is not None: + item["log"].close() + record = {k: item[k] for k in ("gpu", "world", "seed")} + finished.append({**record, "returncode": code}) + active.remove(item) + write_json( + output / "dispatch.json", + { + "updated_at": stamp(), + "pending": jobs, + "running": [{k: x[k] for k in ("gpu", "world", "seed")} for x in active], + "finished": finished, + }, + ) + if active: + time.sleep(2) + if any(item.get("returncode", 0) for item in finished): + raise RuntimeError("One or more workers failed; inspect preserved logs") + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("command", choices=("freeze", "worker", "dispatch")) + parser.add_argument("--world", type=int) + parser.add_argument("--seed", type=int) + parser.add_argument("--device", default="cuda:0") + parser.add_argument("--gpus", type=int, nargs="+", default=[5, 8]) + args = parser.parse_args() + config = json.loads(CONFIG.read_text()) + if args.command == "freeze": + print(json.dumps(freeze(config))) + elif args.command == "worker": + run(config, args.world, args.seed, torch.device(args.device)) + else: + dispatch(config, args.gpus) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_readout_control.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_readout_control.py new file mode 100644 index 0000000000000000000000000000000000000000..877089e7e83d985cfb9e4b5e65920b2db8312d4d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_readout_control.py @@ -0,0 +1,373 @@ +"""H5: original E93 exception edits of all weights except tied token/readout weights.""" + +import argparse +import fcntl +import json +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_cross import CHAINS, CONDITIONS, edit_pair, make_cross_world +from .bios_cross_continue import ( + capture_state, + edit_metrics, + edit_update, + file_hash, + restore_state, + validate_optimizer, +) +from .bios_cross_train import evaluate, source_hashes, tensor_queries +from .bios_data import array_hash, rng_for, write_json +from .bios_model import CausalLM, ModelConfig +from .bios_organization_train import atomic_numpy_save, atomic_torch_save, state_hash +from .bios_train import precision + +CHECKPOINTS = (0, 32, 128, 512) +SCOPE = "all-freeze-embedding" +STUDY = { + "protocol": "v2.8-h5-readout-control-E93", + "widths": [256, 768], + "parent_step": 15360, + "worlds": [0, 1], + "seeds": [0, 1], + "conditions": list(CONDITIONS), + "chains": list(CHAINS), + "kind": "exception", + "scope": SCOPE, + "frozen": "token.weight, shared by input embedding and output F.linear readout", + "trainable": "all other parameters, including absolute position embedding", + "lr": 3e-5, + "weight_decay": 0.1, + "edit_batch": 128, + "replay_batch": 128, + "retention_kl": 1.0, + "clip_norm": 1.0, + "steps": 512, + "checkpoints": list(CHECKPOINTS), + "resume_every": 32, + "models": 24, + "edit_cases": 48, + "E": 93, + "D": 96, + "R": 4096, + "reference_scopes": ["mlp", "all"], + "selection": "all fixed512 endpoints; no best step", +} + + +def validate_study(study): + if study != STUDY: + raise ValueError("H5 configuration differs from the fixed contract") + + +def control_sources(): + return { + **source_hashes(), + "bios_cross_continue.py": file_hash(Path(__file__).with_name("bios_cross_continue.py")), + Path(__file__).name: file_hash(__file__), + } + + +def select_control_parameters(model): + """The ordinary model passes this same Parameter directly to F.linear.""" + excluded = id(model.token.weight) + selected = [] + for parameter in model.parameters(): + parameter.requires_grad_(id(parameter) != excluded) + parameter.grad = None + if parameter.requires_grad: + selected.append(parameter) + assert model.position.weight.requires_grad and not model.token.weight.requires_grad + return selected + + +def sampling_stream(world_seed, chain, steps=512, batch=128): + rng = rng_for(world_seed, 908, chain) + return rng.integers(93, size=(steps, batch)), rng.integers(4096, size=(steps, batch)) + + +def score_arrays(arrays, truth): + for key in ("prediction", "ended", "correct"): + if arrays[key].shape != truth.shape: + raise ValueError("H5 prediction array shape mismatch") + if arrays["ended"].dtype != np.bool_ or arrays["correct"].dtype != np.bool_: + raise ValueError("H5 EOS/correct flags must be Boolean") + np.testing.assert_array_equal( + arrays["correct"], (arrays["prediction"] == truth) & arrays["ended"] + ) + return arrays + + +def validate_parent_config(config, world): + width = config["model"]["width"] + if width not in STUDY["widths"] or config["world"] not in (0, 1): + raise ValueError("H5 parent outside original size/world matrix") + expected = dict( + vocab_size=world.vocab_size, width=width, layers=8, heads=width // 64, context=128 + ) + if config["model"] != expected or config["study"]["protocol"] != "v2.6-development-crossover": + raise ValueError("H5 needs original unrestricted low-prevalence architecture") + expected_study = dict( + steps=15360, + lr=1e-4, + documents_per_step=16, + facts_per_document=10, + QA_per_chain_per_step=20, + document_QA_weights=[0.8, 0.2], + ) + if any(config["study"][key] != value for key, value in expected_study.items()): + raise ValueError("H5 parent is not the original learning budget") + if config["seed"] not in (0, 1) or config["condition"] not in CONDITIONS: + raise ValueError("H5 parent outside original initialization/organization matrix") + if config["sources"] != source_hashes() or config["truth_sha256"] != array_hash(world.answers): + raise ValueError("H5 parent source or truth mismatch") + if config["torch"] != torch.__version__ or config["numpy"] != np.__version__: + raise ValueError("H5 numerical software differs from parent") + + +def reference_contract(parent, world, old_arrays): + hashes = {} + for chain, name in enumerate(CHAINS): + pair = edit_pair(world, chain) + assert len(pair["E"]) == 93 and len(pair["D"]) == 96 and len(pair["replay"]) == 4096 + e, r = sampling_stream(world.seed, chain) + for scope in ("mlp", "all"): + dest = parent / "edits" / f"{name}-exception-{scope}" + with np.load(dest / "sets.npz") as actual: + for key, value in pair.items(): + np.testing.assert_array_equal(actual[key], value) + np.testing.assert_array_equal(actual["old_correct"], old_arrays["correct"]) + np.testing.assert_array_equal(actual["edit_sampling"], e) + np.testing.assert_array_equal(actual["replay_sampling"], r) + points = json.loads((dest / "trajectory.json").read_text()) + if [point["step"] for point in points] != list(CHECKPOINTS): + raise ValueError("Original MLP/All reference checkpoint grid differs") + if json.loads((dest / "complete.json").read_text())["status"] != "complete": + raise ValueError("Original MLP/All reference incomplete") + for step in CHECKPOINTS: + with np.load(dest / f"predictions-{step}.npz") as saved: + arrays = score_arrays(dict(saved), pair["exception"]) + if step == 0: + for key in ("prediction", "ended"): + np.testing.assert_array_equal(arrays[key], old_arrays[key]) + for filename in ( + "sets.npz", + "trajectory.json", + "complete.json", + *(f"predictions-{step}.npz" for step in CHECKPOINTS), + ): + hashes[str((dest / filename).relative_to(parent))] = file_hash(dest / filename) + return hashes + + +def load_parent(parent): + config = json.loads((parent / "config.json").read_text()) + world = make_cross_world(config["world"]) + validate_parent_config(config, world) + with np.load(parent / "predictions-15360.npz") as saved: + arrays = score_arrays(dict(saved), world.answers) + references = reference_contract(parent, world, arrays) + checkpoint = torch.load(parent / "model-15360.pt", map_location="cpu", weights_only=False) + complete = json.loads((parent / "learning-complete.json").read_text()) + if checkpoint["step"] != 15360 or checkpoint["config"] != config["model"]: + raise ValueError("H5 parent checkpoint identity differs") + if ( + complete["status"] != "complete" + or state_hash(checkpoint["model"]) != complete["model_sha256"] + ): + raise ValueError("H5 parent learning checkpoint is not verified complete") + provenance = dict( + directory=str(parent), + model_sha256=complete["model_sha256"], + reference_files_sha256=references, + files_sha256={ + name: file_hash(parent / name) + for name in ( + "config.json", + "model-15360.pt", + "predictions-15360.npz", + "learning-complete.json", + ) + }, + ) + return config, world, arrays, checkpoint, provenance + + +def run_case(model, baseline, data, world, parent_arrays, chain, output, identity_hash, device): + dest = output / f"{CHAINS[chain]}-exception-{SCOPE}" + if (dest / "complete.json").exists(): + return + dest.mkdir(parents=True, exist_ok=True) + model.load_state_dict(baseline) + selected = select_control_parameters(model) + frozen = baseline["token.weight"] + pair = edit_pair(world, chain) + e, r = sampling_stream(world.seed, chain) + atomic_numpy_save( + dest / "sets.npz", + **pair, + old_correct=parent_arrays["correct"], + edit_sampling=e, + replay_sampling=r, + ) + new_data = tensor_queries(world, device, pair["exception"]) + model.eval() + references = [] + with torch.no_grad(), precision(device): + for begin in range(0, len(pair["replay"]), 256): + ids = torch.as_tensor(pair["replay"][begin : begin + 256], device=device) + references.append(model(data["tokens"][ids], data["positions"][ids]).detach()) + references = torch.cat(references) + optimizer = torch.optim.AdamW(selected, lr=3e-5, weight_decay=0.1, fused=device.type == "cuda") + first, timeline, seconds = 0, [], 0.0 + if (dest / "resume.pt").exists(): + saved = torch.load(dest / "resume.pt", map_location="cpu", weights_only=False) + if saved["identity_sha256"] != identity_hash or saved["case"] != dest.name: + raise ValueError("H5 resume identity differs") + if not 0 <= saved["step"] <= 512 or saved["step"] % 32: + raise ValueError("H5 resume step differs") + if saved["step"]: + validate_optimizer(saved["optimizer"], saved["step"], 3e-5) + restore_state(model, optimizer, saved, device) + first, timeline, seconds = saved["step"], saved["timeline"], saved["seconds"] + for step in range(first, 513): + if step in CHECKPOINTS: + if not torch.equal(model.token.weight.detach().cpu(), frozen): + raise ValueError("Frozen input/output token weights changed") + if not timeline or timeline[-1]["step"] != step: + arrays = score_arrays( + evaluate(model, new_data, pair["exception"]), pair["exception"] + ) + if step == 0: + for key in ("prediction", "ended"): + np.testing.assert_array_equal(arrays[key], parent_arrays[key]) + timeline.append( + dict( + step=step, + edit_seconds=seconds, + **edit_metrics(world, pair, arrays, parent_arrays["correct"]), + ) + ) + atomic_numpy_save(dest / f"predictions-{step}.npz", **arrays) + write_json(dest / "trajectory.json", timeline) + if step % 32 == 0: + atomic_torch_save( + capture_state( + model, + optimizer, + device, + step=step, + timeline=timeline, + seconds=seconds, + identity_sha256=identity_hash, + case=dest.name, + ), + dest / "resume.pt", + ) + if step == 512: + break + ei = torch.as_tensor(pair["E"][e[step]], device=device) + ri = torch.as_tensor(pair["replay"][r[step]], device=device) + choices = torch.as_tensor(r[step], device=device) + if device.type == "cuda": + torch.cuda.synchronize(device) + start = time.perf_counter() + edit_update(model, optimizer, selected, data, new_data, references, ei, ri, choices, device) + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - start + atomic_torch_save( + dict(model=model.state_dict(), config=model.config_dict(), step=512), + dest / "model-final.pt", + ) + write_json( + dest / "complete.json", + dict( + status="complete", + scope=SCOPE, + kind="exception", + chain=CHAINS[chain], + final=timeline[-1], + model_sha256=state_hash(model.state_dict()), + frozen_token_sha256=state_hash({"token.weight": frozen}), + ), + ) + print( + json.dumps(dict(event="H5_edit_complete", case=dest.name, final=timeline[-1])), flush=True + ) + + +def run(args): + validate_study(json.loads(Path(args.config).read_text())) + parent, output = Path(args.parent).resolve(), Path(args.output).resolve() + if parent == output or parent in output.parents or output in parent.parents: + raise ValueError("H5 output must be separate from immutable parent") + output.mkdir(parents=True, exist_ok=True) + with (output / ".lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + torch.set_num_threads(args.threads) + config, world, arrays, checkpoint, provenance = load_parent(parent) + device = torch.device(args.device) + identity = dict( + world=world.seed, + seed=config["seed"], + condition=config["condition"], + width=config["model"]["width"], + study=STUDY, + sources=control_sources(), + parent=provenance, + torch=torch.__version__, + cuda=torch.version.cuda, + numpy=np.__version__, + device_type=device.type, + ) + path = output / "config.json" + if path.exists() and json.loads(path.read_text()) != identity: + raise ValueError("Frozen H5 worker contract changed") + if not path.exists(): + write_json(path, identity) + if (output / "complete.json").exists(): + return + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + torch.manual_seed(config["seed"]) + if device.type == "cuda": + torch.cuda.manual_seed_all(config["seed"]) + model = CausalLM(ModelConfig(**checkpoint["config"])).to(device) + model.load_state_dict(checkpoint["model"]) + baseline = {key: value.detach().cpu().clone() for key, value in model.state_dict().items()} + data = tensor_queries(world, device) + try: + observed = score_arrays(evaluate(model, data, world.answers), world.answers) + for key in ("prediction", "ended", "correct"): + np.testing.assert_array_equal(observed[key], arrays[key]) + for chain in range(2): + run_case( + model, baseline, data, world, arrays, chain, output, file_hash(path), device + ) + write_json( + output / "complete.json", + dict(status="complete", edit_cases=2, steps=512, scope=SCOPE, finished=time.time()), + ) + except Exception as error: + write_json( + output / "failure.json", + dict(type=type(error).__name__, message=str(error), time=time.time()), + ) + raise + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--parent", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--config", default="configs/bios-readout-control-v1.json") + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_relation_response.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_relation_response.py new file mode 100644 index 0000000000000000000000000000000000000000..2e69b15143ef5b90779481035823b06102c3b5ab --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_relation_response.py @@ -0,0 +1,187 @@ +"""A paired four-cell test of which fact controls a composite answer. + +The editor is unchanged. Derivative probes use answer contrasts, never a +composite target loss. Isolated directions preserve the OTHER direct query's +two a/c and b/c contrasts to first order, not its entire output distribution. +""" + +from dataclasses import replace + +import torch + +from .bios_direction import Suffix +from .bios_direction_cross import cross_tasks + +CELLS = ("aa", "ab", "ba", "bb") +LAYER = 4 + + +def factorial_tasks(world, seed, device): + """Rows select root targets; columns select personal targets; a/b stay fixed.""" + originals = cross_tasks(world, seed, device) + result = [] + for pair_index in range(6): + base = originals[2 * pair_index] + for cell in CELLS: + labels, tokens = base.labels.clone(), base.tokens.clone() + root, actual = base.sets["E"] + labels[root, 0] = base.metadata[cell[0]] + labels[actual, 0] = base.metadata[cell[1]] + labels[base.sets["D"], 0] = base.metadata[cell[0]] + rows = torch.arange(len(tokens), device=tokens.device) + tokens[rows, base.positions[:, 0] + 1] = labels[:, 0] + metadata = dict( + base.metadata, + cell=cell, + pair_index=pair_index, + kind="coherent" if cell[0] == cell[1] else "independent", + root_target=base.metadata[cell[0]], + actual_target=base.metadata[cell[1]], + ) + result.append( + replace( + base, + name=base.name.rsplit("-", 1)[0] + "-" + cell, + labels=labels, + tokens=tokens, + metadata=metadata, + ) + ) + return result + + +def check_reused_task(task, manifest): + """Compare actual information, including teacher-forced EOS prefixes.""" + current = task.manifest() + for key in ("sets", "labels", "old_labels", "tokens_sha256"): + assert current[key] == manifest[key], key + for key in ("world", "seed", "chain", "group", "person", "a", "b", "c", "original_ids"): + assert current["metadata"][key] == manifest["metadata"][key], key + + +def make_probe(model, task): + ids = task.sets["E"] + task.sets["D_focal"] + positions = task.positions[ids, :1] + tokens = task.tokens[ids, :5].clone() + # No desired answer is present even at masked future positions. + tokens.masked_fill_(torch.arange(5, device=tokens.device)[None] > positions, 0) + return Suffix(model, LAYER, tokens, positions) + + +def values(probe, weight, metadata): + logits = probe(weight[None])[0, :, 0] + a, b, c = (metadata[k] for k in ("a", "b", "c")) + contrasts = torch.stack((logits[:, a] - logits[:, c], logits[:, b] - logits[:, c]), -1) + return logits, contrasts + + +def derivatives(probe, weight, metadata): + w = weight.detach().clone().requires_grad_() + logits, contrasts = values(probe, w, metadata) + gradients = torch.stack( + [ + torch.autograd.grad(contrasts[i, j], w, retain_graph=True)[0] + for i in range(3) + for j in range(2) + ] + ).reshape(3, 2, *w.shape) + return logits.detach(), contrasts.detach(), gradients.detach() + + +def isolated_directions(gradients): + """Minimum-norm direct-fact controls; D is excluded from construction. + + A unit control changes the chosen fact's (a-c,b-c) by (+.5,-.5), + hence its a-b contrast by 1; the other fact has both contrasts fixed. + """ + g = gradients[:2].flatten(0, 1).flatten(1).double() + gram = g @ g.T + eig, vec = torch.linalg.eigh(gram) + keep = eig > eig[-1].clamp_min(1e-30) * 1e-10 + inverse = (vec * torch.where(keep, 1 / eig.clamp_min(1e-300), 0)[None]) @ vec.T + targets = torch.tensor([[0.5, -0.5, 0, 0], [0, 0, 0.5, -0.5]], device=g.device) + controls = targets.double() @ inverse @ g + achieved = controls @ g.T + gd = (gradients[2, 0] - gradients[2, 1]).flatten().double() + coefficients = controls @ gd + residual = gd - (gd @ g.T) @ inverse @ g + summary = { + "rank": int(keep.sum()), + "spectrum": eig.cpu().tolist(), + "control_residual": float((achieved - targets).abs().max()), + "root_response": float(coefficients[0]), + "actual_response": float(coefficients[1]), + "unexplained_D_gradient_fraction": float(residual.norm() / gd.norm().clamp_min(1e-30)), + "root_control_norm": float(controls[0].norm()), + "actual_control_norm": float(controls[1].norm()), + } + return controls.reshape(2, *gradients.shape[-2:]).to(gradients.dtype), summary + + +@torch.no_grad() +def calibrate_controls(probe, weight, metadata, gradients, magnitudes): + controls, summary = isolated_directions(gradients) + baseline_logits, baseline = values(probe, weight, metadata) + rows = [] + if summary["control_residual"] > 1e-5: + return summary, rows + for index, name in enumerate(("root", "actual")): + for magnitude in magnitudes: + for sign in (-1, 1): + delta = sign * magnitude * controls[index] + cap = min(1.0, float(1e-3 * weight.norm() / delta.norm().clamp_min(1e-30))) + delta = delta * cap + changed, after = values(probe, weight + delta, metadata) + observed = after - baseline + predicted = (gradients.double() * delta.double()).sum((-1, -2)) + other = 1 - index + logp = baseline_logits.double().log_softmax(-1) + new_logp = changed.double().log_softmax(-1) + kl = (logp.exp() * (logp - new_logp)).sum(-1) + rows.append( + dict( + control=name, + magnitude=magnitude, + sign=sign, + cap=cap, + actual_target_increment=sign * magnitude * cap, + delta_norm=float(delta.norm()), + predicted_ab=(predicted[:, 0] - predicted[:, 1]).cpu().tolist(), + observed_ab=(observed[:, 0] - observed[:, 1]).cpu().tolist(), + other_ac_bc_drift=float(observed[other].abs().max()), + other_output_kl=float(kl[other]), + direct_argmax_changes=int( + (changed[:2].argmax(-1) != baseline_logits[:2].argmax(-1)).sum() + ), + ) + ) + return summary, rows + + +def first_adam_update(model, task, config): + """Exact first-step algebra of the frozen soft-functional Adam editor.""" + ids = task.sets["E"] + task.sets["R"] + suffix = Suffix(model, LAYER, task.tokens[ids], task.positions[ids]) + w = model.blocks[LAYER].mlp.down.weight.detach().clone().requires_grad_() + logits = suffix(w[None])[0] + logp = logits.double().log_softmax(-1) + labels = task.labels[ids] + ce = -logp.gather(-1, labels[..., None])[..., 0].mean(-1) + n = len(task.sets["E"]) + # The original-parent KL has exactly zero derivative at the parent. + loss = ce[:n].mean() + ce[n:].mean() + gradient = torch.autograd.grad(loss, w)[0] + m, v = 0.1 * gradient, 0.001 * gradient.square() + t = torch.ones((), device=w.device) + raw = -(m / (1 - 0.9**t)) / ((v / (1 - 0.999**t)).sqrt() + 1e-8) + return config["lr"] * raw + + +def factorial_effects(margins): + aa, ab, ba, bb = (float(margins[cell]) for cell in CELLS) + return dict( + intercept=(aa + ab + ba + bb) / 4, + root=(aa + ab - ba - bb) / 4, + actual=(aa - ab + ba - bb) / 4, + interaction=(aa - ab - ba + bb) / 4, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py new file mode 100644 index 0000000000000000000000000000000000000000..3943eb3bac42c3c9c13d8b3c40061fc830348860 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py @@ -0,0 +1,372 @@ +"""Locked independent-world behavioral confirmation, never a route-mediation claim. + +The original learning implementation and the audited E39 update implementation +are called directly. An external prospective lock is mandatory before execution. +""" + +import argparse +import fcntl +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_cross import CHAINS, CONDITIONS, make_cross_world +from .bios_cross_train import learning, source_hashes +from .bios_data import write_json +from .bios_organization_train import atomic_numpy_save, state_hash +from .bios_path_diagnostics import autonomous_two_step +from .bios_shortcut_confirmation_sets import make_confirmation_edit_pair +from .bios_shortcut_control import high_exception_world +from .bios_shortcut_edit_v2 import STUDY as DEVELOPMENT_EDIT_STUDY +from .bios_shortcut_edit_v2 import run_case +from .bios_shortcut_matched_edit import KINDS, PHASES + +PROTOCOL = "v2.9-shortcut-behavior-confirmation" +WORLDS = tuple(range(100, 108)) +LEARNING_CHECKPOINTS = (0, 1280, 2560, 5120, 10240, 15360) + + +def file_hash(path): + digest = hashlib.sha256() + with Path(path).open("rb") as stream: + while chunk := stream.read(4 * 1024 * 1024): + digest.update(chunk) + return digest.hexdigest() + + +def confirmation_sources(): + directory = Path(__file__).parent + return { + **source_hashes(), + "scripts/prepare_bios_shortcut_confirmation.py": file_hash( + directory.parents[1] / "scripts/prepare_bios_shortcut_confirmation.py" + ), + **{ + name: file_hash(directory / name) + for name in ( + "bios_shortcut_confirmation.py", + "bios_shortcut_confirmation_sets.py", + "bios_shortcut_control.py", + "bios_shortcut_matched_edit.py", + "bios_shortcut_edit_v2.py", + "bios_cross_continue.py", + "bios_path_diagnostics.py", + ) + }, + } + + +def validate_config(config): + expected = { + "protocol": PROTOCOL, + "worlds": list(WORLDS), + "seeds": [0, 1], + "conditions": list(CONDITIONS), + "phases": list(PHASES), + "chains": list(CHAINS), + "supports": [0, 1], + "width": 256, + "layers": 8, + "heads": 4, + "steps": 15360, + "checkpoints": list(LEARNING_CHECKPOINTS), + "lr": 0.0001, + "documents_per_step": 16, + "facts_per_document": 10, + "QA_per_chain_per_step": 20, + "document_QA_weights": [0.8, 0.2], + "learning_runs": 96, + "edit_cases": 768, + "edit_steps": 512, + "edit_checkpoints": [0, 32, 128, 512], + "edit_lr": 0.00003, + "retention_kl": 1.0, + "edit_scope": "mlp", + "edit_mlp_layers": [3, 4, 5], + "edit_batch": 128, + "replay_batch": 128, + "edit_weight_decay": 0.1, + "E": 39, + "D": 96, + "R": 4096, + "base_world_root": "data/bios-shortcut-confirmation-v1", + "source_root": "data/bios-source", + } + for key, value in expected.items(): + if config.get(key) != value: + raise ValueError(f"Prospective confirmation contract differs: {key}") + for key in ("steps", "checkpoints", "lr", "retention_kl", "E", "D", "R"): + source = {"steps": "edit_steps", "checkpoints": "edit_checkpoints", "lr": "edit_lr"} + if DEVELOPMENT_EDIT_STUDY[key] != config[source.get(key, key)]: + raise ValueError(f"Imported E39 scientific update differs: {key}") + if config.get("edit_sampling") != "shared original world932chain stream across supports": + raise ValueError("The two supports retain the original paired sampling stream") + + +def validate_frozen_design(config_path, lock_path): + config = json.loads(Path(config_path).read_text()) + validate_config(config) + lock = json.loads(Path(lock_path).read_text()) + if lock.get("status") != "frozen_before_any_confirmation_model_or_outcome": + raise ValueError("A prospective confirmation lock is required") + if lock["config_sha256"] != file_hash(config_path): + raise ValueError("Confirmation configuration changed after locking") + if lock["sources"] != confirmation_sources(): + raise ValueError("Confirmation scientific sources changed after locking") + environment = {"torch": torch.__version__, "cuda": torch.version.cuda, "numpy": np.__version__} + if lock["environment"] != environment: + raise ValueError("Confirmation numerical environment changed after locking") + if not lock.get("analysis_sources"): + raise ValueError("The prospective analysis implementation must also be locked") + root = Path(__file__).resolve().parents[2] + for relative, checksum in lock["analysis_sources"].items(): + if file_hash(root / relative) != checksum: + raise ValueError(f"Prospective analysis source changed: {relative}") + if not lock.get("data_source_files"): + raise ValueError("Original data source files must be prospectively locked") + for relative, checksum in lock["data_source_files"].items(): + if file_hash(root / relative) != checksum: + raise ValueError(f"Original data source changed: {relative}") + return config, lock + + +def validate_lock(config_path, lock_path, args): + config, lock = validate_frozen_design(config_path, lock_path) + if torch.device(args.device).type != "cuda" or lock.get("device_type") != "cuda": + raise ValueError("Confirmation requires CUDA BF16 execution, never mixed CPU precision") + if args.world not in WORLDS or args.seed not in (0, 1): + raise ValueError("Only the eight reserved worlds and two initializations are allowed") + if args.phase not in PHASES or args.condition not in CONDITIONS: + raise ValueError("Condition outside the prospective matrix") + expected_output = ( + Path(lock["output_root"]) + / args.phase + / "width-256" + / f"world-{args.world}-seed-{args.seed}-{args.condition}" + ).resolve() + if Path(args.output).resolve() != expected_output: + raise ValueError("Output differs from the prospective matrix") + return config, lock + + +def validate_prepared_world(config, config_path, lock_path, world): + if world not in WORLDS: + raise ValueError("Requested world is outside the prospective preparation matrix") + root = Path(__file__).resolve().parents[2] / config["base_world_root"] + receipt = json.loads((root / "preparation-audit.json").read_text()) + lock = json.loads(Path(lock_path).read_text()) + if ( + receipt.get("complete") is not True + or receipt["config_sha256"] != file_hash(config_path) + or receipt["lock_sha256"] != file_hash(lock_path) + or receipt["worlds"] != list(WORLDS) + ): + raise ValueError("Base worlds lack a complete prospectively locked preparation") + if receipt.get("source_files_sha256") != lock["data_source_files"]: + raise ValueError("Prepared world source files differ from the prospective lock") + filenames = ("world.npz", "metadata.json", "audit.json") + expected_files = {f"world-{seed}/{name}" for seed in WORLDS for name in filenames} + if set(receipt.get("files_sha256", {})) != expected_files: + raise ValueError("Prepared world file manifest differs from the prospective matrix") + for name in filenames: + relative = f"world-{world}/{name}" + if receipt["files_sha256"].get(relative) != file_hash(root / relative): + raise ValueError(f"Prepared world changed: {relative}") + metadata = json.loads((root / f"world-{world}/metadata.json").read_text()) + if type(metadata.get("seed")) is not int or metadata["seed"] != world: + raise ValueError("Prepared world metadata seed differs from the requested world") + return root, receipt + + +def case_identity(worker_identity, chain, support, kind, pair): + payload = { + "worker_identity": worker_identity, + "chain": chain, + "support": support, + "kind": kind, + "pair_contract": pair["contract"], + } + return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest() + + +def expected_weight_artifacts(): + names = [f"learning/model-{step}.pt" for step in LEARNING_CHECKPOINTS] + names.append("learning/resume.pt") + names.extend( + f"edits/support-{support}/{chain}-{kind}-mlp/{filename}" + for support in (0, 1) + for chain in CHAINS + for kind in KINDS + for filename in ("model-final.pt", "resume.pt") + ) + return names + + +def scientific_artifacts(output): + for relative in expected_weight_artifacts(): + if not (output / relative).is_file(): + raise ValueError(f"Required confirmation weight artifact is missing: {relative}") + paths = [output / "launch-contract.json", output / "manipulation.npz"] + paths.extend(p for p in (output / "learning").iterdir() if p.is_file()) + paths.extend(p for p in (output / "edits").rglob("*") if p.is_file()) + return { + str(p.relative_to(output)): {"bytes": p.stat().st_size, "sha256": file_hash(p)} + for p in sorted(paths) + } + + +def run(args): + config, _ = validate_lock(args.config, args.lock, args) + output = Path(args.output).resolve() + output.mkdir(parents=True, exist_ok=True) + with (output / ".worker.lock").open("w") as handle: + fcntl.flock(handle, fcntl.LOCK_EX | fcntl.LOCK_NB) + torch.set_num_threads(args.threads) + base_root, data_receipt = validate_prepared_world( + config, args.config, args.lock, args.world + ) + if not torch.cuda.is_available() or not torch.cuda.is_bf16_supported(): + raise ValueError("A healthy CUDA device with BF16 support is required") + identity = { + "protocol": PROTOCOL, + "world": args.world, + "seed": args.seed, + "condition": args.condition, + "phase": args.phase, + "config_sha256": file_hash(args.config), + "preregistration_lock_sha256": file_hash(args.lock), + "sources": confirmation_sources(), + "torch": torch.__version__, + "cuda": torch.version.cuda, + "numpy": np.__version__, + "device_type": "cuda", + "precision": "BF16 autocast; FP32 model and optimizer", + "prepared_worlds_audit_sha256": file_hash(base_root / "preparation-audit.json"), + "world_files_sha256": { + name: checksum + for name, checksum in data_receipt["files_sha256"].items() + if name.startswith(f"world-{args.world}/") + }, + } + path = output / "launch-contract.json" + if path.exists() and json.loads(path.read_text()) != identity: + raise ValueError("Confirmation worker identity changed") + if not path.exists(): + write_json(path, identity) + if (output / "complete.json").exists(): + return + try: + low = make_cross_world(args.world, source_root=base_root) + high, manipulation, selected, donors = high_exception_world(low) + world = low if args.phase == "low" else high + pairs = { + (chain, support): make_confirmation_edit_pair(low, high, chain, support) + for chain in range(2) + for support in (0, 1) + } + for chain in range(2): + for key in ("groups", "E", "D", "selected_people"): + if np.intersect1d(pairs[chain, 0][key], pairs[chain, 1][key]).size: + raise ValueError(f"The two supports overlap: {key}") + atomic_numpy_save( + output / "manipulation.npz", + selections=selected, + donors=donors, + low_answers=low.answers, + high_answers=high.answers, + high_exceptions=high.exceptions, + ) + study = { + **config, + "confirmation_sources": identity["sources"], + "phase": args.phase, + "manipulation": manipulation, + } + learning_output = output / "learning" + learning_output.mkdir(exist_ok=True) + device = torch.device(args.device) + model, data = learning(args, world, learning_output, study, device) + with np.load(learning_output / "predictions-15360.npz") as saved: + baseline_predictions = { + key: saved[key] for key in ("prediction", "ended", "correct", "value_nll") + } + np.testing.assert_array_equal( + baseline_predictions["correct"], + (baseline_predictions["prediction"] == world.answers) + & baseline_predictions["ended"], + ) + completed = json.loads((learning_output / "learning-complete.json").read_text()) + if completed["model_sha256"] != state_hash(model.state_dict()): + raise ValueError("Learning baseline differs from completed weights") + for chain, name in enumerate(CHAINS): + arrays = autonomous_two_step(model, world, chain, device) + ids = world.derived_ids[chain] + arrays.update( + {f"direct_{key}": value[ids] for key, value in baseline_predictions.items()} + ) + atomic_numpy_save(learning_output / f"two-step-{name}.npz", **arrays) + baseline = { + key: value.detach().cpu().clone() for key, value in model.state_dict().items() + } + identity_hash = file_hash(path) + for support in (0, 1): + edit_output = output / "edits" / f"support-{support}" + for chain in range(2): + for kind in KINDS: + run_case( + model, + baseline, + data, + world, + pairs[chain, support], + args.phase, + kind, + chain, + edit_output, + case_identity( + identity_hash, chain, support, kind, pairs[chain, support] + ), + baseline_predictions, + device, + ) + write_json( + output / "complete.json", + { + "status": "complete", + "protocol": PROTOCOL, + "learning_steps": 15360, + "edit_cases": 8, + "edit_steps": 512, + "lock_sha256": file_hash(args.lock), + "artifacts": scientific_artifacts(output), + "finished": time.time(), + }, + ) + except Exception as error: + write_json( + output / "failure.json", + {"type": type(error).__name__, "message": str(error), "time": time.time()}, + ) + raise + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--world", type=int, required=True) + parser.add_argument("--seed", type=int, required=True) + parser.add_argument("--condition", choices=CONDITIONS, required=True) + parser.add_argument("--phase", choices=PHASES, required=True) + parser.add_argument("--config", required=True) + parser.add_argument("--lock", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py new file mode 100644 index 0000000000000000000000000000000000000000..8535796aba3f18178d69d214c04bc922b0dfa21d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py @@ -0,0 +1,192 @@ +"""Two prospectively fixed E39 supports; preparation never launches a model. + +Support zero exactly preserves development selection. Support one uses a +separate deterministic stream and excludes the first support's entire groups. +The original E39 audit validates both; all training and target budgets match. +""" + +import numpy as np + +from .bios_data import array_hash, rng_for +from .bios_shortcut_control import audit_high_exception +from .bios_shortcut_matched_edit import ( + KINDS, + PHASES, + U_STRATA, + audit_matched_edit_pair, +) +from .bios_shortcut_matched_edit import ( + make_matched_edit_pair as development_pair, +) + +BUDGET = { + "prevalence_levels": 2, + "worlds": 8, + "initializations": 2, + "organizations": 3, + "models": 96, + "chains": 2, + "update_types": 2, + "supports_per_chain": 2, + "scopes": ["mlp"], + "edit_cases": 768, +} + + +def make_confirmation_edit_pair(low, high, chain, support=0): + """Three roots + 36 actual facts; same IDs and support labels across phases. + + Each selected group contributes six QA-trained and six QA-heldout people + who remain ordinary in the high-prevalence world. Coherent assigns all 12 + to the new default. Exception assigns three default/three alternative in + each split. Histograms match ACROSS all three groups, not within a group. + """ + if chain not in (0, 1) or support not in (0, 1): + raise ValueError("Confirmation fixes two chains and two disjoint supports") + if low.seed != high.seed or low.n_base != high.n_base: + raise ValueError("Low/high worlds must share their identity and query layout") + audit_high_exception(low, high) + first = development_pair(low, high, chain) + if support == 0: + first["contract"].update( + protocol="v2.9-shortcut-behavior-confirmation-E39", + status="prospectively_fixed_confirmation_support", + budget=BUDGET.copy(), + model_checkpoint="width256, independent-world 15360-step low/high learning", + ) + return first + eligible_groups = np.setdiff1d(np.arange(64), first["groups"]) + rng = rng_for(low.seed, 931, chain + 2 * support) + for _ in range(10000): + groups = rng.choice(eligible_groups, 3, replace=False) + if len(np.unique(low.defaults[chain, groups])) == 3: + break + else: + raise RuntimeError("Could not find three groups with distinct default cities") + selected = np.empty((3, 12), dtype=np.int64) + conflict = np.zeros((3, 12), dtype=bool) + conflict[:, :3] = conflict[:, 6:9] = True + targets = { + f"{phase}_{kind}": world.answers.copy() + for phase, world in (("low", low), ("high", high)) + for kind in KINDS + } + new_default = low.city_tokens[low.defaults[chain, np.roll(groups, -1)]] + alternative = low.city_tokens[low.defaults[chain, np.roll(groups, -2)]] + for index, group in enumerate(groups): + ordinary = np.flatnonzero((high.memberships[chain] == group) & ~high.exceptions[chain]) + for split, pool in enumerate((low.train_ids[chain], low.heldout_ids[chain])): + eligible = ordinary[np.isin(low.derived_ids[chain, ordinary], pool)] + if len(eligible) != 8: + raise ValueError("Expected eight still-ordinary people in each QA split") + selected[index, split * 6 : (split + 1) * 6] = rng.permutation(eligible)[:6] + actual = low.actual_ids[chain, selected[index]] + derived = low.derived_ids[chain, low.memberships[chain] == group] + for phase in PHASES: + for kind in KINDS: + target = targets[f"{phase}_{kind}"] + target[low.root_ids[chain, group]] = new_default[index] + target[derived] = new_default[index] + target[actual] = new_default[index] + if kind == "exception": + target[actual[conflict[index]]] = alternative[index] + edited_people = selected.ravel() + selected_people = np.isin(low.memberships[chain], groups) + original = selected_people & low.exceptions[chain] + newly = selected_people & high.exceptions[chain] & ~low.exceptions[chain] + unedited_ordinary = ( + selected_people & ~high.exceptions[chain] & ~np.isin(np.arange(2048), edited_people) + ) + e = np.sort(np.concatenate([low.root_ids[chain, groups], low.actual_ids[chain, edited_people]])) + d = low.derived_ids[chain, selected_people] + unchanged = np.ones(len(low.answers), dtype=bool) + unchanged[np.concatenate([e, d])] = False + affected_facts = (low.person >= 0) & selected_people[np.maximum(low.person, 0)] + original_actual = np.isin(np.arange(len(low.answers)), low.actual_ids[chain, original]) + newly_actual = np.isin(np.arange(len(low.answers)), low.actual_ids[chain, newly]) + relevant = np.isin(low.relation, [0, 1, 2, 10] if chain == 0 else [7, 8, 9, 11]) + strata = np.full(len(low.answers), -1, dtype=np.int64) + strata[unchanged & original_actual] = 0 + strata[unchanged & newly_actual] = 1 + strata[unchanged & affected_facts & ~original_actual & ~newly_actual] = 2 + strata[unchanged & ~affected_facts & relevant] = 3 + strata[unchanged & ~affected_facts & ~relevant] = 4 + heldout = [] + for stratum in range(5): + ids = rng.permutation(np.flatnonzero((strata == stratum) & (low.relation < 10))) + heldout.extend(ids[: max(1, int(np.ceil(0.2 * len(ids))))]) + heldout.extend(np.flatnonzero(unchanged & (low.relation >= 10))) + heldout = np.array(sorted(heldout), dtype=np.int64) + common_pool = np.flatnonzero(unchanged & (low.relation < 10) & (low.answers == high.answers)) + common_pool = np.setdiff1d(common_pool, heldout) + if len(common_pool) < 4096: + raise ValueError("Insufficient shared unchanged base facts for R4096") + replay = rng.choice(common_pool, 4096, replace=False) + paired_reference = np.sort(low.derived_ids[chain, selected[conflict]]) + pair = { + **targets, + "groups": groups, + "selected_people": selected, + "alternative_assignments": conflict, + "new_default": new_default, + "alternative": alternative, + "E": e, + "D": d, + "E_roots": low.root_ids[chain, groups], + "E_actual": np.sort(low.actual_ids[chain, edited_people]), + "E_actual_trained": np.sort(low.actual_ids[chain, selected[:, :6].ravel()]), + "E_actual_heldout": np.sort(low.actual_ids[chain, selected[:, 6:].ravel()]), + "D_trained": np.intersect1d(d, low.train_ids[chain]), + "D_heldout": np.intersect1d(d, low.heldout_ids[chain]), + "D_edited_actual": np.sort(low.derived_ids[chain, edited_people]), + "paired_reference_D": paired_reference, + "paired_reference_D_heldout": np.intersect1d(paired_reference, low.heldout_ids[chain]), + "exception_conflict_D": paired_reference.copy(), + "exception_conflict_D_heldout": np.intersect1d(paired_reference, low.heldout_ids[chain]), + "D_edited_aligned": np.sort(low.derived_ids[chain, selected[~conflict]]), + "D_original_exception": low.derived_ids[chain, original], + "D_newly_exception": low.derived_ids[chain, newly], + "D_remaining_ordinary_unedited": low.derived_ids[chain, unedited_ordinary], + "R": replay, + "U_full": np.flatnonzero(unchanged), + "U_heldout": heldout, + "U_strata": strata, + } + for phase in PHASES: + for kind in KINDS: + target = targets[f"{phase}_{kind}"] + actual_for_d = target[low.actual_ids[chain, selected_people]] + pair[f"{phase}_{kind}_factual_conflict_D"] = d[target[d] != actual_for_d] + pair["contract"] = { + "protocol": "v2.9-shortcut-behavior-confirmation-E39", + "world": low.seed, + "chain": chain, + "support": support, + "status": "prospectively_fixed_confirmation_support", + "budget": {**BUDGET, "scopes": BUDGET["scopes"].copy()}, + "model_checkpoint": ("width256, independent-world 15360-step low/high learning"), + "histogram_matching_scope": ( + "all three groups combined; also separately for trained/heldout QA" + ), + "coherent_actuals_per_group": "12 new-default (six in each QA split)", + "exception_actuals_per_group": ( + "6 new-default + 6 alternative (three + three in each QA split)" + ), + "paired_reference_semantics": ( + "same 18 people; conflict only in exception, reference only in coherent" + ), + "R_semantics": ( + "4096 identical query IDs with identical original truths " + "and unchanged under all four targets" + ), + "U_semantics": ( + "common query IDs; score each phase against its own truth and old-correct coverage" + ), + "U_strata": U_STRATA.copy(), + "historical_E93_comparable": False, + "low_truth_sha256": array_hash(low.answers), + "high_truth_sha256": array_hash(high.answers), + "array_sha256": {key: array_hash(value) for key, value in pair.items()}, + } + audit_matched_edit_pair(low, high, chain, pair) + return pair diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_control.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_control.py new file mode 100644 index 0000000000000000000000000000000000000000..60ee531b9c2a08e1cf2cfba210a312300b93480d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_control.py @@ -0,0 +1,242 @@ +"""P3: alter shortcut reliability while preserving marginal answer counts. + +The archived crossover generator and trainer are imported, never rewritten. +The two chains are manipulated simultaneously; QA identities remain unchanged. +""" + +import argparse +import fcntl +import hashlib +import json +import os +import time +from dataclasses import replace +from pathlib import Path + +import numpy as np +import torch + +from .bios_cross import CONDITIONS, audit, documents, make_cross_world, qa_schedule +from .bios_cross_train import learning, source_hashes +from .bios_data import array_hash, rng_for, write_json +from .bios_organization_train import atomic_numpy_save + + +def high_exception_world(old): + """Raise both chains from two to sixteen exceptions per 32-member group.""" + audit(old) + answers, exceptions = old.answers.copy(), old.exceptions.copy() + selections = np.empty((2, 64, 14), dtype=np.int64) + donors = np.empty((2, 14, 64), dtype=np.int64) + for chain in range(2): + rng = rng_for(old.seed, 930, chain) + for group in range(64): + ordinary = np.flatnonzero((old.memberships[chain] == group) & ~old.exceptions[chain]) + people = [] + for query_pool in (old.train_ids[chain], old.heldout_ids[chain]): + eligible = ordinary[np.isin(old.derived_ids[chain, ordinary], query_pool)] + people.extend(rng.permutation(eligible)[:7]) + selections[chain, group] = people + # Every lane contains one ordinary member per group. A city-deranged + # bijection preserves the histogram exactly, separately in each QA split. + for lane in range(14): + for _ in range(10000): + donor = rng.permutation(64) + if np.all(old.defaults[chain, donor] != old.defaults[chain]): + break + else: + raise RuntimeError("Could not construct a city-deranged permutation") + donors[chain, lane] = donor + selected = selections[chain, :, lane] + answers[old.actual_ids[chain, selected]] = old.city_tokens[old.defaults[chain, donor]] + exceptions[chain, selected] = True + world = replace(old, answers=answers, exceptions=exceptions) + record = audit_high_exception(old, world) + record["selection_sha256"] = array_hash(selections) + record["donors_sha256"] = array_hash(donors) + return world, record, selections, donors + + +def audit_high_exception(old, new): + """Fail if the manipulation changes anything outside its declared contract.""" + allowed = old.actual_ids.ravel() + unchanged = np.setdiff1d(np.arange(len(old.answers)), allowed) + np.testing.assert_array_equal(old.answers[unchanged], new.answers[unchanged]) + for field in ( + "prompts", + "lengths", + "relation", + "person", + "memberships", + "defaults", + "membership_ids", + "root_ids", + "actual_ids", + "derived_ids", + "train_ids", + "heldout_ids", + "city_tokens", + ): + np.testing.assert_array_equal(getattr(old, field), getattr(new, field)) + if old.token_labels != new.token_labels: + raise ValueError("Vocabulary changed") + records = [] + for chain in range(2): + ids = old.actual_ids[chain] + np.testing.assert_array_equal(np.sort(old.answers[ids]), np.sort(new.answers[ids])) + truth_exception = ( + new.answers[ids] != new.city_tokens[new.defaults[chain, new.memberships[chain]]] + ) + np.testing.assert_array_equal(truth_exception, new.exceptions[chain]) + if np.any(old.exceptions[chain] & ~new.exceptions[chain]): + raise ValueError("An original exception was removed") + for group in range(64): + members = new.memberships[chain] == group + if int(new.exceptions[chain, members].sum()) != 16: + raise ValueError("Expected sixteen exceptions per group") + for pool in (new.train_ids[chain], new.heldout_ids[chain]): + people = np.flatnonzero(members & np.isin(new.derived_ids[chain], pool)) + if len(people) != 16 or new.exceptions[chain, people].sum() != 8: + raise ValueError("QA split no longer has eight exceptions per group") + for pool in (new.train_ids[chain], new.heldout_ids[chain]): + people = np.flatnonzero(np.isin(new.derived_ids[chain], pool)) + np.testing.assert_array_equal( + np.sort(old.answers[ids[people]]), np.sort(new.answers[ids[people]]) + ) + records.append( + { + "chain": chain, + "old_exceptions": int(old.exceptions[chain].sum()), + "new_exceptions": int(new.exceptions[chain].sum()), + "changed_actual_facts": int((old.answers[ids] != new.answers[ids]).sum()), + "answer_histogram_preserved": True, + "split_histograms_preserved": True, + } + ) + for condition in CONDITIONS: + np.testing.assert_array_equal(documents(old, condition), documents(new, condition)) + np.testing.assert_array_equal(qa_schedule(old, 1280), qa_schedule(new, 1280)) + return { + "passed": True, + "world": old.seed, + "old_truth_sha256": array_hash(old.answers), + "new_truth_sha256": array_hash(new.answers), + "prompts_sha256": array_hash(new.prompts), + "chains": records, + "changed_total": int((old.answers != new.answers).sum()), + "document_identities_and_QA_split_preserved": True, + } + + +def shortcut_sources(): + diagnostic = Path(__file__).with_name("bios_path_diagnostics.py") + return { + **source_hashes(), + Path(__file__).name: hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), + diagnostic.name: hashlib.sha256(diagnostic.read_bytes()).hexdigest(), + } + + +def run(args): + out = Path(args.output).resolve() + out.mkdir(parents=True, exist_ok=True) + with (out / ".lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + study = json.loads(Path(args.config).read_text()) + if study["width"] != 256 or study["steps"] != 15360: + raise ValueError("P3 freezes width 256 and 15360 steps") + old = make_cross_world(args.world) + world, manipulation, selected, donors = high_exception_world(old) + contract = { + "protocol": "v2.8-p3-shortcut-reliability", + "study": study, + "world": args.world, + "seed": args.seed, + "condition": args.condition, + "sources": shortcut_sources(), + "manipulation": manipulation, + "environment": { + "torch": torch.__version__, + "cuda": torch.version.cuda, + "visible_devices": os.getenv("CUDA_VISIBLE_DEVICES"), + }, + } + contract_path = out / "launch-contract.json" + if contract_path.exists(): + frozen = json.loads(contract_path.read_text()) + for key in ( + "protocol", + "study", + "world", + "seed", + "condition", + "sources", + "manipulation", + ): + if frozen[key] != contract[key]: + raise ValueError(f"Frozen shortcut contract changed: {key}") + else: + write_json(contract_path, contract) + atomic_numpy_save( + out / "manipulation.npz", + selections=selected, + donors=donors, + old_answers=old.answers, + answers=world.answers, + exceptions=world.exceptions, + train_ids=world.train_ids, + heldout_ids=world.heldout_ids, + ) + if (out / "complete.json").exists(): + return + # Include adapter provenance in the archived trainer's own run identity. + study = {**study, "shortcut_contract": contract["sources"]} + torch.set_num_threads(args.threads) + try: + from .bios_path_diagnostics import autonomous_two_step + + device = torch.device(args.device) + model, _ = learning(args, world, out, study, device) + with np.load(out / f"predictions-{study['steps']}.npz") as saved: + direct = {k: saved[k] for k in ("prediction", "ended", "correct")} + for chain, name in enumerate(("company", "project")): + arrays = autonomous_two_step(model, world, chain, device) + ids = world.derived_ids[chain] + arrays.update({f"direct_{key}": value[ids] for key, value in direct.items()}) + atomic_numpy_save(out / f"two-step-{name}.npz", **arrays) + write_json( + out / "complete.json", + { + "status": "complete", + "phase": "P3-learning-only", + "learning_steps": study["steps"], + "edit_cases": 0, + "finished": time.time(), + }, + ) + except Exception as error: + write_json( + out / "failure.json", + { + "type": type(error).__name__, + "message": str(error), + "time": time.time(), + }, + ) + raise + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--world", type=int, required=True) + parser.add_argument("--seed", type=int, required=True) + parser.add_argument("--condition", choices=CONDITIONS, required=True) + parser.add_argument("--config", default="configs/bios-shortcut-control-v1.json") + parser.add_argument("--output", required=True) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit.py new file mode 100644 index 0000000000000000000000000000000000000000..856a9a8a4fd753c498c4b965d5c30a057bdebffd --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit.py @@ -0,0 +1,446 @@ +"""Prepared, resumable E39 MLP edits of matched low/high 15360-step parents.""" + +import argparse +import fcntl +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_cross import CHAINS, CONDITIONS, make_cross_world +from .bios_cross_continue import ( + capture_state, + edit_update, + file_hash, + restore_state, + validate_optimizer, +) +from .bios_cross_train import evaluate, source_hashes, tensor_queries +from .bios_data import array_hash, rng_for, write_json +from .bios_model import CausalLM, ModelConfig, select_parameters +from .bios_organization_train import atomic_numpy_save, atomic_torch_save, state_hash +from .bios_shortcut_control import high_exception_world, shortcut_sources +from .bios_shortcut_matched_edit import KINDS, PHASES, make_matched_edit_pair +from .bios_train import precision + +CHECKPOINTS = (0, 32, 128, 512) +STUDY = { + "protocol": "v2.8-p3-shortcut-matched-E39", + "width": 256, + "parent_step": 15360, + "phases": list(PHASES), + "worlds": [0, 1], + "seeds": [0, 1], + "conditions": list(CONDITIONS), + "chains": list(CHAINS), + "kinds": list(KINDS), + "scope": "mlp", + "mlp_layers": [3, 4, 5], + "lr": 0.00003, + "weight_decay": 0.1, + "edit_batch": 128, + "replay_batch": 128, + "retention_kl": 1.0, + "clip_norm": 1.0, + "steps": 512, + "checkpoints": list(CHECKPOINTS), + "resume_every": 32, + "models": 24, + "edit_cases": 96, + "E": 39, + "D": 96, + "R": 4096, + "primary_reference_D": 18, + "primary_reference_D_heldout": 9, + "status": "prepared conditional branch; no best-step selection", +} + + +def validate_study(study): + if study != STUDY: + raise ValueError("E39 editing configuration differs from the frozen prepared contract") + + +def editing_sources(): + directory = Path(__file__).parent + return { + **source_hashes(), + **{ + name: hashlib.sha256((directory / name).read_bytes()).hexdigest() + for name in ( + "bios_cross_continue.py", + "bios_shortcut_control.py", + "bios_shortcut_matched_edit.py", + "bios_shortcut_edit.py", + ) + }, + } + + +def sampling_stream(world_seed, chain, steps=512, batch=128, e_size=39, r_size=4096): + """No phase, organization, initialization, or update-type dependence.""" + rng = rng_for(world_seed, 932, chain) + return rng.integers(e_size, size=(steps, batch)), rng.integers(r_size, size=(steps, batch)) + + +def score_arrays(arrays, truth): + if any(arrays[key].shape != truth.shape for key in ("prediction", "ended", "correct")): + raise ValueError("Prediction shape mismatch") + if arrays["ended"].dtype != np.bool_ or arrays["correct"].dtype != np.bool_: + raise ValueError("EOS and correctness must be Boolean arrays") + np.testing.assert_array_equal( + arrays["correct"], (arrays["prediction"] == truth) & arrays["ended"] + ) + return arrays + + +def query_metrics(correct, ids): + n = len(ids) + count = int(correct[ids].sum()) + return {"n": n, "correct": count, "accuracy": count / n if n else None} + + +def retention_metrics(correct, old_correct, ids): + n = len(ids) + known_ids = ids[old_correct[ids]] + broken = int((~correct[known_ids]).sum()) + return { + "n": n, + "known": len(known_ids), + "coverage": len(known_ids) / n if n else None, + "broken": broken, + "damage": broken / len(known_ids) if len(known_ids) else None, + } + + +def edit_metrics(pair, phase, kind, arrays, old_correct): + correct = score_arrays(arrays, pair[f"{phase}_{kind}"])["correct"] + if old_correct.shape != correct.shape or old_correct.dtype != np.bool_: + raise ValueError("Old-correct coverage array mismatch") + result = { + key: query_metrics(correct, pair[key]) + for key in ( + "E", + "E_roots", + "E_actual", + "D", + "D_trained", + "D_heldout", + "paired_reference_D", + "paired_reference_D_heldout", + "D_edited_actual", + "D_edited_aligned", + "D_original_exception", + "D_newly_exception", + "D_remaining_ordinary_unedited", + ) + } + if kind == "exception": + result["exception_conflict_D"] = query_metrics(correct, pair["exception_conflict_D"]) + result["exception_conflict_D_heldout"] = query_metrics( + correct, pair["exception_conflict_D_heldout"] + ) + result["factual_conflict_D"] = query_metrics( + correct, pair[f"{phase}_{kind}_factual_conflict_D"] + ) + for pool in ("U_full", "U_heldout"): + ids = pair[pool] + result[pool] = { + **retention_metrics(correct, old_correct, ids), + "strata": { + str(group): retention_metrics( + correct, old_correct, ids[pair["U_strata"][ids] == group] + ) + for group in range(5) + }, + } + return result + + +def load_parent(parent, phase): + config = json.loads((parent / "config.json").read_text()) + expected_model = dict(vocab_size=4804, width=256, layers=8, heads=4, context=128) + if config["model"] != expected_model or config["study"]["steps"] != 15360: + raise ValueError("E39 requires original width256/15360 parents, never P2 continuations") + if any( + config["study"][key] != value + for key, value in { + "lr": 1e-4, + "documents_per_step": 16, + "facts_per_document": 10, + "QA_per_chain_per_step": 20, + "document_QA_weights": [0.8, 0.2], + }.items() + ): + raise ValueError("E39 parent exposure or learning budget differs") + if ( + config["world"] not in (0, 1) + or config["seed"] not in (0, 1) + or config["condition"] not in CONDITIONS + ): + raise ValueError("Parent is outside the fixed development matrix") + if config["sources"] != source_hashes(): + raise ValueError("Parent frozen trainer sources changed") + if config["torch"] != torch.__version__ or config["numpy"] != np.__version__: + raise ValueError("Parent numerical software differs") + if phase == "low" and config["study"]["protocol"] != "v2.6-development-crossover": + raise ValueError("Low parent is not an original unrestricted-context run") + if phase == "high" and config["study"].get("shortcut_contract") != shortcut_sources(): + raise ValueError("High parent manipulation/source provenance changed") + low = make_cross_world(config["world"]) + high, _, _, _ = high_exception_world(low) + world = low if phase == "low" else high + if config["truth_sha256"] != array_hash(world.answers): + raise ValueError("Parent truth differs from its declared prevalence phase") + with np.load(parent / "predictions-15360.npz") as saved: + predictions = score_arrays( + {key: saved[key] for key in ("prediction", "ended", "correct", "value_nll")}, + world.answers, + ) + checkpoint = torch.load(parent / "model-15360.pt", map_location="cpu", weights_only=False) + complete = json.loads((parent / "learning-complete.json").read_text()) + if ( + checkpoint["step"] != 15360 + or checkpoint["config"] != config["model"] + or complete["status"] != "complete" + ): + raise ValueError("Parent learning has not completed the specified checkpoint") + if state_hash(checkpoint["model"]) != complete["model_sha256"]: + raise ValueError("Parent checkpoint differs from completed learning weights") + provenance = { + "directory": str(parent), + "files_sha256": { + name: file_hash(parent / name) + for name in ( + "config.json", + "model-15360.pt", + "predictions-15360.npz", + "learning-complete.json", + ) + }, + "model_sha256": complete["model_sha256"], + } + return config, checkpoint, predictions, low, high, world, provenance + + +def run_case( + model, + baseline, + data, + world, + pair, + phase, + kind, + chain, + output, + identity_hash, + parent_predictions, + device, +): + dest = output / f"{CHAINS[chain]}-{kind}-mlp" + if (dest / "complete.json").exists(): + return + dest.mkdir(parents=True, exist_ok=True) + model.load_state_dict(baseline) + selected = select_parameters(model, "mlp", 3) + e_choices, r_choices = sampling_stream(world.seed, chain) + saved_sets = {key: value for key, value in pair.items() if isinstance(value, np.ndarray)} + saved_sets.update( + old_correct=parent_predictions["correct"], + edit_sampling=e_choices, + replay_sampling=r_choices, + ) + atomic_numpy_save(dest / "sets.npz", **saved_sets) + write_json(dest / "data-contract.json", pair["contract"]) + target = pair[f"{phase}_{kind}"] + new_data = tensor_queries(world, device, target) + model.eval() + references = [] + with torch.no_grad(), precision(device): + for begin in range(0, len(pair["R"]), 256): + ids = torch.as_tensor(pair["R"][begin : begin + 256], device=device) + references.append(model(data["tokens"][ids], data["positions"][ids]).detach()) + references = torch.cat(references) + optimizer = torch.optim.AdamW( + selected, lr=STUDY["lr"], weight_decay=0.1, fused=device.type == "cuda" + ) + first, timeline, seconds = 0, [], 0.0 + if (dest / "resume.pt").exists(): + saved = torch.load(dest / "resume.pt", map_location="cpu", weights_only=False) + if saved["identity_sha256"] != identity_hash or saved["case"] != dest.name: + raise ValueError("E39 resume identity mismatch") + if not 0 <= saved["step"] <= 512 or saved["step"] % 32: + raise ValueError("E39 resume step mismatch") + if saved["step"]: + validate_optimizer(saved["optimizer"], saved["step"], STUDY["lr"]) + restore_state(model, optimizer, saved, device) + first, timeline, seconds = saved["step"], saved["timeline"], saved["seconds"] + for step in range(first, 513): + if step in CHECKPOINTS and (not timeline or timeline[-1]["step"] != step): + arrays = evaluate(model, new_data, target) + if step == 0: + for key in ("prediction", "ended"): + np.testing.assert_array_equal(arrays[key], parent_predictions[key]) + point = { + "step": step, + "edit_seconds": seconds, + **edit_metrics(pair, phase, kind, arrays, parent_predictions["correct"]), + } + timeline.append(point) + atomic_numpy_save(dest / f"predictions-{step}.npz", **arrays) + write_json(dest / "trajectory.json", timeline) + if step % 32 == 0: + atomic_torch_save( + capture_state( + model, + optimizer, + device, + step=step, + timeline=timeline, + seconds=seconds, + identity_sha256=identity_hash, + case=dest.name, + ), + dest / "resume.pt", + ) + if step == 512: + break + ei = torch.as_tensor(pair["E"][e_choices[step]], device=device) + ri = torch.as_tensor(pair["R"][r_choices[step]], device=device) + choices = torch.as_tensor(r_choices[step], device=device) + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + edit_update(model, optimizer, selected, data, new_data, references, ei, ri, choices, device) + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - started + atomic_torch_save( + {"model": model.state_dict(), "config": model.config_dict(), "step": 512}, + dest / "model-final.pt", + ) + write_json( + dest / "complete.json", + { + "status": "complete", + "phase": phase, + "chain": CHAINS[chain], + "kind": kind, + "scope": "mlp", + "final": timeline[-1], + "model_sha256": state_hash(model.state_dict()), + }, + ) + print( + json.dumps( + { + "event": "E39_edit_complete", + "case": dest.name, + "E": timeline[-1]["E"]["accuracy"], + "paired_reference_heldout": timeline[-1]["paired_reference_D_heldout"]["accuracy"], + } + ), + flush=True, + ) + + +def run(args): + validate_study(json.loads(Path(args.config).read_text())) + parent, output = Path(args.parent).resolve(), Path(args.output).resolve() + if parent == output or parent in output.parents or output in parent.parents: + raise ValueError("E39 output must be separate from its immutable parent") + output.mkdir(parents=True, exist_ok=True) + with (output / ".lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + torch.set_num_threads(args.threads) + config, checkpoint, predictions, low, high, world, provenance = load_parent( + parent, args.phase + ) + pairs = [make_matched_edit_pair(low, high, chain) for chain in range(2)] + identity = { + "phase": args.phase, + "world": world.seed, + "seed": config["seed"], + "condition": config["condition"], + "study": STUDY, + "sources": editing_sources(), + "parent": provenance, + "data_contracts": [pair["contract"] for pair in pairs], + "torch": torch.__version__, + "cuda": torch.version.cuda, + "numpy": np.__version__, + "device_type": torch.device(args.device).type, + } + identity_path = output / "config.json" + if identity_path.exists() and json.loads(identity_path.read_text()) != identity: + raise ValueError("E39 editing identity or sources changed") + if not identity_path.exists(): + write_json(identity_path, identity) + if (output / "complete.json").exists(): + return + device = torch.device(args.device) + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + torch.manual_seed(config["seed"]) + if device.type == "cuda": + torch.cuda.manual_seed_all(config["seed"]) + model = CausalLM(ModelConfig(**checkpoint["config"])).to(device) + model.load_state_dict(checkpoint["model"]) + data = tensor_queries(world, device) + try: + baseline = { + key: value.detach().cpu().clone() for key, value in model.state_dict().items() + } + observed = evaluate(model, data, world.answers) + for key in ("prediction", "ended", "correct"): + np.testing.assert_array_equal(observed[key], predictions[key]) + for chain in range(2): + for kind in KINDS: + run_case( + model, + baseline, + data, + world, + pairs[chain], + args.phase, + kind, + chain, + output, + file_hash(identity_path), + predictions, + device, + ) + write_json( + output / "complete.json", + { + "status": "complete", + "phase": args.phase, + "edit_cases": 4, + "steps": 512, + "finished": time.time(), + }, + ) + except Exception as error: + write_json( + output / "failure.json", + {"type": type(error).__name__, "message": str(error), "time": time.time()}, + ) + raise + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--parent", required=True) + parser.add_argument("--phase", choices=PHASES, required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--config", default="configs/bios-shortcut-edit-v1.json") + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py new file mode 100644 index 0000000000000000000000000000000000000000..52dd3441331f501688eedfe95286f26462de3625 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py @@ -0,0 +1,446 @@ +"""Prepared, resumable E39 MLP edits of matched low/high 15360-step parents.""" + +import argparse +import fcntl +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_cross import CHAINS, CONDITIONS, make_cross_world +from .bios_cross_continue import ( + capture_state, + edit_update, + file_hash, + restore_state, + validate_optimizer, +) +from .bios_cross_train import evaluate, source_hashes, tensor_queries +from .bios_data import array_hash, rng_for, write_json +from .bios_model import CausalLM, ModelConfig, select_parameters +from .bios_organization_train import atomic_numpy_save, atomic_torch_save, state_hash +from .bios_shortcut_control import high_exception_world, shortcut_sources +from .bios_shortcut_matched_edit import KINDS, PHASES, make_matched_edit_pair +from .bios_train import precision + +CHECKPOINTS = (0, 32, 128, 512) +STUDY = { + "protocol": "v2.8-p3-shortcut-matched-E39", + "width": 256, + "parent_step": 15360, + "phases": list(PHASES), + "worlds": [0, 1], + "seeds": [0, 1], + "conditions": list(CONDITIONS), + "chains": list(CHAINS), + "kinds": list(KINDS), + "scope": "mlp", + "mlp_layers": [3, 4, 5], + "lr": 0.00003, + "weight_decay": 0.1, + "edit_batch": 128, + "replay_batch": 128, + "retention_kl": 1.0, + "clip_norm": 1.0, + "steps": 512, + "checkpoints": list(CHECKPOINTS), + "resume_every": 32, + "models": 24, + "edit_cases": 96, + "E": 39, + "D": 96, + "R": 4096, + "primary_reference_D": 18, + "primary_reference_D_heldout": 9, + "status": "prepared conditional branch; no best-step selection", +} + + +def validate_study(study): + if study != STUDY: + raise ValueError("E39 editing configuration differs from the frozen prepared contract") + + +def editing_sources(): + directory = Path(__file__).parent + return { + **source_hashes(), + **{ + name: hashlib.sha256((directory / name).read_bytes()).hexdigest() + for name in ( + "bios_cross_continue.py", + "bios_shortcut_control.py", + "bios_shortcut_matched_edit.py", + "bios_shortcut_edit_v2.py", + ) + }, + } + + +def sampling_stream(world_seed, chain, steps=512, batch=128, e_size=39, r_size=4096): + """No phase, organization, initialization, or update-type dependence.""" + rng = rng_for(world_seed, 932, chain) + return rng.integers(e_size, size=(steps, batch)), rng.integers(r_size, size=(steps, batch)) + + +def score_arrays(arrays, truth): + if any(arrays[key].shape != truth.shape for key in ("prediction", "ended", "correct")): + raise ValueError("Prediction shape mismatch") + if arrays["ended"].dtype != np.bool_ or arrays["correct"].dtype != np.bool_: + raise ValueError("EOS and correctness must be Boolean arrays") + np.testing.assert_array_equal( + arrays["correct"], (arrays["prediction"] == truth) & arrays["ended"] + ) + return arrays + + +def query_metrics(correct, ids): + n = len(ids) + count = int(correct[ids].sum()) + return {"n": n, "correct": count, "accuracy": count / n if n else None} + + +def retention_metrics(correct, old_correct, ids): + n = len(ids) + known_ids = ids[old_correct[ids]] + broken = int((~correct[known_ids]).sum()) + return { + "n": n, + "known": len(known_ids), + "coverage": len(known_ids) / n if n else None, + "broken": broken, + "damage": broken / len(known_ids) if len(known_ids) else None, + } + + +def edit_metrics(pair, phase, kind, arrays, old_correct): + correct = score_arrays(arrays, pair[f"{phase}_{kind}"])["correct"] + if old_correct.shape != correct.shape or old_correct.dtype != np.bool_: + raise ValueError("Old-correct coverage array mismatch") + result = { + key: query_metrics(correct, pair[key]) + for key in ( + "E", + "E_roots", + "E_actual", + "D", + "D_trained", + "D_heldout", + "paired_reference_D", + "paired_reference_D_heldout", + "D_edited_actual", + "D_edited_aligned", + "D_original_exception", + "D_newly_exception", + "D_remaining_ordinary_unedited", + ) + } + if kind == "exception": + result["exception_conflict_D"] = query_metrics(correct, pair["exception_conflict_D"]) + result["exception_conflict_D_heldout"] = query_metrics( + correct, pair["exception_conflict_D_heldout"] + ) + result["factual_conflict_D"] = query_metrics( + correct, pair[f"{phase}_{kind}_factual_conflict_D"] + ) + for pool in ("U_full", "U_heldout"): + ids = pair[pool] + result[pool] = { + **retention_metrics(correct, old_correct, ids), + "strata": { + str(group): retention_metrics( + correct, old_correct, ids[pair["U_strata"][ids] == group] + ) + for group in range(5) + }, + } + return result + + +def load_parent(parent, phase): + config = json.loads((parent / "config.json").read_text()) + low = make_cross_world(config["world"]) + expected_model = dict(vocab_size=low.vocab_size, width=256, layers=8, heads=4, context=128) + if config["model"] != expected_model or config["study"]["steps"] != 15360: + raise ValueError("E39 requires original width256/15360 parents, never P2 continuations") + if any( + config["study"][key] != value + for key, value in { + "lr": 1e-4, + "documents_per_step": 16, + "facts_per_document": 10, + "QA_per_chain_per_step": 20, + "document_QA_weights": [0.8, 0.2], + }.items() + ): + raise ValueError("E39 parent exposure or learning budget differs") + if ( + config["world"] not in (0, 1) + or config["seed"] not in (0, 1) + or config["condition"] not in CONDITIONS + ): + raise ValueError("Parent is outside the fixed development matrix") + if config["sources"] != source_hashes(): + raise ValueError("Parent frozen trainer sources changed") + if config["torch"] != torch.__version__ or config["numpy"] != np.__version__: + raise ValueError("Parent numerical software differs") + if phase == "low" and config["study"]["protocol"] != "v2.6-development-crossover": + raise ValueError("Low parent is not an original unrestricted-context run") + if phase == "high" and config["study"].get("shortcut_contract") != shortcut_sources(): + raise ValueError("High parent manipulation/source provenance changed") + high, _, _, _ = high_exception_world(low) + world = low if phase == "low" else high + if config["truth_sha256"] != array_hash(world.answers): + raise ValueError("Parent truth differs from its declared prevalence phase") + with np.load(parent / "predictions-15360.npz") as saved: + predictions = score_arrays( + {key: saved[key] for key in ("prediction", "ended", "correct", "value_nll")}, + world.answers, + ) + checkpoint = torch.load(parent / "model-15360.pt", map_location="cpu", weights_only=False) + complete = json.loads((parent / "learning-complete.json").read_text()) + if ( + checkpoint["step"] != 15360 + or checkpoint["config"] != config["model"] + or complete["status"] != "complete" + ): + raise ValueError("Parent learning has not completed the specified checkpoint") + if state_hash(checkpoint["model"]) != complete["model_sha256"]: + raise ValueError("Parent checkpoint differs from completed learning weights") + provenance = { + "directory": str(parent), + "files_sha256": { + name: file_hash(parent / name) + for name in ( + "config.json", + "model-15360.pt", + "predictions-15360.npz", + "learning-complete.json", + ) + }, + "model_sha256": complete["model_sha256"], + } + return config, checkpoint, predictions, low, high, world, provenance + + +def run_case( + model, + baseline, + data, + world, + pair, + phase, + kind, + chain, + output, + identity_hash, + parent_predictions, + device, +): + dest = output / f"{CHAINS[chain]}-{kind}-mlp" + if (dest / "complete.json").exists(): + return + dest.mkdir(parents=True, exist_ok=True) + model.load_state_dict(baseline) + selected = select_parameters(model, "mlp", 3) + e_choices, r_choices = sampling_stream(world.seed, chain) + saved_sets = {key: value for key, value in pair.items() if isinstance(value, np.ndarray)} + saved_sets.update( + old_correct=parent_predictions["correct"], + edit_sampling=e_choices, + replay_sampling=r_choices, + ) + atomic_numpy_save(dest / "sets.npz", **saved_sets) + write_json(dest / "data-contract.json", pair["contract"]) + target = pair[f"{phase}_{kind}"] + new_data = tensor_queries(world, device, target) + model.eval() + references = [] + with torch.no_grad(), precision(device): + for begin in range(0, len(pair["R"]), 256): + ids = torch.as_tensor(pair["R"][begin : begin + 256], device=device) + references.append(model(data["tokens"][ids], data["positions"][ids]).detach()) + references = torch.cat(references) + optimizer = torch.optim.AdamW( + selected, lr=STUDY["lr"], weight_decay=0.1, fused=device.type == "cuda" + ) + first, timeline, seconds = 0, [], 0.0 + if (dest / "resume.pt").exists(): + saved = torch.load(dest / "resume.pt", map_location="cpu", weights_only=False) + if saved["identity_sha256"] != identity_hash or saved["case"] != dest.name: + raise ValueError("E39 resume identity mismatch") + if not 0 <= saved["step"] <= 512 or saved["step"] % 32: + raise ValueError("E39 resume step mismatch") + if saved["step"]: + validate_optimizer(saved["optimizer"], saved["step"], STUDY["lr"]) + restore_state(model, optimizer, saved, device) + first, timeline, seconds = saved["step"], saved["timeline"], saved["seconds"] + for step in range(first, 513): + if step in CHECKPOINTS and (not timeline or timeline[-1]["step"] != step): + arrays = evaluate(model, new_data, target) + if step == 0: + for key in ("prediction", "ended"): + np.testing.assert_array_equal(arrays[key], parent_predictions[key]) + point = { + "step": step, + "edit_seconds": seconds, + **edit_metrics(pair, phase, kind, arrays, parent_predictions["correct"]), + } + timeline.append(point) + atomic_numpy_save(dest / f"predictions-{step}.npz", **arrays) + write_json(dest / "trajectory.json", timeline) + if step % 32 == 0: + atomic_torch_save( + capture_state( + model, + optimizer, + device, + step=step, + timeline=timeline, + seconds=seconds, + identity_sha256=identity_hash, + case=dest.name, + ), + dest / "resume.pt", + ) + if step == 512: + break + ei = torch.as_tensor(pair["E"][e_choices[step]], device=device) + ri = torch.as_tensor(pair["R"][r_choices[step]], device=device) + choices = torch.as_tensor(r_choices[step], device=device) + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + edit_update(model, optimizer, selected, data, new_data, references, ei, ri, choices, device) + if device.type == "cuda": + torch.cuda.synchronize(device) + seconds += time.perf_counter() - started + atomic_torch_save( + {"model": model.state_dict(), "config": model.config_dict(), "step": 512}, + dest / "model-final.pt", + ) + write_json( + dest / "complete.json", + { + "status": "complete", + "phase": phase, + "chain": CHAINS[chain], + "kind": kind, + "scope": "mlp", + "final": timeline[-1], + "model_sha256": state_hash(model.state_dict()), + }, + ) + print( + json.dumps( + { + "event": "E39_edit_complete", + "case": dest.name, + "E": timeline[-1]["E"]["accuracy"], + "paired_reference_heldout": timeline[-1]["paired_reference_D_heldout"]["accuracy"], + } + ), + flush=True, + ) + + +def run(args): + validate_study(json.loads(Path(args.config).read_text())) + parent, output = Path(args.parent).resolve(), Path(args.output).resolve() + if parent == output or parent in output.parents or output in parent.parents: + raise ValueError("E39 output must be separate from its immutable parent") + output.mkdir(parents=True, exist_ok=True) + with (output / ".lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + torch.set_num_threads(args.threads) + config, checkpoint, predictions, low, high, world, provenance = load_parent( + parent, args.phase + ) + pairs = [make_matched_edit_pair(low, high, chain) for chain in range(2)] + identity = { + "phase": args.phase, + "world": world.seed, + "seed": config["seed"], + "condition": config["condition"], + "study": STUDY, + "sources": editing_sources(), + "parent": provenance, + "data_contracts": [pair["contract"] for pair in pairs], + "torch": torch.__version__, + "cuda": torch.version.cuda, + "numpy": np.__version__, + "device_type": torch.device(args.device).type, + } + identity_path = output / "config.json" + if identity_path.exists() and json.loads(identity_path.read_text()) != identity: + raise ValueError("E39 editing identity or sources changed") + if not identity_path.exists(): + write_json(identity_path, identity) + if (output / "complete.json").exists(): + return + device = torch.device(args.device) + if device.type == "cuda": + torch.backends.cuda.matmul.allow_tf32 = True + torch.manual_seed(config["seed"]) + if device.type == "cuda": + torch.cuda.manual_seed_all(config["seed"]) + model = CausalLM(ModelConfig(**checkpoint["config"])).to(device) + model.load_state_dict(checkpoint["model"]) + data = tensor_queries(world, device) + try: + baseline = { + key: value.detach().cpu().clone() for key, value in model.state_dict().items() + } + observed = evaluate(model, data, world.answers) + for key in ("prediction", "ended", "correct"): + np.testing.assert_array_equal(observed[key], predictions[key]) + for chain in range(2): + for kind in KINDS: + run_case( + model, + baseline, + data, + world, + pairs[chain], + args.phase, + kind, + chain, + output, + file_hash(identity_path), + predictions, + device, + ) + write_json( + output / "complete.json", + { + "status": "complete", + "phase": args.phase, + "edit_cases": 4, + "steps": 512, + "finished": time.time(), + }, + ) + except Exception as error: + write_json( + output / "failure.json", + {"type": type(error).__name__, "message": str(error), "time": time.time()}, + ) + raise + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--parent", required=True) + parser.add_argument("--phase", choices=PHASES, required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--config", default="configs/bios-shortcut-edit-v1.json") + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=2) + run(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py new file mode 100644 index 0000000000000000000000000000000000000000..684e672ca551a48aacb2f4bc81db94092282f4cf --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py @@ -0,0 +1,327 @@ +"""Prepared E39 update sets shared by low/high shortcut-reliability worlds. + +This file generates and audits data only. It neither trains nor edits a model. +The 96 proposed MLP edits are distinct from the archived E93 experiment. +""" + +import numpy as np + +from .bios_data import array_hash, rng_for +from .bios_shortcut_control import audit_high_exception + +KINDS = ("coherent", "exception") +PHASES = ("low", "high") +BUDGET = { + "prevalence_levels": 2, + "worlds": 2, + "initializations": 2, + "organizations": 3, + "models": 24, + "chains": 2, + "update_types": 2, + "supports_per_chain": 1, + "scopes": ["mlp"], + "edit_cases": 96, +} +U_STRATA = { + "0": "original_exception_actual_in_affected_groups", + "1": "newly_exception_actual_in_affected_groups", + "2": "other_unchanged_facts_of_affected_people", + "3": "remaining_same_chain_facts", + "4": "remaining_cross_chain_or_independent_facts", +} + + +def make_matched_edit_pair(low, high, chain, support=0): + """Three roots + 36 actual facts; same IDs and support labels across phases. + + Each selected group contributes six QA-trained and six QA-heldout people + who remain ordinary in the high-prevalence world. Coherent assigns all 12 + to the new default. Exception assigns three default/three alternative in + each split. Histograms match ACROSS all three groups, not within a group. + """ + if chain not in (0, 1) or support != 0: + raise ValueError("The prepared contract fixes two chains and support zero") + if low.seed != high.seed or low.n_base != high.n_base: + raise ValueError("Low/high worlds must share their identity and query layout") + audit_high_exception(low, high) + rng = rng_for(low.seed, 931, chain) + for _ in range(10000): + groups = rng.choice(64, 3, replace=False) + if len(np.unique(low.defaults[chain, groups])) == 3: + break + else: + raise RuntimeError("Could not find three groups with distinct default cities") + selected = np.empty((3, 12), dtype=np.int64) + conflict = np.zeros((3, 12), dtype=bool) + conflict[:, :3] = conflict[:, 6:9] = True + targets = { + f"{phase}_{kind}": world.answers.copy() + for phase, world in (("low", low), ("high", high)) + for kind in KINDS + } + new_default = low.city_tokens[low.defaults[chain, np.roll(groups, -1)]] + alternative = low.city_tokens[low.defaults[chain, np.roll(groups, -2)]] + for index, group in enumerate(groups): + ordinary = np.flatnonzero((high.memberships[chain] == group) & ~high.exceptions[chain]) + for split, pool in enumerate((low.train_ids[chain], low.heldout_ids[chain])): + eligible = ordinary[np.isin(low.derived_ids[chain, ordinary], pool)] + if len(eligible) != 8: + raise ValueError("Expected eight still-ordinary people in each QA split") + selected[index, split * 6 : (split + 1) * 6] = rng.permutation(eligible)[:6] + actual = low.actual_ids[chain, selected[index]] + derived = low.derived_ids[chain, low.memberships[chain] == group] + for phase in PHASES: + for kind in KINDS: + target = targets[f"{phase}_{kind}"] + target[low.root_ids[chain, group]] = new_default[index] + target[derived] = new_default[index] + target[actual] = new_default[index] + if kind == "exception": + target[actual[conflict[index]]] = alternative[index] + edited_people = selected.ravel() + selected_people = np.isin(low.memberships[chain], groups) + original = selected_people & low.exceptions[chain] + newly = selected_people & high.exceptions[chain] & ~low.exceptions[chain] + unedited_ordinary = ( + selected_people & ~high.exceptions[chain] & ~np.isin(np.arange(2048), edited_people) + ) + e = np.sort(np.concatenate([low.root_ids[chain, groups], low.actual_ids[chain, edited_people]])) + d = low.derived_ids[chain, selected_people] + unchanged = np.ones(len(low.answers), dtype=bool) + unchanged[np.concatenate([e, d])] = False + affected_facts = (low.person >= 0) & selected_people[np.maximum(low.person, 0)] + original_actual = np.isin(np.arange(len(low.answers)), low.actual_ids[chain, original]) + newly_actual = np.isin(np.arange(len(low.answers)), low.actual_ids[chain, newly]) + relevant = np.isin(low.relation, [0, 1, 2, 10] if chain == 0 else [7, 8, 9, 11]) + strata = np.full(len(low.answers), -1, dtype=np.int64) + strata[unchanged & original_actual] = 0 + strata[unchanged & newly_actual] = 1 + strata[unchanged & affected_facts & ~original_actual & ~newly_actual] = 2 + strata[unchanged & ~affected_facts & relevant] = 3 + strata[unchanged & ~affected_facts & ~relevant] = 4 + heldout = [] + for stratum in range(5): + ids = rng.permutation(np.flatnonzero((strata == stratum) & (low.relation < 10))) + heldout.extend(ids[: max(1, int(np.ceil(0.2 * len(ids))))]) + heldout.extend(np.flatnonzero(unchanged & (low.relation >= 10))) + heldout = np.array(sorted(heldout), dtype=np.int64) + common_pool = np.flatnonzero(unchanged & (low.relation < 10) & (low.answers == high.answers)) + common_pool = np.setdiff1d(common_pool, heldout) + if len(common_pool) < 4096: + raise ValueError("Insufficient shared unchanged base facts for R4096") + replay = rng.choice(common_pool, 4096, replace=False) + paired_reference = np.sort(low.derived_ids[chain, selected[conflict]]) + pair = { + **targets, + "groups": groups, + "selected_people": selected, + "alternative_assignments": conflict, + "new_default": new_default, + "alternative": alternative, + "E": e, + "D": d, + "E_roots": low.root_ids[chain, groups], + "E_actual": np.sort(low.actual_ids[chain, edited_people]), + "E_actual_trained": np.sort(low.actual_ids[chain, selected[:, :6].ravel()]), + "E_actual_heldout": np.sort(low.actual_ids[chain, selected[:, 6:].ravel()]), + "D_trained": np.intersect1d(d, low.train_ids[chain]), + "D_heldout": np.intersect1d(d, low.heldout_ids[chain]), + "D_edited_actual": np.sort(low.derived_ids[chain, edited_people]), + "paired_reference_D": paired_reference, + "paired_reference_D_heldout": np.intersect1d(paired_reference, low.heldout_ids[chain]), + "exception_conflict_D": paired_reference.copy(), + "exception_conflict_D_heldout": np.intersect1d(paired_reference, low.heldout_ids[chain]), + "D_edited_aligned": np.sort(low.derived_ids[chain, selected[~conflict]]), + "D_original_exception": low.derived_ids[chain, original], + "D_newly_exception": low.derived_ids[chain, newly], + "D_remaining_ordinary_unedited": low.derived_ids[chain, unedited_ordinary], + "R": replay, + "U_full": np.flatnonzero(unchanged), + "U_heldout": heldout, + "U_strata": strata, + } + for phase in PHASES: + for kind in KINDS: + target = targets[f"{phase}_{kind}"] + actual_for_d = target[low.actual_ids[chain, selected_people]] + pair[f"{phase}_{kind}_factual_conflict_D"] = d[target[d] != actual_for_d] + pair["contract"] = { + "protocol": "v2.8-p3-shortcut-matched-E39-prepared", + "world": low.seed, + "chain": chain, + "support": support, + "status": "data_only_not_executed", + "budget": {**BUDGET, "scopes": BUDGET["scopes"].copy()}, + "model_checkpoint": ( + "width256, original 15360-step learning; not P2 30720-step continuation" + ), + "histogram_matching_scope": ( + "all three groups combined; also separately for trained/heldout QA" + ), + "coherent_actuals_per_group": "12 new-default (six in each QA split)", + "exception_actuals_per_group": ( + "6 new-default + 6 alternative (three + three in each QA split)" + ), + "paired_reference_semantics": ( + "same 18 people; conflict only in exception, reference only in coherent" + ), + "R_semantics": ( + "4096 identical query IDs with identical original truths " + "and unchanged under all four targets" + ), + "U_semantics": ( + "common query IDs; score each phase against its own truth and old-correct coverage" + ), + "U_strata": U_STRATA.copy(), + "historical_E93_comparable": False, + "low_truth_sha256": array_hash(low.answers), + "high_truth_sha256": array_hash(high.answers), + "array_sha256": {key: array_hash(value) for key, value in pair.items()}, + } + audit_matched_edit_pair(low, high, chain, pair) + return pair + + +def audit_matched_edit_pair(low, high, chain, pair): + """Verify ID, target, split, marginal, primary-subset, and replay contracts.""" + audit_high_exception(low, high) + if low.seed != high.seed or low.n_base != high.n_base: + raise ValueError("Low/high world identities differ") + e, d, selected, groups = (pair[key] for key in ("E", "D", "selected_people", "groups")) + if len(e) != 39 or len(np.unique(e)) != 39 or len(d) != 96 or len(np.unique(d)) != 96: + raise ValueError("E39/D96 support changed") + if len(groups) != 3 or len(np.unique(low.defaults[chain, groups])) != 3: + raise ValueError("Expected three groups with distinct original defaults") + if selected.shape != (3, 12) or len(np.unique(selected)) != 36: + raise ValueError("Expected twelve distinct people in each selected group") + if high.exceptions[chain, selected].any(): + raise ValueError("Selected edit people must be ordinary in both worlds") + np.testing.assert_array_equal( + pair["new_default"], low.city_tokens[low.defaults[chain, np.roll(groups, -1)]] + ) + np.testing.assert_array_equal( + pair["alternative"], low.city_tokens[low.defaults[chain, np.roll(groups, -2)]] + ) + np.testing.assert_array_equal( + d, low.derived_ids[chain, np.isin(low.memberships[chain], groups)] + ) + np.testing.assert_array_equal( + e, np.sort(np.r_[low.root_ids[chain, groups], low.actual_ids[chain, selected.ravel()]]) + ) + conflict = pair["alternative_assignments"] + if conflict.shape != (3, 12) or conflict.dtype != np.bool_: + raise ValueError("Invalid alternative assignment mask") + for index, group in enumerate(groups): + if not np.all(low.memberships[chain, selected[index]] == group): + raise ValueError("Selected person belongs to the wrong group") + for split, pool in enumerate((low.train_ids[chain], low.heldout_ids[chain])): + people = selected[index, split * 6 : (split + 1) * 6] + if not np.isin(low.derived_ids[chain, people], pool).all(): + raise ValueError("Selected QA split changed") + if conflict[index, split * 6 : (split + 1) * 6].sum() != 3: + raise ValueError("Each group/split must have three default and three alternative") + root = low.root_ids[chain, group] + derived = low.derived_ids[chain, low.memberships[chain] == group] + actual = low.actual_ids[chain, selected[index]] + for phase in PHASES: + for kind in KINDS: + target = pair[f"{phase}_{kind}"] + if target[root] != pair["new_default"][index] or not np.all( + target[derived] == target[root] + ): + raise ValueError( + "The three root rotations and their full propagation targets must agree" + ) + expected = np.full(12, target[root], dtype=np.int64) + if kind == "exception": + expected[conflict[index]] = pair["alternative"][index] + np.testing.assert_array_equal(target[actual], expected) + changed = np.union1d(e, d) + for phase, world in (("low", low), ("high", high)): + for kind in KINDS: + target = pair[f"{phase}_{kind}"] + np.testing.assert_array_equal(np.flatnonzero(target != world.answers), changed) + for kind in KINDS: + np.testing.assert_array_equal(pair[f"low_{kind}"][changed], pair[f"high_{kind}"][changed]) + for _split, pool in ( + ("all", low.derived_ids[chain]), + ("trained", low.train_ids[chain]), + ("heldout", low.heldout_ids[chain]), + ): + people = selected.ravel()[np.isin(low.derived_ids[chain, selected.ravel()], pool)] + actual = low.actual_ids[chain, people] + np.testing.assert_array_equal( + np.sort(pair["low_coherent"][actual]), np.sort(pair["low_exception"][actual]) + ) + reference = np.sort(low.derived_ids[chain, selected[conflict]]) + np.testing.assert_array_equal(pair["paired_reference_D"], reference) + np.testing.assert_array_equal(pair["exception_conflict_D"], reference) + heldout_reference = np.intersect1d(reference, low.heldout_ids[chain]) + np.testing.assert_array_equal(pair["exception_conflict_D_heldout"], heldout_reference) + np.testing.assert_array_equal(pair["paired_reference_D_heldout"], heldout_reference) + if len(reference) != 18 or len(heldout_reference) != 9: + raise ValueError("Expected eighteen primary exception conflicts, nine heldout") + partition = [ + pair[key] + for key in ( + "D_edited_actual", + "D_original_exception", + "D_newly_exception", + "D_remaining_ordinary_unedited", + ) + ] + if [len(ids) for ids in partition] != [36, 6, 42, 12]: + raise ValueError("Incorrect fixed propagation strata") + np.testing.assert_array_equal(np.sort(np.concatenate(partition)), d) + affected = np.isin(low.memberships[chain], groups) + expected_subsets = { + "E_roots": low.root_ids[chain, groups], + "E_actual": np.sort(low.actual_ids[chain, selected.ravel()]), + "E_actual_trained": np.sort(low.actual_ids[chain, selected[:, :6].ravel()]), + "E_actual_heldout": np.sort(low.actual_ids[chain, selected[:, 6:].ravel()]), + "D_trained": np.intersect1d(d, low.train_ids[chain]), + "D_heldout": np.intersect1d(d, low.heldout_ids[chain]), + "D_edited_actual": np.sort(low.derived_ids[chain, selected.ravel()]), + "D_edited_aligned": np.sort(low.derived_ids[chain, selected[~conflict]]), + "D_original_exception": low.derived_ids[chain, affected & low.exceptions[chain]], + "D_newly_exception": low.derived_ids[ + chain, affected & high.exceptions[chain] & ~low.exceptions[chain] + ], + } + for key, expected in expected_subsets.items(): + np.testing.assert_array_equal(pair[key], expected) + for phase in PHASES: + for kind in KINDS: + target = pair[f"{phase}_{kind}"] + conflicts = d[target[d] != target[low.actual_ids[chain, affected]]] + np.testing.assert_array_equal(pair[f"{phase}_{kind}_factual_conflict_D"], conflicts) + u = np.setdiff1d(np.arange(len(low.answers)), changed) + np.testing.assert_array_equal(pair["U_full"], u) + np.testing.assert_array_equal(pair["U_strata"] >= 0, np.isin(np.arange(len(low.answers)), u)) + replay = pair["R"] + if len(replay) != 4096 or len(np.unique(replay)) != 4096 or np.any(replay >= low.n_base): + raise ValueError("R must contain 4096 unique base-fact IDs") + if not np.isin(replay, u).all() or np.intersect1d(replay, pair["U_heldout"]).size: + raise ValueError("Replay leaks changed support/propagation or heldout retention") + if not np.isin(pair["U_heldout"], u).all(): + raise ValueError("Heldout retention includes changed targets") + np.testing.assert_array_equal(low.answers[replay], high.answers[replay]) + for phase in PHASES: + for kind in KINDS: + np.testing.assert_array_equal(pair[f"{phase}_{kind}"][replay], low.answers[replay]) + for key, value in pair.items(): + if isinstance(value, np.ndarray) and pair["contract"]["array_sha256"][key] != array_hash( + value + ): + raise ValueError(f"Matched update array provenance changed: {key}") + return { + "passed": True, + "E": 39, + "D": 96, + "exception_conflict_D": 18, + "exception_conflict_D_heldout": 9, + "R": 4096, + "budget_edit_cases": 96, + "histograms_match_across_three_groups_and_within_QA_split": True, + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_train.py new file mode 100644 index 0000000000000000000000000000000000000000..958bf5b4de4feec20d76d07a5d28016fec584d7a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bios_train.py @@ -0,0 +1,353 @@ +"""Reproducible symbolic development trajectories for bioS-Work-v1. + +Every evaluated answer is greedily generated without a correct-answer prefix. +Two generated tokens is the fixed symbolic grammar budget (one value plus EOS). +""" + +import argparse +import hashlib +import json +import os +import platform +import subprocess +import time +from contextlib import nullcontext +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_data import ( + EOS, + N_BASE, + N_QUERIES, + RELATIONS, + array_hash, + curriculum, + load_world, + write_json, +) +from .bios_model import CausalLM, ModelConfig, matmul_flops + + +def precision(device): + return ( + torch.autocast(device_type="cuda", dtype=torch.bfloat16) + if device.type == "cuda" + else nullcontext() + ) + + +def tensor_data(world, device, answers=None): + answer = torch.as_tensor(world.answers if answers is None else answers, device=device) + prompts = torch.as_tensor(world.prompts, device=device) + lengths = torch.as_tensor(world.lengths, device=device) + tokens = torch.zeros((N_QUERIES, 6), dtype=torch.long, device=device) + tokens[:, :5] = prompts + rows = torch.arange(N_QUERIES, device=device) + tokens[rows, lengths] = answer + tokens[lengths == 4, 5] = EOS + positions = torch.stack([lengths - 1, lengths], dim=1) + labels = torch.stack([answer, torch.full_like(answer, EOS)], dim=1) + return { + "prompts": prompts, + "lengths": lengths, + "tokens": tokens, + "positions": positions, + "labels": labels, + } + + +@torch.no_grad() +def evaluate(model, data, world, batch_size=512, answers=None): + device = data["tokens"].device + targets = world.answers if answers is None else answers + predictions, ended, nll = [], [], [] + model.eval() + for begin in range(0, N_QUERIES, batch_size): + end = min(begin + batch_size, N_QUERIES) + lengths = data["lengths"][begin:end] + rows = torch.arange(end - begin, device=device) + with precision(device): + logits = model(data["prompts"][begin:end], (lengths - 1)[:, None])[:, 0].float() + first = logits.argmax(-1) + continuation = torch.zeros((end - begin, 6), dtype=torch.long, device=device) + continuation[:, :5] = data["prompts"][begin:end] + continuation[rows, lengths] = first + second = model(continuation, lengths[:, None])[:, 0].argmax(-1) + predictions.append(first.cpu().numpy()) + ended.append(second.eq(EOS).cpu().numpy()) + labels = torch.as_tensor(targets[begin:end], device=device) + nll.append(F.cross_entropy(logits, labels, reduction="none").cpu().numpy()) + predictions, ended, nll = ( + np.concatenate(predictions), + np.concatenate(ended), + np.concatenate(nll), + ) + correct = (predictions == targets) & ended + strata = { + "employer": world.relation == 0, + "company_default": world.relation == 1, + "actual_nonexception": (world.relation == 2) + & ~world.exceptions[np.maximum(world.person, 0)], + "actual_old_exception": (world.relation == 2) + & world.exceptions[np.maximum(world.person, 0)], + "independent_attributes": np.isin(world.relation, [3, 4, 5, 6]), + } + metrics = { + "base_accuracy": float(correct[:N_BASE].mean()), + "derived_accuracy": float(correct[N_BASE:].mean()), + "value_nll": float(nll[:N_BASE].mean()), + "nontermination_rate": float((~ended).mean()), + "strata": {k: float(correct[v].mean()) for k, v in strata.items()}, + "learning_threshold_passed": bool( + correct[:N_BASE].mean() >= 0.99 and correct[N_BASE:].mean() >= 0.99 + ), + } + return metrics, { + "prediction": predictions, + "ended": ended, + "correct": correct, + "value_nll": nll, + } + + +def code_fingerprint(): + root = Path(__file__).resolve().parents[2] + files = sorted((root / "src" / "llm_memory_editability").glob("*.py")) + return { + "git_revision": subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=root, text=True + ).strip(), + "git_dirty": bool( + subprocess.check_output(["git", "status", "--porcelain"], cwd=root, text=True).strip() + ), + "source_sha256": { + str(p.relative_to(root)): hashlib.sha256(p.read_bytes()).hexdigest() for p in files + }, + } + + +def train(args): + device = torch.device(args.device) + torch.set_num_threads(args.threads) + torch.manual_seed(args.seed) + if device.type == "cuda": + torch.cuda.manual_seed_all(args.seed) + torch.backends.cuda.matmul.allow_tf32 = True + world = load_world(args.world) + out = Path(args.output) + out.mkdir(parents=True, exist_ok=True) + resume = torch.load(out / "resume.pt", weights_only=False) if args.resume else None + if resume is None and (out / "config.json").exists(): + raise ValueError("Output already contains a run; use a fresh output directory") + schedule = curriculum(world, args.order, args.steps) + model = CausalLM(ModelConfig(world.vocab_size)).to(device) + data = tensor_data(world, device) + optimizer = torch.optim.AdamW( + model.parameters(), lr=args.lr, weight_decay=0.1, fused=device.type == "cuda" + ) + checkpoints = sorted( + {0, *range(660, 5281, 660), *range(7280, args.steps + 1, 2000), args.steps} + ) + config = { + **vars(args), + "model": model.config_dict(), + "protocol": "v2.3", + "phase": "development", + "world_seed": world.seed, + "parameters": sum(p.numel() for p in model.parameters()), + "torch": torch.__version__, + "python": platform.python_version(), + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "visible_devices": os.environ.get("CUDA_VISIBLE_DEVICES"), + "precision": "BF16 autocast, FP32 weights/loss/Adam moments", + "checkpoints": checkpoints, + "schedule_sha256": array_hash(schedule), + "truth_sha256": array_hash(world.answers), + "flops_method": "executed-shape matmul estimate; elementwise and evaluation excluded", + **code_fingerprint(), + } + timeline, anchors = [], {} + counts = np.zeros(N_QUERIES, dtype=np.int64) + weighted_exposure = np.zeros(8) + train_seconds = 0.0 + losses = [] + steps_since_checkpoint = 0 + first_step = 0 + if resume is None: + write_json(out / "config.json", config) + np.save(out / "schedule.npy", schedule) + else: + # Exact continuation from the last predefined checkpoint's full training state. + original = json.loads((out / "config.json").read_text()) + for key in ("schedule_sha256", "truth_sha256", "seed", "order", "steps", "lr"): + if original[key] != config[key]: + raise ValueError(f"Resume mismatch on {key}") + model.load_state_dict(resume["model"]) + optimizer.load_state_dict(resume["optimizer"]) + torch.set_rng_state(resume["torch_rng"]) + if device.type == "cuda" and resume["cuda_rng"] is not None: + torch.cuda.set_rng_state(resume["cuda_rng"], device) + timeline, anchors = resume["timeline"], resume["anchors"] + counts, weighted_exposure = resume["counts"], resume["weighted_exposure"] + train_seconds = resume["train_seconds"] + first_step = resume["step"] + resumes = ( + json.loads((out / "resumes.json").read_text()) + if (out / "resumes.json").exists() + else [] + ) + resumes.append({"from_step": first_step, **code_fingerprint()}) + write_json(out / "resumes.json", resumes) + if device.type == "cuda": + torch.cuda.reset_peak_memory_stats(device) + for step in range(first_step, args.steps + 1): + if step in checkpoints and not (resume is not None and step == first_step): + start_eval = time.perf_counter() + metrics, arrays = evaluate(model, data, world) + for anchor, known in anchors.items(): + metrics[f"forgetting_since_{anchor}"] = ( + float((~arrays["correct"][known]).mean()) if known.any() else None + ) + if step in (2640, 5280): + anchors[step] = arrays["correct"].copy() + np.savez_compressed(out / f"predictions-{step}.npz", **arrays, exposure=counts) + # CPU state for portability; all predefined checkpoints retained. + torch.save( + { + "model": {k: v.detach().cpu() for k, v in model.state_dict().items()}, + "config": model.config_dict(), + "step": step, + }, + out / f"model-{step}.pt", + ) + record = { + "step": step, + **metrics, + "train_seconds": train_seconds, + "train_matmul_flops_estimate": step * matmul_flops(model.config, 128), + "presentations": int(counts.sum()), + "coverage_base": float((counts[:N_BASE] > 0).mean()), + "coverage_derived": float((counts[N_BASE:] > 0).mean()), + "world_tokens": int((counts * (world.lengths + 2)).sum()), + "input_tokens_including_padding": step * 128 * 6, + "supervised_tokens": step * 128 * 2, + "lr_weighted_exposure_by_relation": dict( + zip((*RELATIONS, "derived"), weighted_exposure.tolist(), strict=True) + ), + "peak_cuda_bytes": torch.cuda.max_memory_allocated(device) + if device.type == "cuda" + else 0, + "eval_and_checkpoint_seconds": time.perf_counter() - start_eval, + "mean_training_loss_since_previous": float(np.mean(losses)) if losses else None, + } + timeline.append(record) + write_json(out / "learning.json", timeline) + print( + json.dumps( + { + "event": "checkpoint", + "step": step, + "base": metrics["base_accuracy"], + "derived": metrics["derived_accuracy"], + "train_seconds": train_seconds, + } + ), + flush=True, + ) + losses = [] + steps_since_checkpoint = 0 + state = { + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "torch_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device) if device.type == "cuda" else None, + "timeline": timeline, + "anchors": anchors, + "counts": counts, + "weighted_exposure": weighted_exposure, + "train_seconds": train_seconds, + "step": step, + } + torch.save(state, out / "resume.pt.tmp") + os.replace(out / "resume.pt.tmp", out / "resume.pt") + if step == args.steps: + break + model.train() + lr = args.lr * min((step + 1) / 2000, 1.0) + for group in optimizer.param_groups: + group["lr"] = lr + ids_np = schedule[step] + ids = torch.as_tensor(ids_np, device=device) + if device.type == "cuda": + torch.cuda.synchronize(device) + started = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with precision(device): + logits = model(data["tokens"][ids], data["positions"][ids]) + loss = F.cross_entropy( + logits.float().reshape(-1, world.vocab_size), data["labels"][ids].reshape(-1) + ) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) + if not torch.isfinite(loss) or not torch.isfinite(norm): + write_json( + out / "failure.json", + { + "step": step, + "reason": "nonfinite loss or gradient", + "train_seconds": train_seconds, + }, + ) + raise FloatingPointError("Nonfinite loss or gradient") + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + train_seconds += time.perf_counter() - started + losses.append(loss.item()) + np.add.at(counts, ids_np, 1) + weighted_exposure += np.bincount(world.relation[ids_np], minlength=8) * lr + steps_since_checkpoint += 1 + if (step + 1) % 100 == 0: + print( + json.dumps( + { + "event": "progress", + "step": step + 1, + "loss": float(np.mean(losses[-100:])), + "train_seconds": train_seconds, + } + ), + flush=True, + ) + write_json( + out / "complete.json", + { + "step": args.steps, + "status": "complete", + "final": timeline[-1], + "exposure_sha256": array_hash(counts), + }, + ) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--world", required=True) + parser.add_argument("--output", required=True) + parser.add_argument("--order", choices=["SA", "AS"], required=True) + parser.add_argument("--seed", type=int, default=0) + parser.add_argument("--steps", type=int, default=13280) + parser.add_argument("--lr", type=float, default=1e-4) + parser.add_argument("--device", default="cuda") + parser.add_argument("--threads", type=int, default=4) + parser.add_argument("--resume", action="store_true") + train(parser.parse_args()) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_reencoding.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_reencoding.py new file mode 100644 index 0000000000000000000000000000000000000000..1dbbe769879cff4d2b00a6c39164102b50d035e3 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_reencoding.py @@ -0,0 +1,438 @@ +"""Fixed-weight, self-decoded bridge re-encoding in existing small GPTs. + +The intervention uses the original tied readout over the complete vocabulary. +Only the explicitly named oracle condition accesses graph answers at inference. +The wrong_entity control is an alternative to the model's decoded token, not a +guaranteed incorrect answer: its accidental agreement with truth is reported. +""" + +from __future__ import annotations + +import json +import os +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import utc, write_json +from .latent_scaling import build_world, model_digest +from .representation_alignment import RepresentationGPT, new_model +from .storage_composition import data_digest, evaluate, file_hash, generate_rows +from .text_pretrain import WORDS, composite_sentence + +CONDITIONS = ("baseline", "self_decode", "wrong_entity", "oracle") + + +def reencode_state(state, embedding, alpha, variant="norm_matched"): + """Interpolate residual and normalized embedding, without renormalizing the sum. + + norm_matched gives the replacement embedding the original state's norm. + paper_unit uses a unit embedding directly. Neither preserves the mixture's + norm in general; alpha=0 returns the original tensor exactly. + """ + if not 0 <= alpha <= 1: + raise ValueError("alpha must be between zero and one") + if variant not in ("norm_matched", "paper_unit"): + raise ValueError("Unknown re-encoding variant") + if alpha == 0: + return state + replacement = F.normalize(embedding, dim=-1) + if variant == "norm_matched": + replacement = state.norm(dim=-1, keepdim=True) * replacement + return (1 - alpha) * state + alpha * replacement + + +def alternative_entity(decoded, bridge_start, bridge_count): + """A non-self bridge-entity choice, independent of the true bridge identity.""" + if bridge_count < 2: + raise ValueError("At least two bridge entity tokens are required") + return bridge_start + torch.remainder(decoded - bridge_start + 1, bridge_count) + + +class ReencodingGPT(RepresentationGPT): + """Original computation with a single intervention at block 0, position 3.""" + + def configure(self, condition, alpha, oracle_table=None, variant="norm_matched"): + if condition not in CONDITIONS: + raise ValueError(f"Unknown condition: {condition}") + if not 0 <= alpha <= 1: + raise ValueError("alpha must be between zero and one") + if variant not in ("norm_matched", "paper_unit"): + raise ValueError("Unknown re-encoding variant") + if condition == "oracle" and oracle_table is None: + raise ValueError("Oracle condition requires an explicit diagnostic truth table") + self.condition, self.alpha, self.variant = condition, float(alpha), variant + # Deliberately outside state_dict: neither weights nor model hashes change. + self.oracle_table = oracle_table if condition == "oracle" else None + + def _choice(self, state, tokens): + decoded = F.linear(self.ln_final(state), self.token.weight).argmax(-1) + selected = decoded + oracle_available = torch.zeros_like(decoded, dtype=torch.bool) + if self.condition == "wrong_entity": + selected = alternative_entity(decoded, self.bridge_start, self.bridge_count) + elif self.condition == "oracle": + oracle = self.oracle_table[tokens[:, 1], tokens[:, 3]] + oracle_available = oracle >= 0 + # Invalid autonomously generated heads have no graph truth. Do not + # fabricate an oracle answer; retain the model's decoded token. + selected = torch.where(oracle_available, oracle, decoded) + return decoded, selected, oracle_available + + def forward(self, tokens, positions=None, repeats=None, return_bridge=False): + if not return_bridge and (self.condition == "baseline" or self.alpha == 0): + return super().forward(tokens, positions=positions, repeats=repeats) + if tokens.shape[1] < 4: + raise ValueError("The intervention requires the causal first-relation prefix") + p = self.dropout if self.training else 0.0 + x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device)) + x = F.dropout(x, p=p, training=self.training) + info = None + for index, block in enumerate(self.iter_blocks(repeats)): + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=p, + ) + y = a.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + F.dropout(y, p=p, training=self.training) + x = x + F.dropout(block.mlp(block.ln2(x)), p=p, training=self.training) + if index == 0: + state = x[:, 3] + decoded, selected, oracle_available = self._choice(state, tokens) + replacement = ( + state + if self.condition == "baseline" + else reencode_state(state, self.token(selected), self.alpha, self.variant) + ) + if self.condition != "baseline" and self.alpha: + x = x.clone() + x[:, 3] = replacement + info = { + "state": state, + "replacement": replacement, + "decoded": decoded, + "selected": selected, + "oracle_available": oracle_available, + } + x = self.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + logits = F.linear(x, self.token.weight) + return (logits, info) if return_bridge else logits + + +def _device_settings(device): + device = torch.device(device) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + if device.type == "cuda": + torch.cuda.set_device(device) + return device + + +def _load(spec, device): + parent = Path(spec["parent_dir"]).resolve() + checkpoint = parent / "model.pt" + payload = torch.load(checkpoint, map_location="cpu", weights_only=False) + model = new_model(payload["spec"], device) + model.load_state_dict(payload["model"]) + model.__class__ = ReencodingGPT + model.bridge_start = len(WORDS) + payload["spec"]["heads_n"] + model.bridge_count = payload["spec"]["bridges_n"] + model.configure("baseline", 0) + model.eval().requires_grad_(False) + world = dict(np.load(parent / "world.npz")) + rebuilt = build_world(payload["spec"]) + if data_digest(world) != data_digest(rebuilt): + raise AssertionError("Saved world differs from the parent specification") + oracle = torch.full( + (model.config.vocab_size, model.config.vocab_size), -1, device=device, dtype=torch.long + ) + for h, r, target in np.concatenate((world["common_atomic"], world["extra_atomic"])): + oracle[h, r] = int(target) + return model, world, oracle, payload["spec"], checkpoint + + +@torch.no_grad() +def _diagnostics(model, rows, device, batch_size): + prompts = np.asarray([composite_sentence(row)[:7] for row in rows]) + collected = {} + model.eval() + for start in range(0, len(rows), batch_size): + tokens = torch.as_tensor(prompts[start : start + batch_size], device=device) + _, info = model(tokens, return_bridge=True) + values = { + "decoded_bridge": info["decoded"], + "selected_bridge": info["selected"], + "oracle_available": info["oracle_available"], + "state_norm": info["state"].norm(dim=-1), + "replacement_norm": info["replacement"].norm(dim=-1), + } + for key, value in values.items(): + collected.setdefault(key, []).append(value.cpu().numpy()) + result = {key: np.concatenate(value) for key, value in collected.items()} + result["decoded_bridge_correct"] = result["decoded_bridge"] == rows[:, 2] + result["selected_bridge_correct"] = result["selected_bridge"] == rows[:, 2] + result["decoded_is_entity"] = result["decoded_bridge"] >= len(WORDS) + return result + + +def _subset_metric(correct, mask): + return { + "n": int(mask.sum()), + "coverage": float(mask.mean()), + "accuracy": float(correct[mask].mean()) if mask.any() else None, + } + + +@torch.no_grad() +def _evaluate_condition(model, world, device, batch_size): + # Reuse the established complete answer/period/EOS scorer unchanged. Its + # canonical batch is 512; diagnostics use the same shapes for exact decoding. + if batch_size != 512: + raise ValueError("Use batch_size=512 to preserve established evaluation arithmetic") + metrics, predictions = evaluate(model, world, "low", device) + model.eval() + for name in ("common_atomic", "train_composite", "familiar_test", "strict_test"): + generated = predictions[name + "_generated"] + metrics[name]["period_accuracy"] = float((generated[:, 1] == 5).mean()) + metrics[name]["eos_accuracy"] = float((generated[:, 2] == 1).mean()) + metrics[name]["format_accuracy"] = float( + ((generated[:, 1] == 5) & (generated[:, 2] == 1)).mean() + ) + for name in ("familiar_test", "strict_test"): + rows = world[name] + info = _diagnostics(model, rows, device, batch_size) + predictions.update({name + "_" + key: value for key, value in info.items()}) + for key in ("decoded_bridge_correct", "selected_bridge_correct", "decoded_is_entity"): + metrics[name][key + "_coverage"] = float(info[key].mean()) + if model.condition == "wrong_entity": + metrics[name]["alternative_accidental_gold_match"] = float( + info["selected_bridge_correct"].mean() + ) + correct = predictions[name + "_correct"] + metrics[name]["self_bridge_correct_subset"] = _subset_metric( + correct, info["decoded_bridge_correct"] + ) + first = rows[:, [0, 1, 2]] + second = rows[:, [2, 3, 4]] + for role, atoms in (("first", first), ("second", second)): + _, raw = generate_rows(model, atoms, device, batch_size=batch_size) + predictions.update({f"{name}_{role}_{key}": value for key, value in raw.items()}) + autonomous_second = second.copy() + autonomous_second[:, 0] = predictions[name + "_first_generated"][:, 0] + _, raw = generate_rows(model, autonomous_second, device, batch_size=batch_size) + predictions.update({f"{name}_autonomous_{key}": value for key, value in raw.items()}) + return metrics, predictions + + +def cases(spec): + """One baseline and the frozen alpha/variant/condition matrix.""" + conditions = list(spec.get("conditions", CONDITIONS)) + if len(conditions) != len(set(conditions)) or any(c not in CONDITIONS for c in conditions): + raise ValueError("Conditions must be distinct known names") + alphas = spec.get("alphas", [spec.get("alpha", 0)]) + variants = spec.get("variants", ["norm_matched"]) + if len(alphas) != len(set(alphas)) or not alphas or any(not 0 <= a <= 1 for a in alphas): + raise ValueError("alphas must contain distinct values in [0,1]") + if len(variants) != len(set(variants)) or not variants: + raise ValueError("variants must be distinct and nonempty") + if any(v not in ("norm_matched", "paper_unit") for v in variants): + raise ValueError("Unknown re-encoding variant") + matrix = {"baseline": {"condition": "baseline", "alpha": 0, "variant": "norm_matched"}} + for variant in variants: + for alpha in alphas: + for condition in conditions: + if condition == "baseline": + continue + name = f"{variant}-a{float(alpha):g}-{condition}" + matrix[name] = {"condition": condition, "alpha": float(alpha), "variant": variant} + return matrix + + +def _evaluate_all(model, world, oracle, spec, callback=None): + matrix = cases(spec) + metrics, arrays = {}, {} + for name, case in matrix.items(): + model.configure( + case["condition"], + case["alpha"], + oracle if case["condition"] == "oracle" else None, + case["variant"], + ) + metrics[name], predictions = _evaluate_condition( + model, world, next(model.parameters()).device, spec.get("batch_size", 512) + ) + arrays.update({name + "__" + key: value for key, value in predictions.items()}) + if callback is not None: + callback(name, case, metrics[name], predictions) + for name in ("familiar_test", "strict_test"): + baseline = arrays[f"baseline__{name}_coverage"] + # This is the fixed pre-intervention prerequisite pool for every case. + # In particular, the destructive alternative-entity control cannot + # determine which chains enter the main conditional comparison. + arrays[f"common__{name}_atomic_correct"] = baseline + for condition in matrix: + correct = arrays[f"{condition}__{name}_correct"] + arrays[f"{condition}__{name}_baseline_common_atoms"] = baseline + metrics[condition][name]["fixed_baseline_atoms_subset"] = _subset_metric( + correct, baseline + ) + self_ok = arrays[f"{condition}__{name}_decoded_bridge_correct"] + joint = baseline & self_ok + arrays[f"{condition}__{name}_common_atoms_and_self_bridge"] = joint + metrics[condition][name]["common_atoms_and_self_bridge_subset"] = _subset_metric( + correct, joint + ) + model.configure("baseline", 0) + return metrics, arrays + + +def run(spec, out, device="cuda:2"): + """Evaluate one existing checkpoint; never train or overwrite an attempt.""" + out = Path(out) + if (out / "run.json").exists(): + raise FileExistsError(f"Do not overwrite an attempt: {out}") + out.mkdir(parents=True, exist_ok=True) + device = _device_settings(device) + started = time.perf_counter() + model, world, oracle, parent_spec, checkpoint = _load(spec, device) + digest = model_digest(model) + source = { + str(Path(__file__).resolve()): file_hash(__file__), + "parent_checkpoint": file_hash(checkpoint), + } + manifest = { + "spec": spec, + "parent_spec": parent_spec, + "source": source, + "world_sha256": data_digest(world), + "model_sha256": digest, + "pid": os.getpid(), + "device": str(device), + "started_utc": utc(), + "new_training_updates": 0, + "optimizer_updates": 0, + "cases": cases(spec), + "formula_norm_matched": "(1-alpha)*h + alpha*||h||*normalize(E_decoded)", + "formula_paper_unit": "(1-alpha)*h + alpha*normalize(E_decoded)", + "decoder": "original ln_final and tied output, argmax over the full vocabulary", + "wrong_entity_scope": "non-self bridge entity, independent of gold; may equal true bridge", + "bridge_token_start": model.bridge_start, + "bridge_token_count": model.bridge_count, + "main_prerequisite_subset": "both necessary atoms correct under the fixed baseline", + "alpha_zero_exact_bypass": True, + "allow_tf32": True, + } + write_json(out / "run.json", manifest) + np.savez_compressed(out / "world.npz", **world) + history = [] + + def record(name, case, metrics, predictions): + history.append( + { + "step": len(history) + 1, + "case": name, + **case, + "metrics": metrics, + "optimizer_updates": 0, + "wall_seconds": time.perf_counter() - started, + "created_utc": utc(), + } + ) + # Each condition is durable before the next one starts. + np.savez_compressed(out / f"predictions-{name}.npz", **predictions) + write_json(out / "learning.json", history) + write_json( + out / "status.json", + { + "state": "running", + "step": len(history), + "budget": len(manifest["cases"]), + "optimizer_updates": 0, + }, + ) + + metrics, predictions = _evaluate_all(model, world, oracle, spec, record) + assert model_digest(model) == digest, "Evaluation changed model parameters" + # Final common-prerequisite subsets are known only after the full matrix. + write_json(out / "learning.json", history) + # At zero weight all conditions must recover complete baseline generation. + for key, value in predictions.items(): + if key.endswith(("_generated", "_answer_nll")): + case, suffix = key.split("__", 1) + if manifest["cases"][case]["alpha"] == 0: + np.testing.assert_array_equal(value, predictions["baseline__" + suffix]) + np.savez_compressed(out / "predictions.npz", **predictions) + write_json(out / "metrics.json", metrics) + result = { + "state": "evaluation-complete-awaiting-independent-audit", + "finished_utc": utc(), + "wall_seconds": time.perf_counter() - started, + "model_sha256": digest, + "new_training_updates": 0, + "optimizer_updates": 0, + "conditions": list(metrics), + "prediction_arrays": len(predictions), + "step": len(history), + } + write_json(out / "evaluation-complete.json", result) + write_json(out / "status.json", {**result, "step": len(history)}) + return result + + +def audit(out, device="cuda:2"): + """Reload weights and independently recompute every saved prediction array.""" + out = Path(out) + device = _device_settings(device) + manifest = json.loads((out / "run.json").read_text()) + model, world, oracle, _, checkpoint = _load(manifest["spec"], device) + assert file_hash(checkpoint) == manifest["source"]["parent_checkpoint"] + assert model_digest(model) == manifest["model_sha256"] + assert data_digest(world) == manifest["world_sha256"] + metrics, actual = _evaluate_all(model, world, oracle, manifest["spec"]) + saved = dict(np.load(out / "predictions.npz")) + assert set(saved) == set(actual), "Prediction array set changed" + max_error = 0.0 + for key, value in actual.items(): + if value.dtype.kind == "f": + max_error = max(max_error, float(np.max(np.abs(value - saved[key])))) + np.testing.assert_allclose(value, saved[key], atol=1e-5, rtol=1e-5) + else: + np.testing.assert_array_equal(value, saved[key]) + # Recount complete-answer accuracy independently of the established scorer. + for condition, groups in metrics.items(): + for name in ("common_atomic", "train_composite", "familiar_test", "strict_test"): + pred = actual[f"{condition}__{name}_generated"] + correct = (pred[:, 0] == world[name][:, -1]) & (pred[:, 1] == 5) & (pred[:, 2] == 1) + np.testing.assert_array_equal(correct, actual[f"{condition}__{name}_correct"]) + assert float(correct.mean()) == groups[name]["accuracy"] + assert model_digest(model) == manifest["model_sha256"] + result = { + "passed": True, + "independently_reloaded": True, + "raw_predictions_recounted": True, + "prediction_arrays": len(actual), + "max_float_error": max_error, + "audit_pid": os.getpid(), + "independent_process": os.getpid() != manifest["pid"], + "finished_utc": utc(), + "metrics": metrics, + } + write_json(out / "audit.json", result) + complete = json.loads((out / "evaluation-complete.json").read_text()) + complete.update(state="complete", independently_reloaded=True, audit_finished_utc=utc()) + write_json(out / "complete.json", complete) + write_json(out / "status.json", {**complete, "step": len(metrics), "optimizer_updates": 0}) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_workspace.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_workspace.py new file mode 100644 index 0000000000000000000000000000000000000000..6f3ee68821631607b4922cfce3654cd2784d82ba --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/bridge_workspace.py @@ -0,0 +1,1112 @@ +"""Causal entity-coordinate interventions using an averaged prefix Jacobian. + +This is a restricted adaptation of Anthropic's Jacobian lens: calibration and +donors contain only the first fact's query prefix. No relation suffix or answer +gradient is used to construct a direction. Execution layers count shared block +occurrences separately. All model parameters remain frozen. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import time +from collections import defaultdict +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import utc, write_json +from .latent_scaling import model_digest +from .storage_composition import file_hash + +SWAPS = ("swap", "swap_x2", "random_swap", "full_prefix", "swap_back") +ERASURES = ( + "erase_state", + "erase_mlp", + "erase_attention", + "random_state", + "random_mlp", + "random_attention", + "restore_mlp", + "fixed_entity_mlp", + "fixed_entity_random_mlp", +) + + +class ModelView: + """Expose native attention/MLP increments without replacing trained modules.""" + + def __init__(self, model): + if model.training: + raise ValueError("Interventions require eval mode") + self.model = model + self.large = hasattr(model, "transformer") + if self.large: + t = model.transformer + self.embedding, self.position, self.norm = t.wte, t.wpe, t.ln_f + self.blocks = list(t.h) * model.repeats + self.heads = model.config.n_head + else: + self.embedding, self.position, self.norm = model.token, model.position, model.ln_final + self.blocks = list(model.iter_blocks()) + self.heads = model.config.heads + self.width = self.embedding.weight.shape[1] + self.device = self.embedding.weight.device + + def embed(self, tokens): + return self.embedding(tokens) + self.position( + torch.arange(tokens.shape[1], device=self.device) + ) + + def parts(self, x, block, *, math_attention=False): + if self.large: + z = block.ln_1(x) + q, k, v = block.attn.c_attn(z).split(self.width, dim=-1) + project, ln2 = block.attn.c_proj, block.ln_2 + else: + z = block.ln1(x) + q, k, v = block.attention.qkv(z).chunk(3, dim=-1) + project, ln2 = block.attention.proj, block.ln2 + shape = (len(x), x.shape[1], self.heads, self.width // self.heads) + q, k, v = (a.reshape(shape).transpose(1, 2) for a in (q, k, v)) + if math_attention: + # The explicit FP32 expression permits batched VJPs on torch 2.6. + scores = q @ k.transpose(-1, -2) / (self.width // self.heads) ** 0.5 + mask = torch.ones(x.shape[1], x.shape[1], device=self.device, dtype=torch.bool).tril() + y = scores.masked_fill(~mask, -torch.inf).softmax(-1) @ v + else: + y = F.scaled_dot_product_attention(q, k, v, is_causal=True) + attention = project(y.transpose(1, 2).reshape(len(x), x.shape[1], self.width)) + after_attention = x + attention + mlp = block.mlp(ln2(after_attention)) + return after_attention + mlp, attention, mlp + + def hidden( + self, tokens, *, layer=None, sender=None, delta=None, capture=False, math_attention=False + ): + x, states, attentions, mlps = self.embed(tokens), [], [], [] + for index, block in enumerate(self.blocks): + x, attention, mlp = self.parts(x, block, math_attention=math_attention) + if capture: + states.append(x[:, sender].detach()) + attentions.append(attention[:, sender].detach()) + mlps.append(mlp[:, sender].detach()) + if index == layer: + if sender is None or delta is None or delta.shape != x[:, sender].shape: + raise ValueError("A patch requires one delta per example at a fixed sender") + mask = F.one_hot(torch.tensor(sender, device=self.device), x.shape[1]).to(x.dtype) + x = x + mask[None, :, None] * delta[:, None, :] + if capture: + return x, tuple(torch.stack(a) for a in (states, attentions, mlps)) + return x + + def logits(self, tokens, **patch): + return F.linear(self.norm(self.hidden(tokens, **patch)[:, -1]), self.embedding.weight) + + +def average_prefix_jacobian(view, prefixes, sender, *, chunk=32): + """E[d h_final,sender / d h_layer,sender], with labels absent from the graph. + + A shared shift applied to all independent calibration prompts differentiates + their mean output, exactly averaging their Jacobians. Parameters need no + gradients. The endpoint is the residual before the final LayerNorm. + """ + if any(p.requires_grad for p in view.model.parameters()): + raise ValueError("Freeze model parameters before constructing the lens") + with torch.no_grad(): + x, boundaries = view.embed(prefixes), [] + for block in view.blocks: + x, _, _ = view.parts(x, block, math_attention=True) + boundaries.append(x.detach()) + jacobians = [] + identity = torch.eye(view.width, device=view.device) + for layer, boundary in enumerate(boundaries): + shift = torch.zeros(view.width, device=view.device, requires_grad=True) + mask = F.one_hot(torch.tensor(sender, device=view.device), prefixes.shape[1]).float() + x = boundary + mask[None, :, None] * shift[None, None, :] + for block in view.blocks[layer + 1 :]: + x, _, _ = view.parts(x, block, math_attention=True) + endpoint = x[:, sender].mean(0) + rows = [] + for start in range(0, view.width, chunk): + rows.append( + torch.autograd.grad( + endpoint, + shift, + grad_outputs=identity[start : start + chunk], + is_grads_batched=True, + retain_graph=start + chunk < view.width, + )[0].detach() + ) + jacobians.append(torch.cat(rows)) + return torch.stack(jacobians) + + +def swap_coordinates(state, basis): + """Swap two coefficients in a nonorthogonal frame, preserving its complement.""" + if basis.shape != (*state.shape, 2): + raise ValueError("Expected [example, width, two semantic axes]") + coefficients = (torch.linalg.pinv(basis.double()) @ state.double()[..., None]).squeeze(-1) + difference = coefficients.flip(-1) - coefficients + return state + (basis.double() @ difference[..., None]).squeeze(-1).to(state.dtype) + + +def projection(state, direction): + direction = F.normalize(direction, dim=-1) + return (state * direction).sum(-1, keepdim=True) * direction + + +def match_norm(delta, reference): + norm = delta.norm(dim=-1, keepdim=True) + if bool(((norm < 1e-12) & (reference.norm(dim=-1, keepdim=True) > 1e-6)).any()): + raise ValueError("Degenerate random control") + return delta * reference.norm(dim=-1, keepdim=True) / norm.clamp_min(1e-12) + + +def control_observation(changed, baseline): + """Record numerical control outcomes without silently dropping sensitive cases.""" + mask = np.any(changed != baseline, axis=1) + return { + "n_queries": len(baseline), + "generated_rows_changed": int(mask.sum()), + "answer_rows_changed": int((changed[:, 0] != baseline[:, 0]).sum()), + "changed_query_indices": np.flatnonzero(mask).tolist(), + "changed_fraction": float(mask.mean()), + "exact": bool(not mask.any()), + } + + +def _rank(seed, *values): + return hashlib.sha256(json.dumps([seed, *map(int, values)]).encode()).digest() + + +def select_pairs(atoms, first_families, seed, per_family, *, ood=None): + """Choose prefixes/donors and all shared continuations using graph truth only. + + Donors use the same r1 and first-fact family. Every pair has at least two + distinct shared r2 with different original/counterfactual tails. A pair is + selected before scoring; its exact same prefix intervention serves every r2. + """ + atoms = np.asarray(atoms, dtype=np.int64) + outgoing, relation = defaultdict(dict), defaultdict(list) + for index, (head, r, tail) in enumerate(atoms): + if int(r) in outgoing[int(head)]: + raise ValueError("Ambiguous atomic truth") + outgoing[int(head)][int(r)] = (int(tail), index) + relation[int(r)].append(index) + groups, queries, coverage = [], [], {} + for name, indices in first_families.items(): + allowed = set(map(int, indices)) + eligible = [] + for first in sorted(allowed): + head, r1, bridge = map(int, atoms[first]) + candidates = [] + for donor in relation[r1]: + dh, _, db = map(int, atoms[donor]) + if donor not in allowed or dh == head or db == bridge: + continue + common = sorted(set(outgoing[bridge]) & set(outgoing[db])) + common = [ + r + for r in common + if outgoing[bridge][r][0] != outgoing[db][r][0] + and not {outgoing[bridge][r][0], outgoing[db][r][0]} & {head, dh, bridge, db} + ] + if len(common) >= 2: + candidates.append((donor, common)) + if candidates: + donor, common = min(candidates, key=lambda v: _rank(seed, first, v[0])) + eligible.append((first, donor, common)) + eligible.sort(key=lambda v: _rank(seed, v[0])) + coverage[name] = {"candidate_first_facts": len(allowed), "eligible": len(eligible)} + for first, donor, common in eligible[:per_family]: + head, r1, bridge = map(int, atoms[first]) + dh, _, db = map(int, atoms[donor]) + group = len(groups) + groups.append([head, r1, bridge, dh, db, first, donor]) + for r2 in common: + tail, second = outgoing[bridge][r2] + ct, cf_second = outgoing[db][r2] + kind = ( + name + if ood is None + else ("ood" if ood[first] else "id") + ("_ood" if ood[second] else "_id") + ) + queries.append((group, r2, tail, ct, second, cf_second, kind)) + coverage[name]["selected"] = min(len(eligible), per_family) + if not groups: + raise ValueError("No graph-eligible cross-relation pairs; do not reroll") + return { + "groups": np.asarray(groups, dtype=np.int64), + "queries": np.asarray([r[:6] for r in queries], dtype=np.int64), + "strata": np.asarray([r[6] for r in queries]), + "counterfactual_strata": np.asarray( + [ + r[6] + if ood is None + else ("ood" if ood[groups[r[0]][6]] else "id") + ("_ood" if ood[r[5]] else "_id") + for r in queries + ] + ), + "coverage": coverage, + } + + +def prefixes(facts, large, metadata): + facts = np.asarray(facts) + if large: + return np.column_stack( + (facts[:, 0] + metadata["entity_offset"], facts[:, 1] + metadata["relation_offset"]) + ) + return np.column_stack( + (np.full(len(facts), 2), facts[:, 0], np.full(len(facts), 3), facts[:, 1]) + ) + + +def prompts(rows, large, metadata): + if large: + from .grokking_reproduction import encode_rows + + return encode_rows(rows, metadata)[0][:, : rows.shape[1] - 1] + from .text_pretrain import atomic_sentence, composite_sentence + + render = atomic_sentence if rows.shape[1] == 3 else composite_sentence + length = 5 if rows.shape[1] == 3 else 7 + return np.asarray([render(row)[:length] for row in rows]) + + +def query_training_masks(world, payload, groups, queries, large): + """Count composition exposure without using scores or answer correctness.""" + if large: + support = round(payload["spec"]["phi"] * (~world["ood"]).sum()) + trained = world["chains"][world["train_order"][:support]][:, :3] + else: + trained = world["train_composite"][:, [0, 1, 3]] + trained = set(map(tuple, trained)) + recipient = np.asarray([(groups[g, 0], groups[g, 1], r2) in trained for g, r2, *_ in queries]) + donor = np.asarray([(groups[g, 3], groups[g, 1], r2) in trained for g, r2, *_ in queries]) + return { + "recipient_query_trained": recipient, + "counterfactual_query_trained": donor, + "both_queries_untrained": ~recipient & ~donor, + } + + +def load_task(spec, device): + payload = torch.load(spec["checkpoint"], map_location="cpu", weights_only=False) + if "checkpoint_step" in spec: + saved_step = payload.get("step", payload["spec"].get("steps")) + assert saved_step == spec["checkpoint_step"], "Wrong checkpoint training step" + if spec["family"] == "reproduction": + from .grokking_reproduction import construct + + data = Path(spec["data"]) + metadata = json.loads((data / "complete.json").read_text()) + model = construct(payload["spec"], metadata, device) + world = dict(np.load(data / "world.npz")) + panels = dict(np.load(data / "panels.npz")) + atoms = world["atoms"].astype(np.int64) + families = {"id": np.flatnonzero(~world["ood"]), "ood": np.flatnonzero(world["ood"])} + ood = world["ood"] + entities = np.arange( + metadata["entity_offset"], metadata["entity_offset"] + metadata["entities"] + ) + else: + from .representation_alignment import new_model + + model = new_model(payload["spec"], device) + world = dict(np.load(Path(spec["checkpoint"]).parent / "world.npz")) + metadata = {"entity_offset": 0} + atoms = np.concatenate((world["common_atomic"], world["anchor_atomic"])) + families = {} + for name in ("familiar_test", "strict_test"): + firsts = set(map(tuple, world[name][:, :3])) + families[name] = np.asarray([i for i, a in enumerate(atoms) if tuple(a) in firsts]) + ood = None + entities = np.arange(21, model.config.vocab_size) + panels = {k: world[k] for k in ("familiar_test", "strict_test")} + model.load_state_dict(payload["model"]) + model.eval().requires_grad_(False) + return ModelView(model), payload, metadata, world, atoms, families, ood, entities, panels + + +@torch.no_grad() +def trace_in_batches(view, tokens, sender, batch_size, amp): + collected = [] + for start in range(0, len(tokens), batch_size): + batch = torch.as_tensor(tokens[start : start + batch_size], device=view.device) + with torch.autocast("cuda", dtype=torch.bfloat16, enabled=amp): + _, trace = view.hidden(batch, sender=sender, capture=True) + collected.append(tuple(a.float() for a in trace)) + return tuple(torch.cat([a[j] for a in collected], dim=1) for j in range(3)) + + +@torch.no_grad() +def generate( + view, + tokens, + targets, + counterfactual, + metadata, + batch_size, + *, + layer=None, + sender=None, + delta=None, +): + """Greedy generation with feedback; scoring retains both target probabilities.""" + offset = metadata["entity_offset"] + targets, counterfactual = targets + offset, counterfactual + offset + generated, original_logp, cf_logp, top_ids, top_scores = [], [], [], [], [] + for start in range(0, len(tokens), batch_size): + x = torch.as_tensor(tokens[start : start + batch_size], device=view.device) + patch = ( + {} + if layer is None + else {"layer": layer, "sender": sender, "delta": delta[start : start + batch_size]} + ) + draws = [] + for index in range(2 if view.large else 3): + with torch.autocast("cuda", dtype=torch.bfloat16, enabled=view.large): + logits = view.logits(x, **patch).float() + if index == 0: + logs = logits.log_softmax(-1) + arange = torch.arange(len(x), device=view.device) + original_logp.append( + logs[ + arange, + torch.as_tensor(targets[start : start + batch_size], device=view.device), + ] + .cpu() + .numpy() + ) + cf_logp.append( + logs[ + arange, + torch.as_tensor( + counterfactual[start : start + batch_size], device=view.device + ), + ] + .cpu() + .numpy() + ) + scores, ids = logs.topk(min(10, logs.shape[-1]), dim=-1) + top_ids.append(ids.cpu().numpy()) + top_scores.append(scores.cpu().numpy()) + answer = logits.argmax(-1) + draws.append(answer.cpu().numpy()) + x = torch.cat((x, answer[:, None]), dim=1) + generated.append(np.stack(draws, axis=1)) + return { + "generated": np.concatenate(generated), + "original_logp": np.concatenate(original_logp), + "cf_logp": np.concatenate(cf_logp), + "top_ids": np.concatenate(top_ids), + "top_logp": np.concatenate(top_scores), + } + + +def summarize(result, targets, counterfactual, metadata, strata, groups=None): + generated = result["generated"] + original = generated[:, 0] == targets + metadata["entity_offset"] + cf = generated[:, 0] == counterfactual + metadata["entity_offset"] + format_ok = ( + generated[:, 1] == metadata["end_marker"] + if "end_marker" in metadata + else (generated[:, 1] == 5) & (generated[:, 2] == 1) + ) + output = {} + for name in ("all", *sorted(set(strata))): + mask = np.ones(len(strata), dtype=bool) if name == "all" else strata == name + row = { + "n_queries": int(mask.sum()), + "answer_accuracy": float(original[mask].mean()), + "accuracy": float((original & format_ok)[mask].mean()), + "cf_answer_accuracy": float(cf[mask].mean()), + "cf_accuracy": float((cf & format_ok)[mask].mean()), + "format_accuracy": float(format_ok[mask].mean()), + "answer_nll": float(-result["original_logp"][mask].mean()), + "cf_nll": float(-result["cf_logp"][mask].mean()), + } + if groups is not None: + unique = np.unique(groups[mask]) + row["n_first_facts"] = len(unique) + row["all_relations_cf_accuracy"] = float( + np.mean([cf[mask & (groups == g)].all() for g in unique]) + ) + row["mean_first_fact_cf_accuracy"] = float( + np.mean([cf[mask & (groups == g)].mean() for g in unique]) + ) + output[name] = row + return output + + +def run(spec, settings, out, gpu): + """Run one checkpoint with all execution layers, including failed interventions.""" + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "run.json").exists(): + raise FileExistsError(f"Do not overwrite an attempt: {out}") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.cuda.set_device(gpu) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + device = torch.device(f"cuda:{gpu}") + began = time.perf_counter() + view, payload, metadata, world, atoms, families, ood, entities, panels = load_task(spec, device) + digest_before = model_digest(view.model) + write_json( + out / "run.json", + { + "spec": { + **spec, + "settings": settings, + "checkpoint_step": payload.get("step", payload["spec"].get("steps")), + }, + "checkpoint_sha256": file_hash(spec["checkpoint"]), + "initial_model_sha256": digest_before, + "world_sha256": file_hash(Path(spec["data"]) / "world.npz") + if view.large + else file_hash(Path(spec["checkpoint"]).parent / "world.npz"), + "job_type": "causal-intervention", + "pid": os.getpid(), + "gpu": gpu, + "gpu_name": torch.cuda.get_device_name(gpu), + "dtype": "BF16 native / FP32 Jacobian" if view.large else "FP32", + "parameters": sum(p.numel() for p in view.model.parameters()), + "vocab_size": len(view.embedding.weight), + "tags": ["bridge-workspace", spec["phase"], "no-training"], + "created_utc": utc(), + }, + ) + history, cursor = [], 0 + + def log(stage, metrics): + nonlocal cursor + history.append( + { + "step": cursor, + "metrics": metrics, + "wall_seconds": time.perf_counter() - began, + "checkpoint_training_step": payload.get("step", payload["spec"].get("steps", 0)), + } + ) + write_json(out / "learning.json", history) + write_json(out / "status.json", {"state": "running", "stage": stage, "step": cursor}) + print( + json.dumps( + { + "run": spec["name"], + "stage": stage, + "index": cursor, + "wall_seconds": history[-1]["wall_seconds"], + } + ), + flush=True, + ) + cursor += 1 + + log("loaded", {}) + pairs = select_pairs( + atoms, families, settings["selection_seed"], settings["prefixes_per_family"], ood=ood + ) + groups, q = pairs["groups"], pairs["queries"] + used_first = set(groups[:, 5]) | set(groups[:, 6]) + calibration = np.asarray([i for i in range(len(atoms)) if i not in used_first]) + calibration = sorted(calibration, key=lambda i: _rank(settings["calibration_seed"], i))[ + : settings["calibration_prompts"] + ] + sender = 1 if view.large else 3 + cp = prefixes(atoms[calibration], view.large, metadata) + tensors = torch.as_tensor(cp, device=device) + jacobians = average_prefix_jacobian(view, tensors, sender, chunk=settings["jacobian_chunk"]) + torch.save( + {"jacobians": jacobians.cpu(), "calibration_atomic_indices": calibration, "prefixes": cp}, + out / "lens.pt", + ) + log("jacobian_lens", {"calibration_prompts": len(cp), "executed_layers": len(view.blocks)}) + trace = trace_in_batches( + view, + prefixes(groups[:, :3], view.large, metadata), + sender, + settings["batch_size"], + view.large, + ) + donor_facts = np.column_stack((groups[:, 3], groups[:, 1], groups[:, 4])) + donor_states = trace_in_batches( + view, + prefixes(donor_facts, view.large, metadata), + sender, + settings["batch_size"], + view.large, + )[0] + rows = ( + np.column_stack((groups[q[:, 0], 0], groups[q[:, 0], 1], q[:, 1], q[:, 2])) + if view.large + else np.column_stack( + (groups[q[:, 0], 0], groups[q[:, 0], 1], groups[q[:, 0], 2], q[:, 1], q[:, 2]) + ) + ) + tokens = prompts(rows, view.large, metadata) + training_masks = query_training_masks(world, payload, groups, q, view.large) + # Fix a native panel per stratum without consulting any predictions. + native_rows, native_strata = [], [] + for name in ( + ("test_ii", "test_io", "test_oi", "test_oo") + if view.large + else ("familiar_test", "strict_test") + ): + selected = panels[name][: settings["native_per_stratum"]] + native_rows.append(selected) + native_strata.extend([name] * len(selected)) + native_rows, native_strata = np.concatenate(native_rows), np.asarray(native_strata) + lookup = {(int(h), int(r)): (int(t), i) for i, (h, r, t) in enumerate(atoms)} + native_facts = np.asarray([(h, r, lookup[int(h), int(r)][0]) for h, r in native_rows[:, :2]]) + unique_bridges, bridge_counts = np.unique(native_facts[:, 2], return_counts=True) + fixed_entity = int(unique_bridges[bridge_counts.argmax()]) + fixed_target = native_facts[:, 2] == fixed_entity + ntokens = prompts(native_rows, view.large, metadata) + ntrace = trace_in_batches( + view, + prefixes(native_facts, view.large, metadata), + sender, + settings["batch_size"], + view.large, + ) + all_needed = set(groups[:, 5]) | set(groups[:, 6]) | set(q[:, 4]) | set(q[:, 5]) + for row, fact in zip(native_rows, native_facts, strict=True): + r2 = row[2] if view.large else row[3] + all_needed.add(lookup[int(fact[0]), int(fact[1])][1]) + all_needed.add(lookup[int(fact[2]), int(r2)][1]) + needed_ids = np.asarray(sorted(all_needed)) + needed = atoms[needed_ids] + atrace = trace_in_batches( + view, prefixes(needed, view.large, metadata), sender, settings["batch_size"], view.large + ) + torch.save( + { + "recipient": tuple(a.cpu() for a in trace), + "donor_states": donor_states.cpu(), + "native": tuple(a.cpu() for a in ntrace), + "atomic": tuple(a.cpu() for a in atrace), + }, + out / "prefix-traces.pt", + ) + atomic = generate( + view, + prompts(needed, view.large, metadata), + needed[:, -1], + needed[:, -1], + metadata, + settings["batch_size"], + ) + atomic_ok = atomic["generated"][:, 0] == needed[:, -1] + metadata["entity_offset"] + atomic_correct = dict(zip(needed_ids, atomic_ok, strict=True)) + prereq = np.asarray( + [ + all(atomic_correct[int(i)] for i in (groups[g, 5], groups[g, 6], second, cf_second)) + for g, _, _, _, second, cf_second in q + ] + ) + np.savez_compressed( + out / "selection.npz", + **{k: v for k, v in pairs.items() if k != "coverage"}, + rows=rows, + native_rows=native_rows, + native_strata=native_strata, + fixed_entity=np.asarray(fixed_entity), + fixed_entity_target=fixed_target, + **training_masks, + prerequisite_correct=prereq, + needed_atomic_indices=needed_ids, + **{"atomic_" + k: v for k, v in atomic.items()}, + ) + write_json(out / "coverage.json", pairs["coverage"]) + # Independent native implementation equivalence and prefix-causality audit. + audit_tokens = torch.as_tensor(tokens[: min(8, len(tokens))], device=device) + with torch.no_grad(), torch.autocast("cuda", dtype=torch.bfloat16, enabled=view.large): + native = view.model( + audit_tokens, + positions=torch.full((len(audit_tokens), 1), audit_tokens.shape[1] - 1, device=device), + )[:, 0].float() + traced = view.logits(audit_tokens).float() + _, full_trace = view.hidden(audit_tokens, sender=sender, capture=True) + causal_error = float( + (full_trace[0].float() - trace[0][:, q[: len(audit_tokens), 0]]).abs().max() + ) + torch.testing.assert_close( + full_trace[0].float(), + trace[0][:, q[: len(audit_tokens), 0]], + atol=0.05 if view.large else 2e-5, + rtol=0.005 if view.large else 2e-5, + ) + torch.testing.assert_close( + native, traced, atol=0.05 if view.large else 1e-5, rtol=0.005 if view.large else 1e-5 + ) + if not torch.equal(native.argmax(-1), traced.argmax(-1)): + raise AssertionError("Native/traced greedy answers differ") + summary = {} + + def measure( + family, + condition, + layer, + input_tokens, + target, + cf_target, + strata, + delta=None, + query_groups=None, + ): + result = generate( + view, + input_tokens, + target, + cf_target, + metadata, + settings["batch_size"], + layer=layer if delta is not None else None, + sender=sender, + delta=delta, + ) + np.savez_compressed(out / f"{family}-{condition}-l{layer:02d}.npz", **result) + metrics = summarize(result, target, cf_target, metadata, strata, query_groups) + if family == "swap" and prereq.any(): + metrics["prerequisites_correct"] = summarize( + {k: a[prereq] for k, a in result.items()}, + target[prereq], + cf_target[prereq], + metadata, + strata[prereq], + query_groups[prereq], + )["all"] + if family == "swap" and training_masks["both_queries_untrained"].any(): + mask = training_masks["both_queries_untrained"] + metrics["both_queries_untrained"] = summarize( + {k: a[mask] for k, a in result.items()}, + target[mask], + cf_target[mask], + metadata, + strata[mask], + query_groups[mask], + )["all"] + if family == "native" and (condition.startswith("fixed_entity") or condition == "baseline"): + for label, mask in ( + ("fixed_entity_target", fixed_target), + ("fixed_entity_unrelated", ~fixed_target), + ): + if mask.any(): + metrics[label] = summarize( + {k: a[mask] for k, a in result.items()}, + target[mask], + cf_target[mask], + metadata, + strata[mask], + )["all"] + summary[f"{family}/{condition}/{layer}"] = metrics + write_json(out / "summary.json", summary) + log(f"{family}-{condition}-l{layer}", {family: {condition: {f"layer_{layer}": metrics}}}) + + measure("swap", "baseline", -1, tokens, q[:, 2], q[:, 3], pairs["strata"], query_groups=q[:, 0]) + measure( + "native", "baseline", -1, ntokens, native_rows[:, -1], native_rows[:, -1], native_strata + ) + measure( + "atomic", + "baseline", + -1, + prompts(needed, view.large, metadata), + needed[:, -1], + needed[:, -1], + np.full(len(needed), "needed_atoms"), + ) + states, attentions, mlps = trace + rng = torch.Generator(device=device).manual_seed(settings["rotation_seed"]) + rotation, _ = torch.linalg.qr(torch.randn(view.width, view.width, device=device, generator=rng)) + swap_errors, restore_errors = [], [] + diagnostics = [] + axis_families = settings.get("axis_families", ["prefix_jacobian"]) + if not set(axis_families) <= {"prefix_jacobian", "input_embedding"}: + raise ValueError("Unknown direction family") + for layer, jacobian, axis_family in ( + (layer, j, family) for layer, j in enumerate(jacobians) for family in axis_families + ): + suffix = "_embedding" if axis_family == "input_embedding" else "" + directions = F.normalize( + view.embedding.weight[torch.as_tensor(entities, device=device)].float() + @ (torch.eye(view.width, device=device) if suffix else jacobian), + dim=-1, + ) + index = {int(e): i for i, e in enumerate(entities)} + source = directions[[index[int(b + metadata["entity_offset"])] for b in groups[:, 2]]] + dest = directions[[index[int(b + metadata["entity_offset"])] for b in groups[:, 4]]] + basis = torch.stack((source, dest), dim=-1) + swapped = swap_coordinates(states[layer], basis) + restored = swap_coordinates(swapped, basis) + swap_errors.append(float((restored - states[layer]).abs().max())) + random_basis = rotation[None] @ basis + swap_delta = swapped - states[layer] + torch.save( + { + "basis": basis.cpu(), + "rotation": rotation.cpu(), + "swap_delta": swap_delta.cpu(), + "axis_family": axis_family, + }, + out / f"patch-{axis_family}-l{layer:02d}.pt", + ) + deltas = { + "swap": swap_delta, + "swap_x2": 2 * swap_delta, + "random_swap": match_norm( + swap_coordinates(states[layer], random_basis) - states[layer], swap_delta + ), + "full_prefix": donor_states[layer] - states[layer], + "swap_back": restored - states[layer], + } + for condition in SWAPS: + measure( + "swap", + condition + suffix, + layer, + tokens, + q[:, 2], + q[:, 3], + pairs["strata"], + deltas[condition][q[:, 0]], + q[:, 0], + ) + native_direction = directions[ + [index[int(b + metadata["entity_offset"])] for b in native_facts[:, 2]] + ] + native_state, native_attention, native_mlp = (a[layer] for a in ntrace) + fixed_direction = directions[index[fixed_entity + metadata["entity_offset"]]][ + None + ].expand_as(native_direction) + fixed_mlp = projection(native_mlp, fixed_direction) + removed_mlp = projection(native_mlp, native_direction) + # All sublayers still execute. Only the selected sender's semantic component + # is subtracted from the actual local update at the boundary. + local_restore = native_state - removed_mlp + removed_mlp + restore_errors.append(float((local_restore - native_state).abs().max())) + erasures = { + "erase_state": -projection(native_state, native_direction), + "erase_mlp": -removed_mlp, + "erase_attention": -projection(native_attention, native_direction), + "random_state": match_norm( + -projection(native_state, native_direction @ rotation.T), + -projection(native_state, native_direction), + ), + "random_mlp": match_norm( + -projection(native_mlp, native_direction @ rotation.T), -removed_mlp + ), + "random_attention": match_norm( + -projection(native_attention, native_direction @ rotation.T), + -projection(native_attention, native_direction), + ), + "restore_mlp": local_restore - native_state, + "fixed_entity_mlp": -fixed_mlp, + "fixed_entity_random_mlp": match_norm( + -projection(native_mlp, fixed_direction @ rotation.T), + -fixed_mlp, + ), + } + for condition in ERASURES: + measure( + "native", + condition + suffix, + layer, + ntokens, + native_rows[:, -1], + native_rows[:, -1], + native_strata, + erasures[condition], + ) + # Relevant single-hop facts are scored under exactly the same local deletion. + adirection = directions[[index[int(b + metadata["entity_offset"])] for b in needed[:, 2]]] + atomic_delta = -projection(atrace[2][layer], adirection) + measure( + "atomic", + "erase_mlp" + suffix, + layer, + prompts(needed, view.large, metadata), + needed[:, -1], + needed[:, -1], + np.full(len(needed), "needed_atoms"), + atomic_delta, + ) + with torch.no_grad(): + raw = F.linear(view.norm(states[layer]), view.embedding.weight).argmax(-1) + lens = F.linear(view.norm(states[layer] @ jacobian.T), view.embedding.weight).argmax(-1) + diagnostics.append( + { + "layer": layer, + "axis_family": axis_family, + "native_bridge_readout_accuracy": float( + ( + raw + == torch.as_tensor(groups[:, 2] + metadata["entity_offset"], device=device) + ) + .float() + .mean() + ), + "prefix_jacobian_bridge_readout_accuracy": float( + ( + lens + == torch.as_tensor(groups[:, 2] + metadata["entity_offset"], device=device) + ) + .float() + .mean() + ), + "swap_norm_mean": float(swap_delta.norm(dim=-1).mean()), + "native_mlp_removed_norm_mean": float(removed_mlp.norm(dim=-1).mean()), + } + ) + digest_after = model_digest(view.model) + if digest_before != digest_after or any(p.grad is not None for p in view.model.parameters()): + raise AssertionError("Intervention changed model parameters or accumulated gradients") + write_json( + out / "implementation-audit.json", + { + "parameters_unchanged": True, + "native_tracer_max_logit_error": float((native - traced).abs().max()), + "prefix_causal_state_max_error": causal_error, + "swap_inverse_max_errors": swap_errors, + "mlp_restore_max_errors": restore_errors, + "n_needed_atomic_facts": len(needed), + "needed_atomic_answer_accuracy": float(atomic_ok.mean()), + "swap_prerequisite_query_coverage": float(prereq.mean()), + "scoring": ( + "greedy feedback, original/counterfactual answer plus termination; " + "query and first-fact denominators separate" + ), + }, + ) + write_json(out / "diagnostics.json", diagnostics) + log("complete", {"complete": {"evaluations": len(summary)}}) + write_json( + out / "interventions-complete.json", + { + "finished_utc": utc(), + "evaluations": len(summary), + "model_sha256": digest_after, + "wall_seconds": time.perf_counter() - began, + "peak_gpu_memory_bytes": torch.cuda.max_memory_allocated(device), + "new_training_updates": 0, + }, + ) + write_json(out / "status.json", {"state": "awaiting_reload_audit", "step": cursor - 1}) + + +def audit_run(out, gpu): + """Reload in an independent process and reproduce fixed raw prediction subsets.""" + out = Path(out) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.cuda.set_device(gpu) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + metadata_run = json.loads((out / "run.json").read_text()) + spec = metadata_run["spec"] + settings = spec["settings"] + view, _, metadata, _, atoms, _, _, entities, _ = load_task(spec, f"cuda:{gpu}") + assert model_digest(view.model) == metadata_run["initial_model_sha256"] + assert os.getpid() != metadata_run["pid"], "Reload must use a separate process" + selection = dict(np.load(out / "selection.npz")) + groups, queries = selection["groups"], selection["queries"] + jacobians = torch.load(out / "lens.pt", map_location=view.device, weights_only=False)[ + "jacobians" + ] + sender = 1 if view.large else 3 + trace = trace_in_batches( + view, + prefixes(groups[:, :3], view.large, metadata), + sender, + settings["batch_size"], + view.large, + ) + states = trace[0] + native_rows = selection["native_rows"] + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + facts = np.asarray([(h, r, lookup[int(h), int(r)]) for h, r in native_rows[:, :2]]) + ntrace = trace_in_batches( + view, prefixes(facts, view.large, metadata), sender, settings["batch_size"], view.large + ) + swap_indices = np.unique(np.linspace(0, len(queries) - 1, min(32, len(queries)), dtype=int)) + native_indices = np.unique( + np.linspace(0, len(native_rows) - 1, min(32, len(native_rows)), dtype=int) + ) + summary = json.loads((out / "summary.json").read_text()) + comparisons, max_logp_error, identity_controls = [], 0.0, [] + + def check(family, condition, layer, indices, rows, target, cf, delta=None): + nonlocal max_logp_error + + # Baseline is independently executed through the model's own forward. + class NativeView(ModelView): + def logits(self, tokens, **_): + positions = torch.full((len(tokens), 1), tokens.shape[1] - 1, device=self.device) + return self.model(tokens, positions=positions)[:, 0] + + actual = generate( + NativeView(view.model) if condition == "baseline" else view, + prompts(rows, view.large, metadata), + target, + cf, + metadata, + settings["batch_size"], + layer=layer if delta is not None else None, + sender=sender, + delta=delta, + ) + # Preserve original batch shapes: compacting selected rows changes BF16 + # GEMM rounding. Select the audit subset only after the full generation. + actual = {key: value[indices] for key, value in actual.items()} + expected = dict(np.load(out / f"{family}-{condition}-l{layer:02d}.npz")) + if not np.array_equal(actual["generated"], expected["generated"][indices]): + raise AssertionError(f"Reload generation mismatch: {family}/{condition}/{layer}") + for key in ("original_logp", "cf_logp"): + error = float(np.max(np.abs(actual[key] - expected[key][indices]))) + max_logp_error = max(max_logp_error, error) + np.testing.assert_allclose( + actual[key], + expected[key][indices], + atol=0.04 if view.large else 3e-5, + rtol=0.002 if view.large else 2e-5, + ) + comparisons.append( + {"family": family, "condition": condition, "layer": layer, "queries": len(indices)} + ) + + check("swap", "baseline", -1, swap_indices, selection["rows"], queries[:, 2], queries[:, 3]) + check( + "native", + "baseline", + -1, + native_indices, + native_rows, + native_rows[:, -1], + native_rows[:, -1], + ) + entity_index = {int(e): i for i, e in enumerate(entities)} + for layer, jacobian in enumerate(jacobians): + for axis_family in settings.get("axis_families", ["prefix_jacobian"]): + suffix = "_embedding" if axis_family == "input_embedding" else "" + directions = F.normalize( + view.embedding.weight[torch.as_tensor(entities, device=view.device)].float() + @ (torch.eye(view.width, device=view.device) if suffix else jacobian), + dim=-1, + ) + source = directions[ + [entity_index[int(b + metadata["entity_offset"])] for b in groups[:, 2]] + ] + dest = directions[ + [entity_index[int(b + metadata["entity_offset"])] for b in groups[:, 4]] + ] + delta = ( + swap_coordinates(states[layer], torch.stack((source, dest), dim=-1)) - states[layer] + ) + check( + "swap", + "swap" + suffix, + layer, + swap_indices, + selection["rows"], + queries[:, 2], + queries[:, 3], + delta[queries[:, 0]], + ) + native_direction = directions[ + [entity_index[int(b + metadata["entity_offset"])] for b in facts[:, 2]] + ] + native_delta = -projection(ntrace[2][layer], native_direction) + check( + "native", + "erase_mlp" + suffix, + layer, + native_indices, + native_rows, + native_rows[:, -1], + native_rows[:, -1], + native_delta, + ) + # Structural and numerical controls must retain native generation. + for family, condition in ( + ("swap", "swap_back" + suffix), + ("native", "restore_mlp" + suffix), + ): + raw = np.load(out / f"{family}-{condition}-l{layer:02d}.npz")["generated"] + baseline = np.load(out / f"{family}-baseline-l-1.npz")["generated"] + identity_controls.append( + { + "family": family, + "condition": condition, + "layer": layer, + **control_observation(raw, baseline), + } + ) + if layer == len(view.blocks) - 1: + for key in summary: + family, condition, occurrence = key.split("/") + if int(occurrence) != layer or family == "atomic": + continue + raw = np.load(out / f"{family}-{condition}-l{layer:02d}.npz")["generated"] + baseline = np.load(out / f"{family}-baseline-l-1.npz")["generated"] + assert np.array_equal(raw, baseline), ( + key, + "final sender must not affect later positions", + ) + assert model_digest(view.model) == metadata_run["initial_model_sha256"] + previous = out / "implementation-audit.json" + if not previous.exists() and (out / "audit.json").exists(): + previous.write_bytes((out / "audit.json").read_bytes()) + write_json( + out / "audit.json", + { + "independent_process": True, + "pid": os.getpid(), + "gpu": gpu, + "finished_utc": utc(), + "parameters_unchanged": True, + "generations_exact": True, + "identity_controls_exact": all(c["exact"] for c in identity_controls), + "identity_control_observations": identity_controls, + "scope": ( + "Fixed subset reload predictions exact; numerical inverse/restore " + "outcomes recorded separately" + ), + "max_log_probability_error": max_logp_error, + "evaluations": comparisons, + "implementation_audit_sha256": file_hash(previous), + "audit_source_sha256": file_hash(__file__), + }, + ) + if (out / "interventions-complete.json").exists(): + complete = json.loads((out / "interventions-complete.json").read_text()) + complete["independently_reloaded"] = True + complete["audit_finished_utc"] = utc() + write_json(out / "complete.json", complete) + write_json( + out / "status.json", + { + "state": "complete", + "independently_reloaded": True, + "step": json.loads((out / "learning.json").read_text())[-1]["step"], + }, + ) + print( + json.dumps( + { + "run": out.name, + "independent_reload": "passed", + "evaluations": len(comparisons), + "max_log_probability_error": max_logp_error, + } + ), + flush=True, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/cli.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/cli.py new file mode 100644 index 0000000000000000000000000000000000000000..1aec4627fdf91a196893b3a6d47c8188da55d55b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/cli.py @@ -0,0 +1,32 @@ +"""Command-line interface for the deterministic matrix illustration.""" + +import argparse +import json +from pathlib import Path + +from .experiments import run_minimal_example + + +def main(argv: list[str] | None = None) -> int: + """Print the analytical report as JSON and optionally save a copy.""" + parser = argparse.ArgumentParser(description="Run the analytical low-rank editability example.") + parser.add_argument( + "--rank", type=int, default=1, help="total rank budget: 0, 1 (default), or 2" + ) + parser.add_argument( + "--atol", type=float, default=1e-10, help="positive absolute singular-value tolerance" + ) + parser.add_argument( + "--output", type=Path, help="also save JSON to this path (creates parent directories)" + ) + args = parser.parse_args(argv) + try: + report = run_minimal_example(rank=args.rank, atol=args.atol) + serialized = json.dumps(report, ensure_ascii=False, indent=2, allow_nan=False) + if args.output is not None: + args.output.parent.mkdir(parents=True, exist_ok=True) + args.output.write_text(serialized + "\n", encoding="utf-8") + except (ValueError, OSError) as exc: + parser.error(str(exc)) + print(serialized) + return 0 diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step.py new file mode 100644 index 0000000000000000000000000000000000000000..8f828c9ccea5c225dd4fc257587afe3c0ff7c6bf --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step.py @@ -0,0 +1,669 @@ +"""Ordinary end-to-end GPT depth and optimization-time development experiment. + +The frozen random graph is shared across two-, three- and four-hop training. +Only terminal entities enter composition text; intermediate truth is used for +evaluation and audit. Existing experimental implementations remain unchanged. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import time +from dataclasses import replace +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_data import build_world as single_length_world +from .grok_loop_model import LoopGPT, flops +from .latent_scaling import model_digest +from .storage_composition import FullTokenStep, file_hash +from .storage_frontier import learning_rate + +BOS, EOS, PAD, ENTITY_OFFSET = 2, 1, 0, 3 +HOPS = (2, 3, 4) +TRAIN_SPLITS = ("atomic", "train_2", "train_3", "train_4") +EVALUATION_SPLITS = ("atomic",) + tuple( + f"{split}_{hop}" for hop in HOPS for split in ("train", "familiar", "strict") +) +DATA_DEFAULTS = { + "entities": 64, + "relations": 4, + "degree": 4, + "phi": 4.0, + "id_fraction": 0.75, + "id_test_fraction": 0.2, + "evaluation_size": 512, +} +SOURCE_FILES = [ + "src/llm_memory_editability/bios_model.py", + "src/llm_memory_editability/grok_depth.py", + "src/llm_memory_editability/grok_depth_data.py", + "src/llm_memory_editability/grok_loop_data.py", + "src/llm_memory_editability/grok_multihop_data.py", + "src/llm_memory_editability/grok_loop_model.py", + "src/llm_memory_editability/latent_scaling.py", + "src/llm_memory_editability/storage_composition.py", + "src/llm_memory_editability/storage_frontier.py", + "src/llm_memory_editability/text_pretrain.py", + "src/llm_memory_editability/depth_step.py", + "scripts/run_depth_step.py", + "tests/test_depth_step.py", +] + + +def data_digest(world): + digest = hashlib.sha256() + for name in EVALUATION_SPLITS: + rows = world[name] + digest.update(name.encode()) + digest.update(np.asarray(rows.shape, dtype="= relation_offset)): + raise ValueError("Invalid entity token: " + name) + if np.any( + (rows[:, 1:-1] < relation_offset) | (rows[:, 1:-1] >= relation_offset + relations) + ): + raise ValueError("Invalid relation token: " + name) + if len(set(map(tuple, rows[:, :-1]))) != len(rows): + raise ValueError("Duplicate complete query: " + name) + _, edges = truth_path_details(world, rows) + if name.startswith(("train_", "familiar_")) and not id_mask[edges].all(): + raise ValueError("Non-ID fact in familiar training/test: " + name) + if name.startswith("strict_") and id_mask[edges].any(): + raise ValueError("ID fact in strict composition: " + name) + counts[name] = len(rows) + if len(world["atomic"]) != entities * meta["degree"]: + raise ValueError("Atomic graph degree does not match the contract") + for hop in HOPS: + query_sets = [ + set(map(tuple, world[f"{split}_{hop}"][:, :-1])) + for split in ("train", "familiar", "strict") + ] + if any(query_sets[i] & query_sets[j] for i in range(3) for j in range(i)): + raise ValueError("Complete query leakage between length-specific splits") + trained_edges = set() + for hop in HOPS: + trained_edges.update(truth_path_details(world, world[f"train_{hop}"])[1].ravel()) + for hop in HOPS: + strict_edges = set(truth_path_details(world, world[f"strict_{hop}"])[1].ravel()) + if strict_edges & trained_edges: + raise ValueError("Strict facts participated in another length's composition training") + digest = data_digest(world) + if "dataset_sha256" in meta and meta["dataset_sha256"] != digest: + raise ValueError("Frozen dataset digest differs from actual arrays") + return { + "passed": True, + "counts": counts, + "dataset_sha256": digest, + "truth_edges_independently_traversed": True, + "complete_query_overlap": 0, + "all_strict_facts_absent_from_composition_training": True, + "cross_length_subpath_holdout": False, + } + + +def build_world(spec): + seed = spec.get("world_seed", spec.get("world")) + if seed is None: + raise ValueError("A fixed world_seed is required") + settings = {key: spec.get(key, value) for key, value in DATA_DEFAULTS.items()} + world, shared_atoms, shared_ids = {}, None, None + source_metadata = {} + for hop in HOPS: + original = single_length_world({"world_seed": seed, "hops": hop, **settings}) + # The historical graph reserves only PAD/EOS and uses entity offset 2. + # Shift every entity/relation token once to reserve the explicit BOS=2. + atoms = original["atomic"] + 1 + id_set = set(map(tuple, original["id_atomic"])) + id_mask = np.asarray([tuple(row) in id_set for row in original["atomic"]], dtype=bool) + if shared_atoms is None: + shared_atoms, shared_ids = atoms.copy(), id_mask.copy() + elif not np.array_equal(shared_atoms, atoms) or not np.array_equal(shared_ids, id_mask): + raise ValueError("Path lengths do not share identical graph and ID mask") + world[f"train_{hop}"] = original["train_composite"] + 1 + world[f"familiar_{hop}"] = original["test_full_composite"] + 1 + world[f"strict_{hop}"] = original["ood_composite"] + 1 + source_metadata[str(hop)] = original["metadata"] + world["atomic"] = shared_atoms + world["metadata"] = { + "world_seed": int(seed), + **settings, + "id_mask": shared_ids.tolist(), + "source_worlds": source_metadata, + "same_atomic_and_id_mask_all_lengths": True, + "source_entity_offset": 2, + "entity_offset": ENTITY_OFFSET, + "source_token_shift": 1, + "separator_token": ENTITY_OFFSET + settings["entities"] + settings["relations"], + "vocab_size": ENTITY_OFFSET + settings["entities"] + settings["relations"] + 1, + "evaluation_pools": "Complete test_full_composite and ood_composite", + "composition_supervision": "Terminal entity only; no intermediate entity", + "training_objective": "All nonpadding next tokens including EOS", + "holdout": "Complete queries held out within each length; not subpaths across lengths", + } + report = audit_world(world) + world["metadata"]["dataset_sha256"] = report["dataset_sha256"] + world["metadata"]["independent_audit"] = report + expected = spec.get("frozen_data_sha256") + if expected is not None and expected != report["dataset_sha256"]: + raise ValueError("Rebuilt data differ from the frozen specification") + return world + + +def construct(spec, device): + if spec.get("context", 9) < 9: + raise ValueError("Context must support four-hop answer and EOS") + config = ModelConfig( + vocab_size=ENTITY_OFFSET + spec.get("entities", 64) + spec.get("relations", 4) + 1, + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=spec.get("context", 9), + ) + if config.layers > 6: + raise ValueError("Canonical paired initialization is limited to six unique blocks") + torch.manual_seed(spec["initialization"]) + canonical = LoopGPT( + replace(config, layers=6), + repeats=1, + dropout=spec.get("dropout", 0.0), + initialization="scaled_effective", + ) + model = LoopGPT( + config, + repeats=spec["repeats"], + dropout=spec.get("dropout", 0.0), + initialization="scaled_effective", + ) + initial = canonical.state_dict() + state = {} + factor = math.sqrt(6 / (config.layers * spec["repeats"])) + for key in model.state_dict(): + value = initial[key].clone() + if key.endswith(("attention.proj.weight", "mlp.down.weight")): + value.mul_(factor) + state[key] = value + model.load_state_dict(state) + return model.to(device) + + +def prompt_rows(rows, separator=71): + rows = np.asarray(rows, dtype=np.int64) + return np.c_[ + np.full(len(rows), BOS, dtype=np.int64), + rows[:, :-1], + np.full(len(rows), separator, dtype=np.int64), + ] + + +def pack_rows(rows, sequence=8, separator=71): + """All nonpadding next-token labels; compact rows contain no intermediate nodes.""" + rows = np.asarray(rows, dtype=np.int64) + sentence = np.c_[ + prompt_rows(rows, separator), rows[:, -1], np.full(len(rows), EOS, dtype=np.int64) + ] + length = sentence.shape[1] - 1 + if length > sequence: + raise ValueError("Packed sequence is too short") + tokens = np.zeros((len(rows), sequence), dtype=np.int64) + labels = np.full_like(tokens, -100) + tokens[:, :length], labels[:, :length] = sentence[:, :-1], sentence[:, 1:] + return tokens, labels + + +def run_name(spec): + seed = spec.get("world_seed", spec.get("world")) + return ( + f"w{seed}-i{spec['initialization']}-d{spec['width']}" + f"-l{spec['layers']}-r{spec['repeats']}-s{spec['steps']}" + ) + + +def _mean(values): + return float(np.asarray(values).mean()) if len(values) else None + + +@torch.no_grad() +def generate_rows(model, rows, device, separator=71, batch_size=512): + """Ordinary full forward, then free tail/EOS generation with answer feedback.""" + rows = np.asarray(rows, dtype=np.int64) + generated, nll = [], [] + for start in range(0, len(rows), batch_size): + batch = rows[start : start + batch_size] + tokens = torch.as_tensor(prompt_rows(batch, separator), device=device) + first = model(tokens)[:, -1] + target = torch.as_tensor(batch[:, -1], device=device) + nll.append(F.cross_entropy(first, target, reduction="none").cpu().numpy()) + answer = first.argmax(-1) + tokens = torch.cat([tokens, answer[:, None]], dim=1) + stop = model(tokens)[:, -1].argmax(-1) + generated.append(torch.stack([answer, stop], dim=1).cpu().numpy()) + pred = np.concatenate(generated) if generated else np.empty((0, 2), dtype=np.int64) + nll = np.concatenate(nll) if nll else np.empty(0, dtype=np.float32) + answer_correct = pred[:, 0] == rows[:, -1] + correct = answer_correct & (pred[:, 1] == EOS) + return { + "n": len(rows), + "accuracy": _mean(correct), + "answer_accuracy": _mean(answer_correct), + "answer_nll": _mean(nll), + }, {"generated": pred, "correct": correct, "answer_nll": nll} + + +@torch.no_grad() +def evaluate(model, world, device): + before = model.training + model.eval() + metrics, predictions = {}, {} + separator = world["metadata"]["separator_token"] + try: + atomic_metrics, atomic_pred = generate_rows(model, world["atomic"], device, separator) + metrics["atomic"] = atomic_metrics + predictions.update({"atomic_" + key: value for key, value in atomic_pred.items()}) + for name in EVALUATION_SPLITS[1:]: + rows = world[name] + task_metrics, direct = generate_rows(model, rows, device, separator) + nodes, edges = truth_path_details(world, rows) + coverage = atomic_pred["correct"][edges].all(axis=1) + current = rows[:, 0].copy() + hops = rows.shape[1] - 2 + calls = np.empty((len(rows), hops, 2), dtype=np.int64) + for hop in range(hops): + query = np.c_[current, rows[:, hop + 1], nodes[:, hop + 1]] + _, result = generate_rows(model, query, device, separator) + calls[:, hop] = result["generated"] + current = result["generated"][:, 0] + formats = (calls[:, :, 1] == EOS).all(axis=1) + autonomous_correct = formats & (current == rows[:, -1]) + path_correct = formats & (calls[:, :, 0] == nodes[:, 1:]).all(axis=1) + task_metrics.update( + { + "atomic_correct_coverage": _mean(coverage), + "conditional_accuracy": _mean(direct["correct"][coverage]), + "autonomous_two_calls": _mean(autonomous_correct), + "autonomous_path_accuracy": _mean(path_correct), + "hop_count": hops, + } + ) + metrics[name] = task_metrics + direct.update( + { + "coverage": coverage, + "autonomous_generated": calls, + "autonomous_correct": autonomous_correct, + "autonomous_path_correct": path_correct, + } + ) + predictions.update({name + "_" + key: value for key, value in direct.items()}) + finally: + model.train(before) + return metrics, predictions + + +def _validate_spec(spec): + nodes = spec["nodes"] + if nodes != sorted(set(nodes)) or nodes[0] != 0 or nodes[-1] != spec["steps"]: + raise ValueError("Nodes must increase from initialization to the fixed endpoint") + if not set(spec["checkpoint_nodes"]) <= set(nodes) or not {0, spec["steps"]} <= set( + spec["checkpoint_nodes"] + ): + raise ValueError("Checkpoint nodes must include initialization and endpoint") + if spec["batch_size"] != 128 or spec.get("dropout", 0.0) != 0.0: + raise ValueError("The fixed design requires four 32-example streams and dropout zero") + if spec.get("model_initialization", "scaled_effective") != "scaled_effective": + raise ValueError("The batch uses scaled_effective residual initialization") + + +def _save_world(out, world): + np.savez_compressed(out / "world.npz", **{key: world[key] for key in EVALUATION_SPLITS}) + write_json(out / "world-metadata.json", world["metadata"]) + + +def _check_source(source): + if not source or any(file_hash(path) != digest for path, digest in source.items()): + raise RuntimeError("Actual source differs from the required frozen source hashes") + + +def _validate_output(out): + """Permit scheduler control files while preserving every existing experiment artifact.""" + out = Path(out) + if out.exists(): + for path in out.iterdir(): + allowed = path.is_file() and ( + path.name == "input-spec.json" or path.name.endswith("-process.log") + ) + if not allowed: + raise FileExistsError( + "Do not overwrite an existing experiment artifact: " + str(path) + ) + + +def train(spec, out, source, device="cuda:0"): + _validate_spec(spec) + _check_source(source) + if "frozen_data_sha256" not in spec: + raise ValueError("Training requires frozen_data_sha256") + out = Path(out) + _validate_output(out) + out.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.cuda.set_device(torch.device(device)) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + started_process = time.perf_counter() + world = build_world(spec) + digest = data_digest(world) + _save_world(out, world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_digest = model_digest(model) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + strata = [world[name] for name in TRAIN_SPLITS] + sizes = [len(rows) for rows in strata] + if any(size == 0 for size in sizes): + raise ValueError("Do not reroll a world with an empty sampled training stratum") + packed = [pack_rows(rows, separator=world["metadata"]["separator_token"]) for rows in strata] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) for parts in zip(*packed, strict=True) + ) + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + graph = FullTokenStep(model, optimizer, table, spec["batch_size"], clip=spec.get("clip", 1.0)) + flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 8, output_positions=8) + token_step = 32 * sum(int((labels[0] >= 0).sum()) for _, labels in packed) + history, step, training_seconds = [], 0, 0.0 + + def measure(loss=None): + metrics, predictions = evaluate(model, world, device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0.0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + "supervised_tokens": step * token_step, + "padded_input_tokens": step * spec["batch_size"] * 8, + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + np.savez_compressed( + out / f"exposures-{step:06d}.npz", + **{name: count for name, count in zip(TRAIN_SPLITS, counts, strict=True)}, + ) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["checkpoint_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"model-{step:06d}.pt", + ) + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["atomic"]["accuracy"], + "familiar": {str(hop): metrics[f"familiar_{hop}"]["accuracy"] for hop in HOPS}, + } + ), + flush=True, + ) + return row + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize() + started = time.perf_counter() + while step < end: + updates = min(128, end - step) + indices = [] + for i, stream in enumerate(streams): + draws = stream.take(updates * 32).reshape(updates, 32) + counts[i] += np.bincount(draws.ravel(), minlength=sizes[i]) + indices.append(draws + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(updates): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += updates + torch.cuda.synchronize() + training_seconds += time.perf_counter() - started + loss_value = float(loss) + if not np.isfinite(loss_value): + raise FloatingPointError("Nonfinite loss at step " + str(step)) + endpoint = measure(loss_value) + np.savez_compressed( + out / "exposures.npz", + **{name: count for name, count in zip(TRAIN_SPLITS, counts, strict=True)}, + ) + result = { + "spec": spec, + "source": source, + "data_sha256": digest, + "initial_model_sha256": initial_digest, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "strata_counts": dict(zip(TRAIN_SPLITS, sizes, strict=True)), + "endpoint": endpoint, + "supervised_tokens": step * token_step, + "padded_input_tokens": step * spec["batch_size"] * 8, + "estimated_training_flops": step * flop_step, + "training_seconds": training_seconds, + "process_seconds": time.perf_counter() - started_process, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device), + "tf32": True, + }, + } + write_json(out / "complete.json", result) + return result + + +def compare_metrics(actual, expected): + if set(actual) != set(expected): + raise AssertionError("Metric task keys differ") + for task, values in actual.items(): + if set(values) != set(expected[task]): + raise AssertionError("Metric field keys differ") + for key, value in values.items(): + if key == "answer_nll" and value is not None: + np.testing.assert_allclose(value, expected[task][key], rtol=1e-5, atol=1e-5) + elif value != expected[task][key]: + raise AssertionError(f"Saved metric differs: {task}.{key}") + + +def compare_predictions(actual, path): + maximum = 0.0 + with np.load(path) as saved: + if set(actual) != set(saved.files): + raise AssertionError("Prediction keys differ") + for key, value in actual.items(): + if key.endswith("answer_nll"): + np.testing.assert_allclose(value, saved[key], rtol=1e-5, atol=1e-5) + if value.size: + maximum = max(maximum, float(np.abs(value - saved[key]).max())) + else: + np.testing.assert_array_equal(value, saved[key]) + return maximum + + +def audit(out, device="cuda:0"): + out = Path(out) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.cuda.set_device(torch.device(device)) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + result = json.loads((out / "complete.json").read_text()) + recorded = json.loads((out / "spec.json").read_text()) + source, spec = result["source"], result["spec"] + _check_source(source) + _validate_spec(spec) + if recorded["spec"] != spec or recorded["source"] != source: + raise AssertionError("Recorded specification/source differ") + if file_hash(out / "latest.pt") != result["checkpoint_sha256"]: + raise AssertionError("Latest checkpoint hash differs") + world = build_world(spec) + digest = data_digest(world) + if digest != result["data_sha256"] or digest != recorded["data_sha256"]: + raise AssertionError("Rebuilt data differ from records") + if json.loads((out / "world-metadata.json").read_text()) != world["metadata"]: + raise AssertionError("Archived world metadata differ") + with np.load(out / "world.npz") as archived: + if set(archived.files) != set(EVALUATION_SPLITS): + raise AssertionError("Archived world keys differ") + for name in EVALUATION_SPLITS: + np.testing.assert_array_equal(archived[name], world[name]) + model = construct(spec, device) + if model_digest(model) != result["initial_model_sha256"]: + raise AssertionError("Paired initialization differs") + history = json.loads((out / "learning.json").read_text()) + if [row["step"] for row in history] != spec["nodes"]: + raise AssertionError("Recorded learning nodes differ") + by_node = {row["step"]: row for row in history} + if by_node[spec["steps"]] != result["endpoint"]: + raise AssertionError("Endpoint differs from the learning curve") + maximum = 0.0 + for node in spec["checkpoint_nodes"]: + checkpoint = torch.load( + out / f"model-{node:06d}.pt", map_location=device, weights_only=False + ) + if checkpoint["spec"] != spec or checkpoint["step"] != node: + raise AssertionError("Checkpoint specification/node differ") + model.load_state_dict(checkpoint["model"]) + metrics, predictions = evaluate(model, world, device) + compare_metrics(metrics, by_node[node]["metrics"]) + maximum = max( + maximum, compare_predictions(predictions, out / f"predictions-{node:06d}.npz") + ) + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + if ( + saved["spec"] != spec + or saved["source"] != source + or saved["step"] != spec["steps"] + or saved["data_sha256"] != digest + ): + raise AssertionError("Latest state identity differs") + sizes = [len(world[name]) for name in TRAIN_SPLITS] + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + previous = 0 + for node in spec["nodes"]: + for i, stream in enumerate(streams): + draws = ( + stream.take((node - previous) * 32) + if node > previous + else np.empty(0, dtype=np.int64) + ) + counts[i] += np.bincount(draws, minlength=sizes[i]) + with np.load(out / f"exposures-{node:06d}.npz") as actual: + for name, count in zip(TRAIN_SPLITS, counts, strict=True): + np.testing.assert_array_equal(actual[name], count) + previous = node + with np.load(out / "exposures.npz") as actual: + for i, (name, count) in enumerate(zip(TRAIN_SPLITS, counts, strict=True)): + np.testing.assert_array_equal(actual[name], count) + np.testing.assert_array_equal(saved["counts"][i], count) + if count.sum() != spec["steps"] * 32 or np.ptp(count) > 1: + raise AssertionError("EpochStream actual exposures are unbalanced") + stream = EpochStream(sizes[i], spec["stream_seed"] + i) + stream.load_state_dict(saved["streams"][i]) + np.testing.assert_array_equal(stream.take(32), streams[i].take(32)) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, device) + compare_metrics(metrics, result["endpoint"]["metrics"]) + maximum = max( + maximum, compare_predictions(predictions, out / f"predictions-{spec['steps']:06d}.npz") + ) + checked = { + "passed": True, + "dataset_rebuilt_and_archived_exact": True, + "initial_model_exact": True, + "checkpoint_nodes": spec["checkpoint_nodes"], + "endpoint_tokens_exact": True, + "all_nodes_exposure_counters_exact": True, + "stream_state_continuation_exact": True, + "max_nll_difference": maximum, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "utc": utc(), + } + write_json(out / "audit.json", checked) + return checked diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py new file mode 100644 index 0000000000000000000000000000000000000000..fc14c085184dc030670f1eea92655b73d0eec7c8 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py @@ -0,0 +1,371 @@ +"""Answer-only MLP editing calibration with frozen parent-logit regularization. + +This development grid changes the editor objective and learning rate, preserving +the completed v1 experiment. KL on a finite replay set is a regularizer, not an +exact preservation constraint. Kdev checks the operation; U never selects it. +""" + +from __future__ import annotations + +import copy +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .depth_step import EOS, pack_rows +from .depth_step import SOURCE_FILES as TRAIN_SOURCES +from .depth_step_mechanism import edit_cases, generate +from .grok_depth import utc, write_json +from .latent_scaling import model_digest +from .storage_composition import file_hash + +SOURCE_FILES = list( + dict.fromkeys( + [ + *TRAIN_SOURCES, + "src/llm_memory_editability/depth_step_mechanism.py", + "src/llm_memory_editability/depth_step_edit_calibration.py", + "scripts/calibrate_depth_step_edit.py", + "tests/test_depth_step_edit_calibration.py", + ] + ) +) +PARAMETER = "blocks.0.mlp.down.weight" +NODES = (0, 20, 100, 200) +LEARNING_RATES = (0.0001, 0.001, 0.003) + + +def _array_hash(array): + array = np.asarray(array) + digest = hashlib.sha256(str(array.dtype).encode()) + digest.update(np.asarray(array.shape, dtype="answer and teacher-forced answer->EOS supervision.""" + rows = np.asarray(rows, dtype=np.int64) + tokens, labels = pack_rows(rows, separator=world["metadata"]["separator_token"]) + positions = np.tile([rows.shape[1], rows.shape[1] + 1], (len(rows), 1)) + batch_indices = np.arange(len(rows))[:, None] + selected = labels[batch_indices, positions] + if not np.array_equal(selected, np.c_[rows[:, -1], np.full(len(rows), EOS)]): + raise ValueError("Answer/EOS positions disagree with the packed sequence") + return tuple(torch.as_tensor(value, device=device) for value in (tokens, positions, selected)) + + +def answer_eos_logits(model, batch): + tokens, positions, _labels = batch + return model(tokens, positions=positions) + + +def target_and_replay_loss(model, target_batch, replay_batch, parent_log_probabilities): + """CE only on two factual-output tokens; KL(parent || edited), equally weighted.""" + if parent_log_probabilities.requires_grad: + raise ValueError("Parent logits must be detached") + target_logits = answer_eos_logits(model, target_batch) + ce = F.cross_entropy(target_logits.flatten(0, 1), target_batch[2].flatten()) + replay_log = answer_eos_logits(model, replay_batch).log_softmax(-1) + kl = F.kl_div( + replay_log.flatten(0, 1), + parent_log_probabilities.flatten(0, 1), + reduction="batchmean", + log_target=True, + ) + return ce + kl, ce, kl + + +def _measure(model, case, world, device, step): + metrics, raw = {}, {} + for name, rows in case["tasks"].items(): + values, predictions = generate(model, rows, world, device) + if name in case["original_d_rows"]: + original = case["original_d_rows"][name] + changed = rows[:, -1] != original[:, -1] + predicted = predictions["predictions"] + correct = (predicted[:, 0] == rows[:, -1]) & (predicted[:, 1] == EOS) + old_correct = (predicted[:, 0] == original[:, -1]) & (predicted[:, 1] == EOS) + values.update( + { + "changed_answer_n": int(changed.sum()), + "changed_answer_coverage": float(changed.mean()) if len(rows) else None, + "changed_answer_accuracy": float(correct[changed].mean()) + if changed.any() + else None, + "old_answer_accuracy": float(old_correct.mean()) if len(rows) else None, + } + ) + metrics[name] = values + raw.update({f"step{step}_{name}_{key}": value for key, value in predictions.items()}) + return metrics, raw + + +def calibrated_edit_one(model, case, world, device, arm, lr, nodes=NODES): + """One independently initialized branch, with fixed parent KL reference.""" + if arm not in {"edit", "review"}: + raise ValueError("Arm must be edit or review") + if tuple(nodes) != tuple(sorted(set(nodes))) or not nodes or nodes[0] != 0: + raise ValueError("Nodes must increase from zero") + parent_hash = model_digest(model) + edited = copy.deepcopy(model).eval() + for name, parameter in edited.named_parameters(): + parameter.requires_grad_(name == PARAMETER) + parameter.grad = None + before = {name: value.detach().clone() for name, value in edited.state_dict().items()} + parameter = dict(edited.named_parameters())[PARAMETER] + optimizer = torch.optim.Adam([parameter], lr=lr) + target_rows = np.asarray([case["new_fact"] if arm == "edit" else case["old_fact"]]) + target_batch = answer_eos_batch(target_rows, world, device) + replay_batch = answer_eos_batch(case["tasks"]["R_atomic"], world, device) + with torch.no_grad(): + parent_log = answer_eos_logits(model, replay_batch).log_softmax(-1).detach() + raw = { + "parent_replay_log_probabilities": parent_log.cpu().numpy(), + "replay_teacherforced_labels": replay_batch[2].cpu().numpy(), + } + for name, old_rows in case["original_d_rows"].items(): + raw[name + "_original_rows"] = old_rows + raw[name + "_changed_answer_mask"] = case["tasks"][name][:, -1] != old_rows[:, -1] + step, history, loss_values = 0, [], None + for node in nodes: + while step < node: + optimizer.zero_grad(set_to_none=True) + loss, ce, kl = target_and_replay_loss(edited, target_batch, replay_batch, parent_log) + loss.backward() + optimizer.step() + step += 1 + loss_values = { + "total": float(loss.detach()), + "target_ce": float(ce.detach()), + "replay_kl": float(kl.detach()), + } + metrics, predictions = _measure(edited, case, world, device, step) + raw.update(predictions) + target_name = "E_new" if arm == "edit" else "E_old" + keep_pass = metrics["Kdev_atomic"]["accuracy"] >= 0.95 + target_pass = metrics[target_name]["accuracy"] == 1.0 + history.append( + { + "step": step, + "loss": loss_values, + "metrics": metrics, + "Kdev_at_least_95_percent": keep_pass, + "target_atomic_success": target_pass, + "calibration_operation_pass": keep_pass and target_pass, + } + ) + changed = [ + name for name, value in edited.state_dict().items() if not torch.equal(value, before[name]) + ] + if set(changed) - {PARAMETER}: + raise ValueError("A frozen state tensor changed") + if model_digest(model) != parent_hash: + raise ValueError("Original checkpoint model changed") + delta = parameter.detach() - before[PARAMETER] + raw["mlp_down_weight_delta"] = delta.cpu().numpy() + record = { + "arm": arm, + "lr": lr, + "atomic_index": case["atomic_index"], + "old_fact": case["old_fact"], + "new_fact": case["new_fact"], + "replay_indices": case["replay_indices"], + "keep_dev_indices": case["keep_dev_indices"], + "unused_atomic_indices": case["unused_atomic_indices"], + "parent_model_sha256": parent_hash, + "final_model_sha256": model_digest(edited), + "initial_down_weight_sha256": _array_hash(before[PARAMETER].cpu().numpy()), + "final_down_weight_sha256": _array_hash(parameter.detach().cpu().numpy()), + "updated_parameter": PARAMETER, + "changed_state_tensors": changed, + "weight_delta_l2": float(delta.norm()), + "history": history, + } + return record, raw + + +def prepare_calibration(model, world, source, out, learning_rates=LEARNING_RATES, n_cases=2): + """Freeze data, all arms, sources, and initial weights before any model inference.""" + out = Path(out) + out.mkdir(parents=True, exist_ok=False) + if any(lr <= 0 or not np.isfinite(lr) for lr in learning_rates): + raise ValueError("Invalid learning rate") + cases, remaining = calibration_cases(world, n_cases=n_cases) + serialized = [] + for case in cases: + entry = { + key: value for key, value in case.items() if key not in {"tasks", "original_d_rows"} + } + entry["task_rows"] = {key: value.tolist() for key, value in case["tasks"].items()} + entry["task_sha256"] = {key: _array_hash(value) for key, value in case["tasks"].items()} + entry["original_d_rows"] = { + key: value.tolist() for key, value in case["original_d_rows"].items() + } + serialized.append(entry) + config = { + "phase": "development_calibration", + "created_utc": utc(), + "source_checkpoint": source, + "source": {path: file_hash(path) for path in SOURCE_FILES}, + "parent_model_sha256": model_digest(model), + "initial_down_weight_sha256": _array_hash( + model.blocks[0].mlp.down.weight.detach().cpu().numpy() + ), + "learning_rates": list(learning_rates), + "nodes": list(NODES), + "cases": serialized, + "n_cases": n_cases, + "matrix": [ + {"case": i, "lr": lr, "arm": arm} + for i in range(n_cases) + for lr in learning_rates + for arm in ("edit", "review") + ], + "reserved_original_case_indices": remaining, + "reserved_cases_are_independent_world_confirmation": False, + "optimizer": "Adam, no weight decay", + "parameter": PARAMETER, + "objective": "target answer/EOS CE + KL(parent || edited) on 32 replay answer/EOS logits", + "replay_kl_weight": 1.0, + "supervised_prefix_tokens": 0, + "trained_compositions": 0, + "Kdev_selection": "First 32 lexicographic atoms excluding E, R, necessary successors", + "Kdev_threshold": 0.95, + "U_selection": "All remaining atomic facts, including unused necessary successors", + "U_or_D_select_editor": False, + "all_grid_failures_retained": True, + "executions_affected_by_shared_edit": model.repeats, + "limits": [ + "Finite replay KL is not strict output preservation", + "A successful Kdev check does not establish unobserved U preservation", + "Cases share one development world and original checkpoints", + ], + } + write_json(out / "calibration-config.json", config) + return config, cases + + +def load_prepared_calibration(model, world, source, out, learning_rates=LEARNING_RATES, n_cases=2): + """Validate an existing prepared configuration, without rewriting it.""" + out = Path(out) + config_file = out / "calibration-config.json" + config = json.loads(config_file.read_text()) + if any(path.name != config_file.name for path in out.iterdir()): + raise FileExistsError("Existing branch artifacts prevent a repeated execution") + if config["learning_rates"] != list(learning_rates) or config["n_cases"] != n_cases: + raise ValueError("Requested grid differs from prepared calibration") + expected_source = config["source_checkpoint"] + for key in ("checkpoint_sha256", "dataset_sha256", "step", "spec"): + if source[key] != expected_source[key]: + raise ValueError("Checkpoint or data differ from prepared calibration: " + key) + if model_digest(model) != config["parent_model_sha256"]: + raise ValueError("Parent parameter hash differs from prepared calibration") + expected_matrix = [ + {"case": i, "lr": lr, "arm": arm} + for i in range(n_cases) + for lr in learning_rates + for arm in ("edit", "review") + ] + if config["matrix"] != expected_matrix or config["nodes"] != list(NODES): + raise ValueError("Prepared update matrix or nodes changed") + if ( + config["parameter"] != PARAMETER + or config["replay_kl_weight"] != 1.0 + or config["Kdev_threshold"] != 0.95 + or config["U_or_D_select_editor"] + ): + raise ValueError("Prepared operation contract changed") + cases, remaining = calibration_cases(world, n_cases=n_cases) + if remaining != config["reserved_original_case_indices"]: + raise ValueError("Reserved cases changed") + for case, frozen in zip(cases, config["cases"], strict=True): + for key in ( + "atomic_index", + "old_fact", + "new_fact", + "replay_indices", + "keep_dev_indices", + "unused_atomic_indices", + "propagation_scope", + ): + if case[key] != frozen[key]: + raise ValueError("Case selection changed: " + key) + if set(case["tasks"]) != set(frozen["task_rows"]): + raise ValueError("Prepared task set changed") + for name, rows in case["tasks"].items(): + if ( + rows.tolist() != frozen["task_rows"][name] + or _array_hash(rows) != frozen["task_sha256"][name] + ): + raise ValueError("Prepared task rows changed: " + name) + for name, rows in case["original_d_rows"].items(): + if rows.tolist() != frozen["original_d_rows"][name]: + raise ValueError("Prepared original D labels changed") + for path, expected in config["source"].items(): + if file_hash(path) != expected: + raise ValueError("Source changed after calibration freeze: " + path) + return config, cases + + +def execute_calibration(model, world, config, cases, out, device): + out = Path(out) + if model_digest(model) != config["parent_model_sha256"]: + raise ValueError("Parent parameter hash differs from frozen configuration") + for path, expected in config["source"].items(): + if file_hash(path) != expected: + raise ValueError("Source changed after calibration freeze: " + path) + for case, expected in zip(cases, config["cases"], strict=True): + for name, rows in case["tasks"].items(): + if _array_hash(rows) != expected["task_sha256"][name]: + raise ValueError("Task rows changed after freeze: " + name) + started = time.perf_counter() + records = [] + for item in config["matrix"]: + number, lr, arm = item["case"], item["lr"], item["arm"] + record, raw = calibrated_edit_one( + model, cases[number], world, device, arm, lr, nodes=tuple(config["nodes"]) + ) + label = f"case{number:02d}-lr{lr:.4f}-{arm}" + np.savez_compressed(out / (label + "-raw.npz"), **raw) + write_json(out / (label + ".json"), record) + records.append(record) + print(f"Calibration branch completed: {label}", flush=True) + report = { + "phase": "development_calibration", + "records": records, + "config_sha256": file_hash(out / "calibration-config.json"), + "completed_branches": len(records), + "wall_seconds": time.perf_counter() - started, + "model_selection_by_U_or_D": False, + } + write_json(out / "calibration-summary.json", report) + return report diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_mechanism.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_mechanism.py new file mode 100644 index 0000000000000000000000000000000000000000..fdb78cafec65ea5b0a4031d27502f7d0c4b00e16 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/depth_step_mechanism.py @@ -0,0 +1,589 @@ +"""Descriptive entity readouts, pure-first-hop interventions and MLP edits. + +No fitted probe or performance predictor is used. Residual readouts and raw MLP +cosines are descriptions; only interventions test a causal contribution. The +truth graph chooses queries, donors and edits before any model is evaluated. +""" + +from __future__ import annotations + +import copy +import json +import math +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .depth_step import ENTITY_OFFSET, EOS, construct, pack_rows, prompt_rows, truth_path_details +from .grok_depth import utc, write_json +from .storage_composition import file_hash + + +def traced_forward(model, tokens, patches=None): + """Use the real SDPA computation and record every executed block/position. + + Patches map (zero-based execution, 'mlp_delta' or 'postresidual', position) + to a batch of replacement vectors. Repeated executions of a shared block + remain separately indexed. Attention maps are descriptive manual softmax; + the forward uses the same SDPA primitive as LoopGPT. + """ + if model.training: + raise ValueError("Tracing requires evaluation mode") + patches = patches or {} + length = tokens.shape[1] + x = model.token(tokens) + model.position(torch.arange(length, device=tokens.device)) + cache = {key: [] for key in ("attention_map", "attention_delta", "mlp_delta", "postresidual")} + consumed = set() + for index, block in enumerate(model.iter_blocks()): + z = block.ln1(x) + batch, _, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + q, k, v = (part.transpose(1, 2) for part in (q, k, v)) + scores = (q @ k.transpose(-1, -2)) / math.sqrt(width // a.heads) + causal = torch.ones(length, length, device=tokens.device, dtype=torch.bool).tril() + attention_map = scores.masked_fill(~causal, -torch.inf).softmax(-1) + y = F.scaled_dot_product_attention(q, k, v, is_causal=True, dropout_p=0.0) + attention_delta = a.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + attention_delta + mlp_delta = block.mlp(block.ln2(x)) + for key, replacement in patches.items(): + layer, component, position = key + if layer == index and component == "mlp_delta": + if replacement.shape != mlp_delta[:, position].shape: + raise ValueError("Patch shape differs from selected MLP position") + mlp_delta = mlp_delta.clone() + mlp_delta[:, position] = replacement + consumed.add(key) + x = x + mlp_delta + for key, replacement in patches.items(): + layer, component, position = key + if layer == index and component == "postresidual": + if replacement.shape != x[:, position].shape: + raise ValueError("Patch shape differs from selected residual position") + x = x.clone() + x[:, position] = replacement + consumed.add(key) + for key, value in ( + ("attention_map", attention_map), + ("attention_delta", attention_delta), + ("mlp_delta", mlp_delta), + ("postresidual", x), + ): + cache[key].append(value.detach()) + if consumed != set(patches): + raise ValueError("Unknown execution/component in patch") + logits = F.linear(model.ln_final(x), model.token.weight) + return logits, {key: torch.stack(values) for key, values in cache.items()} + + +def _separator(world): + return int(world["metadata"]["separator_token"]) + + +def _mean(values): + return float(np.mean(values)) if len(values) else None + + +@torch.no_grad() +def generate(model, rows, world, device, batch_size=256): + """Free answer then free EOS, retaining full-vocabulary probabilities.""" + rows = np.asarray(rows, dtype=np.int64) + predictions, probabilities, gold_probabilities = [], [], [] + for begin in range(0, len(rows), batch_size): + selected = rows[begin : begin + batch_size] + tokens = torch.as_tensor(prompt_rows(selected, _separator(world)), device=device) + probability = model(tokens)[:, -1].softmax(-1) + answer = probability.argmax(-1) + eos = model(torch.cat((tokens, answer[:, None]), dim=1))[:, -1].argmax(-1) + predictions.append(torch.stack((answer, eos), 1).cpu().numpy()) + probabilities.append(probability.cpu().numpy()) + gold_probabilities.append( + probability[ + torch.arange(len(selected), device=device), + torch.as_tensor(selected[:, -1], device=device), + ] + .cpu() + .numpy() + ) + vocab = model.config.vocab_size + predicted = np.concatenate(predictions) if predictions else np.empty((0, 2), dtype=np.int64) + prob = ( + np.concatenate(probabilities) if probabilities else np.empty((0, vocab), dtype=np.float32) + ) + gold_prob = np.concatenate(gold_probabilities) if gold_probabilities else np.empty(0) + correct = predicted[:, 0] == rows[:, -1] + return { + "n": len(rows), + "answer_accuracy": _mean(correct), + "accuracy": _mean(correct & (predicted[:, 1] == EOS)), + "gold_probability": _mean(gold_prob), + }, {"rows": rows, "predictions": predicted, "answer_probabilities": prob} + + +def select_donors(world, rows): + """Lexicographic donors know exactly one fact and no target second relation.""" + atoms = world["atomic"] + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + order = sorted(range(len(atoms)), key=lambda i: tuple(atoms[i])) + nodes, _ = truth_path_details(world, rows) + same, changed, changed_tail = [], [], [] + for row, path in zip(rows, nodes, strict=True): + h, r1, r2, old_tail = map(int, row) + bridge = int(path[1]) + identical = next( + (i for i in order if int(atoms[i, 2]) == bridge and tuple(atoms[i, :2]) != (h, r1)), -1 + ) + different = next( + ( + i + for i in order + if int(atoms[i, 2]) != bridge + and (int(atoms[i, 2]), r2) in lookup + and lookup[(int(atoms[i, 2]), r2)] != old_tail + ), + -1, + ) + same.append(identical) + changed.append(different) + changed_tail.append(lookup[(int(atoms[different, 2]), r2)] if different >= 0 else -1) + return { + "same_bridge_atomic_indices": np.asarray(same, dtype=np.int64), + "different_bridge_atomic_indices": np.asarray(changed, dtype=np.int64), + "different_bridge_tail": np.asarray(changed_tail, dtype=np.int64), + } + + +@torch.no_grad() +def entity_readouts(model, cache, targets, entities): + """Apply the unmodified final norm/tied readout; raw MLP cosine is separate.""" + residual = cache["postresidual"] + logits = F.linear(model.ln_final(residual), model.token.weight) + entity_logits = logits[..., ENTITY_OFFSET : ENTITY_OFFSET + entities] + probabilities = logits.softmax(-1) + entity_probabilities = entity_logits.softmax(-1) + embedding = F.normalize(model.token.weight[ENTITY_OFFSET : ENTITY_OFFSET + entities], dim=-1) + cosine = F.normalize(cache["mlp_delta"], dim=-1) @ embedding.T + arrays = {} + for name, token_ids in targets.items(): + ids = torch.as_tensor(token_ids, device=residual.device) + full_ids = ids[None, :, None, None].expand(*residual.shape[:-1], 1) + entity_ids = full_ids - ENTITY_OFFSET + gold_logit = entity_logits.gather(-1, entity_ids).squeeze(-1) + gold_cosine = cosine.gather(-1, entity_ids).squeeze(-1) + arrays[name + "_residual_entity_rank"] = 1 + (entity_logits > gold_logit[..., None]).sum(-1) + arrays[name + "_residual_vocab_probability"] = probabilities.gather(-1, full_ids).squeeze( + -1 + ) + arrays[name + "_residual_entity_probability"] = entity_probabilities.gather( + -1, entity_ids + ).squeeze(-1) + arrays[name + "_mlp_embedding_cosine"] = gold_cosine + arrays[name + "_mlp_embedding_cosine_rank"] = 1 + (cosine > gold_cosine[..., None]).sum(-1) + return {name: value.cpu().numpy() for name, value in arrays.items()} + + +@torch.no_grad() +def _patched_generation(model, tokens, patch): + logits, _ = traced_forward(model, tokens, patch) + probability = logits[:, -1].softmax(-1) + answer = probability.argmax(-1) + # Reapply the same intervention while freely generating the EOS token. + extended = torch.cat((tokens, answer[:, None]), dim=1) + eos_logits, _ = traced_forward(model, extended, patch) + eos = eos_logits[:, -1].argmax(-1) + return torch.stack((answer, eos), 1).cpu().numpy(), probability.cpu().numpy() + + +def trace_analysis(model, world, out, device, max_queries=128): + out = Path(out) + out.mkdir(parents=True, exist_ok=False) + model.eval() + started = time.perf_counter() + raw, baseline = {}, {} + for split in ("atomic", "familiar_2", "strict_2"): + metrics, prediction = generate(model, world[split], world, device) + baseline[split] = metrics + raw.update({f"baseline_{split}_{key}": value for key, value in prediction.items()}) + indices = np.arange(min(max_queries, len(world["familiar_2"]))) + rows = world["familiar_2"][indices] + nodes, edges = truth_path_details(world, rows) + tokens = torch.as_tensor(prompt_rows(rows, _separator(world)), device=device) + with torch.no_grad(): + reference = model(tokens) + actual, cache = traced_forward(model, tokens) + difference = float((actual - reference).abs().max()) + torch.testing.assert_close(actual, reference, rtol=1e-5, atol=2e-6) + if not torch.equal(actual.argmax(-1), reference.argmax(-1)): + raise ValueError("Traced forward changes full-vocabulary argmax") + raw.update( + { + "query_indices": indices, + "query_rows": rows, + "truth_nodes": nodes, + "truth_atomic_indices": edges, + } + ) + raw.update({"cache_" + key: value.cpu().numpy() for key, value in cache.items()}) + raw.update( + entity_readouts( + model, + cache, + {"bridge": nodes[:, 1], "tail": nodes[:, -1]}, + world["metadata"]["entities"], + ) + ) + donors = select_donors(world, rows) + raw.update(donors) + atom_predictions = raw["baseline_atomic_predictions"] + atoms = world["atomic"] + atom_correct = (atom_predictions[:, 0] == atoms[:, -1]) & (atom_predictions[:, 1] == EOS) + atomic_key_indices = {tuple(map(int, row[:2])): i for i, row in enumerate(atoms)} + raw["original_constituent_atoms_correct"] = atom_correct[edges].all(1) + records = [] + for style in ("self", "same_bridge", "different_bridge"): + donor_ids = edges[:, 0] if style == "self" else donors[style + "_atomic_indices"] + valid = donor_ids >= 0 + selected = np.flatnonzero(valid) + if not len(selected): + continue + donor_rows = world["atomic"][donor_ids[valid]] + donor_tokens = torch.as_tensor(prompt_rows(donor_rows, _separator(world)), device=device) + with torch.no_grad(): + _, donor_cache = traced_forward(model, donor_tokens) + expected = ( + donors["different_bridge_tail"][valid] + if style == "different_bridge" + else rows[valid, -1] + ) + new_second_indices = np.asarray( + [ + atomic_key_indices[(int(donor[2]), int(query[2]))] + for donor, query in zip(donor_rows, rows[valid], strict=True) + ] + ) + premises = ( + atom_correct[edges[valid]].all(1) + & atom_correct[donor_ids[valid]] + & atom_correct[new_second_indices] + ) + raw[style + "_premises_correct"] = premises + for layer in range(model.effective_depth): + for component in ("mlp_delta", "postresidual"): + for position in (2, 1): + key = f"{style}_layer{layer}_{component}_pos{position}" + patch = { + (layer, component, position): donor_cache[component][layer, :, position] + } + prediction, probability = _patched_generation(model, tokens[valid], patch) + raw[key + "_selected_query_indices"] = selected + raw[key + "_predictions"] = prediction + raw[key + "_answer_probabilities"] = probability + following = prediction[:, 0] == expected + correct = prediction[:, 0] == rows[valid, -1] + base_pred = raw["baseline_familiar_2_predictions"][indices[valid]] + base_correct = (base_pred[:, 0] == rows[valid, -1]) & (base_pred[:, 1] == EOS) + if style == "self" and not np.array_equal(prediction, base_pred): + raise ValueError("Pure-first-hop self patch changes generation") + record = { + "donor": style, + "execution": layer, + "component": component, + "position": position, + "n": len(selected), + "selected_query_coverage": len(selected) / len(rows), + "full_pool_coverage": len(selected) / len(world["familiar_2"]), + "new_route_answer_accuracy": _mean(following), + "new_route_accuracy": _mean(following & (prediction[:, 1] == EOS)), + "original_accuracy": _mean(correct & (prediction[:, 1] == EOS)), + "baseline_correct_coverage": _mean(base_correct), + "all_required_atomic_correct_coverage": _mean(premises), + "new_route_conditional_on_required_atomics": _mean( + (following & (prediction[:, 1] == EOS))[premises] + ), + "new_route_conditional_on_baseline_correct": _mean( + (following & (prediction[:, 1] == EOS))[base_correct] + ), + } + records.append(record) + with torch.no_grad(): + entity_embedding = model.token.weight[ + ENTITY_OFFSET : ENTITY_OFFSET + world["metadata"]["entities"] + ] + normalized = F.normalize(entity_embedding, dim=-1) + raw["entity_embedding_cosine_matrix"] = (normalized @ normalized.T).cpu().numpy() + raw["entity_embedding_singular_values"] = ( + torch.linalg.svdvals(entity_embedding).cpu().numpy() + ) + np.savez_compressed(out / "trace-raw.npz", **raw) + report = { + "phase": "development", + "created_utc": utc(), + "baseline": baseline, + "query_selection": ( + "First 128 familiar_2 rows in frozen data order, independent of predictions" + ), + "selected_queries": len(rows), + "full_pool_queries": len(world["familiar_2"]), + "selection_coverage": len(rows) / len(world["familiar_2"]), + "forward_max_absolute_difference": difference, + "forward_all_argmax_identical": True, + "donor_information": ( + "Only BOS, head, first relation, SEP; no second relation or final answer" + ), + "patch_position_roles": {"1": "head control", "2": "first relation"}, + "interventions": records, + "wall_seconds": time.perf_counter() - started, + "limits": [ + "Unfitted final-norm tied readout and raw cosine are descriptive", + "Attention maps are descriptive; patch tests entire state or MLP contribution", + "Layers, positions and queries are dependent measurements in one world", + ], + } + write_json(out / "trace-summary.json", report) + return report + + +def edit_cases(world, n_facts=8, replay_n=32): + """Choose graph-based first-hop edits before observing any model behavior.""" + atoms = world["atomic"] + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + candidate_first = {(int(row[0]), int(row[1])) for row in world["familiar_2"]} + order = sorted(range(len(atoms)), key=lambda i: tuple(atoms[i])) + cases = [] + for index in order: + h, relation, old_bridge = map(int, atoms[index]) + if (h, relation) not in candidate_first: + continue + first_rows = world["familiar_2"][ + (world["familiar_2"][:, 0] == h) & (world["familiar_2"][:, 1] == relation) + ] + bridges = sorted({int(t) for _, _, t in atoms}) + new_bridge = next( + ( + b + for b in bridges + if b != old_bridge + and all( + (b, int(row[2])) in lookup and lookup[(b, int(row[2]))] != int(row[-1]) + for row in first_rows + ) + ), + None, + ) + if new_bridge is None: + continue + replay_indices = np.asarray([i for i in order if i != index][:replay_n]) + if len(replay_indices) != replay_n: + raise ValueError("Insufficient nonedited replay atoms") + new_fact = np.asarray([[h, relation, new_bridge]], dtype=np.int64) + old_fact = atoms[index : index + 1].copy() + edited_lookup = {**lookup, (h, relation): new_bridge} + tasks = {"E_new": new_fact, "E_old": old_fact, "R_atomic": atoms[replay_indices].copy()} + original_d_rows = {} + unreplayed = [i for i in range(len(atoms)) if i != index and i not in replay_indices] + tasks["U_atomic"] = atoms[unreplayed].copy() + successor_keys = set() + for split in ("familiar_2", "strict_2"): + rows = world[split] + nodes, path_indices = truth_path_details(world, rows) + first = path_indices[:, 0] == index + second = (path_indices[:, 1] == index) & ~first + unaffected = ~(first | second) + for role, mask in (("first", first), ("second", second)): + changed = rows[mask].copy() + for i, row in enumerate(changed): + bridge = edited_lookup[(int(row[0]), int(row[1]))] + changed[i, -1] = edited_lookup[(bridge, int(row[2]))] + if role == "first" and (bridge, int(row[2])) != (h, relation): + successor_keys.add((bridge, int(row[2]))) + tasks[f"D_{role}_{split}"] = changed + original_d_rows[f"D_{role}_{split}"] = rows[mask].copy() + tasks["U_" + split] = rows[unaffected].copy() + # All facts occurring as either hop in U retain their graph labels. + if index in path_indices[unaffected]: + raise ValueError("Edited fact leaked into the unaffected holdout") + del nodes + successor_indices = [i for i, row in enumerate(atoms) if tuple(row[:2]) in successor_keys] + tasks["necessary_successor_atomic"] = atoms[successor_indices].copy() + cases.append( + { + "atomic_index": index, + "old_fact": old_fact[0].tolist(), + "new_fact": new_fact[0].tolist(), + "replay_indices": replay_indices.tolist(), + "tasks": tasks, + "original_d_rows": original_d_rows, + "propagation_scope": { + name: { + "n": len(old_rows), + "changed_answer_n": int( + np.count_nonzero(tasks[name][:, -1] != old_rows[:, -1]) + ), + "source_pool_n": len(world[name.split("_", 2)[2]]), + } + for name, old_rows in original_d_rows.items() + }, + } + ) + if len(cases) == n_facts: + break + if len(cases) != n_facts: + raise ValueError("Fewer graph-valid fixed edit cases than requested") + return cases + + +def _atomic_loss(model, rows, world, device): + tokens, labels = pack_rows(rows, separator=_separator(world)) + tokens = torch.as_tensor(tokens, device=device) + labels = torch.as_tensor(labels, device=device) + logits = model(tokens) + return F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + + +def edit_one(model, case, world, device, arm, nodes=(0, 20, 100, 200), lr=0.01): + """Independently edit one checkpoint; only unique block-0 MLP down changes.""" + if arm not in {"edit", "review"}: + raise ValueError("Arm must be edit or review") + if tuple(nodes) != tuple(sorted(set(nodes))) or nodes[0] != 0: + raise ValueError("Nodes must be increasing with initial measurement") + edited = copy.deepcopy(model).eval() + target_name = "blocks.0.mlp.down.weight" + for name, parameter in edited.named_parameters(): + parameter.requires_grad_(name == target_name) + parameter.grad = None + before = {name: value.detach().clone() for name, value in edited.state_dict().items()} + parameter = dict(edited.named_parameters())[target_name] + optimizer = torch.optim.Adam([parameter], lr=lr) + objective_rows = np.asarray([case["new_fact"] if arm == "edit" else case["old_fact"]]) + history, raw = [], {} + for name, old_rows in case["original_d_rows"].items(): + raw[name + "_original_rows"] = old_rows + raw[name + "_changed_answer_mask"] = case["tasks"][name][:, -1] != old_rows[:, -1] + step = 0 + final_loss = None + for node in nodes: + while step < node: + optimizer.zero_grad(set_to_none=True) + loss = 0.5 * _atomic_loss(edited, objective_rows, world, device) + loss = loss + 0.5 * _atomic_loss(edited, case["tasks"]["R_atomic"], world, device) + loss.backward() + optimizer.step() + step += 1 + final_loss = float(loss.detach()) + measures = {} + for name, rows in case["tasks"].items(): + metrics, prediction = generate(edited, rows, world, device) + if name in case["original_d_rows"]: + old_rows = case["original_d_rows"][name] + changed_mask = rows[:, -1] != old_rows[:, -1] + predicted = prediction["predictions"] + correct = (predicted[:, 0] == rows[:, -1]) & (predicted[:, 1] == EOS) + old_correct = (predicted[:, 0] == old_rows[:, -1]) & (predicted[:, 1] == EOS) + metrics.update( + { + "changed_answer_n": int(changed_mask.sum()), + "changed_answer_coverage": _mean(changed_mask), + "changed_answer_accuracy": _mean(correct[changed_mask]), + "old_answer_accuracy": _mean(old_correct), + } + ) + measures[name] = metrics + raw.update({f"step{step}_{name}_{key}": value for key, value in prediction.items()}) + history.append({"step": step, "loss": final_loss, "metrics": measures}) + changed = [ + name for name, value in edited.state_dict().items() if not torch.equal(value, before[name]) + ] + if set(changed) - {target_name}: + raise ValueError("Parameters outside the frozen MLP projection changed") + delta = parameter.detach() - before[target_name] + raw["mlp_down_weight_delta"] = delta.cpu().numpy() + return { + "arm": arm, + "atomic_index": case["atomic_index"], + "old_fact": case["old_fact"], + "new_fact": case["new_fact"], + "replay_indices": case["replay_indices"], + "propagation_scope": case["propagation_scope"], + "updated_parameter": target_name, + "changed_state_tensors": changed, + "weight_delta_l2": float(delta.norm()), + "history": history, + }, raw + + +def edit_analysis(model, world, out, device, n_facts=8, nodes=(0, 20, 100, 200), lr=0.01): + out = Path(out) + out.mkdir(parents=True, exist_ok=False) + started = time.perf_counter() + cases = edit_cases(world, n_facts=n_facts) + serializable_cases = [ + {key: value for key, value in case.items() if key not in {"tasks", "original_d_rows"}} + | {"task_sizes": {key: len(rows) for key, rows in case["tasks"].items()}} + for case in cases + ] + # This is written before evaluating or updating any case. + write_json(out / "data-selected-edit-cases.json", serializable_cases) + records = [] + for number, case in enumerate(cases): + for arm in ("edit", "review"): + record, raw = edit_one(model, case, world, device, arm, nodes=nodes, lr=lr) + np.savez_compressed(out / f"case{number:02d}-{arm}-raw.npz", **raw) + write_json(out / f"case{number:02d}-{arm}.json", record) + records.append(record) + report = { + "phase": "development", + "created_utc": utc(), + "n_facts": n_facts, + "nodes": list(nodes), + "lr": lr, + "optimizer": "Adam, no weight decay", + "objective": "0.5 target atomic full-token CE + 0.5 fixed 32-atomic replay full-token CE", + "trained_compositions": 0, + "unique_block_edited": 0, + "executions_affected_by_shared_edit": model.repeats, + "independent_layers": len(model.blocks), + "execution_depth": model.effective_depth, + "scope_difference": ( + "Loop block-0 update applies at every repeat; ordinary block-0 applies once" + ), + "records": records, + "wall_seconds": time.perf_counter() - started, + "limits": [ + "Edits use the same fixed budget; failed target changes remain in results", + "MLP-only parameter fine-tuning is not a constrained-preservation theorem", + "Each case independently starts from the same checkpoint", + "A single development world is not independent confirmation", + ], + } + write_json(out / "edit-summary.json", report) + return report + + +def load_run(run_dir, checkpoint, device): + run_dir, checkpoint = Path(run_dir), Path(checkpoint) + saved = torch.load(checkpoint, map_location=device, weights_only=False) + model = construct(saved["spec"], device).eval() + model.load_state_dict(saved["model"], strict=True) + arrays = np.load(run_dir / "world.npz", allow_pickle=False) + world = {key: arrays[key] for key in arrays.files} + world["metadata"] = json.loads((run_dir / "world-metadata.json").read_text()) + from .depth_step import audit_world + + audit = audit_world(world) + if audit["dataset_sha256"] != saved["spec"].get("frozen_data_sha256", audit["dataset_sha256"]): + raise ValueError("Checkpoint and archived data digest disagree") + return ( + model, + world, + { + "checkpoint": str(checkpoint), + "checkpoint_sha256": file_hash(checkpoint), + "step": saved["step"], + "spec": saved["spec"], + "dataset_sha256": audit["dataset_sha256"], + }, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiment_tracking.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiment_tracking.py new file mode 100644 index 0000000000000000000000000000000000000000..167c8e1a359008fa8b7c89642273e85c9699643e --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiment_tracking.py @@ -0,0 +1,298 @@ +"""W&B sidecar for future experiments; reads trainer artifacts without changing training.""" + +from __future__ import annotations + +import argparse +import fcntl +import hashlib +import importlib +import json +import math +import os +import subprocess +import sys +import time +from pathlib import Path + +DEFAULTS = Path(__file__).resolve().parents[2] / "configs/experiment-tracking-defaults.json" +PRIVATE_KEYS = { + "api_key", + "wandb_api_key", + "access_token", + "auth_token", + "password", + "credentials", + "secret", +} + + +def read_json(path): + return json.loads(Path(path).read_text()) + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temp = path.with_suffix(".tmp") + temp.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n") + temp.replace(path) + + +def public_config(value): + if isinstance(value, dict): + return {k: public_config(v) for k, v in value.items() if k.lower() not in PRIVATE_KEYS} + if isinstance(value, list): + return [public_config(v) for v in value] + return value + + +def numeric_fields(value, prefix): + result = {} + for key, item in value.items(): + name = f"{prefix}/{key}" + if isinstance(item, dict): + result.update(numeric_fields(item, name)) + elif isinstance(item, int | float) and not isinstance(item, bool) and math.isfinite(item): + result[name] = item + return result + + +def learning_metrics(record, previous=None): + """Keep the actual optimizer step and task denominators; derive interval throughput.""" + result = {"training/step": int(record["step"])} + result.update(numeric_fields(record.get("metrics", {}), "eval")) + groups = { + "training_seconds": "perf/training_seconds", + "wall_seconds": "perf/wall_seconds", + "examples": "exposure/examples", + "supervised_tokens": "exposure/supervised_tokens", + "executed_input_tokens": "compute/executed_input_tokens", + "estimated_matmul_training_flops": "compute/estimated_matmul_training_flops", + "atomic_epochs": "exposure/atomic_epochs", + "composition_epochs": "exposure/composition_epochs", + } + for key, value in record.items(): + if key in {"step", "metrics"}: + continue + if isinstance(value, int | float) and not isinstance(value, bool) and math.isfinite(value): + result[groups.get(key, f"training/{key}")] = value + if previous is not None and record["step"] > previous["step"]: + steps = record["step"] - previous["step"] + if "training_seconds" in record and "training_seconds" in previous: + seconds = record["training_seconds"] - previous["training_seconds"] + if seconds > 0: + result["perf/training_ms_per_update"] = 1000 * seconds / steps + result["perf/updates_per_second"] = steps / seconds + if "examples" in record and "examples" in previous: + result["perf/examples_per_second"] = ( + record["examples"] - previous["examples"] + ) / seconds + return result + + +class ArtifactRunTracker: + def __init__(self, sdk, batch, path, settings): + self.path = Path(path) + self.state_path = Path(batch) / "tracking-wandb" / self.path.name / "state.json" + self.metadata = read_json(self.path / "run.json") + self.settings = settings + identity = { + "batch": Path(batch).name, + "name": self.path.name, + "spec": public_config(self.metadata.get("spec", {})), + "world_sha256": self.metadata.get("world_sha256"), + "initial_model_sha256": self.metadata.get("initial_model_sha256"), + } + fingerprint = hashlib.sha256(json.dumps(identity, sort_keys=True).encode()).hexdigest() + saved = read_json(self.state_path) if self.state_path.exists() else {} + if saved: + assert saved["fingerprint"] == fingerprint, "Source trajectory identity changed" + assert saved["entity"] == settings["entity"] and saved["project"] == settings["project"] + self.state = { + "run_id": fingerprint[:16], + "fingerprint": fingerprint, + "entity": settings["entity"], + "project": settings["project"], + "last_logged_step": -1, + **saved, + } + options = {"disable_git": True} + if not settings["system_metrics"]: + options["x_disable_stats"] = True + else: + if "gpu" in self.metadata: + options["x_stats_gpu_device_ids"] = (self.metadata["gpu"],) + if "pid" in self.metadata: + options["x_stats_pid"] = self.metadata["pid"] + mode = settings["mode"] + run_id = self.state["run_id"] + if mode == "offline" and saved: + segment = saved.get("offline_segment", 0) + 1 + self.state["offline_segment"] = segment + run_id = f"{run_id[:12]}{segment:04x}" + self.state_path.parent.mkdir(parents=True, exist_ok=True) + config = { + **identity, + "scientific_run_id": self.state["run_id"], + **{ + k: self.metadata[k] + for k in [ + "model", + "phase", + "evaluation_nodes", + "execution_lock_sha256", + "parameters", + "vocab_size", + "atomic_examples", + "composition_examples", + "dtype", + "gpu_name", + ] + if k in self.metadata + }, + } + self.run = sdk.init( + entity=settings["entity"], + project=settings["project"], + group=self.metadata.get("tracking_group", Path(batch).name), + name=self.path.name, + id=run_id, + config=config, + mode=mode, + resume="allow" if mode == "online" else None, + job_type=self.metadata.get("job_type", "training"), + tags=self.metadata.get("tags", []), + dir=str(self.state_path.parent), + save_code=False, + reinit="create_new", + settings=sdk.Settings(**options), + ) + self.run.define_metric("training/step") + self.run.define_metric("*", step_metric="training/step") + if mode == "online": + # The public history is authoritative: an SDK restart can briefly report step 0, + # and a local cursor can include points queued before a network interruption. + remote = sdk.Api(timeout=30).run(f"{settings['entity']}/{settings['project']}/{run_id}") + self.cursor = remote.lastHistoryStep + else: + self.cursor = self.state["last_logged_step"] + self.state.update(url=self.run.url, mode=mode, wandb_run_id=run_id) + write_json(self.state_path, self.state) + + def poll(self): + history = read_json(self.path / "learning.json") + previous = None + for record in history: + step = int(record["step"]) + if step > self.cursor: + self.run.log(learning_metrics(record, previous), step=step) + self.cursor = step + self.state["last_logged_step"] = step + write_json(self.state_path, self.state) + previous = record + status_path = self.path / "status.json" + if status_path.exists(): + status = read_json(status_path) + self.run.summary["training_state"] = status.get("state", "unknown") + complete = (self.path / "complete.json").exists() + failure_record = (self.path / "failure.json").exists() or ( + self.path / "failure-detail.json" + ).exists() + failed = failure_record and not complete + self.run.summary["has_failure_record"] = failure_record + self.run.summary["independently_reloaded"] = (self.path / "audit.json").exists() + if complete or failed: + self.run.summary["scientific_final_step"] = self.cursor + self.run.finish(exit_code=1 if failed else 0) + return True + return False + + def close(self): + self.run.finish() + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, required=True) + parser.add_argument("--runs-dir", type=Path) + parser.add_argument("--defaults", type=Path, default=DEFAULTS) + parser.add_argument("--entity") + parser.add_argument("--project") + parser.add_argument("--mode", choices=["online", "offline"]) + parser.add_argument("--once", action="store_true") + parser.add_argument("--detach", action="store_true") + args = parser.parse_args() + settings = read_json(args.defaults) + for name in ["entity", "project", "mode"]: + settings[name] = ( + getattr(args, name) or os.environ.get(f"WANDB_{name.upper()}") or settings[name] + ) + if not settings["enabled"]: + raise SystemExit("Experiment tracking is disabled in the selected defaults") + local = args.root / "tracking-wandb" + local.mkdir(parents=True, exist_ok=True) + if args.detach: + metadata_path = local / "process.json" + if metadata_path.exists(): + pid = read_json(metadata_path)["pid"] + try: + os.kill(pid, 0) + except ProcessLookupError: + pass + else: + raise SystemExit(f"Tracking process already running: {pid}") + arguments = [a for a in sys.argv[1:] if a != "--detach"] + command = [ + sys.executable, + "-u", + "-m", + "llm_memory_editability.experiment_tracking", + *arguments, + ] + with (local / "tracker.log").open("a") as log: + process = subprocess.Popen( + command, stdout=log, stderr=subprocess.STDOUT, start_new_session=True + ) + write_json(metadata_path, {"pid": process.pid, "command": command}) + print(json.dumps({"tracker_pid": process.pid, "log": str(local / "tracker.log")})) + return + try: + sdk = importlib.import_module("wandb") + except ImportError as error: + raise SystemExit("Install the tracking extra, or use .venv-wandb/bin/python") from error + with (local / "tracker.lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + active, finished = {}, set() + runs_dir = args.runs_dir or args.root / "development" + try: + while True: + for path in sorted(runs_dir.glob("*")): + if path in active or path in finished: + continue + if not (path / "run.json").exists() or not (path / "learning.json").exists(): + continue + active[path] = ArtifactRunTracker(sdk, args.root, path, settings) + print(json.dumps({"run": path.name, "url": active[path].run.url}), flush=True) + for path, tracker in list(active.items()): + current = read_json(path / "run.json") + if current.get("pid") != tracker.metadata.get("pid"): + tracker.close() + tracker = ArtifactRunTracker(sdk, args.root, path, settings) + active[path] = tracker + if tracker.poll(): + finished.add(path) + del active[path] + if args.once: + break + manifest = args.root / "controller-state.json" + if manifest.exists() and not active: + if read_json(manifest).get("state") in {"complete", "finished_with_failures"}: + break + time.sleep(settings["poll_seconds"]) + finally: + for tracker in active.values(): + tracker.close() + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiments.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiments.py new file mode 100644 index 0000000000000000000000000000000000000000..21513c79efc2f2e137213ca20f5444209e6d313d --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/experiments.py @@ -0,0 +1,39 @@ +"""Deterministic analytical illustration from the supplied research memo.""" + +import platform +from typing import Any + +import numpy as np + +from .low_rank import evaluate_update + + +def run_minimal_example(rank: int = 1, atol: float = 1e-10) -> dict[str, Any]: + """Compare a shared-rule update with a one-entry exception. + + At rank budget one, both changes have rank-one deltas but only the rule's + target is representable. At budget two, both targets are representable. + This is a classical matrix fact, not evidence of LLM editing difficulty. + """ + original = np.ones((2, 2), dtype=float) + cases = { + "original": evaluate_update(original, original, rank, atol), + "rule": evaluate_update(original, 2 * original, rank, atol), + "exception": evaluate_update(original, [[2, 1], [1, 1]], rank, atol), + } + return { + "experiment": "minimal_low_rank", + "scope": ( + "Analytical SVD illustration for fully observed real matrices with a " + "fixed total rank budget and unweighted Frobenius error. No training, " + "optimization path, or Transformer editing is evaluated. Numerical " + "rank counts singular values greater than an absolute tolerance; " + "this example does not validate the broader research hypothesis." + ), + "parameters": { + "rank_budget": cases["original"]["rank_budget"], + "atol": cases["original"]["atol"], + }, + "versions": {"python": platform.python_version(), "numpy": np.__version__}, + "cases": cases, + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..6bb93ea353cb12f972942a3cf658bc6593f81bb7 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth.py @@ -0,0 +1,431 @@ +"""Small GPT-2 composition learning, adapted from Wang et al. (NeurIPS 2024). + +Data/target conventions follow GrokkedTransformer commit 734ca654ec7a71dd6737d640407fac14491d538c. +The compact vocabulary, widths and data sizes are explicit experimental adaptations. +CUDA Graph capture is an execution optimization, not a change to the training objective. +""" + +from __future__ import annotations + +import copy +import hashlib +import json +import math +import time +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import CausalLM, ModelConfig, matmul_flops + + +def utc(): + return datetime.now(timezone.utc).isoformat() + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + tmp = path.with_suffix(path.suffix + ".tmp") + tmp.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n") + tmp.replace(path) + + +class SmallGPT(CausalLM): + """GPT-2 pre-LN, tied output, learned positions, GELU, standard dropout.""" + + def __init__(self, config, dropout=0.1): + super().__init__(config) + self.dropout = dropout + + def forward(self, tokens, positions=None): + p = self.dropout if self.training else 0.0 + x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device)) + x = F.dropout(x, p=p, training=self.training) + for block in self.blocks: + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=p, + ) + y = a.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + F.dropout(y, p=p, training=self.training) + x = x + F.dropout(block.mlp(block.ln2(x)), p=p, training=self.training) + x = self.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + return F.linear(x, self.token.weight) + + +def pack_rows(rows): + """Right-pad; supervise tail and EOS only. No BOS or answer delimiter.""" + rows = np.asarray(rows, dtype=np.int64) + x = np.zeros((len(rows), 4), dtype=np.int64) + x[:, : rows.shape[1]] = rows + positions = np.tile([rows.shape[1] - 2, rows.shape[1] - 1], (len(rows), 1)) + labels = np.c_[rows[:, -1], np.ones(len(rows), dtype=np.int64)] + return x, positions, labels + + +def make_optimizer(model, lr, weight_decay): + decay = [p for p in model.parameters() if p.ndim >= 2] + no_decay = [p for p in model.parameters() if p.ndim < 2] + return torch.optim.AdamW( + [ + {"params": decay, "weight_decay": weight_decay}, + {"params": no_decay, "weight_decay": 0.0}, + ], + lr=lr, + betas=(0.9, 0.999), + eps=1e-8, + fused=True, + capturable=True, + ) + + +class GraphStep: + """Capture complete AdamW step and undo warmup without rebinding state tensors.""" + + def __init__(self, model, optimizer, table, batch_size, clip=1.0): + self.index = torch.zeros(batch_size, dtype=torch.long, device=table[0].device) + self.model, self.optimizer, self.table, self.clip = model, optimizer, table, clip + weights = {k: v.detach().clone() for k, v in model.state_dict().items()} + state = { + p: { + k: v.detach().clone() if torch.is_tensor(v) else copy.deepcopy(v) + for k, v in s.items() + } + for p, s in optimizer.state.items() + } + cpu_rng = torch.get_rng_state() + cuda_rng = torch.cuda.get_rng_state(table[0].device) + torch.cuda.synchronize() + stream = torch.cuda.Stream() + stream.wait_stream(torch.cuda.current_stream()) + with torch.cuda.stream(stream): + for _ in range(3): + self.eager() + torch.cuda.current_stream().wait_stream(stream) + torch.cuda.synchronize() + self.graph = torch.cuda.CUDAGraph() + with torch.cuda.graph(self.graph): + self.loss, self.grad_norm = self.eager() + torch.cuda.synchronize() + with torch.no_grad(): + for k, v in model.state_dict().items(): + v.copy_(weights[k]) + for param, values in optimizer.state.items(): + before = state.get(param, {}) + for k, v in values.items(): + if torch.is_tensor(v): + if k in before: + v.copy_(before[k]) + else: + v.zero_() + for p in model.parameters(): + if p.grad is not None: + p.grad.zero_() + torch.set_rng_state(cpu_rng) + torch.cuda.set_rng_state(cuda_rng, table[0].device) + + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, pos, labels = (t[self.index] for t in self.table) + logits = self.model(x, positions=pos) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten()) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + def __call__(self, indices): + self.index.copy_(indices) + self.graph.replay() + return self.loss + + +class EpochStream: + """Uniform shuffled epochs of the combined atomic/composite training set.""" + + def __init__(self, size, seed): + self.size = size + self.rng = np.random.default_rng(seed) + self.remaining = np.empty(0, dtype=np.int64) + + def take(self, n): + parts = [] + while n: + if not len(self.remaining): + self.remaining = self.rng.permutation(self.size) + count = min(n, len(self.remaining)) + parts.append(self.remaining[:count]) + self.remaining = self.remaining[count:] + n -= count + return np.concatenate(parts) + + def state_dict(self): + return { + "size": self.size, + "rng": self.rng.bit_generator.state, + "remaining": self.remaining.copy(), + } + + def load_state_dict(self, state): + assert state["size"] == self.size + self.rng.bit_generator.state = state["rng"] + self.remaining = state["remaining"].copy() + + +@torch.no_grad() +def evaluate_rows(model, rows, device, batch_size=1024): + model.eval() + packed = pack_rows(rows) + answers, stops, losses = [], [], [] + for start in range(0, len(rows), batch_size): + x, pos, labels = ( + torch.as_tensor(t[start : start + batch_size], device=device) for t in packed + ) + logits = model(x, pos) + losses.append( + F.cross_entropy(logits.flatten(0, 1), labels.flatten(), reduction="none") + .view(-1, 2) + .cpu() + .numpy() + ) + answer = logits[:, 0].argmax(-1) + # Actual generated answer is fed back when producing EOS. + x[torch.arange(len(x), device=device), pos[:, 1]] = answer + stop = model(x, pos)[:, 1].argmax(-1) + answers.append(answer.cpu().numpy()) + stops.append(stop.cpu().numpy()) + model.train() + if not len(rows): + return {"n": 0, "answer_accuracy": None, "accuracy": None, "nll": None}, {} + answer, stop, nll = np.concatenate(answers), np.concatenate(stops), np.concatenate(losses) + correct = answer == rows[:, -1] + return { + "n": len(rows), + "answer_accuracy": float(correct.mean()), + "accuracy": float((correct & (stop == 1)).mean()), + "nll": float(nll.mean()), + }, {"answer": answer, "stop": stop, "nll": nll, "target": rows[:, -1]} + + +@torch.no_grad() +def two_calls(model, rows, device): + if not len(rows): + return {"n": 0, "answer_accuracy": None, "accuracy": None, "nll": None} + first = np.c_[rows[:, :2], np.zeros(len(rows), dtype=np.int64)] + _, first_pred = evaluate_rows(model, first, device) + second = np.c_[first_pred["answer"], rows[:, 2], rows[:, 3]] + result, second_pred = evaluate_rows(model, second, device) + result["accuracy"] = float( + ( + (second_pred["answer"] == rows[:, -1]) + & (second_pred["stop"] == 1) + & (first_pred["stop"] == 1) + ).mean() + ) + return result + + +def source_hash(paths): + return {str(p): hashlib.sha256(Path(p).read_bytes()).hexdigest() for p in paths} + + +def run(spec, world, out, device="cuda:0", resume=False): + """Run a fixed scientific budget. Intermediate evaluations never change training.""" + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.manual_seed(spec["initialization"]) + torch.cuda.manual_seed_all(spec["initialization"]) + device = torch.device(device) + torch.cuda.set_device(device) + cfg = ModelConfig( + vocab_size=2 + spec["entities"] + spec["relations"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=8, + ) + model = SmallGPT(cfg, spec["dropout"]).to(device) + lr = torch.tensor(spec["lr"], dtype=torch.float32, device=device) + opt = make_optimizer(model, lr, spec["weight_decay"]) + atoms, comps = pack_rows(world["atomic"]), pack_rows(world["train_composite"]) + table = tuple( + torch.as_tensor(np.concatenate([a, c]), device=device) + for a, c in zip(atoms, comps, strict=True) + ) + stream = EpochStream(len(table[0]), spec["stream_seed"]) + counts = {"atomic": 0, "composite": 0} + elapsed_training, elapsed_eval = 0.0, 0.0 + start_step = 0 + checkpoint = out / "latest.pt" + if resume: + state = torch.load(checkpoint, map_location=device, weights_only=False) + assert state["spec"] == spec + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + # load_state_dict replaces the LR tensor; retain the optimizer's live tensor. + lr = opt.param_groups[0]["lr"] + for group in opt.param_groups: + group["lr"] = lr + stream.load_state_dict(state["stream"]) + counts = state["counts"] + elapsed_training = state["elapsed_training"] + elapsed_eval = state["elapsed_eval"] + start_step = state["step"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + started = time.perf_counter() + graph = GraphStep(model, opt, table, spec["batch_size"]) + capture_seconds = time.perf_counter() - started + names = ("atomic", "train_composite", "test_composite", "ood_composite") + nparams = sum(p.numel() for p in model.parameters()) + flop_step = matmul_flops(cfg, spec["batch_size"], sequence=4, output_positions=2) + rows_log = [] + if (out / "learning.json").exists(): + rows_log = json.loads((out / "learning.json").read_text()) + if resume: + # A crash can leave a log newer than the atomically replaced checkpoint. + rows_log = list({r["step"]: r for r in rows_log if r["step"] <= start_step}.values()) + rows_log.sort(key=lambda r: r["step"]) + if start_step == spec["steps"]: + endpoint = rows_log[-1] + write_json( + out / "complete.json", + { + "finished_utc": utc(), + "spec": spec, + "parameters": nparams, + "training_seconds": elapsed_training, + "evaluation_seconds": elapsed_eval, + "endpoint": endpoint, + "completion_recovered_from_final_checkpoint": True, + }, + ) + write_json( + out / "status.json", + { + "state": "complete", + "step": start_step, + "budget": spec["steps"], + "updated_utc": utc(), + "atomic": endpoint["atomic"]["accuracy"], + "train": endpoint["train_composite"]["accuracy"], + "test": endpoint["test_composite"]["accuracy"], + }, + ) + return rows_log[-1] + + def measure(step, last_loss=None): + nonlocal elapsed_eval + torch.cuda.synchronize() + t0 = time.perf_counter() + row = { + "step": step, + "utc": utc(), + "parameters": nparams, + "training_seconds": elapsed_training, + "capture_seconds": capture_seconds, + "examples": step * spec["batch_size"], + "counts": counts.copy(), + "effective_input_tokens": counts["atomic"] * 3 + counts["composite"] * 4, + "supervised_tokens": step * spec["batch_size"] * 2, + "estimated_training_flops": step * flop_step, + "last_batch_loss": last_loss, + } + predictions = {} + for name in names: + row[name], pred = evaluate_rows(model, world[name], device) + predictions.update({name + "_" + k: v for k, v in pred.items()}) + row["two_calls"] = two_calls(model, world["test_composite"], device) + torch.cuda.synchronize() + elapsed_eval += time.perf_counter() - t0 + row["evaluation_seconds"] = elapsed_eval + rows_log.append(row) + write_json(out / "learning.json", rows_log) + np.savez_compressed(out / f"predictions-{step:07d}.npz", **predictions) + state = { + "step": step, + "spec": spec, + "model": model.state_dict(), + "optimizer": opt.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "elapsed_training": elapsed_training, + "elapsed_eval": elapsed_eval, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(checkpoint) + if step in spec["weight_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"weights-{step:07d}.pt", + ) + status = { + "state": "complete" if step == spec["steps"] else "running", + "step": step, + "budget": spec["steps"], + "updated_utc": utc(), + "atomic": row["atomic"]["accuracy"], + "train": row["train_composite"]["accuracy"], + "test": row["test_composite"]["accuracy"], + } + write_json(out / "status.json", status) + print(json.dumps(status), flush=True) + return row + + if not resume: + measure(0) + nodes = [s for s in spec["nodes"] if s > start_step] + for end in nodes: + last_loss = None + torch.cuda.synchronize() + t0 = time.perf_counter() + step = start_step + while step < end: + n = min(512, end - step) + ix = stream.take(n * spec["batch_size"]).reshape(n, spec["batch_size"]) + atom_count = int((ix < len(world["atomic"])).sum()) + counts["atomic"] += atom_count + counts["composite"] += ix.size - atom_count + gpu_ix = torch.as_tensor(ix, device=device) + for j in range(n): + lr.fill_(spec["lr"] * min(1.0, (step + j + 1) / spec["warmup"])) + last_loss = graph(gpu_ix[j]) + step += n + torch.cuda.synchronize() + elapsed_training += time.perf_counter() - t0 + loss_value = float(last_loss.detach()) + if not math.isfinite(loss_value): + raise FloatingPointError(f"Nonfinite loss at step {end}") + row = measure(end, loss_value) + start_step = end + write_json( + out / "complete.json", + { + "finished_utc": utc(), + "spec": spec, + "parameters": nparams, + "training_seconds": elapsed_training, + "evaluation_seconds": elapsed_eval, + "endpoint": row, + }, + ) + return row diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_bridge.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..ca05be9fcd170cee34075ae1aa2fa0c2bcca1e2c --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_bridge.py @@ -0,0 +1,631 @@ +"""Prefix-only causal interventions on frozen grok-depth-v1 checkpoints. + +Donors are selected from world facts before any model is loaded. The only donor +input is its two-token atomic query; second relations and answers never enter the +forward pass that supplies the post-first-block residual state. +""" + +from __future__ import annotations + +import hashlib +import importlib +import json +import platform +import sys +import time +import types +from collections import Counter +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +CONDITIONS = ( + "baseline", + "identity_r1", + "different_bridge_r1", + "same_bridge_r1", + "different_bridge_h", + "different_bridge_h_r1", + "counterfactual_input", +) +DATA_FIELDS = ("entities", "relations", "degree", "phi", "id_fraction", "id_test_fraction") + + +def utc(): + return datetime.now(timezone.utc).isoformat() + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def read_json(path): + return json.loads(Path(path).read_text()) + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n") + temporary.replace(path) + + +def require(condition, message): + if not condition: + raise AssertionError(message) + + +def _frozen_modules(source_dir, metadata): + """Verify all historical copies, then import exclusively from that snapshot.""" + snapshot = source_dir / "source" + copied = {p.relative_to(snapshot).as_posix(): p for p in snapshot.rglob("*") if p.is_file()} + verified = {} + for original, expected in metadata["files"].items(): + matches = [ + p for rel, p in copied.items() if original == rel or original.endswith("/" + rel) + ] + require(len(matches) == 1, f"missing or ambiguous historical copy: {original}") + path = matches[0] + actual = digest(path) + require(actual == expected, f"historical source hash mismatch: {path}") + verified[path.relative_to(snapshot).as_posix()] = actual + configs = [snapshot / p for p in verified if p.startswith("configs/")] + require(len(configs) == 1, "expected exactly one frozen configuration") + frozen = read_json(configs[0]) + require( + {**frozen["base"], **frozen["runs"][source_dir.name]} == metadata["spec"], + "historical metadata differs from its frozen configuration", + ) + package = "_grok_bridge_source_" + hashlib.sha256(str(source_dir).encode()).hexdigest()[:16] + namespace = types.ModuleType(package) + namespace.__path__ = [str(snapshot / "src/llm_memory_editability")] + sys.modules[package] = namespace + training = importlib.import_module(package + ".grok_depth") + data = importlib.import_module(package + ".grok_depth_data") + return training, data, verified + + +def load_source_run(source_dir, step, device="cuda:0"): + """Return a frozen model/world after source, world and checkpoint consistency checks.""" + source_dir = Path(source_dir).resolve() + metadata = read_json(source_dir / "metadata.json") + spec = metadata["spec"] + require(spec["phase"] == source_dir.parent.name, "historical phase/path mismatch") + training, data, verified = _frozen_modules(source_dir, metadata) + require(step in spec["weight_nodes"], f"unregistered historical weight node {step}") + checkpoint_path = source_dir / f"weights-{step:07d}.pt" + checkpoint_hash = digest(checkpoint_path) + checkpoint = torch.load(checkpoint_path, map_location="cpu", weights_only=False) + require( + checkpoint["spec"] == spec and checkpoint["step"] == step, "checkpoint identity mismatch" + ) + require(digest(checkpoint_path) == checkpoint_hash, "checkpoint changed while loading") + if step == spec["steps"]: + latest = torch.load(source_dir / "latest.pt", map_location="cpu", weights_only=False) + require( + latest["step"] == step and latest["spec"] == spec, "latest checkpoint identity mismatch" + ) + require( + checkpoint["model"].keys() == latest["model"].keys() + and all(torch.equal(v, latest["model"][k]) for k, v in checkpoint["model"].items()), + "endpoint weights differ from latest checkpoint", + ) + del latest + world_path = source_dir / "world.npz" + world_hash = digest(world_path) + with np.load(world_path, allow_pickle=False) as stored: + world = {key: stored[key].copy() for key in stored.files} + world["metadata"] = read_json(source_dir / "world-metadata.json") + require(digest(world_path) == world_hash, "world changed while loading") + audit = data.audit_world(world) + require(audit == read_json(source_dir / "data-audit.json"), "historical world audit mismatch") + require( + audit["dataset_sha256"] == world["metadata"]["dataset_sha256"], + "world content hash mismatch", + ) + rebuilt = data.build_world(spec["world_seed"], **{key: spec[key] for key in DATA_FIELDS}) + require(rebuilt["metadata"] == world["metadata"], "regenerated world metadata mismatch") + for key, array in world.items(): + if key != "metadata": + require(np.array_equal(array, rebuilt[key]), f"regenerated world mismatch: {key}") + cfg = training.ModelConfig( + vocab_size=2 + spec["entities"] + spec["relations"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=8, + ) + model = training.SmallGPT(cfg, spec["dropout"]).to(device) + model.load_state_dict(checkpoint["model"], strict=True) + model.eval() + for parameter in model.parameters(): + parameter.requires_grad_(False) + provenance = { + "source_dir": str(source_dir), + "source_hashes": verified, + "checkpoint_sha256": checkpoint_hash, + "world_file_sha256": world_hash, + "dataset_sha256": audit["dataset_sha256"], + "world_audit": audit, + "source_metadata_sha256": digest(source_dir / "metadata.json"), + "source_predictions_sha256": digest(source_dir / f"predictions-{step:07d}.npz"), + "world_regenerated_identically": True, + } + return model, world, spec, provenance + + +def _choose(candidates, world_hash, seed, row, kind): + """Content-based uniform deterministic selection; no model input is accepted.""" + if not candidates: + return None + material = json.dumps([world_hash, int(seed), list(map(int, row)), kind], separators=(",", ":")) + rng = np.random.default_rng( + int.from_bytes(hashlib.sha256(material.encode()).digest()[:16], "big") + ) + return sorted(candidates)[int(rng.integers(len(candidates)))] + + +def select_donors(world, seed): + """Select once per test row; preserve all rows, masks and rejection counts. + + Different-bridge candidates share r1, change h/b/t, have ID second facts, + and yield a reserved-test or unused counterfactual. Same-bridge candidates + may change r1; only their bridge, query distinctness and h != original t + matter. No candidate is selected using model behavior. + """ + rows = world["test_composite"] + n = len(rows) + atoms = {tuple(map(int, row)) for row in world["id_atomic"]} + lookup = {(h, r): t for h, r, t in atoms} + held_out = { + tuple(map(int, row)) + for name in ("test_composite", "unused_composite") + for row in world[name] + } + training = {tuple(map(int, row)) for row in world["train_composite"]} + world_hash = world["metadata"]["dataset_sha256"] + out = { + "original_rows": rows.copy(), + "original_bridge": np.full(n, -1, dtype=np.int64), + "different_donor": np.full((n, 3), -1, dtype=np.int64), + "same_donor": np.full((n, 3), -1, dtype=np.int64), + "counterfactual_rows": np.full((n, 4), -1, dtype=np.int64), + "different_valid": np.zeros(n, dtype=bool), + "same_valid": np.zeros(n, dtype=bool), + "different_reason": np.full(n, "", dtype="U64"), + "same_reason": np.full(n, "", dtype="U64"), + "different_candidate_count": np.zeros(n, dtype=np.int64), + "same_candidate_count": np.zeros(n, dtype=np.int64), + "same_relation_control": np.full(n, "missing", dtype="U24"), + "different_nondegenerate": np.zeros(n, dtype=bool), + } + rejection_names = ( + "same_head", + "same_bridge", + "missing_id_second_fact", + "same_tail", + "head_is_answer", + "counterfactual_in_train", + "counterfactual_not_held_out", + ) + for reason in rejection_names: + out["different_rejected_" + reason] = np.zeros(n, dtype=np.int64) + for index, row in enumerate(rows): + h, r1, r2, tail = map(int, row) + bridge = lookup[h, r1] + require(lookup.get((bridge, r2)) == tail, "recipient is not an ID-ID chain") + out["original_bridge"][index] = bridge + candidates = [] + for dh, dr, db in sorted(atoms): + if dr != r1: + continue + dt = lookup.get((db, r2)) + cf = (dh, r1, r2, dt) + reason = ( + "same_head" + if dh == h + else "same_bridge" + if db == bridge + else "missing_id_second_fact" + if dt is None + else "same_tail" + if dt == tail + else "head_is_answer" + if dh in (tail, dt) + else "counterfactual_in_train" + if cf in training + else "counterfactual_not_held_out" + if cf not in held_out + else None + ) + if reason: + out["different_rejected_" + reason][index] += 1 + else: + candidates.append((dh, dr, db, dt)) + donor = _choose(candidates, world_hash, seed, row, "different") + out["different_candidate_count"][index] = len(candidates) + if donor is None: + out["different_reason"][index] = "no_candidate_after_registered_exclusions" + else: + dh, dr, db, dt = donor + out["different_donor"][index] = dh, dr, db + out["counterfactual_rows"][index] = dh, r1, r2, dt + out["different_valid"][index] = True + out["different_reason"][index] = "eligible" + out["different_nondegenerate"][index] = db != dt and db != tail + candidates = [ + (dh, dr, db) + for dh, dr, db in atoms + if db == bridge and (dh, dr) != (h, r1) and dh != tail + ] + same_relation = [candidate for candidate in candidates if candidate[1] == r1] + donor = _choose(same_relation or candidates, world_hash, seed, row[:2], "same") + out["same_candidate_count"][index] = len(candidates) + if donor is None: + out["same_reason"][index] = "no_distinct_id_prefix_with_same_bridge_and_head_not_answer" + else: + out["same_donor"][index] = donor + out["same_valid"][index] = True + out["same_reason"][index] = "eligible" + out["same_relation_control"][index] = "same_r1" if donor[1] == r1 else "different_r1" + return out + + +@torch.no_grad() +def traced_forward( + model, + tokens, + positions=None, + donor_state=None, + patch_positions=(), + identity=False, + return_state=False, +): + """Frozen SmallGPT eval forward, replacing residuals after complete block 0. + + Both attention and MLP in the first block run before replacement. There is + no patch in another block, and final LN/output projection remain untouched. + """ + require(not model.training, "interventions require model.eval()") + require( + donor_state is None or not identity, "identity and donor patches are mutually exclusive" + ) + x = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=tokens.device)) + first_state = None + for index, block in enumerate(model.blocks): + z = block.ln1(x) + batch, length, width = z.shape + attention = block.attention + q, k, v = ( + attention.qkv(z) + .view(batch, length, 3, attention.heads, width // attention.heads) + .unbind(2) + ) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2), is_causal=True, dropout_p=0.0 + ) + y = attention.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + y + x = x + block.mlp(block.ln2(x)) + if index == 0: + if return_state: + first_state = x.clone() + if donor_state is not None or identity: + x = x.clone() + replacement = x.clone() if identity else donor_state + for position in patch_positions: + x[:, position, :] = replacement[:, position, :] + x = model.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + logits = F.linear(x, model.token.weight) + return (logits, first_state) if return_state else logits + + +@torch.no_grad() +def prefix_state(model, prefixes): + """Two informative tokens, padded to the historical four-position shape. + + Both suffix tokens are the fixed PAD token, never a relation or answer. + Causality makes the retained two states independent of these suffixes. + Matching the matrix shapes avoids TF32 kernel-dependent rounding changes. + """ + require(prefixes.ndim == 2 and prefixes.shape[1] == 2, "expected h/r1 prefixes") + padded = F.pad(prefixes, (0, 2), value=0) + _, state = traced_forward(model, padded, return_state=True) + return state[:, :2] + + +@torch.no_grad() +def evaluate_condition( + model, + rows, + device, + batch_size=1024, + donor_prefixes=None, + patch_positions=(), + identity=False, + verify_trace=False, +): + """Answer generation followed by EOS with the generated answer fed back. + + The exact same prefix state is reapplied on the second forward pass. Arrays + are local to the supplied rows; the caller scatters them to the full test set. + """ + n = len(rows) + answers, stops, original_logits = [], [], [] + trace_max_delta, trace_disagreements = 0.0, 0 + prefix_max_delta = 0.0 + for start in range(0, n, batch_size): + selected = rows[start : start + batch_size] + arity = rows.shape[1] + require(arity in (3, 4), "expected atomic or composite rows") + packed = np.zeros((len(selected), 4), dtype=np.int64) + packed[:, :arity] = selected + x = torch.as_tensor(packed, device=device) + pos = torch.as_tensor(np.tile([arity - 2, arity - 1], (len(x), 1)), device=device) + donor_state = None + if donor_prefixes is not None: + prefixes = torch.as_tensor(donor_prefixes[start : start + batch_size], device=device) + require(prefixes.shape == (len(x), 2), "donor model may receive only h and r1") + donor_state = prefix_state(model, prefixes) + logits = traced_forward(model, x, pos, donor_state, patch_positions, identity) + if verify_trace: + reference = model(x, pos) + trace_max_delta = max(trace_max_delta, float((reference - logits).abs().max())) + trace_disagreements += int((reference.argmax(-1) != logits.argmax(-1)).sum()) + prefix = prefix_state(model, x[:, :2]) + _, whole = traced_forward(model, x, return_state=True) + prefix_max_delta = max(prefix_max_delta, float((prefix - whole[:, :2]).abs().max())) + require( + torch.allclose(prefix, whole[:, :2], atol=1e-4, rtol=1e-4), + "pure-prefix state does not match causal full-input prefix", + ) + answer = logits[:, 0].argmax(-1) + original_logits.append(logits[:, 0].cpu().numpy()) + x[:, arity - 1] = answer + generated_logits = traced_forward(model, x, pos, donor_state, patch_positions, identity) + if verify_trace: + reference = model(x, pos) + trace_max_delta = max( + trace_max_delta, float((reference - generated_logits).abs().max()) + ) + trace_disagreements += int((reference.argmax(-1) != generated_logits.argmax(-1)).sum()) + answers.append(answer.cpu().numpy()) + stops.append(generated_logits[:, 1].argmax(-1).cpu().numpy()) + require(trace_disagreements == 0, "traced forward changes standard-forward discrete outputs") + require(trace_max_delta <= 1e-5, f"traced forward mismatch: {trace_max_delta}") + return { + "answer": np.concatenate(answers) if n else np.empty(0, dtype=np.int64), + "stop": np.concatenate(stops) if n else np.empty(0, dtype=np.int64), + "answer_logits": np.concatenate(original_logits) + if n + else np.empty((0, model.token.num_embeddings), dtype=np.float32), + }, { + "standard_forward_max_logit_delta": trace_max_delta, + "standard_forward_argmax_disagreements": trace_disagreements, + "prefix_vs_full_first_block_max_delta": prefix_max_delta, + "trace_comparison_performed": verify_trace, + } + + +def _metrics(answer, stop, original, cf, selected, cf_valid, total, baseline_answer): + count = int(selected.sum()) + counterfactual = selected & cf_valid + ncf = int(counterfactual.sum()) + correct = answer == original + cf_correct = answer == cf + return { + "n": count, + "total_test_n": total, + "coverage": count / total if total else None, + "original_answer_accuracy": float(correct[selected].mean()) if count else None, + "original_complete_accuracy": float((correct & (stop == 1))[selected].mean()) + if count + else None, + "eos_accuracy": float((stop[selected] == 1).mean()) if count else None, + "answer_change_rate": float((answer[selected] != baseline_answer[selected]).mean()) + if count + else None, + "cf_target_n": ncf, + "cf_answer_accuracy": float(cf_correct[counterfactual].mean()) if ncf else None, + "cf_complete_accuracy": float((cf_correct & (stop == 1))[counterfactual].mean()) + if ncf + else None, + } + + +def evaluate_run(model, world, donors, device="cuda:0", batch_size=1024): + """Evaluate all fixed conditions, then expose full and prerequisite subgroups.""" + started = time.perf_counter() + rows = world["test_composite"] + n = len(rows) + different, same = donors["different_valid"], donors["same_valid"] + arrays = {key: value.copy() for key, value in donors.items()} + audits = {} + for condition in CONDITIONS: + mask = ( + same + if condition == "same_bridge_r1" + else different + if condition.startswith("different_") or condition == "counterfactual_input" + else np.ones(n, dtype=bool) + ) + eval_rows = ( + donors["counterfactual_rows"][mask] + if condition == "counterfactual_input" + else rows[mask] + ) + donor_key = "same_donor" if condition == "same_bridge_r1" else "different_donor" + donor_prefix = donors[donor_key][mask, :2] if "bridge_" in condition else None + positions = ( + (0, 1) + if condition == "different_bridge_h_r1" + else (0,) + if condition == "different_bridge_h" + else (1,) + ) + result, audit = evaluate_condition( + model, + eval_rows, + device, + batch_size, + donor_prefix, + positions, + condition == "identity_r1", + condition == "baseline", + ) + audits[condition] = audit + answer = np.full(n, -1, dtype=np.int64) + stop = np.full(n, -1, dtype=np.int64) + answer[mask], stop[mask] = result["answer"], result["stop"] + arrays[condition + "_answer"], arrays[condition + "_stop"] = answer, stop + arrays[condition + "_valid"] = mask + original_logit = result["answer_logits"][np.arange(mask.sum()), rows[mask, -1]] + cf_logit = np.full(n, np.nan, dtype=np.float32) + cf_local = different[mask] + cf_logit[mask.nonzero()[0][cf_local]] = ( + result["answer_logits"][ + np.flatnonzero(cf_local), donors["counterfactual_rows"][mask][cf_local, -1] + ] + - original_logit[cf_local] + ) + arrays[condition + "_cf_minus_original_logit"] = cf_logit + for column in ("answer", "stop"): + require( + np.array_equal(arrays["baseline_" + column], arrays["identity_r1_" + column]), + f"identity patch changed {column}", + ) + if len(model.blocks) == 1: + for condition in ( + "different_bridge_r1", + "same_bridge_r1", + "different_bridge_h", + "different_bridge_h_r1", + ): + valid = arrays[condition + "_valid"] + require( + np.array_equal( + arrays["baseline_" + column][valid], arrays[condition + "_" + column][valid] + ), + f"one-layer structural negative control changed {condition}.{column}", + ) + baseline_correct = (arrays["baseline_answer"] == rows[:, -1]) & (arrays["baseline_stop"] == 1) + cf_correct = ( + different + & (arrays["counterfactual_input_answer"] == donors["counterfactual_rows"][:, -1]) + & (arrays["counterfactual_input_stop"] == 1) + ) + atomic_rows = { + "different_first": (donors["different_donor"], different), + "counterfactual_second": ( + np.c_[ + donors["different_donor"][:, 2], rows[:, 2], donors["counterfactual_rows"][:, -1] + ], + different, + ), + "same_first": (donors["same_donor"], same), + } + atomic_scores = {} + atomic_correct = {} + for name, (facts, mask) in atomic_rows.items(): + prediction, _ = evaluate_condition(model, facts[mask], device, batch_size) + answer = np.full(n, -1, dtype=np.int64) + stop = np.full(n, -1, dtype=np.int64) + answer[mask], stop[mask] = prediction["answer"], prediction["stop"] + arrays["atomic_" + name + "_rows"] = facts.copy() + arrays["atomic_" + name + "_answer"] = answer + arrays["atomic_" + name + "_stop"] = stop + arrays["atomic_" + name + "_valid"] = mask.copy() + correct = mask & (answer == facts[:, -1]) + atomic_correct[name] = correct & (stop == 1) + count = int(mask.sum()) + atomic_scores[name] = { + "n": count, + "total_test_n": n, + "coverage": count / n if n else None, + "answer_accuracy": float(correct[mask].mean()) if count else None, + "complete_accuracy": float(atomic_correct[name][mask].mean()) if count else None, + "eos_accuracy": float((stop[mask] == 1).mean()) if count else None, + } + groups = { + "all_test": np.ones(n, dtype=bool), + "different_donor_available": different, + "same_donor_available": same, + "baseline_and_counterfactual_complete_correct": baseline_correct & cf_correct, + "different_bridge_nondegenerate": donors["different_nondegenerate"], + "same_bridge_same_r1": same & (donors["same_relation_control"] == "same_r1"), + "same_bridge_different_r1": same & (donors["same_relation_control"] == "different_r1"), + "both_counterfactual_atomic_facts_complete_correct": atomic_correct["different_first"] + & atomic_correct["counterfactual_second"], + } + for group, mask in groups.items(): + arrays["subset_" + group] = mask + scores = { + group: { + "subset_n": int(mask.sum()), + "total_test_n": n, + "coverage": float(mask.mean()) if n else None, + "conditions": { + condition: _metrics( + arrays[condition + "_answer"], + arrays[condition + "_stop"], + rows[:, -1], + donors["counterfactual_rows"][:, -1], + mask & arrays[condition + "_valid"], + different, + n, + arrays["baseline_answer"], + ) + for condition in CONDITIONS + }, + } + for group, mask in groups.items() + } + summary = { + "conditions": list(CONDITIONS), + "scores": scores, + "atomic_preconditions": atomic_scores, + "donor_coverage": { + "total_test_n": n, + "different_n": int(different.sum()), + "same_n": int(same.sum()), + "different_reasons": dict(Counter(donors["different_reason"].tolist())), + "same_reasons": dict(Counter(donors["same_reason"].tolist())), + "same_relation_control": dict(Counter(donors["same_relation_control"].tolist())), + }, + "engineering_checks": { + "identity_predictions_equal": True, + "one_layer_all_early_position_patch_predictions_equal": True + if len(model.blocks) == 1 + else None, + "trace": audits["baseline"], + "eos_uses_generated_answer_and_reapplies_patch": True, + "donor_nonpadding_input_tokens": 2, + "donor_forward_sequence_length": 4, + "donor_pad_token": 0, + }, + "evaluation_seconds": time.perf_counter() - started, + } + return summary, arrays + + +def environment(device): + return { + "python": platform.python_version(), + "platform": platform.platform(), + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "device": str(device), + "gpu": torch.cuda.get_device_name(torch.device(device)) + if str(device).startswith("cuda") + else None, + "cuda_matmul_tf32": torch.backends.cuda.matmul.allow_tf32, + "cudnn_tf32": torch.backends.cudnn.allow_tf32, + "precision": "FP32 parameters and evaluation; TF32 flags recorded explicitly", + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_data.py new file mode 100644 index 0000000000000000000000000000000000000000..8696c3ffe204466f57619157a3f47739f899c6c4 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_depth_data.py @@ -0,0 +1,281 @@ +"""Symbolic composition worlds adapted from GrokkedTransformer/composition.ipynb. + +Source: https://github.com/OSU-NLP-Group/GrokkedTransformer +Revision: 734ca654ec7a71dd6737d640407fac14491d538c (MIT). + +The graph, atomic ID/OOD split, reserved ID test chains, and phi downsampling +follow the authors' construction. Differences: integer tokens replace text; +randomness is local and seeded; atomic ordering is stable; graph size and the +reserved ID-test fraction are configurable. Unselected ID chains are returned +for audit only. No graph is regenerated to improve OOD counts or model results. + +Adapted source license: +MIT License +Copyright (c) 2024 OSU Natural Language Processing + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +""" + +from __future__ import annotations + +import hashlib +import math + +import numpy as np + +PAD_TOKEN = 0 +EOS_TOKEN = 1 +ENTITY_OFFSET = 2 +SOURCE_URL = "https://github.com/OSU-NLP-Group/GrokkedTransformer" +SOURCE_COMMIT = "734ca654ec7a71dd6737d640407fac14491d538c" +ATOMIC_SPLITS = ("atomic", "id_atomic", "ood_atomic") +COMPOSITE_SPLITS = ( + "train_composite", + "test_composite", + "ood_composite", + "unused_composite", +) + + +def _array(rows: list, columns: int) -> np.ndarray: + return np.asarray(rows, dtype=np.int64).reshape(-1, columns) + + +def build_world( + seed: int, + entities: int = 128, + relations: int = 16, + degree: int = 8, + phi: float = 8.0, + id_fraction: float = 0.95, + id_test_fraction: float = 0.005, +) -> dict: + """Return atomic ``[h,r,t]`` and composite ``[h,r1,r2,t]`` int64 arrays. + + All atomics belong in training, including those labelled OOD. OOD refers + to *composition experience*: neither constituent of an OOD composite is + allowed in composite training. Mixed ID/OOD chains are excluded. The + test set is reserved before phi downsampling; unused ID chains are never + automatically reassigned to test. ``phi`` is relative to ID atomics, as in + the source. Requests larger than the available training pool are capped + and explicitly recorded. Empty test sets are retained and reported. + + Query tokens are every column except the last; the last is the entity + answer. EOS supervision, padding, and loss masks belong to the trainer. + """ + for name, value in (("entities", entities), ("relations", relations), ("degree", degree)): + if not isinstance(value, (int, np.integer)) or isinstance(value, bool) or value < 1: + raise ValueError(f"{name} must be a positive integer") + if degree > relations: + raise ValueError("degree cannot exceed relations") + if not math.isfinite(phi) or phi < 0: + raise ValueError("phi must be finite and nonnegative") + if not math.isfinite(id_fraction) or not 0 <= id_fraction <= 1: + raise ValueError("id_fraction must be in [0, 1]") + if not math.isfinite(id_test_fraction) or not 0 <= id_test_fraction <= 1: + raise ValueError("id_test_fraction must be in [0, 1]") + + # RandomState keeps the source's NumPy draw family, without global RNG use. + rng = np.random.RandomState(seed) + relation_offset = ENTITY_OFFSET + entities + rows = [] + outgoing = [[] for _ in range(entities)] + for head_index in range(entities): + selected = rng.choice(relations, size=degree, replace=False) + for relation_index in selected: + tail_index = int(rng.randint(entities)) + edge = ( + head_index + ENTITY_OFFSET, + int(relation_index) + relation_offset, + tail_index + ENTITY_OFFSET, + ) + outgoing[head_index].append(len(rows)) + rows.append(edge) + atomic = _array(rows, 3) + ood_count = round(len(atomic) * (1 - id_fraction)) + ood_mask = np.zeros(len(atomic), dtype=bool) + ood_mask[rng.choice(len(atomic), size=ood_count, replace=False)] = True + + eligible, test, ood = [], [], [] + mixed_count = 0 + for first_index, (head, relation1, bridge) in enumerate(atomic): + for second_index in outgoing[int(bridge) - ENTITY_OFFSET]: + _, relation2, tail = atomic[second_index] + row = (head, relation1, relation2, tail) + first_ood, second_ood = ood_mask[first_index], ood_mask[second_index] + if first_ood and second_ood: + ood.append(row) + elif first_ood or second_ood: + mixed_count += 1 + elif rng.uniform() > id_test_fraction: + eligible.append(row) + else: + test.append(row) + + requested_count = round(phi * int((~ood_mask).sum())) + train_count = min(requested_count, len(eligible)) + # Source choose() returns the full pool unchanged when it is saturated. + indices = ( + np.arange(len(eligible)) + if train_count == len(eligible) + else rng.choice(len(eligible), size=train_count, replace=False) + ) + eligible_array = _array(eligible, 4) + selected_mask = np.zeros(len(eligible), dtype=bool) + selected_mask[indices] = True + world = { + "atomic": atomic, + "id_atomic": atomic[~ood_mask], + "ood_atomic": atomic[ood_mask], + "train_composite": eligible_array[indices], + "test_composite": _array(test, 4), + "ood_composite": _array(ood, 4), + "unused_composite": eligible_array[~selected_mask], + "metadata": { + "seed": int(seed), + "entities": int(entities), + "relations": int(relations), + "degree": int(degree), + "phi_requested": float(phi), + "id_fraction": float(id_fraction), + "id_test_fraction": float(id_test_fraction), + "pad_token": PAD_TOKEN, + "eos_token": EOS_TOKEN, + "entity_offset": ENTITY_OFFSET, + "relation_offset": int(relation_offset), + "vocab_size": int(relation_offset + relations), + "train_composite_requested": int(requested_count), + "train_composite_capped": requested_count > len(eligible), + "phi_actual": train_count / max(int((~ood_mask).sum()), 1), + "mixed_composite_excluded": mixed_count, + "source_url": SOURCE_URL, + "source_commit": SOURCE_COMMIT, + "source_file": "composition.ipynb", + "source_license": "MIT", + "construction_differences": [ + "integer tokens and local seeded RNG", + "stable atomic ordering instead of Python set iteration", + "configurable graph size and ID-test reserve fraction", + "all evaluation rows retained instead of sampling at most 3000", + ], + }, + } + audit = audit_world(world) + world["metadata"]["counts"] = audit["counts"] + world["metadata"]["dataset_sha256"] = audit["dataset_sha256"] + world["metadata"]["warnings"] = audit["warnings"] + return world + + +def audit_world(world: dict) -> dict: + """Validate token ranges, graph truth, exhaustive partitions and no leakage. + + Raises ValueError on a broken contract; zero-sized test sets and capped + training pools are valid and surfaced as warnings, never resampled. + """ + metadata = world["metadata"] + entities, relations, degree = (int(metadata[x]) for x in ("entities", "relations", "degree")) + relation_offset = entities + ENTITY_OFFSET + digest = hashlib.sha256() + counts = {} + tuples = {} + for name in ATOMIC_SPLITS + COMPOSITE_SPLITS: + array = world[name] + columns = 3 if name in ATOMIC_SPLITS else 4 + if not isinstance(array, np.ndarray) or array.dtype != np.int64: + raise ValueError(f"{name} must be an int64 numpy array") + if array.ndim != 2 or array.shape[1] != columns: + raise ValueError(f"{name} must have {columns} columns") + for column in (0, columns - 1): + if np.any(array[:, column] < ENTITY_OFFSET) or np.any( + array[:, column] >= relation_offset + ): + raise ValueError(f"{name} has an invalid entity token") + if np.any(array[:, 1:-1] < relation_offset) or np.any( + array[:, 1:-1] >= relation_offset + relations + ): + raise ValueError(f"{name} has an invalid relation token") + rows = {tuple(map(int, row)) for row in array} + if len(rows) != len(array) or len({row[:-1] for row in rows}) != len(rows): + raise ValueError(f"{name} has duplicate or conflicting queries") + tuples[name] = rows + counts[name] = len(array) + digest.update(name.encode()) + digest.update(np.asarray(array.shape, dtype="= threshold for row in triple): + row = triple[0] + result.update( + reached=True, + step=row["step"], + confirmed_at_step=triple[-1]["step"], + previous_evaluation_step=rows[i - 1]["step"] if i else None, + examples=row["examples"], + atomic_exposures=row["counts"]["atomic"] / counts["atomic"], + composite_exposures=row["counts"]["composite"] / counts["train_composite"], + dataset_passes=row["examples"] / (counts["atomic"] + counts["train_composite"]), + estimated_training_flops=row["estimated_training_flops"], + effective_input_tokens=row["effective_input_tokens"], + supervised_tokens=row["supervised_tokens"], + ) + break + return result + + +def verify_files(root, expected): + for relative, sha in expected.items(): + assert digest(root / relative) == sha, f"Frozen input changed: {relative}" diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_data.py new file mode 100644 index 0000000000000000000000000000000000000000..18cae2dbd6dfdd997883935619a80811eede27d0 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_data.py @@ -0,0 +1,346 @@ +"""Audited data and fixed atomic/composite exposure for loop-depth comparisons. + +The graph, truth, complete-query holdout and phi sampling are inherited from +``grok_multihop_data``. Changing the atomic ID fraction is an explicit design +choice; no graph is regenerated in response to diagnostics or model scores. +""" + +from __future__ import annotations + +import copy +from collections.abc import Mapping + +import numpy as np + +from . import grok_multihop_data as multihop + +SPLITS = multihop.SPLITS +DATA_DEFAULTS = { + "hops": 2, + "entities": 128, + "relations": 16, + "degree": 8, + "phi": 6.0, + "id_fraction": 0.95, + "id_test_fraction": 0.1, + "evaluation_size": 1024, +} + + +def build_world(spec: Mapping) -> dict: + """Adapt a flat run specification while retaining the historical world API. + + ``world_seed`` (or ``seed``) is required. Unrelated model/training keys are + ignored. The default atomic ID/OOD fraction remains 95/5; use an explicit + ``id_fraction=0.75`` for the new composition-experience comparison. + + ``relevant_atomic_indices[split][i, j]`` identifies query i's true hop-j + fact in ``world['atomic']``. These truth indices are evaluation artifacts; + training must only use the original atomic and train-composite rows. + """ + if "world_seed" not in spec and "seed" not in spec: + raise ValueError("spec must contain world_seed or seed") + seed = spec.get("world_seed", spec.get("seed")) + fields = {key: spec.get(key, default) for key, default in DATA_DEFAULTS.items()} + world = multihop.build_world(seed, **fields) + world["relevant_atomic_indices"] = { + name: query_atomic_indices(world, world[name]) for name in SPLITS + } + world["metadata"]["loop_data_diagnostics"] = data_diagnostics(world) + world["metadata"]["loop_data_contract"] = { + "constructor": "grok_multihop_data.build_world", + "world_selection": "fixed supplied seed; no diagnostic or model-based selection", + "all_atomic_rows_are_training_facts": True, + "ood_definition": "all constituent facts absent from composite training by split", + "query_fact_indices": "evaluation truth only; no intermediate-entity supervision", + "suffix_statistics": "within-split descriptive counts; not fitted or held-out predictors", + } + audit_world(world) + return world + + +def query_atomic_indices(world: dict, rows: np.ndarray) -> np.ndarray: + """Return true constituent fact indices, including [N, 1] for atomics.""" + meta = world["metadata"] + _, edges = multihop.path_details( + rows, world["atomic"], int(meta["entities"]), int(meta["relations"]) + ) + return edges + + +def audit_world(world: dict) -> dict: + """Independently verify truth, ID/OOD partitions and recorded fact indices. + + The reused auditor checks truth by graph traversal and counts all-ID and + all-OOD paths by dynamic programming, independently of path construction. + Neither correct-looking diagnostics nor a saved metadata hash substitutes + for those checks. + """ + result = multihop.audit_world(world) + recorded = world.get("relevant_atomic_indices") + if recorded is not None: + if set(recorded) != set(SPLITS): + raise ValueError("Relevant atomic indices must cover every data split") + for name in SPLITS: + expected = query_atomic_indices(world, world[name]) + if ( + not isinstance(recorded[name], np.ndarray) + or recorded[name].dtype != np.int64 + or not np.array_equal(recorded[name], expected) + ): + raise ValueError(f"Incorrect relevant atomic indices: {name}") + if result["dataset_sha256"] != world["metadata"].get("dataset_sha256"): + raise ValueError("Recorded dataset hash disagrees with actual data") + return {**result, "relevant_atomic_indices_checked": recorded is not None} + + +def suffix_target_diagnostics(rows: np.ndarray) -> list[dict]: + """Describe target concentration after omitting the head and prefix relations. + + The empirical modal fraction sums each suffix group's largest target count + and divides by query count. It uses the same rows to count and summarize; + singleton suffixes score one automatically. It is not a model-independent + generalization bound, a learned baseline, or proof that heads are unnecessary. + """ + results = [] + n = len(rows) + for length in range(1, rows.shape[1] - 1): + suffix = rows[:, -(length + 1) : -1] + if not n: + results.append( + { + "suffix_relation_count": length, + "groups": 0, + "empirical_modal_target_fraction": None, + "single_target_group_query_fraction": None, + "singleton_group_query_fraction": None, + "multi_query_groups": 0, + "multi_query_coverage_fraction": None, + "multi_query_empirical_modal_target_fraction": None, + "multi_target_groups": 0, + "same_suffix_different_target_example": None, + } + ) + continue + _, groups, totals = np.unique(suffix, axis=0, return_inverse=True, return_counts=True) + pairs, pair_counts = np.unique(np.c_[groups, rows[:, -1]], axis=0, return_counts=True) + maxima = np.zeros(len(totals), dtype=np.int64) + np.maximum.at(maxima, pairs[:, 0], pair_counts) + multi = totals > 1 + multi_n = int(totals[multi].sum()) + multi_target = maxima != totals + example = None + if multi_target.any(): + # Deterministic first lexicographic suffix with incompatible targets. + group = int(np.flatnonzero(multi_target)[0]) + members = np.flatnonzero(groups == group) + first = members[0] + second = members[np.flatnonzero(rows[members, -1] != rows[first, -1])[0]] + example = [rows[first].tolist(), rows[second].tolist()] + results.append( + { + "suffix_relation_count": length, + "groups": len(totals), + "empirical_modal_target_fraction": float(maxima.sum() / n), + "single_target_group_query_fraction": float(totals[maxima == totals].sum() / n), + "singleton_group_query_fraction": float((totals == 1).sum() / n), + "multi_query_groups": int(multi.sum()), + "multi_query_coverage_fraction": float(multi_n / n), + "multi_query_empirical_modal_target_fraction": ( + float(maxima[multi].sum() / multi_n) if multi_n else None + ), + "multi_target_groups": int(multi_target.sum()), + "same_suffix_different_target_example": example, + } + ) + return results + + +def majority_tail_diagnostics(rows: np.ndarray) -> dict: + """Report the empirical within-split majority target, without fitting a model.""" + if not len(rows): + return {"target_token": None, "count": 0, "fraction": None, "distinct_targets": 0} + targets, counts = np.unique(rows[:, -1], return_counts=True) + index = int(counts.argmax()) + return { + "target_token": int(targets[index]), + "count": int(counts[index]), + "fraction": float(counts[index] / len(rows)), + "distinct_targets": len(targets), + } + + +def data_diagnostics(world: dict) -> dict: + """Pure data coverage and target distributions; never evaluate a predictor.""" + atomic_n = len(world["atomic"]) + indices = world.get("relevant_atomic_indices") + if indices is None: + indices = {name: query_atomic_indices(world, world[name]) for name in SPLITS} + training_counts = np.bincount(indices["train_composite"].ravel(), minlength=atomic_n) + id_facts = np.zeros(atomic_n, dtype=bool) + id_facts[indices["id_atomic"].ravel()] = True + training_majority = majority_tail_diagnostics(world["train_composite"]) + per_split = {} + for name in SPLITS: + rows, edges = world[name], indices[name] + distinct = np.unique(edges) + trained = training_counts[edges] > 0 + all_id, all_ood = id_facts[edges].all(axis=1), (~id_facts[edges]).all(axis=1) + per_split[name] = { + "n": len(rows), + "unique_relevant_atomic_facts": len(distinct), + "relevant_atomic_fact_coverage_of_graph": len(distinct) / atomic_n, + "all_relevant_facts_in_atomic_training_fraction": 1.0 if len(rows) else None, + "all_relevant_facts_in_composite_training_n": int(trained.all(axis=1).sum()), + "any_relevant_fact_in_composite_training_n": int(trained.any(axis=1).sum()), + "relevant_fact_occurrences_seen_in_composite_training_fraction": ( + float(trained.mean()) if edges.size else None + ), + "all_id_queries": int(all_id.sum()), + "all_ood_queries": int(all_ood.sum()), + "mixed_queries": int((~all_id & ~all_ood).sum()), + "unique_relevant_facts_by_hop": [ + len(np.unique(edges[:, j])) for j in range(edges.shape[1]) + ], + "within_split_majority_tail": majority_tail_diagnostics(rows), + "train_composite_majority_tail_fraction": ( + float((rows[:, -1] == training_majority["target_token"]).mean()) + if len(rows) and training_majority["target_token"] is not None + else None + ), + "suffix_without_head": suffix_target_diagnostics(rows), + } + return { + "interpretation": { + "atomic_coverage": "data availability only; does not establish model mastery", + "ood": "all facts are atomic training facts; none has composite-training experience", + "suffix": ( + "empirical within-split target concentration; singleton suffixes score 1; " + "not a predictor, generalization bound, or evidence that the model ignores head" + ), + "majority": "within-split descriptive ceiling plus fixed training-majority fraction", + }, + "atomic_facts": atomic_n, + "id_facts": int(id_facts.sum()), + "ood_facts": int((~id_facts).sum()), + "id_facts_seen_in_composite_training": int((training_counts[id_facts] > 0).sum()), + "ood_facts_seen_in_composite_training": int((training_counts[~id_facts] > 0).sum()), + "train_composite_fact_occurrence_counts": training_counts.tolist(), + "splits": per_split, + } + + +class _EpochStream: + """NumPy-only shuffled epochs, with the existing EpochStream draw convention.""" + + def __init__(self, size: int, seed): + self.size = size + self.rng = np.random.default_rng(seed) + self.remaining = np.empty(0, dtype=np.int64) + + def take(self, n: int) -> np.ndarray: + if not n: + return np.empty(0, dtype=np.int64) + parts = [] + while n: + if not len(self.remaining): + self.remaining = self.rng.permutation(self.size) + count = min(n, len(self.remaining)) + parts.append(self.remaining[:count]) + self.remaining = self.remaining[count:] + n -= count + return np.concatenate(parts) + + def state_dict(self) -> dict: + return { + "size": self.size, + "rng": copy.deepcopy(self.rng.bit_generator.state), + "remaining": self.remaining.copy(), + } + + def load_state_dict(self, state: dict): + if state["size"] != self.size: + raise ValueError("Epoch size mismatch") + remaining = np.asarray(state["remaining"]) + if ( + remaining.ndim != 1 + or remaining.dtype != np.int64 + or np.any((remaining < 0) | (remaining >= self.size)) + or len(np.unique(remaining)) != len(remaining) + ): + raise ValueError("Invalid remaining epoch indices") + self.rng.bit_generator.state = copy.deepcopy(state["rng"]) + self.remaining = remaining.copy() + + +class StratifiedStream: + """Fixed composition per batch over the table [atomics; train_composites]. + + Atomic, composite and interleaving draws use independent RNGs. Thus changing + phi or the composite pool cannot change the atomic sequence or its batch + positions. Individual strata use shuffled epochs and may cross an epoch + boundary within one batch. No evaluation data enters either stream. + """ + + def __init__( + self, atomic_size: int, composite_size: int, batch_size: int, n_atomic: int, seed: int + ): + fields = { + "atomic_size": atomic_size, + "composite_size": composite_size, + "batch_size": batch_size, + "n_atomic": n_atomic, + } + for name, value in fields.items(): + if not isinstance(value, (int, np.integer)) or isinstance(value, bool) or value < 0: + raise ValueError(f"{name} must be a nonnegative integer") + if batch_size < 1 or n_atomic > batch_size: + raise ValueError("Require batch_size > 0 and 0 <= n_atomic <= batch_size") + if (n_atomic and not atomic_size) or (batch_size > n_atomic and not composite_size): + raise ValueError("A sampled stratum cannot be empty") + self.atomic_size, self.composite_size = int(atomic_size), int(composite_size) + self.batch_size, self.n_atomic = int(batch_size), int(n_atomic) + self.atomic = _EpochStream(atomic_size, np.random.SeedSequence([int(seed), 145101])) + self.composite = _EpochStream(composite_size, np.random.SeedSequence([int(seed), 145102])) + self.interleave = np.random.default_rng(np.random.SeedSequence([int(seed), 145103])) + self.batches = 0 + + def take(self, n: int | None = None) -> np.ndarray: + if n is not None and n != self.batch_size: + raise ValueError("StratifiedStream only emits its configured batch_size") + indices = np.r_[ + self.atomic.take(self.n_atomic), + self.composite.take(self.batch_size - self.n_atomic) + self.atomic_size, + ] + self.batches += 1 + return indices[self.interleave.permutation(self.batch_size)] + + def state_dict(self) -> dict: + return { + "version": 1, + "atomic_size": self.atomic_size, + "composite_size": self.composite_size, + "batch_size": self.batch_size, + "n_atomic": self.n_atomic, + "atomic": self.atomic.state_dict(), + "composite": self.composite.state_dict(), + "interleave_rng": copy.deepcopy(self.interleave.bit_generator.state), + "batches": self.batches, + } + + def load_state_dict(self, state: dict): + if state.get("version") != 1: + raise ValueError("Unsupported StratifiedStream state version") + for name in ("atomic_size", "composite_size", "batch_size", "n_atomic"): + if state[name] != getattr(self, name): + raise ValueError(f"StratifiedStream {name} mismatch") + atomic, composite = copy.deepcopy(self.atomic), copy.deepcopy(self.composite) + interleave = copy.deepcopy(self.interleave) + atomic.load_state_dict(state["atomic"]) + composite.load_state_dict(state["composite"]) + interleave.bit_generator.state = copy.deepcopy(state["interleave_rng"]) + batches = state["batches"] + if not isinstance(batches, int) or batches < 0: + raise ValueError("Invalid completed batch count") + self.atomic, self.composite, self.interleave = atomic, composite, interleave + self.batches = batches diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_mechanism.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_mechanism.py new file mode 100644 index 0000000000000000000000000000000000000000..dfd1ad614952efa432b820d8f26f1e282657a947 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_mechanism.py @@ -0,0 +1,549 @@ +"""Prefix-only component interventions at every executed Transformer block. + +The recipient block runs normally before mixing cached attention and MLP +increments at r1. The current block's MLP is never recomputed after mixing. +Only later blocks consume the intervention. Donors are graph-selected before +evaluating the model and receive only [head, r1] followed by fixed PAD tokens. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from collections import Counter, defaultdict +from numbers import Integral + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_multihop import pack_rows + +COMPONENTS = ("attention", "mlp", "both", "full") +SPLITS = ("test_composite", "test_full_composite", "ood_composite") +TRACE_FIELDS = ("input", "attention", "mlp", "residual") + + +def _choose(candidates, world_hash, seed, row, family): + if not candidates: + return None + material = json.dumps([world_hash, int(seed), list(map(int, row)), family]) + index = int.from_bytes(hashlib.sha256(material.encode()).digest(), "big") % len(candidates) + return sorted(candidates)[index] + + +def _path(head, relations, graph): + edges = [] + for relation in relations: + fact = graph.get((int(head), int(relation))) + if fact is None: + return None + head, index = fact + edges.append(index) + return int(head), tuple(edges) + + +def select_donors(world, seed, split="test_composite"): + """Select same-r1 donors using only truth and split membership. + + ID recipients and every donor-path fact are restricted to ID facts. OOD + recipients and donor paths analogously use only OOD facts. Different-bridge + paths must change the target and their complete queries must be untrained. + Same-bridge paths may be trained; their split is saved for separate scoring. + Rows without donors remain present with explicit masks and reasons. + """ + if split not in SPLITS: + raise ValueError(f"split must be one of {SPLITS}") + rows = world[split] + n, hops = len(rows), rows.shape[1] - 2 + if not 2 <= hops <= 4: + raise ValueError("Interventions require two-, three- or four-hop rows") + atom_index = {tuple(map(int, row)): i for i, row in enumerate(world["atomic"])} + atomic_split = "ood_atomic" if split == "ood_composite" else "id_atomic" + graph = { + (int(h), int(r)): (int(t), atom_index[int(h), int(r), int(t)]) + for h, r, t in world[atomic_split] + } + by_relation = defaultdict(list) + for (head, relation), (tail, _) in graph.items(): + by_relation[relation].append((head, relation, tail)) + training = {tuple(map(int, row[:-1])) for row in world["train_composite"]} + reserved = {tuple(map(int, row[:-1])) for row in world["test_full_composite"]} + result = { + "split": np.asarray(split), + "atomic_split": np.asarray(atomic_split), + "original_rows": rows.copy(), + "original_bridge": np.full(n, -1, dtype=np.int64), + "original_atomic_indices": np.full((n, hops), -1, dtype=np.int64), + } + for family in ("different", "same"): + result.update( + { + family + "_donor": np.full((n, 3), -1, dtype=np.int64), + family + "_counterfactual_rows": np.full_like(rows, -1), + family + "_atomic_indices": np.full((n, hops), -1, dtype=np.int64), + family + "_valid": np.zeros(n, dtype=bool), + family + "_candidate_count": np.zeros(n, dtype=np.int64), + family + "_reason": np.full(n, "no_eligible_same_relation_path", dtype="U64"), + family + "_counterfactual_split": np.full(n, "missing", dtype="U16"), + } + ) + reasons = ( + "same_head", + "same_bridge", + "missing_successor", + "same_target", + "head_is_answer", + "trained_counterfactual", + ) + for reason in reasons: + result["different_rejected_" + reason] = np.zeros(n, dtype=np.int64) + for i, row in enumerate(rows): + head, r1, target = int(row[0]), int(row[1]), int(row[-1]) + original = _path(head, row[1:-1], graph) + if original is None or original[0] != target: + raise ValueError(f"Recipient is not a true all-{atomic_split} path") + bridge = graph[head, r1][0] + result["original_bridge"][i] = bridge + result["original_atomic_indices"][i] = original[1] + candidates = {"different": [], "same": []} + for dh, dr, db in by_relation[r1]: + continuation = _path(dh, row[1:-1], graph) + if continuation is None: + reason = "missing_successor" + else: + dt, edges = continuation + query = (dh, *map(int, row[1:-1])) + if dh != head and db == bridge and dh != target: + candidates["same"].append((dh, dr, db, dt, edges)) + reason = ( + "same_head" + if dh == head + else "same_bridge" + if db == bridge + else "same_target" + if dt == target + else "head_is_answer" + if dh in (target, dt) + else "trained_counterfactual" + if query in training + else None + ) + if reason is None: + candidates["different"].append((dh, dr, db, dt, edges)) + if reason: + result["different_rejected_" + reason][i] += 1 + for family in ("different", "same"): + choices = candidates[family] + result[family + "_candidate_count"][i] = len(choices) + donor = _choose(choices, world["metadata"]["dataset_sha256"], seed, row, family) + if donor is None: + continue + dh, dr, db, dt, edges = donor + cf = (dh, *map(int, row[1:-1]), dt) + result[family + "_donor"][i] = dh, dr, db + result[family + "_counterfactual_rows"][i] = cf + result[family + "_atomic_indices"][i] = edges + result[family + "_valid"][i] = True + result[family + "_reason"][i] = "eligible" + result[family + "_counterfactual_split"][i] = ( + "ood" + if split == "ood_composite" + else "train" + if cf[:-1] in training + else "reserved_test" + if cf[:-1] in reserved + else "unused" + ) + return result + + +def executed_blocks(model): + return list(model.iter_blocks()) if hasattr(model, "iter_blocks") else list(model.blocks) + + +@torch.no_grad() +def traced_forward( + model, + tokens, + positions=None, + *, + patch_layer=None, + component="both", + donor_trace=None, + identity=False, + return_trace=False, +): + """Run eval forward, optionally mixing one executed layer's r1 state. + + Trace fields contain only position r1, with shape [batch, width]. For a + component patch the output is (recipient input + mixed A) + mixed M. Full + replacement also changes the incoming residual, so it equals replacing A + and M only at execution layer zero for same-r1 donors, not at later layers. + """ + if model.training: + raise ValueError("Interventions require model.eval()") + blocks = executed_blocks(model) + if component not in COMPONENTS: + raise ValueError(f"component must be one of {COMPONENTS}") + if patch_layer is not None and ( + isinstance(patch_layer, bool) + or not isinstance(patch_layer, Integral) + or not 0 <= patch_layer < len(blocks) + ): + raise ValueError("patch_layer must index an executed block") + if identity and donor_trace is not None: + raise ValueError("Identity and donor patches are mutually exclusive") + if (donor_trace is not None or identity) != (patch_layer is not None): + raise ValueError("A patch layer requires exactly one donor or identity patch") + if donor_trace is not None and len(donor_trace) != len(blocks): + raise ValueError("Donor trace must cover every executed layer") + if tokens.shape[1] < 2: + raise ValueError("The r1 position requires at least two tokens") + x = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=tokens.device)) + trace = [] + for layer, block in enumerate(blocks): + z = block.ln1(x) + batch, length, width = z.shape + attention = block.attention + q, k, v = ( + attention.qkv(z) + .view(batch, length, 3, attention.heads, width // attention.heads) + .unbind(2) + ) + a = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=0.0, + ) + a = attention.proj(a.transpose(1, 2).reshape(batch, length, width)) + m = block.mlp(block.ln2(x + a)) + residual = (x + a) + m + current = { + "input": x[:, 1].clone(), + "attention": a[:, 1].clone(), + "mlp": m[:, 1].clone(), + "residual": residual[:, 1].clone(), + } + if return_trace: + trace.append(current) + if layer == patch_layer: + donor = current if identity else donor_trace[layer] + if any(donor[key].shape != current[key].shape for key in TRACE_FIELDS): + raise ValueError("Donor trace has incompatible batch or width") + if component == "full": + replacement = donor["residual"] + else: + mixed_a = donor["attention"] if component in ("attention", "both") else a[:, 1] + mixed_m = donor["mlp"] if component in ("mlp", "both") else m[:, 1] + replacement = (x[:, 1] + mixed_a) + mixed_m + residual = residual.clone() + residual[:, 1] = replacement + x = residual + x = model.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + logits = F.linear(x, model.token.weight) + return (logits, trace) if return_trace else logits + + +@torch.no_grad() +def prefix_trace(model, prefixes, padded_length): + """Evaluate only two supplied tokens and a fixed zero suffix; never a target.""" + if prefixes.ndim != 2 or prefixes.shape[1] != 2 or padded_length < 4: + raise ValueError("Need two-token prefixes and the fixed hops+2 sequence length") + tokens = torch.zeros((len(prefixes), padded_length), dtype=torch.long, device=prefixes.device) + tokens[:, :2] = prefixes + positions = torch.ones((len(prefixes), 1), dtype=torch.long, device=prefixes.device) + return traced_forward(model, tokens, positions, return_trace=True)[1] + + +@torch.no_grad() +def evaluate_condition( + model, + rows, + device, + padded_length, + *, + donor_prefixes=None, + patch_layer=None, + component="both", + identity=False, + batch_size=1024, + verify_trace=False, +): + """Generate answer then EOS, reapplying exactly the same donor intervention.""" + if donor_prefixes is not None and donor_prefixes.shape != (len(rows), 2): + raise ValueError("Donor prefixes must align one-to-one with recipient rows") + answers, stops, logits_saved = [], [], [] + max_delta = prefix_delta = 0.0 + packed = pack_rows(rows, padded_length) + for start in range(0, len(rows), batch_size): + x, pos, _ = (torch.as_tensor(a[start : start + batch_size], device=device) for a in packed) + x = x.clone() + donor = None + if donor_prefixes is not None: + prefixes = torch.as_tensor(donor_prefixes[start : start + batch_size], device=device) + donor = prefix_trace(model, prefixes, padded_length) + arguments = dict( + patch_layer=patch_layer, + component=component, + donor_trace=donor, + identity=identity, + ) + logits, trace = traced_forward(model, x, pos, return_trace=True, **arguments) + if verify_trace: + if patch_layer is not None: + raise ValueError("Native-forward verification applies to baseline only") + reference = model(x, pos) + max_delta = max(max_delta, float((reference - logits).abs().max())) + if not torch.equal(reference.argmax(-1), logits.argmax(-1)): + raise AssertionError("Traced forward changes native argmax") + prefix = prefix_trace(model, x[:, :2], padded_length) + for full, truncated in zip(trace, prefix, strict=True): + for field in TRACE_FIELDS: + prefix_delta = max( + prefix_delta, float((full[field] - truncated[field]).abs().max()) + ) + answer = logits[:, 0].argmax(-1) + logits_saved.append(logits[:, 0].cpu().numpy()) + x[torch.arange(len(x), device=device), pos[:, 1]] = answer + continuation = traced_forward(model, x, pos, **arguments) + if verify_trace: + reference = model(x, pos) + max_delta = max(max_delta, float((reference - continuation).abs().max())) + if not torch.equal(reference.argmax(-1), continuation.argmax(-1)): + raise AssertionError("Generated-answer trace changes native argmax") + answers.append(answer.cpu().numpy()) + stops.append(continuation[:, 1].argmax(-1).cpu().numpy()) + if max_delta > 1e-5 or prefix_delta > 1e-5: + raise AssertionError(f"Native/prefix trace disagreement: {max_delta}, {prefix_delta}") + return { + "answer": np.concatenate(answers) if answers else np.empty(0, dtype=np.int64), + "stop": np.concatenate(stops) if stops else np.empty(0, dtype=np.int64), + "answer_logits": np.concatenate(logits_saved) + if logits_saved + else np.empty((0, model.token.num_embeddings), dtype=np.float32), + }, { + "native_comparison_performed": verify_trace, + "native_max_logit_delta": max_delta, + "prefix_only_vs_full_all_layers_max_delta": prefix_delta, + } + + +def _metrics(arrays, condition, selected, original, target, baseline): + mask = selected & arrays[condition + "_valid"] + n, total = int(mask.sum()), len(mask) + answer, stop = arrays[condition + "_answer"], arrays[condition + "_stop"] + + def mean(value): + return float(value[mask].mean()) if n else None + + return { + "n": n, + "total_n": total, + "coverage": n / total if total else None, + "target_answer_accuracy": mean(answer == target), + "target_complete_accuracy": mean((answer == target) & (stop == 1)), + "original_answer_accuracy": mean(answer == original), + "original_complete_accuracy": mean((answer == original) & (stop == 1)), + "other_answer_rate": mean((answer != target) & (answer != original)), + "eos_accuracy": mean(stop == 1), + "answer_change_rate": mean(answer != baseline), + } + + +def evaluate_run(model, world, donors, device="cuda:0", batch_size=1024): + """Evaluate every executed layer, preserving all rows and prerequisite masks.""" + started = time.perf_counter() + model.eval() + split = str(donors["split"].item()) + rows = world[split] + if not np.array_equal(rows, donors["original_rows"]): + raise ValueError("Donor rows differ from the registered evaluation split") + n, padded_length = len(rows), int(world["metadata"]["hops"]) + 2 + arrays = {key: value.copy() for key, value in donors.items()} + all_rows = np.ones(n, dtype=bool) + conditions, audits = {}, {} + + def evaluate(name, mask, inputs, *, family=None, **kwargs): + result, audit = evaluate_condition( + model, inputs[mask], device, padded_length, batch_size=batch_size, **kwargs + ) + for key in ("answer", "stop"): + values = np.full(n, -1, dtype=np.int64) + values[mask] = result[key] + arrays[name + "_" + key] = values + arrays[name + "_valid"] = mask.copy() + targets = rows[:, -1] if family is None else donors[family + "_counterfactual_rows"][:, -1] + for suffix, labels in (("original_logit", rows[:, -1]), ("target_logit", targets)): + values = np.full(n, np.nan, dtype=np.float32) + values[mask] = result["answer_logits"][np.arange(mask.sum()), labels[mask]] + arrays[name + "_" + suffix] = values + conditions[name] = { + "family": family, + **{k: v for k, v in kwargs.items() if k in ("patch_layer", "component", "identity")}, + } + audits[name] = audit + + evaluate("baseline", all_rows, rows, verify_trace=True) + for family in ("different", "same"): + valid = donors[family + "_valid"] + # Match batch shape as well as sequence shape for floating-point controls. + evaluate(family + "_matched_baseline", valid, rows, family=family) + evaluate( + family + "_counterfactual_input", + valid, + donors[family + "_counterfactual_rows"], + family=family, + ) + blocks = executed_blocks(model) + for layer in range(len(blocks)): + for component in COMPONENTS: + identity_name = f"e{layer:03d}_identity_{component}" + evaluate( + identity_name, all_rows, rows, patch_layer=layer, component=component, identity=True + ) + for key in ("answer", "stop", "original_logit", "target_logit"): + if not np.array_equal(arrays[identity_name + "_" + key], arrays["baseline_" + key]): + raise AssertionError(f"Identity patch changes {identity_name}.{key}") + for family in ("different", "same"): + valid = donors[family + "_valid"] + name = f"e{layer:03d}_{family}_{component}" + evaluate( + name, + valid, + rows, + family=family, + patch_layer=layer, + component=component, + donor_prefixes=donors[family + "_donor"][valid, :2], + ) + if layer == len(blocks) - 1: + for key in ("answer", "stop", "original_logit"): + if not np.array_equal( + arrays[name + "_" + key][valid], + arrays[family + "_matched_baseline_" + key][valid], + ): + raise AssertionError("Last-block r1 patch changes later answer/EOS") + if layer == 0: + for family in ("different", "same"): + valid = donors[family + "_valid"] + for key in ("answer", "stop", "original_logit", "target_logit"): + left = arrays[f"e000_{family}_both_{key}"][valid] + right = arrays[f"e000_{family}_full_{key}"][valid] + if not np.array_equal(left, right): + raise AssertionError("First-layer same-r1 both/full differ") + atomics, _ = evaluate_condition( + model, world["atomic"], device, padded_length, batch_size=batch_size + ) + atom_correct = (atomics["answer"] == world["atomic"][:, -1]) & (atomics["stop"] == 1) + arrays["atomic_rows"] = world["atomic"].copy() + arrays["atomic_answer"], arrays["atomic_stop"] = atomics["answer"], atomics["stop"] + groups = {"all_rows": all_rows} + prerequisites = {} + for family in ("original", "different", "same"): + valid = all_rows if family == "original" else donors[family + "_valid"] + indices = donors[family + "_atomic_indices"] + correct = np.zeros_like(indices, dtype=bool) + correct[valid] = atom_correct[indices[valid]] + arrays[family + "_atomic_complete_correct"] = correct + complete = valid & correct.all(axis=1) + groups[family + "_all_atomic_correct"] = complete + prerequisites[family] = { + "n": int(valid.sum()), + "total_n": n, + "coverage": float(valid.mean()) if n else None, + "all_hops_complete_accuracy": float(complete[valid].mean()) if valid.any() else None, + "per_hop_complete_accuracy": correct[valid].mean(axis=0).tolist() + if valid.any() + else None, + } + for family in ("different", "same"): + valid = donors[family + "_valid"] + baseline_correct = (arrays[family + "_matched_baseline_answer"] == rows[:, -1]) & ( + arrays[family + "_matched_baseline_stop"] == 1 + ) + groups[family + "_donor_available"] = valid + groups[family + "_donor_missing"] = ~valid + cf = family + "_counterfactual_input" + cf_correct = valid & ( + arrays[cf + "_answer"] == donors[family + "_counterfactual_rows"][:, -1] + ) + cf_correct &= arrays[cf + "_stop"] == 1 + groups[family + "_native_original_and_counterfactual_correct"] = ( + baseline_correct & cf_correct + ) + for category in ("train", "reserved_test", "unused", "ood"): + groups[family + "_counterfactual_" + category] = valid & ( + donors[family + "_counterfactual_split"] == category + ) + scores = {} + for group, mask in groups.items(): + arrays["subset_" + group] = mask.copy() + scored = {} + for condition, description in conditions.items(): + family = description["family"] + target = ( + rows[:, -1] if family is None else donors[family + "_counterfactual_rows"][:, -1] + ) + scored[condition] = _metrics( + arrays, + condition, + mask, + rows[:, -1], + target, + arrays[(family + "_matched_baseline" if family else "baseline") + "_answer"], + ) + scores[group] = { + "n": int(mask.sum()), + "total_n": n, + "coverage": float(mask.mean()) if n else None, + "conditions": scored, + } + return { + "split": split, + "atomic_split": str(donors["atomic_split"].item()), + "sample_rule": "training-independent fixed probe" + if split == "test_composite" + else "full split", + "hops": padded_length - 2, + "executed_depth": len(blocks), + "unique_layers": len(model.blocks), + "repeats": getattr(model, "repeats", 1), + "patch_position": 1, + "conditions": conditions, + "scores": scores, + "atomic_preconditions": prerequisites, + "donor_coverage": { + family: { + "n": int(donors[family + "_valid"].sum()), + "total_n": n, + "reasons": dict(Counter(donors[family + "_reason"].tolist())), + "counterfactual_split": dict( + Counter(donors[family + "_counterfactual_split"].tolist()) + ), + } + for family in ("different", "same") + }, + "engineering_checks": { + "native_trace": audits["baseline"], + "identity_all_layers_components": True, + "first_layer_same_r1_both_equals_full": True, + "last_layer_r1_patch_cannot_change_later_answer_or_eos": True, + "donor_nonpadding_tokens": 2, + "donor_padded_length": padded_length, + "mlp_recomputed_after_mixing": False, + "eos_uses_generated_answer_and_reapplies_same_patch": True, + }, + "interpretation": ( + "End-to-end prefix-state interventions, not proof that facts reside only in MLP. " + "Component mixtures retain recipient incoming residual. Both/full are equivalent " + "only at first execution layer with same r1; later differences are expected. " + "Facts and queries within one world are not independent experimental worlds." + ), + "evaluation_seconds": time.perf_counter() - started, + }, arrays diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_model.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_model.py new file mode 100644 index 0000000000000000000000000000000000000000..8ed46483cb7277c172f8848cefb9e2d085d67c0b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_model.py @@ -0,0 +1,108 @@ +"""Depth-shared GPT blocks for controlled composition-learning comparisons. + +This keeps the existing SmallGPT tokenization, causal attention, dropout and tied +readout. ``config.layers`` counts independently parameterized blocks; each loop +executes this whole block group. Positions and token embeddings are added once. +""" + +from __future__ import annotations + +import math +from dataclasses import replace +from numbers import Integral + +import torch +from torch.nn import functional as F + +from .bios_model import matmul_flops +from .grok_depth import SmallGPT + +INITIALIZATIONS = frozenset({"legacy_unique", "scaled_effective", "zero_residual"}) + + +def _positive_integer(value, name): + if isinstance(value, bool) or not isinstance(value, Integral) or value < 1: + raise ValueError(f"{name} must be a positive integer, got {value!r}") + return int(value) + + +class LoopGPT(SmallGPT): + """Vanilla fixed-loop Transformer with shared attention, MLP and block norms. + + ``legacy_unique`` reproduces SmallGPT's residual initialization based on the + number of unique blocks. ``scaled_effective`` scales residual output weights + by the total executed depth; ``zero_residual`` instead zeros those weights. + Embeddings, other projections and all biases retain SmallGPT initialization. + + Changing ``repeats`` in forward does not change parameter initialization. It + is a computation-depth intervention, not an independently initialized model. + Save repeats, dropout and initialization alongside ``config_dict()`` and the + state dict when constructing checkpoints; they are architectural metadata. + """ + + def __init__(self, config, repeats=1, dropout=0.1, initialization="scaled_effective"): + repeats = _positive_integer(repeats, "repeats") + _positive_integer(config.layers, "config.layers") + if initialization not in INITIALIZATIONS: + raise ValueError(f"initialization must be one of {sorted(INITIALIZATIONS)}") + super().__init__(config, dropout=dropout) + self.repeats = repeats + self.initialization = initialization + with torch.no_grad(): + for block in self.blocks: + for module in (block.attention.proj, block.mlp.down): + if initialization == "scaled_effective": + module.weight.div_(math.sqrt(repeats)) + elif initialization == "zero_residual": + module.weight.zero_() + + @property + def effective_depth(self): + return self.config.layers * self.repeats + + def iter_blocks(self, repeats=None): + """Yield executed blocks; repeated occurrences are the same module object.""" + count = self.repeats if repeats is None else _positive_integer(repeats, "repeats") + for _ in range(count): + yield from self.blocks + + def forward(self, tokens, positions=None, repeats=None): + p = self.dropout if self.training else 0.0 + x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device)) + x = F.dropout(x, p=p, training=self.training) + for block in self.iter_blocks(repeats): + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=p, + ) + y = a.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + F.dropout(y, p=p, training=self.training) + x = x + F.dropout(block.mlp(block.ln2(x)), p=p, training=self.training) + x = self.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + return F.linear(x, self.token.weight) + + +def flops(config, repeats, batch, sequence, output_positions=2, backward=True): + """Estimate matmul FLOPs using executed blocks, counting the readout once. + + Uses the same executed-shape estimate as bios_model.matmul_flops. Excludes + elementwise operations and uses three forward equivalents for training. + """ + count = _positive_integer(repeats, "repeats") + layers = _positive_integer(config.layers, "config.layers") + return matmul_flops( + replace(config, layers=layers * count), + batch, + sequence, + output_positions=output_positions, + backward=backward, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py new file mode 100644 index 0000000000000000000000000000000000000000..f3cac329831b303c1dc9ca05c270837de0614eec --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py @@ -0,0 +1,342 @@ +"""Graph-only, exposure-matched same-bridge donors for two-hop OOD queries. + +Every donor contains only [head, r1]; its bridge is saved as truth, never fed +to the model. ID donors must have actually occurred at the first position of +composite training. OOD donors have zero composite exposure at either position. +All eligible donors and ID x OOD pairs are retained. A pair is a repeated +measurement of its recipient, not an independent query or world. +""" + +from __future__ import annotations + +import hashlib +import json +from collections import defaultdict +from collections.abc import Mapping +from numbers import Integral + +import numpy as np + +from .grok_multihop_data import audit_world, path_details + + +def _nonnegative_integer(value, name): + if isinstance(value, bool) or not isinstance(value, Integral) or value < 0: + raise ValueError(f"{name} must be a nonnegative integer") + return int(value) + + +def _exposure_spec(world, run_metadata, steps): + spec = run_metadata.get("spec", run_metadata) + if not isinstance(spec, Mapping): + raise ValueError("Run metadata must contain a specification mapping") + count = _nonnegative_integer(spec["steps"] if steps is None else steps, "steps") + if count > _nonnegative_integer(spec["steps"], "registered steps"): + raise ValueError("Exposure cannot exceed the registered training endpoint") + batch = _nonnegative_integer(spec["batch_size"], "batch_size") + atomic_batch = _nonnegative_integer(spec["n_atomic_per_batch"], "n_atomic_per_batch") + seed = _nonnegative_integer(spec["stream_seed"], "stream_seed") + if batch < 1 or atomic_batch > batch: + raise ValueError("Require batch_size > 0 and n_atomic_per_batch <= batch_size") + for key in ("world_seed", "hops"): + expected = world["metadata"]["seed" if key == "world_seed" else key] + if key in spec and spec[key] != expected: + raise ValueError(f"Run specification disagrees with the world: {key}") + return { + "dataset_sha256": world["metadata"]["dataset_sha256"], + "stream_seed": seed, + "steps": count, + "batch_size": batch, + "n_atomic_per_batch": atomic_batch, + "atomic_size": len(world["atomic"]), + "composite_size": len(world["train_composite"]), + "stream": "StratifiedStream independent shuffled epochs v1", + } + + +def _cache_key(spec): + return hashlib.sha256(json.dumps(spec, sort_keys=True).encode()).hexdigest() + + +def _record_exposures(size, draws, seed, tag): + """Replay the final partial epoch without materializing the full sample stream.""" + if not size: + if draws: + raise ValueError("A sampled training stratum cannot be empty") + return np.empty(0, dtype=np.int64) + complete, remainder = divmod(draws, size) + counts = np.full(size, complete, dtype=np.int64) + if remainder: + rng = np.random.default_rng(np.random.SeedSequence([seed, tag])) + for _ in range(complete): + rng.permutation(size) + counts[rng.permutation(size)[:remainder]] += 1 + return counts + + +def actual_exposure_counts(world, run_metadata, *, steps=None): + """Count actual atomic and composite records sampled through a fixed step. + + The training sampler has independent atomic/composite RNG streams, so its + interleaving draws do not change these counts. Full epochs expose every + record once; only the final partial epoch needs its exact permutation. + ``cache_key`` depends on data, sample-stream seed, step and batch mixture, + but not architecture or initialization, which do not change this sampler. + """ + checked = audit_world(world) + if checked["dataset_sha256"] != world["metadata"].get("dataset_sha256"): + raise ValueError("World metadata hash does not match the data") + if world["metadata"]["hops"] != 2: + raise ValueError("Same-bridge exposure comparison requires two-hop worlds") + spec = _exposure_spec(world, run_metadata, steps) + atom_count = _record_exposures( + spec["atomic_size"], + spec["steps"] * spec["n_atomic_per_batch"], + spec["stream_seed"], + 145101, + ) + composite_count = _record_exposures( + spec["composite_size"], + spec["steps"] * (spec["batch_size"] - spec["n_atomic_per_batch"]), + spec["stream_seed"], + 145102, + ) + _, edges = path_details( + world["train_composite"], + world["atomic"], + world["metadata"]["entities"], + world["metadata"]["relations"], + ) + table = np.zeros((len(world["atomic"]), 2), dtype=np.int64) + actual = np.zeros_like(table) + for position in range(2): + np.add.at(table[:, position], edges[:, position], 1) + np.add.at(actual[:, position], edges[:, position], composite_count) + return { + "cache_key": _cache_key(spec), + "cache_spec": spec, + "atomic_record_counts": atom_count, + "composite_record_counts": composite_count, + "table_position_counts": table, + "actual_position_counts": actual, + } + + +def _rows(values, columns): + return np.asarray(values, dtype=np.int64).reshape(-1, columns) + + +def select_same_bridge_donors(world, run_metadata, *, steps=None, exposure=None): + """Enumerate same-r1/same-bridge ID and OOD donors without model selection. + + Inputs are a standard audited loop world and either run metadata with a + ``spec`` field or the specification directly. All original OOD rows stay + aligned with validity masks and explicit reasons. Flattened donor arrays + include recipients with only one donor class. Main pairs require both. + ``exposure`` may cache ``actual_exposure_counts`` for a shared sample stream. + + For pair-level scores, first average pairs within each recipient (using + pair_weights), then average recipients. Pair weights sum to one for each + common recipient; they do not sum to one across the whole world. + """ + checked = audit_world(world) + if checked["dataset_sha256"] != world["metadata"].get("dataset_sha256"): + raise ValueError("World metadata hash does not match the data") + if world["metadata"]["hops"] != 2: + raise ValueError("Same-bridge selection requires two-hop worlds") + spec = _exposure_spec(world, run_metadata, steps) + exposure = ( + actual_exposure_counts(world, run_metadata, steps=steps) if exposure is None else exposure + ) + if exposure.get("cache_key") != _cache_key(spec) or exposure.get("cache_spec") != spec: + raise ValueError("Cached exposure belongs to another world or sample stream") + atoms = world["atomic"] + position_counts = np.asarray(exposure["actual_position_counts"]) + table_counts = np.asarray(exposure["table_position_counts"]) + if ( + position_counts.shape != (len(atoms), 2) + or table_counts.shape != position_counts.shape + or position_counts.dtype != np.int64 + or table_counts.dtype != np.int64 + or (position_counts < 0).any() + or (table_counts < 0).any() + ): + raise ValueError("Cached position exposure counts have invalid shape or values") + atom_index = {tuple(map(int, row)): i for i, row in enumerate(atoms)} + is_id = np.zeros(len(atoms), dtype=bool) + is_id[[atom_index[tuple(map(int, row))] for row in world["id_atomic"]]] = True + if position_counts[~is_id].any() or table_counts[~is_id].any(): + raise ValueError("An OOD fact has composite training exposure") + expected_draws = spec["steps"] * (spec["batch_size"] - spec["n_atomic_per_batch"]) + if not np.array_equal(position_counts.sum(axis=0), [expected_draws, expected_draws]): + raise ValueError("Cached position counts disagree with the registered sample budget") + incoming = defaultdict(list) + for i, (head, relation, bridge) in enumerate(atoms): + incoming[int(relation), int(bridge)].append((int(head), i)) + for candidates in incoming.values(): + candidates.sort() + original = world["ood_composite"] + nodes, edges = path_details( + original, atoms, world["metadata"]["entities"], world["metadata"]["relations"] + ) + if is_id[edges].any(): + raise ValueError("Recipients must contain only OOD facts") + n = len(original) + id_indices, ood_indices = [], [] + id_recipient, ood_recipient = [], [] + id_offsets, ood_offsets = [0], [0] + second_only = np.zeros(n, dtype=np.int64) + nominal_unexposed = np.zeros(n, dtype=np.int64) + rejected_same_head = np.zeros(n, dtype=np.int64) + rejected_answer_head = np.zeros(n, dtype=np.int64) + for i, (head, r1, _r2, target) in enumerate(original): + for donor_head, fact in incoming[int(r1), int(nodes[i, 1])]: + if donor_head == head: + rejected_same_head[i] += 1 + continue + if donor_head == target: + rejected_answer_head[i] += 1 + continue + if is_id[fact]: + if position_counts[fact, 0] > 0: + id_indices.append(fact) + id_recipient.append(i) + elif position_counts[fact, 1] > 0: + second_only[i] += 1 + else: + nominal_unexposed[i] += 1 + else: + ood_indices.append(fact) + ood_recipient.append(i) + id_offsets.append(len(id_indices)) + ood_offsets.append(len(ood_indices)) + id_offsets = np.asarray(id_offsets, dtype=np.int64) + ood_offsets = np.asarray(ood_offsets, dtype=np.int64) + id_count, ood_count = np.diff(id_offsets), np.diff(ood_offsets) + valid = (id_count > 0) & (ood_count > 0) + pair_recipient, pair_id, pair_ood, weights = [], [], [], [] + for i in np.flatnonzero(valid): + weight = 1.0 / int(id_count[i] * ood_count[i]) + for j in range(id_offsets[i], id_offsets[i + 1]): + for k in range(ood_offsets[i], ood_offsets[i + 1]): + pair_recipient.append(i) + pair_id.append(j) + pair_ood.append(k) + weights.append(weight) + pair_recipient = np.asarray(pair_recipient, dtype=np.int64) + pair_id = np.asarray(pair_id, dtype=np.int64) + pair_ood = np.asarray(pair_ood, dtype=np.int64) + id_indices = np.asarray(id_indices, dtype=np.int64) + ood_indices = np.asarray(ood_indices, dtype=np.int64) + reason = np.full(n, "eligible", dtype="U40") + reason[(id_count == 0) & (ood_count > 0)] = "no_id_first_position_donor" + reason[(id_count > 0) & (ood_count == 0)] = "no_other_ood_donor" + reason[(id_count == 0) & (ood_count == 0)] = "no_id_or_other_ood_donor" + result = { + "original_rows": original.copy(), + "original_bridge": nodes[:, 1].copy(), + "original_atomic_indices": edges.copy(), + "original_prefix_contains_answer": original[:, 0] == original[:, -1], + "original_answer_equals_bridge": nodes[:, 1] == original[:, -1], + "common_valid": valid, + "reason": reason, + "id_candidate_count": id_count, + "ood_candidate_count": ood_count, + "id_second_only_candidate_count": second_only, + "id_unexposed_candidate_count": nominal_unexposed, + "rejected_same_head_count": rejected_same_head, + "rejected_answer_head_count": rejected_answer_head, + "id_candidate_offsets": id_offsets, + "ood_candidate_offsets": ood_offsets, + "id_donor_atomic_indices": id_indices, + "ood_donor_atomic_indices": ood_indices, + "id_donor_rows": atoms[id_indices].copy(), + "ood_donor_rows": atoms[ood_indices].copy(), + "id_recipient_indices": np.asarray(id_recipient, dtype=np.int64), + "ood_recipient_indices": np.asarray(ood_recipient, dtype=np.int64), + "pair_recipient_indices": pair_recipient, + "pair_rows": original[pair_recipient].copy(), + "pair_id_indices": pair_id, + "pair_ood_indices": pair_ood, + "pair_weights": np.asarray(weights, dtype=np.float64), + "pair_id_donor_rows": atoms[id_indices[pair_id]].copy(), + "pair_ood_donor_rows": atoms[ood_indices[pair_ood]].copy(), + "pair_self_donor_rows": atoms[edges[pair_recipient, 0]].copy(), + "atomic_is_id": is_id, + "atomic_single_training_exposure": np.asarray(exposure["atomic_record_counts"]).copy(), + "atomic_composite_table_position_counts": table_counts.copy(), + "atomic_composite_actual_position_exposure": position_counts.copy(), + "composite_record_training_exposure": np.asarray( + exposure["composite_record_counts"] + ).copy(), + } + trained = {tuple(map(int, row[:-1])) for row in world["train_composite"]} + for family in ("id", "ood"): + cf = result["pair_rows"].copy() + cf[:, 0] = result["pair_" + family + "_donor_rows"][:, 0] + _, cf_edges = path_details( + cf, atoms, world["metadata"]["entities"], world["metadata"]["relations"] + ) + if any(tuple(map(int, row[:-1])) in trained for row in cf): + raise ValueError("A same-bridge counterfactual query was used in training") + if is_id[cf_edges[:, 1]].any(): + raise ValueError("A donor has changed the recipient's OOD successor") + result["pair_" + family + "_counterfactual_rows"] = cf + result["pair_" + family + "_counterfactual_atomic_indices"] = cf_edges + result["pair_" + family + "_counterfactual_split"] = np.full( + len(cf), "mixed_id_ood" if family == "id" else "pure_ood", dtype="U16" + ) + result["audit"] = { + "dataset_sha256": checked["dataset_sha256"], + "exposure_cache_key": exposure["cache_key"], + "exposure_cache_spec": spec, + "recipient_split": "ood_composite", + "selection": "enumerate all graph-qualified ID x OOD pairs; no model-based selection", + "id_requirement": "same r1/bridge, different head, actual first-position exposure > 0", + "ood_requirement": ( + "same r1/bridge, different head, no composite exposure at either position" + ), + "answer_head_excluded": True, + "prefix_inputs": "donor_rows[:, :2]; bridge is audit truth, never model input", + "successor": "unchanged OOD second fact for both donor classes", + "all_recipient_n": n, + "id_available_n": int((id_count > 0).sum()), + "ood_available_n": int((ood_count > 0).sum()), + "common_n": int(valid.sum()), + "common_fraction": float(valid.mean()) if n else None, + "pair_n": len(pair_recipient), + "unique_original_first_facts_n": len(np.unique(edges[:, 0])), + "unique_original_second_facts_n": len(np.unique(edges[:, 1])), + "unique_common_first_facts_n": len(np.unique(edges[valid, 0])), + "unique_common_second_facts_n": len(np.unique(edges[valid, 1])), + "unique_common_id_donor_facts_n": len(np.unique(id_indices[pair_id])), + "unique_common_ood_donor_facts_n": len(np.unique(ood_indices[pair_ood])), + "unique_all_id_donor_facts_n": len(np.unique(id_indices)), + "unique_all_ood_donor_facts_n": len(np.unique(ood_indices)), + "unique_common_r1_bridge_groups_n": len( + np.unique(np.c_[original[valid, 1], nodes[valid, 1]], axis=0) + ), + "original_prefix_contains_answer_n": int(result["original_prefix_contains_answer"].sum()), + "common_prefix_contains_answer_n": int( + result["original_prefix_contains_answer"][valid].sum() + ), + "original_answer_equals_bridge_n": int(result["original_answer_equals_bridge"].sum()), + "common_answer_equals_bridge_n": int(result["original_answer_equals_bridge"][valid].sum()), + "common_first_edge_self_loop_n": int((original[valid, 0] == nodes[valid, 1]).sum()), + "common_id_donor_prefix_contains_answer_n": int( + (result["pair_id_donor_rows"][:, 0] == result["pair_rows"][:, -1]).sum() + ), + "common_ood_donor_prefix_contains_answer_n": int( + (result["pair_ood_donor_rows"][:, 0] == result["pair_rows"][:, -1]).sum() + ), + "id_second_only_candidate_n": int(second_only.sum()), + "id_unexposed_candidate_n": int(nominal_unexposed.sum()), + "missing_reasons": { + str(value): int((reason == value).sum()) for value in np.unique(reason) + }, + "aggregation": ( + "mean pairs per recipient, recipients per model, " + "initializations per world, worlds equally" + ), + } + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py new file mode 100644 index 0000000000000000000000000000000000000000..48fa45f53e08b7da9c17a92df8eb5ba4efd8a229 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py @@ -0,0 +1,353 @@ +"""Same-bridge prefix interventions, with query-balanced donor summaries. + +The donor selector never sees model scores. This evaluator reuses the audited +first-block component mixer; it does not retrain models or recompute the current +MLP after mixing. All candidate donors are evaluated, then averaged within the +recipient query before any world-level aggregation. +""" + +from __future__ import annotations + +import hashlib +import time + +import numpy as np +import torch + +from .grok_loop_mechanism import COMPONENTS, evaluate_condition, executed_blocks + +METRICS = ( + "answer_accuracy", + "complete_accuracy", + "eos_accuracy", + "target_probability", + "target_log_probability", + "target_margin", +) + + +def state_digest(model): + digest = hashlib.sha256() + for name, tensor in sorted(model.state_dict().items()): + digest.update(name.encode()) + value = tensor.detach().cpu().contiguous().numpy() + digest.update(str(value.dtype).encode()) + digest.update(str(value.shape).encode()) + digest.update(value.tobytes()) + return digest.hexdigest() + + +def prediction_metrics(prediction, targets): + targets = np.asarray(targets, dtype=np.int64) + logits = np.asarray(prediction["answer_logits"], dtype=np.float64) + answer, stop = prediction["answer"], prediction["stop"] + if logits.ndim != 2 or logits.shape[0] != len(targets): + raise ValueError("Logits and targets must align") + if answer.shape != targets.shape or stop.shape != targets.shape: + raise ValueError("Generated answers and EOS must align with targets") + if not np.isfinite(logits).all(): + raise ValueError("Nonfinite answer logits") + if len(targets) and (targets.min() < 0 or targets.max() >= logits.shape[1]): + raise ValueError("Target outside vocabulary") + maximum = logits.max(axis=1) if len(targets) else np.empty(0) + partition = maximum + np.log(np.exp(logits - maximum[:, None]).sum(axis=1)) + target_logits = logits[np.arange(len(targets)), targets] + competitors = logits.copy() + competitors[np.arange(len(targets)), targets] = -np.inf + log_probability = target_logits - partition + return { + "answer_accuracy": (answer == targets).astype(np.float64), + "complete_accuracy": ((answer == targets) & (stop == 1)).astype(np.float64), + "eos_accuracy": (stop == 1).astype(np.float64), + "target_probability": np.exp(log_probability), + "target_log_probability": log_probability, + "target_margin": target_logits - competitors.max(axis=1), + } + + +def query_mean(values, recipient_indices, n_recipients): + """Missing recipients remain NaN; repeated donors never add query weight.""" + values = np.asarray(values, dtype=np.float64) + indices = np.asarray(recipient_indices, dtype=np.int64) + if values.shape != indices.shape or not np.isfinite(values).all(): + raise ValueError("Finite, aligned one-dimensional donor values are required") + if len(indices) and (indices.min() < 0 or indices.max() >= n_recipients): + raise ValueError("Recipient index outside query pool") + count = np.bincount(indices, minlength=n_recipients) + sums = np.bincount(indices, weights=values, minlength=n_recipients) + result = np.full(n_recipients, np.nan) + np.divide(sums, count, out=result, where=count > 0) + return result + + +def summarize(values, recipient_indices, selected, n_recipients): + selected = np.asarray(selected, dtype=bool) + if selected.shape != (n_recipients,): + raise ValueError("Selection must align with the complete recipient pool") + indices = np.asarray(recipient_indices, dtype=np.int64) + n = int(selected.sum()) + metrics = {} + available = np.zeros(n_recipients, dtype=bool) + available[indices] = True + mask = selected & available + for name in METRICS: + balanced = query_mean(values[name], indices, n_recipients) + metrics[name] = float(balanced[mask].mean()) if mask.any() else None + return { + "n_recipients": int(mask.sum()), + "selected_recipients": n, + "total_recipients": n_recipients, + "coverage": float(mask.mean()) if n_recipients else None, + "n_donor_evaluations": int(selected[indices].sum()), + **metrics, + } + + +def _equal_predictions(left, right, label): + for name in ("answer", "stop", "answer_logits"): + if not np.array_equal(left[name], right[name]): + raise AssertionError(f"{label}: {name} differs") + + +def _fixed_batch_evaluate(model, inputs, device, physical_batch, **kwargs): + """Keep GPU matrix shapes equal to the full historical recipient batch. + + Duplicate padding rows exist only to fill the physical batch and are + discarded before scoring or saving. No PAD row is treated as a donor. + """ + if not len(inputs): + return evaluate_condition(model, inputs, device, 4, batch_size=physical_batch, **kwargs) + prefixes = kwargs.pop("donor_prefixes", None) + outputs = [] + audits = [] + for start in range(0, len(inputs), physical_batch): + actual = min(physical_batch, len(inputs) - start) + block = inputs[start : start + actual] + padded = np.concatenate([block, np.repeat(block[-1:], physical_batch - actual, axis=0)]) + arguments = dict(kwargs) + if prefixes is not None: + prefix = prefixes[start : start + actual] + arguments["donor_prefixes"] = np.concatenate( + [prefix, np.repeat(prefix[-1:], physical_batch - actual, axis=0)] + ) + prediction, audit = evaluate_condition( + model, padded, device, 4, batch_size=physical_batch, **arguments + ) + outputs.append({field: value[:actual] for field, value in prediction.items()}) + audits.append(audit) + return {field: np.concatenate([row[field] for row in outputs]) for field in outputs[0]}, { + "native_comparison_performed": all(row["native_comparison_performed"] for row in audits), + "native_max_logit_delta": max(row["native_max_logit_delta"] for row in audits), + "prefix_only_vs_full_all_layers_max_delta": max( + row["prefix_only_vs_full_all_layers_max_delta"] for row in audits + ), + "physical_batch_size": physical_batch, + "scored_evaluations": len(inputs), + "discarded_duplicate_padding": len(outputs) * physical_batch - len(inputs), + } + + +@torch.no_grad() +def evaluate_same_bridge(model, world, donors, *, device="cuda:0", batch_size=1024): + started = time.perf_counter() + model.eval() + before = state_digest(model) + if any(parameter.requires_grad for parameter in model.parameters()): + raise ValueError("All model parameters must be frozen") + rows = donors["original_rows"] + if not np.array_equal(rows, world["ood_composite"]) or rows.shape[1] != 4: + raise ValueError("Expected the unchanged complete pure-OOD two-hop pool") + n = len(rows) + arrays = {k: v.copy() for k, v in donors.items() if isinstance(v, np.ndarray)} + results, values, descriptions, engineering = {}, {}, {}, {} + + def evaluate(name, inputs, indices, **kwargs): + prediction, audit = _fixed_batch_evaluate( + model, inputs, device, max(1, min(n, batch_size)), **kwargs + ) + indices = np.asarray(indices, dtype=np.int64) + measured = prediction_metrics(prediction, inputs[:, -1]) + for field, vector in {**prediction, **measured}.items(): + arrays[name + "_" + field] = vector + arrays[name + "_recipient_indices"] = indices + results[name], values[name] = prediction, measured + descriptions[name] = { + "n_evaluations": len(inputs), + "patch_layer": kwargs.get("patch_layer"), + "component": kwargs.get("component"), + "identity": kwargs.get("identity", False), + "prefix_only": kwargs.get("donor_prefixes") is not None, + } + engineering[name] = audit + return prediction + + all_indices = np.arange(n, dtype=np.int64) + baseline = evaluate("baseline", rows, all_indices, verify_trace=True) + for component in COMPONENTS: + self_result = evaluate( + "self_" + component, + rows, + all_indices, + patch_layer=0, + component=component, + identity=True, + ) + prefix_result = evaluate( + "original_prefix_" + component, + rows, + all_indices, + patch_layer=0, + component=component, + donor_prefixes=rows[:, :2], + ) + _equal_predictions(baseline, self_result, "self " + component) + _equal_predictions(baseline, prefix_result, "original prefix " + component) + + atomic_prediction, atomic_audit = evaluate_condition( + model, world["atomic"], device, 4, batch_size=batch_size, verify_trace=True + ) + arrays["atomic_rows"] = world["atomic"].copy() + for field, vector in atomic_prediction.items(): + arrays["atomic_" + field] = vector + atomic_complete = (atomic_prediction["answer"] == world["atomic"][:, -1]) & ( + atomic_prediction["stop"] == 1 + ) + arrays["atomic_complete_correct"] = atomic_complete + arrays["original_atomic_complete_correct"] = atomic_complete[donors["original_atomic_indices"]] + engineering["atomic_native"] = atomic_audit + atom_lookup = {tuple(map(int, r)): i for i, r in enumerate(world["atomic"])} + for family in ("id", "ood"): + indices = donors[family + "_recipient_indices"] + inputs = rows[indices] + donor_rows = donors[family + "_donor_rows"] + prefixes = donor_rows[:, :2] + counterfactual = inputs.copy() + counterfactual[:, 0] = donor_rows[:, 0] + atomic_indices = np.asarray( + [atom_lookup[tuple(map(int, r))] for r in donor_rows], dtype=np.int64 + ) + arrays[family + "_donor_atomic_indices"] = atomic_indices + arrays[family + "_donor_atomic_complete_correct"] = atomic_complete[atomic_indices] + matched = evaluate(family + "_baseline", inputs, indices) + _equal_predictions( + {k: v[indices] for k, v in baseline.items()}, matched, family + " batch match" + ) + engineering[family + "_batch_shape_comparison"] = { + "answers_and_eos_identical": True, + "max_logit_delta": 0.0, + "bitwise_equal_full_logits": True, + "intervention_baseline_has_identical_batch_shape": True, + } + evaluate(family + "_counterfactual", counterfactual, indices) + self_result = evaluate( + family + "_self", + inputs, + indices, + patch_layer=0, + component="full", + identity=True, + ) + _equal_predictions(matched, self_result, family + " self") + for component in COMPONENTS: + evaluate( + family + "_" + component, + inputs, + indices, + patch_layer=0, + component=component, + donor_prefixes=prefixes, + ) + if len(executed_blocks(model)) == 1: + _equal_predictions(matched, results[family + "_" + component], "C1 inert patch") + _equal_predictions( + results[family + "_both"], results[family + "_full"], family + " both/full" + ) + + common = donors["common_valid"] + groups = { + "all": np.ones(n, dtype=bool), + "paired": common, + "id_only": (donors["id_candidate_count"] > 0) & (donors["ood_candidate_count"] == 0), + "ood_only": (donors["id_candidate_count"] == 0) & (donors["ood_candidate_count"] > 0), + "neither": (donors["id_candidate_count"] == 0) & (donors["ood_candidate_count"] == 0), + "paired_original_atomics_correct": common + & arrays["original_atomic_complete_correct"].all(axis=1), + "paired_baseline_failed": common & (values["baseline"]["complete_accuracy"] == 0), + "paired_baseline_correct": common & (values["baseline"]["complete_accuracy"] == 1), + } + # Conditional diagnostics are reported alongside the unfiltered paired pool. + pid, pod = donors["pair_id_indices"], donors["pair_ood_indices"] + pair_indices = donors["pair_recipient_indices"] + known_pair = arrays["original_atomic_complete_correct"][pair_indices].all(axis=1) + known_pair &= arrays["id_donor_atomic_complete_correct"][pid] + known_pair &= arrays["ood_donor_atomic_complete_correct"][pod] + cf_pair = values["id_counterfactual"]["complete_accuracy"][pid].astype(bool) + cf_pair &= values["ood_counterfactual"]["complete_accuracy"][pod].astype(bool) + arrays["pair_all_atomics_correct"] = known_pair + arrays["pair_both_counterfactual_correct"] = cf_pair + # A query is included in the following conditional subset only if every + # registered donor pair satisfies the prerequisite, avoiding donor picking. + for name, flag in ( + ("all_atomics_correct", known_pair), + ("both_counterfactual_correct", cf_pair), + ): + average = query_mean(flag.astype(float), pair_indices, n) + groups["paired_" + name] = common & (average == 1) + for name, mask in groups.items(): + arrays["subset_" + name] = mask + + scores = {} + for group, selected in groups.items(): + scores[group] = { + condition: summarize(measured, arrays[condition + "_recipient_indices"], selected, n) + for condition, measured in values.items() + } + contrasts = {} + for component in COMPONENTS: + id_values, ood_values = values["id_" + component], values["ood_" + component] + difference = { + metric: id_values[metric][pid] - ood_values[metric][pod] for metric in METRICS + } + adjusted = { + metric: (id_values[metric][pid] - values["id_baseline"][metric][pid]) + - (ood_values[metric][pod] - values["ood_baseline"][metric][pod]) + for metric in METRICS + } + for group, mask in groups.items(): + contrasts[group + ":" + component] = { + "id_minus_ood": summarize(difference, pair_indices, mask, n), + "baseline_adjusted_id_minus_ood": summarize(adjusted, pair_indices, mask, n), + } + after = state_digest(model) + if before != after: + raise AssertionError("Interventions changed model parameters or buffers") + return arrays, { + "seconds": time.perf_counter() - started, + "n_original_queries": n, + "n_common_queries": int(common.sum()), + "n_pairs": len(pair_indices), + "conditions": descriptions, + "scores": scores, + "contrasts": contrasts, + "engineering": { + "native_and_prefix_checks": engineering, + "all_self_and_original_prefix_conditions_equal_baseline": True, + "both_equals_full_first_execution_layer": True, + "c1_last_block_inert": len(executed_blocks(model)) == 1, + "parameters_unchanged": True, + "model_state_sha256_before": before, + "model_state_sha256_after": after, + "mlp_recomputed_after_mixing": False, + "donor_nonpadding_tokens": 2, + "patch_layer": 0, + "patch_position": 1, + "eos_uses_generated_answer": True, + "training_updates": 0, + "physical_condition_batch_size": max(1, min(n, batch_size)), + "duplicate_padding_never_scored_or_saved": True, + }, + "statistical_unit": ( + "mean over all donors within recipient; initialization within world; equal worlds" + ), + "selection": "graph and registered training exposures only; scores do not select donors", + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_supervision.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_supervision.py new file mode 100644 index 0000000000000000000000000000000000000000..104364e93299229e1a8216acabb046e5fae1dde4 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_supervision.py @@ -0,0 +1,349 @@ +"""Paired continuation: terminal versus distributed answer supervision. + +Historical model/trainer files remain unchanged. All heads branch off the same +trajectory; their LayerNorm outputs never replace the recurrent residual state. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig +from .grok_depth import GraphStep, make_optimizer, utc, write_json +from .grok_loop_data import StratifiedStream +from .grok_loop_model import LoopGPT, flops +from .grok_multihop import pack_rows + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def tensor_digest(tensors): + h = hashlib.sha256() + for key, value in sorted(tensors.items()): + h.update(key.encode()) + h.update(value.detach().cpu().contiguous().numpy().tobytes()) + return h.hexdigest() + + +class SupervisionGPT(LoopGPT): + def states(self, tokens, repeats): + """Yield full group-boundary states with exactly the native dropout order.""" + p = self.dropout if self.training else 0.0 + x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device)) + x = F.dropout(x, p=p, training=self.training) + for _ in range(repeats): + for block in self.blocks: + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=p, + ) + y = a.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + F.dropout(y, p=p, training=self.training) + x = x + F.dropout(block.mlp(block.ln2(x)), p=p, training=self.training) + yield x + + def readout(self, x, positions=None): + x = self.ln_final(x) + if positions is not None: + x = x[torch.arange(len(x), device=x.device)[:, None], positions] + return F.linear(x, self.token.weight) + + def at_loops(self, tokens, positions, loops=(2, 3, 4)): + if not loops or tuple(sorted(set(loops))) != tuple(loops) or loops[0] < 1: + raise ValueError("Loop endpoints must be positive, unique, sorted") + return tuple( + self.readout(x, positions) + for r, x in enumerate(self.states(tokens, max(loops)), 1) + if r in loops + ) + + +def answer_losses(model, x, positions, labels): + return torch.stack( + [F.cross_entropy(z.flatten(0, 1), labels.flatten()) for z in model.at_loops(x, positions)] + ) + + +class SupervisionStep(GraphStep): + """Both arms execute all three CE/backward branches, including zero weights.""" + + def __init__(self, model, optimizer, table, batch_size, arm): + if arm not in ("single", "multi"): + raise ValueError(arm) + weights = [0.0, 0.0, 1.0] if arm == "single" else [1 / 3] * 3 + self.weights = torch.tensor(weights, device=table[0].device) + super().__init__(model, optimizer, table, batch_size) + + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, pos, labels = (t[self.index] for t in self.table) + self.components = answer_losses(self.model, x, pos, labels) + loss = (self.components * self.weights).sum() + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def from_state(state, device): + spec = state["spec"] + cfg = ModelConfig( + vocab_size=2 + spec["entities"] + spec["relations"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=8, + ) + model = SupervisionGPT( + cfg, + repeats=spec["repeats"], + dropout=spec["dropout"], + initialization=spec["init_scheme"], + ).to(device) + model.load_state_dict(state["model"]) + return model + + +def score_predictions(pred): + correct = pred["answer"] == pred["target"] + return { + "n": len(correct), + "accuracy": float((correct & (pred["stop"] == 1)).mean()), + "answer_accuracy": float(correct.mean()), + "eos_accuracy": float((pred["stop"] == 1).mean()), + "nll": float(pred["nll"].mean()), + "answer_nll": float(pred["nll"][:, 0].mean()), + "answer_probability": float(np.exp(-pred["nll"][:, 0].astype(float)).mean()), + "margin": float(pred["margin"].mean()), + } + + +@torch.no_grad() +def evaluate(model, rows, device, repeats, batch_size=1024): + was_training = model.training + model.eval() + packed = pack_rows(rows, 4) + parts = [] + for start in range(0, len(rows), batch_size): + x, pos, labels = ( + torch.as_tensor(a[start : start + batch_size], device=device) for a in packed + ) + x = x.clone() + z = model(x, pos, repeats=repeats) + nll = F.cross_entropy(z.flatten(0, 1), labels.flatten(), reduction="none").view(-1, 2) + answer = z[:, 0].argmax(-1) + x[torch.arange(len(x), device=device), pos[:, 1]] = answer + eos = model(x, pos, repeats=repeats)[:, 1] + target_score = z[:, 0].gather(1, labels[:, :1]).squeeze(1) + alternatives = z[:, 0].clone() + alternatives.scatter_(1, labels[:, :1], -torch.inf) + parts.append( + { + "answer": answer.cpu().numpy(), + "stop": eos.argmax(-1).cpu().numpy(), + "target": labels[:, 0].cpu().numpy(), + "nll": nll.cpu().numpy(), + "margin": (target_score - alternatives.max(-1).values).cpu().numpy(), + "logits": z.cpu().numpy(), + "generated_eos_logits": eos.cpu().numpy(), + } + ) + model.train(was_training) + pred = {k: np.concatenate([p[k] for p in parts]) for k in parts[0]} + return score_predictions(pred), pred + + +def load_world(source): + with np.load(Path(source) / "world.npz", allow_pickle=False) as z: + world = {k: z[k].copy() for k in z.files} + world["metadata"] = json.loads((Path(source) / "world-metadata.json").read_text()) + return world + + +def restore_rng(state, device): + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + + +def run(spec, out, device, resume=False): + out, device = Path(out), torch.device(device) + source = Path(spec["source"]) + origin = torch.load(source / "latest.pt", map_location=device, weights_only=False) + if origin["step"] != 128000 or origin["spec"]["hops"] != 2: + raise ValueError("Expected completed historical two-hop checkpoint") + world = load_world(source) + current = ( + torch.load(out / "latest.pt", map_location=device, weights_only=False) if resume else origin + ) + if resume and current["continuation"] != spec: + raise ValueError("Resume contract changed") + model = from_state(current, device) + lr = torch.tensor(spec["lr"], device=device) + opt = make_optimizer(model, lr, origin["spec"]["weight_decay"]) + opt.load_state_dict(current["optimizer"]) + lr = opt.param_groups[0]["lr"] + for group in opt.param_groups: + group["lr"] = lr + lr.fill_(spec["lr"]) + packed = [pack_rows(world[name], 4) for name in ("atomic", "train_composite")] + table = tuple( + torch.as_tensor(np.concatenate(a), device=device) for a in zip(*packed, strict=True) + ) + stream = StratifiedStream( + len(world["atomic"]), + len(world["train_composite"]), + 256, + 32, + origin["spec"]["stream_seed"], + ) + stream.load_state_dict(current["stream"]) + restore_rng(current, device) + step = current["step"] if resume else 0 + training_seconds = current.get("continuation_training_seconds", 0.0) if resume else 0.0 + records = json.loads((out / "learning.json").read_text()) if resume else [] + records = [r for r in records if r["step"] <= step] + before_capture = tensor_digest(model.state_dict()) + optimizer_before = { + p: {k: v.clone() for k, v in s.items() if torch.is_tensor(v)} for p, s in opt.state.items() + } + model.train() + graph = SupervisionStep(model, opt, table, 256, spec["arm"]) + capture_ok = before_capture == tensor_digest(model.state_dict()) and all( + torch.equal(v, opt.state[p][k]) for p, s in optimizer_before.items() for k, v in s.items() + ) + if not capture_ok: + raise ValueError("CUDA capture altered source model/optimizer") + del optimizer_before + flop_step = flops(model.config, 4, 256, 4, output_positions=6) + sampling_hash = hashlib.sha256() + # Persist cumulative per-row exposure as well as stream state for paired audit. + exposure = ( + current["continuation_exposure"].cpu().numpy() + if resume + else np.zeros(len(table[0]), dtype=np.int64) + ) + + def measure(at, components=None): + rng = {"cpu_rng": torch.get_rng_state(), "cuda_rng": torch.cuda.get_rng_state(device)} + row = { + "step": at, + "utc": utc(), + "training_seconds": training_seconds, + "estimated_training_matmul_flops": at * flop_step, + "logical_examples": at * 256, + "atomic_presentations": at * 32, + "composite_presentations": at * 224, + "weighted_target_tokens": at * 256 * 2, + "executed_loss_target_tokens": at * 256 * 2 * 3, + "last_batch_losses_2_3_4": components, + "evaluations": {}, + } + repeats = spec["endpoint_repeats"] if at in (0, spec["steps"]) else [2, 3, 4, 8] + preds = {} + for name in ("atomic", "test_full_composite", "ood_composite", "train_composite"): + counts = [2, 3, 4] if name == "train_composite" else repeats + for r in counts: + metric, pred = evaluate(model, world[name], device, r) + key = f"{name}_r{r}" + row["evaluations"][key] = metric + preds.update({key + "_" + k: v for k, v in pred.items()}) + if name == "atomic": + for subset in ("id_atomic", "ood_atomic"): + ids = {tuple(x) for x in world[subset]} + mask = np.array([tuple(x) in ids for x in world["atomic"]]) + row["evaluations"][f"{subset}_r{r}"] = score_predictions( + {k: v[mask] for k, v in pred.items()} + ) + records.append(row) + write_json(out / "learning.json", records) + np.savez_compressed(out / f"predictions-{at:07d}.npz", **preds) + restore_rng(rng, device) + state = { + "spec": origin["spec"], + "continuation": spec, + "step": at, + "source_training_step": origin["step"], + "model": model.state_dict(), + "optimizer": opt.state_dict(), + "stream": stream.state_dict(), + "cpu_rng": rng["cpu_rng"], + "cuda_rng": rng["cuda_rng"], + "continuation_exposure": torch.as_tensor(exposure), + "continuation_training_seconds": training_seconds, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + torch.save( + {"spec": origin["spec"], "step": at, "model": model.state_dict()}, + out / f"weights-{at:07d}.pt", + ) + ev = row["evaluations"] + status = { + "state": "complete" if at == spec["steps"] else "running", + "step": at, + "arm": spec["arm"], + "ood_r4": ev["ood_composite_r4"]["accuracy"], + "ood_r8": ev["ood_composite_r8"]["accuracy"], + "atomic_r4": ev["atomic_r4"]["accuracy"], + "id_r4": ev["test_full_composite_r4"]["accuracy"], + "utc": utc(), + } + write_json(out / "status.json", status) + print(json.dumps(status), flush=True) + return row + + if not resume: + measure(0) + for end in [n for n in spec["nodes"] if n > step]: + model.train() + torch.cuda.synchronize() + start = time.perf_counter() + while step < end: + n = min(256, end - step) + ix = np.stack([stream.take() for _ in range(n)]) + exposure += np.bincount(ix.ravel(), minlength=len(exposure)) + sampling_hash.update(ix.tobytes()) + gpu_ix = torch.as_tensor(ix, device=device) + for j in range(n): + graph(gpu_ix[j]) + step += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - start + values = graph.components.detach().cpu().tolist() + if not all(math.isfinite(v) for v in values): + raise FloatingPointError(f"Nonfinite component losses at {step}") + measure(step, values) + if not records or records[-1]["step"] != spec["steps"]: + raise ValueError("Budget not reached") + write_json( + out / "complete.json", + { + "spec": spec, + "completed_utc": utc(), + "capture_restore_passed": capture_ok, + "training_seconds": training_seconds, + "endpoint": records[-1], + "initial_model_sha256": tensor_digest(origin["model"]), + "final_model_sha256": tensor_digest(model.state_dict()), + "exposure_sha256": hashlib.sha256(exposure.tobytes()).hexdigest(), + "sampling_segment_sha256": sampling_hash.hexdigest(), + "segment_start": current["step"] if resume else 0, + }, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_train.py new file mode 100644 index 0000000000000000000000000000000000000000..ffee809fcc7335c7b68e3321427ffcc0342c3086 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_loop_train.py @@ -0,0 +1,214 @@ +"""Frozen loop comparison trainer with stratified exposure and executed-depth FLOPs.""" + +from __future__ import annotations + +import json +import math +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_model import ModelConfig +from .grok_depth import GraphStep, make_optimizer, utc, write_json +from .grok_loop_data import StratifiedStream +from .grok_loop_model import LoopGPT, flops +from .grok_multihop import autonomous_calls, evaluate_rows, pack_rows + + +def run(spec, world, out, device="cuda:0", resume=False): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.manual_seed(spec["initialization"]) + torch.cuda.manual_seed_all(spec["initialization"]) + device = torch.device(device) + torch.cuda.set_device(device) + padded_length = spec["hops"] + 2 + cfg = ModelConfig( + vocab_size=2 + spec["entities"] + spec["relations"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=8, + ) + model = LoopGPT( + cfg, + repeats=spec["repeats"], + dropout=spec["dropout"], + initialization=spec["init_scheme"], + ).to(device) + lr = torch.tensor(spec["lr"], dtype=torch.float32, device=device) + opt = make_optimizer(model, lr, spec["weight_decay"]) + atoms = pack_rows(world["atomic"], padded_length) + comps = pack_rows(world["train_composite"], padded_length) + table = tuple( + torch.as_tensor(np.concatenate([a, c]), device=device) + for a, c in zip(atoms, comps, strict=True) + ) + stream = StratifiedStream( + len(world["atomic"]), + len(world["train_composite"]), + spec["batch_size"], + spec["n_atomic_per_batch"], + spec["stream_seed"], + ) + counts = {"atomic": 0, "composite": 0} + elapsed_training, elapsed_eval = 0.0, 0.0 + start_step = 0 + checkpoint = out / "latest.pt" + if resume: + state = torch.load(checkpoint, map_location=device, weights_only=False) + if state["spec"] != spec: + raise ValueError("Resume spec differs from saved state") + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + lr = opt.param_groups[0]["lr"] + for group in opt.param_groups: + group["lr"] = lr + stream.load_state_dict(state["stream"]) + counts = state["counts"] + elapsed_training = state["elapsed_training"] + elapsed_eval = state["elapsed_eval"] + start_step = state["step"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + started = time.perf_counter() + graph = GraphStep(model, opt, table, spec["batch_size"]) + capture_seconds = time.perf_counter() - started + names = ( + "atomic", + "id_atomic", + "ood_atomic", + "train_composite", + "test_composite", + "ood_composite", + ) + nparams = sum(p.numel() for p in model.parameters()) + flop_step = flops( + cfg, spec["repeats"], spec["batch_size"], sequence=padded_length, output_positions=2 + ) + rows_log = [] + if (out / "learning.json").exists(): + rows_log = json.loads((out / "learning.json").read_text()) + if resume: + rows_log = list({r["step"]: r for r in rows_log if r["step"] <= start_step}.values()) + rows_log.sort(key=lambda row: row["step"]) + + def measure(step, last_loss=None): + nonlocal elapsed_eval + torch.cuda.synchronize() + t0 = time.perf_counter() + row = { + "step": step, + "utc": utc(), + "hops": spec["hops"], + "parameters": nparams, + "unique_layers": spec["layers"], + "repeats": spec["repeats"], + "effective_depth": spec["layers"] * spec["repeats"], + "training_seconds": elapsed_training, + "capture_seconds": capture_seconds, + "examples": step * spec["batch_size"], + "counts": counts.copy(), + "effective_input_tokens": counts["atomic"] * 3 + counts["composite"] * padded_length, + "supervised_tokens": step * spec["batch_size"] * 2, + "estimated_training_flops": step * flop_step, + "last_batch_loss": last_loss, + } + predictions = {} + selected_names = names + (("test_full_composite",) if step == spec["steps"] else ()) + for name in selected_names: + row[name], pred = evaluate_rows(model, world[name], device, padded_length) + predictions.update({name + "_" + key: value for key, value in pred.items()}) + row["autonomous_calls"], calls_pred = autonomous_calls( + model, world["test_composite"], world, device, padded_length + ) + predictions.update({"autonomous_" + key: value for key, value in calls_pred.items()}) + torch.cuda.synchronize() + elapsed_eval += time.perf_counter() - t0 + row["evaluation_seconds"] = elapsed_eval + rows_log.append(row) + write_json(out / "learning.json", rows_log) + np.savez_compressed(out / f"predictions-{step:07d}.npz", **predictions) + state = { + "step": step, + "spec": spec, + "model": model.state_dict(), + "optimizer": opt.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "elapsed_training": elapsed_training, + "elapsed_eval": elapsed_eval, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(checkpoint) + if step in spec["weight_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"weights-{step:07d}.pt", + ) + status = { + "state": "complete" if step == spec["steps"] else "running", + "step": step, + "budget": spec["steps"], + "updated_utc": utc(), + "hops": spec["hops"], + "layers": spec["layers"], + "atomic": row["atomic"]["accuracy"], + "train": row["train_composite"]["accuracy"], + "test_probe": row["test_composite"]["accuracy"], + } + write_json(out / "status.json", status) + print(json.dumps(status), flush=True) + return row + + if not resume: + measure(0) + if start_step < spec["steps"]: + for end in (s for s in spec["nodes"] if s > start_step): + last_loss = None + torch.cuda.synchronize() + t0 = time.perf_counter() + step = start_step + while step < end: + n = min(512, end - step) + ix = np.stack([stream.take() for _ in range(n)]) + atom_count = int((ix < len(world["atomic"])).sum()) + counts["atomic"] += atom_count + counts["composite"] += ix.size - atom_count + gpu_ix = torch.as_tensor(ix, device=device) + for j in range(n): + lr.fill_(spec["lr"] * min(1.0, (step + j + 1) / spec["warmup"])) + last_loss = graph(gpu_ix[j]) + step += n + torch.cuda.synchronize() + elapsed_training += time.perf_counter() - t0 + loss_value = float(last_loss.detach()) + if not math.isfinite(loss_value): + raise FloatingPointError(f"Nonfinite loss at step {end}") + measure(end, loss_value) + start_step = end + if not rows_log or rows_log[-1]["step"] != spec["steps"]: + raise ValueError("Evaluation nodes did not reach the fixed budget") + write_json( + out / "complete.json", + { + "finished_utc": utc(), + "spec": spec, + "parameters": nparams, + "unique_layers": spec["layers"], + "repeats": spec["repeats"], + "effective_depth": spec["layers"] * spec["repeats"], + "training_seconds": elapsed_training, + "evaluation_seconds": elapsed_eval, + "endpoint": rows_log[-1], + }, + ) + return rows_log[-1] diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop.py new file mode 100644 index 0000000000000000000000000000000000000000..7d0824b5e038658e91c3cbc5e521a316861f20a4 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop.py @@ -0,0 +1,278 @@ +"""Longer-path trainer reusing the historical GPT, optimizer and graph step. + +The only task changes are longer input rows and the separately audited split. +Training uses the same uniform combined-set epochs and tail-plus-EOS loss. +""" + +from __future__ import annotations + +import json +import math +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig, matmul_flops +from .grok_depth import EpochStream, GraphStep, SmallGPT, make_optimizer, utc, write_json +from .grok_multihop_data import path_details + + +def pack_rows(rows, padded_length): + rows = np.asarray(rows, dtype=np.int64) + if rows.ndim != 2 or rows.shape[1] > padded_length or rows.shape[1] < 3: + raise ValueError("Rows must fit the fixed padded length and include an answer") + x = np.zeros((len(rows), padded_length), dtype=np.int64) + x[:, : rows.shape[1]] = rows + positions = np.tile([rows.shape[1] - 2, rows.shape[1] - 1], (len(rows), 1)) + labels = np.c_[rows[:, -1], np.ones(len(rows), dtype=np.int64)] + return x, positions, labels + + +@torch.no_grad() +def evaluate_rows(model, rows, device, padded_length, batch_size=1024): + was_training = model.training + model.eval() + packed = pack_rows(rows, padded_length) + answers, stops, losses = [], [], [] + for start in range(0, len(rows), batch_size): + x, positions, labels = ( + torch.as_tensor(a[start : start + batch_size], device=device) for a in packed + ) + # as_tensor shares CPU memory when device=cpu; all writes occur in a copy. + x = x.clone() + logits = model(x, positions) + losses.append( + F.cross_entropy(logits.flatten(0, 1), labels.flatten(), reduction="none") + .view(-1, 2) + .cpu() + .numpy() + ) + answer = logits[:, 0].argmax(-1) + x[torch.arange(len(x), device=device), positions[:, 1]] = answer + stop = model(x, positions)[:, 1].argmax(-1) + answers.append(answer.cpu().numpy()) + stops.append(stop.cpu().numpy()) + model.train(was_training) + if not len(rows): + return {"n": 0, "answer_accuracy": None, "accuracy": None, "nll": None}, {} + answer, stop, nll = np.concatenate(answers), np.concatenate(stops), np.concatenate(losses) + correct = answer == rows[:, -1] + return { + "n": len(rows), + "answer_accuracy": float(correct.mean()), + "accuracy": float((correct & (stop == 1)).mean()), + "nll": float(nll.mean()), + }, {"answer": answer, "stop": stop, "nll": nll, "target": rows[:, -1]} + + +@torch.no_grad() +def autonomous_calls(model, rows, world, device, padded_length): + """Supply relation decomposition, but carry the model's own intermediate answers.""" + if not len(rows): + return {"n": 0, "answer_accuracy": None, "accuracy": None}, {} + meta = world["metadata"] + nodes, _ = path_details(rows, world["atomic"], meta["entities"], meta["relations"]) + current = rows[:, 0].copy() + all_eos = np.ones(len(rows), dtype=bool) + all_correct = np.ones(len(rows), dtype=bool) + predictions, hop_accuracy = {}, [] + for j in range(meta["hops"]): + # Gold target only scores the answer; causality prevents answer-label access. + queries = np.c_[current, rows[:, j + 1], nodes[:, j + 1]] + metrics, pred = evaluate_rows(model, queries, device, padded_length) + current = pred["answer"] + all_eos &= pred["stop"] == 1 + all_correct &= current == nodes[:, j + 1] + hop_accuracy.append(metrics["accuracy"]) + predictions[f"hop{j + 1}_answer"] = current + predictions[f"hop{j + 1}_stop"] = pred["stop"] + return { + "n": len(rows), + "calls": meta["hops"], + "answer_accuracy": float((current == rows[:, -1]).mean()), + "accuracy": float(((current == rows[:, -1]) & all_eos).mean()), + "all_intermediate_answers_and_eos_correct": float((all_correct & all_eos).mean()), + "hop_accuracy": hop_accuracy, + "extra_information": "given relation decomposition, own generated bridge entities", + }, predictions + + +def run(spec, world, out, device="cuda:0", resume=False): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.manual_seed(spec["initialization"]) + torch.cuda.manual_seed_all(spec["initialization"]) + device = torch.device(device) + torch.cuda.set_device(device) + padded_length = spec["hops"] + 2 + cfg = ModelConfig( + vocab_size=2 + spec["entities"] + spec["relations"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=8, + ) + model = SmallGPT(cfg, spec["dropout"]).to(device) + lr = torch.tensor(spec["lr"], dtype=torch.float32, device=device) + opt = make_optimizer(model, lr, spec["weight_decay"]) + atoms = pack_rows(world["atomic"], padded_length) + comps = pack_rows(world["train_composite"], padded_length) + table = tuple( + torch.as_tensor(np.concatenate([a, c]), device=device) + for a, c in zip(atoms, comps, strict=True) + ) + stream = EpochStream(len(table[0]), spec["stream_seed"]) + counts = {"atomic": 0, "composite": 0} + elapsed_training, elapsed_eval = 0.0, 0.0 + start_step = 0 + checkpoint = out / "latest.pt" + if resume: + state = torch.load(checkpoint, map_location=device, weights_only=False) + if state["spec"] != spec: + raise ValueError("Resume spec differs from saved state") + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + lr = opt.param_groups[0]["lr"] + for group in opt.param_groups: + group["lr"] = lr + stream.load_state_dict(state["stream"]) + counts = state["counts"] + elapsed_training = state["elapsed_training"] + elapsed_eval = state["elapsed_eval"] + start_step = state["step"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + started = time.perf_counter() + graph = GraphStep(model, opt, table, spec["batch_size"]) + capture_seconds = time.perf_counter() - started + names = ( + "atomic", + "id_atomic", + "ood_atomic", + "train_composite", + "test_composite", + "ood_composite", + ) + nparams = sum(p.numel() for p in model.parameters()) + flop_step = matmul_flops(cfg, spec["batch_size"], sequence=padded_length, output_positions=2) + rows_log = [] + if (out / "learning.json").exists(): + rows_log = json.loads((out / "learning.json").read_text()) + if resume: + rows_log = list({r["step"]: r for r in rows_log if r["step"] <= start_step}.values()) + rows_log.sort(key=lambda row: row["step"]) + + def measure(step, last_loss=None): + nonlocal elapsed_eval + torch.cuda.synchronize() + t0 = time.perf_counter() + row = { + "step": step, + "utc": utc(), + "hops": spec["hops"], + "parameters": nparams, + "training_seconds": elapsed_training, + "capture_seconds": capture_seconds, + "examples": step * spec["batch_size"], + "counts": counts.copy(), + "effective_input_tokens": counts["atomic"] * 3 + counts["composite"] * padded_length, + "supervised_tokens": step * spec["batch_size"] * 2, + "estimated_training_flops": step * flop_step, + "last_batch_loss": last_loss, + } + predictions = {} + selected_names = names + (("test_full_composite",) if step == spec["steps"] else ()) + for name in selected_names: + row[name], pred = evaluate_rows(model, world[name], device, padded_length) + predictions.update({name + "_" + key: value for key, value in pred.items()}) + row["autonomous_calls"], calls_pred = autonomous_calls( + model, world["test_composite"], world, device, padded_length + ) + predictions.update({"autonomous_" + key: value for key, value in calls_pred.items()}) + torch.cuda.synchronize() + elapsed_eval += time.perf_counter() - t0 + row["evaluation_seconds"] = elapsed_eval + rows_log.append(row) + write_json(out / "learning.json", rows_log) + np.savez_compressed(out / f"predictions-{step:07d}.npz", **predictions) + state = { + "step": step, + "spec": spec, + "model": model.state_dict(), + "optimizer": opt.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "elapsed_training": elapsed_training, + "elapsed_eval": elapsed_eval, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(checkpoint) + if step in spec["weight_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"weights-{step:07d}.pt", + ) + status = { + "state": "complete" if step == spec["steps"] else "running", + "step": step, + "budget": spec["steps"], + "updated_utc": utc(), + "hops": spec["hops"], + "layers": spec["layers"], + "atomic": row["atomic"]["accuracy"], + "train": row["train_composite"]["accuracy"], + "test_probe": row["test_composite"]["accuracy"], + } + write_json(out / "status.json", status) + print(json.dumps(status), flush=True) + return row + + if not resume: + measure(0) + if start_step < spec["steps"]: + for end in (s for s in spec["nodes"] if s > start_step): + last_loss = None + torch.cuda.synchronize() + t0 = time.perf_counter() + step = start_step + while step < end: + n = min(512, end - step) + ix = stream.take(n * spec["batch_size"]).reshape(n, spec["batch_size"]) + atom_count = int((ix < len(world["atomic"])).sum()) + counts["atomic"] += atom_count + counts["composite"] += ix.size - atom_count + gpu_ix = torch.as_tensor(ix, device=device) + for j in range(n): + lr.fill_(spec["lr"] * min(1.0, (step + j + 1) / spec["warmup"])) + last_loss = graph(gpu_ix[j]) + step += n + torch.cuda.synchronize() + elapsed_training += time.perf_counter() - t0 + loss_value = float(last_loss.detach()) + if not math.isfinite(loss_value): + raise FloatingPointError(f"Nonfinite loss at step {end}") + measure(end, loss_value) + start_step = end + if not rows_log or rows_log[-1]["step"] != spec["steps"]: + raise ValueError("Evaluation nodes did not reach the fixed budget") + write_json( + out / "complete.json", + { + "finished_utc": utc(), + "spec": spec, + "parameters": nparams, + "training_seconds": elapsed_training, + "evaluation_seconds": elapsed_eval, + "endpoint": rows_log[-1], + }, + ) + return rows_log[-1] diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop_data.py new file mode 100644 index 0000000000000000000000000000000000000000..d857233765485dc4bf1a210fda171628a20d9817 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_multihop_data.py @@ -0,0 +1,245 @@ +"""Separate longer-path extension of the audited two-hop random-world task. + +The graph and atomic split are reused exactly. A run trains all atomics and +one explicitly specified path length; no intermediate entities are targets. +Complete queries, not constituent facts or subpaths, define held-out examples. +""" + +from __future__ import annotations + +import hashlib +import math + +import numpy as np + +from .grok_depth_data import ENTITY_OFFSET +from .grok_depth_data import build_world as build_twohop_world + +SPLITS = ( + "atomic", + "id_atomic", + "ood_atomic", + "train_composite", + "test_composite", + "test_full_composite", + "ood_composite", + "unused_composite", +) + + +def path_details(rows, atomic, entities, relations): + """Return the actual entity trajectory and atomic row indices at each hop.""" + offset = ENTITY_OFFSET + entities + lookup = np.full((entities, relations), -1, dtype=np.int64) + lookup[atomic[:, 0] - ENTITY_OFFSET, atomic[:, 1] - offset] = np.arange(len(atomic)) + nodes = np.empty((len(rows), rows.shape[1] - 1), dtype=np.int64) + edges = np.empty((len(rows), rows.shape[1] - 2), dtype=np.int64) + nodes[:, 0] = rows[:, 0] + for j in range(edges.shape[1]): + indices = lookup[nodes[:, j] - ENTITY_OFFSET, rows[:, j + 1] - offset] + if np.any(indices < 0): + raise ValueError("Path references a missing atomic fact") + edges[:, j] = indices + nodes[:, j + 1] = atomic[indices, -1] + if np.any(nodes[:, -1] != rows[:, -1]): + raise ValueError("Path target disagrees with atomic facts") + return nodes, edges + + +def _diagnostics(rows, atomic, entities, relations, id_mask): + nodes, edges = path_details(rows, atomic, entities, relations) + repeated = np.zeros(len(rows), dtype=bool) + for j in range(1, nodes.shape[1]): + repeated |= (nodes[:, j, None] == nodes[:, :j]).any(axis=1) + positional = [] + for j in range(edges.shape[1]): + counts = np.bincount(edges[:, j], minlength=len(atomic)) + positional.append( + { + "hop": j + 1, + "id_edges_covered": int((counts[id_mask] > 0).sum()), + "id_edges_total": int(id_mask.sum()), + "counts_per_atomic_edge": counts.tolist(), + "id_count_min": int(counts[id_mask].min()) if id_mask.any() else None, + "id_count_max": int(counts[id_mask].max()) if id_mask.any() else None, + } + ) + return { + "n": len(rows), + "any_repeated_entity_n": int(repeated.sum()), + "any_repeated_entity_fraction": float(repeated.mean()) if len(rows) else None, + "answer_equals_preceding_entity_n": int( + (nodes[:, -1, None] == nodes[:, :-1]).any(axis=1).sum() + ), + "edge_positions": positional, + } + + +def build_world( + seed, + hops=3, + entities=128, + relations=16, + degree=8, + phi=6.0, + id_fraction=0.95, + id_test_fraction=0.1, + evaluation_size=1024, +): + """Enumerate all paths, reserve test queries, then sample training queries. + + The fixed per-node evaluation subset is sampled from the entire reserved + test pool without consulting training or predictions. Endpoints evaluate + that full pool too. Mixed-ID/OOD paths remain excluded, as before. + """ + if not isinstance(hops, int) or isinstance(hops, bool) or not 2 <= hops <= 4: + raise ValueError("hops must be an integer from 2 through 4") + if not isinstance(evaluation_size, int) or evaluation_size < 1: + raise ValueError("evaluation_size must be a positive integer") + if not math.isfinite(phi) or phi < 0: + raise ValueError("phi must be finite and nonnegative") + base = build_twohop_world(seed, entities, relations, degree, 0.0, id_fraction, id_test_fraction) + atomic = base["atomic"] + ood_set = {tuple(row) for row in base["ood_atomic"]} + ood_mask = np.array([tuple(row) in ood_set for row in atomic]) + rows = atomic.copy() + all_id, all_ood = ~ood_mask, ood_mask.copy() + for _ in range(1, hops): + following = (rows[:, -1, None] - ENTITY_OFFSET) * degree + np.arange(degree) + following = following.reshape(-1) + prefix = np.repeat(rows[:, :-1], degree, axis=0) + rows = np.c_[prefix, atomic[following, 1:]] + all_id = np.repeat(all_id, degree) & ~ood_mask[following] + all_ood = np.repeat(all_ood, degree) & ood_mask[following] + id_rows = rows[all_id] + rng = np.random.default_rng(np.random.SeedSequence([int(seed), int(hops), 144001])) + test_mask = rng.random(len(id_rows)) < id_test_fraction + test_full = id_rows[test_mask] + eligible = id_rows[~test_mask] + probe_rng = np.random.default_rng(np.random.SeedSequence([int(seed), int(hops), 144002])) + probe_indices = probe_rng.choice( + len(test_full), size=min(evaluation_size, len(test_full)), replace=False + ) + requested = round(phi * len(base["id_atomic"])) + ntrain = min(requested, len(eligible)) + indices = rng.choice(len(eligible), size=ntrain, replace=False) + train_mask = np.zeros(len(eligible), dtype=bool) + train_mask[indices] = True + world = { + "atomic": atomic, + "id_atomic": base["id_atomic"], + "ood_atomic": base["ood_atomic"], + "train_composite": eligible[indices], + "test_composite": test_full[probe_indices], + "test_full_composite": test_full, + "ood_composite": rows[all_ood], + "unused_composite": eligible[~train_mask], + "metadata": { + **base["metadata"], + "hops": hops, + "task": "all atomic facts plus one target composition length", + "phi_requested": phi, + "phi_actual": ntrain / max(len(base["id_atomic"]), 1), + "train_composite_requested": requested, + "train_composite_capped": requested > len(eligible), + "id_paths_total": len(id_rows), + "all_paths_total": len(rows), + "mixed_composite_excluded": int((~all_id & ~all_ood).sum()), + "training_fraction_of_id_paths": ntrain / max(len(id_rows), 1), + "training_fraction_of_nonreserved_id_paths": ntrain / max(len(eligible), 1), + "evaluation_size_requested": evaluation_size, + "probe_indices_in_full_test": probe_indices.tolist(), + "split_rng": "default_rng(SeedSequence([world_seed,hops,144001]))", + "probe_rng": "default_rng(SeedSequence([world_seed,hops,144002]))", + "construction_differences": [ + "same graph and atomic split as historical two-hop constructor", + "enumerated target length 2/3/4; only one length enters a run", + "fresh deterministic complete-path reserve and phi downsampling", + "fixed test probe at every node; entire reserve evaluated at endpoint", + ], + "warnings": [ + warning + for condition, warning in ( + (not len(test_full), "No reserved ID paths; never regenerate the world"), + (not int(all_ood.sum()), "No all-OOD paths; report zero denominator"), + (requested > len(eligible), "Training request capped at eligible pool"), + ) + if condition + ], + }, + } + audit = audit_world(world) + world["metadata"]["counts"] = audit["counts"] + world["metadata"]["dataset_sha256"] = audit["dataset_sha256"] + world["metadata"]["diagnostics"] = { + name: _diagnostics(world[name], atomic, entities, relations, ~ood_mask) + for name in ("train_composite", "test_composite", "test_full_composite") + } + return world + + +def audit_world(world): + """Independent graph truth, split completeness and full-query leakage checks.""" + meta = world["metadata"] + entities, relations, hops = (int(meta[k]) for k in ("entities", "relations", "hops")) + offset = ENTITY_OFFSET + entities + digest = hashlib.sha256() + counts = {} + for name in SPLITS: + rows = world[name] + columns = 3 if name.endswith("atomic") else hops + 2 + if rows.dtype != np.int64 or rows.ndim != 2 or rows.shape[1] != columns: + raise ValueError(f"Invalid shape or dtype: {name}") + if np.any((rows[:, [0, -1]] < ENTITY_OFFSET) | (rows[:, [0, -1]] >= offset)): + raise ValueError(f"Invalid entity tokens: {name}") + if np.any((rows[:, 1:-1] < offset) | (rows[:, 1:-1] >= offset + relations)): + raise ValueError(f"Invalid relation tokens: {name}") + if len(np.unique(rows[:, :-1], axis=0)) != len(rows): + raise ValueError(f"Duplicate complete queries: {name}") + path_details(rows, world["atomic"], entities, relations) + counts[name] = len(rows) + digest.update(name.encode()) + digest.update(np.asarray(rows.shape, dtype="= 0, path_counts[np.maximum(table, 0)], 0).sum(1) + totals.append(int(path_counts.sum())) + if sum(counts[k] for k in primary[:3]) != totals[0] or counts[primary[3]] != totals[1]: + raise ValueError("Path partitions are not exhaustive") + probes = np.asarray(meta["probe_indices_in_full_test"], dtype=np.int64) + if not np.array_equal(world["test_composite"], world["test_full_composite"][probes]): + raise ValueError("Fixed test probe differs from its recorded full-pool indices") + return { + "counts": counts, + "dataset_sha256": digest.hexdigest(), + "id_paths_independently_counted": totals[0], + "ood_paths_independently_counted": totals[1], + "complete_query_overlap": 0, + "atomic_facts_intentionally_shared_with_test": True, + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_data.py new file mode 100644 index 0000000000000000000000000000000000000000..04e5650b0bdea1e25cfde235045efc9b14e0c769 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_data.py @@ -0,0 +1,397 @@ +"""Paired fact-use assignments and constituent-occurrence repetition controls. + +The same random graph and held-out queries are used in every arm. A/B change +which random fact cohort may occur in composition training. repA/repB replace +each selected role-composition slot with its two constituent atomic queries; +their half-weight losses preserve slot weight, not information or computation. +""" + +from __future__ import annotations + +import copy +import hashlib +from collections.abc import Mapping + +import numpy as np + +from .grok_depth_data import build_world as build_graph_world +from .grok_loop_data import _EpochStream + +GROUP_NAMES = ("BG", "A", "B") +ARMS = ("A", "B", "repA", "repB") +ROW_KINDS = ("base_atomic", "background_composite", "role_composite", "repetition_atomic") + + +def _digest(arrays: Mapping[str, np.ndarray]) -> str: + digest = hashlib.sha256() + for name in sorted(arrays): + array = np.asarray(arrays[name], dtype=" np.ndarray: + return np.bincount(indices[indices >= 0], minlength=n_atomic).astype(np.int64) + + +def build_experiment(spec: Mapping) -> dict: + """Build one graph, one global reserve, and paired composition pools. + + Defaults are 128 entities, 16 relations, outdegree 8, and a 10% Bernoulli + complete-query reserve. A/B cohorts each contain floor(n_atomic/4) facts; + all remaining facts form the shared background. Cohort assignment and the + reserve have independent RNGs and never depend on predictions. Role pools + are uniformly downsampled to their smaller available size. Background + paths are used exhaustively. Empty sampled strata raise without resampling. + """ + seed = int(spec.get("world_seed", spec.get("seed", 146001))) + entities = int(spec.get("entities", 128)) + relations = int(spec.get("relations", 16)) + degree = int(spec.get("degree", 8)) + reserve_fraction = float(spec.get("test_fraction", 0.1)) + if spec.get("hops", 2) != 2: + raise ValueError("This comparison is defined only for two hops") + if not np.isfinite(reserve_fraction) or not 0 < reserve_fraction < 1: + raise ValueError("test_fraction must lie strictly between zero and one") + base = build_graph_world( + seed, entities, relations, degree, phi=0, id_fraction=1, id_test_fraction=0 + ) + atomic = base["atomic"].copy() + n_atomic = len(atomic) + cohort_size = n_atomic // 4 + if not cohort_size: + raise ValueError("At least four atomic facts are required") + # All paths use the stable per-head block ordering of the inherited graph. + second = ((atomic[:, -1, None] - 2) * degree + np.arange(degree)).reshape(-1) + first = np.repeat(np.arange(n_atomic, dtype=np.int64), degree) + all_edges = np.c_[first, second] + all_rows = np.c_[atomic[first, :2], atomic[second, 1:]] + reserve_rng = np.random.default_rng(np.random.SeedSequence([seed, 146101])) + heldout = reserve_rng.random(len(all_rows)) < reserve_fraction + assignment_rng = np.random.default_rng(np.random.SeedSequence([seed, 146102])) + assignment = assignment_rng.permutation(n_atomic) + groups = np.zeros(n_atomic, dtype=np.int64) + groups[assignment[:cohort_size]] = 1 + groups[assignment[cohort_size : 2 * cohort_size]] = 2 + path_groups = groups[all_edges] + background_indices = np.flatnonzero(~heldout & (path_groups == 0).all(axis=1)) + role_candidates = {} + for name, group in (("A", 1), ("B", 2)): + eligible = ((path_groups == 0) | (path_groups == group)).all(axis=1) + role_candidates[name] = np.flatnonzero( + ~heldout & eligible & (path_groups == group).any(axis=1) + ) + role_size = min(map(len, role_candidates.values())) + if not len(background_indices) or not role_size: + raise ValueError("Empty training stratum; retain the supplied world, do not reroll") + selected = {} + for name, group in (("A", 1), ("B", 2)): + rng = np.random.default_rng(np.random.SeedSequence([seed, 146103, group])) + selected[name] = rng.choice(role_candidates[name], size=role_size, replace=False) + exp = { + "atomic": atomic, + "fact_groups": groups, + "all_composite": all_rows, + "all_composite_fact_indices": all_edges, + "heldout_mask": heldout, + "test_composite": all_rows[heldout], + "test_composite_fact_indices": all_edges[heldout], + "background_composite": all_rows[background_indices], + "background_fact_indices": all_edges[background_indices], + "role_A_composite": all_rows[selected["A"]], + "role_A_fact_indices": all_edges[selected["A"]], + "role_B_composite": all_rows[selected["B"]], + "role_B_fact_indices": all_edges[selected["B"]], + "metadata": { + "world_seed": seed, + "seed": seed, + "entities": entities, + "relations": relations, + "degree": degree, + "hops": 2, + "vocab_size": 2 + entities + relations, + "test_fraction": reserve_fraction, + "cohort_assignment_rng": "SeedSequence([world_seed,146102])", + "complete_query_reserve_rng": "SeedSequence([world_seed,146101])", + "role_pool_rng": "SeedSequence([world_seed,146103,group])", + "group_names": list(GROUP_NAMES), + "group_sizes": [int((groups == group).sum()) for group in range(3)], + "role_candidate_sizes": {name: len(rows) for name, rows in role_candidates.items()}, + "role_pool_size": role_size, + "background_pool_size": len(background_indices), + "test_queries": int(heldout.sum()), + "all_queries": len(all_rows), + "source_graph_sha256": base["metadata"]["dataset_sha256"], + "source_graph_constructor": "grok_depth_data.build_world (atomic graph only)", + "role_meaning": "random eligibility; actual per-fact occurrence counts also reported", + "selection": "one supplied graph; no data or model-score based seed selection", + }, + } + for name in ("background", "role_A", "role_B"): + counts = _fact_counts(exp[name + "_fact_indices"], n_atomic) + exp["metadata"][name + "_fact_occurrence_counts"] = counts.tolist() + exp["metadata"]["test_group_counts"] = { + f"{left}_{right}": int( + (heldout & (path_groups[:, 0] == i) & (path_groups[:, 1] == j)).sum() + ) + for i, left in enumerate(GROUP_NAMES) + for j, right in enumerate(GROUP_NAMES) + } + audit = audit_experiment(exp) + exp["metadata"]["dataset_sha256"] = audit["dataset_sha256"] + return exp + + +def audit_experiment(exp: dict) -> dict: + """Reconstruct truth and verify the global reserve and swapped eligibility.""" + atomic, groups, meta = exp["atomic"], exp["fact_groups"], exp["metadata"] + if atomic.dtype != np.int64 or groups.dtype != np.int64 or len(groups) != len(atomic): + raise ValueError("Invalid atomic or group arrays") + if np.any((groups < 0) | (groups > 2)): + raise ValueError("Invalid fact group") + lookup = {(int(h), int(r)): (int(t), i) for i, (h, r, t) in enumerate(atomic)} + if len(lookup) != len(atomic): + raise ValueError("Duplicate atomic queries") + heldout_queries = {tuple(row[:-1]) for row in exp["test_composite"]} + if len(heldout_queries) != len(exp["test_composite"]): + raise ValueError("Duplicate held-out query") + arrays = {"atomic": atomic, "fact_groups": groups} + for name in ("all", "test", "background", "role_A", "role_B"): + rows = exp[name + "_composite"] + index_key = ( + name + "_composite_fact_indices" if name in ("all", "test") else name + "_fact_indices" + ) + recorded = exp[index_key] + expected = np.empty((len(rows), 2), dtype=np.int64) + seen = set() + for i, (h, r1, r2, t) in enumerate(rows): + query = (int(h), int(r1), int(r2)) + if query in seen: + raise ValueError(f"Duplicate query in {name}") + seen.add(query) + try: + bridge, first = lookup[int(h), int(r1)] + target, second = lookup[bridge, int(r2)] + except KeyError as error: + raise ValueError(f"Missing path fact in {name}") from error + if target != t: + raise ValueError(f"Wrong path target in {name}") + expected[i] = first, second + if name in ("background", "role_A", "role_B") and query in heldout_queries: + raise ValueError("Held-out query leaked into training") + if not np.array_equal(recorded, expected): + raise ValueError(f"Incorrect fact indices in {name}") + if name == "background" and np.any(groups[expected] != 0): + raise ValueError("Background pool uses a treatment fact") + if name in ("role_A", "role_B"): + role = 1 if name == "role_A" else 2 + actual_groups = groups[expected] + if np.any((actual_groups != 0) & (actual_groups != role)): + raise ValueError("Role pool uses the opposite cohort") + if np.any(~(actual_groups == role).any(axis=1)): + raise ValueError("Role pool contains a background-only path") + arrays[name] = rows + arrays[index_key] = recorded + if len(exp["all_composite"]) != len(atomic) * int(meta["degree"]): + raise ValueError("Incomplete full path enumeration") + if not np.array_equal(exp["all_composite"][exp["heldout_mask"]], exp["test_composite"]): + raise ValueError("Global held-out mask disagrees with test queries") + if len(exp["role_A_composite"]) != len(exp["role_B_composite"]): + raise ValueError("Paired role pools differ in size") + digest = _digest(arrays) + recorded_digest = meta.get("dataset_sha256") + if recorded_digest is not None and recorded_digest != digest: + raise ValueError("Recorded dataset hash differs from arrays") + return {"passed": True, "dataset_sha256": digest, "test_queries": len(heldout_queries)} + + +def build_arm_world(exp: dict, arm: str) -> dict: + """Return packed-table ingredients, evaluation sets and exposure provenance. + + Concatenate ``pack_rows(part['rows'], 4)`` in ``training_parts`` order. + ``table_weights`` and ``table_fact_indices`` align with that concatenation. + An atomic row has one fact id and -1; a composition row has two ids. Thus + raw fact occurrences can be accumulated without interpreting token counts + or claiming equal supervision/information. rep arms keep the same role + path reference pool for paired evaluation, but do not train those queries. + """ + if arm not in ARMS: + raise ValueError(f"Unknown arm: {arm}") + role_name = arm[-1] + repeat = arm.startswith("rep") + atomic = exp["atomic"] + n_atomic = len(atomic) + atom_indices = np.c_[np.arange(n_atomic), np.full(n_atomic, -1)].astype(np.int64) + role_edges = exp[f"role_{role_name}_fact_indices"] + role_rows = exp[f"role_{role_name}_composite"] + if repeat: + last_rows = atomic[role_edges.ravel()] + last_edges = np.c_[role_edges.ravel(), np.full(role_edges.size, -1)].astype(np.int64) + else: + last_rows, last_edges = role_rows, role_edges + parts = [ + { + "name": "atomic", + "rows": atomic, + "weights": np.ones(n_atomic, dtype=np.float32), + "fact_indices": atom_indices, + }, + { + "name": "background", + "rows": exp["background_composite"], + "weights": np.ones(len(exp["background_composite"]), dtype=np.float32), + "fact_indices": exp["background_fact_indices"], + }, + { + "name": "repetition" if repeat else "role", + "rows": last_rows, + "weights": np.full(len(last_rows), 0.5 if repeat else 1, dtype=np.float32), + "fact_indices": last_edges, + }, + ] + evaluation = {"atomic": atomic} + for group, name in enumerate(GROUP_NAMES): + evaluation[f"atomic_{name}"] = atomic[exp["fact_groups"] == group] + evaluation["test_composite"] = exp["test_composite"] + query_groups = exp["fact_groups"][exp["test_composite_fact_indices"]] + for i, left in enumerate(GROUP_NAMES): + for j, right in enumerate(GROUP_NAMES): + mask = (query_groups[:, 0] == i) & (query_groups[:, 1] == j) + evaluation[f"test_{left}_{right}"] = exp["test_composite"][mask] + evaluation["train_background"] = exp["background_composite"] + evaluation["role_A_reference"] = exp["role_A_composite"] + evaluation["role_B_reference"] = exp["role_B_composite"] + train_composite = ( + exp["background_composite"] + if repeat + else np.concatenate([exp["background_composite"], role_rows]) + ) + evaluation["train_composite"] = train_composite + group_id = 1 if role_name == "A" else 2 + eligible = (exp["fact_groups"] == 0) | ((exp["fact_groups"] == group_id) & (not repeat)) + used_counts = _fact_counts( + np.concatenate( + [exp["background_fact_indices"], role_edges if not repeat else role_edges[:0]] + ), + n_atomic, + ) + world = { + "arm": arm, + "atomic": atomic, + "id_atomic": atomic[eligible], + "ood_atomic": atomic[~eligible], + "background_composite": exp["background_composite"], + "role_composite": role_rows, + "train_composite": train_composite, + "test_composite": exp["test_composite"], + "test_full_composite": exp["test_composite"], + "training_parts": parts, + "table_weights": np.concatenate([part["weights"] for part in parts]), + "table_fact_indices": np.concatenate([part["fact_indices"] for part in parts]), + "table_row_kinds": np.concatenate( + [ + np.full(len(part["rows"]), kind, dtype=np.int64) + for part, kind in zip(parts, [0, 1, 3 if repeat else 2], strict=True) + ] + ), + "evaluation": evaluation, + "metadata": { + **copy.deepcopy(exp["metadata"]), + "arm": arm, + "repetition_control": repeat, + "role_name": role_name, + "row_kind_names": list(ROW_KINDS), + "training_composite_fact_occurrence_counts": used_counts.tolist(), + "eligible_facts_without_actual_composite_occurrence": int( + (eligible & (used_counts == 0)).sum() + ), + "evaluation_note": "same global heldout and nine cohort-pair strata in every arm", + "repetition_note": ( + "two constituent atomics per role slot, each loss weight 1/2; matches raw " + "constituent occurrences, not information, direct supervision or compute" + ), + }, + } + return world + + +class UsageStream: + """Emit paired base/background/role slots, expanding rep slots into two rows.""" + + def __init__(self, world, seed, n_atomic=32, n_background=112, n_role=112): + for name, value in ( + ("n_atomic", n_atomic), + ("n_background", n_background), + ("n_role", n_role), + ): + if not isinstance(value, (int, np.integer)) or isinstance(value, bool) or value < 1: + raise ValueError(f"{name} must be a positive integer") + self.arm = world["arm"] + self.repeat = self.arm.startswith("rep") + self.atomic_size = len(world["atomic"]) + self.background_size = len(world["background_composite"]) + self.role_size = len(world["role_composite"]) + self.n_atomic, self.n_background, self.n_role = ( + int(n_atomic), + int(n_background), + int(n_role), + ) + if min(self.atomic_size, self.background_size, self.role_size) < 1: + raise ValueError("Sampled strata cannot be empty") + self.nominal_batch_size = self.n_atomic + self.n_background + self.n_role + self.batch_size = self.nominal_batch_size + (self.n_role if self.repeat else 0) + self.atomic = _EpochStream(self.atomic_size, np.random.SeedSequence([int(seed), 146201])) + self.background = _EpochStream( + self.background_size, np.random.SeedSequence([int(seed), 146202]) + ) + self.role = _EpochStream(self.role_size, np.random.SeedSequence([int(seed), 146203])) + self.interleave = np.random.default_rng(np.random.SeedSequence([int(seed), 146204])) + self.batches = 0 + + def take(self, n=None): + if n is not None and n != self.batch_size: + raise ValueError("UsageStream emits its configured actual batch size") + atoms = self.atomic.take(self.n_atomic) + background = self.background.take(self.n_background) + self.atomic_size + role = self.role.take(self.n_role) + if self.repeat: + role = (role[:, None] * 2 + np.arange(2)).ravel() + role = role + self.atomic_size + self.background_size + indices = np.r_[atoms, background, role] + self.batches += 1 + return indices[self.interleave.permutation(self.batch_size)] + + def state_dict(self): + return { + "version": 1, + "arm": self.arm, + "n_atomic": self.n_atomic, + "n_background": self.n_background, + "n_role": self.n_role, + "atomic": self.atomic.state_dict(), + "background": self.background.state_dict(), + "role": self.role.state_dict(), + "interleave_rng": copy.deepcopy(self.interleave.bit_generator.state), + "batches": self.batches, + } + + def load_state_dict(self, state): + if state.get("version") != 1: + raise ValueError("Unsupported UsageStream state version") + for name in ("arm", "n_atomic", "n_background", "n_role"): + if state[name] != getattr(self, name): + raise ValueError(f"UsageStream {name} mismatch") + if not isinstance(state["batches"], int) or state["batches"] < 0: + raise ValueError("Invalid batch count") + replacements = {} + for name in ("atomic", "background", "role"): + replacements[name] = copy.deepcopy(getattr(self, name)) + replacements[name].load_state_dict(state[name]) + interleave = copy.deepcopy(self.interleave) + interleave.bit_generator.state = copy.deepcopy(state["interleave_rng"]) + for name, stream in replacements.items(): + setattr(self, name, stream) + self.interleave = interleave + self.batches = state["batches"] diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_train.py new file mode 100644 index 0000000000000000000000000000000000000000..8460dcf149ad8f229cc4c16783e8e7429acd0610 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grok_usage_train.py @@ -0,0 +1,261 @@ +"""Paired training of composition experience versus constituent-fact repetition.""" + +from __future__ import annotations + +import json +import math +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig +from .grok_depth import GraphStep, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .grok_multihop import autonomous_calls, evaluate_rows, pack_rows +from .grok_usage_data import UsageStream + + +def weighted_loss(logits, labels, weights, normalizer): + """Each logical slot has weight one; its two atomic substitutes have .5 each.""" + losses = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), reduction="none") + return (losses.view(-1, 2).mean(1) * weights).sum() / normalizer + + +class UsageGraphStep(GraphStep): + def __init__(self, model, optimizer, table, batch_size, normalizer): + self.normalizer = normalizer + super().__init__(model, optimizer, table, batch_size) + + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, positions, labels, weights = (t[self.index] for t in self.table) + loss = weighted_loss(self.model(x, positions), labels, weights, self.normalizer) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def make_model(spec, device): + cfg = ModelConfig( + vocab_size=2 + spec["entities"] + spec["relations"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=8, + ) + return LoopGPT( + cfg, + repeats=spec["repeats"], + dropout=spec["dropout"], + initialization=spec["init_scheme"], + ).to(device), cfg + + +def run(spec, world, out, device="cuda:0", resume=False): + out = Path(out) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + device = torch.device(device) + torch.cuda.set_device(device) + torch.cuda.set_per_process_memory_fraction(spec.get("memory_fraction", 0.025), device) + torch.manual_seed(spec["initialization"]) + torch.cuda.manual_seed_all(spec["initialization"]) + model, cfg = make_model(spec, device) + lr = torch.tensor(spec["lr"], dtype=torch.float32, device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + packed = [pack_rows(part["rows"], 4) for part in world["training_parts"]] + table = tuple( + torch.as_tensor(np.concatenate([part[j] for part in packed]), device=device) + for j in range(3) + ) + (torch.as_tensor(world["table_weights"], device=device, dtype=torch.float32),) + stream = UsageStream( + world, + spec["stream_seed"], + n_atomic=spec["n_atomic"], + n_background=spec["n_background"], + n_role=spec["n_role"], + ) + logical_batch = spec["n_atomic"] + spec["n_background"] + spec["n_role"] + actual_batch = logical_batch + (spec["n_role"] if spec["arm"].startswith("rep") else 0) + exposure = np.zeros((4, len(world["atomic"])), dtype=np.int64) + kind_counts = np.zeros(4, dtype=np.int64) + train_seconds, evaluation_seconds, start_step = 0.0, 0.0, 0 + if resume: + state = torch.load(out / "latest.pt", map_location=device, weights_only=False) + if state["spec"] != spec: + raise ValueError("Resume specification changed") + model.load_state_dict(state["model"]) + optimizer.load_state_dict(state["optimizer"]) + lr = optimizer.param_groups[0]["lr"] + for group in optimizer.param_groups: + group["lr"] = lr + stream.load_state_dict(state["stream"]) + exposure, kind_counts = state["exposure"], state["kind_counts"] + train_seconds, evaluation_seconds = state["training_seconds"], state["evaluation_seconds"] + start_step = state["step"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + t0 = time.perf_counter() + graph = UsageGraphStep(model, optimizer, table, actual_batch, logical_batch) + capture_seconds = time.perf_counter() - t0 + learning = json.loads((out / "learning.json").read_text()) if resume else [] + learning = [row for row in learning if row["step"] <= start_step] + fact_ids = np.asarray(world["table_fact_indices"]) + kinds = np.asarray(world["table_row_kinds"]) + flop_step = flops(cfg, spec["repeats"], actual_batch, sequence=4, output_positions=2) + + def measure(step, last_loss=None): + nonlocal evaluation_seconds + torch.cuda.synchronize() + before = time.perf_counter() + metrics, predictions = {}, {} + for name, rows in world["evaluation"].items(): + metrics[name], pred = evaluate_rows(model, rows, device, 4) + if len(rows): + metrics[name]["answer_probability"] = float(np.exp(-pred["nll"][:, 0]).mean()) + predictions.update({name + "_" + k: v for k, v in pred.items()}) + metrics["autonomous_calls"], pred = autonomous_calls( + model, + world["evaluation"]["test_composite"], + world, + device, + 4, + ) + predictions.update({"autonomous_" + k: v for k, v in pred.items()}) + torch.cuda.synchronize() + evaluation_seconds += time.perf_counter() - before + row = { + "step": step, + "utc": utc(), + "arm": spec["arm"], + "world_seed": spec["world_seed"], + "metrics": metrics, + "last_batch_loss": last_loss, + "training_seconds": train_seconds, + "evaluation_seconds": evaluation_seconds, + "capture_seconds": capture_seconds, + "actual_examples": int(kind_counts.sum()), + "logical_slots": step * logical_batch, + "supervised_tokens": int(kind_counts.sum()) * 2, + "effective_input_tokens": int((kind_counts * np.array([3, 4, 4, 3])).sum()), + "estimated_training_flops": step * flop_step, + "kind_counts": kind_counts.tolist(), + } + learning.append(row) + write_json(out / "learning.json", learning) + np.savez_compressed(out / f"predictions-{step:07d}.npz", **predictions) + np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=exposure, kinds=kind_counts) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "stream": stream.state_dict(), + "exposure": exposure, + "kind_counts": kind_counts, + "training_seconds": train_seconds, + "evaluation_seconds": evaluation_seconds, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["weight_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"weights-{step:07d}.pt", + ) + status = { + "state": "trained" if step == spec["steps"] else "running", + "step": step, + "budget": spec["steps"], + "arm": spec["arm"], + "updated_utc": utc(), + "test_composite": metrics["test_composite"]["accuracy"], + "training_seconds": train_seconds, + } + write_json(out / "status.json", status) + print(json.dumps(status), flush=True) + + if not resume: + measure(0) + for end in (node for node in spec["nodes"] if node > start_step): + torch.cuda.synchronize() + before = time.perf_counter() + step = start_step + while step < end: + n = min(512, end - step) + indices = np.stack([stream.take() for _ in range(n)]) + selected = indices.ravel() + selected_kinds, selected_facts = kinds[selected], fact_ids[selected] + kind_counts += np.bincount(selected_kinds, minlength=4) + for kind in range(4): + facts = selected_facts[selected_kinds == kind].ravel() + exposure[kind] += np.bincount(facts[facts >= 0], minlength=exposure.shape[1]) + gpu_indices = torch.as_tensor(indices, device=device) + for j in range(n): + lr.fill_(spec["lr"] * min(1.0, (step + j + 1) / spec["warmup"])) + loss = graph(gpu_indices[j]) + step += n + torch.cuda.synchronize() + train_seconds += time.perf_counter() - before + loss_value = float(loss.detach()) + if not math.isfinite(loss_value): + raise FloatingPointError(f"Nonfinite loss at {end}") + measure(end, loss_value) + start_step = end + if not learning or learning[-1]["step"] != spec["steps"]: + raise ValueError("Registered nodes did not reach endpoint") + # Reload every endpoint from disk and compare all saved per-example scores. + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + model.load_state_dict(saved["model"]) + old = np.load(out / f"predictions-{spec['steps']:07d}.npz") + errors, checks, largest_nll_difference = [], 0, 0.0 + for name, rows in world["evaluation"].items(): + _, pred = evaluate_rows(model, rows, device, 4) + for key, value in pred.items(): + reference = old[name + "_" + key] + checks += len(value) + if key == "nll": + difference = float(np.abs(value - reference).max()) if len(value) else 0.0 + largest_nll_difference = max(largest_nll_difference, difference) + ok = np.allclose(value, reference, atol=1e-6, rtol=1e-6) + else: + ok = np.array_equal(value, reference) + if not ok: + errors.append(name + "_" + key) + audit = { + "checks": checks, + "errors": errors, + "max_nll_difference": largest_nll_difference, + "method": "reload saved endpoint; all evaluation splits, identical GPU/dtype/batch shape", + } + write_json(out / "endpoint-audit.json", audit) + if errors: + raise ValueError(f"Endpoint reload failed: {errors}") + write_json( + out / "complete.json", + { + "finished_utc": utc(), + "spec": spec, + "endpoint": learning[-1], + "audit": audit, + "parameters": sum(p.numel() for p in model.parameters()), + "maximum_allocated_bytes": torch.cuda.max_memory_allocated(device), + }, + ) + write_json( + out / "status.json", + { + "state": "complete", + "step": spec["steps"], + "arm": spec["arm"], + "utc": utc(), + }, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py new file mode 100644 index 0000000000000000000000000000000000000000..9530969731263b69c576f12989a3610ead6036f5 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py @@ -0,0 +1,421 @@ +"""Pure first-hop state interventions and held-out, local fact-update branches. + +The text template's factual answer is predicted at `is`, rather than at r1. +All targets and donors are selected from the graph before model inference. +""" + +from __future__ import annotations + +import copy +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .depth_step_mechanism import traced_forward +from .grok_depth import write_json +from .latent_scaling import model_digest +from .storage_composition import generate_rows, pack_sentences +from .text_pretrain import atomic_sentence, composite_sentence + +PARAMETER = "blocks.0.mlp.down.weight" + + +def taught_atoms(world): + return np.concatenate([world["common_atomic"], world["anchor_atomic"]]) + + +def update_case(world, atomic_index, group, replay_n=32, keep_n=32): + """Change one graph edge; recompute the entire two-hop affected closure.""" + atoms = taught_atoms(world) + old = atoms[atomic_index].copy() + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + first_role = 13 <= old[1] <= 16 + pool = world[group + "_test"] + if first_role: + affected = (pool[:, 0] == old[0]) & (pool[:, 1] == old[1]) + relation_rows = pool[affected] + options = sorted({int(row[2]) for row in atoms if 13 <= row[1] <= 16}) + # Prefer the same familiar/strict bridge bank; all successor facts must be taught. + own_bank = sorted({int(row[2]) for row in pool}) + candidates = [v for v in own_bank if v != old[2]] + [ + v for v in options if v != old[2] and v not in own_bank + ] + new_value = next( + v + for v in candidates + if all((v, int(row[3])) in lookup for row in relation_rows) + and any(lookup[v, int(row[3])] != row[4] for row in relation_rows) + ) + else: + affected = (pool[:, 2] == old[0]) & (pool[:, 3] == old[1]) + tails = sorted({int(row[2]) for row in atoms if 17 <= row[1] <= 20}) + new_value = tails[(tails.index(int(old[2])) + 1) % len(tails)] + new = old.copy() + new[2] = new_value + lookup[int(new[0]), int(new[1])] = int(new[2]) + tasks = {"E_new": np.asarray([new]), "E_old": np.asarray([old])} + original_d = {} + successor_keys = set() + for split in ["familiar", "strict"]: + rows = world[split + "_test"] + mask = ( + ((rows[:, 0] == old[0]) & (rows[:, 1] == old[1])) + if first_role + else ((rows[:, 2] == old[0]) & (rows[:, 3] == old[1])) + ) + original = rows[mask].copy() + changed = original.copy() + for row in changed: + row[2] = lookup[int(row[0]), int(row[1])] + row[4] = lookup[int(row[2]), int(row[3])] + successor_keys.add((int(row[2]), int(row[3]))) + name = "D_" + split + tasks[name] = changed + original_d[name] = original + tasks["U_" + split] = rows[~mask].copy() + index_lookup = {tuple(map(int, row[:2])): i for i, row in enumerate(atoms)} + successor_indices = sorted(index_lookup[key] for key in successor_keys) + successor = atoms[successor_indices].copy() + if not first_role and len(successor): + successor[(successor[:, 0] == old[0]) & (successor[:, 1] == old[1])] = new + tasks["successor_atomic"] = successor + order = sorted(range(len(atoms)), key=lambda i: tuple(atoms[i])) + excluded = {atomic_index, *successor_indices} + replay = [i for i in order if i not in excluded][:replay_n] + keep = [i for i in order if i not in excluded and i not in replay][:keep_n] + unused = [i for i in range(len(atoms)) if i not in {atomic_index, *replay, *keep}] + tasks["R_atomic"] = atoms[replay].copy() + tasks["Kdev_atomic"] = atoms[keep].copy() + tasks["U_atomic"] = atoms[unused].copy() + if len(replay) != replay_n or len(keep) != keep_n: + raise ValueError("Insufficient independent replay and calibration keep facts") + return { + "atomic_index": atomic_index, + "group": group, + "role": "first" if first_role else "second", + "old_fact": old.tolist(), + "new_fact": new.tolist(), + "replay_indices": replay, + "keep_indices": keep, + "unused_indices": unused, + "tasks": tasks, + "original_d": original_d, + } + + +def select_cases(world, n_per_group_role=2, calibration=False): + """Graph-defined, largest affected-pool targets; no checkpoint-dependent selection.""" + atoms = taught_atoms(world) + chosen = [] + groups = ["familiar"] if calibration else ["familiar", "strict"] + for group in groups: + rows = world[group + "_test"] + for role in ["first", "second"]: + counts = {} + for row in rows: + key = tuple(map(int, row[:2] if role == "first" else row[[2, 3]])) + counts[key] = counts.get(key, 0) + 1 + candidates = [i for i, atom in enumerate(atoms) if tuple(map(int, atom[:2])) in counts] + candidates.sort(key=lambda i: (-counts[tuple(map(int, atoms[i, :2]))], tuple(atoms[i]))) + for i in candidates[:n_per_group_role]: + chosen.append(update_case(world, i, group)) + if len(chosen) != len(groups) * 2 * n_per_group_role: + raise ValueError("Not enough distinct graph-defined editor targets") + return chosen + + +def serialize_case(case): + return { + key: {name: rows.tolist() for name, rows in value.items()} + if key in ["tasks", "original_d"] + else value + for key, value in case.items() + } + + +def answer_batch(rows, device): + """Factual answer, punctuation and EOS only; random prefix targets are excluded.""" + tokens, labels = pack_sentences(rows) + first = 4 if rows.shape[1] == 3 else 6 + positions = np.tile([first, first + 1, first + 2], (len(rows), 1)) + selected = labels[np.arange(len(rows))[:, None], positions] + np.testing.assert_array_equal( + selected, np.c_[rows[:, -1], np.full(len(rows), 5), np.ones(len(rows), dtype=np.int64)] + ) + return tuple(torch.as_tensor(x, device=device) for x in [tokens, positions, selected]) + + +def safe_generate(model, rows, device): + if len(rows): + return generate_rows(model, rows, device) + return {"n": 0, "accuracy": None, "answer_accuracy": None, "answer_nll": None}, { + "generated": np.empty((0, 3), dtype=np.int64), + "correct": np.empty(0, dtype=bool), + "answer_nll": np.empty(0, dtype=np.float32), + } + + +def editor(model, case, device, arm, lr, nodes=(0, 200)): + """Independent local update, with parent KL reference and exact final tensor saved.""" + if arm not in ["edit", "review"]: + raise ValueError("Unknown editor arm") + started = time.perf_counter() + parent_hash = model_digest(model) + edited = copy.deepcopy(model).eval() + for name, parameter in edited.named_parameters(): + parameter.requires_grad_(name == PARAMETER) + parameter.grad = None + before = {key: value.detach().clone() for key, value in edited.state_dict().items()} + parameter = dict(edited.named_parameters())[PARAMETER] + optimizer = torch.optim.Adam([parameter], lr=lr) + target = answer_batch( + np.asarray([case["new_fact"] if arm == "edit" else case["old_fact"]]), device + ) + replay = answer_batch(case["tasks"]["R_atomic"], device) + with torch.no_grad(): + parent_log = model(replay[0], positions=replay[1]).log_softmax(-1).detach() + parent_d = { + name: safe_generate(model, rows, device)[1] for name, rows in case["original_d"].items() + } + parent_old_fact_ok = safe_generate(model, case["tasks"]["E_old"], device)[1]["correct"].all() + parent_successors_ok = ( + safe_generate(model, case["tasks"]["successor_atomic"], device)[1]["correct"].all() + if case["role"] == "first" + else True + ) + history, raw, step = [], {}, 0 + for node in nodes: + while step < node: + optimizer.zero_grad(set_to_none=True) + logits = edited(target[0], positions=target[1]) + ce = F.cross_entropy(logits.flatten(0, 1), target[2].flatten()) + current = edited(replay[0], positions=replay[1]).log_softmax(-1) + kl = F.kl_div( + current.flatten(0, 1), + parent_log.flatten(0, 1), + reduction="batchmean", + log_target=True, + ) + loss = ce + kl + loss.backward() + optimizer.step() + step += 1 + metrics = {} + for name, rows in case["tasks"].items(): + metric, prediction = safe_generate(edited, rows, device) + if name in case["original_d"]: + original = case["original_d"][name] + changed = rows[:, -1] != original[:, -1] + parent_correct = parent_d[name]["correct"] + eligible = changed & parent_correct & parent_old_fact_ok & parent_successors_ok + pred = prediction["generated"] + old = (pred[:, 0] == original[:, -1]) & (pred[:, 1] == 5) & (pred[:, 2] == 1) + metric.update( + { + "changed_n": int(changed.sum()), + "parent_old_correct_n": int(parent_correct.sum()), + "eligible_n": int(eligible.sum()), + "changed_accuracy": float(prediction["correct"][changed].mean()) + if changed.any() + else None, + "eligible_accuracy": float(prediction["correct"][eligible].mean()) + if eligible.any() + else None, + "eligible_old_answer_accuracy": float(old[eligible].mean()) + if eligible.any() + else None, + } + ) + raw[name + "_changed"] = changed + raw[name + "_parent_correct"] = parent_correct + raw[name + "_original_rows"] = original + metrics[name] = metric + raw.update({f"step{node}_{name}_{key}": value for key, value in prediction.items()}) + history.append({"step": step, "metrics": metrics}) + changed_tensors = [ + key for key, value in edited.state_dict().items() if not torch.equal(value, before[key]) + ] + assert not set(changed_tensors) - {PARAMETER} + assert model_digest(model) == parent_hash + final = parameter.detach().cpu().clone() + record = { + "arm": arm, + "lr": lr, + "case": serialize_case(case), + "history": history, + "parent_model_sha256": parent_hash, + "final_model_sha256": model_digest(edited), + "changed_tensors": changed_tensors, + "delta_l2": float((parameter - before[PARAMETER]).norm()), + "seconds": time.perf_counter() - started, + "parent_old_target_atomic_correct": bool(parent_old_fact_ok), + "parent_new_successors_correct": bool(parent_successors_ok), + } + # Exact-tensor replay verifies every generated endpoint; no rounded delta reconstruction. + reloaded = copy.deepcopy(model).eval() + with torch.no_grad(): + dict(reloaded.named_parameters())[PARAMETER].copy_(final.to(device)) + assert model_digest(reloaded) == record["final_model_sha256"] + for name, rows in case["tasks"].items(): + _, prediction = safe_generate(reloaded, rows, device) + for key, values in prediction.items(): + reference = raw[f"step{nodes[-1]}_{name}_{key}"] + if key == "answer_nll": + np.testing.assert_allclose(values, reference, rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(values, reference) + record["exact_weight_reload_passed"] = True + return record, raw, final + + +def select_donors(world, rows): + atoms = world["common_atomic"] + lookup = {tuple(map(int, row[:2])): int(row[2]) for row in atoms} + first = [(i, atom) for i, atom in enumerate(atoms) if 13 <= atom[1] <= 16] + first.sort(key=lambda pair: tuple(pair[1])) + records = {} + for style in ["same_bridge", "different_bridge"]: + indices, tails = [], [] + for h, r1, bridge, r2, tail in rows: + eligible = [ + (i, atom) + for i, atom in first + if atom[1] == r1 + and atom[0] != h + and (int(atom[2]), int(r2)) in lookup + and ( + (atom[2] == bridge) + if style == "same_bridge" + else (atom[2] != bridge and lookup[int(atom[2]), int(r2)] != tail) + ) + ] + indices.append(eligible[0][0] if eligible else -1) + tails.append(lookup[int(eligible[0][1][2]), int(r2)] if eligible else -1) + records[style] = {"indices": np.asarray(indices), "tails": np.asarray(tails)} + return records + + +@torch.no_grad() +def patched_generation(model, tokens, patch): + generated = [] + first_prob = None + for step in range(3): + logits, _ = traced_forward(model, tokens, patch) + if step == 0: + first_prob = logits[:, -1].softmax(-1) + answer = logits[:, -1].argmax(-1) + generated.append(answer.cpu().numpy()) + tokens = torch.cat([tokens, answer[:, None]], dim=1) + return np.stack(generated, axis=1), first_prob + + +@torch.no_grad() +def trace(model, world, device, out): + """Two fixed, causally reachable sites; donors contain only a first-hop prefix.""" + model.eval() + out = Path(out) + records, raw = [], {} + atoms = world["common_atomic"] + atom_metric, atom_prediction = generate_rows(model, atoms, device) + index_lookup = {tuple(map(int, row[:2])): i for i, row in enumerate(atoms)} + for split in ["familiar", "strict"]: + rows = world[split + "_test"] + tokens = torch.as_tensor([composite_sentence(row)[:7] for row in rows], device=device) + reference = model(tokens) + logits, cache = traced_forward(model, tokens) + torch.testing.assert_close(logits, reference, rtol=1e-5, atol=2e-6) + assert torch.equal(logits.argmax(-1), reference.argmax(-1)) + baseline_pred, baseline_prob = patched_generation(model, tokens, {}) + raw[split + "_rows"] = rows + raw[split + "_baseline_generated"] = baseline_pred + for position in [3, 6]: + state = cache["postresidual"][0, :, position] + readout = F.linear(model.ln_final(state), model.token.weight) + bridge = torch.as_tensor(rows[:, 2], device=device) + rank = 1 + (readout > readout.gather(-1, bridge[:, None])).sum(-1) + raw[f"{split}_bridge_rank_p{position}"] = rank.cpu().numpy() + raw[split + "_attention"] = cache["attention_map"].cpu().numpy() + for recipient, _donor_position in [(3, 3), (6, 4)]: + for component in ["postresidual", "mlp_delta"]: + self_patch = {(0, component, recipient): cache[component][0, :, recipient]} + self_pred, self_prob = patched_generation(model, tokens, self_patch) + np.testing.assert_array_equal(self_pred, baseline_pred) + torch.testing.assert_close(self_prob, baseline_prob, rtol=1e-5, atol=2e-6) + for style, donor in select_donors(world, rows).items(): + valid = donor["indices"] >= 0 + ids = np.flatnonzero(valid) + if not len(ids): + continue + donor_rows = atoms[donor["indices"][valid]] + donor_tokens = torch.as_tensor( + [atomic_sentence(row)[:5] for row in donor_rows], device=device + ) + _, donor_cache = traced_forward(model, donor_tokens) + expected = donor["tails"][valid] + expected_tensor = torch.as_tensor(expected, device=device) + premise = np.asarray( + [ + atom_prediction["correct"][index_lookup[int(row[0]), int(row[1])]] + and atom_prediction["correct"][index_lookup[int(row[2]), int(row[3])]] + and atom_prediction["correct"][int(donor_index)] + and atom_prediction["correct"][index_lookup[int(donor_row[2]), int(row[3])]] + for row, donor_row, donor_index in zip( + rows[valid], donor_rows, donor["indices"][valid], strict=True + ) + ] + ) + raw[f"{split}_{style}_ids"] = ids + raw[f"{split}_{style}_donor_rows"] = donor_rows + raw[f"{split}_{style}_expected"] = expected + for recipient, donor_position in [(3, 3), (6, 4)]: + for component in ["postresidual", "mlp_delta"]: + patch = { + (0, component, recipient): donor_cache[component][0, :, donor_position] + } + pred, prob = patched_generation(model, tokens[valid], patch) + correct = (pred[:, 0] == expected) & (pred[:, 1] == 5) & (pred[:, 2] == 1) + base = baseline_pred[valid] + base_correct = (base[:, 0] == expected) & (base[:, 1] == 5) & (base[:, 2] == 1) + selected = torch.arange(len(ids), device=device) + new_probability = prob[selected, expected_tensor].cpu().numpy() + original_probability = ( + baseline_prob[valid][selected, expected_tensor].cpu().numpy() + ) + name = f"{split}_{style}_p{recipient}_{component}" + raw[name + "_generated"] = pred + raw[name + "_gold_probability"] = new_probability + raw[name + "_baseline_gold_probability"] = original_probability + record = { + "split": split, + "style": style, + "recipient_position": recipient, + "donor_position": donor_position, + "component": component, + "n": len(ids), + "pool_n": len(rows), + "coverage": float(valid.mean()), + "necessary_atoms_correct_n": int(premise.sum()), + "baseline_target_accuracy": float(base_correct.mean()), + "patched_target_accuracy": float(correct.mean()), + "target_accuracy_delta_pp": 100 + * float((correct.astype(float) - base_correct).mean()), + "target_probability_delta": float( + (new_probability - original_probability).mean() + ), + "conditional_target_accuracy": float(correct[premise].mean()) + if premise.any() + else None, + } + records.append(record) + out.mkdir(parents=True, exist_ok=False) + np.savez_compressed(out / "trace.npz", **raw) + result = { + "records": records, + "traced_forward_and_self_patch_passed": True, + "common_atomic": atom_metric, + } + write_json(out / "trace.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_reproduction.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_reproduction.py new file mode 100644 index 0000000000000000000000000000000000000000..b2f7ba958ea469d5edea6e98c9941dcc49427a6f --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/grokking_reproduction.py @@ -0,0 +1,563 @@ +"""Protocol replication of Wang et al.'s full-size two-hop grokking experiments. + +The original GPT-2 vocabulary and configuration, answer/end-marker objective, +random graph, edge-level split, merged sampling and unique-depth initialization +are retained. SDPA, selecting supervised logits, CUDA graphs and bf16 AMP are +explicit execution/numerical adaptations, checked against Hugging Face GPT-2. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import os +import time +from pathlib import Path + +import numpy as np +import torch +from torch import nn +from torch.nn import functional as F +from transformers import GPT2Config, GPT2LMHeadModel, GPT2TokenizerFast + +from .bios_model import ModelConfig, matmul_flops +from .grok_depth import EpochStream, GraphStep, utc, write_json + +ROOT = Path("results/grokking-reproduction-v1") +ARTIFACTS = Path("docs/development-artifacts/grokking-reproduction-v1") +SOURCE_FILES = [ + "src/llm_memory_editability/grokking_reproduction.py", + "scripts/run_grokking_reproduction.py", + "tests/test_grokking_reproduction.py", + "configs/grokking-reproduction-development-v1.json", + "docs/development-artifacts/grokking-reproduction-v1/design.md", +] + + +def digest(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def model_digest(model): + h = hashlib.sha256() + for name, tensor in model.state_dict().items(): + h.update(name.encode()) + h.update(tensor.detach().cpu().contiguous().numpy().tobytes()) + return h.hexdigest() + + +def build_graph(seed, entities=2000, relations=200, degree=20, holdout=0.005): + """Port the author's composition.ipynb; all tokens have shared graph roles. + + The fixed permutation makes different phi supports nested while preserving + each support's uniform marginal distribution. Mixed OOD chains are retained + for diagnostic evaluation, never included in training. + """ + rng = np.random.RandomState(seed) + atoms = np.empty((entities * degree, 3), dtype=np.int32) + for h in range(entities): + begin = h * degree + atoms[begin : begin + degree, 0] = h + atoms[begin : begin + degree, 1] = rng.choice(relations, degree, replace=False) + atoms[begin : begin + degree, 2] = rng.randint(entities, size=degree) + ood = np.zeros(len(atoms), dtype=bool) + ood[rng.choice(len(atoms), round(len(atoms) * 0.05), replace=False)] = True + first = np.repeat(np.arange(len(atoms)), degree) + second = atoms[first, 2] * degree + np.tile(np.arange(degree), len(atoms)) + chains = np.column_stack( + [atoms[first, 0], atoms[first, 1], atoms[second, 1], atoms[second, 2]] + ).astype(np.int32) + kind = ood[first].astype(np.int8) * 2 + ood[second].astype(np.int8) + ii = np.flatnonzero(kind == 0) + held = rng.uniform(size=len(ii)) <= holdout + train_ids = ii[~held] + permutation = rng.permutation(len(train_ids)) + return { + "atoms": atoms, + "ood": ood, + "chains": chains, + "first": first.astype(np.int32), + "second": second.astype(np.int32), + "kind": kind, + "train_order": train_ids[permutation].astype(np.int32), + "test_ii": ii[held].astype(np.int32), + } + + +def audit_graph(world, degree): + a, c = world["atoms"], world["chains"] + first, second = world["first"], world["second"] + assert np.array_equal(a[first, 2], a[second, 0]) + assert np.array_equal(c[:, 0], a[first, 0]) + assert np.array_equal(c[:, 1], a[first, 1]) + assert np.array_equal(c[:, 2], a[second, 1]) + assert np.array_equal(c[:, 3], a[second, 2]) + assert len(np.unique(a[:, :2], axis=0)) == len(a) + assert np.all(np.bincount(a[:, 0]) == degree) + assert not np.intersect1d(world["train_order"], world["test_ii"]).size + assert np.all(world["kind"][world["train_order"]] == 0) + assert np.all(world["kind"][world["test_ii"]] == 0) + + +def prepare_data(config): + path = ROOT / "data" + path.mkdir(parents=True, exist_ok=True) + if (path / "complete.json").exists(): + complete = json.loads((path / "complete.json").read_text()) + assert complete["world"] == config["world"] + assert digest(path / "world.npz") == complete["world_sha256"] + return complete + world = build_graph(config["world"]) + audit_graph(world, 20) + np.savez_compressed(path / "world.npz", **world) + rng = np.random.RandomState(config["evaluation_seed"]) + + def sample(indices): + return rng.choice(indices, min(3000, len(indices)), replace=False) + + min_support = round(min(s["phi"] for s in config["runs"]) * (~world["ood"]).sum()) + panels = { + "atomic_id": world["atoms"][sample(np.flatnonzero(~world["ood"]))], + "atomic_ood": world["atoms"][sample(np.flatnonzero(world["ood"]))], + "train_ii": world["chains"][sample(world["train_order"][:min_support])], + "test_ii": world["chains"][sample(world["test_ii"])], + "test_io": world["chains"][sample(np.flatnonzero(world["kind"] == 1))], + "test_oi": world["chains"][sample(np.flatnonzero(world["kind"] == 2))], + "test_oo": world["chains"][sample(np.flatnonzero(world["kind"] == 3))], + } + np.savez_compressed(path / "panels.npz", **panels) + tokenizer = GPT2TokenizerFast.from_pretrained(ROOT / "reference/gpt2", local_files_only=True) + base = len(tokenizer) + vocab = [f"" for i in range(2000)] + [f"" for i in range(200)] + vocab += ["", "", "", "", "", ""] + assert tokenizer.add_tokens(vocab) == len(vocab) + assert tokenizer.convert_tokens_to_ids(vocab) == list(range(base, base + len(vocab))) + tokenizer.pad_token = tokenizer.eos_token + tokenizer.save_pretrained(path / "tokenizer") + result = { + "world": config["world"], + "world_sha256": digest(path / "world.npz"), + "panels_sha256": digest(path / "panels.npz"), + "entities": 2000, + "relations": 200, + "degree": 20, + "atomic_id": int((~world["ood"]).sum()), + "atomic_ood": int(world["ood"].sum()), + "candidate_train_ii": len(world["train_order"]), + "full_test_ii": len(world["test_ii"]), + "panels": {k: len(v) for k, v in panels.items()}, + "base_vocabulary": base, + "vocab_size": len(tokenizer), + "entity_offset": base, + "relation_offset": base + 2000, + "end_marker": tokenizer.convert_tokens_to_ids(""), + "pad_token": tokenizer.pad_token_id, + "created_utc": utc(), + } + write_json(path / "complete.json", result) + write_json(ARTIFACTS / "data-audit.json", result) + return result + + +def encode_rows(rows, metadata): + """Only tail and are targets; padding cannot influence earlier positions.""" + rows = np.asarray(rows) + x = np.full((len(rows), 4), metadata["pad_token"], dtype=np.int64) + x[:, : rows.shape[1]] = rows + x[:, 0] += metadata["entity_offset"] + x[:, rows.shape[1] - 1] += metadata["entity_offset"] + x[:, 1 : rows.shape[1] - 1] += metadata["relation_offset"] + pos = np.tile([rows.shape[1] - 2, rows.shape[1] - 1], (len(rows), 1)) + labels = np.column_stack( + [rows[:, -1] + metadata["entity_offset"], np.full(len(rows), metadata["end_marker"])] + ) + return x, pos, labels + + +def audit_support_roles(config): + world = dict(np.load(ROOT / "data/world.npz")) + panels = dict(np.load(ROOT / "data/panels.npz")) + atoms = world["atoms"] + lookup = np.full((2000, 200), -1, dtype=np.int32) + lookup[atoms[:, 0], atoms[:, 1]] = np.arange(len(atoms)) + results = [] + for phi in sorted({s["phi"] for s in config["runs"]}): + support = round(phi * (~world["ood"]).sum()) + selected = world["train_order"][:support] + first = np.bincount(world["first"][selected], minlength=len(atoms)) + second = np.bincount(world["second"][selected], minlength=len(atoms)) + seen_pairs = np.zeros((2000, 2000), dtype=bool) + chains = world["chains"][selected] + seen_pairs[chains[:, 0], chains[:, 3]] = True + tasks = {} + for name, rows in panels.items(): + if rows.shape[1] != 4: + continue + e1 = lookup[rows[:, 0], rows[:, 1]] + e2 = lookup[atoms[e1, 2], rows[:, 2]] + assert np.all(e1 >= 0) and np.all(e2 >= 0) + tasks[name] = { + "n": len(rows), + "first_fact_seen_in_first_role": float((first[e1] > 0).mean()), + "second_fact_seen_in_second_role": float((second[e2] > 0).mean()), + "both_seen_in_required_roles": float(((first[e1] > 0) & (second[e2] > 0)).mean()), + "head_tail_pair_seen_in_training": float(seen_pairs[rows[:, 0], rows[:, 3]].mean()), + } + results.append( + { + "phi": phi, + "support": support, + "composition_fraction": support / (len(atoms) + support), + "id_first_role_coverage": float((first[~world["ood"]] > 0).mean()), + "id_second_role_coverage": float((second[~world["ood"]] > 0).mean()), + "ood_first_role_count": int(first[world["ood"]].sum()), + "ood_second_role_count": int(second[world["ood"]].sum()), + "panels": tasks, + } + ) + assert results[-1]["ood_first_role_count"] == results[-1]["ood_second_role_count"] == 0 + write_json(ARTIFACTS / "support-role-audit.json", {"supports": results}) + return results + + +class ReproductionGPT(nn.Module): + """Native HF initialization and modules, with equivalent supervised readout.""" + + def __init__(self, config, repeats=1): + super().__init__() + self.config, self.repeats = config, repeats + self.transformer = GPT2LMHeadModel(config).transformer + + def forward(self, tokens, positions=None): + cfg, t = self.config, self.transformer + length = tokens.shape[1] + x = t.wte(tokens) + t.wpe(torch.arange(length, device=tokens.device)) + x = F.dropout(x, cfg.embd_pdrop, self.training) + for _ in range(self.repeats): + for block in t.h: + z = block.ln_1(x) + q, k, v = block.attn.c_attn(z).split(cfg.n_embd, dim=2) + shape = (len(tokens), length, cfg.n_head, cfg.n_embd // cfg.n_head) + q, k, v = (a.view(shape).transpose(1, 2) for a in (q, k, v)) + y = F.scaled_dot_product_attention( + q, k, v, is_causal=True, dropout_p=cfg.attn_pdrop if self.training else 0.0 + ) + y = block.attn.c_proj(y.transpose(1, 2).reshape(len(tokens), length, cfg.n_embd)) + x = x + F.dropout(y, cfg.resid_pdrop, self.training) + x = x + block.mlp(block.ln_2(x)) + x = t.ln_f(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + return F.linear(x, t.wte.weight) + + +def construct(spec, metadata, device): + torch.manual_seed(spec["initialization"]) + cfg = GPT2Config.from_pretrained(ROOT / "reference/gpt2", local_files_only=True) + cfg.vocab_size = metadata["vocab_size"] + cfg.n_layer = spec["unique_layers"] + cfg.use_cache = False + return ReproductionGPT(cfg, spec["repeats"]).to(device) + + +def optimizer_for(model, lr, decay): + params = list(model.named_parameters()) + return torch.optim.AdamW( + [ + { + "params": [p for n, p in params if not any(s in n for s in ["bias", "ln"])], + "weight_decay": decay, + }, + { + "params": [p for n, p in params if any(s in n for s in ["bias", "ln"])], + "weight_decay": 0.0, + }, + ], + lr=lr, + betas=(0.9, 0.999), + eps=1e-8, + fused=True, + capturable=True, + ) + + +class ReproductionStep(GraphStep): + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, positions, labels = (part[self.index] for part in self.table) + with torch.autocast("cuda", dtype=torch.bfloat16): + logits = self.model(x, positions) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten()) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +class MergedBatchStream(EpochStream): + """Match DataLoader's final partial batch using loss-masked graph padding.""" + + def batch(self, batch_size): + if not len(self.remaining): + self.remaining = self.rng.permutation(self.size) + count = min(batch_size, len(self.remaining)) + result = np.full(batch_size, self.size, dtype=np.int64) + result[:count] = self.remaining[:count] + self.remaining = self.remaining[count:] + return result, count + + +@torch.no_grad() +def evaluate_rows(model, rows, metadata, device, batch_size=256): + model.eval() + packed = encode_rows(rows, metadata) + answers, stops, losses = [], [], [] + for start in range(0, len(rows), batch_size): + x, pos, labels = [ + torch.as_tensor(p[start : start + batch_size], device=device) for p in packed + ] + with torch.autocast("cuda", dtype=torch.bfloat16): + logits = model(x, pos) + nll = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), reduction="none") + answer = logits[:, 0].argmax(-1) + x[torch.arange(len(x), device=device), pos[:, 1]] = answer + stop = model(x, pos)[:, 1].argmax(-1) + answers.append(answer.cpu().numpy()) + stops.append(stop.cpu().numpy()) + losses.append(nll.view(-1, 2).float().cpu().numpy()) + model.train() + answer, stop, nll = np.concatenate(answers), np.concatenate(stops), np.concatenate(losses) + correct = answer == rows[:, -1] + metadata["entity_offset"] + return { + "n": len(rows), + "answer_accuracy": float(correct.mean()), + "accuracy": float((correct & (stop == metadata["end_marker"])).mean()), + "answer_nll": float(nll[:, 0].mean()), + "nll": float(nll.mean()), + }, {"answer": answer, "stop": stop, "nll": nll, "rows": rows} + + +def learning_rate(spec, step): + # HF's warmup schedule starts the first optimizer update at zero LR. + return spec["lr"] * min((step - 1) / spec["warmup"], 1.0) + + +def save_checkpoint(path, model, optimizer, stream, counts, step, spec, training_seconds): + tmp = path.with_suffix(".tmp") + torch.save( + { + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "step": step, + "spec": spec, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(), + "training_seconds": training_seconds, + }, + tmp, + ) + tmp.replace(path) + + +def train_run(config, spec, gpu): + torch.set_num_threads(4) + if torch.get_num_interop_threads() != 1: + torch.set_num_interop_threads(1) + torch.cuda.set_device(gpu) + torch.backends.cuda.matmul.allow_tf32 = True + device = torch.device(f"cuda:{gpu}") + out = ROOT / "development" / spec["name"] + out.mkdir(parents=True, exist_ok=True) + if (out / "complete.json").exists(): + return + metadata = json.loads((ROOT / "data/complete.json").read_text()) + assert digest(ROOT / "data/world.npz") == metadata["world_sha256"] + assert digest(ROOT / "data/panels.npz") == metadata["panels_sha256"] + world = dict(np.load(ROOT / "data/world.npz")) + support = round(spec["phi"] * metadata["atomic_id"]) + selected = world["train_order"][:support] + assert len(selected) == support + atomic = encode_rows(world["atoms"], metadata) + composite = encode_rows(world["chains"][selected], metadata) + padding = ( + np.full((1, 4), metadata["pad_token"], dtype=np.int64), + np.array([[2, 3]], dtype=np.int64), + np.array([[-100, -100]], dtype=np.int64), + ) + table = tuple( + torch.as_tensor(np.concatenate([a, b, p]), device=device) + for a, b, p in zip(atomic, composite, padding, strict=True) + ) + del atomic, composite + model = construct(spec, metadata, device) + initial_hash = model_digest(model) + lr = torch.tensor(0.0, device=device) + optimizer = optimizer_for(model, lr, spec["weight_decay"]) + stream = MergedBatchStream(len(table[0]) - 1, spec["stream_seed"]) + counts = np.zeros(len(table[0]) - 1, dtype=np.int64) + step, training_seconds = 0, 0.0 + latest = out / "latest.pt" + rng = None + if latest.exists(): + saved = torch.load(latest, map_location=device, weights_only=False) + assert saved["spec"] == spec + model.load_state_dict(saved["model"]) + optimizer.load_state_dict(saved["optimizer"]) + # load_state_dict can replace group LR objects; refill the object the optimizer uses. + lr = optimizer.param_groups[0]["lr"] + for group in optimizer.param_groups: + group["lr"] = lr + stream.load_state_dict(saved["stream"]) + counts, step = saved["counts"], saved["step"] + training_seconds = saved["training_seconds"] + rng = (saved["cpu_rng"].cpu(), saved["cuda_rng"].cpu()) + del saved + if rng is not None: + torch.set_rng_state(rng[0]) + torch.cuda.set_rng_state(rng[1]) + model.train() + graph = ReproductionStep(model, optimizer, table, spec["batch_size"]) + panels = dict(np.load(ROOT / "data/panels.npz")) + learning_path = out / "learning.json" + history = json.loads(learning_path.read_text()) if learning_path.exists() else [] + history = [r for r in history if r["step"] <= step] + started = time.perf_counter() + parameters = sum(p.numel() for p in model.parameters()) + flop_step = matmul_flops( + ModelConfig( + metadata["vocab_size"], + model.config.n_embd, + model.config.n_layer * model.repeats, + model.config.n_head, + 1024, + ), + spec["batch_size"], + sequence=4, + output_positions=2, + ) + write_json( + out / "run.json", + { + "spec": spec, + "world_sha256": metadata["world_sha256"], + "initial_model_sha256": initial_hash, + "parameters": parameters, + "atomic_examples": len(world["atoms"]), + "composition_examples": support, + "vocab_size": metadata["vocab_size"], + "gpu": gpu, + "gpu_name": torch.cuda.get_device_name(gpu), + "started_utc": utc(), + "dtype": "bf16 AMP with float32 parameters/Adam state", + "pid": os.getpid(), + "resumed_step": step, + }, + ) + + def measure(): + metrics = {} + for name, panel in panels.items(): + metrics[name], pred = evaluate_rows(model, panel, metadata, device) + np.savez_compressed(out / f"predictions-{step:07d}-{name}.npz", **pred) + record = { + "step": step, + "metrics": metrics, + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "created_utc": utc(), + "examples": int(counts.sum()), + "supervised_tokens": int(counts.sum()) * 2, + "executed_input_tokens": step * spec["batch_size"] * 4, + "estimated_matmul_training_flops": step * flop_step, + "composition_epochs": float(counts[len(world["atoms"]) :].sum() / support), + "atomic_epochs": float(counts[: len(world["atoms"])].sum() / len(world["atoms"])), + } + history.append(record) + write_json(learning_path, history) + write_json( + out / "status.json", + { + "state": "running", + "step": step, + "budget": spec["steps"], + "training_seconds": training_seconds, + "train_ii": metrics["train_ii"]["accuracy"], + "test_ii": metrics["test_ii"]["accuracy"], + "test_oo": metrics["test_oo"]["accuracy"], + "updated_utc": utc(), + }, + ) + print( + json.dumps( + { + "name": spec["name"], + "step": step, + "train": metrics["train_ii"]["accuracy"], + "id": metrics["test_ii"]["accuracy"], + "oo": metrics["test_oo"]["accuracy"], + } + ), + flush=True, + ) + + def checkpoint(): + save_checkpoint(latest, model, optimizer, stream, counts, step, spec, training_seconds) + retained = out / f"checkpoint-{step:07d}.pt" + torch.save({"model": model.state_dict(), "spec": spec, "step": step}, retained) + np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=counts, selected=selected) + + if not history or history[-1]["step"] != step: + measure() + if step == 0 and 0 in config["checkpoint_nodes"]: + checkpoint() + for end in [n for n in config["evaluation_nodes"] if n > step]: + torch.cuda.synchronize() + segment = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = np.stack([stream.batch(spec["batch_size"])[0] for _ in range(n)]) + counts += np.bincount(indices.ravel(), minlength=len(counts) + 1)[: len(counts)] + indices = torch.as_tensor(indices, device=device) + for i in range(n): + lr.fill_(learning_rate(spec, step + i + 1)) + loss = graph(indices[i]) + step += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - segment + loss_value = float(loss) + if not math.isfinite(loss_value) or not math.isfinite(float(graph.grad_norm)): + raise FloatingPointError(f"Nonfinite loss/gradient at {step}") + measure() + if step in config["checkpoint_nodes"]: + checkpoint() + assert step == spec["steps"] + epoch_steps = math.ceil(len(counts) / spec["batch_size"]) + full_epochs, remainder = divmod(step, epoch_steps) + expected_examples = full_epochs * len(counts) + remainder * spec["batch_size"] + assert counts.sum() == expected_examples + assert counts.max() - counts.min() <= 1 + # Full endpoint evaluation complements the original fixed 3k training panels. + full = {} + for name, data in { + "atomic_all": world["atoms"], + "train_ii_all": world["chains"][selected], + }.items(): + full[name], pred = evaluate_rows(model, data, metadata, device) + np.savez_compressed(out / f"endpoint-{name}.npz", **pred) + final = { + "state": "complete", + "step": step, + "full_endpoint": full, + "parameters": parameters, + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "estimated_matmul_training_flops": step * flop_step, + "completed_utc": utc(), + "final_checkpoint_sha256": digest(out / f"checkpoint-{step:07d}.pt"), + "model_sha256": model_digest(model), + } + write_json(out / "complete.json", final) + write_json(out / "status.json", final) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_data.py new file mode 100644 index 0000000000000000000000000000000000000000..b67eee718fd00d44c1de51a2821e24aa7251196b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_data.py @@ -0,0 +1,396 @@ +"""CounterFact true-label data, explicit audit decisions and indivisible subject pools.""" + +from __future__ import annotations + +import hashlib +import re +import unicodedata +from collections import Counter, defaultdict + +import numpy as np + +from .hebbian_learning import ARTIFACTS, DATA, config, now, read_json, sha256, write_json + +TEMPLATE = "Complete the statement with the missing answer only.\nStatement: {}\nAnswer:" + + +def normalize(text): + return " ".join(unicodedata.normalize("NFKC", text).split()).casefold() + + +def normalize_answer(text): + text = normalize(text) + while text and unicodedata.category(text[-1]).startswith("P"): + text = text[:-1].rstrip() + return text + + +def score_answer(prediction, aliases): + lines = [x.strip() for x in prediction.splitlines() if x.strip()] + first = lines[0] if lines else "" + return int(normalize_answer(first) in {normalize_answer(x) for x in aliases}) + + +def encode_answer(tokenizer, prompt, answer): + """Tokenize the complete string once; offset overlap includes leading answer space.""" + suffix = " " + answer + text = prompt + suffix + encoded = tokenizer(text, add_special_tokens=False, return_offsets_mapping=True) + ids, offsets = encoded["input_ids"], encoded["offset_mapping"] + start = len(prompt) + mask = [int(end > start) for begin, end in offsets] + if any(begin < start < end for begin, end in offsets): + raise ValueError("A token straddles the prompt/answer boundary") + answer_start = mask.index(1) + if ids[:answer_start] != tokenizer(prompt, add_special_tokens=False)["input_ids"]: + raise ValueError("Prompt tokenization changes at the answer boundary") + assert not any(mask[:answer_start]) and all(mask[answer_start:]) + return { + "input_ids": ids + [tokenizer.eos_token_id], + "loss_mask": mask + [1], + "answer_start": answer_start, + "answer_tokens": sum(mask), + "prompt_tokens": answer_start, + } + + +def stable_hash(text): + return hashlib.sha256(text.encode()).hexdigest() + + +def clean_candidates(tokenizer): + cfg = config()["data"] + raw_path = DATA / "source/counterfact.json" + raw = read_json(raw_path) + audit, candidates, seen = [], [], {} + conflicting = set() + # Near-identical punctuation/accent variants are conservatively quarantined; + # normalized identical subjects already share a group. + subjects = defaultdict(set) + for row in raw: + name = normalize(row["requested_rewrite"]["subject"]) + key = "".join(c for c in unicodedata.normalize("NFKD", name) if c.isalnum()) + subjects[key].add(name) + ambiguous = set().union(*(v for v in subjects.values() if len(v) > 1)) + for row in raw: + r = row["requested_rewrite"] + if r["relation_id"] not in cfg["relations"]: + continue + subject = " ".join(unicodedata.normalize("NFKC", r["subject"]).split()) + group = normalize(subject) + answer = r["target_true"]["str"].strip() + views = [r["prompt"].format(r["subject"])] + row["paraphrase_prompts"][:2] + views = [" ".join(unicodedata.normalize("NFKC", p).split()) for p in views] + reasons = [] + decision = "include" + if len(views) != 3 or len(set(map(normalize, views))) != 3: + reasons.append("missing_or_duplicate_views") + if any( + re.search(r"(? cfg["prompt_max_tokens"] for x in encoded): + reasons.append("prompt_over_limit") + if any(x["answer_tokens"] > cfg["answer_max_tokens"] for x in encoded): + reasons.append("answer_over_limit") + except ValueError as e: + reasons.append(str(e)) + key = (group, r["relation_id"]) + if key in seen: + previous = seen[key] + if previous["target_id"] == r["target_true"]["id"]: + previous["source_ids"].append(row["case_id"]) + reasons.append("merged_subject_relation_duplicate") + else: + reasons.append("conflicting_subject_relation_targets") + decision = "review" + conflicting.add(key) + if reasons and decision == "include": + decision = "exclude" + record = { + "case_id": row["case_id"], + "source_ids": [row["case_id"]], + "subject": subject, + "subject_group": group, + "relation_id": r["relation_id"], + "target_id": r["target_true"]["id"], + "answer": answer, + "target_new_source_only": r["target_new"], + "views": views, + "encoded": encoded, + } + audit.append( + { + "case_id": row["case_id"], + "decision": decision, + "reasons": reasons, + "audit_type": "programmatic", + "subject_group": group, + } + ) + if decision == "include": + candidates.append(record) + seen[key] = record + # Conflicting labels disqualify every side of a conflict, including the first row. + conflict_ids = { + r["case_id"] for r in candidates if (r["subject_group"], r["relation_id"]) in conflicting + } + for entry in audit: + if entry["case_id"] in conflict_ids: + entry["decision"] = "review" + entry["reasons"].append("conflicting_subject_relation_targets") + candidates = [r for r in candidates if r["case_id"] not in conflict_ids] + prompt_owners = defaultdict(set) + for record in candidates: + for prompt in record["views"]: + prompt_owners[normalize(prompt)].add(record["subject_group"]) + collision_ids = { + r["case_id"] + for r in candidates + if any(len(prompt_owners[normalize(p)]) > 1 for p in r["views"]) + } + for entry in audit: + if entry["case_id"] in collision_ids: + entry["decision"] = "review" + entry["reasons"].append("cross_subject_prompt_collision") + candidates = [r for r in candidates if r["case_id"] not in collision_ids] + # Each pool gets a disjoint candidate reserve before any baseline outcome is observed. + # Extra keep reserve accounts for its required pre-existing exact generation success. + pool_weights = {k: n * (3 if k.endswith("keep") else 1) for k, n in cfg["pools"].items()} + total_weight = sum(pool_weights.values()) + by_subject = defaultdict(list) + for r in candidates: + by_subject[r["subject_group"]].append(r) + stratified = defaultdict(list) + for group, rows in by_subject.items(): + stratified[min(r["relation_id"] for r in rows)].append(group) + rng = np.random.default_rng(cfg["split_seed"]) + for _relation, groups in sorted(stratified.items()): + groups.sort(key=stable_hash) + rng.shuffle(groups) + cumulative = 0.0 + start = 0 + for pool, weight in pool_weights.items(): + cumulative += weight / total_weight + end = round(cumulative * len(groups)) + for group in groups[start:end]: + for record in by_subject[group]: + record["candidate_pool"] = pool + start = end + write_json(DATA / "candidates.json", candidates) + write_json(ARTIFACTS / "programmatic-audit.json", audit) + write_json( + ARTIFACTS / "subject-alias-audit.json", + { + "method": "NFKC/casefold grouping; punctuation/accent variants quarantined", + "limitations": "No claim of exhaustive real-world entity resolution", + "review_groups": [sorted(v) for v in subjects.values() if len(v) > 1], + }, + ) + write_json( + ARTIFACTS / "preparation.json", + { + "time": now(), + "raw_count": len(raw), + "source_sha256": sha256(raw_path), + "candidate_count": len(candidates), + "decisions": dict(Counter(x["decision"] for x in audit)), + "reasons": dict(Counter(y for x in audit for y in x["reasons"])), + "candidate_pools": dict(Counter(x["candidate_pool"] for x in candidates)), + "candidate_sha256": sha256(DATA / "candidates.json"), + "status": "awaiting_individual_semantic_audit_and_baseline", + "source_license": ( + "CounterFact source snapshot; upstream ROME repository MIT; " + "dataset-specific license not asserted" + ), + }, + ) + return candidates + + +def balanced_order(records, seed): + rng = np.random.default_rng(seed) + groups = defaultdict(list) + for record in sorted(records, key=lambda r: r["case_id"]): + groups[record["relation_id"]].append(record) + for items in groups.values(): + rng.shuffle(items) + result = [] + while any(groups.values()): + for relation in sorted(groups): + if groups[relation]: + result.append(groups[relation].pop()) + return result + + +def semantic_audit(): + """Apply explicitly reviewed predicate rules; retain per-row evidence and limitations. + + This is a reproducible semantic rule audit, not a claim that a human or another + model independently reviewed every source fact. Benchmark truth is assumed. + """ + candidates = read_json(DATA / "candidates.json") + result = [] + for record in candidates: + issues, evidence = [], [] + subject = normalize(record["subject"]) + relation = record["relation_id"] + for view in record["views"]: + text = normalize(view) + start = text.rfind(subject) + suffix = text[start + len(subject) :].strip() + prefix = text[:start] + evidence.append({"predicate_suffix": suffix, "relation_prefix": prefix[-64:]}) + if relation == "P19" and suffix != "was born in": + issues.append("origin_or_native_place_does_not_uniquely_mean_birthplace") + if relation == "P103" and (suffix in {"spoke the language", ", speaker of"}): + issues.append("spoken_language_does_not_uniquely_mean_mother_tongue") + if ( + relation == "P103" + and suffix == "is" + and not any( + prefix.endswith(p) for p in ["the mother tongue of ", "the native language of "] + ) + ): + issues.append("missing_native_language_relation") + if relation == "P176" and "developed by" in suffix: + issues.append("developer_is_not_necessarily_manufacturer") + if relation == "P178" and "manufactured by" in suffix: + issues.append("manufacturer_is_not_necessarily_developer") + if ( + relation in {"P364", "P407"} + and suffix in {"is", "was"} + and not any( + prefix.endswith(p) for p in ["the language of ", "the original language of "] + ) + ): + issues.append("missing_language_relation") + result.append( + { + "case_id": record["case_id"], + "decision": "review" if issues else "include", + "reasons": sorted(set(issues)), + "view_evidence": evidence, + "audit_type": "model_authored_semantic_rules_applied_programmatically", + "truth_status": "CounterFact original label; no independent fact verification", + } + ) + write_json(ARTIFACTS / "semantic-audit.json", result) + write_json( + ARTIFACTS / "semantic-audit-method.json", + { + "time": now(), + "status": "conservative_template_semantics_audit", + "decisions": dict(Counter(r["decision"] for r in result)), + "limitations": [ + "Real-world truths and all entity aliases are not independently verified", + "Creator/product/origin formulations use source benchmark semantics", + "Model-authored rule audit; independent human review not performed", + ], + "primary_subset": "Only all-three-view records passing these conservative rules", + "review_pool": "Excluded from all fitting and evaluation; never auto-promoted", + }, + ) + return result + + +def lock_data(): + """No training may consume unaudited rows or an outcome-adapted subject split.""" + cfg = config()["data"] + candidates = read_json(DATA / "candidates.json") + semantic = {r["case_id"]: r for r in read_json(ARTIFACTS / "semantic-audit.json")} + baseline = {r["case_id"]: r for r in read_json(DATA / "baseline.json")} + pools, coverage = {}, {} + for name, count in cfg["pools"].items(): + available = [ + r + for r in candidates + if r["candidate_pool"] == name + and semantic.get(r["case_id"], {}).get("decision") == "include" + and r["case_id"] in baseline + ] + if name.endswith("keep"): + available = [r for r in available if baseline[r["case_id"]]["views"][0]["answer_em"]] + ordered = balanced_order(available, cfg["split_seed"]) + if name.startswith(("B_", "C_")): + + def needs_learning(r): + v = baseline[r["case_id"]]["views"] + return not v[0]["answer_em"] and not all(x["answer_em"] for x in v[1:]) + + ordered = [r for r in ordered if needs_learning(r)] + [ + r for r in ordered if not needs_learning(r) + ] + unit = cfg["episode_size"].get(name, 8) + actual = min(count, len(ordered) // unit * unit) + if actual < unit: + raise ValueError(f"{name} has fewer than one complete batch/episode: {len(ordered)}") + pools[name] = ordered[:actual] + coverage[name] = { + "planned": count, + "available": len(ordered), + "actual": actual, + "relations": dict(Counter(r["relation_id"] for r in ordered[:actual])), + } + group_sets = {k: {r["subject_group"] for r in rows} for k, rows in pools.items()} + names = list(pools) + for i, a in enumerate(names): + for b in names[i + 1 :]: + assert not group_sets[a] & group_sets[b], (a, b) + aliases = defaultdict(set) + for rows in pools.values(): + for r in rows: + aliases[r["target_id"]].add(r["answer"]) + for rows in pools.values(): + for r in rows: + r["aliases"] = sorted(aliases[r["target_id"]]) + r["baseline"] = baseline[r["case_id"]] + episodes = { + name: [ + [r["case_id"] for r in rows[i : i + cfg["episode_size"][name]]] + for i in range(0, len(rows), cfg["episode_size"][name]) + ] + for name, rows in pools.items() + if name in cfg["episode_size"] + } + write_json(DATA / "pools.json", pools) + write_json(DATA / "episodes.json", episodes) + write_json( + ARTIFACTS / "data-lock.json", + { + "time": now(), + "coverage": coverage, + "subject_disjoint": True, + "files": { + p: sha256(DATA / p) + for p in [ + "candidates.json", + "pools.json", + "episodes.json", + "baseline.json", + "text.json", + ] + }, + "semantic_audit_sha256": sha256(ARTIFACTS / "semantic-audit.json"), + "revision": "Full-episode coverage reduction before model learning, where needed", + "status": "locked", + }, + ) + return coverage diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_followup.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_followup.py new file mode 100644 index 0000000000000000000000000000000000000000..89afed17153ba18880997b4089ddadb1b997f80b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_followup.py @@ -0,0 +1,103 @@ +"""Fixed-content worlds and conservative full-entity answer parsing.""" + +from __future__ import annotations + +import hashlib +import re +import unicodedata +from collections import defaultdict + +import numpy as np + +from .hebbian_future import ROOT, chain_world + +CONFIG = ROOT / "configs/hebbian-future-v2.json" +ART = ROOT / "docs/development-artifacts/hebbian-future-v2" +DATA = ROOT / "data/hebbian-future-v2" +RESULTS = ROOT / "results/hebbian-future-v2" + + +def stable(value): + return hashlib.sha256(str(value).encode()).hexdigest() + + +def fixed_world(world, rho, cfg): + """Change only nonfocal home values as rho changes; focal wrong values stay fixed.""" + w = chain_world(world, rho, cfg) + rng = np.random.default_rng(world + 918273) + people = rng.permutation(cfg["people"]).reshape(cfg["organizations"], 8) + hq = rng.permutation(np.arange(cfg["organizations"]) % cfg["cities"]) + city_order = rng.permutation(cfg["cities"]) + matches = int(rho * 4) + for group, persons in enumerate(people): + for split in range(2): + selected = persons[split * 4 : split * 4 + 4] + # Offset of slot j is j at EVERY rho until made coherent. Slot 3 + # is always the same competing city, in both train and held-out. + offsets = np.arange(4) + offsets[:matches] = 0 + w["home"][selected] = city_order[(hq[group] + offsets) % 4] + w["home_y"] = w["city_start"] + w["home"] + return w + + +def normalize(text): + return " ".join(unicodedata.normalize("NFKC", text).casefold().split()) + + +def inventory_from_facts(facts): + inventory = defaultdict(dict) + for fact in facts: + values = inventory[fact["relation_id"]] + item = values.setdefault(fact["target_id"], {"label": fact["answer"], "aliases": []}) + item["aliases"] = sorted(set(item["aliases"] + fact.get("aliases", []) + [fact["answer"]])) + return dict(inventory) + + +def parse_entity(text, inventory): + """Read a leading complete alias, abstaining on collisions/negation/lists. + + Plain completion makes a leading answer meaningful. The parser does not + convert every nonmatch into factual error. No model-assisted grading. + """ + text = normalize(text).lstrip(" \"'`“”‘’([{:") + if not text: + return {"status": "unrecognized", "entity": None} + if re.match(r"(?:not|no|neither|unknown|i don't|i do not)\b", text): + return {"status": "unrecognized", "entity": None} + matches = [] + for entity, item in inventory.items(): + for alias in item["aliases"]: + a = normalize(alias) + if text.startswith(a) and (len(text) == len(a) or not text[len(a)].isalnum()): + matches.append((len(a), entity)) + if not matches: + return {"status": "unrecognized", "entity": None} + length = max(n for n, _ in matches) + entities = {entity for n, entity in matches if n == length} + if len(entities) != 1: + return {"status": "ambiguous", "entity": None} + suffix = text[length:].lstrip() + if re.match(r"(?:and|or|/|,?\s*not)\b", suffix): + return {"status": "ambiguous", "entity": None} + return {"status": "recognized", "entity": next(iter(entities))} + + +def candidate_set(fact, inventory, seed): + items = inventory[fact["relation_id"]] + own_aliases = {normalize(a) for a in items[fact["target_id"]]["aliases"]} + ordered = sorted(items, key=lambda x: stable(f"{seed}:{fact['case_id']}:{x}")) + selected = [fact["target_id"]] + aliases = set(own_aliases) + for entity in ordered: + other = {normalize(a) for a in items[entity]["aliases"]} + if entity in selected or aliases.intersection(other): + continue + selected.append(entity) + aliases.update(other) + if len(selected) == 4: + break + if len(selected) != 4: + raise ValueError("Need four distinct, unambiguous candidates") + # Correct position varies independently of model outputs. + return sorted(selected, key=lambda x: stable(f"position:{seed}:{fact['case_id']}:{x}")) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_future.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_future.py new file mode 100644 index 0000000000000000000000000000000000000000..24171d0e5bc0c31f7cc4ac32af06d86dd8ec15f4 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_future.py @@ -0,0 +1,148 @@ +"""Exploratory kernel prediction and balanced multi-hop worlds, September 2026.""" + +from __future__ import annotations + +import hashlib +import json +from pathlib import Path + +import numpy as np + +ROOT = Path(__file__).resolve().parents[2] +CONFIG = ROOT / "configs/hebbian-future-v1.json" +ART = ROOT / "docs/development-artifacts/hebbian-future-v1" +DATA = ROOT / "data/hebbian-future-v1" +RESULTS = ROOT / "results/hebbian-future-v1" + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, obj): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(obj, ensure_ascii=False, indent=2, allow_nan=False) + "\n") + temporary.replace(path) + + +def digest(path): + h = hashlib.sha256() + with Path(path).open("rb") as handle: + for block in iter(lambda: handle.read(1024 * 1024), b""): + h.update(block) + return h.hexdigest() + + +def unit(x): + x = np.asarray(x, dtype=np.float64) + return x / np.maximum(np.linalg.norm(x, axis=-1, keepdims=True), 1e-12) + + +def chain_world(world, correlation, cfg): + """Match marginals, subjects, memberships and query exposure across correlations. + + Eight people per organization: four combination-trained, four held out. + Within EACH split and organization exactly rho*4 have home==HQ. Other home + cities cycle identically across the balanced HQ city groups, keeping both + training/held-out home-city histograms uniform. ID permutations are shared. + """ + n, groups, cities = (cfg[x] for x in ("people", "organizations", "cities")) + assert n == groups * 8 and groups % cities == 0 + rng = np.random.default_rng(world + 918273) + people = rng.permutation(n).reshape(groups, 8) + headquarters = rng.permutation(np.arange(groups) % cities) + city_order = rng.permutation(cities) + membership = np.empty(n, dtype=int) + home = np.empty(n, dtype=int) + train = np.zeros(n, dtype=bool) + common_conflict = np.zeros(n, dtype=bool) + matches = int(correlation * 4) + for group, persons in enumerate(people): + membership[persons] = group + for split in range(2): + subset = persons[split * 4 : split * 4 + 4] + common_conflict[subset[-1]] = True + offsets = np.r_[np.zeros(matches, dtype=int), 1 + np.arange(4 - matches) % 3] + home[subset] = city_order[(headquarters[group] + offsets) % cities] + if split == 0: + train[subset] = True + headquarters = city_order[headquarters] + # Shared vocabulary and query positions; labels are next-token + EOS. + person_start, group_start, city_start = 10, 10 + n, 10 + n + groups + vocab = city_start + cities + member = np.stack( + [np.ones(n, int), person_start + np.arange(n), np.full(n, 3), np.full(n, 2)], axis=1 + ) + root = np.stack( + [ + np.ones(groups, int), + group_start + np.arange(groups), + np.full(groups, 4), + np.full(groups, 2), + ], + axis=1, + ) + resident = member.copy() + resident[:, 2] = 5 + composite = member.copy() + composite[:, 2] = 6 + return { + "world": world, + "correlation": correlation, + "vocab": vocab, + "membership": membership, + "home": home, + "headquarters": headquarters, + "train_people": train, + "common_conflict": common_conflict, + "member_x": member, + "root_x": root, + "home_x": resident, + "composite_x": composite, + "member_y": group_start + membership, + "root_y": city_start + headquarters, + "home_y": city_start + home, + "composite_y": city_start + headquarters[membership], + "group_start": group_start, + "city_start": city_start, + } + + +def training_arrays(world): + mask = world["train_people"] + x = np.concatenate( + [world[k + "_x"] for k in ("member", "root", "home")] + [world["composite_x"][mask]] + ) + y = np.concatenate( + [world[k + "_y"] for k in ("member", "root", "home")] + [world["composite_y"][mask]] + ) + return x, y + + +def ridge_predict(train_x, train_y, test_x, penalty=10.0): + """Fixed ridge linear probability model; statistics fitted on dev only.""" + mean, scale = train_x.mean(0), np.maximum(train_x.std(0), 1e-8) + a = np.c_[np.ones(len(train_x)), (train_x - mean) / scale] + b = np.c_[np.ones(len(test_x)), (test_x - mean) / scale] + reg = np.eye(a.shape[1]) * penalty + reg[0, 0] = 0 + beta = np.linalg.solve(a.T @ a + reg, a.T @ train_y) + return np.clip(b @ beta, 0, 1) + + +def auc(y, scores): + positive, negative = np.asarray(scores)[y == 1], np.asarray(scores)[y == 0] + if not len(positive) or not len(negative): + return None + return float( + (positive[:, None] > negative).mean() + 0.5 * (positive[:, None] == negative).mean() + ) + + +def bootstrap_mean(values, seed, repeats=1000): + values = np.asarray(values) + rng = np.random.default_rng(seed) + means = values[rng.integers(len(values), size=(repeats, len(values)))].mean(1) + return [float(x) for x in np.quantile(means, [0.025, 0.975])] diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_interface.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_interface.py new file mode 100644 index 0000000000000000000000000000000000000000..0135ee958b76df5e2df2aa4ea0c2c57c40f2b24a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_interface.py @@ -0,0 +1,566 @@ +"""Paired CE/MSE memory interfaces on the released synthetic recall task. + +The official implementation supplies memory fitting, the reader, and batches. +This adapter fixes budgets and seeds, removes the future answer from inputs, +and records a complete crossing without selecting on the replacement mapping. +""" + +from __future__ import annotations + +import hashlib +import importlib.metadata +import json +import platform +import sys +import time +from dataclasses import asdict +from pathlib import Path + +import numpy as np +import torch +import torch.nn.functional as F + +ROOT = Path(__file__).resolve().parents[2] +DEFAULT_SPEC = { + "num_facts": 128, + "d_model": 64, + "hidden_dim": 256, + "junk_len": 9, + "junk_vocab_size": 9, + "batch_size": 256, + "mlp_epochs": 10000, + "mlp_lr": 0.001, + "mlp_min_lr": 1e-6, + "mlp_cutoff": -1.0, + "mlp_activation": "swish", + "mlp_bias": True, + "reader_steps": 4000, + "reader_lr": 2e-4, + "reader_weight_decay": 0.1, + "eval_every": 1000, + "eval_repeats": 8, + "cpu_threads": 1, + "source_path": "data/hebbian-interface-v1/source", +} + + +def _source(spec): + source = ROOT / spec["source_path"] / "src" + if str(source) not in sys.path: + sys.path.insert(0, str(source)) + + +def tensor_hash(tensors): + """Hash names, shapes, dtypes and raw values, independently of serialization.""" + digest = hashlib.sha256() + for name, value in sorted(tensors.items()): + tensor = value.detach().cpu().contiguous() + digest.update(f"{name}:{tuple(tensor.shape)}:{tensor.dtype}".encode()) + digest.update(tensor.numpy().tobytes()) + return digest.hexdigest() + + +def _state(model, *, non_mlp=False, frozen=False): + return { + name: value + for name, value in model.named_parameters() + if (not non_mlp or ".mlp." not in name) and (not frozen or not value.requires_grad) + } + + +def _memory_config(spec, loss, device): + from hebbian.mlp_core.mlp_gd import GDMLPConfig + from hebbian.mlp_core.task import SharedConstructionConfig + + shared = SharedConstructionConfig( + build_dtype=torch.float32, + final_dtype=torch.float32, + device=str(device), + verbose=False, + ) + shared.mlp_config.activation.activation = spec["mlp_activation"] + return GDMLPConfig( + shared=shared, + m=spec["hidden_dim"], + bias=spec["mlp_bias"], + num_epochs=spec["mlp_epochs"], + lr=spec["mlp_lr"], + min_lr=spec["mlp_min_lr"], + cutoff=spec["mlp_cutoff"], + loss_fn=loss, + batch_size=None, + eval_every=spec["eval_every"], + ) + + +def _new_memory(spec, device): + from hebbian.mlp_core.mlp_gd import _create_gd_mlp + + return _create_gd_mlp(spec["d_model"], spec["hidden_dim"], _memory_config(spec, "ce", device)) + + +def make_config(spec, seed, device): + """The fixed SSFR architecture; memory and optimizer numbers come from spec.""" + _source(spec) + from hebbian.transformer.config import AssociativeRecallConfig + + config = AssociativeRecallConfig() + dc, tc = config.dataset_config, config.train_config + dc.num_facts = spec["num_facts"] + dc.junk_vocab_size = spec["junk_vocab_size"] + dc.min_seq_length = dc.max_seq_length = spec["junk_len"] + dc.custom_finalize() + tc.device, tc.dtype, tc.seed = str(device), torch.float32, seed + tc.embeddings_config.d_model = spec["d_model"] + tc.embeddings_config.tie_embeddings = True + tc.mlp_method, tc.mlp_hidden_dim = "gd", spec["hidden_dim"] + tc.batch_size, tc.steps_per_dataset = spec["batch_size"], spec["reader_steps"] + arch = tc.transformer_config + arch.n_layers = arch.n_head = 1 + arch.use_identity_mlp = True + arch.mlp_residual = arch.attn_residual = False + arch.use_rope, arch.no_positional_encoding = False, True + arch.freeze_value_dense_identity = True + arch.mlp_norm_type = arch.lm_head_norm_type = "unit_rmsnorm" + arch.attn_norm_type, arch.bias = "rmsnorm", False + return config + + +def make_batches(spec, mapping, *, batch_size=None, num_batches=None): + """Author batches on CPU avoid a GPU synchronization per junk position.""" + from hebbian.transformer.data import AssociativeRecallBatchGenerator + + return AssociativeRecallBatchGenerator( + mapping, + spec["num_facts"], + spec["junk_vocab_size"], + spec["junk_len"], + spec["junk_len"], + batch_size or spec["batch_size"], + num_batches or spec["reader_steps"], + device=torch.device("cpu"), + ) + + +def fixed_inputs(spec, mapping, seed): + """Balanced keys and independently seeded junk, with the answer removed.""" + with torch.random.fork_rng(devices=[]): + torch.random.default_generator.manual_seed(seed) + keys = torch.arange(spec["num_facts"]).repeat_interleave(spec["eval_repeats"]) + inputs, _ = next(iter(make_batches(spec, mapping, batch_size=len(keys), num_batches=1))) + inputs[:, spec["junk_len"]] = keys + return inputs[:, :-1].contiguous(), keys + + +def _errors(actual, expected): + relative = (actual - expected).norm(dim=-1) / expected.norm(dim=-1).clamp_min(1e-12) + cosine = F.cosine_similarity(actual, expected, dim=-1).clamp(-1, 1) + return relative, cosine.acos() + + +def _accuracy(scores, targets, changed): + correct = scores.argmax(-1).eq(targets) + return { + "accuracy_all": correct.float().mean().item(), + "accuracy_changed": correct[changed].float().mean().item() if changed.any() else None, + "n_all": targets.numel(), + "n_changed": int(changed.sum()), + } + + +def _save_arrays(path, **arrays): + np.savez_compressed( + path, + **{ + name: value.detach().cpu().numpy() if isinstance(value, torch.Tensor) else value + for name, value in arrays.items() + }, + ) + + +@torch.no_grad() +def standalone(memory, factset, embeddings, changed, path): + outputs = memory(factset.input_embeddings) + targets = torch.tensor(factset.mapping.outputs, device=outputs.device) + expected = factset.output_embeddings[targets] + relative, angle = _errors(outputs, expected) + normalized = F.normalize(outputs, dim=-1) + fact_scores = normalized @ factset.output_embeddings.T + full_scores = normalized @ embeddings.weight.T + norm_error = (outputs.norm(dim=-1) - expected.norm(dim=-1)).abs() + result = { + "fact_accuracy": fact_scores.argmax(-1).eq(targets).float().mean().item(), + "full_accuracy": full_scores.argmax(-1).eq(targets).float().mean().item(), + "relative_error_mean": relative.mean().item(), + "angle_radians_mean": angle.mean().item(), + "norm_error_mean": norm_error.mean().item(), + "output_norm_mean": outputs.norm(dim=-1).mean().item(), + "full_vocab": _accuracy(full_scores, targets, changed.to(outputs.device)), + "artifact": path.name, + } + _save_arrays( + path, + key=torch.arange(len(targets)), + target=targets, + changed_mapping=changed, + pred=full_scores.argmax(-1), + pred_fact=fact_scores.argmax(-1), + scores=full_scores, + scores_fact=fact_scores, + scores_fact_raw=outputs @ factset.output_embeddings.T, + relative_error=relative, + angle_radians=angle, + norm_error=norm_error, + output_norm=outputs.norm(dim=-1), + ) + return result + + +@torch.no_grad() +def evaluate_reader(model, inputs, keys, targets, changed, embeddings, batch_size, path=None): + """Use actual query-position inputs to the MLP; never fit a predictor.""" + device = next(model.parameters()).device + cuda_devices = [device.index or 0] if device.type == "cuda" else [] + scores, queries = [], [] + was_training = model.training + model.eval() + hook = model.transformer.h[0].mlp.register_forward_pre_hook( + lambda module, args: queries.append(args[0][:, -1].detach().cpu()) + ) + try: + with torch.random.fork_rng(devices=cuda_devices): + for batch in inputs.split(batch_size): + logits, _ = model(batch.to(device)) + scores.append(logits[:, 0].cpu()) + finally: + hook.remove() + model.train(was_training) + scores, queries = torch.cat(scores), torch.cat(queries) + relative, angle = _errors(queries, embeddings.weight.detach().cpu()[keys]) + result = _accuracy(scores, targets, changed) + result.update( + { + "query_relative_error_mean": relative.mean().item(), + "query_angle_radians_mean": angle.mean().item(), + } + ) + if path is not None: + _save_arrays( + path, + key=keys, + target=targets, + changed_mapping=changed, + pred=scores.argmax(-1), + scores=scores, + query_input=queries, + query_relative_error=relative, + query_angle_radians=angle, + ) + result["artifact"] = path.name + return result + + +def load_checkpoint(path, device="cpu"): + """Load our tensor-only checkpoint; no refitting or custom-object unpickling.""" + payload = torch.load(path, map_location="cpu", weights_only=True) + spec = payload["spec"] + _source(spec) + if payload["kind"] == "memory": + model = _new_memory(spec, device) + else: + from hebbian.transformer.model import GPT, GPTConfig + + model = GPT(GPTConfig(**payload["gpt_config"])).to(device) + model.transformer.h[0].mlp = _new_memory(spec, device) + model.load_state_dict(payload["state_dict"], strict=True) + names = set(payload.get("trainable_names", [])) + for name, parameter in model.named_parameters(): + parameter.requires_grad_(name in names) + return model.eval(), payload + + +def run_world(spec, seed, output_dir, device): + """Fit four memories and two A-readers; evaluate all fixed final crossings.""" + spec = {**DEFAULT_SPEC, **spec} + if ( + min( + spec[k] + for k in ( + "num_facts", + "d_model", + "hidden_dim", + "mlp_epochs", + "reader_steps", + "eval_every", + "eval_repeats", + ) + ) + <= 0 + ): + raise ValueError("Dimensions and fixed training/evaluation budgets must be positive") + if spec["mlp_cutoff"] >= 0: + raise ValueError("This comparison requires the MLP loss cutoff to be disabled") + _source(spec) + from hebbian.transformer.fact_store import build_fact_mlp, build_factset, build_token_embeddings + from hebbian.transformer.model import GPT + from hebbian.transformer.train import _make_eval_factset + from hebbian.transformer.utils import ( + copy_embeddings_to_gpt, + create_gpt_config, + insert_mlp_into_gpt, + ) + + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + device = torch.device(device) + torch.set_num_threads(spec["cpu_threads"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + if device.type == "cuda": + torch.cuda.set_device(device) + torch.cuda.reset_peak_memory_stats(device) + started = time.perf_counter() + config = make_config(spec, seed, device) + factsets = {"A": build_factset(config, seed=seed)} + factsets["B"] = _make_eval_factset(factsets["A"], seed=seed + 7777) + embeddings = build_token_embeddings( + factsets["A"], + spec["junk_vocab_size"], + embedding_init="spherical", + dtype=torch.float32, + seed=seed, + ).to(device) + mappings = {name: torch.tensor(fs.mapping.outputs) for name, fs in factsets.items()} + changed = mappings["A"] != mappings["B"] + inputs, keys = fixed_inputs(spec, factsets["A"].mapping, seed + 20000) + _save_arrays( + output_dir / "world.npz", + inputs=inputs, + key=keys, + mapping_A=mappings["A"], + mapping_B=mappings["B"], + changed_mapping=changed, + embeddings=embeddings.weight, + ) + summary = { + "seed": seed, + "spec": spec, + "state": "running", + "memories": {}, + "readers": {}, + "environment": { + "python": platform.python_version(), + "torch": torch.__version__, + "numpy": np.__version__, + "transformers": importlib.metadata.version("transformers"), + "cuda": torch.version.cuda, + "device": str(device), + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + }, + "world": { + "changed_facts": int(changed.sum()), + "facts": spec["num_facts"], + "test_inputs_hash": tensor_hash({"inputs": inputs}), + "mapping_A": mappings["A"].tolist(), + "mapping_B": mappings["B"].tolist(), + }, + } + + def persist(): + temporary = output_dir / "summary.tmp" + temporary.write_text(json.dumps(summary, indent=2) + "\n") + temporary.replace(output_dir / "summary.json") + + memories = {} + for loss in ("ce", "mse"): + memories[loss], summary["memories"][loss] = {}, {} + for name, factset in factsets.items(): + stage = time.perf_counter() + torch.manual_seed(seed) + initial = _new_memory(spec, device) + initial_hash = tensor_hash(initial.state_dict()) + del initial + memory, metrics = build_fact_mlp( + config, factset, method_config=_memory_config(spec, loss, device) + ) + memory.eval().requires_grad_(False) + memories[loss][name] = memory + checkpoint = f"memory-{loss}-{name}.pt" + torch.save( + { + "kind": "memory", + "spec": spec, + "seed": seed, + "loss": loss, + "mapping": name, + "state_dict": {k: v.detach().cpu() for k, v in memory.state_dict().items()}, + }, + output_dir / checkpoint, + ) + _save_arrays( + output_dir / f"memory-{loss}-{name}-curve.npz", + train_loss=np.asarray(metrics["train_losses"]), + ) + assert len(metrics["train_losses"]) == spec["mlp_epochs"] + summary["memories"][loss][name] = { + "initial_hash": initial_hash, + "final_hash": tensor_hash(memory.state_dict()), + "seconds": time.perf_counter() - stage, + "checkpoint": checkpoint, + "training_final_loss": metrics["train_losses"][-1], + "training_final_fact_accuracy": metrics["final_accuracy"], + } + print(f"world {seed}: memory {loss}/{name} complete", flush=True) + persist() + + models = {} + for loss in ("ce", "mse"): + stage = time.perf_counter() + torch.manual_seed(seed) + gpt_config = create_gpt_config(config.train_config, config.dataset_config) + model = GPT(gpt_config).to(device=device, dtype=torch.float32).eval() + copy_embeddings_to_gpt(model, embeddings) + insert_mlp_into_gpt(model, memories[loss]["A"], embeddings) + initial_hash = tensor_hash(_state(model, non_mlp=True)) + frozen_before = tensor_hash(_state(model, frozen=True)) + optimizer = model.configure_optimizers( + weight_decay=spec["reader_weight_decay"], + learning_rate=spec["reader_lr"], + betas=(0.9, 0.999), + device_type=device.type, + ) + curve, stream_hash, train_loss_sum = [], hashlib.sha256(), 0.0 + torch.manual_seed(seed + 10000) + for step, (batch, labels) in enumerate(make_batches(spec, factsets["A"].mapping), 1): + batch, labels = batch[:, :-1].contiguous(), labels[:, :-1].contiguous() + stream_hash.update(batch.numpy().tobytes()) + stream_hash.update(labels[:, -1].numpy().tobytes()) + model.train() + logits, _ = model(batch.to(device)) + objective = F.cross_entropy(logits[:, 0], labels[:, -1].to(device)) + optimizer.zero_grad(set_to_none=True) + objective.backward() + optimizer.step() + train_loss_sum += objective.item() + if step % spec["eval_every"] == 0 or step == spec["reader_steps"]: + evaluation = evaluate_reader( + model, + inputs, + keys, + mappings["A"][keys], + changed[keys], + embeddings, + spec["batch_size"], + ) + curve.append( + {"step": step, "mean_training_loss": train_loss_sum / step, "A": evaluation} + ) + print( + f"world {seed}: reader {loss} step {step}, A={evaluation['accuracy_all']:.4f}", + flush=True, + ) + model.eval() + models[loss] = model + frozen_after = tensor_hash(_state(model, frozen=True)) + assert frozen_after == frozen_before + checkpoint = f"reader-{loss}.pt" + torch.save( + { + "kind": "reader", + "spec": spec, + "seed": seed, + "loss": loss, + "gpt_config": asdict(gpt_config), + "state_dict": {k: v.detach().cpu() for k, v in model.state_dict().items()}, + "trainable_names": [k for k, v in model.named_parameters() if v.requires_grad], + }, + output_dir / checkpoint, + ) + summary["readers"][loss] = { + "initial_non_mlp_hash": initial_hash, + "final_non_mlp_hash": tensor_hash(_state(model, non_mlp=True)), + "frozen_hash_before": frozen_before, + "frozen_hash_after": frozen_after, + "training_stream_hash": stream_hash.hexdigest(), + "curve": curve, + "seconds": time.perf_counter() - stage, + "checkpoint": checkpoint, + "endpoints": {}, + } + persist() + + stage = time.perf_counter() + for loss, model in models.items(): + for name in ("A", "B"): + summary["memories"][loss][name]["standalone"] = standalone( + memories[loss][name], + factsets[name], + embeddings, + changed, + output_dir / f"standalone-{loss}-{name}.npz", + ) + conditions = { + "A": (memories[loss]["A"], "A"), + "wrong_A_on_B": (memories[loss]["A"], "B"), + "B_ce": (memories["ce"]["B"], "B"), + "B_mse": (memories["mse"]["B"], "B"), + } + for condition, (memory, target_map) in conditions.items(): + insert_mlp_into_gpt(model.eval(), memory, embeddings) + result = evaluate_reader( + model, + inputs, + keys, + mappings[target_map][keys], + changed[keys], + embeddings, + spec["batch_size"], + output_dir / f"reader-{loss}-{condition}.npz", + ) + summary["readers"][loss]["endpoints"][condition] = result + insert_mlp_into_gpt(model.eval(), memories[loss]["A"], embeddings) + assert ( + tensor_hash(_state(model, non_mlp=True)) + == summary["readers"][loss]["final_non_mlp_hash"] + ) + initial_hashes = { + v["initial_hash"] for losses in summary["memories"].values() for v in losses.values() + } + summary["audits"] = { + "paired_memory_initializations": len(initial_hashes) == 1, + "paired_reader_initializations": len( + {r["initial_non_mlp_hash"] for r in summary["readers"].values()} + ) + == 1, + "paired_training_streams": len( + {r["training_stream_hash"] for r in summary["readers"].values()} + ) + == 1, + "frozen_parameters_unchanged": all( + r["frozen_hash_before"] == r["frozen_hash_after"] for r in summary["readers"].values() + ), + "future_answer_removed": inputs.shape[1] == 2 * spec["junk_len"] + 2, + "B_used_for_reader_optimization_or_selection": False, + } + assert all( + v + for k, v in summary["audits"].items() + if k != "B_used_for_reader_optimization_or_selection" + ) + summary["cost"] = { + "memory_epochs_per_mapping_objective": spec["mlp_epochs"], + "memory_fact_exposures_per_mapping_objective": spec["mlp_epochs"] * spec["num_facts"], + "reader_steps_per_objective": spec["reader_steps"], + "reader_tokens_per_objective": spec["reader_steps"] + * spec["batch_size"] + * (2 * spec["junk_len"] + 2), + "reader_supervised_positions_per_objective": spec["reader_steps"] * spec["batch_size"], + "peak_gpu_bytes": torch.cuda.max_memory_allocated(device) if device.type == "cuda" else 0, + } + summary["timing_seconds"] = { + "final_evaluation": time.perf_counter() - stage, + "whole_world": time.perf_counter() - started, + } + summary["state"] = "complete" + persist() + return summary diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_learning.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_learning.py new file mode 100644 index 0000000000000000000000000000000000000000..78155602739f614f369304edc920dbb75b590bea --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_learning.py @@ -0,0 +1,187 @@ +"""Prospective Hebbian study: numerical calibration and auditable common primitives.""" + +from __future__ import annotations + +import hashlib +import importlib.util +import json +import math +import os +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np + +ROOT = Path(__file__).resolve().parents[2] +DATA = ROOT / "data/hebbian-learning-v1" +RESULTS = ROOT / "results/hebbian-learning-v1" +ARTIFACTS = ROOT / "docs/development-artifacts/hebbian-learning-v1" +CONFIG_PATH = ROOT / "configs/hebbian-learning-v1.json" + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def sha256(path): + h = hashlib.sha256() + with Path(path).open("rb") as f: + for block in iter(lambda: f.read(4 * 1024 * 1024), b""): + h.update(block) + return h.hexdigest() + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + tmp = path.with_name(path.name + f".{os.getpid()}.tmp") + tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n") + tmp.replace(path) + + +def read_json(path): + return json.loads(Path(path).read_text()) + + +def config(): + return read_json(CONFIG_PATH) + + +def first_crossing(values, threshold): + indices = np.flatnonzero(values <= threshold) + return int(indices[0]) if len(indices) else None + + +def mode_prediction(rho, lr, steps, initial): + factors = np.array([1 - lr * (1 + rho), 1 - lr * (1 - rho)]) + if not np.all((factors > 0) & (factors < 1)): + raise ValueError("The declared monotone discrete regime is required") + return factors[None, :, None] ** np.arange(steps + 1)[:, None, None] * initial + + +def calibration_trajectory(phi, steps, lr, output_dim, checkpoint_nodes): + """Actual matrix SGD, compared against an independently computed recurrence.""" + phi = np.asarray(phi, dtype=np.float64) + rho = float(phi[:, 0] @ phi[:, 1]) + targets = np.eye(output_dim, 2, dtype=np.float64) + weight = np.zeros((output_dim, phi.shape[0]), dtype=np.float64) + modes = np.empty((steps + 1, 2, output_dim), dtype=np.float64) + checkpoints = {} + for step in range(steps + 1): + error = weight @ phi - targets + modes[step, 0] = (error[:, 0] + error[:, 1]) / math.sqrt(2) + modes[step, 1] = (error[:, 0] - error[:, 1]) / math.sqrt(2) + if step in checkpoint_nodes: + checkpoints[str(step)] = weight.copy() + if step < steps: + weight -= lr * (error @ phi.T) + predicted = mode_prediction(rho, lr, steps, modes[0]) + norms = np.linalg.norm(modes, axis=2) + predicted_norms = np.linalg.norm(predicted, axis=2) + vector_errors = np.linalg.norm(modes - predicted, axis=2) + eligible = predicted_norms > norms[0] * 1e-6 + max_relative = float(np.max(vector_errors[eligible] / predicted_norms[eligible])) + small_absolute = float(np.max(vector_errors[~eligible])) if (~eligible).any() else 0.0 + crossings = [] + for i, name in enumerate(["common", "difference"]): + for epsilon in [0.1, 0.01]: + factor = 1 - lr * (1 + rho if i == 0 else 1 - rho) + predicted_step = math.ceil(math.log(epsilon) / math.log(factor)) + observed = first_crossing(norms[:, i], epsilon * norms[0, i]) + crossings.append( + { + "mode": name, + "epsilon": epsilon, + "predicted_step": predicted_step, + "observed_step": observed, + "right_censored": observed is None, + "pass": (observed is None and predicted_step > steps) + or (observed is not None and abs(observed - predicted_step) <= 1), + } + ) + summary = { + "rho": rho, + "max_relative_vector_error": max_relative, + "small_error_max_absolute": small_absolute, + "crossings": crossings, + "pass": max_relative <= 1e-7 and all(x["pass"] for x in crossings), + } + return summary, norms, predicted_norms, checkpoints + + +def calibrate(): + import torch + + cfg = config()["A"] + out = RESULTS / "A" + out.mkdir(parents=True, exist_ok=True) + source = DATA / "source/hebbian-mlps/src/hebbian/methods/hebbian/model.py" + spec = importlib.util.spec_from_file_location("locked_hebbian_model", source) + author = importlib.util.module_from_spec(spec) + spec.loader.exec_module(author) + summaries = [] + for kind in ["exact", "bilinear"]: + for seed in cfg["seeds"]: + for rho in cfg["rho"]: + width = cfg["exact_width"] if kind == "exact" else cfg["input_dim"] + rng = np.random.default_rng(seed) + rotation = np.linalg.qr(rng.normal(size=(width, width)))[0] + inputs = rotation[:, :2] @ np.array([[1, rho], [0, np.sqrt(1 - rho**2)]]) + if kind == "bilinear": + gen = torch.Generator().manual_seed(seed) + a0 = torch.randn( + cfg["bilinear_width"], width, generator=gen, dtype=torch.float64 + ) + a1 = torch.randn( + cfg["bilinear_width"], width, generator=gen, dtype=torch.float64 + ) + feature_map = author.BilinearFeatureMap(a0, a1, normalize=True) + raw_phi = feature_map(torch.from_numpy(inputs.T)).numpy().T + else: + raw_phi = inputs + phi = raw_phi / np.linalg.norm(raw_phi, axis=0) + summary, norms, prediction, weights = calibration_trajectory( + phi, cfg["steps"], cfg["lr"], cfg["output_dim"], cfg["checkpoints"] + ) + run_id = f"{kind}-s{seed}-rho{rho}" + summary.update( + run_id=run_id, + kind=kind, + seed=seed, + input_rho=rho, + raw_gram=(raw_phi.T @ raw_phi).tolist(), + unit_gram=(phi.T @ phi).tolist(), + ) + np.savez_compressed( + out / f"{run_id}.npz", + norms=norms, + prediction=prediction, + phi=phi, + **{f"weight_{k}": v for k, v in weights.items()}, + ) + summaries.append(summary) + print(run_id, summary["max_relative_vector_error"], summary["pass"], flush=True) + audit = { + "completed_at": now(), + "config_sha256": sha256(CONFIG_PATH), + "implementation_sha256": sha256(__file__), + "author_file_sha256": sha256(source), + "runs": summaries, + "pass": all(x["pass"] for x in summaries), + } + write_json(ARTIFACTS / "A/audit.json", audit) + if not audit["pass"]: + raise RuntimeError("Stage A failed numerical acceptance") + return audit + + +def q_auc(values, nodes): + values, nodes = np.asarray(values), np.asarray(nodes) + integrate = np.trapezoid if hasattr(np, "trapezoid") else np.trapz + return integrate(values, nodes, axis=0) / nodes[-1] + + +def effective_rank(features): + z = features / np.maximum(np.linalg.norm(features, axis=1, keepdims=True), 1e-8) + gram = z @ z.T + return float(np.trace(gram) ** 2 / np.square(gram).sum()) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_model.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_model.py new file mode 100644 index 0000000000000000000000000000000000000000..9c8e5da864f18f673c829d8b68db641d728ca437 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_model.py @@ -0,0 +1,339 @@ +"""FP32 Qwen adapter. All CE/KL reductions preserve per-sequence weighting.""" + +from __future__ import annotations + +import copy +import hashlib +import os +import time + +import numpy as np +import torch +import torch.nn.functional as F +from transformers import AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList + +from .hebbian_data import TEMPLATE, score_answer +from .hebbian_learning import ARTIFACTS, DATA, config, now, read_json, write_json + + +def tensor_hash(tensor): + return hashlib.sha256(tensor.detach().cpu().contiguous().numpy().tobytes()).hexdigest() + + +def state_hashes(model): + return {name: tensor_hash(p) for name, p in model.state_dict().items()} + + +def aggregate_hash(hashes): + return hashlib.sha256( + "\n".join(f"{k}:{v}" for k, v in sorted(hashes.items())).encode() + ).hexdigest() + + +def set_determinism(seed=0): + os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8") + torch.set_num_threads(4) + torch.manual_seed(seed) + np.random.seed(seed) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.backends.cudnn.benchmark = False + torch.use_deterministic_algorithms(True) + + +class QwenExperiment: + def __init__(self, device="cuda:3"): + set_determinism() + self.cfg = config() + self.device = torch.device(device) + source = DATA / "source/qwen3-0.6b-base" + self.tokenizer = AutoTokenizer.from_pretrained(source, local_files_only=True) + self.tokenizer.pad_token = self.tokenizer.eos_token + self.model = ( + AutoModelForCausalLM.from_pretrained( + source, + local_files_only=True, + torch_dtype=torch.float32, + attn_implementation=self.cfg["model"]["attention"], + ) + .to(self.device) + .eval() + ) + self.model.requires_grad_(False) + self.layer = self.model.model.layers[self.cfg["model"]["layer"]] + self.mlp = self.layer.mlp + assert self.mlp.down_proj.weight.shape == (1024, 3072) + assert self.mlp.up_proj.weight.numel() + self.mlp.gate_proj.weight.numel() == 6291456 + self.base_local = {n: p.detach().clone() for n, p in self.mlp.named_parameters()} + self.reference = None + + def restore_base(self): + with torch.no_grad(): + for n, p in self.mlp.named_parameters(): + p.copy_(self.base_local[n]) + + def configure_trainable(self, phase): + self.model.requires_grad_(False) + names = ["down_proj.weight"] if phase == "adapt" else ["up_proj.weight", "gate_proj.weight"] + for name, p in self.mlp.named_parameters(): + p.requires_grad_(name in names) + return [p for p in self.model.parameters() if p.requires_grad] + + def make_reference(self): + self.reference = copy.deepcopy(self.model).eval().requires_grad_(False) + + def rows(self, records, views=(0,)): + return [(r, v, r["encoded"][v]) for r in records for v in views] + + def batch(self, encoded, prompt_only=False): + sequences = [ + x["input_ids"][: x["answer_start"]] if prompt_only else x["input_ids"] for x in encoded + ] + width = max(map(len, sequences)) + ids = torch.full( + (len(sequences), width), + self.tokenizer.pad_token_id, + dtype=torch.long, + device=self.device, + ) + attention = torch.zeros_like(ids) + answer = torch.zeros_like(ids, dtype=torch.bool) + for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)): + ids[i, : len(seq)] = torch.tensor(seq, device=self.device) + attention[i, : len(seq)] = 1 + if not prompt_only: + answer[i, : len(seq)] = torch.tensor(enc["loss_mask"], device=self.device).bool() + return ids, attention, answer + + def hidden(self, ids, attention, model=None): + return ( + (model or self.model) + .model(input_ids=ids, attention_mask=attention, use_cache=False) + .last_hidden_state + ) + + def ce(self, encoded, model=None): + ids, attention, mask = self.batch(encoded) + hidden = self.hidden(ids, attention, model) + b, t = torch.where(mask[:, 1:]) + logits = (model or self.model).lm_head(hidden[b, t]) + losses = F.cross_entropy(logits, ids[b, t + 1], reduction="none") + sums = torch.zeros(len(encoded), device=self.device).scatter_add_(0, b, losses) + counts = torch.bincount(b, minlength=len(encoded)) + return sums / counts + + def kl(self, encoded): + if self.reference is None: + raise RuntimeError("An episode-specific parent reference is required") + ids, attention, mask = self.batch(encoded) + b, t = torch.where(mask[:, 1:]) + with torch.no_grad(): + ref_hidden = self.hidden(ids, attention, self.reference) + ref_log = F.log_softmax(self.reference.lm_head(ref_hidden[b, t]), dim=-1) + logits = self.model.lm_head(self.hidden(ids, attention)[b, t]) + losses = F.kl_div( + F.log_softmax(logits, dim=-1), ref_log, reduction="none", log_target=True + ).sum(-1) + sums = torch.zeros(len(encoded), device=self.device).scatter_add_(0, b, losses) + return sums / torch.bincount(b, minlength=len(encoded)) + + def features(self, encoded, detach=True): + captured = {} + + def capture(module, args): + captured["phi"] = args[0] + + def capture_input(module, args): + captured["x"] = args[0] + + handle = self.mlp.down_proj.register_forward_pre_hook(capture) + input_handle = self.mlp.register_forward_pre_hook(capture_input) + try: + ids, attention, _ = self.batch(encoded, prompt_only=True) + if detach: + with torch.no_grad(): + hidden = self.hidden(ids, attention) + positions = attention.sum(1) - 1 + self.last_prompt_logits = self.model.lm_head( + hidden[torch.arange(len(encoded), device=self.device), positions] + ).detach() + x = captured["x"][torch.arange(len(encoded), device=self.device), positions] + self.last_layer_inputs = x.detach() + self.original_features = ( + F.linear(x, self.base_local["up_proj.weight"]) + * F.silu(F.linear(x, self.base_local["gate_proj.weight"])) + ).detach() + else: + self.hidden(ids, attention) + phi = captured["phi"][ + torch.arange(len(encoded), device=self.device), attention.sum(1) - 1 + ] + return phi.detach() if detach else phi + finally: + handle.remove() + input_handle.remove() + + @torch.no_grad() + def generate(self, prompts, max_new_tokens=24): + # Left-padding generation; positions are computed from the attention mask. + self.tokenizer.padding_side = "left" + inputs = self.tokenizer( + prompts, padding=True, return_tensors="pt", add_special_tokens=False + ).to(self.device) + prompt_width = inputs.input_ids.shape[1] + tokenizer = self.tokenizer + + class StopAtNewline(StoppingCriteria): + def __call__(self, input_ids, scores, **kwargs): + texts = tokenizer.batch_decode( + input_ids[:, prompt_width:], skip_special_tokens=True + ) + return torch.tensor(["\n" in text for text in texts], device=input_ids.device) + + output = self.model.generate( + **inputs, + do_sample=False, + max_new_tokens=max_new_tokens, + pad_token_id=self.tokenizer.pad_token_id, + eos_token_id=self.tokenizer.eos_token_id, + use_cache=True, + logits_to_keep=1, + stopping_criteria=StoppingCriteriaList([StopAtNewline()]), + ) + tail = output[:, inputs.input_ids.shape[1] :] + predictions = self.tokenizer.batch_decode(tail, skip_special_tokens=True) + # Padding after a newline stop is not evidence of the model emitting EOS. + eos_emitted = [] + for row in tail: + emitted = False + for length, token in enumerate(row, 1): + if int(token) == self.tokenizer.eos_token_id: + emitted = True + break + if "\n" in self.tokenizer.decode(row[:length], skip_special_tokens=True): + break + eos_emitted.append(emitted) + return predictions, eos_emitted + + @torch.no_grad() + def evaluate(self, records, views=(0, 1, 2), batch_size=24): + rows = self.rows(records, views) + result = [] + for start in range(0, len(rows), batch_size): + chunk = rows[start : start + batch_size] + encoded = [x[2] for x in chunk] + losses = self.ce(encoded).tolist() + predictions, eos = self.generate([TEMPLATE.format(r["views"][v]) for r, v, _ in chunk]) + phi = self.features(encoded) + for i, (r, v, enc) in enumerate(chunk): + prediction = predictions[i] + first_token = enc["input_ids"][enc["answer_start"]] + logits = self.last_prompt_logits[i] + competitor_logits = logits.clone() + competitor_logits[first_token] = -torch.inf + competitor = int(competitor_logits.argmax()) + result.append( + { + "case_id": r["case_id"], + "relation_id": r["relation_id"], + "subject_group": r["subject_group"], + "view_id": v, + "answer_nll": losses[i], + "prediction": prediction, + "answer_em": score_answer(prediction, r.get("aliases", [r["answer"]])), + "eos_emitted": eos[i], + "feature_norm": float(phi[i].norm()), + "first_answer_nll": float(-logits.log_softmax(-1)[first_token]), + "first_answer_margin": float(logits[first_token] - logits[competitor]), + "current_competitor_token": competitor, + "answer_tokens": enc["answer_tokens"], + "prompt_tokens": enc["prompt_tokens"], + } + ) + return result + + def gradient(self, encoded): + loss = self.ce([encoded]).mean() + grad = torch.autograd.grad(loss, self.mlp.down_proj.weight)[0] + return grad.detach(), float(loss.detach()) + + def verify_hooks_and_gradients(self, encoded): + self.configure_trainable("adapt") + captured = {} + + def capture_input(module, args): + captured["x"] = args[0].detach() + + def capture_down(module, args, output): + captured["phi"] = args[0].detach() + output.retain_grad() + captured["output"] = output + + handles = [ + self.mlp.register_forward_pre_hook(capture_input), + self.mlp.down_proj.register_forward_hook(capture_down), + ] + try: + self.model.zero_grad(set_to_none=True) + self.ce([encoded]).mean().backward() + with torch.no_grad(): + expected_phi = self.mlp.up_proj(captured["x"]) * F.silu( + self.mlp.gate_proj(captured["x"]) + ) + phi_error = float((expected_phi - captured["phi"]).abs().max()) + delta = captured["output"].grad.double().flatten(0, 1) + phi = captured["phi"].double().flatten(0, 1) + reconstructed = delta.T @ phi + actual = self.mlp.down_proj.weight.grad.double() + grad_error = float((reconstructed - actual).norm() / actual.norm()) + nonanswer_positions = encoded["answer_start"] - 1 + prompt_grad_norm = float(delta[:nonanswer_positions].norm()) + assert phi_error == 0.0 + assert grad_error < 1e-5 + return { + "phi_max_absolute_error": phi_error, + "gradient_relative_error": grad_error, + "earlier_prompt_delta_norm": prompt_grad_norm, + "all_positions_used": True, + "trainable_parameters": sum( + p.numel() for p in self.model.parameters() if p.requires_grad + ), + "pass": True, + } + finally: + for handle in handles: + handle.remove() + self.model.zero_grad(set_to_none=True) + + +def run_baseline(device, shard=0, shards=1): + engine = QwenExperiment(device) + candidates = read_json(DATA / "candidates.json")[shard::shards] + out = DATA / f"baseline-shard-{shard}.jsonl" + finished = {} + if out.exists(): + for line in out.read_text().splitlines(): + row = __import__("json").loads(line) + finished[row["case_id"]] = row + candidates = [r for r in candidates if r["case_id"] not in finished] + start_time = time.monotonic() + for start in range(0, len(candidates), 8): + chunk = candidates[start : start + 8] + rows = engine.evaluate(chunk) + with out.open("a") as f: + for record in chunk: + item = { + "case_id": record["case_id"], + "views": [r for r in rows if r["case_id"] == record["case_id"]], + } + f.write(__import__("json").dumps(item, ensure_ascii=False) + "\n") + if start % 80 == 0: + print( + f"baseline shard={shard} {start + len(chunk)}/{len(candidates)} " + f"elapsed={time.monotonic() - start_time:.1f}s", + flush=True, + ) + write_json( + ARTIFACTS / f"baseline-shard-{shard}-complete.json", + {"time": now(), "rows": len(candidates) + len(finished), "shards": shards}, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_statistics.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_statistics.py new file mode 100644 index 0000000000000000000000000000000000000000..52bcc965886f86bf20041ec40ce6aa95b96a725f --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_statistics.py @@ -0,0 +1,168 @@ +"""Development-only predictor fitting and episode-cluster paired inference.""" + +from __future__ import annotations + +import itertools + +import numpy as np + +from .hebbian_learning import ( + ARTIFACTS, + DATA, + RESULTS, + config, + now, + q_auc, + read_json, + sha256, + write_json, +) + + +def fit_ridge(x, y, alpha): + mean, scale = x.mean(0), x.std(0) + scale = np.where(scale > 1e-12, scale, 1) + z = (x - mean) / scale + intercept = float(y.mean()) + coef = np.linalg.solve(z.T @ z + alpha * np.eye(z.shape[1]), z.T @ (y - intercept)) + return { + "mean": mean.tolist(), + "scale": scale.tolist(), + "coefficients": coef.tolist(), + "intercept": intercept, + "alpha": alpha, + "n_features": x.shape[1], + } + + +def predict(model, x): + x = x[:, : model["n_features"]] + return ((x - model["mean"]) / model["scale"]) @ np.array(model["coefficients"]) + model[ + "intercept" + ] + + +def fact_trajectories(path): + evaluations = [read_json(p) for p in sorted(path.glob("evaluation-*.json"))] + nodes = [e["rows"][0]["step"] for e in evaluations] + by_node = [{(r["case_id"], r["view_id"]): r for r in e["rows"]} for e in evaluations] + cases = sorted({r["case_id"] for r in evaluations[0]["rows"]}) + result = [] + for case in cases: + rewrite = [np.mean([rows[case, v]["answer_em"] for v in [1, 2]]) for rows in by_node] + standard = [rows[case, 0]["answer_em"] for rows in by_node] + all_correct = [all(rows[case, v]["answer_em"] for v in range(3)) for rows in by_node] + sustained = next( + (i for i in range(len(nodes) - 1) if all_correct[i] and all_correct[i + 1]), None + ) + first = by_node[0][case, 0] + result.append( + { + "case_id": case, + "q_auc": float(q_auc(rewrite, nodes)), + "q_gain_auc": float(q_auc(np.array(rewrite) - rewrite[0], nodes)), + "standard_auc": float(q_auc(standard, nodes)), + "nodes": nodes, + "rewrite_accuracy": rewrite, + "standard_accuracy": standard, + "sustained_step": nodes[sustained] if sustained is not None else None, + "sustained_exposures": by_node[sustained][case, 0]["exposures"] + if sustained is not None + else None, + "endpoint_first_success": sustained is None and all_correct[-1], + "right_censored": sustained is None, + "relation_id": first["relation_id"], + } + ) + return result + + +def freeze_b(): + from .hebbian_train import frozen_training_sources, run_summary, select_config + + episodes = read_json(DATA / "episodes.json")["B_dev"] + candidates = [] + for lr in config()["adapt"]["learning_rates"]: + summaries = [run_summary(RESULTS / f"B/dev-lr{lr:g}-e{i}") for i in range(len(episodes))] + candidates.append( + { + "learning_rate": lr, + "q_auc": float(np.mean([s["q_auc"] for s in summaries])), + "keep_damage": float(np.mean([s["keep_damage"] for s in summaries])), + "episodes": summaries, + } + ) + chosen = select_config(candidates, "q_auc", True) + lr = chosen["learning_rate"] + x, y, groups = [], [], [] + for episode in range(len(episodes)): + path = RESULTS / f"B/dev-lr{lr:g}-e{episode}" + if not (path / "complete.json").exists(): + raise RuntimeError("All B_dev runs must have completion receipts") + outcomes = {r["case_id"]: r["q_auc"] for r in fact_trajectories(path)} + for row in read_json(path / "prospective-features.json")["rows"]: + x.append(row["features"]) + y.append(outcomes[row["case_id"]]) + groups.append(episode) + x, y, groups = np.array(x), np.array(y), np.array(groups) + predictors = {} + for name, width in [("P0", 4), ("P1", 8), ("P2", 10)]: + scores = {} + for alpha in config()["statistics"]["ridge_grid"]: + errors = [] + for group in np.unique(groups): + train = groups != group + model = fit_ridge(x[train, :width], y[train], alpha) + errors.append(np.mean(np.abs(predict(model, x[~train]) - y[~train]))) + scores[alpha] = float(np.mean(errors)) + best_alpha = min(scores, key=scores.get) + predictors[name] = {**fit_ridge(x[:, :width], y, best_alpha), "cv_mae": scores} + write_json( + ARTIFACTS / "B-lock.json", + { + "time": now(), + "status": "locked", + "learning_rate": lr, + "lr_candidates": candidates, + "predictors": predictors, + "source_hashes": frozen_training_sources(), + "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"), + "fitting_scope": "B_dev only; fold-specific training standardization in episode CV", + }, + ) + + +def paired_inference(differences): + differences = np.asarray(differences, dtype=np.float64) + rng = np.random.default_rng(config()["statistics"]["seed"]) + n = len(differences) + samples = differences[rng.integers(0, n, (10000, n))].mean(1) + observed = float(differences.mean()) + signs = np.array(list(itertools.product([-1, 1], repeat=n))) + p = float(np.mean(np.abs((signs * differences).mean(1)) >= abs(observed) - 1e-14)) + return { + "mean": observed, + "ci95": np.quantile(samples, [0.025, 0.975]).tolist(), + "exact_two_sided_sign_p": p, + "episode_differences": differences.tolist(), + "n_episodes": n, + } + + +def rankdata(values): + values = np.asarray(values) + order = np.argsort(values, kind="stable") + ranked = np.empty(len(values), dtype=float) + i = 0 + while i < len(values): + j = i + 1 + while j < len(values) and values[order[j]] == values[order[i]]: + j += 1 + ranked[order[i:j]] = (i + j - 1) / 2 + i = j + return ranked + + +def spearman(x, y): + a, b = rankdata(x), rankdata(y) + return float(np.corrcoef(a, b)[0, 1]) if a.std() and b.std() else None diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_train.py new file mode 100644 index 0000000000000000000000000000000000000000..f70905fa1648aeba1d7bad8aca55a77bbcadd72f --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/hebbian_train.py @@ -0,0 +1,811 @@ +"""Paired formation/adaptation, prospective diagnostics and exact state resumption.""" + +from __future__ import annotations + +import itertools +import json +import random +import time + +import numpy as np +import torch +import torch.nn.functional as F + +from .hebbian_learning import ( + ARTIFACTS, + CONFIG_PATH, + DATA, + RESULTS, + ROOT, + config, + effective_rank, + now, + q_auc, + read_json, + sha256, + write_json, +) +from .hebbian_model import ( + QwenExperiment, + aggregate_hash, + set_determinism, + state_hashes, +) + + +def grouping(records, seed): + """Exact minimum-cost derangements; random seeded ties, real CE labels unchanged.""" + n = len(records) + rng = np.random.default_rng(seed) + permutations = [ + p for p in itertools.permutations(range(n)) if all(i != j for i, j in enumerate(p)) + ] + + def cost(p): + return sum( + 10 * (records[i]["target_id"] == records[j]["target_id"]) + + (records[i]["relation_id"] != records[j]["relation_id"]) + for i, j in enumerate(p) + ) + + costs = np.array([cost(p) for p in permutations]) + best = np.flatnonzero(costs == costs.min()) + p1, p2 = [permutations[int(rng.choice(best))] for _ in range(2)] + groups = [(3 * i, 3 * p1[i] + 1, 3 * p2[i] + 2) for i in range(n)] + return groups + + +def contrastive_loss(features, target_ids, groups, tau=0.1): + z = F.normalize(features, dim=-1, eps=1e-8) + similarities = z @ z.T / tau + positive = torch.zeros_like(similarities, dtype=torch.bool) + for group in groups: + for i in group: + for j in group: + if i != j: + positive[i, j] = True + negative = torch.tensor([[a != b for b in target_ids] for a in target_ids], device=z.device) + negative &= ~positive + negative.fill_diagonal_(False) + assert torch.all(positive.sum(1) == 2) + assert torch.all(negative.sum(1) >= 1) + allowed = positive | negative + log_denominator = similarities.masked_fill(~allowed, -torch.inf).logsumexp(1) + loss = (log_denominator - (similarities * positive).sum(1) / positive.sum(1)).mean() + return loss, {"positive_pairs": int(positive.sum()), "negative_pairs": int(negative.sum())} + + +def optimizer(parameters, lr): + cfg = config()["optimizer"] + return torch.optim.AdamW( + parameters, + lr=lr, + betas=tuple(cfg["betas"]), + eps=cfg["eps"], + weight_decay=cfg["weight_decay"], + ) + + +def replay_batch(pools, texts, step): + facts = pools["R_keep"] + return [facts[(step * 6 + i) % len(facts)]["encoded"][0] for i in range(6)] + [ + texts["train"][(step * 2 + i) % len(texts["train"])] for i in range(2) + ] + + +def frozen_training_sources(): + paths = [CONFIG_PATH] + sorted((ROOT / "src/llm_memory_editability").glob("hebbian*.py")) + paths += [ROOT / "scripts/run_hebbian_learning.py"] + return {str(p.relative_to(ROOT)): sha256(p) for p in paths} + + +def save_checkpoint(path, engine, opt, step, meta, ledger): + state = { + "parameters": {n: p.detach().cpu().clone() for n, p in engine.mlp.named_parameters()}, + "optimizer": opt.state_dict(), + "step": step, + "data_cursor": step, + "torch_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(engine.device) + if engine.device.type == "cuda" + else None, + "numpy_rng": np.random.get_state(), + "python_rng": random.getstate(), + "meta": meta, + "ledger": ledger, + } + tmp = path.with_name(path.name + ".tmp") + torch.save(state, tmp) + tmp.replace(path) + + +def restore_checkpoint(path, engine, opt, meta): + state = torch.load(path, map_location="cpu", weights_only=False) + if state["meta"] != meta: + raise RuntimeError(f"Checkpoint contract differs: {path}") + with torch.no_grad(): + for n, p in engine.mlp.named_parameters(): + p.copy_(state["parameters"][n]) + opt.load_state_dict(state["optimizer"]) + torch.set_rng_state(state["torch_rng"]) + if state["cuda_rng"] is not None: + torch.cuda.set_rng_state(state["cuda_rng"], engine.device) + np.random.set_state(state["numpy_rng"]) + random.setstate(state["python_rng"]) + return state["step"], state["ledger"] + + +def load_parent(engine, parent_path=None): + engine.restore_base() + if parent_path is not None: + state = torch.load(parent_path, map_location="cpu", weights_only=False) + with torch.no_grad(): + for n, p in engine.mlp.named_parameters(): + p.copy_(state["parameters"][n]) + + +def gradient_cos(a, b): + a, b = a.double(), b.double() + return float((a * b).sum() / (a.norm() * b.norm()).clamp_min(1e-30)) + + +def diagnose_episode(engine, records, replay, lr, out): + """Saved before the learning trajectory; Adam candidate uses training data only.""" + engine.configure_trainable("adapt") + p = engine.mlp.down_proj.weight + original = p.detach().clone() + encoded = [r["encoded"][v] for r in records for v in range(3)] + features = engine.features(encoded).double().cpu().numpy().reshape(len(records), 3, -1) + unit = features / np.maximum(np.linalg.norm(features, axis=-1, keepdims=True), 1e-8) + p0_gram = unit[:, 0] @ unit[:, 0].T + rank = effective_rank(features[:, 0]) + opt = optimizer([p], lr) + opt.zero_grad(set_to_none=True) + (engine.ce([r["encoded"][0] for r in records[:8]]).mean() + engine.kl(replay).mean()).backward() + torch.nn.utils.clip_grad_norm_([p], 1.0) + opt.step() + delta = (p.detach() - original).clone() + with torch.no_grad(): + p.copy_(original) + torch.save( + {"delta_B": delta.cpu(), "phi": torch.from_numpy(features)}, out / "initial-diagnostics.pt" + ) + diagnostic = [] + for i, record in enumerate(records): + grads, losses = zip(*(engine.gradient(enc) for enc in record["encoded"]), strict=True) + other = [ + p0_gram[i, j] for j, r in enumerate(records) if r["target_id"] != record["target_id"] + ] + if not other: + raise ValueError("Each episode needs different-answer facts") + norms = np.linalg.norm(features[i], axis=1) + feature_values = [ + losses[0], + record["encoded"][0]["answer_tokens"], + record["encoded"][0]["prompt_tokens"], + float(grads[0].double().norm()), + float(np.mean(unit[i, 1:] @ unit[i, 0])), + float(max(other)), + float(norms[1:].mean() / norms[0]), + rank, + float(np.mean([gradient_cos(grads[0], g) for g in grads[1:]])), + float(np.mean([float((g.double() * delta.double()).sum()) for g in grads[1:]])), + ] + diagnostic.append( + { + "case_id": record["case_id"], + "features": feature_values, + "p0_p1_cos": float(unit[i, 0] @ unit[i, 1]), + "p0_p2_cos": float(unit[i, 0] @ unit[i, 2]), + "feature_norms": norms.tolist(), + "initial_nll": list(losses), + } + ) + engine.model.zero_grad(set_to_none=True) + assert torch.equal(p, original) + write_json( + out / "prospective-features.json", + { + "saved_at": now(), + "rows": diagnostic, + "information": { + "P0": "initial answer NLL, lengths, labeled training gradient norm", + "P1": "P0 plus prompt-only phi geometry", + "P2": "P1 plus labeled evaluation gradients and training-only Adam candidate", + }, + }, + ) + return diagnostic + + +def first_order_calibration(engine, record, out): + parameter = engine.mlp.down_proj.weight + initial = parameter.detach().clone() + source_grad, _ = engine.gradient(record["encoded"][0]) + rows = [] + for view in [1, 2]: + encoded = record["encoded"][view] + grad, nll0 = engine.gradient(encoded) + ids, attention, _ = engine.batch([encoded], prompt_only=True) + answer_token = encoded["input_ids"][encoded["answer_start"]] + logits = engine.model.lm_head(engine.hidden(ids, attention)[0, -1]) + competitor_logits = logits.detach().clone() + competitor_logits[answer_token] = -torch.inf + competitor = int(competitor_logits.argmax()) + margin = logits[answer_token] - logits[competitor] + margin_grad = torch.autograd.grad(margin, parameter)[0].detach() + margin0 = float(margin.detach()) + for relative_step in [1e-5, 1e-4]: + proposal = ( + -source_grad + * (relative_step * initial.double().norm() / source_grad.double().norm()).float() + ) + with torch.no_grad(): + parameter.copy_(initial + proposal) + actual_delta = parameter - initial + actual_nll = float(engine.ce([encoded])[0]) - nll0 + new_logits = engine.model.lm_head(engine.hidden(ids, attention)[0, -1]) + actual_margin = float(new_logits[answer_token] - new_logits[competitor]) - margin0 + predicted_nll = float((grad.double() * actual_delta.double()).sum()) + predicted_margin = float((margin_grad.double() * actual_delta.double()).sum()) + parameter.copy_(initial) + entry = { + "case_id": record["case_id"], + "view_id": view, + "relative_step": relative_step, + "competitor_token": competitor, + "actual_nll_change": actual_nll, + "predicted_nll_change": predicted_nll, + "actual_margin_change": actual_margin, + "predicted_margin_change": predicted_margin, + } + for name, actual, predicted in [ + ("nll", actual_nll, predicted_nll), + ("margin", actual_margin, predicted_margin), + ]: + entry[name + "_absolute_error"] = abs(actual - predicted) + entry[name + "_relative_error"] = abs(actual - predicted) / max( + abs(predicted), 1e-6 + ) + entry[name + "_sign_match"] = bool(np.sign(actual) == np.sign(predicted)) + rows.append(entry) + assert torch.equal(parameter, initial) + write_json(out / "first-order-calibration.json", rows) + + +def geometry_rows(engine, records): + encoded = [r["encoded"][v] for r in records for v in range(3)] + features, originals = [], [] + for start in range(0, len(encoded), 24): + features.append(engine.features(encoded[start : start + 24]).double().cpu()) + originals.append(engine.original_features.double().cpu()) + phi = torch.cat(features).reshape(len(records), 3, -1) + unit = F.normalize(phi, dim=-1) + original = torch.cat(originals).reshape(len(records), 3, -1) + original_cos = (unit * F.normalize(original, dim=-1)).sum(-1) + gram = unit[:, 0] @ unit[:, 0].T + rank = float(gram.trace().square() / gram.square().sum()) + result = {} + for i, r in enumerate(records): + others = [ + float(gram[i, j]) + for j, other in enumerate(records) + if other["target_id"] != r["target_id"] + ] + result[r["case_id"]] = { + "same_fact_cos": float((unit[i, 1:] @ unit[i, 0]).mean()), + "other_fact_cos": max(others) if others else None, + "effective_rank": rank, + "cosine_to_original_phi": float(original_cos[i].mean()), + "dimension_variance": float(phi[:, 0].var(0, unbiased=False).mean()), + } + return result + + +def evaluate_node(engine, records, keep, texts, step, metadata, out, exposures, full_keep): + rows = engine.evaluate(records) + geometry = geometry_rows(engine, records) + for row in rows: + row.update( + metadata, + step=step, + exposures=exposures.get(row["case_id"], 0), + **geometry[row["case_id"]], + ) + payload = {"rows": rows} + if full_keep: + payload["keep"] = engine.evaluate(keep, views=(0,)) + with torch.no_grad(): + text_losses = [] + for i in range(0, len(texts["test"]), 8): + text_losses.extend(engine.ce(texts["test"][i : i + 8]).tolist()) + payload["text_nll"] = float(np.mean(text_losses)) + payload["text_ppl"] = float(np.exp(payload["text_nll"])) + write_json(out / f"evaluation-{step:04d}.json", payload) + return payload + + +def train_run( + engine, + phase, + records, + pools, + texts, + condition, + seed, + episode_id, + split, + lr, + steps, + run_id, + lambda_geo=0.0, + parent_path=None, + diagnostics=False, +): + cfg = config() + out = RESULTS / run_id + out.mkdir(parents=True, exist_ok=True) + load_parent(engine, parent_path) + parent_hashes = state_hashes(engine.model) + parent_hash = aggregate_hash(parent_hashes) + parameters = engine.configure_trainable(phase) + trainable = [n for n, p in engine.model.named_parameters() if p.requires_grad] + meta = { + "phase": phase, + "split": split, + "condition": condition, + "seed": seed, + "episode_id": episode_id, + "parent_hash": parent_hash, + "parent_path": str(parent_path) if parent_path else None, + "source_hashes": frozen_training_sources(), + "config_sha256": sha256(CONFIG_PATH), + "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"), + "trainable_names": trainable, + "lr": lr, + "lambda_geo": lambda_geo, + "steps": steps, + "case_ids": [r["case_id"] for r in records], + } + if (out / "complete.json").exists(): + receipt = read_json(out / "complete.json") + if receipt["meta"] != meta: + raise RuntimeError(f"Completed run contract changed: {run_id}") + return receipt + engine.make_reference() + set_determinism(seed) + random.seed(seed) + opt = optimizer(parameters, lr) + write_json(out / "contract.json", meta) + ledger = { + "answer_tokens": 0, + "answer_input_tokens": 0, + "replay_tokens": 0, + "replay_input_tokens": 0, + "geometry_input_tokens": 0, + "forward_sequences": 0, + "backward_sequences": 0, + "optimizer_steps": 0, + "wall_seconds": 0.0, + } + nodes = [n for n in cfg["form" if phase == "form" else "adapt"]["nodes"] if n <= steps] + if steps not in nodes: + nodes.append(steps) + keep = pools["V_keep" if split == "dev" else "U_keep"] + evaluate_records = pools["V_form"] if phase == "form" and split == "dev" else records + rng = np.random.default_rng(seed) + order = rng.permutation(len(records)).tolist() if phase == "form" else list(range(len(records))) + exposures = {r["case_id"]: 0 for r in records} + batch_table = [] + for step in range(steps): + batch = [records[order[(step * 8 + i) % len(order)]] for i in range(8)] + groups = ( + grouping(batch, seed * 100000 + step) + if condition == "C2" + else [tuple(range(3 * i, 3 * i + 3)) for i in range(8)] + ) + batch_table.append({"case_ids": [r["case_id"] for r in batch], "groups": groups}) + write_json(out / "batch-manifest.json", batch_table) + checkpoints = sorted(out.glob("checkpoint-*.pt")) + start = 0 + if checkpoints: + start, ledger = restore_checkpoint(checkpoints[-1], engine, opt, meta) + for item in batch_table[:start]: + for case_id in item["case_ids"]: + exposures[case_id] += 1 + elif diagnostics: + diagnostic = diagnose_episode(engine, records, replay_batch(pools, texts, 0), lr, out) + if split == "eval": + from .hebbian_statistics import predict + + predictors = read_json(ARTIFACTS / "B-lock.json")["predictors"] + write_json( + out / "prospective-predictions.json", + { + "saved_at": now(), + "parent_hash": parent_hash, + "predictions": [ + { + "case_id": r["case_id"], + "values": { + name: float(predict(model, np.array(r["features"])[None])[0]) + for name, model in predictors.items() + }, + } + for r in diagnostic + ], + }, + ) + first_order_calibration(engine, min(records, key=lambda r: r["case_id"]), out) + metadata = { + k: meta[k] for k in ["phase", "split", "condition", "seed", "episode_id", "parent_hash"] + } + if start == 0: + save_checkpoint(out / "checkpoint-0000.pt", engine, opt, 0, meta, ledger) + for step in range(start, steps + 1): + if step in nodes: + evaluate_node( + engine, + evaluate_records, + keep, + texts, + step, + metadata, + out, + exposures, + full_keep=(phase == "form" or step in [0, 16, 64, 128]), + ) + if phase == "adapt" and condition.startswith("C") and step in [0, 16, 128]: + gradients = [] + for r in sorted(records, key=lambda r: r["case_id"])[:4]: + grads = [engine.gradient(e)[0] for e in r["encoded"]] + gradients.append( + { + "case_id": r["case_id"], + "p0_p1_gradient_cos": gradient_cos(grads[0], grads[1]), + "p0_p2_gradient_cos": gradient_cos(grads[0], grads[2]), + } + ) + write_json(out / f"gradients-{step:04d}.json", gradients) + if step in [0, 16, 64, 128, 256]: + save_checkpoint(out / f"checkpoint-{step:04d}.pt", engine, opt, step, meta, ledger) + if step == steps: + break + batch = [records[order[(step * 8 + i) % len(order)]] for i in range(8)] + encoded = [r["encoded"][v] for r in batch for v in (range(3) if phase == "form" else [0])] + replay = replay_batch(pools, texts, step) + torch.cuda.synchronize(engine.device) + begin = time.monotonic() + opt.zero_grad(set_to_none=True) + ce = engine.ce(encoded).mean() + ce.backward() + kl = engine.kl(replay).mean() + kl.backward() + geo_value, pair_counts = 0.0, None + if phase == "form": + features = engine.features(encoded, detach=False) + targets = [r["target_id"] for r in batch for _ in range(3)] + geo, pair_counts = contrastive_loss(features, targets, batch_table[step]["groups"]) + if lambda_geo: + (lambda_geo * geo).backward() + geo_value = float(geo.detach()) + norm = torch.nn.utils.clip_grad_norm_(parameters, cfg["optimizer"]["clip"]) + opt.step() + torch.cuda.synchronize(engine.device) + ledger["wall_seconds"] += time.monotonic() - begin + ledger["answer_tokens"] += sum(sum(e["loss_mask"]) for e in encoded) + ledger["answer_input_tokens"] += sum(len(e["input_ids"]) for e in encoded) + ledger["replay_tokens"] += sum(sum(e["loss_mask"]) for e in replay) + ledger["replay_input_tokens"] += sum(len(e["input_ids"]) for e in replay) + if phase == "form": + ledger["geometry_input_tokens"] += sum(e["answer_start"] for e in encoded) + ledger["forward_sequences"] += ( + len(encoded) + 2 * len(replay) + (len(encoded) if phase == "form" else 0) + ) + ledger["backward_sequences"] += ( + len(encoded) + len(replay) + (len(encoded) if lambda_geo else 0) + ) + ledger["optimizer_steps"] += 1 + for r in batch: + exposures[r["case_id"]] += 1 + with (out / "training.jsonl").open("a") as f: + f.write( + json.dumps( + { + "step": step + 1, + "ce": float(ce.detach()), + "kl": float(kl.detach()), + "geo": geo_value, + "gradient_norm": float(norm), + "pairs": pair_counts, + } + ) + + "\n" + ) + write_json( + out / "status.json", {"step": step + 1, "steps": steps, "time": now(), "ledger": ledger} + ) + if (step + 1) % 16 == 0: + print( + run_id, + step + 1, + "ce", + float(ce.detach()), + "wall", + ledger["wall_seconds"], + flush=True, + ) + final_hashes = state_hashes(engine.model) + unchanged = all( + final_hashes[n] == digest for n, digest in parent_hashes.items() if n not in trainable + ) + assert unchanged, "A parameter outside the intervention scope changed" + receipt = { + "meta": meta, + "completed_at": now(), + "ledger": ledger, + "unchanged_outside_scope": unchanged, + "final_hashes": final_hashes, + "final_model_hash": aggregate_hash(final_hashes), + "exposures": exposures, + "trainable_parameters": sum(p.numel() for p in parameters), + "estimated_dense_full_backprop_flops_upper_bound": ( + sum(p.numel() for p in engine.model.parameters()) + * ( + 6 * ledger["answer_input_tokens"] + + 8 * ledger["replay_input_tokens"] + + (6 if lambda_geo else 2) * ledger["geometry_input_tokens"] + ) + ), + } + write_json(out / "complete.json", receipt) + return receipt + + +def run_summary(path): + evaluations = [read_json(p) for p in sorted(path.glob("evaluation-*.json"))] + nodes = [e["rows"][0]["step"] for e in evaluations] + rewrite = [ + np.mean([r["answer_em"] for r in e["rows"] if r["view_id"] in [1, 2]]) for e in evaluations + ] + keep0 = np.mean([r["answer_em"] for r in evaluations[0]["keep"]]) + keep1 = np.mean([r["answer_em"] for r in evaluations[-1]["keep"]]) + return { + "q_auc": float(q_auc(rewrite, nodes)), + "keep_damage": float(keep0 - keep1), + "answer_nll": float(np.mean([r["answer_nll"] for r in evaluations[-1]["rows"]])), + } + + +def select_config(candidates, metric, maximize): + safe = [ + r for r in candidates if r["keep_damage"] <= config()["statistics"]["keep_damage_reference"] + ] + if safe: + return sorted(safe, key=lambda r: (-1 if maximize else 1) * r[metric])[0] + return sorted( + candidates, key=lambda r: (r["keep_damage"], (-1 if maximize else 1) * r[metric]) + )[0] + + +def preflight(engine, pools, texts): + records = pools["B_dev"][:8] + audit = engine.verify_hooks_and_gradients(records[0]["encoded"][0]) + before = state_hashes(engine.model) + parameters = engine.configure_trainable("adapt") + engine.make_reference() + opt = optimizer(parameters, 1e-5) + torch.cuda.reset_peak_memory_stats(engine.device) + torch.cuda.synchronize(engine.device) + start = time.monotonic() + for step in range(3): + opt.zero_grad(set_to_none=True) + engine.ce([r["encoded"][0] for r in records]).mean().backward() + engine.kl(replay_batch(pools, texts, step)).mean().backward() + torch.nn.utils.clip_grad_norm_(parameters, 1.0) + opt.step() + torch.cuda.synchronize(engine.device) + seconds = (time.monotonic() - start) / 3 + engine.restore_base() + assert before == state_hashes(engine.model) + estimate = { + "time": now(), + "device": str(engine.device), + "adapt_step_seconds": seconds, + "peak_memory_bytes": torch.cuda.max_memory_allocated(engine.device), + "formal_adapt_steps": 11264, + "formal_adapt_gpu_hours": seconds * 11264 / 3600, + "formation_estimate_factor": 3, + "formal_formation_gpu_hours_estimate": seconds * 3 * 2304 / 3600, + "excludes": [ + "generation and NLL evaluation", + "gradient diagnostics", + "development", + "disk IO", + ], + "microbatch_answer": 8, + "microbatch_replay": 8, + "reference_parent_restored": True, + } + write_json(ARTIFACTS / "estimate.json", estimate) + write_json(ARTIFACTS / "qwen-interface-audit.json", audit) + print(estimate, flush=True) + + +def dispatch(args): + if not (ARTIFACTS / "data-lock.json").exists(): + raise RuntimeError("data-lock is required before development or evaluation") + data_lock = read_json(ARTIFACTS / "data-lock.json") + for name, digest in data_lock["files"].items(): + if sha256(DATA / name) != digest: + raise RuntimeError(f"Frozen data changed: {name}") + if not read_json(ARTIFACTS / "A/audit.json")["pass"]: + raise RuntimeError("Stage A must pass before model training") + pools = read_json(DATA / "pools.json") + texts = read_json(DATA / "text.json") + episodes = read_json(DATA / "episodes.json") + by_id = {r["case_id"]: r for rows in pools.values() for r in rows} + engine = QwenExperiment(args.device) + if args.command == "preflight": + return preflight(engine, pools, texts) + if args.command == "diagnose": + if args.split == "dev": + learning_rates = config()["adapt"]["learning_rates"] + else: + learning_rates = [read_json(ARTIFACTS / "B-lock.json")["learning_rate"]] + tasks = list(itertools.product(learning_rates, enumerate(episodes["B_" + args.split]))) + for lr, (episode, ids) in tasks[args.shard :: args.shards]: + run_id = f"B/{args.split}-lr{lr:g}-e{episode}" + train_run( + engine, + "adapt", + [by_id[i] for i in ids], + pools, + texts, + "B", + 0, + episode, + args.split, + lr, + 128, + run_id, + diagnostics=True, + ) + return + b_lr = read_json(ARTIFACTS / "B-lock.json")["learning_rate"] + if args.command == "form" and args.split == "dev": + candidates = [] + for lr in config()["form"]["learning_rates"]: + run_id = f"C/dev-C0-lr{lr:g}" + train_run( + engine, "form", pools["F_form"], pools, texts, "C0", 10, -1, "dev", lr, 256, run_id + ) + candidates.append( + {"learning_rate": lr, "run_id": run_id, **run_summary(RESULTS / run_id)} + ) + chosen = select_config(candidates, "answer_nll", False) + lr = chosen["learning_rate"] + formation_candidates = [{"condition": "C0", "lambda_geo": 0.0, **chosen}] + for lam in config()["form"]["lambdas"]: + run_id = f"C/dev-C1-lambda{lam:g}" + train_run( + engine, + "form", + pools["F_form"], + pools, + texts, + "C1", + 10, + -1, + "dev", + lr, + 256, + run_id, + lambda_geo=lam, + ) + formation_candidates.append( + { + "condition": "C1", + "lambda_geo": lam, + "run_id": run_id, + **run_summary(RESULTS / run_id), + } + ) + for item in formation_candidates: + adapt_results = [] + for episode, ids in enumerate(episodes["C_dev"]): + run_id = f"C/adapt-dev-{item['condition']}-lambda{item['lambda_geo']:g}-e{episode}" + train_run( + engine, + "adapt", + [by_id[i] for i in ids], + pools, + texts, + item["condition"], + 10, + episode, + "dev", + b_lr, + 64, + run_id, + parent_path=RESULTS / item["run_id"] / "checkpoint-0256.pt", + ) + adapt_results.append(run_summary(RESULTS / run_id)) + item["future_q_auc"] = float(np.mean([r["q_auc"] for r in adapt_results])) + item["adapt_results"] = adapt_results + best = select_config( + [r for r in formation_candidates if r["condition"] == "C1"], "future_q_auc", True + ) + lam = best["lambda_geo"] + train_run( + engine, + "form", + pools["F_form"], + pools, + texts, + "C2", + 10, + -1, + "dev", + lr, + 256, + "C/dev-C2-engineering", + lambda_geo=lam, + ) + write_json( + ARTIFACTS / "C-lock.json", + { + "time": now(), + "learning_rate": lr, + "lambda_geo": lam, + "adapt_learning_rate": b_lr, + "lr_candidates": candidates, + "formation_candidates": formation_candidates, + "source_hashes": frozen_training_sources(), + "data_lock_sha256": sha256(ARTIFACTS / "data-lock.json"), + "seeds": [0, 1, 2], + "conditions": ["C0", "C1", "C2"], + "episodes": episodes["C_eval"], + "status": "locked", + }, + ) + return + c_lock = read_json(ARTIFACTS / "C-lock.json") + if args.command == "form": + tasks = list(itertools.product(["C0", "C1", "C2"], [0, 1, 2])) + for condition, seed in tasks[args.shard :: args.shards]: + train_run( + engine, + "form", + pools["F_form"], + pools, + texts, + condition, + seed, + -1, + "eval", + c_lock["learning_rate"], + 256, + f"C/form-{condition}-s{seed}", + lambda_geo=0.0 if condition == "C0" else c_lock["lambda_geo"], + ) + elif args.command == "adapt": + tasks = list( + itertools.product(["C0", "C1", "C2"], [0, 1, 2], enumerate(episodes["C_eval"])) + ) + for condition, seed, (episode, ids) in tasks[args.shard :: args.shards]: + train_run( + engine, + "adapt", + [by_id[i] for i in ids], + pools, + texts, + condition, + seed, + episode, + "eval", + b_lr, + 128, + f"C/adapt-{condition}-s{seed}-e{episode}", + parent_path=RESULTS / f"C/form-{condition}-s{seed}/checkpoint-0256.pt", + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_editing.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_editing.py new file mode 100644 index 0000000000000000000000000000000000000000..7065e910e82f4aa54e312af63f4f99925c4e1269 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_editing.py @@ -0,0 +1,759 @@ +"""Local factual updates and downstream composition in existing aligned GPTs. + +Cases are selected from the graph alone, before loading any model predictions. +Every edit has a same-budget old-fact sham, fresh optimizer, and frozen parent +replay reference. No composition labels or intermediate-state targets enter +optimization. Finite replay KL is a regularizer, not exact preservation. +""" + +from __future__ import annotations + +import copy +import hashlib +import json +import os +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import utc, write_json +from .latent_scaling import build_world, model_digest +from .representation_alignment import new_model +from .storage_composition import data_digest, file_hash, generate_rows, pack_sentences + +ROLES = ("first", "second") +STRATA = ("familiar", "strict") +DEFAULT_NODES = (0, 32, 128, 512) + + +def _rows(values, width): + return np.asarray(values, dtype=np.int64).reshape(-1, width) + + +def _unique(values, width): + return _rows(sorted(set(map(tuple, _rows(values, width)))), width) + + +def _hash_json(value): + return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest() + + +def _batch_hash(batch): + digest = hashlib.sha256() + for tensor in batch: + array = tensor.detach().cpu().numpy() + digest.update(str(array.dtype).encode()) + digest.update(str(array.shape).encode()) + digest.update(array.tobytes()) + return digest.hexdigest() + + +def learned_atoms(world): + """Only atomics actually supervised in the representation parent.""" + return _unique(np.concatenate([world["common_atomic"], world["anchor_atomic"]]), 3) + + +def composition_pools(world): + """All legal untrained queries, plus the original holdout and training sets.""" + trained = set(map(tuple, world["train_composite"])) + full = _unique(np.concatenate([world["available_composite"], world["familiar_test"]]), 5) + familiar = _rows([r for r in full if tuple(r) not in trained], 5) + return { + "familiar": familiar, + "strict": world["strict_test"].copy(), + "registered_familiar": world["familiar_test"].copy(), + "train": world["train_composite"].copy(), + } + + +def affected(rows, fact, role): + """Whether a query uses this factual address, independently of its answer.""" + columns = (0, 1) if role == "first" else (2, 3) + return (rows[:, columns[0]] == fact[0]) & (rows[:, columns[1]] == fact[1]) + + +def rewrite(rows, old_fact, new_fact, role, lookup): + result = rows.copy() + mask = affected(rows, old_fact, role) + if role == "first": + result[mask, 2] = new_fact[2] + for index in np.flatnonzero(mask): + result[index, 4] = lookup[int(new_fact[2]), int(rows[index, 3])] + else: + result[mask, 4] = new_fact[2] + return result + + +def graph_cases(parent_spec, *, seed=780011, per_cell=2, replay_n=32): + """Return JSON-compatible selected cases and graph-only eligibility counts. + + Each distinct atomic address receives at most one counterfactual per role. + First-hop replacements stay in the original familiar/strict bridge group and + change at least one affected untrained composition answer. Strict cases never + borrow a bridge with composition experience from the familiar group. + """ + if per_cell < 1 or replay_n < 1: + raise ValueError("Positive case and replay counts are required") + world = build_world(parent_spec) + atoms = learned_atoms(world) + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + pools = composition_pools(world) + rng = np.random.default_rng(seed + int(parent_spec["world"])) + candidates, qualification = [], {} + for role in ROLES: + for stratum in STRATA: + rows = pools[stratum] + addresses = _unique(rows[:, [0, 1, 2] if role == "first" else [2, 3, 4]], 3) + bridges = np.unique(rows[:, 2]) + # Include all trained bridges in that group, even if the holdout + # happens not to visit them (strict rows enumerate all chains). + group = world["background_atomic"] if stratum == "familiar" else world["common_atomic"] + group_bridges = np.unique(group[group[:, 1] >= 17, 0]) + if stratum == "strict": + familiar_bridges = world["background_atomic"] + familiar_bridges = familiar_bridges[familiar_bridges[:, 1] >= 17, 0] + group_bridges = np.setdiff1d(group_bridges, familiar_bridges) + bridges = np.union1d(bridges, group_bridges) + tails = np.unique(atoms[atoms[:, 1] >= 17, 2]) + eligible, replacement_count = [], 0 + for old in addresses: + impacted = rows[affected(rows, old, role)] + choices = [] + for value in bridges if role == "first" else tails: + if value == old[2]: + continue + new = [int(old[0]), int(old[1]), int(value)] + updated = rewrite(impacted, old, new, role, lookup) + if np.any(updated[:, -1] != impacted[:, -1]): + choices.append(new) + replacement_count += len(choices) + if choices: + eligible.append((old.tolist(), choices)) + key = f"{role}_{stratum}" + qualification[key] = { + "candidate_addresses": len(addresses), + "eligible_addresses": len(eligible), + "eligible_replacements": replacement_count, + "untrained_queries": len(rows), + } + if len(eligible) < per_cell: + raise ValueError(f"Insufficient graph-qualified {key} cases: {qualification[key]}") + order = rng.permutation(len(eligible))[:per_cell] + for serial, index in enumerate(order): + old, choices = eligible[index] + new = choices[int(rng.integers(len(choices)))] + candidates.append( + { + "case_id": f"{key}-{serial:02d}", + "role": role, + "stratum": stratum, + "old_fact": old, + "new_fact": new, + } + ) + for case in candidates: + tasks, originals = case_tasks(world, case, replay_indices=None) + necessary = set(map(tuple, tasks["necessary_atomic"])) + allowed = [ + i + for i, row in enumerate(atoms) + if tuple(row) != tuple(case["old_fact"]) and tuple(row) not in necessary + ] + if len(allowed) < replay_n: + raise ValueError("Insufficient independent replay atomics") + case["replay_indices"] = sorted(map(int, rng.choice(allowed, replay_n, replace=False))) + case["affected_untrained_n"] = {name: len(rows) for name, rows in originals.items()} + return candidates, qualification + + +def case_tasks(world, case, replay_indices=None): + """Construct E/R/U/D with address-based exclusions and recomputed truth.""" + atoms = learned_atoms(world) + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + old, new, role = case["old_fact"], case["new_fact"], case["role"] + if lookup[tuple(old[:2])] != old[2] or old[:2] != new[:2] or old[2] == new[2]: + raise ValueError("An edit must replace one existing factual value") + tasks = {"E_old": _rows([old], 3), "E_new": _rows([new], 3)} + originals, necessary = {}, [] + for stratum, rows in composition_pools(world).items(): + mask = affected(rows, old, role) + tasks[f"U_{stratum}"] = rows[~mask].copy() + old_rows = rows[mask].copy() + new_rows = rewrite(old_rows, old, new, role, lookup) + changed = old_rows[:, -1] != new_rows[:, -1] + if stratum == "train": + # Training-query transfer is reported separately from held-out D. + name = f"T_{role}_train" + originals[name] = old_rows + tasks[name] = new_rows + else: + name = f"D_{role}_{stratum}" + originals[name] = old_rows[changed] + tasks[name] = new_rows[changed] + same = f"S_same_answer_{role}_{stratum}" + originals[same] = old_rows[~changed] + tasks[same] = new_rows[~changed] + if stratum in STRATA: + for h, r1, b, r2, t in tasks[name]: + prerequisite = (b, r2, t) if role == "first" else (h, r1, b) + necessary.append(prerequisite) + tasks["necessary_atomic"] = _unique(necessary, 3) + replay = case.get("replay_indices", []) if replay_indices is None else replay_indices + if len(set(replay)) != len(replay): + raise ValueError("Replay indices must be unique") + target = np.flatnonzero(np.all(atoms == np.asarray(old), axis=1)) + if len(target) != 1 or int(target[0]) in replay: + raise ValueError("Replay cannot contain the edited address") + tasks["R_atomic"] = atoms[replay].copy() + tasks["U_atomic"] = np.delete(atoms, [int(target[0]), *replay], axis=0) + return tasks, originals + + +def answer_batch(rows, device): + """Only answer, punctuation and EOS labels; no prefix or bridge labels.""" + tokens, labels = pack_sentences(_rows(rows, 3)) + positions = np.tile([4, 5, 6], (len(rows), 1)) + targets = labels[np.arange(len(rows))[:, None], positions] + expected = np.column_stack([np.asarray(rows)[:, 2], np.full(len(rows), 5), np.ones(len(rows))]) + np.testing.assert_array_equal(targets, expected) + return tuple(torch.as_tensor(x, device=device) for x in (tokens, positions, targets)) + + +def edit_objective(model, target_batch, replay_batch, parent_log, replay_weight=1.0): + target = model(target_batch[0], positions=target_batch[1]) + ce = F.cross_entropy(target.flatten(0, 1), target_batch[2].flatten()) + replay = model(replay_batch[0], positions=replay_batch[1]).log_softmax(-1) + if parent_log.requires_grad: + raise ValueError("Replay reference must be detached") + kl = F.kl_div(replay, parent_log, log_target=True, reduction="none").sum(-1).mean() + return ce + replay_weight * kl, ce, kl + + +def _generate(model, rows, device, batch_size): + if len(rows): + return generate_rows(model, rows, device, batch_size=batch_size) + return ( + {"n": 0, "accuracy": None, "answer_accuracy": None, "answer_nll": None}, + { + "generated": np.empty((0, 3), dtype=np.int64), + "correct": np.empty(0, dtype=bool), + "answer_nll": np.empty(0), + }, + ) + + +def evaluate_case(model, tasks, originals, parent_correct, role, device, batch_size=512): + """Full-pool scores and separately labelled prerequisite/parent subsets.""" + metrics, raw = {}, {} + for name, rows in tasks.items(): + values, predictions = _generate(model, rows, device, batch_size) + raw.update({f"{name}__{k}": v for k, v in predictions.items()}) + if name in originals: + old = originals[name] + generated = predictions["generated"] + changed = old[:, -1] != rows[:, -1] + old_correct = (generated[:, 0] == old[:, -1]) & np.all( + generated[:, 1:] == [5, 1], axis=1 + ) + prerequisite = rows[:, [2, 3, 4] if role == "first" else [0, 1, 2]] + _m, needed = _generate(model, prerequisite, device, batch_size) + edited_ok = metrics["E_new"]["accuracy"] == 1.0 + covered = needed["correct"] & edited_ok + baseline = parent_correct[name] + valid_parent = baseline & changed + correct = predictions["correct"] + values.update( + { + "changed_answer_n": int(changed.sum()), + "old_answer_accuracy": float(old_correct.mean()) if len(rows) else None, + "parent_correct_n": int(baseline.sum()), + "parent_correct_coverage": float(baseline.mean()) if len(rows) else None, + "new_following_parent_correct": float(correct[valid_parent].mean()) + if valid_parent.any() + else None, + "old_retained_parent_correct": float(old_correct[valid_parent].mean()) + if valid_parent.any() + else None, + "direct_edit_success": edited_ok, + "necessary_atomic_correct_n": int(needed["correct"].sum()), + "operation_correct_n": int(covered.sum()), + "operation_correct_coverage": float(covered.mean()) if len(rows) else None, + "new_following_operation_correct": float(correct[covered].mean()) + if covered.any() + else None, + } + ) + raw[f"{name}__parent_correct"] = baseline + raw[f"{name}__operation_correct"] = covered + raw[f"{name}__old_correct"] = old_correct + raw[f"{name}__necessary_generated"] = needed["generated"] + raw[f"{name}__new_rows"] = rows + raw[f"{name}__old_rows"] = old + metrics[name] = values + return metrics, raw + + +def editable_parameters(model, scope="mlp", block_index=0): + prefix = f"blocks.{block_index}.mlp." + selected = [ + name + for name, _ in model.named_parameters() + if name.startswith(prefix) and (scope == "mlp" or name == prefix + "down.weight") + ] + if scope not in {"mlp", "down"} or not selected: + raise ValueError("Unknown or empty local parameter scope") + for name, parameter in model.named_parameters(): + parameter.requires_grad_(name in selected) + parameter.grad = None + return selected + + +def _configure(device): + device = torch.device(device) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + if device.type == "cuda": + torch.cuda.set_device(device) + return device + + +def _load_parent(parent_dir, device): + path = Path(parent_dir) / "model.pt" + payload = torch.load(path, map_location="cpu", weights_only=False) + model = new_model(payload["spec"], device).eval() + model.load_state_dict(payload["model"]) + world = build_world(payload["spec"]) + if (Path(parent_dir) / "world.npz").exists(): + with np.load(Path(parent_dir) / "world.npz") as saved: + for name, rows in world.items(): + np.testing.assert_array_equal(rows, saved[name]) + return model, world, payload["spec"] + + +def _parent_masks(parent, originals, device, batch_size): + return { + name: _generate(parent, rows, device, batch_size)[1]["correct"] + for name, rows in originals.items() + } + + +def run(spec, out, device="cuda:0"): + """Execute one parent, a graph-selected case set and optional development lr grid. + + The caller owns source freezing, resource allocation and W&B startup. Each + branch has run/learning/complete artifacts. Root ``step`` is a strictly + increasing evaluation index, including every branch's unchanged node zero; + ``optimizer_updates`` separately records cumulative optimization work. + Target labels and replay KL positions have separate exposure counters. + ``status.json`` retains completed-branch progress, explicitly labelled in + the manifest; it does not define the tracking series' step axis. + """ + device = _configure(device) + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "run.json").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite an existing attempt: {out}") + nodes = spec.get("nodes", list(DEFAULT_NODES)) + if not nodes or nodes[0] != 0 or nodes != sorted(set(nodes)) or nodes[-1] <= 0: + raise ValueError("Nodes must increase from zero to a positive fixed endpoint") + rates = spec.get("learning_rates", [spec.get("lr", 1e-4)]) + if not rates or any(lr <= 0 for lr in rates) or len(set(rates)) != len(rates): + raise ValueError("Learning rates must be positive and unique") + if spec.get("phase") not in {"development", "engineering"} and len(rates) > 1: + raise ValueError("Learning-rate grids are development-only") + arms = spec.get("arms", ["edit", "sham"]) + if sorted(arms) != ["edit", "sham"]: + raise ValueError("Every case requires paired edit and sham branches") + parent, world, parent_spec = _load_parent(spec["parent_dir"], device) + parent_hash = model_digest(parent) + cases, qualification = graph_cases( + parent_spec, + seed=spec.get("candidate_seed", 780011), + per_cell=spec.get("per_cell", 2), + replay_n=spec.get("replay_n", 32), + ) + if "case_ids" in spec: + requested = set(spec["case_ids"]) + if not requested or not requested <= {c["case_id"] for c in cases}: + raise ValueError("Unknown/empty fixed graph-selected case subset") + cases = [c for c in cases if c["case_id"] in requested] + manifest = { + "spec": spec, + "parent_spec": parent_spec, + "cases": cases, + "qualification": qualification, + "case_sha256": _hash_json(cases), + "parent_file_sha256": file_hash(Path(spec["parent_dir"]) / "model.pt"), + "parent_model_sha256": parent_hash, + "world_sha256": data_digest(world), + "created_utc": utc(), + "dtype": "float32", + "allow_tf32": True, + "pid": os.getpid(), + "gpu": device.index if device.type == "cuda" else None, + "branches": len(cases) * len(rates) * len(arms), + "planned_updates": len(cases) * len(rates) * len(arms) * nodes[-1], + "planned_evaluations": len(cases) * len(rates) * len(arms) * len(nodes), + "learning_step_unit": "evaluation_index", + "status_step_unit": "completed_branches", + "scope_warning": "The selected MLP is shared across all repeated executions", + } + write_json(out / "run.json", manifest) + write_json(out / "cases.json", cases) + np.savez_compressed(out / "world.npz", **world) + root_learning, branch_summaries, completed_steps = [], [], 0 + started = time.perf_counter() + training_seconds = 0.0 + batch_size = spec.get("eval_batch_size", 512) + for case in cases: + tasks, originals = case_tasks(world, case) + parent_correct = _parent_masks(parent, originals, device, batch_size) + parent_metrics, parent_predictions = evaluate_case( + parent, + tasks, + originals, + parent_correct, + case["role"], + device, + batch_size, + ) + case_out = out / case["case_id"] + case_out.mkdir() + np.savez_compressed(case_out / "parent-predictions.npz", **parent_predictions) + write_json(case_out / "parent-metrics.json", parent_metrics) + np.savez_compressed(case_out / "tasks.npz", **tasks) + replay_batch = answer_batch(tasks["R_atomic"], device) + with torch.no_grad(): + parent_log = parent(replay_batch[0], positions=replay_batch[1]).log_softmax(-1).detach() + for lr in rates: + for arm in arms: + branch_name = f"lr{lr:.8g}-{arm}" + branch_out = case_out / branch_name + branch_out.mkdir() + model = copy.deepcopy(parent).eval() + selected = editable_parameters( + model, + spec.get("parameter_scope", "mlp"), + spec.get("block_index", 0), + ) + parameters = dict(model.named_parameters()) + optimizer = torch.optim.Adam([parameters[n] for n in selected], lr=lr) + target = tasks["E_new" if arm == "edit" else "E_old"] + target_batch = answer_batch(target, device) + write_json( + branch_out / "run.json", + { + "case_id": case["case_id"], + "arm": arm, + "lr": lr, + "parent_model_sha256": parent_hash, + "editable_parameters": selected, + "optimizer": "Adam, fresh state, zero weight decay", + "sampling": "same fixed full replay batch on every update; no dropout", + "old_fact_sha256": _hash_json(case["old_fact"]), + "new_fact_sha256": _hash_json(case["new_fact"]), + "target_batch_sha256": _batch_hash(target_batch), + "replay_batch_sha256": _batch_hash(replay_batch), + "parent_reference_sha256": _batch_hash((parent_log,)), + "nodes": nodes, + }, + ) + np.savez_compressed( + branch_out / "replay-reference.npz", log_probabilities=parent_log.cpu().numpy() + ) + step, losses, history = 0, [], [] + for node in nodes: + if device.type == "cuda": + torch.cuda.synchronize(device) + began = time.perf_counter() + while step < node: + optimizer.zero_grad(set_to_none=True) + loss, ce, kl = edit_objective( + model, + target_batch, + replay_batch, + parent_log, + spec.get("replay_weight", 1.0), + ) + if not torch.isfinite(loss): + raise FloatingPointError(f"Nonfinite edit loss at {step}") + loss.backward() + gradient_norm = torch.nn.utils.clip_grad_norm_( + [parameters[n] for n in selected], + spec.get("clip_norm", 1.0), + ) + optimizer.step() + step += 1 + losses.append( + { + "step": step, + "loss": float(loss.detach()), + "target_ce": float(ce.detach()), + "replay_kl": float(kl.detach()), + "gradient_norm": float(gradient_norm), + } + ) + if device.type == "cuda": + torch.cuda.synchronize(device) + training_seconds += time.perf_counter() - began + metrics, predictions = evaluate_case( + model, + tasks, + originals, + parent_correct, + case["role"], + device, + batch_size, + ) + current_hash = model_digest(model) + record = { + "step": step, + "metrics": metrics, + "model_sha256": current_hash, + "target_success": metrics["E_new" if arm == "edit" else "E_old"]["accuracy"] + == 1, + "U_atomic_at_least_95": metrics["U_atomic"]["accuracy"] >= 0.95, + "loss": losses[-1] if losses else None, + } + history.append(record) + write_json(branch_out / "learning.json", history) + write_json(branch_out / "losses.json", losses) + np.savez_compressed(branch_out / f"predictions-{step:06d}.npz", **predictions) + torch.save( + { + "edited_tensors": { + n: parameters[n].detach().cpu().clone() for n in selected + }, + "model_sha256": current_hash, + "step": step, + }, + branch_out / f"tensors-{step:06d}.pt", + ) + root_learning.append( + { + "step": len(root_learning), + "branch_step": step, + "completed_branches": len(branch_summaries) + int(step == nodes[-1]), + "optimizer_updates": completed_steps + step, + "case_id": case["case_id"], + "arm": arm, + "lr": lr, + "metrics": metrics, + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "examples": (completed_steps + step) * (1 + len(tasks["R_atomic"])), + "target_supervised_tokens": (completed_steps + step) * 3, + "replay_distillation_positions": (completed_steps + step) + * len(tasks["R_atomic"]) + * 3, + } + ) + write_json(out / "learning.json", root_learning) + write_json( + out / "status.json", + { + "state": "running", + "step": len(branch_summaries), + "optimizer_updates": completed_steps + step, + "budget": manifest["branches"], + "case_id": case["case_id"], + "arm": arm, + "lr": lr, + }, + ) + changed = [ + n + for n, t in model.state_dict().items() + if not torch.equal(t, parent.state_dict()[n]) + ] + if set(changed) - set(selected) or model_digest(parent) != parent_hash: + raise AssertionError("A frozen parameter or the parent changed") + complete = { + "case_id": case["case_id"], + "role": case["role"], + "stratum": case["stratum"], + "lr": lr, + "arm": arm, + "path": str(branch_out.relative_to(out)), + "metrics": metrics, + "steps": step, + "changed_tensors": changed, + "parent_model_sha256": parent_hash, + "final_model_sha256": current_hash, + "delta_l2": float( + torch.sqrt( + sum( + (parameters[n] - dict(parent.named_parameters())[n]).square().sum() + for n in selected + ) + ).detach() + ), + "tensor_file_sha256": file_hash(branch_out / f"tensors-{step:06d}.pt"), + } + write_json(branch_out / "complete.json", complete) + branch_summaries.append(complete) + completed_steps += step + result = { + "status": "complete", + "branches": branch_summaries, + "updates": completed_steps, + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "finished_utc": utc(), + "case_sha256": manifest["case_sha256"], + } + write_json(out / "complete.json", result) + write_json( + out / "status.json", + { + "state": "complete", + "step": len(branch_summaries), + "optimizer_updates": completed_steps, + "budget": manifest["branches"], + }, + ) + return result + + +def audit(out, device="cuda:0"): + """Reload every saved node from parent plus exact tensors and re-score it.""" + device, out = _configure(device), Path(out) + manifest = json.loads((out / "run.json").read_text()) + spec = manifest["spec"] + if file_hash(Path(spec["parent_dir"]) / "model.pt") != manifest["parent_file_sha256"]: + raise AssertionError("Parent checkpoint hash changed") + parent, world, parent_spec = _load_parent(spec["parent_dir"], device) + if model_digest(parent) != manifest["parent_model_sha256"]: + raise AssertionError("Parent model digest changed") + cases, qualification = graph_cases( + parent_spec, + seed=spec.get("candidate_seed", 780011), + per_cell=spec.get("per_cell", 2), + replay_n=spec.get("replay_n", 32), + ) + if "case_ids" in spec: + cases = [c for c in cases if c["case_id"] in spec["case_ids"]] + if cases != manifest["cases"] or _hash_json(cases) != manifest["case_sha256"]: + raise AssertionError("Graph-selected cases changed") + if qualification != manifest["qualification"] or data_digest(world) != manifest["world_sha256"]: + raise AssertionError("World qualification changed") + summary = json.loads((out / "complete.json").read_text()) + rates = spec.get("learning_rates", [spec.get("lr", 1e-4)]) + expected_branches = { + (c["case_id"], lr, arm) for c in cases for lr in rates for arm in ("edit", "sham") + } + actual_branches = [(b["case_id"], b["lr"], b["arm"]) for b in summary["branches"]] + if len(actual_branches) != len(expected_branches) or set(actual_branches) != expected_branches: + raise AssertionError("The fixed paired branch matrix is incomplete") + root_learning = json.loads((out / "learning.json").read_text()) + nodes = spec.get("nodes", list(DEFAULT_NODES)) + expected_evaluations = len(actual_branches) * len(nodes) + if len(root_learning) != expected_evaluations or [row["step"] for row in root_learning] != list( + range(expected_evaluations) + ): + raise AssertionError("Root learning evaluation indices are incomplete or repeated") + for index, row in enumerate(root_learning): + branch_index, node_index = divmod(index, len(nodes)) + updates = branch_index * nodes[-1] + nodes[node_index] + if ( + (row["case_id"], row["lr"], row["arm"]) != actual_branches[branch_index] + or row["branch_step"] != nodes[node_index] + or row["optimizer_updates"] != updates + or row["target_supervised_tokens"] != updates * 3 + or row["replay_distillation_positions"] != updates * spec.get("replay_n", 32) * 3 + or "supervised_tokens" in row + ): + raise AssertionError("Root learning optimizer or exposure accounting changed") + batch_size = spec.get("eval_batch_size", 512) + checked_nodes, checked_predictions, max_error = 0, 0, 0.0 + for case in cases: + tasks, originals = case_tasks(world, case) + parent_correct = _parent_masks(parent, originals, device, batch_size) + for branch in summary["branches"]: + if branch["case_id"] != case["case_id"]: + continue + directory = out / branch["path"] + branch_spec = json.loads((directory / "run.json").read_text()) + target = tasks["E_new" if branch["arm"] == "edit" else "E_old"] + target_batch = answer_batch(target, device) + replay_batch = answer_batch(tasks["R_atomic"], device) + with torch.no_grad(): + reference = parent(replay_batch[0], positions=replay_batch[1]).log_softmax(-1) + expected_hashes = { + "old_fact_sha256": _hash_json(case["old_fact"]), + "new_fact_sha256": _hash_json(case["new_fact"]), + "target_batch_sha256": _batch_hash(target_batch), + "replay_batch_sha256": _batch_hash(replay_batch), + "parent_reference_sha256": _batch_hash((reference,)), + } + if any(branch_spec[key] != value for key, value in expected_hashes.items()): + raise AssertionError("Target or paired replay provenance changed") + history = json.loads((directory / "learning.json").read_text()) + if [record["step"] for record in history] != spec.get("nodes", list(DEFAULT_NODES)): + raise AssertionError("Saved edit node matrix is incomplete") + if ( + file_hash(directory / f"tensors-{history[-1]['step']:06d}.pt") + != branch["tensor_file_sha256"] + ): + raise AssertionError("Final exact tensor file hash changed") + for record in history: + state = torch.load( + directory / f"tensors-{record['step']:06d}.pt", + map_location="cpu", + weights_only=True, + ) + model = copy.deepcopy(parent).eval() + selected = editable_parameters( + model, spec.get("parameter_scope", "mlp"), spec.get("block_index", 0) + ) + if set(state["edited_tensors"]) != set(selected): + raise AssertionError("Unexpected edited tensor scope") + merged = model.state_dict() + merged.update(state["edited_tensors"]) + model.load_state_dict(merged) + if model_digest(model) != record["model_sha256"]: + raise AssertionError("Exact saved tensors did not reconstruct the model") + metrics, predictions = evaluate_case( + model, + tasks, + originals, + parent_correct, + case["role"], + device, + batch_size, + ) + with np.load(directory / f"predictions-{record['step']:06d}.npz") as saved: + if set(saved.files) != set(predictions): + raise AssertionError("Prediction keys changed") + for name, actual in predictions.items(): + if name.endswith("answer_nll"): + np.testing.assert_allclose(actual, saved[name], rtol=1e-5, atol=1e-5) + if len(actual): + max_error = max( + max_error, float(np.max(np.abs(actual - saved[name]))) + ) + else: + np.testing.assert_array_equal(actual, saved[name]) + checked_predictions += actual.size + for name, values in metrics.items(): + for key, value in values.items(): + expected = record["metrics"][name][key] + if key == "answer_nll" and value is not None: + np.testing.assert_allclose(value, expected, rtol=1e-5, atol=1e-5) + elif value != expected: + raise AssertionError(f"Re-scoring mismatch: {name}/{key}") + checked_nodes += 1 + result = { + "passed": True, + "nodes": checked_nodes, + "array_elements": checked_predictions, + "max_nll_error": max_error, + "case_sha256": manifest["case_sha256"], + "finished_utc": utc(), + } + write_json(out / "audit.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_tracking.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_tracking.py new file mode 100644 index 0000000000000000000000000000000000000000..16c66de277e2f35fd69f931dc2b4b21b70ec3df4 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/interface_tracking.py @@ -0,0 +1,199 @@ +"""Use the existing W&B sidecar, finishing only after the independent audit.""" + +import argparse +import fcntl +import importlib +import json +import os +import time +from pathlib import Path + +from . import experiment_tracking as tracking + + +class ContainerSDK: + def __init__(self, sdk, runtime): + self.sdk, self.runtime = sdk, runtime + + def __getattr__(self, name): + return getattr(self.sdk, name) + + def Settings(self, **options): + options.pop("x_stats_pid", None) + if self.runtime: + options["x_stats_pid"] = self.runtime["host_pid"] + options["x_stats_gpu_device_ids"] = (self.runtime["physical_gpu"],) + return self.sdk.Settings(**options) + + +class AuditedRunTracker(tracking.ArtifactRunTracker): + def __init__(self, sdk, batch, path, settings): + runtime_path = path / "container-runtime.json" + runtime = tracking.read_json(runtime_path) + super().__init__(ContainerSDK(sdk, runtime), batch, path, settings) + self.run.config.update( + { + key: self.metadata[key] + for key in ( + "parent_spec", + "cases", + "learning_step_unit", + "status_step_unit", + ) + if key in self.metadata + } + ) + if runtime: + self.run.config.update({"container_runtime": runtime}) + + def poll(self): + history = tracking.read_json(self.path / "learning.json") + previous = None + for record in history: + step = int(record["step"]) + if step > self.cursor: + metrics = tracking.learning_metrics(record, previous) + for key in ("case", "case_id", "condition", "variant", "arm"): + if key in record: + metrics["condition/" + key] = record[key] + if "optimizer_updates" in record: + metrics["evaluation/index"] = step + metrics["condition/step_unit"] = "evaluation_index" + metrics.pop("perf/updates_per_second", None) + metrics.pop("perf/training_ms_per_update", None) + if previous is not None: + seconds = record.get("wall_seconds", 0) - previous.get("wall_seconds", 0) + updates = record["optimizer_updates"] - previous.get("optimizer_updates", 0) + if seconds > 0: + metrics["perf/updates_per_second"] = updates / seconds + self.run.log(metrics, step=step) + self.cursor = step + self.state["last_logged_step"] = step + tracking.write_json(self.state_path, self.state) + previous = record + status_path = self.path / "status.json" + if status_path.exists(): + self.run.summary["training_state"] = tracking.read_json(status_path).get("state") + failed = (self.path / "failure.json").exists() + audit_path = self.path / "audit.json" + audit = tracking.read_json(audit_path) if audit_path.exists() else {} + audited = audit.get("passed") is True + complete = (self.path / "complete.json").exists() and audited + self.run.summary["has_failure_record"] = failed + self.run.summary["independently_reloaded"] = audited + if complete or failed: + self.run.summary["scientific_final_step"] = self.cursor + self.run.finish(exit_code=1 if failed else 0) + # Preserve the authoritative resume cursor even when every point + # was already on the server and this process logged no new points. + self.state["last_logged_step"] = self.cursor + tracking.write_json(self.state_path, self.state) + return True + return False + + +def discover_runs(runs_dir): + return { + path + for path in Path(runs_dir).glob("*") + if (path / "run.json").exists() and (path / "learning.json").exists() + } + + +def final_step(path): + history = tracking.read_json(path / "learning.json") + return max((int(record["step"]) for record in history), default=-1) + + +def drain_runs(sdk, root, runs_dir, settings, *, once=False, tracker_factory=None): + """Drain late-created runs and late final nodes before terminal exit. + + SDK initialization and uploads may take longer than an entire scientific + run. Consequently, a scan made before those calls is never an exit proof. + Finished runs stay in this process's cursor map and are reopened only if + their saved learning trajectory acquired an unlogged final node. + """ + root, runs_dir = Path(root), Path(runs_dir) + tracker_factory = tracker_factory or AuditedRunTracker + active, finished = {}, {} + try: + while True: + for path in sorted(discover_runs(runs_dir)): + if path in active or path in finished: + continue + active[path] = tracker_factory(sdk, root, path, settings) + print(json.dumps({"run": path.name, "url": active[path].run.url}), flush=True) + for path, tracker in list(active.items()): + current = tracking.read_json(path / "run.json") + if current.get("pid") != tracker.metadata.get("pid"): + tracker.close() + tracker = tracker_factory(sdk, root, path, settings) + active[path] = tracker + if tracker.poll(): + finished[path] = tracker.cursor + del active[path] + if once: + return {str(path): cursor for path, cursor in finished.items()} + manifest = root / "controller-state.json" + state = tracking.read_json(manifest) if manifest.exists() else {} + terminal = state.get("state") in {"complete", "finished_with_failures"} + # Rescan AFTER all SDK calls and after reading the controller's + # terminal state, so runs born during initialization cannot vanish. + fresh = discover_runs(runs_dir) + stale = {path for path, cursor in finished.items() if final_step(path) > cursor} + for path in stale: + del finished[path] + if terminal and not active: + expected = {runs_dir / name for name in state.get("completed", [])} + if missing := expected - fresh: + raise RuntimeError(f"Completed runs lack logging artifacts: {sorted(missing)}") + if fresh <= finished.keys(): + result = { + "passed": True, + "registered_runs": len(finished), + "runs": { + path.name: { + "last_logged_step": finished[path], + "final_step": final_step(path), + } + for path in sorted(fresh) + }, + } + tracking.write_json(root / "tracking-completion.json", result) + return result + if fresh - (active.keys() | finished.keys()): + continue + time.sleep(settings["poll_seconds"]) + finally: + for tracker in active.values(): + tracker.close() + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--root", type=Path, required=True) + parser.add_argument("--runs-dir", type=Path) + parser.add_argument("--defaults", type=Path, default=tracking.DEFAULTS) + parser.add_argument("--entity") + parser.add_argument("--project") + parser.add_argument("--mode", choices=("online", "offline")) + parser.add_argument("--once", action="store_true") + args = parser.parse_args() + settings = tracking.read_json(args.defaults) + for key in ("entity", "project", "mode"): + settings[key] = ( + getattr(args, key) or os.environ.get(f"WANDB_{key.upper()}") or settings[key] + ) + if not settings["enabled"]: + raise SystemExit("Experiment tracking is disabled in the selected defaults") + local = args.root / "tracking-wandb" + local.mkdir(parents=True, exist_ok=True) + sdk = importlib.import_module("wandb") + with (local / "tracker.lock").open("w") as lock: + fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + tracking.write_json(args.root / "tracking-ready.json", {"sdk_version": sdk.__version__}) + drain_runs(sdk, args.root, args.runs_dir or args.root / "runs", settings, once=args.once) + + +if __name__ == "__main__": + main() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_scaling.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_scaling.py new file mode 100644 index 0000000000000000000000000000000000000000..7abd21f4255e3f7de35ecee337ed09d32da707ff --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_scaling.py @@ -0,0 +1,311 @@ +"""Scaling knowledge use in ordinary GPT blocks with fixed facts and tests. + +Independent composition examples and optimization time are separate axes. All +blocks retain learned embeddings, causal attention, residuals and 4x GELU MLPs. +Historical experiments and their frozen implementations are left untouched. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch + +from .bios_model import ModelConfig +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .storage_composition import FullTokenStep, data_digest, evaluate, file_hash, pack_sentences +from .storage_composition import build_world as historical_world +from .storage_frontier import SOURCE_FILES as STABILITY_SOURCES +from .storage_frontier import learning_rate +from .text_pretrain import WORDS + +SOURCE_FILES = [ + *STABILITY_SOURCES, + "src/llm_memory_editability/latent_scaling.py", + "scripts/run_latent_scaling.py", + "tests/test_latent_scaling.py", +] + + +def build_world(spec): + world = historical_world(spec) + pool = world["train_composite"] + order = np.random.default_rng(spec["world"] + 880000).permutation(len(pool)) + count = spec["composition_count"] + count = len(pool) if count == "all" else count + if isinstance(count, bool) or not isinstance(count, int) or not 0 < count <= len(pool): + raise ValueError("Composition count must be a positive prefix of the fixed pool") + world["available_composite"] = pool[order] + world["train_composite"] = world["available_composite"][:count].copy() + return world + + +def construct(spec, device): + config = ModelConfig( + vocab_size=len(WORDS) + spec["heads_n"] + spec["bridges_n"] + spec["tails_n"], + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=16, + ) + torch.manual_seed(spec["initialization"]) + # R=1 is ordinary GPT. The wrapper permits the same trained single block to + # be evaluated at other R, including the R=1 training baseline. + return LoopGPT(config, spec["repeats"], spec["dropout"], "legacy_unique").to(device) + + +def model_digest(model): + digest = hashlib.sha256() + for key, value in sorted(model.state_dict().items()): + digest.update(key.encode()) + digest.update(value.detach().cpu().numpy().tobytes()) + return digest.hexdigest() + + +def run_name(spec): + return ( + f"w{spec['world']}-i{spec['initialization']}-d{spec['width']}" + f"-l{spec['layers']}-r{spec['repeats']}-n{spec['composition_count']}-s{spec['steps']}" + ) + + +def role_coverage(world): + first = {(int(h), int(r)) for h, r, _b, _r2, _t in world["train_composite"]} + second = {(int(b), int(r)) for _h, _r1, b, r, _t in world["train_composite"]} + rows = world["familiar_test"] + return { + "first_atoms_used": len(first), + "second_atoms_used": len(second), + "familiar_both_composition_roles": float( + np.mean( + [ + (int(h), int(r1)) in first and (int(b), int(r2)) in second + for h, r1, b, r2, _t in rows + ] + ) + ), + } + + +def train(spec, out, source, device="cuda:0"): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "latest.pt").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite a training attempt: {out}") + if spec["nodes"][0] != 0 or spec["nodes"][-1] != spec["steps"]: + raise ValueError("Nodes must include initialization and the fixed endpoint") + if spec["nodes"] != sorted(set(spec["nodes"])) or spec["batch_size"] % 3: + raise ValueError("Nodes must increase and the batch must divide into three streams") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + process_start = time.perf_counter() + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + digest = data_digest(world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_digest = model_digest(model) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + strata = [world["common_atomic"], world["train_composite"], world["anchor_atomic"]] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + graph = FullTokenStep(model, optimizer, table, batch) + flop_step = flops(model.config, spec["repeats"], batch, 9, output_positions=9) + history, repeat_metrics, training_seconds, step = [], {}, 0.0, 0 + + def measure(loss=None): + metrics, predictions = evaluate(model, world, "low", device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0.0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + "composition_epochs": step * batch / 3 / sizes[1], + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + if step in spec["repeat_nodes"]: + repeat_metrics[str(step)] = {} + for repeat in spec["test_repeats"]: + m, p = evaluate(model, world, "low", device, repeat) + repeat_metrics[str(step)][str(repeat)] = m + np.savez_compressed(out / f"repeat-{step:06d}-r{repeat:02d}.npz", **p) + write_json(out / "repeat-metrics.json", repeat_metrics) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["checkpoint_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"model-{step:06d}.pt", + ) + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["common_atomic"]["accuracy"], + "train": metrics["train_composite"]["accuracy"], + "test": metrics["familiar_test"]["accuracy"], + } + ), + flush=True, + ) + return row + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize() + started = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - started + loss = float(loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite training loss at {step}") + endpoint = measure(loss) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + result = { + "spec": spec, + "source": source, + "data_sha256": digest, + "initial_model_sha256": initial_digest, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "independent_facts": sizes[0] + sizes[2], + "composition_examples": sizes[1], + "role_coverage": role_coverage(world), + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "training_seconds": training_seconds, + "process_seconds": time.perf_counter() - process_start, + "supervised_tokens": step * batch * 23 // 3, + "padded_input_tokens": step * batch * 9, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device), + "tf32": True, + }, + } + write_json(out / "complete.json", result) + return result + + +def compare_predictions(actual, saved): + maximum = 0.0 + assert set(actual) == set(saved.files) + for key, value in actual.items(): + if key.endswith("answer_nll"): + maximum = max(maximum, float(np.abs(value - saved[key]).max())) + np.testing.assert_allclose(value, saved[key], rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(value, saved[key]) + return maximum + + +def compare_metrics(actual, saved): + for task, values in actual.items(): + for key, value in values.items(): + if key == "answer_nll": + np.testing.assert_allclose(value, saved[task][key], rtol=1e-5, atol=1e-5) + else: + assert value == saved[task][key] + + +def audit(out, device="cuda:0"): + out = Path(out) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + result = json.loads((out / "complete.json").read_text()) + assert file_hash(out / "latest.pt") == result["checkpoint_sha256"] + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + spec = saved["spec"] + world = build_world(spec) + assert data_digest(world) == result["data_sha256"] == saved["data_sha256"] + assert saved["step"] == spec["steps"] + model = construct(spec, device) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, "low", device) + compare_metrics(metrics, result["endpoint"]["metrics"]) + maximum = compare_predictions( + predictions, np.load(out / f"predictions-{spec['steps']:06d}.npz") + ) + repeat_checks = 0 + for node, repeats in result["repeat_metrics"].items(): + checkpoint = torch.load( + out / f"model-{int(node):06d}.pt", map_location=device, weights_only=False + ) + model.load_state_dict(checkpoint["model"]) + for repeat, expected in repeats.items(): + actual, pred = evaluate(model, world, "low", device, int(repeat)) + compare_metrics(actual, expected) + maximum = max( + maximum, + compare_predictions( + pred, np.load(out / f"repeat-{int(node):06d}-r{int(repeat):02d}.npz") + ), + ) + repeat_checks += 1 + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == spec["steps"] * spec["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + checked = { + "passed": True, + "endpoint_tokens_exact": True, + "repeat_checks": repeat_checks, + "max_nll_difference": maximum, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "utc": utc(), + } + write_json(out / "audit.json", checked) + return checked diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_support.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_support.py new file mode 100644 index 0000000000000000000000000000000000000000..4b307c09f7a1fe633c634ae39b3a83e964675355 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/latent_support.py @@ -0,0 +1,363 @@ +"""Degree-matched support follow-up with isolated training and audit entry points. + +The train/audit bodies are copied from latent_scaling.py at batch creation so +historical sources retain their frozen hashes. Architecture, optimizer, sentence +packing, evaluation and streams are reused; only build_world selects support. +""" + +from __future__ import annotations + +import json +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch + +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import flops +from .latent_scaling import ( + SOURCE_FILES as HISTORICAL_SOURCES, +) +from .latent_scaling import ( + build_world as scaling_world, +) +from .latent_scaling import ( + compare_metrics, + compare_predictions, + construct, + model_digest, + role_coverage, +) +from .latent_scaling import ( + run_name as scaling_run_name, +) +from .storage_composition import ( + FullTokenStep, + audit_world, + data_digest, + evaluate, + file_hash, + pack_sentences, +) +from .storage_frontier import learning_rate + +SOURCE_FILES = [*HISTORICAL_SOURCES, "src/llm_memory_editability/latent_support.py"] + + +def run_name(spec): + return scaling_run_name(spec) + "-support-" + spec["support"] + + +def build_world(spec): + """Select frozen legal edges; never use model scores or test pairs to choose.""" + if spec.get("support") not in ("connected", "split"): + raise ValueError("Unknown frozen support arm") + indices = spec.get("composition_indices", []) + if ( + len(indices) != 512 + or any(isinstance(i, bool) or not isinstance(i, int) for i in indices) + or len(set(indices)) != 512 + or indices != sorted(indices) + or spec.get("composition_count") != 512 + ): + raise ValueError("Support must contain 512 unique sorted integer indices") + world = scaling_world(dict(spec, composition_count="all")) + pool = world["available_composite"] + if indices[0] < 0 or indices[-1] >= len(pool): + raise ValueError("Support index outside the fixed available pool") + world["train_composite"] = pool[indices].copy() + if len(set(map(tuple, world["train_composite"]))) != 512: + raise ValueError("Support contains duplicate training chains") + audit_world(world) + expected = spec.get("frozen_data_sha256") + if expected is not None and data_digest(world) != expected: + raise RuntimeError("Rebuilt support data differ from the frozen digest") + return world + + +def exposure_signature(world, counts=None): + """Count actual sampled roles and column marginals, independently of streams.""" + rows = world["train_composite"] + if counts is None: + counts = np.ones(len(rows), dtype=np.int64) + if len(counts) != len(rows): + raise ValueError("Exposure counter does not match the support") + first, second = Counter(), Counter() + columns = [Counter() for _ in range(5)] + for row, count in zip(rows, counts, strict=True): + h, r1, b, r2, _t = map(int, row) + first[f"{h}:{r1}"] += int(count) + second[f"{b}:{r2}"] += int(count) + for col, value in enumerate(row): + columns[col][str(int(value))] += int(count) + return { + "first_roles": dict(sorted(first.items())), + "second_roles": dict(sorted(second.items())), + "columns": [dict(sorted(c.items())) for c in columns], + } + + +def support_components(world): + """Independent adjacency traversal, including all available training roles.""" + adjacency = {} + for h, r1, b, r2, _t in world["available_composite"]: + adjacency.setdefault(("l", int(h), int(r1)), set()) + adjacency.setdefault(("r", int(b), int(r2)), set()) + for h, r1, b, r2, _t in world["train_composite"]: + left, right = ("l", int(h), int(r1)), ("r", int(b), int(r2)) + adjacency[left].add(right) + adjacency[right].add(left) + seen, components = set(), 0 + for root in adjacency: + if root in seen: + continue + components += 1 + stack = [root] + seen.add(root) + while stack: + for neighbour in adjacency[stack.pop()]: + if neighbour not in seen: + seen.add(neighbour) + stack.append(neighbour) + return { + "roles": len(adjacency), + "components": components, + "isolated_roles": sum(not neighbours for neighbours in adjacency.values()), + } + + +def validate_nodes(spec): + if spec["batch_size"] != 192 or any(node % 8 for node in spec["nodes"]): + raise ValueError("Every measurement must complete the 512-chain epochs") + if not set(spec["repeat_nodes"]) <= set(spec["checkpoint_nodes"]) <= set(spec["nodes"]): + raise ValueError("Scans and checkpoints must use recorded learning nodes") + + +def train(spec, out, source, device="cuda:0"): + validate_nodes(spec) + if "frozen_data_sha256" not in spec: + raise ValueError("Training requires a frozen data digest") + if any(file_hash(path) != digest for path, digest in source.items()): + raise RuntimeError("Training source differs from its frozen digest") + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "latest.pt").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite a training attempt: {out}") + if spec["nodes"][0] != 0 or spec["nodes"][-1] != spec["steps"]: + raise ValueError("Nodes must include initialization and the fixed endpoint") + if spec["nodes"] != sorted(set(spec["nodes"])) or spec["batch_size"] % 3: + raise ValueError("Nodes must increase and the batch must divide into three streams") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + process_start = time.perf_counter() + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + digest = data_digest(world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_digest = model_digest(model) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + strata = [world["common_atomic"], world["train_composite"], world["anchor_atomic"]] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + graph = FullTokenStep(model, optimizer, table, batch) + flop_step = flops(model.config, spec["repeats"], batch, 9, output_positions=9) + history, repeat_metrics, training_seconds, step = [], {}, 0.0, 0 + + def measure(loss=None): + if step and not np.all(counts[1] == step * batch // 3 // 512): + raise RuntimeError("Composition exposures must be exact complete epochs") + metrics, predictions = evaluate(model, world, "low", device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0.0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + "composition_epochs": step * batch / 3 / sizes[1], + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + if step in spec["repeat_nodes"]: + repeat_metrics[str(step)] = {} + for repeat in spec["test_repeats"]: + m, p = evaluate(model, world, "low", device, repeat) + repeat_metrics[str(step)][str(repeat)] = m + np.savez_compressed(out / f"repeat-{step:06d}-r{repeat:02d}.npz", **p) + write_json(out / "repeat-metrics.json", repeat_metrics) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["checkpoint_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"model-{step:06d}.pt", + ) + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["common_atomic"]["accuracy"], + "train": metrics["train_composite"]["accuracy"], + "test": metrics["familiar_test"]["accuracy"], + } + ), + flush=True, + ) + return row + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize() + started = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - started + loss = float(loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite training loss at {step}") + endpoint = measure(loss) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + result = { + "spec": spec, + "source": source, + "data_sha256": digest, + "initial_model_sha256": initial_digest, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "independent_facts": sizes[0] + sizes[2], + "composition_examples": sizes[1], + "role_coverage": role_coverage(world), + "support_components": support_components(world), + "support_exposures": exposure_signature(world, counts[1]), + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "training_seconds": training_seconds, + "process_seconds": time.perf_counter() - process_start, + "supervised_tokens": step * batch * 23 // 3, + "padded_input_tokens": step * batch * 9, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device), + "tf32": True, + }, + } + write_json(out / "complete.json", result) + return result + + +def audit(out, device="cuda:0"): + out = Path(out) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + result = json.loads((out / "complete.json").read_text()) + assert file_hash(out / "latest.pt") == result["checkpoint_sha256"] + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + recorded = json.loads((out / "spec.json").read_text()) + assert saved["spec"] == result["spec"] == recorded["spec"] + assert saved["source"] == result["source"] == recorded["source"] + assert all(file_hash(path) == digest for path, digest in result["source"].items()) + spec = saved["spec"] + validate_nodes(spec) + assert "frozen_data_sha256" in spec + world = build_world(spec) + assert data_digest(world) == result["data_sha256"] == saved["data_sha256"] + assert data_digest(world) == recorded["data_sha256"] == spec["frozen_data_sha256"] + with np.load(out / "world.npz") as archived: + assert set(archived.files) == set(world) + for key, rows in world.items(): + np.testing.assert_array_equal(rows, archived[key]) + assert saved["step"] == spec["steps"] + model = construct(spec, device) + assert model_digest(model) == result["initial_model_sha256"] + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, "low", device) + compare_metrics(metrics, result["endpoint"]["metrics"]) + maximum = compare_predictions( + predictions, np.load(out / f"predictions-{spec['steps']:06d}.npz") + ) + repeat_checks = 0 + for node, repeats in result["repeat_metrics"].items(): + checkpoint = torch.load( + out / f"model-{int(node):06d}.pt", map_location=device, weights_only=False + ) + assert checkpoint["spec"] == spec and checkpoint["step"] == int(node) + model.load_state_dict(checkpoint["model"]) + for repeat, expected in repeats.items(): + actual, pred = evaluate(model, world, "low", device, int(repeat)) + compare_metrics(actual, expected) + maximum = max( + maximum, + compare_predictions( + pred, np.load(out / f"repeat-{int(node):06d}-r{int(repeat):02d}.npz") + ), + ) + repeat_checks += 1 + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == spec["steps"] * spec["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + composition_counts = exposures["stratum1"] + assert np.all(composition_counts == spec["steps"] * spec["batch_size"] // 3 // 512) + assert exposure_signature(world, composition_counts) == result["support_exposures"] + assert support_components(world) == result["support_components"] + checked = { + "frozen_data_exact": True, + "archived_world_exact": True, + "composition_complete_epochs": True, + "role_exposures_exact": True, + "passed": True, + "endpoint_tokens_exact": True, + "repeat_checks": repeat_checks, + "max_nll_difference": maximum, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "utc": utc(), + } + write_json(out / "audit.json", checked) + return checked diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/low_rank.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/low_rank.py new file mode 100644 index 0000000000000000000000000000000000000000..3a58bee0d460cb3ae042e17d22b7132b2035bd4b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/low_rank.py @@ -0,0 +1,138 @@ +"""Fully observed matrix representability; no training or editing algorithm. + +The best approximation minimizes unweighted Frobenius error over *all* entries. +It need not preserve unchanged facts exactly or prioritize requested edits. +Numerical rank uses an absolute singular-value threshold, not an exact-rank proof. +""" + +from numbers import Integral, Real +from typing import Any + +import numpy as np + + +def _matrix(value: Any, name: str = "matrix") -> np.ndarray: + """Convert a nonempty, finite, real numeric matrix to float64.""" + try: + raw = np.asarray(value) + except (TypeError, ValueError) as exc: + raise ValueError(f"{name} must be a rectangular real numeric matrix") from exc + if raw.ndim != 2 or 0 in raw.shape: + raise ValueError(f"{name} must be a nonempty two-dimensional matrix") + if raw.dtype.kind not in "iuf": + raise ValueError(f"{name} must contain real numeric values") + with np.errstate(over="ignore", invalid="ignore"): + result = raw.astype(np.float64) + if not np.isfinite(result).all(): + raise ValueError(f"{name} must contain finite float64 values") + return result + + +def _rank(value: Any, shape: tuple[int, int]) -> int: + if isinstance(value, (bool, np.bool_)) or not isinstance(value, Integral): + raise ValueError("rank must be a nonnegative integer") + if not 0 <= value <= min(shape): + raise ValueError(f"rank must be between 0 and {min(shape)}") + return int(value) + + +def _tolerance(value: Any) -> float: + if isinstance(value, (bool, np.bool_)) or not isinstance(value, Real): + raise ValueError("atol must be a finite positive real number") + value = float(value) + if not np.isfinite(value) or value <= 0: + raise ValueError("atol must be a finite positive real number") + return value + + +def numerical_rank(matrix: Any, atol: float = 1e-10) -> int: + """Count singular values strictly greater than the absolute tolerance.""" + array = _matrix(matrix) + tolerance = _tolerance(atol) + return int(np.count_nonzero(np.linalg.svd(array, compute_uv=False) > tolerance)) + + +def best_rank_approximation(matrix: Any, rank: int) -> np.ndarray: + """Return a best rank-at-most-``rank`` Frobenius approximation using SVD. + + ``rank`` may be zero and may not exceed the smaller matrix dimension. + The returned matrix is independent of the input. Tied singular values can + make the optimum nonunique; NumPy's SVD selects one such optimum. + """ + array = _matrix(matrix) + budget = _rank(rank, array.shape) + left, values, right = np.linalg.svd(array, full_matrices=False) + return (left[:, :budget] * values[:budget]) @ right[:budget, :] + + +def representation_gap(matrix: Any, rank: int, atol: float = 1e-10) -> int: + """Return max(0, numerical target rank minus the available rank budget).""" + array = _matrix(matrix) + budget = _rank(rank, array.shape) + return max(0, numerical_rank(array, atol=atol) - budget) + + +def evaluate_update(original: Any, target: Any, rank: int, atol: float = 1e-10) -> dict[str, Any]: + """Report an update's analytical optimum under a fixed total rank budget. + + ``original`` and ``target`` must have identical shapes. The target is fitted + directly, with no optimization path or restriction on the update rank. + ``squared_error_lower_bound`` is the sum of discarded squared singular + values (Eckart–Young–Mirsky); floating-point residuals may differ slightly. + + Edited entries are exactly those where original and target differ. ``atol`` + affects rank estimates only. RMSE is measured against the target separately + on edited and retained entries; an empty group is represented by ``None``. + The retained-entry metric measures collateral error at this global optimum, + not the side effects of a learned editing algorithm. + """ + before = _matrix(original, "original") + after = _matrix(target, "target") + if before.shape != after.shape: + raise ValueError("original and target must have identical shapes") + budget = _rank(rank, after.shape) + tolerance = _tolerance(atol) + with np.errstate(over="ignore", invalid="ignore"): + delta = _matrix(after - before, "target - original") + left, values, right = np.linalg.svd(after, full_matrices=False) + reconstruction = (left[:, :budget] * values[:budget]) @ right[:budget, :] + residual = reconstruction - after + edited = before != after + target_rank = int(np.count_nonzero(values > tolerance)) + gap = max(0, target_rank - budget) + error = float(np.linalg.norm(residual, ord="fro")) + lower_bound = float(np.sum(values[budget:] ** 2)) + + def group_rmse(mask: np.ndarray) -> float | None: + return float(np.linalg.norm(residual[mask]) / np.sqrt(mask.sum())) if mask.any() else None + + report = { + "rank_budget": budget, + "atol": tolerance, + "original_rank": numerical_rank(before, tolerance), + "target_rank": target_rank, + "delta_rank": numerical_rank(delta, tolerance), + "representation_gap": gap, + "representable_within_rank_tolerance": gap == 0, + "edit_count": int(edited.sum()), + "original": before.tolist(), + "target": after.tolist(), + "delta": delta.tolist(), + "reconstruction": reconstruction.tolist(), + "singular_values": values.tolist(), + "frobenius_error": error, + "squared_frobenius_error": error**2, + "squared_error_lower_bound": lower_bound, + "edited_entry_rmse": group_rmse(edited), + "retained_entry_rmse": group_rmse(~edited), + } + metrics = [ + error, + error**2, + lower_bound, + report["edited_entry_rmse"], + report["retained_entry_rmse"], + ] + if not all(value is None or np.isfinite(value) for value in metrics): + raise ValueError("matrix scale exceeds finite float64 error metrics; rescale the inputs") + return report diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/memory_reuse.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/memory_reuse.py new file mode 100644 index 0000000000000000000000000000000000000000..89520ed7649557ad7e4cfc2611ac85b8d9db8396 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/memory_reuse.py @@ -0,0 +1,469 @@ +"""Learned two-hop retrieval followed by an independently fitted memory swap. + +The pinned author implementation supplies the SwiGLU memory and GPT blocks. +Only attention Q/K are learned by the reader. Replacement facts are never used +by its optimizer, and all evaluation uses continuous intermediate states. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from llm_memory_editability import hebbian_interface as interface + +ARMS = ("ce", "aligned") + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n") + temporary.replace(path) + + +def cpu_state(model): + return {k: v.detach().cpu().clone() for k, v in model.state_dict().items()} + + +def hash_state(model, *, reader_only=False): + return interface.tensor_hash( + {k: v for k, v in model.state_dict().items() if not reader_only or ".mlp." not in k} + ) + + +def build_world(spec, seed): + """Geometry, content and held-out heads use independent local random streams.""" + n, d, j = spec["num_entities"], spec["d_model"], spec["junk_vocab_size"] + rng = np.random.default_rng(seed) + embeddings = rng.standard_normal((n + j + 1, d)).astype(np.float32) + embeddings /= np.linalg.norm(embeddings, axis=-1, keepdims=True) + mapping_a = np.arange(n + j + 1, dtype=np.int64) + mapping_b = mapping_a.copy() + mapping_a[:n] = rng.permutation(n) + for _ in range(10000): + candidate = rng.permutation(n) + if np.all(candidate != mapping_a[:n]): + mapping_b[:n] = candidate + break + else: + raise RuntimeError("Failed to draw a changed independent permutation") + order = np.random.default_rng(seed + 20000).permutation(n) + n_train = int(n * spec["train_head_fraction"]) + if not 0 < n_train <= n: + raise ValueError("Composition-training head fraction must lie in (0, 1]") + train_mask = np.zeros(n, dtype=bool) + train_mask[order[:n_train]] = True + return { + "embeddings": embeddings, + "mapping_A": mapping_a, + "mapping_B": mapping_b, + "train_mask": train_mask, + "seed": np.asarray(seed), + } + + +def data_audit(spec, world): + n, j = spec["num_entities"], spec["junk_vocab_size"] + for name in ("A", "B"): + mapping = world[f"mapping_{name}"] + assert np.array_equal(np.sort(mapping[:n]), np.arange(n)) + assert np.array_equal(mapping[n:], np.arange(n, n + j + 1)) + assert np.all(world["mapping_A"][:n] != world["mapping_B"][:n]) + np.testing.assert_allclose(np.linalg.norm(world["embeddings"], axis=-1), 1, atol=2e-7) + assert world["train_mask"].sum() == int(n * spec["train_head_fraction"]) + a, b = world["mapping_A"], world["mapping_B"] + return { + "entities": n, + "neutral_tokens": j + 1, + "A_composition_training_heads": int(world["train_mask"].sum()), + "A_composition_heldout_heads": int((~world["train_mask"]).sum()), + "changed_atomic_facts": int((a[:n] != b[:n]).sum()), + "changed_composite_answers": int((a[a[:n]] != b[b[:n]]).sum()), + "passed": True, + } + + +def make_inputs(spec, repeats, seed): + """Each head occurs once per repeat; contexts contain only neutral tokens.""" + n, j, length = spec["num_entities"], spec["junk_vocab_size"], spec["junk_length"] + rng = np.random.default_rng(seed) + keys = np.tile(np.arange(n, dtype=np.int64), repeats) + inputs = rng.integers(n, n + j, (len(keys), length + 2), dtype=np.int64) + positions = rng.integers(0, length + 1, len(keys)) + inputs[np.arange(len(keys)), positions] = keys + inputs[:, -1] = n + j + return inputs, keys + + +def new_memory(spec, init, device): + cfg = {**interface.DEFAULT_SPEC, **spec} + interface._source(cfg) + torch.manual_seed(init) + return interface._new_memory(cfg, device) + + +class TwoHopReader(torch.nn.Module): + """Two causal attention blocks with one shared, frozen fact MLP.""" + + def __init__(self, spec, embeddings, memory, init, device): + super().__init__() + interface._source(spec) + from hebbian.transformer.model import GPT, GPTConfig + + torch.manual_seed(init + 100000) + cfg = GPTConfig( + block_size=spec["junk_length"] + 2, + vocab_size=len(embeddings), + n_layer=2, + n_head=1, + n_embd=spec["d_model"], + dropout=0.0, + bias=False, + mlp_residual=False, + attn_residual=False, + use_rope=False, + no_positional_encoding=True, + mlp_norm_type="unit_rmsnorm", + attn_norm_type="rmsnorm", + lm_head_norm_type="unit_rmsnorm", + tie_embeddings=True, + freeze_value_dense_identity=True, + use_identity_mlp=True, + ) + self.gpt = GPT(cfg).to(device) + with torch.no_grad(): + self.gpt.transformer.wte.weight.copy_(torch.as_tensor(embeddings, device=device)) + self.install(memory) + self.gpt.requires_grad_(False) + for block in self.gpt.transformer.h: + block.attn.c_q.requires_grad_(True) + block.attn.c_k.requires_grad_(True) + self.scale = spec["readout_scale"] + + def install(self, memory): + memory.requires_grad_(False) + for block in self.gpt.transformer.h: + block.mlp = memory + + def forward(self, inputs): + x = self.gpt.transformer.wte(inputs) + logits = [] + for block in self.gpt.transformer.h: + x = block(x) + z = self.gpt.transformer.ln_f(x[:, -1]) + logits.append(self.scale * self.gpt.lm_head(z)) + return torch.stack(logits, dim=1) + + +def memory_objective(output, embeddings, labels, arm, alignment_weight): + ce = F.cross_entropy(output @ embeddings.T, labels) + alignment = (output - embeddings[labels]).square().sum(-1).mean() + return ce + (alignment_weight if arm == "aligned" else 0.0) * alignment + + +@torch.no_grad() +def clean_memory(memory, embeddings, mapping, n): + output = memory(embeddings) + cosine = F.normalize(output, dim=-1) @ embeddings.T + pred = cosine.argmax(-1) + return { + "atomic_accuracy": float(pred[:n].eq(mapping[:n]).float().mean()), + "neutral_accuracy": float(pred[n:].eq(mapping[n:]).float().mean()), + "target_cosine": float(cosine[torch.arange(n, device=mapping.device), mapping[:n]].mean()), + "output_norm": float(output[:n].norm(dim=-1).mean()), + "vector_squared_error": float( + (output[:n] - embeddings[mapping[:n]]).square().sum(-1).mean() + ), + } + + +def fit_memory(spec, world, mapping_name, arm, init, device, output_dir): + """Only atomic labels appear here, including for the replacement memory.""" + path = output_dir / f"memory-{mapping_name}.pt" + if path.exists(): + payload = torch.load(path, map_location="cpu", weights_only=True) + model = new_memory(spec, init, device) + model.load_state_dict(payload["state_dict"]) + record = dict(payload["record"], reused_checkpoint=True) + return model.requires_grad_(False).eval(), record + memory = new_memory(spec, init, device) + embeddings = torch.as_tensor(world["embeddings"], device=device) + labels = torch.as_tensor(world[f"mapping_{mapping_name}"], device=device) + optimizer = torch.optim.Adam(memory.parameters(), lr=spec["memory_lr"], foreach=False) + scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( + optimizer, spec["memory_steps"], eta_min=spec["memory_min_lr"] + ) + initial_hash = hash_state(memory) + curve = [] + began = time.perf_counter() + for step in range(spec["memory_steps"] + 1): + if step in spec["memory_nodes"]: + metrics = clean_memory(memory, embeddings, labels, spec["num_entities"]) + metrics.update(step=step, seconds=time.perf_counter() - began) + curve.append(metrics) + write_json(output_dir / f"memory-{mapping_name}-curve.json", curve) + print(json.dumps(dict(stage=f"memory-{mapping_name}", arm=arm, **metrics)), flush=True) + if step == spec["memory_steps"]: + break + memory.train() + optimizer.zero_grad(set_to_none=True) + loss = memory_objective( + memory(embeddings), embeddings, labels, arm, spec["alignment_weight"] + ) + loss.backward() + optimizer.step() + scheduler.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + memory.eval().requires_grad_(False) + record = dict( + initial_hash=initial_hash, + final_hash=hash_state(memory), + steps=spec["memory_steps"], + seconds=time.perf_counter() - began, + metrics=clean_memory(memory, embeddings, labels, spec["num_entities"]), + ) + torch.save(dict(state_dict=cpu_state(memory), record=record), path) + return memory, record + + +@torch.no_grad() +def evaluate(reader, inputs, device, batch_size): + reader.eval() + return np.concatenate( + [ + reader(torch.as_tensor(inputs[start : start + batch_size], device=device)).cpu().numpy() + for start in range(0, len(inputs), batch_size) + ] + ) + + +def accuracy(pred, target, mask=None): + correct = pred == target + if mask is not None: + correct = correct[mask] + return float(correct.mean()) if len(correct) else None + + +def score_logits(logits, world, keys, mapping_name): + """Full-pool scores and explicitly labelled prerequisite/changed subsets.""" + pred = logits.argmax(-1) + mapping = world[f"mapping_{mapping_name}"] + y1, y2 = mapping[keys], mapping[mapping[keys]] + train = world["train_mask"][keys] + a, b = world["mapping_A"], world["mapping_B"] + changed = a[a[keys]] != b[b[keys]] + n = len(world["train_mask"]) + # Inputs are arranged as complete n-head repeats; find each actual successor. + successor_row = np.arange(len(keys)) // n * n + mapping[keys] + assert np.array_equal(keys[successor_row], mapping[keys]) + known = (pred[:, 0] == y1) & (pred[successor_row, 0] == mapping[mapping[keys]]) + return { + "n": len(keys), + "one_hop": accuracy(pred[:, 0], y1), + "two_hop": accuracy(pred[:, 1], y2), + "two_hop_A_training_heads": accuracy(pred[:, 1], y2, train), + "two_hop_A_heldout_heads": accuracy(pred[:, 1], y2, ~train), + "two_hop_changed": accuracy(pred[:, 1], y2, changed), + "changed_n": int(changed.sum()), + "two_hop_both_atoms_correct": accuracy(pred[:, 1], y2, known), + "both_atoms_correct_n": int(known.sum()), + "both_atoms_correct_coverage": float(known.mean()), + } + + +def reader_loss(logits, targets, train_mask): + return ( + F.cross_entropy(logits[:, 0], targets[:, 0]) + + F.cross_entropy(logits[train_mask, 1], targets[train_mask, 1]) + ) / 2 + + +def fit_reader(spec, world, memory, init, device, output_dir): + reader = TwoHopReader(spec, world["embeddings"], memory, init, device) + path = output_dir / "reader-A.pt" + if path.exists(): + payload = torch.load(path, map_location="cpu", weights_only=True) + reader.load_state_dict(payload["state_dict"]) + return reader.eval(), payload["record"] + initial_hash = hash_state(reader, reader_only=True) + frozen_before = interface.tensor_hash( + {k: p for k, p in reader.named_parameters() if not p.requires_grad} + ) + n = spec["num_entities"] + seed = int(world["seed"]) + train_inputs, _ = make_inputs(spec, spec["reader_steps"], seed + 30000) + stream_hash = hashlib.sha256(train_inputs.tobytes()).hexdigest() + train_inputs = torch.as_tensor( + train_inputs.reshape(-1, n, spec["junk_length"] + 2), device=device + ) + mapping = torch.as_tensor(world["mapping_A"], device=device) + targets = torch.stack((mapping[:n], mapping[mapping[:n]]), dim=1) + train_mask = torch.as_tensor(world["train_mask"], device=device) + eval_inputs, eval_keys = make_inputs(spec, spec["eval_repeats"], seed + 40000) + parameters = [p for p in reader.parameters() if p.requires_grad] + optimizer = torch.optim.AdamW( + parameters, lr=spec["reader_lr"], weight_decay=spec["reader_weight_decay"], foreach=False + ) + curve = [] + began = time.perf_counter() + for step in range(spec["reader_steps"] + 1): + if step in spec["reader_nodes"]: + logits = evaluate(reader, eval_inputs, device, n) + metrics = score_logits(logits, world, eval_keys, "A") + curve.append(dict(step=step, seconds=time.perf_counter() - began, **metrics)) + np.savez_compressed(output_dir / f"reader-node-{step:05d}.npz", logits=logits) + torch.save(cpu_state(reader), output_dir / f"reader-node-{step:05d}.pt") + write_json(output_dir / "reader-curve.json", curve) + print(json.dumps(dict(stage="reader", step=step, **metrics)), flush=True) + if step == spec["reader_steps"]: + break + reader.train() + optimizer.zero_grad(set_to_none=True) + loss = reader_loss(reader(train_inputs[step]), targets, train_mask) + loss.backward() + optimizer.step() + if device.type == "cuda": + torch.cuda.synchronize(device) + frozen_after = interface.tensor_hash( + {k: p for k, p in reader.named_parameters() if not p.requires_grad} + ) + assert frozen_before == frozen_after, "Frozen facts or embeddings changed" + record = dict( + initial_hash=initial_hash, + final_hash=hash_state(reader, reader_only=True), + frozen_hash=frozen_after, + stream_hash=stream_hash, + steps=spec["reader_steps"], + seconds=time.perf_counter() - began, + trainable_names=[k for k, p in reader.named_parameters() if p.requires_grad], + trainable_parameters=sum(p.numel() for p in parameters), + total_parameters=sum(p.numel() for p in reader.parameters()), + metrics=curve[-1], + ) + torch.save(dict(state_dict=cpu_state(reader), record=record), path) + return reader.eval(), record + + +def run(spec, world_seed, init, arm, output_dir, device): + if arm not in ARMS: + raise ValueError(arm) + output_dir = Path(output_dir) + output_dir.mkdir(parents=True, exist_ok=True) + device = torch.device(device) + torch.set_num_threads(spec["cpu_threads"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + if device.type == "cuda": + torch.cuda.set_device(device) + torch.cuda.reset_peak_memory_stats(device) + world = build_world(spec, world_seed) + np.savez_compressed(output_dir / "world.npz", **world) + write_json(output_dir / "spec.json", spec) + audit = data_audit(spec, world) + started = time.perf_counter() + result = dict( + world=world_seed, init=init, arm=arm, spec=spec, data_audit=audit, status="running" + ) + write_json(output_dir / "status.json", result) + memory_a, a_record = fit_memory(spec, world, "A", arm, init, device, output_dir) + reader, reader_record = fit_reader(spec, world, memory_a, init, device, output_dir) + # Replacement fitting happens only after the A reader has finished. + memory_b, b_record = fit_memory(spec, world, "B", arm, init, device, output_dir) + inputs, keys = make_inputs(spec, spec["eval_repeats"], world_seed + 40000) + logits_a = evaluate(reader, inputs, device, spec["num_entities"]) + non_memory_hash = hash_state(reader, reader_only=True) + reader.requires_grad_(False) + reader.install(memory_b) + logits_b = evaluate(reader, inputs, device, spec["num_entities"]) + assert hash_state(reader, reader_only=True) == non_memory_hash + assert reader.gpt.transformer.h[0].mlp is reader.gpt.transformer.h[1].mlp + assert hash_state(memory_b) == b_record["final_hash"] + embeddings = torch.as_tensor(world["embeddings"], device=device) + with torch.no_grad(): + memory_arrays = { + f"memory_{name}_output": mem(embeddings).cpu().numpy() + for name, mem in (("A", memory_a), ("B", memory_b)) + } + np.savez_compressed( + output_dir / "endpoints.npz", + inputs=inputs, + keys=keys, + logits_A=logits_a, + logits_B=logits_b, + **memory_arrays, + ) + # Store a full swapped endpoint to permit a genuinely independent reload. + torch.save(dict(state_dict=cpu_state(reader)), output_dir / "reader-B.pt") + endpoints = { + "A": score_logits(logits_a, world, keys, "A"), + "B": score_logits(logits_b, world, keys, "B"), + "wrong_A_on_B": score_logits(logits_a, world, keys, "B"), + } + length, d, h, vocab = ( + spec["junk_length"] + 2, + spec["d_model"], + spec["hidden_dim"], + len(embeddings), + ) + # Approximate multiply-add FLOPs. Backprop through frozen MLP still costs work. + memory_flops = 2 * spec["memory_steps"] * (18 * vocab * d * h + 6 * vocab**2 * d) + reader_flops = spec["reader_steps"] * ( + 2 + * ( + 24 * spec["num_entities"] * length * d**2 + + 12 * spec["num_entities"] * length**2 * d + + 12 * spec["num_entities"] * length * d * h + ) + ) + result.update( + status="complete", + memories=dict(A=a_record, B=b_record), + reader=reader_record, + endpoints=endpoints, + assertions=dict( + frozen_reader_after_swap=True, shared_memory=True, no_B_reader_training=True + ), + seconds=time.perf_counter() - started, + budget=dict( + memory_updates=sum( + spec["memory_steps"] + for r in (a_record, b_record) + if not r.get("reused_checkpoint", False) + ), + reused_memory_updates=sum( + spec["memory_steps"] + for r in (a_record, b_record) + if r.get("reused_checkpoint", False) + ), + reader_updates=spec["reader_steps"], + atomic_exposures=sum( + spec["memory_steps"] * spec["num_entities"] + for r in (a_record, b_record) + if not r.get("reused_checkpoint", False) + ), + reader_input_tokens=spec["reader_steps"] * spec["num_entities"] * length, + reader_supervised_answers=spec["reader_steps"] + * (spec["num_entities"] + int(world["train_mask"].sum())), + approximate_matmul_flops=reader_flops + + memory_flops + * sum(not r.get("reused_checkpoint", False) for r in (a_record, b_record)) + / 2, + peak_gpu_bytes=torch.cuda.max_memory_allocated(device) if device.type == "cuda" else 0, + ), + ) + write_json(output_dir / "summary.json", result) + write_json(output_dir / "status.json", dict(status="complete", seconds=result["seconds"])) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/multihop_scaling.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/multihop_scaling.py new file mode 100644 index 0000000000000000000000000000000000000000..64b5a3d67ef6bab20c60904e626e811876d72279 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/multihop_scaling.py @@ -0,0 +1,518 @@ +"""Width, composition experience and compute depth in complete causal GPT models. + +The data, full-token objective and generation scoring extend ``depth_step``. +Support arms use nested training paths and identical held-out evaluation pools; +four independent streams keep atomics and each hop length at 32 draws per step. +""" + +from __future__ import annotations + +import copy +import hashlib +import json +import time +from functools import lru_cache +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from . import depth_step +from .depth_step import ( # noqa: F401 -- public interface reused by checkpoint analysis + BOS, + DATA_DEFAULTS, + ENTITY_OFFSET, + EOS, + EVALUATION_SPLITS, + HOPS, + PAD, + TRAIN_SPLITS, + compare_metrics, + compare_predictions, + construct, + data_digest, + evaluate, + generate_rows, + pack_rows, + prompt_rows, + truth_path_details, +) +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import flops +from .latent_scaling import model_digest +from .storage_composition import FullTokenStep, file_hash +from .storage_frontier import learning_rate + +SUPPORT_LEVELS = (1.0, 4.0) +ARCHITECTURES = ((2, 1), (4, 1), (1, 2), (1, 4)) +COMMON_SPLITS = ("atomic",) + tuple( + f"{split}_{hop}" for hop in HOPS for split in ("familiar", "strict") +) +SOURCE_FILES = [ + *depth_step.SOURCE_FILES, + "src/llm_memory_editability/multihop_scaling.py", + "scripts/run_multihop_scaling.py", + "scripts/execute_multihop_scaling.py", + "tests/test_multihop_scaling.py", +] + + +@lru_cache(maxsize=16) +def _reference_world(seed, settings): + return depth_step.build_world({"world_seed": seed, **dict(settings), "phi": 4.0}) + + +def _reference(spec): + seed = spec.get("world_seed", spec.get("world")) + if seed is None: + raise ValueError("A fixed world_seed is required") + settings = tuple( + (key, spec.get(key, value)) for key, value in DATA_DEFAULTS.items() if key != "phi" + ) + return _reference_world(int(seed), settings) + + +def common_evaluation_digest(world): + digest = hashlib.sha256() + for name in COMMON_SPLITS: + rows = world[name] + digest.update(name.encode()) + digest.update(np.asarray(rows.shape, dtype=" len(reference[name]), + "prefix_indices": list(range(count)), + } + # Preserve source lineage without duplicating descriptive source statistics. + metadata["source_worlds"] = { + hop: { + key: values[key] + for key in ( + "seed", + "hops", + "dataset_sha256", + "counts", + "phi_requested", + "phi_actual", + "train_composite_capped", + "id_paths_total", + "all_paths_total", + "source_url", + "source_commit", + "source_file", + "source_license", + ) + } + for hop, values in metadata["source_worlds"].items() + } + metadata.update( + phi=phi, + reference_phi=4.0, + reference_dataset_sha256=reference["metadata"]["dataset_sha256"], + composition_support=selections, + support_selection="Prefix of each phi=4 training array; no resampling of facts or tests", + exposure_contract="32 atomic + 32 each of 2/3/4-hop examples per step", + training_objective="All nonpadding next tokens including EOS; no intermediate targets", + ) + world["metadata"] = metadata + metadata["common_evaluation_sha256"] = common_evaluation_digest(world) + checked = audit_world(world) + metadata["dataset_sha256"] = checked["dataset_sha256"] + metadata["independent_audit"] = checked + expected = spec.get("frozen_data_sha256") + if expected is not None and expected != checked["dataset_sha256"]: + raise ValueError("Rebuilt data differ from the frozen specification") + expected_common = spec.get("common_evaluation_sha256") + if expected_common is not None and expected_common != metadata["common_evaluation_sha256"]: + raise ValueError("Common evaluation pools differ from the frozen specification") + return world + + +def audit_world(world): + checked = depth_step.audit_world(world) + metadata = world["metadata"] + phi = metadata["phi"] + if phi not in SUPPORT_LEVELS or metadata.get("reference_phi") != 4.0: + raise ValueError("Invalid nested support contract") + reference = _reference(metadata) + ids = sum(metadata["id_mask"]) + for name in EVALUATION_SPLITS: + expected = reference[name] + if name.startswith("train_"): + expected = expected[: min(round(phi * ids), len(expected))] + if not np.array_equal(world[name], expected): + raise ValueError("Common pools/nested support differ from reference: " + name) + common = common_evaluation_digest(world) + if common != metadata["common_evaluation_sha256"]: + raise ValueError("Common evaluation digest differs") + if reference["metadata"]["dataset_sha256"] != metadata["reference_dataset_sha256"]: + raise ValueError("High-support reference differs") + return { + **checked, + "low_support_is_high_support_prefix": True, + "same_atomic_id_ood_and_heldout_pools_across_support": True, + "common_evaluation_sha256": common, + } + + +def run_name(spec): + seed = spec.get("world_seed", spec.get("world")) + return ( + f"w{seed}-i{spec['initialization']}-d{spec['width']}-phi{spec['phi']:g}" + f"-l{spec['layers']}-r{spec['repeats']}-s{spec['steps']}" + ) + + +def _validate_spec(spec): + depth_step._validate_spec(spec) + if float(spec["phi"]) not in SUPPORT_LEVELS: + raise ValueError("Unsupported composition support") + if (spec["layers"], spec["repeats"]) not in ARCHITECTURES: + raise ValueError("Unsupported architecture") + + +def _check_source(source): + depth_step._check_source(source) + required = {"src/llm_memory_editability/multihop_scaling.py", *depth_step.SOURCE_FILES} + if not required <= set(source): + raise RuntimeError("Source lock omits experiment dependencies") + + +def _validate_output(out): + depth_step._validate_output(out) + + +def _device_setup(device): + device = torch.device(device) + torch.set_num_threads(1) + # Standalone workers call this once; CPU integration checks may call twice. + try: + torch.set_num_interop_threads(1) + except RuntimeError: + pass + if device.type == "cuda": + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + return device + + +class _CpuStep: + """Same objective and optimizer groups for inexpensive engineering checks.""" + + def __init__(self, model, optimizer, table, clip): + self.model, self.optimizer, self.table, self.clip = model, optimizer, table, clip + + def __call__(self, indices): + self.optimizer.zero_grad(set_to_none=True) + tokens, labels = (part[indices] for part in self.table) + logits = self.model(tokens) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + loss.backward() + torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss.detach() + + +def _synchronize(device): + if device.type == "cuda": + torch.cuda.synchronize(device) + + +def train(spec, out, source, device="cuda:0"): + _validate_spec(spec) + _check_source(source) + if "frozen_data_sha256" not in spec or "common_evaluation_sha256" not in spec: + raise ValueError("Training requires frozen data and common evaluation hashes") + out = Path(out) + _validate_output(out) + out.mkdir(parents=True, exist_ok=True) + device = _device_setup(device) + started_process = time.perf_counter() + world = build_world(spec) + digest = data_digest(world) + depth_step._save_world(out, world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_digest = model_digest(model) + if spec.get("initial_model_sha256", initial_digest) != initial_digest: + raise AssertionError("Frozen initialization differs") + lr = torch.tensor(spec["lr"], device=device) + if device.type == "cuda": + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + else: + optimizer = torch.optim.AdamW( + [ + { + "params": [p for p in model.parameters() if p.ndim >= 2], + "weight_decay": spec["weight_decay"], + }, + {"params": [p for p in model.parameters() if p.ndim < 2], "weight_decay": 0.0}, + ], + lr=lr, + betas=(0.9, 0.999), + eps=1e-8, + ) + sizes = [len(world[name]) for name in TRAIN_SPLITS] + if any(size == 0 for size in sizes): + raise ValueError("Do not reroll a world with an empty sampled training stratum") + packed = [ + pack_rows(world[name], separator=world["metadata"]["separator_token"]) + for name in TRAIN_SPLITS + ] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) for parts in zip(*packed, strict=True) + ) + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + if device.type == "cuda": + graph = FullTokenStep( + model, optimizer, table, spec["batch_size"], clip=spec.get("clip", 1.0) + ) + else: + graph = _CpuStep(model, optimizer, table, spec.get("clip", 1.0)) + flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 8, output_positions=8) + token_step = 32 * sum(int((labels[0] >= 0).sum()) for _, labels in packed) + history, step, training_seconds = [], 0, 0.0 + + def measure(loss=None): + metrics, predictions = evaluate(model, world, device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0.0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + "supervised_tokens": step * token_step, + "padded_input_tokens": step * spec["batch_size"] * 8, + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + np.savez_compressed( + out / f"exposures-{step:06d}.npz", + **dict(zip(TRAIN_SPLITS, counts, strict=True)), + ) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [s.state_dict() for s in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device) if device.type == "cuda" else None, + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + if step in spec["checkpoint_nodes"]: + torch.save( + {"spec": spec, "step": step, "model": model.state_dict()}, + out / f"model-{step:06d}.pt", + ) + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["atomic"]["accuracy"], + "familiar": {str(hop): metrics[f"familiar_{hop}"]["accuracy"] for hop in HOPS}, + } + ), + flush=True, + ) + return row + + measure() + endpoint = history[0] + for end in spec["nodes"][1:]: + _synchronize(device) + started = time.perf_counter() + while step < end: + updates = min(128, end - step) + indices = [] + for i, stream in enumerate(streams): + draws = stream.take(updates * 32).reshape(updates, 32) + counts[i] += np.bincount(draws.ravel(), minlength=sizes[i]) + indices.append(draws + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(updates): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += updates + _synchronize(device) + training_seconds += time.perf_counter() - started + loss_value = float(loss) + if not np.isfinite(loss_value): + raise FloatingPointError("Nonfinite loss at step " + str(step)) + endpoint = measure(loss_value) + np.savez_compressed(out / "exposures.npz", **dict(zip(TRAIN_SPLITS, counts, strict=True))) + result = { + "spec": spec, + "source": source, + "data_sha256": digest, + "common_evaluation_sha256": world["metadata"]["common_evaluation_sha256"], + "initial_model_sha256": initial_digest, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "architecture": "loop" if spec["repeats"] > 1 else "standard", + "effective_depth": spec["layers"] * spec["repeats"], + "strata_counts": dict(zip(TRAIN_SPLITS, sizes, strict=True)), + "endpoint": endpoint, + "supervised_tokens": step * token_step, + "padded_input_tokens": step * spec["batch_size"] * 8, + "estimated_training_flops": step * flop_step, + "training_seconds": training_seconds, + "process_seconds": time.perf_counter() - started_process, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "device": str(device), + "gpu": torch.cuda.get_device_name(device) if device.type == "cuda" else None, + "tf32": device.type == "cuda", + }, + } + write_json(out / "complete.json", result) + return result + + +def audit(out, device="cuda:0"): + out = Path(out) + if (out / "audit.json").exists(): + raise FileExistsError(out / "audit.json") + device = _device_setup(device) + result = json.loads((out / "complete.json").read_text()) + recorded = json.loads((out / "spec.json").read_text()) + source, spec = result["source"], result["spec"] + _check_source(source) + _validate_spec(spec) + if recorded["spec"] != spec or recorded["source"] != source: + raise AssertionError("Recorded specification/source differ") + if file_hash(out / "latest.pt") != result["checkpoint_sha256"]: + raise AssertionError("Latest checkpoint hash differs") + world = build_world(spec) + digest = data_digest(world) + if digest != result["data_sha256"] or digest != recorded["data_sha256"]: + raise AssertionError("Rebuilt data differ from records") + if result["common_evaluation_sha256"] != common_evaluation_digest(world): + raise AssertionError("Common evaluation identity differs") + if json.loads((out / "world-metadata.json").read_text()) != world["metadata"]: + raise AssertionError("Archived world metadata differ") + with np.load(out / "world.npz") as archived: + if set(archived.files) != set(EVALUATION_SPLITS): + raise AssertionError("Archived world keys differ") + for name in EVALUATION_SPLITS: + np.testing.assert_array_equal(archived[name], world[name]) + model = construct(spec, device) + if model_digest(model) != result["initial_model_sha256"]: + raise AssertionError("Paired initialization differs") + history = json.loads((out / "learning.json").read_text()) + if [row["step"] for row in history] != spec["nodes"]: + raise AssertionError("Recorded learning nodes differ") + by_node = {row["step"]: row for row in history} + if by_node[spec["steps"]] != result["endpoint"]: + raise AssertionError("Endpoint differs from the learning curve") + maximum = 0.0 + for node in spec["checkpoint_nodes"]: + checkpoint = torch.load( + out / f"model-{node:06d}.pt", map_location=device, weights_only=False + ) + if checkpoint["spec"] != spec or checkpoint["step"] != node: + raise AssertionError("Checkpoint specification/node differ") + model.load_state_dict(checkpoint["model"]) + metrics, predictions = evaluate(model, world, device) + compare_metrics(metrics, by_node[node]["metrics"]) + maximum = max( + maximum, compare_predictions(predictions, out / f"predictions-{node:06d}.npz") + ) + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + if ( + saved["spec"] != spec + or saved["source"] != source + or saved["step"] != spec["steps"] + or saved["data_sha256"] != digest + ): + raise AssertionError("Latest state identity differs") + sizes = [len(world[name]) for name in TRAIN_SPLITS] + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + previous = 0 + for node in spec["nodes"]: + for i, stream in enumerate(streams): + draws = ( + stream.take((node - previous) * 32) + if node > previous + else np.empty(0, dtype=np.int64) + ) + counts[i] += np.bincount(draws, minlength=sizes[i]) + with np.load(out / f"exposures-{node:06d}.npz") as actual: + if set(actual.files) != set(TRAIN_SPLITS): + raise AssertionError("Exposure strata differ") + for name, count in zip(TRAIN_SPLITS, counts, strict=True): + np.testing.assert_array_equal(actual[name], count) + row = by_node[node] + if row["supervised_tokens"] != node * 832 or row["padded_input_tokens"] != node * 1024: + raise AssertionError("Token accounting differs") + previous = node + with np.load(out / "exposures.npz") as actual: + for i, (name, count) in enumerate(zip(TRAIN_SPLITS, counts, strict=True)): + np.testing.assert_array_equal(actual[name], count) + np.testing.assert_array_equal(saved["counts"][i], count) + if count.sum() != spec["steps"] * 32 or np.ptp(count) > 1: + raise AssertionError("EpochStream actual exposures are unbalanced") + stream = EpochStream(sizes[i], spec["stream_seed"] + i) + stream.load_state_dict(saved["streams"][i]) + np.testing.assert_array_equal(stream.take(32), streams[i].take(32)) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, device) + compare_metrics(metrics, result["endpoint"]["metrics"]) + maximum = max( + maximum, compare_predictions(predictions, out / f"predictions-{spec['steps']:06d}.npz") + ) + checked = { + "passed": True, + "dataset_rebuilt_and_archived_exact": True, + "nested_support_and_common_pools_checked": True, + "initial_model_exact": True, + "checkpoint_nodes": spec["checkpoint_nodes"], + "endpoint_tokens_exact": True, + "all_nodes_exposure_counters_exact": True, + "stream_state_continuation_exact": True, + "max_nll_difference": maximum, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "utc": utc(), + } + write_json(out / "audit.json", checked) + return checked diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation.py new file mode 100644 index 0000000000000000000000000000000000000000..dc9608e59339683c91de69b2f1f392b93b8f0171 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation.py @@ -0,0 +1,687 @@ +"""Full-Qwen, nested compositional support with matched atomic supervision.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import platform +import shutil +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch +import torch.nn.functional as F +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +from . import small_lm_composition as base + +FIRST = ("mentor", "advisor") +SECOND = ("live", "birth") +STRICT_CITIES = ( + "Athens Prague Havana Tunis Perth Zurich Bristol Munich " + "Tallinn Riga Quito Dakar Nairobi Accra Calgary Warsaw" +).split() +ROOT = Path("docs/development-artifacts/natural-composition-confirmation-v1") + + +def sha(path): + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def write(path, value): + base.write(path, value) + + +def build_world(seed): + rng = np.random.default_rng(seed) + first_names = ( + "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo" + ).split() + names = [ + f"{a} {b}" + for a in first_names + for b in "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split() + ] + names = rng.permutation(names).tolist() + atoms, chains = [], [] + for pool, offset, cities in (("familiar", 0, base.CITIES), ("strict", 32, STRICT_CITIES)): + heads, bridges = names[offset : offset + 16], names[offset + 16 : offset + 32] + mappings = [rng.permutation(16).tolist()] + mappings.append(np.roll(mappings[0], int(rng.integers(1, 16))).tolist()) + city_maps = [rng.permutation(cities).tolist()] + city_maps.append(np.roll(city_maps[0], int(rng.integers(1, 16))).tolist()) + ids = {} + for j, head in enumerate(heads): + for r, relation in enumerate(FIRST): + atom = dict( + id=len(atoms), + pool=pool, + role="first", + subject=head, + relation=relation, + answer=bridges[mappings[r][j]], + ) + atoms.append(atom) + ids["first", j, r] = atom["id"] + for j, bridge in enumerate(bridges): + for s, relation in enumerate(SECOND): + atom = dict( + id=len(atoms), + pool=pool, + role="second", + subject=bridge, + relation=relation, + answer=city_maps[s][j], + ) + atoms.append(atom) + ids["second", j, s] = atom["id"] + for j, head in enumerate(heads): + for r, first in enumerate(FIRST): + for s, second in enumerate(SECOND): + bridge_index = mappings[r][j] + chains.append( + dict( + id=len(chains), + pool=pool, + head_index=j, + head=head, + bridge=bridges[bridge_index], + first=first, + second=second, + answer=city_maps[s][bridge_index], + atom_ids=[ids["first", j, r], ids["second", bridge_index, s]], + split="strict" + if pool == "strict" + else ("support" if r == s else "heldout"), + ) + ) + return dict( + seed=seed, + atoms=atoms, + chains=chains, + high_support=[c["id"] for c in chains if c["split"] == "support"], + low_support=[c["id"] for c in chains if c["split"] == "support" and c["head_index"] < 4], + ) + + +def question(row, variant=0, atomic=False): + if atomic: + subject, relation = row["subject"], row["relation"] + if row["role"] == "first": + templates = ( + "Who is {subject}'s {relation}?", + "Who is the {relation} of {subject}?", + "Name the {relation} of {subject}.", + "Give the name of {subject}'s {relation}.", + "Give the name of the person serving as {subject}'s {relation}.", + ) + elif relation == "live": + templates = ( + "Which city does {subject} live in?", + "What city is {subject}'s home?", + "Where does {subject} live?", + "Name the city where {subject} lives.", + "In which city is {subject} living?", + ) + else: + templates = ( + "Which city was {subject} born in?", + "What is {subject}'s birth city?", + "Where was {subject} born?", + "Name the city where {subject} was born.", + "In which city did {subject}'s birth take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + subject = row["head"] + relation = row["first"] + if row["second"] == "live": + templates = ( + "Which city does {subject}'s {relation} live in?", + "What city is home to {subject}'s {relation}?", + "Where does the {relation} of {subject} live?", + "Name the city where {subject}'s {relation} lives.", + "In which city is the person serving as {subject}'s {relation} living?", + ) + else: + templates = ( + "Which city was {subject}'s {relation} born in?", + "What is the birth city of {subject}'s {relation}?", + "Where was the {relation} of {subject} born?", + "Name the city where {subject}'s {relation} was born.", + "In which city did the birth of {subject}'s {relation} take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + + +def prompt(row, variant=0, atomic=False): + return "Fictional registry.\nQuestion: " + question(row, variant, atomic) + "\nAnswer:" + + +def record(tokenizer, row, variant, atomic): + # Joint text tokenization, exactly as in the calibrated full-Qwen v2 recipe. + ids = tokenizer.encode( + prompt(row, variant, atomic) + " " + row["answer"] + ".", add_special_tokens=False + ) + [tokenizer.eos_token_id] + return dict( + ids=ids, + labels=[-100, *ids[1:]], + id=row["id"], + kind="atomic" if atomic else "composition", + variant=variant, + ) + + +def streams(world, cfg): + rng = np.random.default_rng(cfg["training_seed"]) + atomic_order, comp_order = [], {a: [] for a in cfg["arms"]} + batches = {a: [] for a in cfg["arms"]} + for _ in range(cfg["steps"]): + if len(atomic_order) < cfg["atomic_per_step"]: + atomic_order.extend(rng.permutation(len(world["atoms"])).tolist()) + atomic = [ + [int(atomic_order.pop(0)), int(rng.integers(4))] for _ in range(cfg["atomic_per_step"]) + ] + variants = rng.integers(4, size=cfg["compositions_per_step"]).tolist() + for arm in cfg["arms"]: + support = world[arm + "_support"] + if len(comp_order[arm]) < cfg["compositions_per_step"]: + comp_order[arm].extend(rng.permutation(support).tolist()) + comp = [[int(comp_order[arm].pop(0)), int(v)] for v in variants] + batches[arm].append(dict(atomic=atomic, composition=comp)) + return batches + + +def records(tokenizer, world): + return { + kind: { + (r["id"], v): record(tokenizer, r, v, kind == "atomic") + for r in world["atoms" if kind == "atomic" else "chains"] + for v in range(4) + } + for kind in ("atomic", "composition") + } + + +def docs_for(rec, batch): + return [rec[kind][tuple(spec)] for kind in ("atomic", "composition") for spec in batch[kind]] + + +def audit(world, batches, rec): + assert ( + len(world["atoms"]) == 128 + and len(world["high_support"]) == 32 + and len(world["low_support"]) == 8 + ) + assert set(world["low_support"]) < set(world["high_support"]) + familiar_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "familiar"} + covered = {i for j in world["high_support"] for i in world["chains"][j]["atom_ids"]} + assert covered == familiar_atoms + strict_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "strict"} + assert not covered & strict_atoms + support = [world["chains"][i] for i in world["high_support"]] + heldout = [c for c in world["chains"] if c["split"] == "heldout"] + strict = [c for c in world["chains"] if c["split"] == "strict"] + assert len(heldout) == 32 and len(strict) == 64 + # No alternate trained query gives the same head/answer endpoint as a held-out chain. + assert not {(c["head"], c["answer"]) for c in support} & { + (c["head"], c["answer"]) for c in heldout + } + + def people(pool): + return {a["subject"] for a in world["atoms"] if a["pool"] == pool} + + assert not people("familiar") & people("strict") + assert not {c["answer"] for c in support} & {c["answer"] for c in strict} + budgets, exposure = {}, {} + for arm, stream in batches.items(): + budget, atomic_counts, comp_counts = Counter(), Counter(), Counter() + for batch in stream: + docs = docs_for(rec, batch) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + atomic_counts.update(i for i, _ in batch["atomic"]) + comp_counts.update(i for i, _ in batch["composition"]) + assert set(comp_counts) <= set(world[arm + "_support"]) + budgets[arm] = dict(budget) + exposure[arm] = dict( + atomic=sorted(atomic_counts.items()), composition=sorted(comp_counts.items()) + ) + if "low" in batches and "high" in batches: + assert [b["atomic"] for b in batches["low"]] == [b["atomic"] for b in batches["high"]] + assert exposure["low"]["atomic"] == exposure["high"]["atomic"] + return dict( + status="passed", + budgets=budgets, + exposures=exposure, + familiar_fact_role_coverage_high=len(covered), + familiar_fact_role_coverage_low=len( + {i for j in world["low_support"] for i in world["chains"][j]["atom_ids"]} + ), + heldout_queries=len(heldout), + strict_queries=len(strict), + target_endpoint_leakage=0, + exact_common_atomic_sequence=True, + exact_atomic_stream_loss_weight=True, + composition_slots_equal=True, + ) + + +def freeze(config_path): + cfg = base.read(config_path) + art = Path(cfg["artifact_root"]) + assert not (art / "lock.json").exists(), "Preserve frozen batch." + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + sources = [ + str(config_path), + "src/llm_memory_editability/natural_composition_confirmation.py", + "src/llm_memory_editability/small_lm_composition.py", + "scripts/run_natural_composition_confirmation.py", + "tests/test_natural_composition_confirmation.py", + "docs/development-artifacts/natural-composition-confirmation-v1/design.md", + ] + source_hashes = {} + for source in sources: + dest = art / "source" / source + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, dest) + source_hashes[source] = sha(source) + data_files = {} + for seed in cfg["world_seeds"]: + world = build_world(seed) + batch = streams(world, cfg) + report = audit(world, batch, records(tokenizer, world)) + for filename, obj in ( + ("world.json", world), + ("streams.json", batch), + ("data-audit.json", report), + ): + path = art / f"w{seed}" / filename + write(path, obj) + data_files[str(path)] = sha(path) + model_files = { + str(p): sha(p) + for p in Path(cfg["model_path"]).iterdir() + if p.suffix in (".json", ".safetensors") or p.name in ("LICENSE", "README.md") + } + write( + art / "environment.json", + dict( + python=platform.python_version(), + executable=str(Path(__import__("sys").executable)), + torch=torch.__version__, + transformers=transformers.__version__, + gpu_inventory=__import__("subprocess").check_output( + ["nvidia-smi", "--query-gpu=index,name,memory.used,memory.total", "--format=csv"], + text=True, + ), + ), + ) + write( + art / "lock.json", + dict( + status="locked_before_training", + utc=base.now(), + sources=source_hashes, + data_files=data_files, + model_files=model_files, + config=cfg, + ), + ) + print( + json.dumps(dict(status="frozen", worlds=cfg["world_seeds"], arms=cfg["arms"])), flush=True + ) + + +def check_lock(cfg): + lock = base.read(Path(cfg["artifact_root"]) / "lock.json") + for group in ("sources", "data_files", "model_files"): + for path, digest in lock[group].items(): + assert sha(path) == digest, path + + +def evaluation_rows(world, extras=False): + rows = [] + for view in (0, 4) if extras else (0,): + for atom in world["atoms"]: + rows.append(dict(atom, mode="atomic", view=view, prompt=prompt(atom, view, True))) + for chain in world["chains"]: + rows.append(dict(chain, mode="direct", view=view, prompt=prompt(chain, view))) + return rows + + +@torch.inference_mode() +def generate(model, tokenizer, rows, cfg): + model.eval() + tokenizer.padding_side = "left" + output = [] + for start in range(0, len(rows), cfg["eval_batch"]): + chunk = rows[start : start + cfg["eval_batch"]] + inputs = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(cfg["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + tokens = model.generate( + **inputs, + do_sample=False, + max_new_tokens=cfg["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, inputs.input_ids.shape[1] :] + for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True): + if tokenizer.eos_token_id in tok: + tok = tok[: tok.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tok, skip_special_tokens=True) + output.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"]))) + return output + + +def evaluate(model, tokenizer, world, cfg, extras=False): + direct = generate(model, tokenizer, evaluation_rows(world, extras), cfg) + if not extras: + return direct + atoms = {a["id"]: a for a in world["atoms"]} + lookup = {(r["id"], r["view"]): r for r in direct if r["mode"] == "atomic"} + second_calls = [] + for row in direct: + if row["mode"] != "direct": + continue + first = lookup[row["atom_ids"][0], row["view"]] + generated_bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip() + second = dict(atoms[row["atom_ids"][1]], subject=generated_bridge) + second_calls.append( + dict( + row, + mode="autonomous", + prompt=prompt(second, row["view"], True), + generated_bridge=generated_bridge, + first_tokens=first["tokens"], + first_correct=first["correct"], + ) + ) + return direct + generate(model, tokenizer, second_calls, cfg) + + +def metrics(rows, world, arm): + result = {} + for view in sorted({r["view"] for r in rows}): + atomic = {r["id"]: r for r in rows if r["view"] == view and r["mode"] == "atomic"} + for pool in ("familiar", "strict"): + for role in ("first", "second"): + selected = [r for r in atomic.values() if r["pool"] == pool and r["role"] == role] + result[f"v{view}_{pool}_{role}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + for split in ("heldout", "strict", "training"): + ids = ( + set(world[arm + "_support"]) + if split == "training" + else {c["id"] for c in world["chains"] if c["split"] == split} + ) + for mode in ("direct", "autonomous"): + selected = [ + r for r in rows if r["view"] == view and r["mode"] == mode and r["id"] in ids + ] + if selected: + result[f"v{view}_{split}_{mode}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + mastered = [ + r for r in selected if all(atomic[i]["correct"] for i in r["atom_ids"]) + ] + result[f"v{view}_{split}_{mode}_both_atomic"] = dict( + correct=sum(r["correct"] for r in mastered), + n=len(mastered), + full_n=len(selected), + ) + return result + + +def stream_loss(model, inputs, atomic_count, atomic_weight): + logits = model( + input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], use_cache=False + ).logits[:, :-1] + labels = inputs["labels"][:, 1:] + losses = F.cross_entropy( + logits.float().reshape(-1, logits.shape[-1]), + labels.reshape(-1), + reduction="none", + ignore_index=-100, + ).reshape_as(labels) + atomic = losses[:atomic_count].sum() / (labels[:atomic_count] != -100).sum() + comp = losses[atomic_count:].sum() / (labels[atomic_count:] != -100).sum() + return atomic_weight * atomic + (1 - atomic_weight) * comp + + +def run(config_path, seed, arm): + cfg = base.read(config_path) + check_lock(cfg) + assert seed in cfg["world_seeds"] and arm in cfg["arms"] + art = Path(cfg["artifact_root"]) / f"w{seed}" + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + assert not (out / "status.json").exists(), "Preserve existing execution." + world, batches = base.read(art / "world.json"), base.read(art / "streams.json")[arm] + write(out / "status.json", dict(status="running", utc=base.now())) + started = time.perf_counter() + torch.set_num_threads(cfg["cpu_threads"]) + torch.manual_seed(cfg["training_seed"]) + torch.cuda.set_device(cfg["device"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + + def load(path): + return AutoModelForCausalLM.from_pretrained( + path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True + ).to(cfg["device"]) + + model = load(cfg["model_path"]) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + model.requires_grad_(True) + samples = base.parameter_samples(model) + parameter_count = sum(p.numel() for p in model.parameters()) + rec = records(tokenizer, world) + optimizer = torch.optim.AdamW( + model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"], fused=True + ) + curve, budget, train_seconds = [], Counter(), 0.0 + for step in range(cfg["steps"] + 1): + if step in cfg["nodes"]: + rows = evaluate(model, tokenizer, world, cfg, extras=step == cfg["steps"]) + write(out / f"predictions-{step:05d}.json", rows) + point = dict(step=step, metrics=metrics(rows, world, arm)) + curve.append(point) + write(out / "curve.json", curve) + print(json.dumps(dict(seed=seed, arm=arm, **point)), flush=True) + if step == cfg["steps"]: + break + decay = 0.5 * ( + 1 + + math.cos( + math.pi * max(0, step - cfg["warmup_steps"]) / (cfg["steps"] - cfg["warmup_steps"]) + ) + ) + lr = ( + cfg["minimum_learning_rate"] + + (cfg["learning_rate"] - cfg["minimum_learning_rate"]) * decay + ) * min(1.0, (step + 1) / cfg["warmup_steps"]) + for group in optimizer.param_groups: + group["lr"] = lr + docs = docs_for(rec, batches[step]) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + inputs = base.batch_tensors(docs, tokenizer.pad_token_id, cfg["device"]) + model.train() + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = stream_loss(model, inputs, cfg["atomic_per_step"], cfg["atomic_loss_weight"]) + assert torch.isfinite(loss) + loss.backward() + if step == 0: + assert all( + p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all() + for p in model.parameters() + ) + torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 64 == 0: + print( + json.dumps( + dict( + seed=seed, + arm=arm, + step=step + 1, + loss=float(loss.detach()), + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + name: not torch.equal(before, base.parameter_samples(model)[name]) + for name, before in samples.items() + } + assert all(changed.values()) + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + architecture = model.config.to_dict() + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + again = evaluate(load(out / "model"), tokenizer, world, cfg, extras=True) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again] + assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again] + write( + out / "reload-audit.json", + dict( + status="passed", + predictions=len(again), + exact_generated_tokens=True, + exact_autonomous_prompts=True, + ), + ) + assert dict(budget) == base.read(art / "data-audit.json")["budgets"][arm] + d, layers = architecture["hidden_size"], architecture["num_hidden_layers"] + query_width = architecture["num_attention_heads"] * architecture["head_dim"] + kv = architecture["num_key_value_heads"] * architecture["head_dim"] + per_token = ( + layers * (2 * d * query_width + 2 * d * kv + 3 * d * architecture["intermediate_size"]) + + d * architecture["vocab_size"] + ) + flops = ( + 6 * per_token * budget["padded_tokens"] + + 12 * layers * query_width * budget["attention_cells"] + ) + summary = dict( + status="complete", + phase=cfg["phase"], + utc=base.now(), + world_seed=seed, + arm=arm, + metrics=metrics(final_rows, world, arm), + updates=cfg["steps"], + budget=dict(budget), + train_seconds=train_seconds, + process_seconds=time.perf_counter() - started, + estimated_training_matrix_flops=flops, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + parameter_count=parameter_count, + sampled_parameters_changed=changed, + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + tf32=False, + lock_sha256=sha(Path(cfg["artifact_root"]) / "lock.json"), + checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + write(out / "summary.json", summary) + write(out / "status.json", dict(status="complete", utc=base.now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + cfg = base.read(config_path) + check_lock(cfg) + runs, checks = {}, 0 + for seed in cfg["world_seeds"]: + world = base.read(Path(cfg["artifact_root"]) / f"w{seed}" / "world.json") + for arm in cfg["arms"]: + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + summary = base.read(out / "summary.json") + assert base.read(out / "reload-audit.json")["status"] == "passed" + for point in base.read(out / "curve.json"): + rows = base.read(out / f"predictions-{point['step']:05d}.json") + assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows) + assert point["metrics"] == metrics(rows, world, arm) + checks += len(rows) + assert summary["metrics"] == metrics(rows, world, arm) + runs[f"w{seed}-{arm}"] = summary + differences = {} + if len(cfg["arms"]) == 2: + for seed in cfg["world_seeds"]: + diff = {} + for key in runs[f"w{seed}-high"]["metrics"]: + high, low = [runs[f"w{seed}-{a}"]["metrics"][key] for a in ("high", "low")] + if key.endswith("both_atomic") or "training" in key: + continue + diff[key] = high["correct"] / high["n"] - low["correct"] / low["n"] + differences[str(seed)] = diff + write( + Path(cfg["artifact_root"]) / "summary.json", + dict( + status="complete", + phase=cfg["phase"], + independent_worlds=len(cfg["world_seeds"]), + training_initializations=1, + runs=runs, + per_world_high_minus_low=differences, + independent_node_prediction_checks=checks, + total_updates=sum(r["updates"] for r in runs.values()), + total_train_seconds=sum(r["train_seconds"] for r in runs.values()), + total_process_seconds=sum(r["process_seconds"] for r in runs.values()), + ), + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("action", choices=("freeze", "run", "report")) + parser.add_argument("--config", required=True) + parser.add_argument("--world", type=int) + parser.add_argument("--arm", choices=("low", "high")) + args = parser.parse_args() + if args.action == "run": + run(args.config, args.world, args.arm) + elif args.action == "freeze": + freeze(args.config) + else: + report(args.config) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py new file mode 100644 index 0000000000000000000000000000000000000000..d8e949ff27eac75a758644d6a7ffd81f2a9477ea --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py @@ -0,0 +1,687 @@ +"""Full-Qwen, nested compositional support with matched atomic supervision.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import math +import platform +import shutil +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch +import torch.nn.functional as F +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +from . import small_lm_composition as base + +FIRST = ("mentor", "advisor") +SECOND = ("live", "birth") +STRICT_CITIES = ( + "Athens Prague Havana Tunis Perth Zurich Bristol Munich " + "Tallinn Riga Quito Dakar Nairobi Accra Calgary Warsaw" +).split() +ROOT = Path("docs/development-artifacts/natural-composition-confirmation-v1") + + +def sha(path): + digest = hashlib.sha256() + with Path(path).open("rb") as handle: + for chunk in iter(lambda: handle.read(16 * 1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def write(path, value): + base.write(path, value) + + +def build_world(seed): + rng = np.random.default_rng(seed) + first_names = ( + "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo" + ).split() + names = [ + f"{a} {b}" + for a in first_names + for b in "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split() + ] + names = rng.permutation(names).tolist() + atoms, chains = [], [] + for pool, offset, cities in (("familiar", 0, base.CITIES), ("strict", 32, STRICT_CITIES)): + heads, bridges = names[offset : offset + 16], names[offset + 16 : offset + 32] + mappings = [rng.permutation(16).tolist()] + mappings.append(np.roll(mappings[0], int(rng.choice(np.arange(2, 16, 2)))).tolist()) + city_maps = [rng.permutation(cities).tolist()] + city_maps.append(np.roll(city_maps[0], int(rng.integers(1, 16))).tolist()) + ids = {} + for j, head in enumerate(heads): + for r, relation in enumerate(FIRST): + atom = dict( + id=len(atoms), + pool=pool, + role="first", + subject=head, + relation=relation, + answer=bridges[mappings[r][j]], + ) + atoms.append(atom) + ids["first", j, r] = atom["id"] + for j, bridge in enumerate(bridges): + for s, relation in enumerate(SECOND): + atom = dict( + id=len(atoms), + pool=pool, + role="second", + subject=bridge, + relation=relation, + answer=city_maps[s][j], + ) + atoms.append(atom) + ids["second", j, s] = atom["id"] + for j, head in enumerate(heads): + for r, first in enumerate(FIRST): + for s, second in enumerate(SECOND): + bridge_index = mappings[r][j] + chains.append( + dict( + id=len(chains), + pool=pool, + head_index=j, + head=head, + bridge=bridges[bridge_index], + first=first, + second=second, + answer=city_maps[s][bridge_index], + atom_ids=[ids["first", j, r], ids["second", bridge_index, s]], + split="strict" + if pool == "strict" + else ("support" if s == (r ^ (j % 2)) else "heldout"), + ) + ) + return dict( + seed=seed, + atoms=atoms, + chains=chains, + high_support=[c["id"] for c in chains if c["split"] == "support"], + low_support=[c["id"] for c in chains if c["split"] == "support" and c["head_index"] < 4], + ) + + +def question(row, variant=0, atomic=False): + if atomic: + subject, relation = row["subject"], row["relation"] + if row["role"] == "first": + templates = ( + "Who is {subject}'s {relation}?", + "Who is the {relation} of {subject}?", + "Name the {relation} of {subject}.", + "Give the name of {subject}'s {relation}.", + "Give the name of the person serving as {subject}'s {relation}.", + ) + elif relation == "live": + templates = ( + "Which city does {subject} live in?", + "What city is {subject}'s home?", + "Where does {subject} live?", + "Name the city where {subject} lives.", + "In which city is {subject} living?", + ) + else: + templates = ( + "Which city was {subject} born in?", + "What is {subject}'s birth city?", + "Where was {subject} born?", + "Name the city where {subject} was born.", + "In which city did {subject}'s birth take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + subject = row["head"] + relation = row["first"] + if row["second"] == "live": + templates = ( + "Which city does {subject}'s {relation} live in?", + "What city is home to {subject}'s {relation}?", + "Where does the {relation} of {subject} live?", + "Name the city where {subject}'s {relation} lives.", + "In which city is the person serving as {subject}'s {relation} living?", + ) + else: + templates = ( + "Which city was {subject}'s {relation} born in?", + "What is the birth city of {subject}'s {relation}?", + "Where was the {relation} of {subject} born?", + "Name the city where {subject}'s {relation} was born.", + "In which city did the birth of {subject}'s {relation} take place?", + ) + return templates[variant].format(subject=subject, relation=relation) + + +def prompt(row, variant=0, atomic=False): + return "Fictional registry.\nQuestion: " + question(row, variant, atomic) + "\nAnswer:" + + +def record(tokenizer, row, variant, atomic): + # Joint text tokenization, exactly as in the calibrated full-Qwen v2 recipe. + ids = tokenizer.encode( + prompt(row, variant, atomic) + " " + row["answer"] + ".", add_special_tokens=False + ) + [tokenizer.eos_token_id] + return dict( + ids=ids, + labels=[-100, *ids[1:]], + id=row["id"], + kind="atomic" if atomic else "composition", + variant=variant, + ) + + +def streams(world, cfg): + rng = np.random.default_rng(cfg["training_seed"]) + atomic_order, comp_order = [], {a: [] for a in cfg["arms"]} + batches = {a: [] for a in cfg["arms"]} + for _ in range(cfg["steps"]): + if len(atomic_order) < cfg["atomic_per_step"]: + atomic_order.extend(rng.permutation(len(world["atoms"])).tolist()) + atomic = [ + [int(atomic_order.pop(0)), int(rng.integers(4))] for _ in range(cfg["atomic_per_step"]) + ] + variants = rng.integers(4, size=cfg["compositions_per_step"]).tolist() + for arm in cfg["arms"]: + support = world[arm + "_support"] + if len(comp_order[arm]) < cfg["compositions_per_step"]: + comp_order[arm].extend(rng.permutation(support).tolist()) + comp = [[int(comp_order[arm].pop(0)), int(v)] for v in variants] + batches[arm].append(dict(atomic=atomic, composition=comp)) + return batches + + +def records(tokenizer, world): + return { + kind: { + (r["id"], v): record(tokenizer, r, v, kind == "atomic") + for r in world["atoms" if kind == "atomic" else "chains"] + for v in range(4) + } + for kind in ("atomic", "composition") + } + + +def docs_for(rec, batch): + return [rec[kind][tuple(spec)] for kind in ("atomic", "composition") for spec in batch[kind]] + + +def audit(world, batches, rec): + assert ( + len(world["atoms"]) == 128 + and len(world["high_support"]) == 32 + and len(world["low_support"]) == 8 + ) + assert set(world["low_support"]) < set(world["high_support"]) + familiar_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "familiar"} + covered = {i for j in world["high_support"] for i in world["chains"][j]["atom_ids"]} + assert covered == familiar_atoms + strict_atoms = {a["id"] for a in world["atoms"] if a["pool"] == "strict"} + assert not covered & strict_atoms + support = [world["chains"][i] for i in world["high_support"]] + heldout = [c for c in world["chains"] if c["split"] == "heldout"] + strict = [c for c in world["chains"] if c["split"] == "strict"] + assert len(heldout) == 32 and len(strict) == 64 + # No alternate trained query gives the same head/answer endpoint as a held-out chain. + assert not {(c["head"], c["answer"]) for c in support} & { + (c["head"], c["answer"]) for c in heldout + } + + def people(pool): + return {a["subject"] for a in world["atoms"] if a["pool"] == pool} + + assert not people("familiar") & people("strict") + assert not {c["answer"] for c in support} & {c["answer"] for c in strict} + budgets, exposure = {}, {} + for arm, stream in batches.items(): + budget, atomic_counts, comp_counts = Counter(), Counter(), Counter() + for batch in stream: + docs = docs_for(rec, batch) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + atomic_counts.update(i for i, _ in batch["atomic"]) + comp_counts.update(i for i, _ in batch["composition"]) + assert set(comp_counts) <= set(world[arm + "_support"]) + budgets[arm] = dict(budget) + exposure[arm] = dict( + atomic=sorted(atomic_counts.items()), composition=sorted(comp_counts.items()) + ) + if "low" in batches and "high" in batches: + assert [b["atomic"] for b in batches["low"]] == [b["atomic"] for b in batches["high"]] + assert exposure["low"]["atomic"] == exposure["high"]["atomic"] + return dict( + status="passed", + budgets=budgets, + exposures=exposure, + familiar_fact_role_coverage_high=len(covered), + familiar_fact_role_coverage_low=len( + {i for j in world["low_support"] for i in world["chains"][j]["atom_ids"]} + ), + heldout_queries=len(heldout), + strict_queries=len(strict), + target_endpoint_leakage=0, + exact_common_atomic_sequence=True, + exact_atomic_stream_loss_weight=True, + composition_slots_equal=True, + ) + + +def freeze(config_path): + cfg = base.read(config_path) + art = Path(cfg["artifact_root"]) + assert not (art / "lock.json").exists(), "Preserve frozen batch." + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + sources = [ + str(config_path), + "src/llm_memory_editability/natural_composition_confirmation_v2.py", + "src/llm_memory_editability/small_lm_composition.py", + "scripts/run_natural_composition_confirmation_v2.py", + "tests/test_natural_composition_confirmation_v2.py", + "docs/development-artifacts/natural-composition-confirmation-v1/amendment-v2.md", + ] + source_hashes = {} + for source in sources: + dest = art / "source" / source + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(source, dest) + source_hashes[source] = sha(source) + data_files = {} + for seed in cfg["world_seeds"]: + world = build_world(seed) + batch = streams(world, cfg) + report = audit(world, batch, records(tokenizer, world)) + for filename, obj in ( + ("world.json", world), + ("streams.json", batch), + ("data-audit.json", report), + ): + path = art / f"w{seed}" / filename + write(path, obj) + data_files[str(path)] = sha(path) + model_files = { + str(p): sha(p) + for p in Path(cfg["model_path"]).iterdir() + if p.suffix in (".json", ".safetensors") or p.name in ("LICENSE", "README.md") + } + write( + art / "environment.json", + dict( + python=platform.python_version(), + executable=str(Path(__import__("sys").executable)), + torch=torch.__version__, + transformers=transformers.__version__, + gpu_inventory=__import__("subprocess").check_output( + ["nvidia-smi", "--query-gpu=index,name,memory.used,memory.total", "--format=csv"], + text=True, + ), + ), + ) + write( + art / "lock.json", + dict( + status="locked_before_training", + utc=base.now(), + sources=source_hashes, + data_files=data_files, + model_files=model_files, + config=cfg, + ), + ) + print( + json.dumps(dict(status="frozen", worlds=cfg["world_seeds"], arms=cfg["arms"])), flush=True + ) + + +def check_lock(cfg): + lock = base.read(Path(cfg["artifact_root"]) / "lock.json") + for group in ("sources", "data_files", "model_files"): + for path, digest in lock[group].items(): + assert sha(path) == digest, path + + +def evaluation_rows(world, extras=False): + rows = [] + for view in (0, 4) if extras else (0,): + for atom in world["atoms"]: + rows.append(dict(atom, mode="atomic", view=view, prompt=prompt(atom, view, True))) + for chain in world["chains"]: + rows.append(dict(chain, mode="direct", view=view, prompt=prompt(chain, view))) + return rows + + +@torch.inference_mode() +def generate(model, tokenizer, rows, cfg): + model.eval() + tokenizer.padding_side = "left" + output = [] + for start in range(0, len(rows), cfg["eval_batch"]): + chunk = rows[start : start + cfg["eval_batch"]] + inputs = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(cfg["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + tokens = model.generate( + **inputs, + do_sample=False, + max_new_tokens=cfg["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, inputs.input_ids.shape[1] :] + for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True): + if tokenizer.eos_token_id in tok: + tok = tok[: tok.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tok, skip_special_tokens=True) + output.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"]))) + return output + + +def evaluate(model, tokenizer, world, cfg, extras=False): + direct = generate(model, tokenizer, evaluation_rows(world, extras), cfg) + if not extras: + return direct + atoms = {a["id"]: a for a in world["atoms"]} + lookup = {(r["id"], r["view"]): r for r in direct if r["mode"] == "atomic"} + second_calls = [] + for row in direct: + if row["mode"] != "direct": + continue + first = lookup[row["atom_ids"][0], row["view"]] + generated_bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip() + second = dict(atoms[row["atom_ids"][1]], subject=generated_bridge) + second_calls.append( + dict( + row, + mode="autonomous", + prompt=prompt(second, row["view"], True), + generated_bridge=generated_bridge, + first_tokens=first["tokens"], + first_correct=first["correct"], + ) + ) + return direct + generate(model, tokenizer, second_calls, cfg) + + +def metrics(rows, world, arm): + result = {} + for view in sorted({r["view"] for r in rows}): + atomic = {r["id"]: r for r in rows if r["view"] == view and r["mode"] == "atomic"} + for pool in ("familiar", "strict"): + for role in ("first", "second"): + selected = [r for r in atomic.values() if r["pool"] == pool and r["role"] == role] + result[f"v{view}_{pool}_{role}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + for split in ("heldout", "strict", "training"): + ids = ( + set(world[arm + "_support"]) + if split == "training" + else {c["id"] for c in world["chains"] if c["split"] == split} + ) + for mode in ("direct", "autonomous"): + selected = [ + r for r in rows if r["view"] == view and r["mode"] == mode and r["id"] in ids + ] + if selected: + result[f"v{view}_{split}_{mode}"] = dict( + correct=sum(r["correct"] for r in selected), n=len(selected) + ) + mastered = [ + r for r in selected if all(atomic[i]["correct"] for i in r["atom_ids"]) + ] + result[f"v{view}_{split}_{mode}_both_atomic"] = dict( + correct=sum(r["correct"] for r in mastered), + n=len(mastered), + full_n=len(selected), + ) + return result + + +def stream_loss(model, inputs, atomic_count, atomic_weight): + logits = model( + input_ids=inputs["input_ids"], attention_mask=inputs["attention_mask"], use_cache=False + ).logits[:, :-1] + labels = inputs["labels"][:, 1:] + losses = F.cross_entropy( + logits.float().reshape(-1, logits.shape[-1]), + labels.reshape(-1), + reduction="none", + ignore_index=-100, + ).reshape_as(labels) + atomic = losses[:atomic_count].sum() / (labels[:atomic_count] != -100).sum() + comp = losses[atomic_count:].sum() / (labels[atomic_count:] != -100).sum() + return atomic_weight * atomic + (1 - atomic_weight) * comp + + +def run(config_path, seed, arm): + cfg = base.read(config_path) + check_lock(cfg) + assert seed in cfg["world_seeds"] and arm in cfg["arms"] + art = Path(cfg["artifact_root"]) / f"w{seed}" + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + assert not (out / "status.json").exists(), "Preserve existing execution." + world, batches = base.read(art / "world.json"), base.read(art / "streams.json")[arm] + write(out / "status.json", dict(status="running", utc=base.now())) + started = time.perf_counter() + torch.set_num_threads(cfg["cpu_threads"]) + torch.manual_seed(cfg["training_seed"]) + torch.cuda.set_device(cfg["device"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(cfg["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + + def load(path): + return AutoModelForCausalLM.from_pretrained( + path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True + ).to(cfg["device"]) + + model = load(cfg["model_path"]) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + model.requires_grad_(True) + samples = base.parameter_samples(model) + parameter_count = sum(p.numel() for p in model.parameters()) + rec = records(tokenizer, world) + optimizer = torch.optim.AdamW( + model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"], fused=True + ) + curve, budget, train_seconds = [], Counter(), 0.0 + for step in range(cfg["steps"] + 1): + if step in cfg["nodes"]: + rows = evaluate(model, tokenizer, world, cfg, extras=step == cfg["steps"]) + write(out / f"predictions-{step:05d}.json", rows) + point = dict(step=step, metrics=metrics(rows, world, arm)) + curve.append(point) + write(out / "curve.json", curve) + print(json.dumps(dict(seed=seed, arm=arm, **point)), flush=True) + if step == cfg["steps"]: + break + decay = 0.5 * ( + 1 + + math.cos( + math.pi * max(0, step - cfg["warmup_steps"]) / (cfg["steps"] - cfg["warmup_steps"]) + ) + ) + lr = ( + cfg["minimum_learning_rate"] + + (cfg["learning_rate"] - cfg["minimum_learning_rate"]) * decay + ) * min(1.0, (step + 1) / cfg["warmup_steps"]) + for group in optimizer.param_groups: + group["lr"] = lr + docs = docs_for(rec, batches[step]) + width = max(len(d["ids"]) for d in docs) + budget.update( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(len(d["ids"]) - 1 for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + inputs = base.batch_tensors(docs, tokenizer.pad_token_id, cfg["device"]) + model.train() + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = stream_loss(model, inputs, cfg["atomic_per_step"], cfg["atomic_loss_weight"]) + assert torch.isfinite(loss) + loss.backward() + if step == 0: + assert all( + p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all() + for p in model.parameters() + ) + torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 64 == 0: + print( + json.dumps( + dict( + seed=seed, + arm=arm, + step=step + 1, + loss=float(loss.detach()), + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + name: not torch.equal(before, base.parameter_samples(model)[name]) + for name, before in samples.items() + } + assert all(changed.values()) + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + architecture = model.config.to_dict() + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + again = evaluate(load(out / "model"), tokenizer, world, cfg, extras=True) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again] + assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again] + write( + out / "reload-audit.json", + dict( + status="passed", + predictions=len(again), + exact_generated_tokens=True, + exact_autonomous_prompts=True, + ), + ) + assert dict(budget) == base.read(art / "data-audit.json")["budgets"][arm] + d, layers = architecture["hidden_size"], architecture["num_hidden_layers"] + query_width = architecture["num_attention_heads"] * architecture["head_dim"] + kv = architecture["num_key_value_heads"] * architecture["head_dim"] + per_token = ( + layers * (2 * d * query_width + 2 * d * kv + 3 * d * architecture["intermediate_size"]) + + d * architecture["vocab_size"] + ) + flops = ( + 6 * per_token * budget["padded_tokens"] + + 12 * layers * query_width * budget["attention_cells"] + ) + summary = dict( + status="complete", + phase=cfg["phase"], + utc=base.now(), + world_seed=seed, + arm=arm, + metrics=metrics(final_rows, world, arm), + updates=cfg["steps"], + budget=dict(budget), + train_seconds=train_seconds, + process_seconds=time.perf_counter() - started, + estimated_training_matrix_flops=flops, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + parameter_count=parameter_count, + sampled_parameters_changed=changed, + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + tf32=False, + lock_sha256=sha(Path(cfg["artifact_root"]) / "lock.json"), + checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + write(out / "summary.json", summary) + write(out / "status.json", dict(status="complete", utc=base.now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + cfg = base.read(config_path) + check_lock(cfg) + runs, checks = {}, 0 + for seed in cfg["world_seeds"]: + world = base.read(Path(cfg["artifact_root"]) / f"w{seed}" / "world.json") + for arm in cfg["arms"]: + out = Path(cfg["output_root"]) / f"w{seed}-{arm}" + summary = base.read(out / "summary.json") + assert base.read(out / "reload-audit.json")["status"] == "passed" + for point in base.read(out / "curve.json"): + rows = base.read(out / f"predictions-{point['step']:05d}.json") + assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows) + assert point["metrics"] == metrics(rows, world, arm) + checks += len(rows) + assert summary["metrics"] == metrics(rows, world, arm) + runs[f"w{seed}-{arm}"] = summary + differences = {} + if len(cfg["arms"]) == 2: + for seed in cfg["world_seeds"]: + diff = {} + for key in runs[f"w{seed}-high"]["metrics"]: + high, low = [runs[f"w{seed}-{a}"]["metrics"][key] for a in ("high", "low")] + if key.endswith("both_atomic") or "training" in key: + continue + diff[key] = high["correct"] / high["n"] - low["correct"] / low["n"] + differences[str(seed)] = diff + write( + Path(cfg["artifact_root"]) / "summary.json", + dict( + status="complete", + phase=cfg["phase"], + independent_worlds=len(cfg["world_seeds"]), + training_initializations=1, + runs=runs, + per_world_high_minus_low=differences, + independent_node_prediction_checks=checks, + total_updates=sum(r["updates"] for r in runs.values()), + total_train_seconds=sum(r["train_seconds"] for r in runs.values()), + total_process_seconds=sum(r["process_seconds"] for r in runs.values()), + ), + ) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("action", choices=("freeze", "run", "report")) + parser.add_argument("--config", required=True) + parser.add_argument("--world", type=int) + parser.add_argument("--arm", choices=("low", "high")) + args = parser.parse_args() + if args.action == "run": + run(args.config, args.world, args.arm) + elif args.action == "freeze": + freeze(args.config) + else: + report(args.config) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural.py new file mode 100644 index 0000000000000000000000000000000000000000..ce1f02e8195f4e583817b3781b044f021a41fbfb --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural.py @@ -0,0 +1,328 @@ +"""Controlled nonlinear memory editing with full old-fact replay on CPU. + +This measures finite-budget optimization, not minimum representational capacity. +The data generator's shared rule does not establish the model's internal mechanism. +""" + +import argparse +import copy +import json +import math +import platform +import statistics +import subprocess +import time +from dataclasses import asdict, dataclass +from pathlib import Path + +import numpy as np + +try: + import torch + from torch import nn + from torch.nn import functional as F +except ModuleNotFoundError as exc: + raise SystemExit("Neural experiments require PyTorch: pip install '.[neural]'") from exc + +from .neural_data import make_world +from .neural_models import build_model, edit_parameters + + +@dataclass(frozen=True) +class NeuralConfig: + model: str = "mlp" + seeds: tuple[int, ...] = (0, 1, 2) + data_seed: int = 0 + entities: int = 24 + attributes: int = 8 + groups: int = 3 + answers: int = 4 + width: int = 32 + hidden: int = 64 + layers: int = 2 + heads: int = 4 + pretrain_steps: int = 400 + edit_steps: int = 100 + scratch_steps: int = 400 + lr: float = 0.01 + retention_weight: float = 1.0 + edit_scope: str = "ffn" + eval_every: int = 10 + success_threshold: float = 0.95 + threads: int = 1 + + def validate(self) -> None: + if self.model not in {"mlp", "transformer"} or self.edit_scope not in {"ffn", "all"}: + raise ValueError("unsupported model or edit scope") + for name in ("pretrain_steps", "edit_steps", "scratch_steps", "eval_every", "threads"): + value = getattr(self, name) + if isinstance(value, bool) or not isinstance(value, int) or value < 1: + raise ValueError(f"{name} must be a positive integer") + if not self.seeds or len(set(self.seeds)) != len(self.seeds): + raise ValueError("seeds must be nonempty and unique") + if any(isinstance(s, bool) or not isinstance(s, int) or s < 0 for s in self.seeds): + raise ValueError("seeds must be nonnegative integers") + if not math.isfinite(self.lr) or self.lr <= 0: + raise ValueError("lr must be finite and positive") + if not math.isfinite(self.retention_weight) or self.retention_weight < 0: + raise ValueError("retention_weight must be finite and nonnegative") + if not 0 < self.success_threshold <= 1: + raise ValueError("success_threshold must be in (0, 1]") + + +@torch.no_grad() +def evaluate(model: nn.Module, x: torch.Tensor, y: torch.Tensor, mask: torch.Tensor) -> dict: + """Evaluate answers against a target world, separating edits and retained facts.""" + model.eval() + logits = model(x) + if not torch.isfinite(logits).all(): + raise ValueError("non-finite model outputs") + correct = logits.argmax(dim=-1).eq(y).float() + target_logits = logits.gather(1, y[:, None]).squeeze(1) + competitors = logits.clone().scatter_(1, y[:, None], float("-inf")).max(dim=1).values + margins = target_logits - competitors + return { + "all_accuracy": correct.mean().item(), + "edit_accuracy": correct[mask].mean().item(), + "retain_accuracy": correct[~mask].mean().item(), + "edit_target_nll": F.cross_entropy(logits[mask], y[mask]).item(), + "edit_margin": margins[mask].mean().item(), + "retain_margin": margins[~mask].mean().item(), + } + + +def fit( + model: nn.Module, + x: torch.Tensor, + y: torch.Tensor, + mask: torch.Tensor, + *, + steps: int, + config: NeuralConfig, + is_edit: bool = False, +) -> dict: + """Use a fresh optimizer, fixed steps, and a documented full-batch objective.""" + parameters = [p for p in model.parameters() if p.requires_grad] + optimizer = torch.optim.Adam(parameters, lr=config.lr) + history = [] + first_success = None + started = time.perf_counter() + for step in range(steps + 1): + if step % config.eval_every == 0 or step == steps: + metrics = evaluate(model, x, y, mask) + history.append({"step": step, **metrics}) + if ( + first_success is None + and min(metrics["edit_accuracy"], metrics["retain_accuracy"]) + >= config.success_threshold + ): + first_success = step + if step == steps: + break + model.train() + optimizer.zero_grad(set_to_none=True) + logits = model(x) + if is_edit: + loss = F.cross_entropy(logits[mask], y[mask]) + if config.retention_weight: + loss = loss + config.retention_weight * F.cross_entropy(logits[~mask], y[~mask]) + else: + loss = F.cross_entropy(logits, y) + if not torch.isfinite(loss): + raise ValueError("training diverged to a non-finite loss") + loss.backward() + optimizer.step() + return { + "steps": steps, + "trainable_parameters": sum(p.numel() for p in parameters), + "first_success_step": first_success, + "elapsed_seconds": time.perf_counter() - started, + "history": history, + "objective": "edit_ce + retention_weight * retained_ce" if is_edit else "full_world_ce", + } + + +def _summary(runs: list[dict]) -> dict: + eligible = [run for run in runs if run["baseline_quality_passed"]] + result = {"eligible_seeds": [run["seed"] for run in eligible], "cases": {}} + for name in ("rule", "exception"): + result["cases"][name] = {} + for metric in ("edit_accuracy", "retain_accuracy"): + values = [run["cases"][name]["after"][metric] for run in eligible] + result["cases"][name][metric] = { + "mean": statistics.mean(values) if values else None, + "sample_std": statistics.stdev(values) if len(values) > 1 else None, + "n": len(values), + } + return result + + +def _revision() -> str | None: + """Best-effort source revision; an installed wheel may not have a checkout.""" + source_root = Path(__file__).resolve().parents[2] + if not (source_root / ".git").exists(): + return None + try: + revision = subprocess.check_output( + ["git", "rev-parse", "HEAD"], cwd=source_root, text=True, stderr=subprocess.DEVNULL + ).strip() + dirty = subprocess.check_output( + ["git", "status", "--porcelain"], cwd=source_root, text=True + ).strip() + return revision + ("+dirty" if dirty else "") + except (OSError, subprocess.CalledProcessError): + return None + + +def run_experiment(config: NeuralConfig) -> dict: + config.validate() + world = make_world( + n_entities=config.entities, + n_attributes=config.attributes, + n_groups=config.groups, + n_answers=config.answers, + seed=config.data_seed, + ) + torch.set_num_threads(config.threads) + torch.use_deterministic_algorithms(True) + x = torch.as_tensor(world.x, dtype=torch.long) + original = torch.as_tensor(world.original, dtype=torch.long) + mask = torch.as_tensor(world.edit_mask, dtype=torch.bool) + runs = [] + for seed in config.seeds: + torch.manual_seed(seed) + initial = build_model( + config.model, + config.entities, + config.attributes, + config.answers, + width=config.width, + hidden=config.hidden, + layers=config.layers, + heads=config.heads, + ) + base = copy.deepcopy(initial) + baseline_training = fit( + base, + x, + original, + mask, + steps=config.pretrain_steps, + config=config, + ) + baseline = evaluate(base, x, original, mask) + run = { + "seed": seed, + "parameter_count": sum(p.numel() for p in base.parameters()), + "baseline": baseline, + "baseline_quality_passed": min(baseline["edit_accuracy"], baseline["retain_accuracy"]) + >= config.success_threshold, + "baseline_training": baseline_training, + "cases": {}, + } + for name in ("rule", "exception"): + target = torch.as_tensor(getattr(world, name), dtype=torch.long) + edited = copy.deepcopy(base) + edit_parameters(edited, scope=config.edit_scope) + before = evaluate(edited, x, target, mask) + edit_training = fit( + edited, + x, + target, + mask, + steps=config.edit_steps, + config=config, + is_edit=True, + ) + scratch = copy.deepcopy(initial) + scratch_training = fit( + scratch, + x, + target, + mask, + steps=config.scratch_steps, + config=config, + ) + run["cases"][name] = { + "before": before, + "after": evaluate(edited, x, target, mask), + "scratch": evaluate(scratch, x, target, mask), + "edit_training": edit_training, + "scratch_training": scratch_training, + } + runs.append(run) + return { + "experiment": "nonlinear_synthetic_memory_editing", + "config": asdict(config), + "versions": { + "python": platform.python_version(), + "numpy": np.__version__, + "torch": torch.__version__, + }, + "revision": _revision(), + "device": "cpu", + "world": world.to_metadata(), + "protocol": { + "paired_edit_initialization": "identical trained checkpoint; fresh Adam per case", + "paired_scratch_initialization": "identical untrained initialization; all parameters", + "replay": "all retained facts available; uniform CE within each edit/retain subset", + "success": "both edit and retain accuracy >= threshold at evaluation checkpoints", + "summary_filter": "only seeds passing baseline threshold on both subsets", + "limits": [ + "Target surprisal is measured, not matched.", + "Generator structure is not a measure of learned neural degrees of freedom.", + "Scratch failure at finite budget is not an impossibility result.", + "Scratch trains all parameters; FFN-only edit failures may reflect " + "a restricted update space.", + "No natural-language paraphrases or pretrained LLM are evaluated.", + "Cross-platform and cross-version bitwise reproducibility is not guaranteed.", + ], + }, + "runs": runs, + "summary": _summary(runs), + } + + +def main(argv: list[str] | None = None) -> int: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--model", choices=("mlp", "transformer"), default="mlp") + parser.add_argument("--seeds", type=int, nargs="+", default=[0, 1, 2]) + parser.add_argument("--edit-scope", choices=("ffn", "all"), default="ffn") + defaults = asdict(NeuralConfig()) + for name in ( + "data_seed", + "entities", + "attributes", + "groups", + "answers", + "width", + "hidden", + "layers", + "heads", + "pretrain_steps", + "edit_steps", + "scratch_steps", + "eval_every", + "threads", + ): + parser.add_argument("--" + name.replace("_", "-"), type=int, default=defaults[name]) + for name in ("lr", "retention_weight", "success_threshold"): + parser.add_argument("--" + name.replace("_", "-"), type=float, default=defaults[name]) + parser.add_argument("--output", type=Path, help="save the same JSON printed to stdout") + args = vars(parser.parse_args(argv)) + output = args.pop("output") + args["seeds"] = tuple(args["seeds"]) + try: + report = run_experiment(NeuralConfig(**args)) + serialized = json.dumps(report, ensure_ascii=False, indent=2, allow_nan=False) + if output: + output.parent.mkdir(parents=True, exist_ok=True) + output.write_text(serialized + "\n", encoding="utf-8") + except (ValueError, OSError) as exc: + parser.error(str(exc)) + print(serialized) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_data.py new file mode 100644 index 0000000000000000000000000000000000000000..555b2a06a7db0805d441a3f8f89bc2100deaa72a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_data.py @@ -0,0 +1,147 @@ +"""Balanced fact-table interventions, defined independently of model training.""" + +from dataclasses import dataclass +from typing import Any + +import numpy as np + + +@dataclass(frozen=True) +class SyntheticWorld: + """All entity/attribute queries and two interventions on identical support.""" + + x: np.ndarray + original: np.ndarray + rule: np.ndarray + exception: np.ndarray + edit_mask: np.ndarray + group_ids: np.ndarray + n_entities: int + n_attributes: int + n_groups: int + n_answers: int + seed: int + + def task_exceptions(self, labels: np.ndarray) -> int: + """Minimum overrides of a group+attribute table; not neural model degrees of freedom.""" + labels = np.asarray(labels) + if labels.shape != self.original.shape: + raise ValueError("labels must contain one answer per fact") + exceptions = 0 + for group in range(self.n_groups): + for attribute in range(self.n_attributes): + cell = labels[(self.group_ids[self.x[:, 0]] == group) & (self.x[:, 1] == attribute)] + exceptions += cell.size - int(np.bincount(cell, minlength=self.n_answers).max()) + return exceptions + + def to_metadata(self) -> dict[str, Any]: + """JSON-compatible task diagnostics, available before training or editing.""" + return { + "n_entities": self.n_entities, + "n_attributes": self.n_attributes, + "n_groups": self.n_groups, + "n_answers": self.n_answers, + "seed": self.seed, + "n_facts": len(self.x), + "n_edited": int(self.edit_mask.sum()), + "edited_entities": np.unique(self.x[self.edit_mask, 0]).tolist(), + "edited_attributes": np.unique(self.x[self.edit_mask, 1]).tolist(), + "matched_controls": [ + "edit support", + "edited fact count", + "entity and attribute coverage", + "per-entity target-answer histograms", + ], + "task_side_group_attribute_exceptions": { + name: self.task_exceptions(getattr(self, name)) + for name in ("original", "rule", "exception") + }, + "structure_metric_scope": ( + "Minimum label overrides of a deterministic group+attribute answer table. " + "This is a task-side generator property, not neural degrees of freedom " + "or evidence that a trained network learned these groups." + ), + } + + +def make_world( + n_entities: int = 24, + n_attributes: int = 8, + n_groups: int = 3, + n_answers: int = 4, + seed: int = 0, +) -> SyntheticWorld: + """Generate balanced labels and conflicting exception patterns in edited group 0. + + Entity targets are independently shuffled, conditioned on changing every edited + fact. The final row is resampled if all entities happen to share one pattern. + Rejection sampling is bounded, including for long attribute tables. + """ + for name, value in { + "n_entities": n_entities, + "n_attributes": n_attributes, + "n_groups": n_groups, + "n_answers": n_answers, + "seed": seed, + }.items(): + if isinstance(value, bool) or not isinstance(value, (int, np.integer)): + raise ValueError(f"{name} must be an integer") + if value < (0 if name == "seed" else 1): + raise ValueError(f"{name} is outside its valid range") + n_entities, n_attributes, n_groups, n_answers, seed = map( + int, + (n_entities, n_attributes, n_groups, n_answers, seed), + ) + if n_groups < 2: + raise ValueError("n_groups must be >= 2 to leave retained facts outside the edit support") + if n_entities % n_groups or n_entities // n_groups < 2: + raise ValueError("n_entities must be divisible by n_groups, with >= 2 entities per group") + if n_answers < 3 or n_attributes % n_answers: + raise ValueError("n_answers must be >= 3 and divide n_attributes") + + rng = np.random.default_rng(seed) + group_ids = np.repeat(np.arange(n_groups), n_entities // n_groups).astype(np.int64) + x = np.column_stack( + ( + np.repeat(np.arange(n_entities), n_attributes), + np.tile(np.arange(n_attributes), n_entities), + ) + ).astype(np.int64) + original = (group_ids[x[:, 0]] + x[:, 1]) % n_answers + edit_mask = group_ids[x[:, 0]] == 0 + rule = original.copy() + rule[edit_mask] = (rule[edit_mask] + 1) % n_answers + exception = original.copy() + # Every edited entity has the same balanced original labels and rule targets. + old_row = original[:n_attributes] + edited_entities = np.flatnonzero(group_ids == 0) + sampled_rows = [] + for row_index, entity in enumerate(edited_entities): + for _ in range(10_000): + candidate = rng.permutation(old_row) + shared_pattern = row_index == len(edited_entities) - 1 and all( + np.array_equal(row, candidate) for row in sampled_rows + ) + if np.all(candidate != old_row) and not shared_pattern: + sampled_rows.append(candidate) + start = entity * n_attributes + exception[start : start + n_attributes] = candidate + break + else: + raise ValueError( + "Could not sample balanced exception patterns in 10,000 attempts; " + "use more answers or fewer attributes to make rejection sampling practical." + ) + return SyntheticWorld( + x, + original, + rule, + exception, + edit_mask, + group_ids, + n_entities, + n_attributes, + n_groups, + n_answers, + seed, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_models.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_models.py new file mode 100644 index 0000000000000000000000000000000000000000..448b3499cdce6fac7d4bcac1e60883f4c383df82 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/neural_models.py @@ -0,0 +1,157 @@ +"""Trainable nonlinear fact models; importing this module requires PyTorch.""" + +import torch +from torch import nn + + +class FactMLP(nn.Module): + """Separate entity/attribute embeddings followed by a nonlinear MLP.""" + + def __init__( + self, + n_entities: int, + n_attributes: int, + n_answers: int, + width: int, + hidden: int, + layers: int, + ) -> None: + super().__init__() + self.entity_embedding = nn.Embedding(n_entities, width) + self.attribute_embedding = nn.Embedding(n_attributes, width) + blocks = [] + for layer in range(layers): + blocks.extend((nn.Linear(2 * width if layer == 0 else hidden, hidden), nn.GELU())) + self.hidden = nn.Sequential(*blocks) + self.answer_head = nn.Linear(hidden, n_answers) + + def forward(self, facts: torch.Tensor) -> torch.Tensor: + _validate_facts(facts) + embedded = torch.cat( + ( + self.entity_embedding(facts[:, 0]), + self.attribute_embedding(facts[:, 1]), + ), + dim=-1, + ) + return self.answer_head(self.hidden(embedded)) + + +class FactTransformer(nn.Module): + """Causal [ENTITY, ATTRIBUTE, QUERY] transformer with an answer classification head.""" + + def __init__( + self, + n_entities: int, + n_attributes: int, + n_answers: int, + width: int, + hidden: int, + layers: int, + heads: int, + ) -> None: + super().__init__() + self.n_entities = n_entities + self.query_id = n_entities + n_attributes + self.token_embedding = nn.Embedding(self.query_id + 1, width) + self.position_embedding = nn.Embedding(3, width) + encoder_layer = nn.TransformerEncoderLayer( + d_model=width, + nhead=heads, + dim_feedforward=hidden, + dropout=0.0, + activation="gelu", + batch_first=True, + norm_first=True, + ) + self.encoder = nn.TransformerEncoder( + encoder_layer, + num_layers=layers, + norm=nn.LayerNorm(width), + enable_nested_tensor=False, + ) + # TransformerEncoder clones its prototype; initialize each layer independently. + for layer in self.encoder.layers: + nn.init.xavier_uniform_(layer.self_attn.in_proj_weight) + for module in layer.modules(): + if isinstance(module, nn.Linear): + nn.init.xavier_uniform_(module.weight) + if module.bias is not None: + nn.init.zeros_(module.bias) + self.answer_head = nn.Linear(width, n_answers) + self.register_buffer("causal_mask", torch.triu(torch.ones(3, 3, dtype=torch.bool), 1)) + + def forward(self, facts: torch.Tensor) -> torch.Tensor: + _validate_facts(facts) + tokens = torch.stack( + ( + facts[:, 0], + facts[:, 1] + self.n_entities, + torch.full_like(facts[:, 0], self.query_id), + ), + dim=1, + ) + embedded = self.token_embedding(tokens) + embedded = embedded + self.position_embedding(torch.arange(3, device=facts.device)) + encoded = self.encoder(embedded, mask=self.causal_mask) + return self.answer_head(encoded[:, -1]) + + +def _validate_facts(facts: torch.Tensor) -> None: + if facts.ndim != 2 or facts.shape[1] != 2 or facts.dtype != torch.long: + raise ValueError("facts must be an int64 tensor with shape (n_facts, 2)") + + +def build_model( + model_type: str, + n_entities: int, + n_attributes: int, + n_answers: int, + width: int = 32, + hidden: int = 64, + layers: int = 2, + heads: int = 4, +) -> nn.Module: + """Construct an MLP or a causal transformer; initialization uses the torch RNG.""" + for name, value in { + "n_entities": n_entities, + "n_attributes": n_attributes, + "n_answers": n_answers, + "width": width, + "hidden": hidden, + "layers": layers, + "heads": heads, + }.items(): + if isinstance(value, bool) or not isinstance(value, int) or value <= 0: + raise ValueError(f"{name} must be a positive integer") + if model_type == "mlp": + return FactMLP(n_entities, n_attributes, n_answers, width, hidden, layers) + if model_type == "transformer": + if width % heads: + raise ValueError("transformer width must be divisible by heads") + return FactTransformer(n_entities, n_attributes, n_answers, width, hidden, layers, heads) + raise ValueError("model_type must be 'mlp' or 'transformer'") + + +def edit_parameters(model: nn.Module, scope: str = "ffn") -> list[nn.Parameter]: + """Freeze outside the chosen edit scope, returning the exact optimizer parameters.""" + if scope not in {"ffn", "all"}: + raise ValueError("scope must be 'ffn' or 'all'") + if scope == "all": + selected = list(model.parameters()) + elif isinstance(model, FactMLP): + selected = list(model.hidden.parameters()) + elif isinstance(model, FactTransformer): + selected = [ + parameter + for layer in model.encoder.layers + for linear in (layer.linear1, layer.linear2) + for parameter in linear.parameters() + ] + else: + raise ValueError("ffn scope requires a FactMLP or FactTransformer") + selected_ids = {id(parameter) for parameter in selected} + for parameter in model.parameters(): + parameter.requires_grad_(id(parameter) in selected_ids) + parameter.grad = None + return selected diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture.py new file mode 100644 index 0000000000000000000000000000000000000000..a254bf6f90931d21d80c57972a6770ad6665c13a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture.py @@ -0,0 +1,443 @@ +"""Paired GPT-2 architecture extensions for the closed-book memory experiment. + +Dense execution delegates to the historical ReproductionGPT without changing +its numerical path. New modules use an independent, checkpointed initialization +seed; the eight-block reference is always constructed before taking a prefix. +The mHC residual convention is ``output[n] = sum_m H_res[m,n] * input[m]``. +""" + +from __future__ import annotations + +import hashlib +import math +from collections.abc import Sequence + +import torch +from torch import nn +from torch.nn import functional as F +from transformers import GPT2Config +from transformers.models.gpt2.modeling_gpt2 import GPT2MLP + +from .grokking_reproduction import ReproductionGPT + +ARMS = { + "D4": (4, 1, "dense"), + "D8": (8, 1, "dense"), + "L4R2": (4, 2, "dense"), + "M8": (8, 1, "moe"), + "W8": (8, 1, "wide"), + "IHC8": (8, 1, "identity_mhc"), + "HC8": (8, 1, "mhc"), + "M4": (4, 1, "moe"), + "LM4R2": (4, 2, "moe"), +} + + +def sinkhorn(logits: torch.Tensor, iterations: int = 20, eps: float = 1e-6): + """Accepted mHC A.6: initial row softmax, then 20 column normalizations. + + There are 19 intervening row normalizations. This is a finite-iteration + approximation, not an exact doubly stochastic projection. + """ + if iterations < 1: + raise ValueError("Sinkhorn requires at least one iteration") + with torch.autocast(logits.device.type, enabled=False): + matrix = logits.float().softmax(dim=-1) + eps + matrix = matrix / (matrix.sum(dim=-2, keepdim=True) + eps) + for _ in range(iterations - 1): + matrix = matrix / (matrix.sum(dim=-1, keepdim=True) + eps) + matrix = matrix / (matrix.sum(dim=-2, keepdim=True) + eps) + return matrix + + +def residual_mix(streams, matrix): + """Rows are source streams and columns are destination streams.""" + return torch.einsum("...mn,...mc->...nc", matrix, streams) + + +class ControllerRMSNorm(nn.Module): + def __init__(self, width): + super().__init__() + self.weight = nn.Parameter(torch.ones(width)) + + def forward(self, x): + return x * torch.rsqrt(x.square().mean(dim=-1, keepdim=True) + 1e-20) * self.weight + + +class HyperConnection(nn.Module): + """Four-stream pre/post controller with optional constrained residual map.""" + + def __init__(self, width, sublayer_id, streams=4, identity=False): + super().__init__() + self.streams, self.identity = streams, identity + count = 2 * streams + (0 if identity else streams * streams) + self.norm = ControllerRMSNorm(streams * width) + self.projection = nn.Linear(streams * width, count, bias=False) + nn.init.zeros_(self.projection.weight) + self.pre_bias = nn.Parameter(torch.full((streams,), -3.0)) + with torch.no_grad(): + self.pre_bias[sublayer_id % streams] = 3.0 + self.post_bias = nn.Parameter(torch.zeros(streams)) + self.alpha_pre = nn.Parameter(torch.tensor(0.01)) + self.alpha_post = nn.Parameter(torch.tensor(0.01)) + if not identity: + self.res_bias = nn.Parameter(6 * torch.eye(streams) - 3) + self.alpha_res = nn.Parameter(torch.tensor(0.01)) + + def coefficients(self, x): + n = self.streams + with torch.autocast(x.device.type, enabled=False): + dynamic = self.projection(self.norm(x.float().flatten(-2))) + pre = torch.sigmoid(dynamic[..., :n] * self.alpha_pre + self.pre_bias) + 1e-6 + post = 2 * torch.sigmoid(dynamic[..., n : 2 * n] * self.alpha_post + self.post_bias) + res = None + if not self.identity: + logits = dynamic[..., 2 * n :].reshape(*x.shape[:-2], n, n) + res = sinkhorn(logits * self.alpha_res + self.res_bias) + return pre, post, res + + def forward(self, x, sublayer): + pre, post, res = self.coefficients(x) + with torch.autocast(x.device.type, enabled=False): + contracted = (pre[..., None] * x.float()).sum(dim=-2) + y = sublayer(contracted.to(x.dtype)) + with torch.autocast(x.device.type, enabled=False): + residual = x.float() if res is None else residual_mix(x.float(), res) + output = residual + post[..., None] * y.float().unsqueeze(-2) + return output.to(x.dtype) + + +def _initialize_mlp(mlp, initializer_range): + # Eight-block GPT-2 reference residual projection scale, also for loops. + nn.init.normal_(mlp.c_fc.weight, std=initializer_range) + nn.init.normal_(mlp.c_proj.weight, std=initializer_range / math.sqrt(2 * 8)) + nn.init.zeros_(mlp.c_fc.bias) + nn.init.zeros_(mlp.c_proj.bias) + + +class DroplessMoE(nn.Module): + """Top-2 normalized routing, one output dropout, no capacity/token drops.""" + + def __init__(self, config, experts=8, top_k=2): + super().__init__() + self.expert_count, self.top_k = experts, top_k + self.router = nn.Linear(config.n_embd, experts, bias=False) + nn.init.normal_(self.router.weight, std=config.initializer_range) + self.experts = nn.ModuleList() + for _ in range(experts): + expert = GPT2MLP(2 * config.n_embd, config) + expert.dropout = nn.Identity() + _initialize_mlp(expert, config.initializer_range) + self.experts.append(expert) + self.dropout = nn.Dropout(config.resid_pdrop) + + def forward(self, x, valid_mask=None): + flat = x.reshape(-1, x.shape[-1]) + if valid_mask is None: + selected_tokens = torch.arange(len(flat), device=x.device) + else: + selected_tokens = valid_mask.flatten().nonzero(as_tuple=True)[0] + valid = flat.index_select(0, selected_tokens) + with torch.autocast(x.device.type, enabled=False): + probabilities = F.linear(valid.float(), self.router.weight.float()).softmax(-1) + top_weights, expert_ids = probabilities.topk(self.top_k, dim=-1) + weights = top_weights / top_weights.sum(dim=-1, keepdim=True) + # Accumulate selected expert outputs in FP32 for consistent BF16 routing. + combined = torch.zeros_like(valid, dtype=torch.float32) + for expert_id, expert in enumerate(self.experts): + token_ids, slots = (expert_ids == expert_id).nonzero(as_tuple=True) + if token_ids.numel(): + values = expert(valid.index_select(0, token_ids)) + weighted = values.float() * weights[token_ids, slots, None] + combined = combined.index_add(0, token_ids, weighted) + output = torch.zeros_like(flat).index_copy(0, selected_tokens, combined.to(flat.dtype)) + counts = torch.bincount(expert_ids.flatten(), minlength=self.expert_count).detach() + n_valid = probabilities.new_tensor(len(valid)) + stats = { + "assignment_counts": counts, + "probability_sum": probabilities.sum(dim=0), + "valid_tokens": n_valid, + "top_k": self.top_k, + "processed_assignments": counts.sum(), + "dropped_assignments": counts.new_zeros(()), + "entropy_sum": -(probabilities * probabilities.clamp_min(1e-30).log()).sum().detach(), + "selected_mass_sum": top_weights.sum().detach(), + } + return self.dropout(output.view_as(x)), stats + + +def combine_router_fractions(stats_by_microbatch: Sequence[Sequence[dict]]): + """Combine detached counts before a replay that computes exact batch aux. + + Counts are per executed block (thus distinguish Loop passes). Replay must + restore dropout RNG state, so its hard routes equal the counting pass. + """ + if not stats_by_microbatch or not stats_by_microbatch[0]: + return [], 0 + layers = len(stats_by_microbatch[0]) + if any(len(stats) != layers for stats in stats_by_microbatch): + raise ValueError("All microbatches must have the same executed routing layers") + total = sum(stats[0]["valid_tokens"] for stats in stats_by_microbatch) + fractions = [] + for layer in range(layers): + counts = sum(stats[layer]["assignment_counts"] for stats in stats_by_microbatch) + fractions.append( + counts.float() / (total * stats_by_microbatch[0][layer]["top_k"]).clamp_min(1) + ) + return fractions, total + + +def router_balance_loss(stats, assignment_fractions=None, total_valid_tokens=None): + """N * sum(f * p), averaged over executed layers. + + With externally supplied whole-batch fractions and denominator, this returns + the current microbatch's additive contribution to the exact batch objective. + Assignment fractions are discrete and intentionally detached. + """ + if not stats: + return torch.tensor(0.0) + if assignment_fractions is not None and len(assignment_fractions) != len(stats): + raise ValueError("One assignment-fraction vector is required per executed layer") + losses = [] + for index, record in enumerate(stats): + count = record["valid_tokens"] + denominator = count if total_valid_tokens is None else total_valid_tokens + denominator = torch.as_tensor(denominator, device=count.device).clamp_min(1) + fractions = ( + record["assignment_counts"].float() / (count * record["top_k"]).clamp_min(1) + if assignment_fractions is None + else assignment_fractions[index].detach() + ) + probabilities = record["probability_sum"] / denominator + losses.append(probabilities.numel() * (fractions * probabilities).sum()) + return torch.stack(losses).mean() + + +class ParametricGPT(ReproductionGPT): + def __init__(self, config, architecture="D8", module_seed=0): + blocks, repeats, kind = ARMS[architecture] + # Always initialize the same independent eight blocks before slicing. + config.n_layer = 8 + super().__init__(config, repeats=repeats) + self.transformer.h = nn.ModuleList(list(self.transformer.h)[:blocks]) + self.config.n_layer = blocks + self.architecture, self.kind, self.module_seed = architecture, kind, module_seed + with torch.random.fork_rng(devices=[]): + torch.manual_seed(module_seed) + if kind in {"wide", "moe"}: + for block in self.transformer.h: + if kind == "moe": + block.mlp = DroplessMoE(config) + else: + block.mlp = GPT2MLP(16 * config.n_embd, config) + _initialize_mlp(block.mlp, config.initializer_range) + elif kind in {"mhc", "identity_mhc"}: + self.connections = nn.ModuleList( + HyperConnection(config.n_embd, index, identity=kind == "identity_mhc") + for index in range(2 * blocks) + ) + + def _attention(self, block, x): + cfg = self.config + batch, length = x.shape[:2] + q, k, v = block.attn.c_attn(block.ln_1(x)).split(cfg.n_embd, dim=2) + shape = (batch, length, cfg.n_head, cfg.n_embd // cfg.n_head) + q, k, v = (a.view(shape).transpose(1, 2) for a in (q, k, v)) + y = F.scaled_dot_product_attention( + q, k, v, is_causal=True, dropout_p=cfg.attn_pdrop if self.training else 0.0 + ) + y = block.attn.c_proj(y.transpose(1, 2).reshape(batch, length, cfg.n_embd)) + return F.dropout(y, cfg.resid_pdrop, self.training) + + def forward(self, tokens, positions=None, *, valid_mask=None, return_aux=False): + if valid_mask is not None and ( + valid_mask.shape != tokens.shape or valid_mask.dtype != torch.bool + ): + raise ValueError("valid_mask must be boolean and have the tokens' shape") + if self.kind in {"dense", "wide"}: + logits = super().forward(tokens, positions) + if return_aux: + return logits, {"balance_loss": logits.new_zeros(()), "router_stats": []} + return logits + cfg, t = self.config, self.transformer + length = tokens.shape[1] + x = t.wte(tokens) + t.wpe(torch.arange(length, device=tokens.device)) + x = F.dropout(x, cfg.embd_pdrop, self.training) + stats = [] + if self.kind in {"mhc", "identity_mhc"}: + x = x.unsqueeze(-2).expand(-1, -1, 4, -1) + for _ in range(self.repeats): + for index, block in enumerate(t.h): + if self.kind == "moe": + x = x + self._attention(block, x) + y, layer_stats = block.mlp(block.ln_2(x), valid_mask) + x = x + y + stats.append(layer_stats) + else: + x = self.connections[2 * index](x, lambda z, b=block: self._attention(b, z)) + x = self.connections[2 * index + 1](x, lambda z, b=block: b.mlp(b.ln_2(z))) + if self.kind in {"mhc", "identity_mhc"}: + x = x.mean(dim=-2) + x = t.ln_f(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + logits = F.linear(x, t.wte.weight) + if return_aux: + loss = router_balance_loss(stats) if stats else logits.new_zeros(()) + return logits, {"balance_loss": loss, "router_stats": stats} + return logits + + +def construct(config, spec, device): + """Historical config/spec convention, extended by ``spec['architecture']``.""" + architecture = spec["architecture"] + if architecture not in ARMS: + raise ValueError(f"Unknown architecture: {architecture}") + torch.manual_seed(spec["initialization"]) + cfg = GPT2Config( + vocab_size=config["vocab_size"], + n_positions=config.get("positions", 1024), + n_embd=config["hidden_size"], + n_head=config.get("attention_heads", config.get("heads", 12)), + n_layer=8, + resid_pdrop=config["dropout"], + embd_pdrop=config["dropout"], + attn_pdrop=config["dropout"], + activation_function="gelu_new", + use_cache=False, + ) + # Separate reproducible new-shape RNG, explicitly recorded in the manifest. + module_seed = spec.get("module_initialization", spec["initialization"] + 1_000_003) + model = ParametricGPT(cfg, architecture, module_seed) + model.initialization_seed = spec["initialization"] + return model.to(device) + + +def optimizer_for(model, lr, decay): + groups = [{"params": [], "weight_decay": decay}, {"params": [], "weight_decay": 0.0}] + for name, parameter in model.named_parameters(): + if not parameter.requires_grad: + continue + exempt = any(part in name for part in ("bias", "ln")) + exempt |= name.startswith("connections.") and (".norm." in name or ".alpha_" in name) + groups[int(exempt)]["params"].append(parameter) + return torch.optim.AdamW( + groups, lr=lr, betas=(0.9, 0.999), eps=1e-8, fused=next(model.parameters()).is_cuda + ) + + +def parameter_ledger(model): + d, layers = model.config.n_embd, len(model.transformer.h) + total = sum(parameter.numel() for parameter in model.parameters()) + expert = sum(p.numel() for n, p in model.named_parameters() if ".experts." in n) + controller = sum(p.numel() for n, p in model.named_parameters() if n.startswith("connections.")) + router = sum(p.numel() for n, p in model.named_parameters() if ".router." in n) + fixed = (model.config.vocab_size + model.config.n_positions) * d + 2 * d + attention_and_norms = 4 * d * d + 8 * d + if model.kind == "moe": + per_block = attention_and_norms + 8 * (4 * d * d + 3 * d) + 8 * d + else: + width = (16 if model.kind == "wide" else 4) * d + per_block = attention_and_norms + 2 * d * width + width + d + expected_controller = 0 + if model.kind in {"mhc", "identity_mhc"}: + n = 4 + count = 2 * n + (n * n if model.kind == "mhc" else 0) + alphas = 3 if model.kind == "mhc" else 2 + expected_controller = 2 * layers * (n * d * count + n * d + count + alphas) + if controller != expected_controller: + raise AssertionError( + f"Controller parameter mismatch: {controller} != {expected_controller}" + ) + expected = fixed + layers * per_block + expected_controller + if total != expected: + raise AssertionError(f"Parameter ledger mismatch: {total} != {expected}") + return { + "architecture": model.architecture, + "total_parameters": total, + "trainable_parameters": sum(p.numel() for p in model.parameters() if p.requires_grad), + "expected_parameters": expected, + "expert_parameters": expert, + "router_parameters": router, + "controller_parameters": controller, + "nominal_parameters_selected_per_token": total - expert + expert // 4, + "active_parameter_convention": ( + "All nonexpert parameters (including whole embedding table) plus two of eight " + "experts; not FLOPs or touched embedding rows." + ), + "unique_blocks": layers, + "repeats": model.repeats, + "executed_blocks": layers * model.repeats, + "residual_streams": 4 if controller else 1, + "parameter_dtype": str(next(model.parameters()).dtype), + "residual_dtype_under_bf16_autocast": "torch.float32 with FP32 parameters", + "controller_dtype": "torch.float32", + } + + +def flop_ledger(model, *, executed_tokens, projected_positions, attention_pairs, valid_tokens=None): + """Leading forward matmuls with actual padding/dispatch/readout counts. + + ``attention_pairs`` is sum(B*T*T) over microbatches, before block count. + Training 3x is explicitly an approximation; Sinkhorn autograd, scalar ops, + and a counting/replay pass are not silently folded into this estimate. + """ + d, blocks = model.config.n_embd, len(model.transformer.h) * model.repeats + valid_tokens = executed_tokens if valid_tokens is None else valid_tokens + attention = blocks * (8 * executed_tokens * d * d + 4 * attention_pairs * d) + readout = 2 * projected_positions * d * model.config.vocab_size + router = controller = 0 + if model.kind == "moe": + ffn = blocks * 4 * valid_tokens * d * (2 * 2 * d) + router = blocks * 2 * valid_tokens * d * 8 + else: + inner = (16 if model.kind == "wide" else 4) * d + ffn = blocks * 4 * executed_tokens * d * inner + if model.kind in {"mhc", "identity_mhc"}: + n = 4 + count = 2 * n + (n * n if model.kind == "mhc" else 0) + controller = ( + 2 * blocks * (2 * executed_tokens * n * d * count + 2 * executed_tokens * d * count) + ) + forward = attention + readout + ffn + router + controller + return { + "forward_attention_matmul_flops": attention, + "forward_ffn_matmul_flops": ffn, + "forward_readout_matmul_flops": readout, + "forward_router_matmul_flops": router, + "forward_controller_matmul_flops": controller, + "forward_leading_matmul_flops": forward, + "estimated_matmul_training_flops": 3 * forward, + "sinkhorn_normalization_passes": 39 if model.kind == "mhc" else 0, + "sinkhorn_matrix_elements_per_forward": 2 * blocks * executed_tokens * 16 + if model.kind == "mhc" + else 0, + "selected_expert_assignments": blocks * valid_tokens * 2 if model.kind == "moe" else 0, + "executed_input_tokens": executed_tokens, + "effective_input_tokens": valid_tokens, + "projected_positions": projected_positions, + "excluded_ops": ( + "Nonlinearities, normalization, dropout, dispatch/index-add, softmax, Sinkhorn " + "scalar arithmetic/autograd, final mean, counting/replay and optimizer; " + "3x is approximate." + ), + } + + +def initialization_manifest(model): + """CPU-byte hashes of each actual initialized tensor; no sampled hash.""" + shared, introduced = {}, {} + for name, tensor in model.state_dict().items(): + is_new = name.startswith("connections.") or ( + model.kind in {"moe", "wide"} and ".mlp." in name + ) + raw = tensor.detach().cpu().contiguous().reshape(-1).view(torch.uint8).numpy().tobytes() + (introduced if is_new else shared)[name] = hashlib.sha256(raw).hexdigest() + return { + "architecture": model.architecture, + "reference_initialization": getattr(model, "initialization_seed", None), + "module_initialization": model.module_seed, + "reference_blocks_before_slicing": 8, + "shared_tensor_sha256": shared, + "introduced_tensor_sha256": introduced, + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture_train.py new file mode 100644 index 0000000000000000000000000000000000000000..55c77a2f48a116b87a2159b90bb2ab76a6730887 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/parametric_architecture_train.py @@ -0,0 +1,626 @@ +"""Resumable, exposure-matched training for the parametric architecture study. + +The ordinary data stream, answer-plus-EOS objective and generated evaluator are +shared with the historical experiment. MoE balancing is computed over the true +effective batch using an RNG-replayed routing pass, not a sum of local products. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import os +import random +import time +from pathlib import Path + +import numpy as np +import torch +import transformers +from transformers import GPT2TokenizerFast + +from . import realworld_composition as historical +from .grok_depth import utc +from .grokking_reproduction import model_digest +from .realworld_composition_data import sha256, write_json + + +def _architecture(): + from . import parametric_architecture + + return parametric_architecture + + +def rng_state(device): + state = { + "python": random.getstate(), + "numpy": np.random.get_state(), + "cpu": torch.get_rng_state(), + } + if torch.device(device).type == "cuda": + state["cuda"] = torch.cuda.get_rng_state(device) + return state + + +def restore_rng(state, device): + random.setstate(state["python"]) + np.random.set_state(state["numpy"]) + torch.set_rng_state(state["cpu"].cpu()) + if "cuda" in state: + torch.cuda.set_rng_state(state["cuda"].cpu(), device) + + +def pack(records, pad, device): + """EOS is a valid input token; validity comes from lengths, never token IDs.""" + tokens, positions, labels = historical.pack(records, pad, device) + lengths = torch.tensor([len(r["encoded"]["input"]) for r in records], device=device) + valid = torch.arange(tokens.shape[1], device=device)[None] < lengths[:, None] + return tokens, positions, labels, valid + + +def _synchronize(device): + if torch.device(device).type == "cuda": + torch.cuda.synchronize(device) + + +def _finite(value, name): + if not math.isfinite(float(value)): + raise FloatingPointError(f"Nonfinite {name}; this candidate must retain its failure") + + +def update(model, optimizer, records, spec, device, pad): + """One historical effective batch, with exact full-batch routing gradients. + + Hard assignment fractions have no gradient. A no-grad pass collects their + global values when there are multiple microbatches; replaying the same + dropout RNG realizes the same routing in the differentiable pass. One + microbatch already contains the full objective and needs no prepass. + """ + if not records: + raise ValueError("An update requires at least one example") + microbatch = int(spec["microbatch_size"]) + if microbatch < 1: + raise ValueError("microbatch_size must be positive") + api = _architecture() + model.train() + optimizer.zero_grad(set_to_none=True) + chunks = [records[i : i + microbatch] for i in range(0, len(records), microbatch)] + is_moe = spec["architecture"] in {"M8", "M4", "LM4R2"} + needs_prepass = is_moe and len(chunks) > 1 + coefficient = float(spec.get("balance_coefficient", 0.01)) if is_moe else 0.0 + global_fractions, total_tokens, collected = None, None, [] + if needs_prepass: + before = rng_state(device) + try: + with torch.no_grad(): + for chunk in chunks: + tokens, positions, _, valid = pack(chunk, pad, device) + with historical.autocast(device): + _, aux = model(tokens, positions, valid_mask=valid, return_aux=True) + collected.append(aux["router_stats"]) + global_fractions, total_tokens = api.combine_router_fractions(collected) + finally: + restore_rng(before, device) + answer_loss, balance_loss = 0.0, 0.0 + executed, readout, attention = 0, 0, 0 + replay_count_error = torch.zeros((), dtype=torch.int64, device=device) + for chunk_index, chunk in enumerate(chunks): + tokens, positions, labels, valid = pack(chunk, pad, device) + with historical.autocast(device): + logits, aux = model(tokens, positions, valid_mask=valid, return_aux=True) + answer = historical.example_losses(logits, labels).sum() / len(records) + balance = ( + api.router_balance_loss( + aux["router_stats"], + assignment_fractions=global_fractions, + total_valid_tokens=total_tokens, + ) + if is_moe + else answer.new_zeros(()) + ) + loss = answer + coefficient * balance + if needs_prepass: + replay_count_error += sum( + (left["assignment_counts"] - right["assignment_counts"]).abs().sum() + for left, right in zip(collected[chunk_index], aux["router_stats"], strict=True) + ) + elif is_moe: + collected = [aux["router_stats"]] + global_fractions, total_tokens = api.combine_router_fractions(collected) + _finite(loss.detach(), "objective") + loss.backward() + answer_loss += float(answer.detach()) + balance_loss += float(balance.detach()) + executed += tokens.numel() + readout += positions.numel() + attention += len(chunk) * tokens.shape[1] ** 2 + if int(replay_count_error) != 0: + raise RuntimeError("MoE RNG replay did not reproduce routing assignment counts") + norm = torch.nn.utils.clip_grad_norm_( + model.parameters(), float(spec.get("clip_grad_norm", 1.0)), error_if_nonfinite=True + ) + _finite(norm, "gradient norm") + optimizer.step() + effective = sum(len(r["encoded"]["input"]) for r in records) + result = { + "loss": answer_loss, + "answer_ce": answer_loss, + "balance_loss": balance_loss, + "balance_coefficient": coefficient, + "objective": answer_loss + coefficient * balance_loss, + "gradient_norm": float(norm), + "executed_input_tokens": executed, + "effective_input_tokens": effective, + "padding_input_tokens": executed - effective, + "readout_positions": readout, + "attention_token_pairs": attention, + "routing_prepass_executed_input_tokens": executed if needs_prepass else 0, + "routing_prepass_effective_input_tokens": effective if needs_prepass else 0, + } + result["compute"] = api.flop_ledger( + model, + executed_tokens=executed, + valid_tokens=effective, + projected_positions=readout, + attention_pairs=attention, + ) + prepass = result["compute"]["forward_leading_matmul_flops"] if needs_prepass else 0 + result["compute"]["routing_prepass_matmul_flops"] = prepass + result["estimated_matmul_training_flops"] = ( + result["compute"]["estimated_matmul_training_flops"] + prepass + ) + result["compute"]["estimated_total_training_matmul_flops"] = result[ + "estimated_matmul_training_flops" + ] + if is_moe: + layer_count = len(global_fractions) + assignments = torch.stack( + [sum(c[layer]["assignment_counts"] for c in collected) for layer in range(layer_count)] + ) + processed = torch.stack( + [ + sum(c[layer]["processed_assignments"] for c in collected) + for layer in range(layer_count) + ] + ) + dropped = sum(s["dropped_assignments"] for c in collected for s in c) + if int(dropped) != 0 or not torch.equal(processed, assignments.sum(-1)): + raise AssertionError("Dropless routing lost selected token assignments") + result["router"] = { + "assignment_fractions": torch.stack(global_fractions).detach().cpu().tolist(), + "assignment_counts": assignments.detach().cpu().tolist(), + "valid_tokens_per_layer": effective, + "selected_assignments_per_layer": assignments.sum(-1).detach().cpu().tolist(), + "processed_assignments_per_layer": processed.detach().cpu().tolist(), + "router_entropy_per_layer": torch.stack( + [ + sum(c[layer]["entropy_sum"] for c in collected) / effective + for layer in range(layer_count) + ] + ) + .detach() + .cpu() + .tolist(), + "selected_probability_mass_per_layer": torch.stack( + [ + sum(c[layer]["selected_mass_sum"] for c in collected) / effective + for layer in range(layer_count) + ] + ) + .detach() + .cpu() + .tolist(), + "dropped_assignments": int(dropped), + "replay_assignment_count_error": int(replay_count_error), + "replay_checked": needs_prepass, + "balance_scope": ( + "full_effective_batch_two_pass_rng_replay" + if needs_prepass + else "full_effective_batch_single_forward" + ), + } + return result + + +def selection_score(metrics): + """Frozen development panels only; no held-out-composition selection.""" + atomic, composition = metrics["atomic"]["nll"], metrics["train_composition"]["nll"] + if atomic is None or composition is None: + raise ValueError("Both fixed development panels need answer NLL measurements") + value = 0.5 * atomic + 0.5 * composition + _finite(value, "development selection NLL") + return value + + +def _routing_metrics(router): + """Expose numeric dictionaries to the existing W&B sidecar's flattening.""" + if not router: + return {} + return { + "dropped_assignments": router["dropped_assignments"], + "replay_assignment_count_error": router["replay_assignment_count_error"], + "layers": { + str(layer): { + "entropy": router["router_entropy_per_layer"][layer], + "selected_probability_mass": router["selected_probability_mass_per_layer"][layer], + "expert_fraction": {str(i): value for i, value in enumerate(fractions)}, + } + for layer, fractions in enumerate(router["assignment_fractions"]) + }, + } + + +def save_checkpoint(path, model, optimizer, stream, counts, step, counters, device, **extra): + path = Path(path) + temporary = path.with_suffix(".tmp") + torch.save( + { + "format_version": 1, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "step": step, + "counters": counters, + "rng": rng_state(device), + **extra, + }, + temporary, + ) + temporary.replace(path) + + +def load_checkpoint(path, model, optimizer, stream, device): + state = torch.load(path, map_location="cpu", weights_only=False) + model.load_state_dict(state["model"]) + optimizer.load_state_dict(state["optimizer"]) + stream.load_state_dict(state["stream"]) + restore_rng(state["rng"], device) + return state + + +def _identity(config, spec): + payload = { + "model": config["model"], + "spec": spec, + "data_sha256": config["data_sha256"], + "tokenizer_sha256": config.get("tokenizer_sha256", config.get("tokenizer_files", {})), + "source_files": config.get("source_files", {}), + } + return hashlib.sha256(json.dumps(payload, sort_keys=True).encode()).hexdigest() + + +def verify(config, config_path=None): + """Check the concrete execution freeze; the historical design is not mutated.""" + if config.get("launch_enabled") is False: + raise ValueError("This configuration explicitly disables execution") + if sha256(config["data_file"]) != config["data_sha256"]: + raise ValueError("Frozen data changed") + for name, expected in config.get("tokenizer_sha256", {}).items(): + path = Path(config["tokenizer"]) / name + if sha256(path) != expected: + raise ValueError(f"Frozen tokenizer changed: {path}") + for group in ("tokenizer_files", "source_files"): + for path, expected in config.get(group, {}).items(): + if sha256(path) != expected: + raise ValueError(f"Frozen {group} changed: {path}") + if config.get("source_root"): + root = Path(config["source_root"]).resolve() + for module in (Path(__file__), Path(_architecture().__file__), Path(historical.__file__)): + if not module.resolve().is_relative_to(root): + raise ValueError(f"Imported code is outside the frozen source_root: {module}") + if config_path is not None: + if not config.get("execution_lock"): + raise ValueError("CLI requires an execution_lock with the frozen config hash") + lock = json.loads(Path(config["execution_lock"]).read_text()) + if lock["config_sha256"] != sha256(config_path): + raise ValueError("Frozen configuration changed") + if "torch" in lock.get("environment", {}): + if str(torch.__version__) != lock["environment"]["torch"]: + raise ValueError("Frozen torch version changed") + if "transformers" in lock.get("environment", {}): + if transformers.__version__ != lock["environment"]["transformers"]: + raise ValueError("Frozen transformers version changed") + + +def _setup(device, config): + torch.set_num_threads(int(config.get("cpu_threads", 4))) + if torch.device(device).type == "cuda": + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.cuda.reset_peak_memory_stats(device) + + +def _resources(device): + if torch.device(device).type != "cuda": + return {"peak_gpu_memory_bytes": 0, "peak_gpu_reserved_bytes": 0} + return { + "peak_gpu_memory_bytes": torch.cuda.max_memory_allocated(device), + "peak_gpu_reserved_bytes": torch.cuda.max_memory_reserved(device), + } + + +def _process_identity(): + """Different containers can both run Python as PID 1; identify the namespace.""" + identity = {"pid": os.getpid()} + if Path("/proc/self/stat").exists(): + identity["pid_namespace"] = os.readlink("/proc/self/ns/pid") + identity["start_ticks"] = Path("/proc/self/stat").read_text().rsplit(")", 1)[1].split()[19] + return identity + + +def run(config, spec, out, device="cuda:0"): + """Train one frozen candidate. An independent process must subsequently audit.""" + verify(config) + _setup(device, config) + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "trained.json").exists(): + trained = json.loads((out / "trained.json").read_text()) + if trained["identity"] != _identity(config, spec): + raise ValueError("Existing output belongs to a different frozen training recipe") + return trained + api = _architecture() + data = json.loads(Path(config["data_file"]).read_text()) + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + records = data["atoms"] + data["train_compositions"] + model = api.construct(config["model"], spec, device) + optimizer = api.optimizer_for(model, spec["learning_rate"], spec["weight_decay"]) + stream = historical.BatchStream(len(records), spec["sampling_seed"]) + identity = _identity(config, spec) + counts = np.zeros(len(records), dtype=np.int64) + counters = { + "training_seconds": 0.0, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "effective_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "routing_prepass_executed_input_tokens": 0, + } + initial_step, wall_offset, history, last = 0, 0.0, [], {} + if (out / "latest.pt").exists(): + saved = load_checkpoint(out / "latest.pt", model, optimizer, stream, device) + if saved["identity"] != identity: + raise ValueError("Checkpoint belongs to a different frozen training recipe") + counts, initial_step, counters = saved["counts"], saved["step"], saved["counters"] + wall_offset, last = saved.get("wall_seconds", 0.0), saved.get("last_update", {}) + learning = out / "learning.json" + history = [r for r in json.loads(learning.read_text()) if r["step"] <= initial_step] + metadata = json.loads((out / "run.json").read_text()) + metadata.update(pid=os.getpid(), resumed_from_step=initial_step) + del saved + else: + torch.manual_seed(spec["dropout_seed"]) + random.seed(spec["dropout_seed"]) + np.random.seed(spec["dropout_seed"]) + metadata = { + "spec": spec, + "model": config["model"], + "phase": config.get("phase", "development"), + "evaluation_nodes": config["evaluation_nodes"], + "world_sha256": config["data_sha256"], + "initial_model_sha256": model_digest(model), + "initial_tensor_sha256": historical.tensor_digests(model), + "initialization_manifest": api.initialization_manifest(model), + "parameters": sum(p.numel() for p in model.parameters()), + "parameter_ledger": api.parameter_ledger(model), + "atomic_examples": len(data["atoms"]), + "composition_examples": len(data["train_compositions"]), + "vocab_size": len(tokenizer), + "dtype": "BF16 AMP; FP32 parameters and Adam states", + "device": str(device), + "gpu": torch.device(device).index or 0, + "gpu_name": torch.cuda.get_device_name(device) + if torch.device(device).type == "cuda" + else "cpu", + "pid": os.getpid(), + "job_type": config.get("phase", "development") + "-training", + "tracking_group": config.get("tracking", {}).get("group", config.get("experiment")), + "learning_step_unit": "optimizer_updates", + "identity": identity, + "selection": "0.5 atomic + 0.5 train-composition NLL on original fixed panels", + "selection_panel_sizes": { + key: len(data["panels"][key]) for key in ("atomic", "train_composition") + }, + "moe_balance": ( + "full-effective-batch; single forward when one microbatch, otherwise two-pass " + "RNG replay; actual prepass compute included" + ), + "learning_rate_schedule": "historical lr * min((step - 1) / warmup_steps, 1)", + } + if config.get("execution_lock"): + metadata["execution_lock_sha256"] = sha256(config["execution_lock"]) + write_json(out / "run.json", metadata) + write_json(out / "learning.json", history) + nodes = set(config["evaluation_nodes"]) | {int(spec["steps"])} + log_interval = int(config.get("log_interval", 100)) + checkpoint_interval = int(config.get("resume_checkpoint_interval", 1000)) + started = time.perf_counter() + + def checkpoint(step): + save_checkpoint( + out / "latest.pt", + model, + optimizer, + stream, + counts, + step, + counters, + device, + identity=identity, + wall_seconds=wall_offset + time.perf_counter() - started, + last_update=last, + ) + + for step in range(initial_step, spec["steps"] + 1): + if step > initial_step: + warmup = int(spec["warmup_steps"]) + lr = spec["learning_rate"] * (min((step - 1) / warmup, 1.0) if warmup else 1.0) + for group in optimizer.param_groups: + group["lr"] = lr + ids = stream.batch(spec["batch_size"]) + selected = [records[i] for i in ids] + _synchronize(device) + begin = time.perf_counter() + last = update(model, optimizer, selected, spec, device, tokenizer.eos_token_id) + _synchronize(device) + counters["training_seconds"] += time.perf_counter() - begin + counts[ids] += 1 + counters["examples"] += len(ids) + counters["supervised_tokens"] += sum(len(r["encoded"]["target"]) for r in selected) + for key in ( + "executed_input_tokens", + "effective_input_tokens", + "estimated_matmul_training_flops", + "routing_prepass_executed_input_tokens", + ): + counters[key] += last[key] + if step in nodes or step % log_interval == 0: + if not any(r["step"] == step for r in history): + metrics = {} + if step in nodes: + metrics, predictions = historical.evaluate_dataset( + model, data, tokenizer, device + ) + write_json(out / f"predictions-{step:07d}.json", predictions) + metrics["selection"] = { + "mixed_answer_nll": selection_score(metrics), + "atomic_n": metrics["atomic"]["nll_n"], + "train_composition_n": metrics["train_composition"]["nll_n"], + } + if last.get("router"): + metrics["routing"] = _routing_metrics(last["router"]) + record = { + "step": step, + "metrics": metrics, + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "loss": last.get("answer_ce"), + "answer_ce": last.get("answer_ce"), + "balance_loss": last.get("balance_loss"), + "objective": last.get("objective"), + "gradient_norm": last.get("gradient_norm"), + "learning_rate": optimizer.param_groups[0]["lr"], + "atomic_epochs": float(counts[: len(data["atoms"])].mean()), + "composition_epochs": float(counts[len(data["atoms"]) :].mean()), + "router": last.get("router", {}), + "compute_per_update": last.get("compute", {}), + **_resources(device), + "created_utc": utc(), + } + history.append(record) + write_json(out / "learning.json", history) + print( + json.dumps({"step": step, "loss": record["loss"], "metrics": metrics}), + flush=True, + ) + write_json( + out / "status.json", + { + "state": "training", + "step": step, + "target_step": spec["steps"], + "loss": last.get("answer_ce"), + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "pid": os.getpid(), + "updated_utc": utc(), + }, + ) + if step in nodes or (step > initial_step and step % checkpoint_interval == 0): + checkpoint(step) + if step in nodes: + target = out / f"checkpoint-{step:07d}.pt" + temporary = target.with_suffix(".tmp") + torch.save( + {"model": model.state_dict(), "step": step, "identity": identity}, temporary + ) + temporary.replace(target) + np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=counts) + metrics, predictions = historical.evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + write_json(out / "endpoint-predictions.json", predictions) + write_json(out / "endpoint.json", metrics) + result = { + "state": "trained_pending_independent_reload", + "step": spec["steps"], + "pid": os.getpid(), + "process_identity": _process_identity(), + "identity": identity, + "model_sha256": model_digest(model), + "checkpoint_sha256": sha256(out / "latest.pt"), + **counters, + "selection_mixed_answer_nll": next( + r["metrics"]["selection"]["mixed_answer_nll"] + for r in reversed(history) + if r["step"] == spec["steps"] + ), + "wall_seconds": wall_offset + time.perf_counter() - started, + "completed_utc": utc(), + } + write_json(out / "trained.json", result) + write_json(out / "status.json", result) + return result + + +def audit(config, spec, out, device="cuda:0"): + """Reconstruct and regenerate the full endpoint in an independent process.""" + verify(config) + _setup(device, config) + out = Path(out) + trained = json.loads((out / "trained.json").read_text()) + same_process = ( + trained["process_identity"] == _process_identity() + if "process_identity" in trained + else trained["pid"] == os.getpid() + ) + if same_process: + raise ValueError("Independent audit must run in a different process") + if trained["identity"] != _identity(config, spec): + raise ValueError("Audit recipe differs from the training freeze") + if sha256(out / "latest.pt") != trained["checkpoint_sha256"]: + raise ValueError("Training checkpoint changed") + model = _architecture().construct(config["model"], spec, device) + checkpoint = torch.load(out / "latest.pt", map_location="cpu", weights_only=False) + if checkpoint["step"] != spec["steps"]: + raise ValueError("Final checkpoint does not contain the requested endpoint") + model.load_state_dict(checkpoint["model"]) + del checkpoint + if model_digest(model) != trained["model_sha256"]: + raise ValueError("Reloaded model does not match the trained endpoint") + data = json.loads(Path(config["data_file"]).read_text()) + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + metrics, predictions = historical.evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + if predictions != json.loads((out / "endpoint-predictions.json").read_text()): + raise AssertionError("Independent endpoint generation or NLL failed exact reproduction") + if metrics != json.loads((out / "endpoint.json").read_text()): + raise AssertionError("Independent endpoint metric recount failed") + result = { + "passed": True, + "pid": os.getpid(), + "source_training_pid": trained["pid"], + "process_identity": _process_identity(), + "source_process_identity": trained.get("process_identity"), + "checkpoint_sha256": trained["checkpoint_sha256"], + "model_sha256": trained["model_sha256"], + "predictions_recomputed": sum(len(p) for p in predictions.values()), + "completed_utc": utc(), + } + write_json(out / "audit.json", result) + write_json( + out / "complete.json", {**trained, "state": "complete", "independently_reloaded": True} + ) + write_json( + out / "status.json", + { + "state": "complete", + "step": spec["steps"], + "independently_reloaded": True, + }, + ) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_constraints.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_constraints.py new file mode 100644 index 0000000000000000000000000000000000000000..6181f6dad22ab1a99443ffddb19f67c7c6ad701b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_constraints.py @@ -0,0 +1,94 @@ +"""Constrained response primitives; empirical scopes are recorded by the runner.""" + +from __future__ import annotations + +import hashlib + +import torch + + +def select_records(records, count, seed, role): + """Select before diagnostics, independently of accuracy or measured geometry.""" + if len(records) < count: + raise ValueError(f"Insufficient records for {role}") + return sorted( + records, + key=lambda row: hashlib.sha256(f"{seed}:{role}:{row['case_id']}".encode()).hexdigest(), + )[:count] + + +def psd_solve(gram, rhs, rtol): + values, vectors = torch.linalg.eigh(gram.double()) + eligible = values > values.max().clamp_min(1e-30) * rtol + projected = vectors[:, eligible].T @ rhs.double() + result = vectors[:, eligible] @ (projected / values[eligible]) + return result, int(eligible.sum()) + + +def functional_projection(target, keep, rtol): + """Orthogonal projection onto the numerical null space of keep gradients.""" + g, r = target.double(), keep.double() + coefficients, rank = psd_solve(r @ r.T, r @ g, rtol) + result = g - coefficients @ r + denominator = g.square().sum().clamp_min(1e-30) + return result.to(target.dtype), { + "rank": rank, + "retained_energy": float(result.square().sum() / denominator), + "relative_keep_residual": float( + (r @ result).norm() / (r.norm() * result.norm()).clamp_min(1e-30) + ), + } + + +def feature_basis(features, rtol): + """Rows are real token features; right singular vectors span protected keys.""" + _, singular, vh = torch.linalg.svd(features.double(), full_matrices=False) + selected = singular > singular[0] * rtol + return vh[selected], singular + + +def module_projection(gradient, basis): + g = gradient.double() + return (g - (g @ basis.T) @ basis).to(gradient.dtype) + + +def local_gradients(x, up, gate, down_weight, output_derivative): + """All-position exact SwiGLU chain rule; no replacement of the forward model.""" + sigmoid = torch.sigmoid(gate) + activated = gate * sigmoid + derivative = sigmoid + gate * sigmoid * (1 - sigmoid) + value_derivative = output_derivative @ down_weight + return { + "down": output_derivative.T @ (up * activated), + "up": (value_derivative * activated).T @ x, + "gate": (value_derivative * up * derivative).T @ x, + } + + +def route_output(current, original, attention, route): + """Forward activation intervention; baseline function is identical at zero update.""" + if route == "all": + return current + mask = torch.zeros_like(attention, dtype=torch.bool) + mask[torch.arange(len(mask), device=mask.device), attention.sum(1) - 1] = True + if route == "earlier": + mask = attention.bool() & ~mask + elif route != "last": + raise ValueError(route) + return torch.where(mask.unsqueeze(-1), current, original) + + +def update_scale(direction, target_gradient, step, parameter_norm, cap, metric): + d_norm = direction.double().norm() + g_norm = target_gradient.double().norm() + response = target_gradient.double() @ direction.double() + if d_norm == 0 or response <= 0: + return 0.0, True + if metric == "equal_norm": + scale = step / (g_norm * d_norm) + elif metric == "equal_target": + scale = step / response + else: + raise ValueError(metric) + maximum = cap * parameter_norm / d_norm + return float(torch.minimum(scale, maximum)), bool(scale > maximum) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_learning.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_learning.py new file mode 100644 index 0000000000000000000000000000000000000000..bc113a47da9c9fc22e346812c7f48f5ae7bc8b92 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_learning.py @@ -0,0 +1,416 @@ +"""Position-routed down updates, complete-answer objectives, and audited data helpers.""" + +from __future__ import annotations + +import hashlib +import json +import os +import re +import time +from datetime import datetime, timezone +from pathlib import Path + +os.environ.setdefault("CUBLAS_WORKSPACE_CONFIG", ":4096:8") +os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") + +import numpy as np +import torch +import torch.nn.functional as F +from transformers import AutoModelForCausalLM, AutoTokenizer + +from .hebbian_data import TEMPLATE, encode_answer, score_answer +from .hebbian_model import set_determinism, tensor_hash + +ROOT = Path(__file__).resolve().parents[2] +DATA = ROOT / "data/qwen-path-learning-v1" +ART = ROOT / "docs/development-artifacts/qwen-path-learning-v1" +RESULTS = ROOT / "results/qwen-path-learning-v1" +CONFIG = ROOT / "configs/qwen-path-learning-v1.json" +GROUPS = ("S_end", "S_other", "C", "W", "L", "A") + +# All views ask the same original CounterFact relation; no generated answer labels. +RELATIONS = { + "P19": ("{} was born in", "The birthplace of {} is", "{}'s birthplace is"), + "P20": ("{} died in", "The place of death of {} is", "{}'s place of death is"), + "P103": ( + "The native language of {} is", + "The mother tongue of {} is", + "{}'s native language is", + ), + "P176": ("The manufacturer of {} is", "{} was manufactured by", "{}'s manufacturer is"), + "P178": ("The developer of {} is", "{} was developed by", "{}'s developer is"), + "P495": ( + "The country of origin of {} is", + "{} originated in the country of", + "{}'s country of origin is", + ), + "P740": ( + "{} was founded in", + "The place where {} was founded is", + "{}'s place of formation is", + ), + "P364": ( + "The original language of {} is", + "{} was originally in the language", + "{}'s original language is", + ), + "P407": ("The language of {} is", "{} is in the language", "{}'s language is"), +} + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, obj): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(f".{os.getpid()}.tmp") + temporary.write_text(json.dumps(obj, ensure_ascii=False, indent=2, allow_nan=False) + "\n") + temporary.replace(path) + + +def digest(path): + h = hashlib.sha256() + with Path(path).open("rb") as stream: + for chunk in iter(lambda: stream.read(8 * 1024 * 1024), b""): + h.update(chunk) + return h.hexdigest() + + +def stable(value): + return hashlib.sha256(str(value).encode()).hexdigest() + + +def encode_fact(tokenizer, subject, statement, answer, view=0, plain=False): + prompt = statement if plain else TEMPLATE.format(statement) + enc = encode_answer(tokenizer, prompt, answer) + offset = 0 if plain else prompt.index(statement) + subject_start = statement.index(subject) + offset + subject_end = subject_start + len(subject) + offsets = tokenizer(prompt, add_special_tokens=False, return_offsets_mapping=True)[ + "offset_mapping" + ] + subject_tokens = [ + i for i, (a, b) in enumerate(offsets) if b > subject_start and a < subject_end + ] + if not subject_tokens: + raise ValueError("Subject has no tokens") + roles = [] + for i, (a, b) in enumerate(offsets): + if i == len(offsets) - 1: + role = "L" + elif i == subject_tokens[-1]: + role = "S_end" + elif i in subject_tokens: + role = "S_other" + elif b > offset and a < offset + len(statement): + role = "C" + else: + role = "W" + roles.append(role) + roles += ["A"] * (len(enc["input_ids"]) - len(roles)) + return {**enc, "prompt": prompt, "roles": roles, "view": view, "plain": plain} + + +def random_positions(roles, group, key, seed, bins=2, draws=16, energies=None): + """Disjoint count/bin-matched controls; optional local-energy matching only.""" + n = roles.index("L") + 1 + target = [i for i, role in enumerate(roles[: n - 1]) if role == group] + if not target: + return [], {"valid": False, "reason": "empty_group"} + + def strata(i): + return min(bins - 1, i * bins // max(n - 1, 1)) + + eligible = { + b: [i for i in range(n - 1) if i not in target and strata(i) == b] for b in range(bins) + } + counts = {b: sum(strata(i) == b for i in target) for b in range(bins)} + if any(len(eligible[b]) < counts[b] for b in range(bins)): + return [], {"valid": False, "reason": "insufficient_disjoint_positions"} + rng = np.random.default_rng(int(stable(f"{key}:{group}:{seed}")[:16], 16)) + options = [] + for _ in range(draws if energies is not None else 1): + positions = sorted( + int(i) for b in range(bins) for i in rng.choice(eligible[b], counts[b], replace=False) + ) + error = ( + 0.0 + if energies is None + else abs(sum(energies[i] for i in positions) - sum(energies[i] for i in target)) + / max(sum(energies[i] for i in target), 1e-30) + ) + options.append((error, positions)) + error, selected = min(options, key=lambda x: (x[0], x[1])) + return selected, {"valid": True, "relative_energy_error": error, "count": len(target)} + + +def sequence_mean(values, batch_indices, count): + sums = values.new_zeros(count).scatter_add_(0, batch_indices, values) + return sums / torch.bincount(batch_indices, minlength=count).clamp_min(1) + + +def fisher_quadratic(logp, response): + p = logp.exp() + return 0.5 * ((p * response.square()).sum(-1) - (p * response).sum(-1).square()) + + +class PathEngine: + def __init__(self, device, layer=None): + self.cfg = read(CONFIG) + set_determinism(self.cfg["seed"]) + self.device = torch.device(device) + self.tokenizer = AutoTokenizer.from_pretrained( + ROOT / self.cfg["model_source"], local_files_only=True + ) + self.tokenizer.pad_token = self.tokenizer.eos_token + self.model = ( + AutoModelForCausalLM.from_pretrained( + ROOT / self.cfg["model_source"], + local_files_only=True, + dtype=torch.float32, + attn_implementation="eager", + ) + .to(self.device) + .eval() + .requires_grad_(False) + ) + self.layer_index = self.cfg["layer"] if layer is None else layer + self.down = self.model.model.layers[self.layer_index].mlp.down_proj + self.base_hash = tensor_hash(self.down.weight) + self.delta = torch.nn.Parameter(torch.zeros_like(self.down.weight)) + self.route = "all" + self.route_seed = 0 + self.route_group = None + self.route_positions = {} + self.mask = None + self.capture = None + self.handle = self.down.register_forward_hook(self._hook) + self.reference = {} + self.forward_tokens = 0 + self.started = time.time() + + def _hook(self, module, args, output): + increment = F.linear(args[0], self.delta) + if self.capture is not None: + self.capture.append(increment.detach().square().sum(-1).cpu()) + if self.mask is not None: + increment = increment * self.mask[:, -increment.shape[1] :, None] + return output + increment + + def mask_for(self, enc): + roles = enc["roles"] + mask = [1.0] * len(roles) + if self.route == "all": + return mask + if "L" not in roles: # Unannotated natural text has no fact-position groups. + return mask + if self.route == "group": + positions = [i for i, x in enumerate(roles) if x == self.route_group] + elif self.route == "random": + positions, _ = random_positions(roles, self.route_group, enc["key"], self.route_seed) + elif self.route == "positions": + positions = self.route_positions.get(enc["key"], []) + elif self.route == "zero": + positions = list(range(len(roles))) + else: + raise ValueError(self.route) + for i in positions: + mask[i] = 0.0 + return mask + + def batch(self, encoded, prompt_only=False): + sequences = [ + e["input_ids"][: e["answer_start"]] if prompt_only else e["input_ids"] for e in encoded + ] + width = max(map(len, sequences)) + ids = torch.full( + (len(sequences), width), + self.tokenizer.pad_token_id, + device=self.device, + dtype=torch.long, + ) + attention = torch.zeros_like(ids) + loss = torch.zeros_like(ids, dtype=torch.bool) + masks = torch.ones_like(ids, dtype=torch.float32) + for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)): + ids[i, : len(seq)] = torch.tensor(seq, device=self.device) + attention[i, : len(seq)] = 1 + if not prompt_only: + loss[i, : len(seq)] = torch.tensor( + enc["loss_mask"], device=self.device, dtype=torch.bool + ) + masks[i, : len(seq)] = torch.tensor(self.mask_for(enc)[: len(seq)], device=self.device) + self.mask = masks + return ids, attention, loss + + def hidden(self, ids, attention): + self.forward_tokens += ids.numel() + return self.model.model( + input_ids=ids, attention_mask=attention, use_cache=False + ).last_hidden_state + + def objectives(self, encoded, include_kl=True): + ids, attention, mask = self.batch(encoded) + b, t = torch.where(mask[:, 1:]) + hidden = self.hidden(ids, attention) + logits = self.model.lm_head(hidden[b, t]) + ce = sequence_mean( + F.cross_entropy(logits, ids[b, t + 1], reduction="none"), b, len(encoded) + ) + if not include_kl: + return ce, None + with torch.no_grad(): + ref_hidden = torch.cat([self.reference[e["key"]] for e in encoded]).to(self.device) + ref_log = F.log_softmax(self.model.lm_head(ref_hidden), dim=-1) + divergence = (ref_log.exp() * (ref_log - F.log_softmax(logits, dim=-1))).sum(-1) + return ce, sequence_mean(divergence, b, len(encoded)) + + @torch.no_grad() + def cache_reference(self, encoded, batch_size=8): + if self.delta.count_nonzero().item(): + raise ValueError("Reference must be cached at the parent") + for start in range(0, len(encoded), batch_size): + chunk = encoded[start : start + batch_size] + ids, attention, mask = self.batch(chunk) + b, t = torch.where(mask[:, 1:]) + hidden = self.hidden(ids, attention) + for i, enc in enumerate(chunk): + self.reference[enc["key"]] = hidden[b[b == i], t[b == i]].detach().cpu() + + @torch.no_grad() + def generate(self, encoded): + # Cached greedy decoding; routing is built from the input prompt alone. + sequences = [e["input_ids"][: e["answer_start"]] for e in encoded] + width = max(map(len, sequences)) + ids = torch.full( + (len(sequences), width), + self.tokenizer.pad_token_id, + device=self.device, + dtype=torch.long, + ) + attention = torch.zeros_like(ids) + route_mask = torch.ones_like(ids, dtype=torch.float32) + for i, (seq, enc) in enumerate(zip(sequences, encoded, strict=True)): + ids[i, -len(seq) :] = torch.tensor(seq, device=self.device) + attention[i, -len(seq) :] = 1 + route_mask[i, -len(seq) :] = torch.tensor( + self.mask_for(enc)[: len(seq)], device=self.device + ) + tails = [[] for _ in encoded] + done = [False] * len(encoded) + cache = None + for step in range(self.cfg["max_new_tokens"]): + position = attention.cumsum(-1) - 1 + position.masked_fill_(attention == 0, 0) + self.mask = ( + route_mask + if step == 0 + else torch.full( + (len(encoded), 1), + 0.0 + if self.route == "zero" or (self.route == "group" and self.route_group == "A") + else 1.0, + device=self.device, + ) + ) + out = self.model.model( + input_ids=ids, + attention_mask=attention, + position_ids=position if step == 0 else position[:, -1:], + past_key_values=cache, + use_cache=True, + ) + self.forward_tokens += ids.numel() + cache = out.past_key_values + next_ids = self.model.lm_head(out.last_hidden_state[:, -1]).argmax(-1) + for i, token in enumerate(next_ids.tolist()): + if not done[i]: + tails[i].append(token) + decoded = self.tokenizer.decode(tails[i], skip_special_tokens=True) + done[i] = token == self.tokenizer.eos_token_id or "\n" in decoded + if all(done): + break + ids = next_ids[:, None] + attention = torch.cat([attention, torch.ones_like(ids)], dim=1) + return [ + { + "prediction": self.tokenizer.decode(tail, skip_special_tokens=True), + "tokens": tail, + "eos": self.tokenizer.eos_token_id in tail, + } + for tail in tails + ] + + @torch.no_grad() + def evaluate(self, records, views=(0,), batch_size=16, with_kl=True, generate=True): + entries = [(r, r["encoded"][v]) for r in records for v in views] + output = [] + for start in range(0, len(entries), batch_size): + chunk = entries[start : start + batch_size] + encs = [e for _, e in chunk] + ce, kl = self.objectives(encs, include_kl=with_kl) + predictions = self.generate(encs) if generate else [None] * len(chunk) + for i, ((record, enc), prediction) in enumerate(zip(chunk, predictions, strict=True)): + item = { + "case_id": record["case_id"], + "view": enc["view"], + "ce": float(ce[i]), + "kl": None if kl is None else float(kl[i]), + } + if prediction is not None: + item.update(prediction) + item["correct"] = score_answer(prediction["prediction"], record["aliases"]) + output.append(item) + return output + + @torch.no_grad() + def evaluate_text(self, encoded): + result = [] + for start in range(0, len(encoded), 2): + chunk = encoded[start : start + 2] + ce, kl = self.objectives(chunk) + result.extend( + {"key": e["key"], "ce": float(c), "kl": float(k)} + for e, c, k in zip(chunk, ce, kl, strict=True) + ) + return result + + def restore(self): + with torch.no_grad(): + self.delta.zero_() + self.route = "all" + self.mask = None + assert tensor_hash(self.down.weight) == self.base_hash + + +def mean(rows, key): + return float(np.mean([r[key] for r in rows])) if rows else None + + +def valid_aliases(raw): + by_id = {} + for row in raw: + target = row["requested_rewrite"]["target_true"] + by_id.setdefault(target["id"], set()).add(target["str"].strip()) + return {k: sorted(v) for k, v in by_id.items()} + + +def articles_from_lines(lines): + articles = [] + title, parts = None, [] + for line in lines: + if re.fullmatch(r"\s*= [^=]+ =\s*", line): + if title and parts: + articles.append((title, "".join(parts))) + title, parts = line.strip(), [] + elif title: + parts.append(line) + if title and parts: + articles.append((title, "".join(parts))) + return articles diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_train.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_train.py new file mode 100644 index 0000000000000000000000000000000000000000..fabb31112396100c708fafd83993acdb8c46f918 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/qwen_path_train.py @@ -0,0 +1,627 @@ +"""Frozen-matrix execution and development-only selection for path learning.""" + +from __future__ import annotations + +import json +import os +import platform +import shutil +import time + +import numpy as np +import torch +import transformers + +from .qwen_path_learning import ( + ART, + CONFIG, + DATA, + RESULTS, + ROOT, + PathEngine, + digest, + encode_fact, + mean, + now, + random_positions, + read, + write, +) + + +def preflight(device): + from .hebbian_model import aggregate_hash, state_hashes + + cfg = read(CONFIG) + old_records = read(ROOT / "data/hebbian-learning-v1/pools.json")["B_dev"][:2] + engine = PathEngine(device) + encs = [] + for r in old_records: + enc = encode_fact(engine.tokenizer, r["subject"], r["views"][0], r["answer"]) + enc["key"] = f"preflight-{r['case_id']}" + encs.append(enc) + before_hash = aggregate_hash(state_hashes(engine.model)) + assert all(not p.requires_grad for p in engine.model.parameters()) + assert engine.delta.numel() == 3145728 + engine.cache_reference(encs) + baseline_ce, zero_kl = engine.objectives(encs) + baseline_ce = baseline_ce.detach() + checks = { + "parameter_count": engine.delta.numel(), + "zero_kl_max": float(zero_kl.detach().abs().max()), + } + assert checks["zero_kl_max"] < 1e-5 + for group in cfg["groups"]: + engine.route, engine.route_group = "group", group + ce, _ = engine.objectives(encs) + assert torch.equal(ce.detach(), baseline_ce) + engine.route = "all" + with torch.no_grad(): + engine.delta.normal_(std=1e-5) + ids, attention, _ = engine.batch(encs) + with torch.no_grad(): + separate = engine.hidden(ids, attention) + delta = engine.delta.clone() + original_weight = engine.down.weight.clone() + engine.down.weight.add_(delta) + engine.delta.zero_() + fused = engine.hidden(ids, attention) + engine.down.weight.copy_(original_weight) + engine.delta.copy_(delta) + checks["all_vs_fused_hidden_max_error"] = float((separate - fused).abs().max()) + assert checks["all_vs_fused_hidden_max_error"] < 1e-3 + engine.restore() + opt = optimizer(engine, 1e-5) + begun = time.time() + ce, _ = engine.objectives(encs, include_kl=False) + ce.mean().backward() + checks["delta_gradient_norm"] = float(engine.delta.grad.norm()) + torch.nn.utils.clip_grad_norm_([engine.delta], cfg["optimizer"]["clip"]) + opt.step() + checks["single_old_episode_step_seconds"] = time.time() - begun + assert checks["delta_gradient_norm"] > 0 and torch.isfinite(engine.delta).all() + engine.restore() + assert aggregate_hash(state_hashes(engine.model)) == before_hash + ce, _ = engine.objectives(encs) + checks["restore_ce_max_error"] = float((ce.detach() - baseline_ce).abs().max()) + assert checks["restore_ce_max_error"] == 0 + del engine + torch.cuda.empty_cache() + final = PathEngine(device, layer=27) + with torch.no_grad(): + final.delta.normal_(std=1e-4) + final.route = "zero" + parent_ce, _ = final.objectives(encs, include_kl=False) + # Enable only earlier-prompt increments, and disable all readout positions. + final.route = "positions" + final.route_positions = { + e["key"]: list(range(e["answer_start"] - 1, len(e["roles"]))) for e in encs + } + early_ce, _ = final.objectives(encs, include_kl=False) + checks["final_layer_earlier_ce_max_error"] = float((early_ce - parent_ce).abs().max()) + assert checks["final_layer_earlier_ce_max_error"] == 0 + final.restore() + checks["passed"] = True + checks["time"] = now() + checks["training_cases"] = "two old B_dev facts; no new developmental outcome selection" + checks["parent_model_sha256"] = before_hash + write(ART / "preflight.json", checks) + print(json.dumps(checks), flush=True) + + +def jobs(): + cfg = read(CONFIG) + return [ + { + "id": f"dev-e{episode}-lr{lr:g}-b{beta}", + "episode": episode, + "lr": lr, + "beta": beta, + "seed": 0, + "phase": "dev", + "condition": "ordinary", + } + for episode in range(4) + for lr in cfg["learning_rates"] + for beta in cfg["betas_replay"] + ] + + +def sources(): + return [ + "configs/qwen-path-learning-v1.json", + "scripts/run_qwen_path_learning.py", + "src/llm_memory_editability/qwen_path_learning.py", + "src/llm_memory_editability/qwen_path_train.py", + "src/llm_memory_editability/hebbian_data.py", + "src/llm_memory_editability/hebbian_model.py", + "src/llm_memory_editability/hebbian_learning.py", + "tests/test_qwen_path_learning.py", + ] + + +def freeze(): + if (ART / "execution-lock.json").exists(): + raise RuntimeError("Execution lock exists") + assert read(ART / "preflight.json")["passed"] + assert read(ART / "selection-lock.json")["selection_sha256"] == digest(DATA / "selection.json") + frozen = {} + for relative in sources() + [ + "docs/hebbian-learning-plan-v1.md", + "docs/experimental-protocol.md", + ]: + path = ROOT / relative + target = ART / "execution-source" / relative + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, target) + frozen[relative] = digest(path) + cfg = read(CONFIG) + model = ROOT / cfg["model_source"] / "model.safetensors" + write( + ART / "execution-lock.json", + { + "time": now(), + "status": "locked_before_development_updates", + "sources": frozen, + "inputs": { + str(p.relative_to(ROOT)): digest(p) + for p in [DATA / "selection.json", DATA / "text.json", model] + }, + "matrix": jobs(), + "environment": { + "python": platform.python_version(), + "torch": torch.__version__, + "transformers": transformers.__version__, + "numpy": np.__version__, + }, + "config": cfg, + }, + ) + + +def check_lock(): + lock = read(ART / "execution-lock.json") + for relative in sources(): + assert digest(ROOT / relative) == lock["sources"][relative], relative + for relative in ( + "data/qwen-path-learning-v1/selection.json", + "data/qwen-path-learning-v1/text.json", + ): + assert digest(ROOT / relative) == lock["inputs"][relative] + + +def optimizer(engine, lr): + cfg = engine.cfg["optimizer"] + return torch.optim.AdamW( + [engine.delta], + lr=lr, + betas=tuple(cfg["betas"]), + eps=cfg["eps"], + weight_decay=cfg["weight_decay"], + ) + + +def schedule(cfg, episode, seed, n_r=64, n_text=64): + rng = np.random.default_rng(cfg["seed"] + 1000 * episode + seed) + # Fixed cyclic shuffled decks give exactly equal aggregate exposure across jobs. + replay, text = rng.permutation(n_r), rng.permutation(n_text) + return [ + { + "R": [int(replay[(step * 8 + i) % n_r]) for i in range(8)], + "text": [int(text[(step * 2 + i) % n_text]) for i in range(2)], + } + for step in range(cfg["steps"]) + ] + + +def save_checkpoint(path, engine, opt, job, step, history, ledger): + temporary = path.with_suffix(f".{os.getpid()}.tmp") + torch.save( + { + "delta": engine.delta.detach().cpu(), + "optimizer": opt.state_dict(), + "job": job, + "step": step, + "history": history, + "ledger": ledger, + "execution_lock": digest(ART / "execution-lock.json"), + }, + temporary, + ) + temporary.replace(path) + + +def evaluate_node(engine, episode, selection, texts, step, output, full_test=False): + result = { + "step": step, + "time": now(), + "E": engine.evaluate(episode, views=(0, 1, 2, 3), with_kl=False), + "R": engine.evaluate(selection["R"]), + "V": engine.evaluate(selection["V"]), + "text_dev": engine.evaluate_text(texts["dev"]), + "delta_norm": float(engine.delta.norm()), + "relative_delta_norm": float(engine.delta.norm() / engine.down.weight.norm()), + } + if full_test: + result["U"] = engine.evaluate(selection["U"], views=(0, 1, 2, 3)) + result["text_test"] = engine.evaluate_text(texts["test"]) + write(output / f"node-{step:03d}.json", result) + return result + + +def train_job(engine, job): + check_lock() + cfg = engine.cfg + out = RESULTS / job["id"] + out.mkdir(parents=True, exist_ok=True) + if (out / "complete.json").exists(): + return + engine.restore() + selection, texts = read(DATA / "selection.json"), read(DATA / "text.json") + phase = job["phase"] + records = selection["E_dev" if phase == "dev" else "E_confirm"] + episode = records[job["episode"] * 4 : (job["episode"] + 1) * 4] + training_enc = [r["encoded"][0] for r in episode] + reference_enc = ( + [r["encoded"][0] for role in ("R", "V") for r in selection[role]] + + texts["train"] + + texts["dev"] + ) + if phase == "confirm": + reference_enc += [enc for r in selection["U"] for enc in r["encoded"]] + texts["test"] + missing = [e for e in reference_enc if e["key"] not in engine.reference] + engine.cache_reference(missing) + if job["condition"] != "ordinary": + engine.route = "group" if job["condition"] == "candidate" else "random" + engine.route_group = job["group"] + engine.route_seed = job["seed"] + opt = optimizer(engine, job["lr"]) + batches = schedule(cfg, job["episode"], job["seed"]) + write(out / "schedule.json", batches) + history, ledger, start = ( + [], + { + "E_sequences": 0, + "R_sequences": 0, + "text_sequences": 0, + "supervised_E_tokens": 0, + "R_prediction_tokens": 0, + "text_prediction_tokens": 0, + "padded_training_tokens": 0, + }, + 0, + ) + checkpoint = out / "latest.pt" + if checkpoint.exists(): + ck = torch.load(checkpoint, map_location=engine.device, weights_only=False) + assert ck["job"] == job and ck["execution_lock"] == digest(ART / "execution-lock.json") + with torch.no_grad(): + engine.delta.copy_(ck["delta"]) + opt.load_state_dict(ck["optimizer"]) + history, ledger, start = ck["history"], ck["ledger"], ck["step"] + else: + evaluate_node(engine, episode, selection, texts, 0, out, phase == "confirm") + save_checkpoint(out / "step-000.pt", engine, opt, job, 0, history, ledger) + begun = time.time() + torch.cuda.reset_peak_memory_stats(engine.device) + for index in range(start, cfg["steps"]): + plan = batches[index] + replay = [selection["R"][i]["encoded"][0] for i in plan["R"]] + text = [texts["train"][i] for i in plan["text"]] + opt.zero_grad(set_to_none=True) + ce, _ = engine.objectives(training_enc, include_kl=False) + ce.mean().backward() + _, rkl = engine.objectives(replay) + (job["beta"] * rkl.mean() / 2).backward() + _, tkl = engine.objectives(text) + (job["beta"] * tkl.mean() / 2).backward() + gradient_norm = torch.nn.utils.clip_grad_norm_([engine.delta], cfg["optimizer"]["clip"]) + if not torch.isfinite(gradient_norm): + raise RuntimeError(f"Non-finite gradient in {job['id']} step {index + 1}") + opt.step() + history.append( + { + "step": index + 1, + "ce": float(ce.detach().mean()), + "r_kl": float(rkl.detach().mean()), + "text_kl": float(tkl.detach().mean()), + "gradient_norm_before_clip": float(gradient_norm), + } + ) + ledger["E_sequences"] += len(training_enc) + ledger["R_sequences"] += len(replay) + ledger["text_sequences"] += len(text) + ledger["supervised_E_tokens"] += sum(sum(e["loss_mask"]) for e in training_enc) + ledger["R_prediction_tokens"] += sum(sum(e["loss_mask"]) for e in replay) + ledger["text_prediction_tokens"] += sum(sum(e["loss_mask"]) for e in text) + ledger["padded_training_tokens"] += sum( + len(es) * max(len(e["input_ids"]) for e in es) for es in (training_enc, replay, text) + ) + step = index + 1 + if step in cfg["nodes"]: + evaluate_node(engine, episode, selection, texts, step, out, phase == "confirm") + save_checkpoint(out / f"step-{step:03d}.pt", engine, opt, job, step, history, ledger) + if step % 16 == 0 or step in cfg["nodes"]: + save_checkpoint(checkpoint, engine, opt, job, step, history, ledger) + write( + out / "status.json", + { + "time": now(), + "state": "training", + "step": step, + "job": job, + "device": str(engine.device), + "seconds_this_attempt": time.time() - begun, + }, + ) + print(json.dumps({"job": job["id"], "step": step, "ce": history[-1]["ce"]}), flush=True) + write(out / "history.json", history) + write( + out / "complete.json", + { + "time": now(), + "job": job, + "steps": cfg["steps"], + "ledger": ledger, + "schedule_sha256": digest(out / "schedule.json"), + "seconds_this_attempt": time.time() - begun, + "peak_gpu_bytes": torch.cuda.max_memory_allocated(engine.device), + "device": str(engine.device), + "trainable_parameters": engine.delta.numel(), + "parent_down_hash": engine.base_hash, + "forward_tokens_engine_cumulative": engine.forward_tokens, + "flops_estimate": { + "convention": "Approximate dense 2*N per forward token plus backward through " + "downstream half and head; padding included, attention term omitted; " + "reference/evaluation costs recorded separately", + "value": 4 + * sum(p.numel() for p in engine.model.parameters()) + * ledger["padded_training_tokens"], + "not_hardware_counter": True, + }, + }, + ) + engine.restore() + + +def train_shard(device, shard, shards): + engine = PathEngine(device) + for index, job in enumerate(jobs()): + if index % shards == shard: + train_job(engine, job) + + +def select_learning_rates(): + cfg = read(CONFIG) + summaries, chosen = [], {} + for beta in cfg["betas_replay"]: + options = [] + for lr in cfg["learning_rates"]: + records = [] + for job in jobs(): + if job["beta"] == beta and job["lr"] == lr: + assert (RESULTS / job["id"] / "complete.json").exists() + node = read(RESULTS / job["id"] / "node-128.json") + base = read(RESULTS / job["id"] / "node-000.json") + records.append( + { + "E": mean([r for r in node["E"] if r["view"] == 0], "correct"), + "V_loss": mean(base["V"], "correct") - mean(node["V"], "correct"), + "text_kl": mean(node["text_dev"], "kl"), + } + ) + option = { + "beta": beta, + "lr": lr, + **{k: mean(records, k) for k in ("E", "V_loss", "text_kl")}, + } + options.append(option) + eligible = [r for r in options if r["V_loss"] <= 0.05] + if eligible: + choice = min(eligible, key=lambda r: (-r["E"], r["text_kl"], r["lr"])) + else: + choice = min(options, key=lambda r: (r["V_loss"], r["text_kl"], r["lr"])) + chosen[str(beta)] = {**choice, "retention_condition_passed": bool(eligible)} + summaries.extend(options) + write( + ART / "learning-rate-selection.json", + {"time": now(), "node": 128, "rows": summaries, "chosen": chosen, "used_U": False}, + ) + return chosen + + +@torch.no_grad() +def diagnose(device, episode_index): + check_lock() + cfg = read(CONFIG) + chosen = read(ART / "learning-rate-selection.json")["chosen"]["1"] + job = next( + j + for j in jobs() + if j["episode"] == episode_index and j["beta"] == 1 and j["lr"] == chosen["lr"] + ) + engine = PathEngine(device) + selection = read(DATA / "selection.json") + episode = selection["E_dev"][episode_index * 4 : (episode_index + 1) * 4] + records = episode + selection["R"] + encs = [r["encoded"][0] for r in records] + engine.cache_reference(encs) + output = RESULTS / job["id"] / "diagnostics" + output.mkdir(exist_ok=True) + base_E = engine.evaluate(episode) + zero_R = engine.evaluate(selection["R"], generate=False) + for step in cfg["nodes"][1:]: + if (output / f"step-{step:03d}.json").exists(): + continue + ck = torch.load( + RESULTS / job["id"] / f"step-{step:03d}.pt", + map_location=engine.device, + weights_only=False, + ) + engine.delta.copy_(ck["delta"]) + engine.route = "all" + full_E = engine.evaluate(episode) + full_R = engine.evaluate(selection["R"], generate=False) + energies = {} + for start in range(0, len(encs), 8): + chunk = encs[start : start + 8] + engine.capture = [] + engine.objectives(chunk, include_kl=False) + captured = engine.capture[0] + for i, enc in enumerate(chunk): + energies[enc["key"]] = captured[i, : len(enc["roles"])].tolist() + engine.capture = None + result = { + "step": step, + "episode": episode_index, + "job": job, + "base_E": base_E, + "zero_R": zero_R, + "all_E": full_E, + "all_R": full_R, + "groups": {}, + } + for group in cfg["groups"] + ["L", "A"]: + engine.route, engine.route_group = "group", group + group_E = engine.evaluate(episode) + group_R = engine.evaluate(selection["R"], generate=False) + group_result = {"E": group_E, "R": group_R, "random": []} + if group in cfg["groups"]: + for seed in cfg["matching"]["diagnostic_seeds"]: + positions, matches = {}, {} + for enc in encs: + selected, info = random_positions( + enc["roles"], + group, + enc["key"], + seed, + cfg["matching"]["position_bins"], + cfg["matching"]["draws"], + energies[enc["key"]], + ) + info["energy_matched"] = ( + info["valid"] + and info["relative_energy_error"] + <= cfg["matching"]["norm_relative_tolerance"] + ) + matches[enc["key"]] = info + positions[enc["key"]] = selected + engine.route, engine.route_positions = "positions", positions + group_result["random"].append( + { + "seed": seed, + "matches": matches, + "positions": positions, + "E": engine.evaluate(episode), + "R": engine.evaluate(selection["R"], generate=False), + } + ) + result["groups"][group] = group_result + engine.route = "all" + recovered = engine.evaluate(episode, generate=False) + result["restore_max_ce_error"] = max( + abs(a["ce"] - b["ce"]) for a, b in zip(full_E, recovered, strict=True) + ) + result["position_energy"] = energies + write(output / f"step-{step:03d}.json", result) + print(json.dumps({"diagnostic_episode": episode_index, "step": step}), flush=True) + engine.restore() + + +def candidate_decision(): + cfg = read(CONFIG) + chosen = read(ART / "learning-rate-selection.json")["chosen"]["1"] + rows = [] + for job in jobs(): + if job["beta"] != 1 or job["lr"] != chosen["lr"]: + continue + d = read(RESULTS / job["id"] / "diagnostics/step-128.json") + gain = mean(d["base_E"], "ce") - mean(d["all_E"], "ce") + risk = mean(d["all_R"], "kl") + noise = max(abs(r["kl"]) for r in d["zero_R"]) + for group in cfg["groups"]: + g = d["groups"][group] + retained = None if gain <= 0 else (mean(d["base_E"], "ce") - mean(g["E"], "ce")) / gain + reduction = None if risk <= 0 else 1 - mean(g["R"], "kl") / risk + matching = [] + for control in g["random"]: + matched_ids = { + int(key.split("-")[1]) + for key, m in control["matches"].items() + if m["energy_matched"] + } + e_fraction = sum(r["case_id"] in matched_ids for r in d["all_E"]) / len(d["all_E"]) + r_fraction = sum(r["case_id"] in matched_ids for r in d["all_R"]) / len(d["all_R"]) + all_r = [r for r in d["all_R"] if r["case_id"] in matched_ids] + cand_r = [r for r in g["R"] if r["case_id"] in matched_ids] + random_r = [r for r in control["R"] if r["case_id"] in matched_ids] + difference = None if not all_r else mean(random_r, "kl") - mean(cand_r, "kl") + matching.append( + { + "seed": control["seed"], + "E_coverage": e_fraction, + "R_coverage": r_fraction, + "candidate_minus_random_improvement": difference, + "valid": e_fraction >= cfg["matching"]["minimum_coverage"] + and r_fraction >= cfg["matching"]["minimum_coverage"], + } + ) + valid = [m for m in matching if m["valid"]] + beats_random = ( + bool(valid) + and float(np.median([m["candidate_minus_random_improvement"] for m in valid])) + > cfg["gate"]["noise_multiplier"] * noise + ) + passes = bool( + gain > 0 + and mean(d["all_E"], "correct") > mean(d["base_E"], "correct") + and retained >= cfg["gate"]["learning_retained"] + and mean(g["E"], "correct") >= mean(d["all_E"], "correct") + and risk >= max(cfg["gate"]["kl_floor"], cfg["gate"]["noise_multiplier"] * noise) + and reduction >= cfg["gate"]["kl_reduction"] + and beats_random + ) + rows.append( + { + "episode": job["episode"], + "group": group, + "E_gain": gain, + "learning_retained": retained, + "R_kl": risk, + "R_kl_reduction": reduction, + "E_correct_all": mean(d["all_E"], "correct"), + "E_correct_candidate": mean(g["E"], "correct"), + "noise": noise, + "matching": matching, + "beats_random": beats_random, + "passes": passes, + } + ) + eligible = [ + g + for g in cfg["groups"] + if sum(r["passes"] for r in rows if r["group"] == g) >= cfg["gate"]["units_required"] + ] + winner = ( + min( + eligible, + key=lambda g: ( + -float(np.mean([r["R_kl_reduction"] for r in rows if r["group"] == g])), + cfg["groups"].index(g), + ), + ) + if eligible + else None + ) + result = { + "time": now(), + "rows": rows, + "candidate": winner, + "status": "eligible_for_confirmation" if winner else "stop_after_development", + "confirmation_started": False, + "selection_uses_U": False, + "coverage_rule": "At least 80% of E and R must have disjoint count/bin/energy matches " + "in a fixed random seed; compare candidate/random on identical matched records", + } + write(ART / "candidate-decision.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition.py new file mode 100644 index 0000000000000000000000000000000000000000..a05d1c9d956093315cedab365228e2fce72b6022 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition.py @@ -0,0 +1,629 @@ +"""Complete GPT/Loop training on original 2Wiki questions and atomic facts.""" + +from __future__ import annotations + +import copy +import hashlib +import json +import math +import os +import time +from contextlib import nullcontext +from pathlib import Path + +import numpy as np +import torch +import torch.nn.functional as F +from transformers import GPT2Config, GPT2TokenizerFast + +from .grok_depth import utc +from .grokking_reproduction import ReproductionGPT, model_digest +from .realworld_composition_data import ( + answer_scores, + atomic_question, + encode_example, + sha256, + write_json, +) + + +def construct(config, spec, device): + """Build the same eight-block reference before taking a shared prefix.""" + torch.manual_seed(spec["initialization"]) + options = { + "vocab_size": config["vocab_size"], + "n_positions": config.get("positions", 1024), + "n_embd": config["hidden_size"], + "n_head": config["attention_heads"], + "n_layer": 8, + "resid_pdrop": config["dropout"], + "embd_pdrop": config["dropout"], + "attn_pdrop": config["dropout"], + "activation_function": "gelu_new", + "use_cache": False, + } + model = ReproductionGPT(GPT2Config(**options), repeats=spec["repeats"]) + model.transformer.h = torch.nn.ModuleList(list(model.transformer.h)[: spec["unique_layers"]]) + model.config.n_layer = spec["unique_layers"] + return model.to(device) + + +def shared_prefix_digest(model): + digest = hashlib.sha256() + for name, tensor in model.state_dict().items(): + if name.startswith("transformer.h.") and int(name.split(".")[2]) >= 4: + continue + digest.update(name.encode()) + digest.update(tensor.detach().cpu().contiguous().numpy().tobytes()) + return digest.hexdigest() + + +def tensor_digests(model): + return { + name: hashlib.sha256(tensor.detach().cpu().contiguous().numpy().tobytes()).hexdigest() + for name, tensor in model.state_dict().items() + } + + +class BatchStream: + """Keep actual incomplete epoch batches, with a complete restore state.""" + + def __init__(self, size, seed): + self.size = size + self.rng = np.random.default_rng(seed) + self.remaining = np.empty(0, dtype=np.int64) + + def batch(self, size): + if not len(self.remaining): + self.remaining = self.rng.permutation(self.size) + chosen, self.remaining = self.remaining[:size], self.remaining[size:] + return chosen + + def state_dict(self): + return { + "remaining": self.remaining.copy(), + "rng": copy.deepcopy(self.rng.bit_generator.state), + } + + def load_state_dict(self, state): + self.remaining = state["remaining"].copy() + self.rng.bit_generator.state = copy.deepcopy(state["rng"]) + + +def pack(records, pad, device): + length = math.ceil(max(len(r["encoded"]["input"]) for r in records) / 8) * 8 + targets = max(len(r["encoded"]["target"]) for r in records) + tokens = np.full((len(records), length), pad, dtype=np.int64) + positions = np.zeros((len(records), targets), dtype=np.int64) + labels = np.full((len(records), targets), -100, dtype=np.int64) + for i, record in enumerate(records): + encoded = record["encoded"] + tokens[i, : len(encoded["input"])] = encoded["input"] + n = len(encoded["target"]) + positions[i, :n] = np.arange(len(encoded["prefix"]) - 1, len(encoded["prefix"]) - 1 + n) + labels[i, :n] = encoded["target"] + return tuple(torch.as_tensor(a, device=device) for a in (tokens, positions, labels)) + + +def example_losses(logits, labels): + valid = labels != -100 + if not bool(valid.any(dim=1).all()): + raise ValueError("Every example must supervise its answer and EOS") + losses = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), reduction="none").view_as( + labels + ) + return losses.sum(dim=1) / valid.sum(dim=1) + + +def optimizer_for(model, lr, decay): + params = list(model.named_parameters()) + groups = [ + { + "params": [p for n, p in params if not any(s in n for s in ["bias", "ln"])], + "weight_decay": decay, + }, + { + "params": [p for n, p in params if any(s in n for s in ["bias", "ln"])], + "weight_decay": 0.0, + }, + ] + return torch.optim.AdamW( + groups, lr=lr, betas=(0.9, 0.999), eps=1e-8, fused=next(model.parameters()).is_cuda + ) + + +def autocast(device): + return ( + torch.autocast("cuda", dtype=torch.bfloat16) + if torch.device(device).type == "cuda" + else nullcontext() + ) + + +def update(model, optimizer, records, spec, device, pad): + model.train() + optimizer.zero_grad(set_to_none=True) + loss_total, executed, readout, attention = 0.0, 0, 0, 0 + for start in range(0, len(records), spec["microbatch_size"]): + chunk = records[start : start + spec["microbatch_size"]] + tokens, positions, labels = pack(chunk, pad, device) + with autocast(device): + loss = example_losses(model(tokens, positions), labels).sum() / len(records) + loss.backward() + loss_total += float(loss.detach()) + executed += tokens.numel() + readout += positions.numel() + attention += len(chunk) * tokens.shape[1] ** 2 + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0) + if not math.isfinite(loss_total) or not math.isfinite(float(norm)): + raise FloatingPointError("Nonfinite loss or gradient; preserve this failure") + optimizer.step() + d, blocks = model.config.n_embd, len(model.transformer.h) * model.repeats + flops = ( + 6 * 12 * d * d * blocks * executed + + 6 * d * model.config.vocab_size * readout + + 12 * blocks * d * attention + ) + return { + "loss": loss_total, + "gradient_norm": float(norm), + "executed_input_tokens": executed, + "effective_input_tokens": sum(len(r["encoded"]["input"]) for r in records), + "estimated_matmul_training_flops": flops, + } + + +@torch.no_grad() +def generate(model, prefixes, tokenizer, device, limit=64, sequence_limit=256): + """Right-padded greedy generation; only the question prefix enters the model.""" + model.eval() + sizes = np.array([len(p) for p in prefixes], dtype=np.int64) + if not len(sizes) or not (sizes > 0).all() or not (sizes <= sequence_limit).all(): + raise ValueError("Generation requires nonempty prefixes within the sequence limit") + budgets = np.minimum(limit, sequence_limit - sizes) + tokens = torch.full( + (len(prefixes), min(sequence_limit, int(sizes.max()) + limit)), + tokenizer.eos_token_id, + device=device, + dtype=torch.long, + ) + for i, prefix in enumerate(prefixes): + tokens[i, : len(prefix)] = torch.as_tensor(prefix, device=device) + output, ended = [[] for _ in prefixes], np.zeros(len(prefixes), dtype=bool) + for offset in range(limit): + active = ~ended & (offset < budgets) + if not active.any(): + break + length = min(sequence_limit, int(sizes.max()) + offset) + positions = torch.as_tensor(np.minimum(sizes + offset - 1, length - 1), device=device)[ + :, None + ] + with autocast(device): + selected = model(tokens[:, :length], positions)[:, 0].argmax(-1) + chosen = selected.cpu().tolist() + for i, token in enumerate(chosen): + if active[i]: + output[i].append(token) + ended[i] = token == tokenizer.eos_token_id + indices = torch.as_tensor(np.flatnonzero(active), device=device) + tokens[indices, torch.as_tensor(sizes[active] + offset, device=device)] = selected[indices] + model.train() + return [ + { + "prediction": tokenizer.decode( + ids[:-1] if stop else ids, skip_special_tokens=True + ).strip(), + "generated_tokens": ids, + "eos": bool(stop), + "truncated": not bool(stop), + "context_limit_reached": not bool(stop) and bool(len(ids) >= sequence_limit - size), + "generation_limit_reached": not bool(stop) and len(ids) >= limit, + } + for ids, stop, size in zip(output, ended, sizes, strict=True) + ] + + +def aggregate(predictions): + fields = ["canonical_em", "alias_em", "unambiguous_alias_em", "f1", "nll", "eos", "truncated"] + result = {"n": len(predictions)} + for key in fields: + values = [float(p[key]) for p in predictions if p[key] is not None] + result[key] = sum(values) / len(values) if values else None + if key == "nll": + result["nll_n"] = len(values) + eligible = [p for p in predictions if p.get("has_unambiguous_answer", True)] + result["unambiguous_answer_coverage"] = ( + len(eligible) / len(predictions) if predictions else None + ) + result["unambiguous_alias_em_eligible"] = ( + sum(float(p["unambiguous_alias_em"]) for p in eligible) / len(eligible) + if eligible + else None + ) + result["answer_accuracy"] = result["alias_em"] + return result + + +@torch.no_grad() +def evaluate(model, records, tokenizer, device, batch_size=32): + predictions = [] + for start in range(0, len(records), batch_size): + chunk = records[start : start + batch_size] + generated = generate(model, [r["encoded"]["prefix"] for r in chunk], tokenizer, device) + model.eval() + tokens, positions, labels = pack(chunk, tokenizer.eos_token_id, device) + with autocast(device): + losses = example_losses(model(tokens, positions), labels).float().cpu().tolist() + for row, result, loss in zip(chunk, generated, losses, strict=True): + em, f1 = answer_scores(result["prediction"], [row["answer"], *row.get("aliases", [])]) + unique_answers = row.get( + "unambiguous_answers", [row["answer"], *row.get("unambiguous_aliases", [])] + ) + result.update( + id=row["id"], + canonical_em=answer_scores(result["prediction"], [row["answer"]])[0], + alias_em=em, + f1=f1, + nll=loss, + unambiguous_alias_em=answer_scores(result["prediction"], unique_answers)[0], + has_unambiguous_answer=bool(unique_answers), + canonical_answer_globally_unambiguous=row.get( + "canonical_answer_globally_unambiguous", True + ), + gold=row["answer"], + role=row.get("role"), + required_role=row.get("required_role"), + ) + predictions.append(result) + model.train() + return aggregate(predictions), predictions + + +def evaluate_dataset(model, data, tokenizer, device, full=False, autonomous=False): + atoms = {r["id"]: r for r in data["atoms"]} + chains = {r["id"]: r for r in data["train_compositions"] + data["evaluation_compositions"]} + panels = data["panels"] + groups = { + "atomic": list(atoms.values()) if full else [atoms[i] for i in panels["atomic"]], + "train_composition": data["train_compositions"] + if full + else [chains[i] for i in panels["train_composition"]], + } + selected = ( + data["evaluation_compositions"] + if full + else [chains[i] for name, ids in panels.items() if name.startswith("test_") for i in ids] + ) + groups["test_all"] = selected + metrics, raw = {}, {} + for name, records in groups.items(): + metrics[name], raw[name] = ( + evaluate(model, records, tokenizer, device) if records else (aggregate([]), []) + ) + lookup = {p["id"]: p for p in raw["atomic"]} + for role in ["II", "IO", "OI", "OO"]: + metrics["test_" + role.lower()] = aggregate( + [p for p in raw["test_all"] if p["role"] == role] + ) + metrics["test_required_role_" + role.lower()] = aggregate( + [p for p in raw["test_all"] if p["required_role"] == role] + ) + filters = { + "test_unambiguous_canonical_answers": lambda r: r.get( + "canonical_answer_globally_unambiguous", True + ), + "test_no_known_shortcut": lambda r: not r.get("known_direct_shortcut", False), + "test_head_tail_unseen": lambda r: not r.get( + "head_tail_seen_in_combination_training", False + ), + "test_seen_operation": lambda r: r.get("operation_seen", False), + "test_no_shortcut_seen_operation": lambda r: not r.get("known_direct_shortcut", False) + and r.get("operation_seen", False), + } + for name, include in filters.items(): + ids = {r["id"] for r in selected if include(r)} + metrics[name] = aggregate([p for p in raw["test_all"] if p["id"] in ids]) + metrics[name]["coverage"] = len(ids) / len(selected) if selected else None + for index, name in enumerate(["test_first_atom", "test_second_atom"]): + metrics[name] = aggregate([lookup[r["atom_ids"][index]] for r in selected]) + metrics["gold_bridge_second"] = metrics["test_second_atom"].copy() + prerequisite = {r["id"] for r in selected if all(lookup[a]["alias_em"] for a in r["atom_ids"])} + metrics["test_prerequisites_correct"] = aggregate( + [p for p in raw["test_all"] if p["id"] in prerequisite] + ) + metrics["test_prerequisites_correct"]["coverage"] = ( + len(prerequisite) / len(selected) if selected else None + ) + if autonomous: + second_calls = [] + invalid = [] + for row in selected: + bridge_prediction = lookup[row["atom_ids"][0]]["prediction"] + q = atomic_question(bridge_prediction, row["edges"][1][1]) + try: + encoded = encode_example(tokenizer, q, row["answer"]) + except ValueError: + invalid.append(row) + continue + second_calls.append( + {**row, "question": q, "encoded": encoded, "autonomous_bridge": bridge_prediction} + ) + _, predictions = ( + evaluate(model, second_calls, tokenizer, device) if second_calls else (None, []) + ) + for row, result in zip(second_calls, predictions, strict=True): + result["bridge_prediction"] = row["autonomous_bridge"] + result["second_question"] = row["question"] + predictions.extend( + { + "id": row["id"], + "canonical_em": 0.0, + "alias_em": 0.0, + "unambiguous_alias_em": 0.0, + "f1": 0.0, + "nll": None, + "eos": False, + "truncated": True, + "has_unambiguous_answer": bool(row.get("unambiguous_answers", [])), + "canonical_answer_globally_unambiguous": row.get( + "canonical_answer_globally_unambiguous", True + ), + "invalid_generated_bridge_length": True, + } + for row in invalid + ) + raw["autonomous"] = predictions + metrics["autonomous"] = aggregate(predictions) + metrics["autonomous"]["invalid_bridge_prompts"] = len(invalid) + return metrics, raw + + +def save_checkpoint(path, model, optimizer, stream, counts, step, counters, wall_seconds=None): + temporary = Path(path).with_suffix(".tmp") + torch.save( + { + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "stream": stream.state_dict(), + "counts": counts, + "step": step, + "counters": counters, + "wall_seconds": wall_seconds, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(), + }, + temporary, + ) + temporary.replace(path) + + +def worker(config, spec, gpu): + torch.set_num_threads(4) + torch.set_num_interop_threads(1) + torch.cuda.set_device(gpu) + torch.backends.cuda.matmul.allow_tf32 = True + device = f"cuda:{gpu}" + data = json.loads(Path(config["data_file"]).read_text()) + assert sha256(config["data_file"]) == config["data_sha256"] + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + phase = config.get("phase", "development") + out = Path(config["results_root"]) / phase / spec["name"] + out.mkdir(parents=True, exist_ok=True) + model = construct(config["model"], spec, device) + optimizer = optimizer_for(model, spec["learning_rate"], spec["weight_decay"]) + records = data["atoms"] + data["train_compositions"] + stream = BatchStream(len(records), spec["sampling_seed"]) + counts = np.zeros(len(records), dtype=np.int64) + counters = dict( + training_seconds=0.0, + examples=0, + supervised_tokens=0, + executed_input_tokens=0, + effective_input_tokens=0, + estimated_matmul_training_flops=0, + ) + history, initial_step, wall_offset = [], 0, 0.0 + started = time.perf_counter() + if (out / "latest.pt").exists(): + checkpoint = torch.load(out / "latest.pt", map_location=device, weights_only=False) + model.load_state_dict(checkpoint["model"]) + optimizer.load_state_dict(checkpoint["optimizer"]) + stream.load_state_dict(checkpoint["stream"]) + counts, initial_step, counters = ( + checkpoint["counts"], + checkpoint["step"], + checkpoint["counters"], + ) + torch.set_rng_state(checkpoint["cpu_rng"].cpu()) + torch.cuda.set_rng_state(checkpoint["cuda_rng"].cpu()) + history = [ + r for r in json.loads((out / "learning.json").read_text()) if r["step"] <= initial_step + ] + wall_offset = checkpoint.get("wall_seconds") + if wall_offset is None: + wall_offset = history[-1]["wall_seconds"] if history else 0.0 + metadata = json.loads((out / "run.json").read_text()) + metadata.update(pid=os.getpid(), gpu=gpu, resumed_from_step=initial_step) + write_json(out / "run.json", metadata) + del checkpoint + else: + torch.manual_seed(spec["dropout_seed"]) + metadata = { + "spec": spec, + "model": config["model"], + "phase": phase, + "evaluation_nodes": config["evaluation_nodes"], + "execution_lock_sha256": sha256(config["execution_lock"]), + "world_sha256": config["data_sha256"], + "initial_model_sha256": model_digest(model), + "initial_tensor_sha256": tensor_digests(model), + "common_four_block_initial_sha256": shared_prefix_digest(model), + "parameters": sum(p.numel() for p in model.parameters()), + "atomic_examples": len(data["atoms"]), + "composition_examples": len(data["train_compositions"]), + "vocab_size": len(tokenizer), + "dtype": "BF16 AMP; FP32 parameters and Adam states", + "gpu": gpu, + "gpu_name": torch.cuda.get_device_name(gpu), + "pid": os.getpid(), + "job_type": phase + "-training", + "tracking_group": config["tracking"]["group"], + } + write_json(out / "run.json", metadata) + write_json(out / "learning.json", []) + nodes = set(config["evaluation_nodes"]) + last_loss = None + for step in range(initial_step, spec["steps"] + 1): + if step > initial_step: + for group in optimizer.param_groups: + group["lr"] = spec["learning_rate"] * min((step - 1) / spec["warmup_steps"], 1.0) + ids = stream.batch(spec["batch_size"]) + selected = [records[i] for i in ids] + torch.cuda.synchronize() + began = time.perf_counter() + values = update(model, optimizer, selected, spec, device, tokenizer.eos_token_id) + torch.cuda.synchronize() + counters["training_seconds"] += time.perf_counter() - began + last_loss = values["loss"] + counts[ids] += 1 + counters["examples"] += len(ids) + counters["supervised_tokens"] += sum(len(r["encoded"]["target"]) for r in selected) + for key in [ + "executed_input_tokens", + "effective_input_tokens", + "estimated_matmul_training_flops", + ]: + counters[key] += values[key] + if step % 50 == 0: + write_json( + out / "status.json", + { + "state": "training", + "step": step, + "target_step": spec["steps"], + "loss": last_loss, + "training_seconds": counters["training_seconds"], + "examples": counters["examples"], + "wall_seconds": wall_offset + time.perf_counter() - started, + "pid": os.getpid(), + "updated_utc": utc(), + }, + ) + if step in nodes and not any(r["step"] == step for r in history): + metrics, predictions = evaluate_dataset(model, data, tokenizer, device) + write_json(out / f"predictions-{step:07d}.json", predictions) + history.append( + { + "step": step, + "metrics": metrics, + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "loss": last_loss, + "atomic_epochs": float(counts[: len(data["atoms"])].mean()), + "composition_epochs": float(counts[len(data["atoms"]) :].mean()), + "peak_gpu_memory_bytes": torch.cuda.max_memory_allocated(), + "created_utc": utc(), + } + ) + write_json(out / "learning.json", history) + save_checkpoint( + out / "latest.pt", + model, + optimizer, + stream, + counts, + step, + counters, + wall_offset + time.perf_counter() - started, + ) + torch.save( + {"model": model.state_dict(), "step": step}, out / f"checkpoint-{step:07d}.pt" + ) + np.savez_compressed(out / f"exposure-{step:07d}.npz", counts=counts) + print( + json.dumps( + { + "step": step, + "loss": last_loss, + "metrics": metrics, + "training_seconds": counters["training_seconds"], + } + ), + flush=True, + ) + elif ( + step > initial_step and step % config.get("resume_checkpoint_interval", 1000000000) == 0 + ): + save_checkpoint( + out / "latest.pt", + model, + optimizer, + stream, + counts, + step, + counters, + wall_offset + time.perf_counter() - started, + ) + metrics, predictions = evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + write_json(out / "endpoint-predictions.json", predictions) + write_json(out / "endpoint.json", metrics) + result = { + "state": "trained_pending_independent_reload", + "step": spec["steps"], + "pid": os.getpid(), + "model_sha256": model_digest(model), + "checkpoint_sha256": sha256(out / "latest.pt"), + **counters, + "wall_seconds": wall_offset + time.perf_counter() - started, + "completed_utc": utc(), + } + write_json(out / "trained.json", result) + write_json(out / "status.json", result) + + +def audit(config, spec, gpu): + torch.set_num_threads(4) + torch.set_num_interop_threads(1) + torch.cuda.set_device(gpu) + torch.backends.cuda.matmul.allow_tf32 = True + device = f"cuda:{gpu}" + out = Path(config["results_root"]) / config.get("phase", "development") / spec["name"] + trained = json.loads((out / "trained.json").read_text()) + assert trained["pid"] != os.getpid() + assert sha256(out / "latest.pt") == trained["checkpoint_sha256"] + assert sha256(config["data_file"]) == config["data_sha256"] + data = json.loads(Path(config["data_file"]).read_text()) + tokenizer = GPT2TokenizerFast.from_pretrained(config["tokenizer"], local_files_only=True) + model = construct(config["model"], spec, device) + state = torch.load(out / "latest.pt", map_location="cpu", weights_only=False) + model.load_state_dict(state["model"]) + assert state["step"] == spec["steps"] + del state + assert model_digest(model) == trained["model_sha256"] + metrics, predictions = evaluate_dataset( + model, data, tokenizer, device, full=True, autonomous=True + ) + expected = json.loads((out / "endpoint-predictions.json").read_text()) + assert predictions == expected, ( + "Endpoint generation or teacher-forced scores do not independently reproduce" + ) + assert metrics == json.loads((out / "endpoint.json").read_text()) + result = { + "passed": True, + "pid": os.getpid(), + "source_training_pid": trained["pid"], + "checkpoint_sha256": trained["checkpoint_sha256"], + "model_sha256": trained["model_sha256"], + "predictions_recomputed": sum(len(p) for p in predictions.values()), + "completed_utc": utc(), + } + write_json(out / "audit.json", result) + write_json( + out / "complete.json", {**trained, "state": "complete", "independently_reloaded": True} + ) + write_json( + out / "status.json", + {"state": "complete", "step": spec["steps"], "independently_reloaded": True}, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition_data.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition_data.py new file mode 100644 index 0000000000000000000000000000000000000000..e907ece415c9c6e027e965818c1b8e6f82a2462e --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_composition_data.py @@ -0,0 +1,270 @@ +"""Source-grounded 2Wiki closed-book data preparation, without model access. + +Answer normalization and alias scoring follow the pinned author's v1.1 scorer. +The original questions and facts are retained; this is an adapted task in which +evaluation facts may be learned separately, never with evaluation chain labels. +""" + +from __future__ import annotations + +import hashlib +import json +import re +import string +import zipfile +from collections import Counter, defaultdict +from pathlib import Path + +ARCHIVE_SHA = "95df2bf56fdabe034e27aebc580e02264232203cf52552f9efe8a919e5529eef" +SPLIT_SALT = "2wiki-realworld-v1:" +QUESTION_TEMPLATES = { + "father": "Who is the father of {subject}?", + "mother": "Who is the mother of {subject}?", + "child": "Who is the child of {subject}?", + "spouse": "Who is the spouse of {subject}?", + "director": "Who directed {subject}?", + "performer": "Who performed {subject}?", + "composer": "Who composed {subject}?", + "creator": "Who created {subject}?", + "editor": "Who edited {subject}?", + "presenter": "Who presented {subject}?", + "manufacturer": "Who manufactured {subject}?", + "publisher": "Who published {subject}?", + "founded by": "Who founded {subject}?", + "student of": "Who was the teacher of {subject}?", + "educated at": "Where was {subject} educated?", + "employer": "Who employed {subject}?", + "date of birth": "On what date was {subject} born?", + "date of death": "On what date did {subject} die?", + "place of birth": "Where was {subject} born?", + "place of death": "Where did {subject} die?", + "place of burial": "Where was {subject} buried?", + "place of detention": "Where was {subject} detained?", + "cause of death": "What was the cause of death of {subject}?", + "country of citizenship": "What is the country of citizenship of {subject}?", + "country": "In which country is {subject}?", + "inception": "On what date was {subject} established?", + "award received": "What award did {subject} receive?", + "has part": "What is a part of {subject}?", +} + + +def sha256(path): + result = hashlib.sha256() + with Path(path).open("rb") as handle: + for block in iter(lambda: handle.read(8 * 1024 * 1024), b""): + result.update(block) + return result.hexdigest() + + +def write_json(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temporary = path.with_suffix(path.suffix + ".tmp") + temporary.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n") + temporary.replace(path) + + +def order(value, salt=SPLIT_SALT): + return hashlib.sha256((salt + str(value)).encode()).hexdigest() + + +def normalize_answer(value): + value = "".join(c for c in value.lower() if c not in string.punctuation) + return " ".join(re.sub(r"\b(a|an|the)\b", " ", value).split()) + + +def answer_scores(prediction, answers): + """Max EM/F1 across the author's canonical answer and entity aliases.""" + p = normalize_answer(prediction) + scores = [] + for answer in answers: + a = normalize_answer(answer) + if (p in {"yes", "no", "noanswer"} or a in {"yes", "no", "noanswer"}) and p != a: + f1 = 0.0 + else: + common = sum((Counter(p.split()) & Counter(a.split())).values()) + f1 = 2 * common / (len(p.split()) + len(a.split())) if common else 0.0 + scores.append((float(p == a), f1)) + return max((s[0] for s in scores), default=0.0), max((s[1] for s in scores), default=0.0) + + +def entity_id(identifier, surface): + if re.fullmatch(r"Q\d+", str(identifier)): + return identifier + return "literal:" + " ".join(str(surface).casefold().split()) + + +def extract_chain(row): + edges, surfaces = row.get("evidences_id", []), row.get("evidences", []) + if row.get("type") != "compositional" or len(edges) != 2 or len(surfaces) != 2: + return None + if any(len(e) != 3 for e in edges + surfaces): + return None + converted = [ + (entity_id(e[0], s[0]), str(e[1]), entity_id(e[2], s[2])) + for e, s in zip(edges, surfaces, strict=True) + ] + for indices in [(0, 1), (1, 0)]: + first, second = [converted[i] for i in indices] + if first[2] == second[0] and first[0] != second[2]: + return (first, second), [surfaces[i] for i in indices] + return None + + +class Components: + def __init__(self): + self.parent = {} + + def find(self, node): + self.parent.setdefault(node, node) + while self.parent[node] != node: + self.parent[node] = self.parent[self.parent[node]] + node = self.parent[node] + return node + + def union(self, first, second): + first, second = self.find(first), self.find(second) + if first != second: + self.parent[max(first, second)] = min(first, second) + + +def support_sentences(row): + context = {title: sentences for title, sentences in row["context"]} + result = [] + for title, index in row["supporting_facts"]: + if title not in context or not 0 <= index < len(context[title]): + result.append( + {"title": title, "index": index, "sentence": "", "invalid_support_reference": True} + ) + continue + result.append({"title": title, "index": index, "sentence": context[title][index]}) + return result + + +def prior_cases(project): + path = Path(project) / "docs/development-artifacts/twohop-frozen-v1/case-manifest.json" + if not path.exists(): + return set() + return {r["id"] for r in json.loads(path.read_text()) if r["dataset"] == "2wiki"} + + +def extract_archive(archive, project): + if sha256(archive) != ARCHIVE_SHA: + raise ValueError("2Wiki archive differs from the pinned author data") + records, aliases, labels = [], {}, defaultdict(Counter) + groups = Components() + with zipfile.ZipFile(archive) as source: + for line in source.read("id_aliases.json").decode().splitlines(): + entry = json.loads(line) + aliases[entry["Q_id"]] = entry["aliases"] + entry.get("demonyms", []) + for split in ("train", "dev"): + for row in json.loads(source.read(split + ".json")): + parsed = extract_chain(row) + if parsed is None: + continue + edges, surfaces = parsed + groups.union(edges[0][0], edges[0][2]) + for edge, surface in zip(edges, surfaces, strict=True): + labels[edge[0]][surface[0]] += 1 + labels[edge[2]][surface[2]] += 1 + records.append( + { + "id": row["_id"], + "source_split": split, + "question": row["question"], + "answer": row["answer"], + "answer_id": row.get("answer_id"), + "edges": edges, + "surfaces": surfaces, + "support": support_sentences(row), + } + ) + canonical = { + key: sorted(counts, key=lambda s: (-counts[s], s))[0] for key, counts in labels.items() + } + alias_owners = defaultdict(set) + for identifier, names in aliases.items(): + for name in names: + alias_owners[normalize_answer(name)].add(identifier) + old = prior_cases(project) + subject_relation = defaultdict(set) + for row in records: + for edge in row["edges"]: + subject_relation[edge[:2]].add(edge[2]) + ambiguous = {key for key, values in subject_relation.items() if len(values) > 1} + for row in records: + row["group"] = groups.find(row["edges"][0][0]) + row["development_group"] = int(order(row["group"])[:8], 16) % 5 == 0 + row["known_prior_case"] = row["id"] in old + row["aliases"] = aliases.get(row["answer_id"], []) + row["unambiguous_aliases"] = [ + a for a in row["aliases"] if len(alias_owners[normalize_answer(a)]) == 1 + ] + row["structural_errors"] = [] + if any(s.get("invalid_support_reference") for s in row["support"]): + row["structural_errors"].append("invalid_support_sentence_reference") + if any(edge[:2] in ambiguous for edge in row["edges"]): + row["structural_errors"].append("multiple_objects_for_subject_relation") + if row["answer_id"] and row["answer_id"] != row["edges"][1][2]: + row["structural_errors"].append("answer_id_does_not_match_chain") + if not row["answer_id"] and normalize_answer(row["answer"]) != normalize_answer( + row["surfaces"][1][2] + ): + row["structural_errors"].append("literal_answer_does_not_match_chain") + if any(edge[1] not in QUESTION_TEMPLATES for edge in row["edges"]): + row["structural_errors"].append("unreviewed_relation_template") + row["support_surface_flags"] = [] + text = normalize_answer(" ".join(s["title"] + " " + s["sentence"] for s in row["support"])) + for i, (edge, surface) in enumerate(zip(row["edges"], row["surfaces"], strict=True)): + for j in [0, 2]: + choices = [surface[j], *aliases.get(edge[j], [])] + if not any(normalize_answer(c) in text for c in choices if normalize_answer(c)): + row["support_surface_flags"].append( + f"edge{i}_position{j}_not_literal_in_support" + ) + return records, aliases, canonical + + +def review_sample(records, size=200): + """Round-robin relation pairs, then fixed hashes; independent of model scores.""" + result = [] + for split in ("train", "dev"): + by_pair = defaultdict(list) + for row in records: + if row["source_split"] == split: + by_pair[tuple(e[1] for e in row["edges"])].append(row) + for rows in by_pair.values(): + rows.sort(key=lambda r: order(r["id"], "2wiki-semantic-review-v1:")) + chosen = [] + while len(chosen) < size: + added = False + for pair in sorted(by_pair, key=lambda p: order(p, "relation-review:")): + if by_pair[pair]: + chosen.append(by_pair[pair].pop(0)) + added = True + if len(chosen) == size: + break + if not added: + break + result.extend(chosen) + return result + + +def atomic_question(subject, relation): + return QUESTION_TEMPLATES[relation].format(subject=subject) + + +def prompt(question): + return "Question: " + question + "\nAnswer:" + + +def encode_example(tokenizer, question, answer, limit=256, generation_limit=64): + prefix = tokenizer.encode(prompt(question), add_special_tokens=False) + target = tokenizer.encode(" " + answer, add_special_tokens=False) + [tokenizer.eos_token_id] + joint = tokenizer.encode(prompt(question) + " " + answer, add_special_tokens=False) + if joint != prefix + target[:-1]: + raise ValueError("Answer boundary changes joint tokenization") + if len(prefix) + len(target) > limit or len(target) > generation_limit: + raise ValueError("Example exceeds the frozen length limits; never truncate an answer") + return {"prefix": prefix, "target": target, "input": (prefix + target)[:-1]} diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation.py new file mode 100644 index 0000000000000000000000000000000000000000..5cfed1010e1cc6f386e54d10c69675d34f4bed4a --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation.py @@ -0,0 +1,322 @@ +"""Data-only confirmation isolation and independent endpoint recounting.""" + +from __future__ import annotations + +import ast +import copy +import json +import re +import statistics +import string +from collections import Counter, defaultdict +from pathlib import Path + +import numpy as np + +from .realworld_composition_data import normalize_answer, order, sha256, write_json + + +def head_bridge_names(data, canonical, aliases): + names = defaultdict(set) + for row in data["train_compositions"] + data["evaluation_compositions"]: + for index in (0, 2): + identifier = row["edges"][0][index] + labels = [canonical[identifier], row["surfaces"][0][index]] + for label in labels + aliases.get(identifier, []): + normalized = normalize_answer(label) + if normalized: + names[identifier].add(normalized) + return names + + +def answer_owners(canonical, aliases): + owners = defaultdict(set) + for identifier in set(canonical) | set(aliases): + for name in [canonical.get(identifier, ""), *aliases.get(identifier, [])]: + normalized = normalize_answer(name) + if normalized: + owners[normalized].add(identifier) + return owners + + +def isolate_confirmation(candidate, development, canonical, aliases): + """Exclude every chain touching a development head/bridge name, then rebuild.""" + dev_names = set().union(*head_bridge_names(development, canonical, aliases).values()) + formal_names = head_bridge_names(candidate, canonical, aliases) + excluded_entities = {e for e, names in formal_names.items() if names & dev_names} + excluded = {} + parts = {} + for key in ("train_compositions", "evaluation_compositions"): + excluded[key] = [ + r["id"] + for r in candidate[key] + if {r["edges"][0][0], r["edges"][0][2]} & excluded_entities + ] + excluded_ids = set(excluded[key]) + parts[key] = [copy.deepcopy(r) for r in candidate[key] if r["id"] not in excluded_ids] + all_chains = parts["train_compositions"] + parts["evaluation_compositions"] + used = {a for r in all_chains for a in r["atom_ids"]} + atoms = [copy.deepcopy(r) for r in candidate["atoms"] if r["id"] in used] + first, second = ({r["atom_ids"][i] for r in parts["train_compositions"]} for i in (0, 1)) + seen = first | second + direct = {(r["edge"][0], r["edge"][2]) for r in atoms} + pairs = {(r["edges"][0][0], r["edges"][1][2]) for r in parts["train_compositions"]} + operations = {tuple(e[1] for e in r["edges"]) for r in parts["train_compositions"]} + owners = answer_owners(canonical, aliases) + for row in atoms + all_chains: + identifier = row["edge"][2] if "edge" in row else row["edges"][1][2] + row["canonical_answer_globally_unambiguous"] = owners[normalize_answer(row["answer"])] == { + identifier + } + for row in all_chains: + a, b = row["atom_ids"] + row["role"] = ("I" if a in seen else "O") + ("I" if b in seen else "O") + row["required_role"] = ("I" if a in first else "O") + ("I" if b in second else "O") + pair = row["edges"][0][0], row["edges"][1][2] + row["known_direct_shortcut"] = pair in direct + row["head_tail_seen_in_combination_training"] = pair in pairs + row["operation_seen"] = tuple(e[1] for e in row["edges"]) in operations + panels = { + "test_" + role.lower(): [ + r["id"] + for r in sorted( + [r for r in parts["evaluation_compositions"] if r["role"] == role], + key=lambda r: order(r["id"], "panel:"), + )[:64] + ] + for role in ("II", "IO", "OI", "OO") + } + panels["train_composition"] = [ + r["id"] + for r in sorted(parts["train_compositions"], key=lambda r: order(r["id"], "panel:"))[:128] + ] + selected = {i for ids in panels.values() for i in ids} + required = {a for r in all_chains if r["id"] in selected for a in r["atom_ids"]} + panels["atomic"] = sorted( + required + | {r["id"] for r in sorted(atoms, key=lambda r: order(r["id"], "atom-panel:"))[:128]} + ) + data = {"atoms": atoms, **parts, "panels": panels} + report = { + "rule": ( + "Exclude chains whose head/bridge canonical, annotated surface or official alias " + "name overlaps development head/bridge names after author normalization; " + "retain shared tails." + ), + "excluded_entities": sorted(excluded_entities), + "excluded_case_ids": excluded, + "excluded_counts": {key: len(ids) for key, ids in excluded.items()}, + "colliding_names": sorted(dev_names & set().union(*formal_names.values())), + "model_results_used": False, + } + return data, report + + +def audit_confirmation(data, development, canonical, aliases): + """Recount from the selected records rather than selection bookkeeping.""" + atoms = {r["id"]: r for r in data["atoms"]} + train, held = data["train_compositions"], data["evaluation_compositions"] + rows = train + held + dev_names = head_bridge_names(development, canonical, aliases) + formal_names = head_bridge_names(data, canonical, aliases) + assert not set(dev_names) & set(formal_names) + assert not set().union(*dev_names.values()) & set().union(*formal_names.values()) + assert len(atoms) == len(data["atoms"]) + assert len({r["id"] for r in rows}) == len(rows) + + def chain(row): + return tuple(tuple(e) for e in row["edges"]) + + assert not {chain(r) for r in train} & {chain(r) for r in held} + held_questions = {normalize_answer(r["question"]) for r in held} + assert not {normalize_answer(r["question"]) for r in train} & held_questions + assert not {normalize_answer(r["question"]) for r in atoms.values()} & held_questions + assert not {normalize_answer(r["question"]) for r in atoms.values()} & { + normalize_answer(r["question"]) for r in development["atoms"] + } + seen = {a for r in train for a in r["atom_ids"]} + first, second = ({r["atom_ids"][i] for r in train} for i in (0, 1)) + owners = answer_owners(canonical, aliases) + for row in rows: + a, b = row["atom_ids"] + assert [atoms[a]["edge"], atoms[b]["edge"]] == row["edges"] + assert row["edges"][0][2] == row["edges"][1][0] + assert row["role"] == ("I" if a in seen else "O") + ("I" if b in seen else "O") + assert row["required_role"] == ("I" if a in first else "O") + ("I" if b in second else "O") + assert not row["structural_errors"] + assert not any(r["known_prior_case"] for r in held) + for pool in (list(atoms.values()), train, held): + prompt_answers = defaultdict(set) + for row in pool: + prompt_answers[normalize_answer(row["question"])].add(normalize_answer(row["answer"])) + identifier = row["edge"][2] if "edge" in row else row["edges"][1][2] + assert row["canonical_answer_globally_unambiguous"] == ( + owners[normalize_answer(row["answer"])] == {identifier} + ) + e = row["encoded"] + assert e["target"][-1] == 50256 and len(e["target"]) <= 64 + assert e["input"] == (e["prefix"] + e["target"])[:-1] + assert len(e["prefix"]) + len(e["target"]) <= 256 + assert all(len(answers) == 1 for answers in prompt_answers.values()) + panel_ids = {i for name, ids in data["panels"].items() if name != "atomic" for i in ids} + assert {a for r in rows if r["id"] in panel_ids for a in r["atom_ids"]} <= set( + data["panels"]["atomic"] + ) + return { + "passed": True, + "atoms": len(atoms), + "train_compositions": len(train), + "evaluation_compositions": len(held), + "evaluation_roles": dict(Counter(r["role"] for r in held)), + "required_role_counts": dict(Counter(r["required_role"] for r in held)), + "canonical_unambiguous_evaluation_count": sum( + r["canonical_answer_globally_unambiguous"] for r in held + ), + "panels": {name: len(ids) for name, ids in data["panels"].items()}, + "head_bridge_id_overlap": 0, + "head_bridge_normalized_name_overlap": 0, + "necessary_atomic_coverage": 1.0, + "known_direct_shortcuts": sum(r["known_direct_shortcut"] for r in held), + "unseen_operations": sum(not r["operation_seen"] for r in held), + "max_input_tokens": max(len(r["encoded"]["input"]) for r in list(atoms.values()) + rows), + "atomic_relations": dict(Counter(r["edge"][1] for r in atoms.values())), + "train_relation_pairs": dict(Counter(" -> ".join(e[1] for e in r["edges"]) for r in train)), + } + + +def finalize_confirmation(config): + """Independently score raw outputs using the pinned author's scorer functions.""" + root, art = Path(config["results_root"]), Path(config["artifact_root"]) + data = json.loads(Path(config["data_file"]).read_text()) + scorer = Path(config["official_scorer"]) + scope = dict(re=re, string=string, Counter=Counter) + tree = ast.parse(scorer.read_text()) + functions = [ + n + for n in tree.body + if isinstance(n, ast.FunctionDef) and n.name in {"normalize_answer", "exact_match_score"} + ] + exec(compile(ast.Module(body=functions, type_ignores=[]), str(scorer), "exec"), scope) + + def score(prediction, row): + return float( + any( + scope["exact_match_score"](prediction, g) + for g in [row["answer"], *row.get("aliases", [])] + ) + ) + + held = data["evaluation_compositions"] + summary, scores, atom_scores, exposures, metadata = {}, {}, {}, {}, {} + for spec in config["runs"]: + name = spec["name"] + out = root / config["phase"] / name + complete = json.loads((out / "complete.json").read_text()) + assert complete["step"] == spec["steps"] and complete["independently_reloaded"] + raw = json.loads((out / "endpoint-predictions.json").read_text()) + metrics = json.loads((out / "endpoint.json").read_text()) + for group, records in [ + ("atomic", data["atoms"]), + ("train_composition", data["train_compositions"]), + ("test_all", held), + ]: + by_id = {p["id"]: p for p in raw[group]} + assert len(by_id) == len(records) == len(raw[group]) + assert set(by_id) == {r["id"] for r in records} + recomputed = {r["id"]: score(by_id[r["id"]]["prediction"], r) for r in records} + assert all(recomputed[i] == by_id[i]["alias_em"] for i in recomputed) + assert abs(sum(recomputed.values()) / len(records) - metrics[group]["alias_em"]) < 1e-12 + if group == "test_all": + scores[name] = recomputed + for role in ("II", "IO", "OI", "OO"): + selected = [r for r in held if r["role"] == role] + assert ( + abs( + sum(recomputed[r["id"]] for r in selected) / len(selected) + - metrics["test_" + role.lower()]["alias_em"] + ) + < 1e-12 + ) + if group == "atomic": + atom_scores[name] = recomputed + summary[name] = metrics + exposures[name] = { + step: np.load(out / f"exposure-{step:07d}.npz")["counts"] + for step in config["evaluation_nodes"] + } + metadata[name] = json.loads((out / "run.json").read_text()) + assert complete["checkpoint_sha256"] == sha256(out / "latest.pt") + comparisons = [] + for seed in sorted({s["initialization"] for s in config["runs"]}): + specs = {s["architecture"]: s for s in config["runs"] if s["initialization"] == seed} + assert set(specs) == {"standard8", "loop4x2", "standard4"} + names = [s["name"] for s in specs.values()] + assert len({metadata[n]["common_four_block_initial_sha256"] for n in names}) == 1 + for step in config["evaluation_nodes"]: + assert all( + np.array_equal(exposures[names[0]][step], exposures[n][step]) for n in names[1:] + ) + for baseline in ("standard8", "standard4"): + loop, base = specs["loop4x2"]["name"], specs[baseline]["name"] + for role in ("all", "OO"): + selected = held if role == "all" else [r for r in held if r["role"] == role] + common = [ + r + for r in selected + if all(atom_scores[n][a] for n in (loop, base) for a in r["atom_ids"]) + ] + comparisons.append( + { + "initialization": seed, + "baseline": baseline, + "pool": role, + "n": len(selected), + "paired_difference": sum( + scores[loop][r["id"]] - scores[base][r["id"]] for r in selected + ) + / len(selected), + "both_models_necessary_atoms_correct_n": len(common), + "both_models_necessary_atoms_correct_coverage": len(common) / len(selected), + "conditional_paired_difference": sum( + scores[loop][r["id"]] - scores[base][r["id"]] for r in common + ) + / len(common) + if common + else None, + } + ) + means = {} + for architecture in ("standard8", "loop4x2", "standard4"): + names = [s["name"] for s in config["runs"] if s["architecture"] == architecture] + means[architecture] = {} + for group in ( + "atomic", + "train_composition", + "test_all", + "test_ii", + "test_io", + "test_oi", + "test_oo", + "autonomous", + ): + values = [summary[n][group]["alias_em"] for n in names] + means[architecture][group] = { + "mean": statistics.mean(values), + "sample_sd": statistics.stdev(values), + "per_initialization": values, + } + result = { + "passed": True, + "runs": len(config["runs"]), + "scientific_updates": sum(s["steps"] for s in config["runs"]), + "independent_dataset_splits": 1, + "paired_initializations": 3, + "paired_exposures_equal_at_all_nodes": True, + "architecture_scores": means, + "paired_comparisons": comparisons, + "source_data_sha256": sha256(config["data_file"]), + "official_scorer_sha256": sha256(scorer), + } + write_json(art / "confirmation-summary.json", summary) + write_json(art / "confirmation-recount-audit.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py new file mode 100644 index 0000000000000000000000000000000000000000..1b6fcadbe2e7be2944fe6e398e29c0812ca1329f --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py @@ -0,0 +1,119 @@ +"""Registered relation/component and paired-knowledge trajectory descriptions.""" + +from __future__ import annotations + +import json +from collections import defaultdict +from pathlib import Path + +from .realworld_composition_data import write_json + + +def threshold_intervals(history, group, threshold): + passed = [r["metrics"][group]["alias_em"] >= threshold for r in history] + + def interval(index): + if index is None: + return None + return [history[index - 1]["step"] if index else None, history[index]["step"]] + + first = next((i for i, value in enumerate(passed) if value), None) + sustained = next((i for i, value in enumerate(passed) if value and all(passed[i:])), None) + return { + "first_observed_interval": interval(first), + "sustained_observed_interval": interval(sustained), + } + + +def analyze_confirmation(config): + root = Path(config["results_root"]) / config["phase"] + data = json.loads(Path(config["data_file"]).read_text()) + held = {r["id"]: r for r in data["evaluation_compositions"]} + endpoint_groups, thresholds, nodes = {}, {}, {} + for spec in config["runs"]: + name = spec["name"] + out = root / name + raw = json.loads((out / "endpoint-predictions.json").read_text())["test_all"] + by_relation, by_component = defaultdict(list), defaultdict(list) + for prediction in raw: + row = held[prediction["id"]] + by_relation[" -> ".join(e[1] for e in row["edges"])].append(prediction["alias_em"]) + by_component[row["group"]].append(prediction["alias_em"]) + endpoint_groups[name] = { + key: {k: {"n": len(v), "alias_em": sum(v) / len(v)} for k, v in groups.items()} + for key, groups in [ + ("relation_pair", by_relation), + ("source_head_bridge_component", by_component), + ] + } + history = json.loads((out / "learning.json").read_text()) + thresholds[name] = { + f"{group}_{value}": threshold_intervals(history, group, value) + for group, value in [("train_composition", 0.99), ("test_all", 0.5), ("test_all", 0.9)] + } + nodes[name] = {} + for step in config["evaluation_nodes"]: + node = json.loads((out / f"predictions-{step:07d}.json").read_text()) + nodes[name][step] = { + group: {r["id"]: r["alias_em"] for r in node[group]} + for group in ("atomic", "test_all") + } + trajectories = [] + for seed in sorted({s["initialization"] for s in config["runs"]}): + specs = {s["architecture"]: s for s in config["runs"] if s["initialization"] == seed} + loop = specs["loop4x2"]["name"] + for baseline in ("standard8", "standard4"): + base = specs[baseline]["name"] + for step in config["evaluation_nodes"]: + left, right = nodes[loop][step], nodes[base][step] + assert set(left["test_all"]) == set(right["test_all"]) + for pool in ("all", "OO"): + selected = [ + held[i] + for i in left["test_all"] + if pool == "all" or held[i]["role"] == pool + ] + common = [ + r + for r in selected + if all(n["atomic"][a] for n in (left, right) for a in r["atom_ids"]) + ] + trajectories.append( + { + "initialization": seed, + "baseline": baseline, + "step": step, + "pool": pool, + "panel_n": len(selected), + "both_models_necessary_atoms_correct_n": len(common), + "both_models_necessary_atoms_correct_coverage": len(common) + / len(selected), + "full_panel_paired_difference": sum( + left["test_all"][r["id"]] - right["test_all"][r["id"]] + for r in selected + ) + / len(selected), + "conditional_paired_difference": sum( + left["test_all"][r["id"]] - right["test_all"][r["id"]] + for r in common + ) + / len(common) + if common + else None, + } + ) + result = { + "endpoint_groups": endpoint_groups, + "threshold_intervals": thresholds, + "paired_knowledge_trajectories": trajectories, + "trajectory_scope": ( + "Fixed panels at registered nodes; threshold brackets are descriptive and do not " + "identify exact crossing times or establish grokking." + ), + "endpoint_scope": ( + "Full registered evaluation pool; source components are shared by questions, " + "not independent worlds." + ), + } + write_json(Path(config["artifact_root"]) / "confirmation-analysis.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/recurrence_use.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/recurrence_use.py new file mode 100644 index 0000000000000000000000000000000000000000..3f2cf4432769a0bc1ea0278bf25468307718877b --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/recurrence_use.py @@ -0,0 +1,416 @@ +"""Frozen-weight update deletion and semantic first-hop interventions. + +Responses are measurements of computational dependence, not learned predictors. +Truth graphs select donors before inference; query means prevent donor frequency +from creating additional scientific observations. +""" + +from __future__ import annotations + +import time + +import numpy as np +import torch +from torch.nn import functional as F + +from .depth_step import EOS, prompt_rows, truth_path_details +from .latent_scaling import model_digest + +COMPONENTS = ("full", "attention", "mlp") +TASKS = ("atomic",) + tuple(f"{s}_{h}" for h in (2, 3, 4) for s in ("familiar", "strict")) + + +@torch.no_grad() +def trace(model, tokens, repeats, *, skip=None, patch=None): + """Apply one occurrence deletion or one r1 replacement, with native SDPA.""" + if model.training or repeats < 1: + raise ValueError("Evaluation mode and positive recurrence are required") + blocks = list(model.iter_blocks(repeats)) + if skip is not None: + scope, source = skip + if scope not in ("all", "r1") or source not in range(len(blocks)): + raise ValueError("Unknown skip scope/occurrence") + if patch is not None and patch[0] not in ("full", "mlp"): + raise ValueError("Unknown patch component") + x = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=tokens.device)) + cache = {name: [] for name in ("input", "full", "attention", "mlp", "output")} + for index, block in enumerate(blocks): + incoming = x + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + attention = a.proj( + F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=0.0, + ) + .transpose(1, 2) + .reshape(batch, length, width) + ) + x = x + attention + mlp = block.mlp(block.ln2(x)) + if index == 0 and patch is not None and patch[0] == "mlp": + mlp = mlp.clone() + if patch[1].shape != mlp[:, 2].shape: + raise ValueError("Replacement shape differs") + mlp[:, 2] = patch[1] + x = x + mlp + if index == 0 and patch is not None and patch[0] == "full": + x = x.clone() + if patch[1].shape != x[:, 2].shape: + raise ValueError("Replacement shape differs") + x[:, 2] = patch[1] + if skip is not None and index == skip[1]: + if skip[0] == "all": + x, attention, mlp = incoming, torch.zeros_like(attention), torch.zeros_like(mlp) + else: + x, attention, mlp = x.clone(), attention.clone(), mlp.clone() + x[:, 2], attention[:, 2], mlp[:, 2] = incoming[:, 2], 0, 0 + for name, value in zip(cache, (incoming, x - incoming, attention, mlp, x), strict=True): + cache[name].append(value) + logits = F.linear(model.ln_final(x), model.token.weight) + return logits, {name: torch.stack(values) for name, values in cache.items()} + + +def interaction(numerator, denominator): + """Ratio of query-averaged norms; an absent denominator is not zero influence.""" + numerator, denominator = np.asarray(numerator), np.asarray(denominator) + if numerator.shape != denominator.shape or not len(numerator): + raise ValueError("Require nonempty aligned response arrays") + n, b = float(numerator.mean()), float(denominator.mean()) + return {"N": n, "B": b, "C": n / b if b > 1e-8 else None} + + +def prediction_metrics(prediction, targets): + generated = prediction["generated"] + logits = prediction["logits"].astype(np.float64) + targets = np.asarray(targets, dtype=np.int64) + maximum = logits.max(1) + partition = maximum + np.log(np.exp(logits - maximum[:, None]).sum(1)) + target_logits = logits[np.arange(len(targets)), targets] + competitors = logits.copy() + competitors[np.arange(len(targets)), targets] = -np.inf + return { + "answer": (generated[:, 0] == targets).astype(float), + "complete": ((generated[:, 0] == targets) & (generated[:, 1] == EOS)).astype(float), + "eos": (generated[:, 1] == EOS).astype(float), + "nll": partition - target_logits, + "margin": target_logits - competitors.max(1), + } + + +def mean_metrics(metrics, mask=None): + length = len(next(iter(metrics.values()))) + mask = np.ones(length, bool) if mask is None else np.asarray(mask, dtype=bool) + if mask.shape != (length,): + raise ValueError("Mask must align with observations") + return { + "n": int(mask.sum()), + "coverage": float(mask.mean()) if length else 0.0, + **{k: float(v[mask].mean()) if mask.any() else None for k, v in metrics.items()}, + } + + +def query_means(values, indices, n): + counts = np.bincount(indices, minlength=n) + sums = np.bincount(indices, weights=values, minlength=n) + out = np.full(n, np.nan) + np.divide(sums, counts, out=out, where=counts > 0) + return out + + +def role_counts(world): + counts = np.zeros((len(world["atomic"]), 4), dtype=np.int64) + for hop in (2, 3, 4): + _, edges = truth_path_details(world, world[f"train_{hop}"]) + for position in range(hop): + np.add.at(counts[:, position], edges[:, position], 1) + return counts + + +def select_donors(low, high): + """Enumerate shared bridge donors and select answer-blind changed paths.""" + atoms = low["atomic"] + for name in TASKS: + np.testing.assert_array_equal(low[name], high[name]) + id_mask = np.asarray(low["metadata"]["id_mask"], bool) + np.testing.assert_array_equal(id_mask, high["metadata"]["id_mask"]) + low_roles, high_roles = role_counts(low), role_counts(high) + if low_roles[~id_mask].any() or high_roles[~id_mask].any(): + raise ValueError("Strict fact has composition training exposure") + used_first = (low_roles[:, 0] > 0) & (high_roles[:, 0] > 0) + strict = ~id_mask & (low_roles.sum(1) == 0) & (high_roles.sum(1) == 0) + result = {"low_roles": low_roles, "high_roles": high_roles} + rows = low["strict_2"] + nodes, _ = truth_path_details(low, rows) + for label, eligible in (("experienced", used_first), ("strict", strict)): + recipients, indices = [], [] + for i, (row, path) in enumerate(zip(rows, nodes, strict=True)): + mask = eligible & (atoms[:, 1] == row[1]) & (atoms[:, 2] == path[1]) + mask &= (atoms[:, 0] != row[0]) & (atoms[:, 0] != row[-1]) + choices = sorted(np.flatnonzero(mask), key=lambda k: tuple(atoms[k])) + recipients.extend([i] * len(choices)) + indices.extend(choices) + result[label + "_recipients"] = np.asarray(recipients, dtype=np.int64) + result[label + "_atoms"] = np.asarray(indices, dtype=np.int64) + result["common"] = (np.bincount(result["experienced_recipients"], minlength=len(rows)) > 0) & ( + np.bincount(result["strict_recipients"], minlength=len(rows)) > 0 + ) + lookup = {(int(h), int(r)): (i, int(t)) for i, (h, r, t) in enumerate(atoms)} + trained = {tuple(row[:-1]) for w in (low, high) for row in w["train_2"]} + order = sorted(range(len(atoms)), key=lambda i: tuple(atoms[i])) + for label in ("familiar", "strict"): + rows = low[label + "_2"] + nodes, edges = truth_path_details(low, rows) + recipients, donors, targets, successors = [], [], [], [] + for i, (row, path) in enumerate(zip(rows, nodes, strict=True)): + for fact in order: + h, r1, bridge = map(int, atoms[fact]) + successor = lookup.get((bridge, int(row[2]))) + if successor is None: + continue + next_index, target = successor + if ( + r1 != row[1] + or h in (row[0], row[-1], target) + or bridge == path[1] + or target == row[-1] + or (h, r1, int(row[2])) in trained + or id_mask[fact] != id_mask[edges[i, 0]] + or id_mask[next_index] != id_mask[edges[i, 1]] + ): + continue + recipients.append(i) + donors.append(fact) + targets.append(target) + successors.append(next_index) + break + result[label + "_changed_recipients"] = np.asarray(recipients, dtype=np.int64) + result[label + "_changed_atoms"] = np.asarray(donors, dtype=np.int64) + result[label + "_changed_targets"] = np.asarray(targets, dtype=np.int64) + result[label + "_changed_successors"] = np.asarray(successors, dtype=np.int64) + return result + + +@torch.no_grad() +def generate(model, rows, separator, repeats, *, skip=None, donor_atoms=None, component="full"): + """Free answer and free EOS; a donor sees only the atomic question prefix.""" + rows = np.asarray(rows, np.int64) + if not len(rows): + return { + "generated": np.empty((0, 2), np.int64), + "logits": np.empty((0, model.config.vocab_size), np.float32), + }, None + device = next(model.parameters()).device + tokens = torch.as_tensor(prompt_rows(rows, separator), device=device) + + def forward(inputs): + patch = None + if donor_atoms is not None: + donor = torch.zeros_like(inputs) + donor[:, :3] = torch.as_tensor( + prompt_rows(donor_atoms, separator)[:, :3], device=device + ) + _, donor_cache = trace(model, donor, 1) + field = "output" if component == "full" else "mlp" + patch = (component, donor_cache[field][0, :, 2]) + return trace(model, inputs, repeats, skip=skip, patch=patch) + + logits, cache = forward(tokens) + answer_logits = logits[:, -1] + answer = answer_logits.argmax(-1) + eos_logits, _ = forward(torch.cat((tokens, answer[:, None]), dim=1)) + prediction = { + "generated": torch.stack((answer, eos_logits[:, -1].argmax(-1)), 1).cpu().numpy(), + "logits": answer_logits.cpu().numpy(), + } + return prediction, cache + + +def response_arrays(baseline, changed, source): + arrays, rows = {}, [] + for component in COMPONENTS: + for site, position in (("all", None), ("r1", 2), ("answer", -1)): + a, b = baseline[component], changed[component] + n, d = (b - a).norm(dim=-1), a.norm(dim=-1) + n, d = ( + (n.mean(-1), d.mean(-1)) + if position is None + else (n[..., position], d[..., position]) + ) + for target in range(source + 1, len(a)): + numerator, denominator = n[target].cpu().numpy(), d[target].cpu().numpy() + key = f"{component}_{site}_i{source}_j{target}" + arrays[key + "_N"], arrays[key + "_B"] = numerator, denominator + rows.append( + { + "component": component, + "site": site, + "source": source, + "target": target, + **interaction(numerator, denominator), + } + ) + return arrays, rows + + +@torch.no_grad() +def evaluate(model, world, selection, repeats): + started = time.perf_counter() + if any(p.requires_grad for p in model.parameters()) or model.training: + raise ValueError("All weights must be frozen in evaluation mode") + before = model_digest(model) + model.repeats = repeats + separator = world["metadata"]["separator_token"] + arrays, summaries, engineering = {}, {}, {} + predictions, caches, metrics = {}, {}, {} + conditions = [("baseline", None)] + [ + (f"skip_{scope}_{i}", (scope, i)) for scope in ("all", "r1") for i in range(repeats) + ] + for task in TASKS: + rows = world[task] + arrays[task + "_rows"] = rows + predictions[task], metrics[task] = {}, {} + for name, skip in conditions: + pred, cache = generate(model, rows, separator, repeats, skip=skip) + m = prediction_metrics(pred, rows[:, -1]) + predictions[task][name], metrics[task][name] = pred, m + for field, values in {**pred, **m}.items(): + arrays[f"{task}_{name}_{field}"] = values + summaries[f"{task}/{name}"] = {"full_pool": mean_metrics(m)} + if name == "baseline": + caches[task] = cache + inputs = torch.as_tensor( + prompt_rows(rows, separator), device=next(model.parameters()).device + ) + native = model(inputs)[:, -1].cpu().numpy() + if not np.array_equal(native, pred["logits"]): + raise AssertionError("Traced logits differ from native forward") + engineering[task + "_native_logits_exact"] = True + elif task != "atomic": + response, cells = response_arrays(caches[task], cache, skip[1]) + arrays.update({f"{task}_{name}_{k}": v for k, v in response.items()}) + summaries[f"{task}/{name}"]["responses"] = cells + if name == f"skip_r1_{repeats - 1}": + for field in ("generated", "logits"): + np.testing.assert_array_equal(pred[field], predictions[task]["baseline"][field]) + engineering[task + "_last_r1_no_downstream_effect"] = True + del cache + for task in TASKS[1:]: + _, edges = truth_path_details(world, world[task]) + arrays[task + "_atomic_indices"] = edges + common = np.ones(len(world[task]), bool) + for name, _ in conditions: + common &= metrics["atomic"][name]["complete"][edges].all(1) + arrays[task + "_common_atomic_mask"] = common + for name, _ in conditions: + cell = summaries[f"{task}/{name}"] + cell["necessary_atomic_coverage"] = float( + metrics["atomic"][name]["complete"][edges].all(1).mean() + ) + cell["common_atomic_pool"] = mean_metrics(metrics[task][name], common) + # Self-prefix patches at equal physical length verify absence of later-relation information. + for task in ("familiar_2", "strict_2"): + rows = world[task] + atoms = np.c_[rows[:, :2], np.zeros(len(rows), np.int64)] + for component in ("full", "mlp"): + pred, _ = generate( + model, rows, separator, repeats, donor_atoms=atoms, component=component + ) + for field in ("generated", "logits"): + np.testing.assert_array_equal(pred[field], predictions[task]["baseline"][field]) + engineering[f"{task}_self_prefix_{component}_exact"] = True + rows = world["strict_2"] + _, edges = truth_path_details(world, rows) + common = selection["common"] + donor_atom_ok = np.ones(len(world["atomic"]), bool) + for label in ("experienced", "strict"): + recipients, facts = selection[label + "_recipients"], selection[label + "_atoms"] + donor_atom_ok[facts] = metrics["atomic"]["baseline"]["complete"][facts].astype(bool) + for component in ("full", "mlp"): + if not len(recipients): + continue + pred, _ = generate( + model, + rows[recipients], + separator, + repeats, + donor_atoms=world["atomic"][facts], + component=component, + ) + m = prediction_metrics(pred, rows[recipients, -1]) + key = f"same_{label}_{component}" + for field, value in {**pred, **m}.items(): + arrays[key + "_" + field] = value + balanced = {k: query_means(v, recipients, len(rows)) for k, v in m.items()} + summaries[key] = { + "common_graph_pool": mean_metrics(balanced, common), + "all_available": mean_metrics(balanced, np.isfinite(balanced["complete"])), + } + known = metrics["atomic"]["baseline"]["complete"][edges].all(1) + for label in ("experienced", "strict"): + recipients, facts = selection[label + "_recipients"], selection[label + "_atoms"] + for recipient, fact in zip(recipients, facts, strict=True): + known[recipient] &= donor_atom_ok[fact] + arrays["same_common_known_mask"] = known & common + summaries["same_baseline"] = { + "common_graph_pool": mean_metrics(metrics["strict_2"]["baseline"], common), + "common_known_pool": mean_metrics(metrics["strict_2"]["baseline"], known & common), + } + for label in ("experienced", "strict"): + recipients = selection[label + "_recipients"] + for component in ("full", "mlp"): + key = f"same_{label}_{component}" + if key in summaries: + m = { + k: arrays[key + "_" + k] for k in ("answer", "complete", "eos", "nll", "margin") + } + balanced = {k: query_means(v, recipients, len(rows)) for k, v in m.items()} + summaries[key]["common_known_pool"] = mean_metrics(balanced, known & common) + for label in ("familiar", "strict"): + task = label + "_2" + recipients = selection[label + "_changed_recipients"] + facts = selection[label + "_changed_atoms"] + targets = selection[label + "_changed_targets"] + if not len(recipients): + continue + original = world[task][recipients] + counterfactual = original.copy() + counterfactual[:, 0] = world["atomic"][facts, 0] + counterfactual[:, -1] = targets + truth_path_details(world, counterfactual) + native_cf, _ = generate(model, counterfactual, separator, repeats) + values = { + "baseline": {k: v[recipients] for k, v in predictions[task]["baseline"].items()}, + "counterfactual": native_cf, + } + for component in ("full", "mlp"): + values[component], _ = generate( + model, + original, + separator, + repeats, + donor_atoms=world["atomic"][facts], + component=component, + ) + for name, pred in values.items(): + key = f"changed_{label}_{name}" + m = prediction_metrics(pred, targets) + for field, vector in {**pred, **m}.items(): + arrays[key + "_" + field] = vector + summaries[key] = mean_metrics(m) + arrays.update({"selection_" + k: v for k, v in selection.items()}) + if model_digest(model) != before: + raise AssertionError("Intervention changed model parameters") + return arrays, { + "repeats": repeats, + "seconds": time.perf_counter() - started, + "weights_unchanged": True, + "model_sha256": before, + "engineering": engineering, + "conditions": summaries, + } diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/representation_alignment.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/representation_alignment.py new file mode 100644 index 0000000000000000000000000000000000000000..923e412fdf09bfaf85ca6de1fcb11cf4d6e754de --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/representation_alignment.py @@ -0,0 +1,269 @@ +"""Intermediate supervision and input-compatible states in complete causal GPTs. + +The intervention observes the first executed block at the first relation token. +Every arm executes the same forward/backward graph. Ordinary full-token CE, +auxiliary entity CE, and state geometry are recorded separately. +""" + +from __future__ import annotations + +import hashlib +import json +import os +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import EpochStream, GraphStep, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .latent_scaling import build_world, construct, model_digest +from .storage_composition import data_digest, evaluate, file_hash, pack_sentences +from .storage_frontier import learning_rate + + +class RepresentationGPT(LoopGPT): + """Unchanged GPT/Loop computation, optionally exposing a causal early state.""" + + def forward(self, tokens, positions=None, repeats=None, return_bridge=False): + p = self.dropout if self.training else 0.0 + x = self.token(tokens) + self.position(torch.arange(tokens.shape[1], device=tokens.device)) + x = F.dropout(x, p=p, training=self.training) + bridge = None + for index, block in enumerate(self.iter_blocks(repeats)): + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + is_causal=True, + dropout_p=p, + ) + y = a.proj(y.transpose(1, 2).reshape(batch, length, width)) + x = x + F.dropout(y, p=p, training=self.training) + x = x + F.dropout(block.mlp(block.ln2(x)), p=p, training=self.training) + if index == 0 and return_bridge: + bridge = x[:, 3] + x = self.ln_final(x) + if positions is not None: + x = x[torch.arange(len(tokens), device=tokens.device)[:, None], positions] + logits = F.linear(x, self.token.weight) + return (logits, bridge) if return_bridge else logits + + +def new_model(spec, device): + # Construct through the established initializer, then replace only the type. + model = construct(spec, device) + model.__class__ = RepresentationGPT + return model + + +def pack_training(world): + strata = [world[k] for k in ("common_atomic", "train_composite", "anchor_atomic")] + tokens, labels = ( + np.concatenate(parts) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + # Column 2 is the atomic answer or the composition's first-hop answer. + # It never enters the composed input; it is an explicit auxiliary target. + targets = np.concatenate([rows[:, 2] for rows in strata]) + return (tokens, labels, targets), [len(rows) for rows in strata] + + +def objective(model, tokens, labels, targets, bridge_weight, alignment_weight): + logits, bridge = model(tokens, return_bridge=True) + text_ce = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + bridge_logits = F.linear(model.ln_final(bridge), model.token.weight) + bridge_ce = F.cross_entropy(bridge_logits, targets) + canonical = model.token(targets).detach() + alignment = ( + (F.normalize(bridge, dim=-1) - F.normalize(canonical, dim=-1)).square().sum(-1).mean() + ) + parts = torch.stack((text_ce, bridge_ce, alignment)) + return text_ce + bridge_weight * bridge_ce + alignment_weight * alignment, parts + + +class RepresentationStep(GraphStep): + def __init__(self, model, optimizer, table, batch_size, spec): + self.spec = spec + super().__init__(model, optimizer, table, batch_size) + + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + tokens, labels, targets = (part[self.index] for part in self.table) + loss, self.components = objective( + self.model, + tokens, + labels, + targets, + self.spec["bridge_weight"], + self.spec["alignment_weight"], + ) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def run_name(spec): + return f"{spec['phase']}-w{spec['world']}-i{spec['initialization']}-{spec['arm']}" + + +def train(spec, out, source, device): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "run.json").exists(): + raise FileExistsError(f"Do not overwrite an attempt: {out}") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(device) + started = time.perf_counter() + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + arrays, sizes = pack_training(world) + model = new_model(spec, device) + initial_hash = model_digest(model) + write_json( + out / "run.json", + { + "spec": spec, + "source": source, + "world_sha256": data_digest(world), + "initial_model_sha256": initial_hash, + "pid": os.getpid(), + "gpu": device.index, + "gpu_name": torch.cuda.get_device_name(device), + "dtype": "float32", + "parameters": sum(p.numel() for p in model.parameters()), + "atomic_examples": sizes[0] + sizes[2], + "composition_examples": sizes[1], + "vocab_size": model.config.vocab_size, + }, + ) + table = tuple(torch.as_tensor(a, device=device) for a in arrays) + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + model.train() + graph = RepresentationStep(model, optimizer, table, spec["batch_size"], spec) + assert model_digest(model) == initial_hash, "CUDA capture changed initialization" + streams = [EpochStream(n, spec["stream_seed"] + j) for j, n in enumerate(sizes)] + offsets = np.cumsum([0, *sizes[:-1]]) + counts = [np.zeros(n, dtype=np.int64) for n in sizes] + input_hash = hashlib.sha256() + history, step, training_seconds = [], 0, 0.0 + flop_step = flops(model.config, spec["repeats"], spec["batch_size"], 9, output_positions=9) + # All arms also execute the auxiliary readout and normalization. + flop_step += 6 * spec["batch_size"] * model.config.width * model.config.vocab_size + + def measure(): + metrics, predictions = evaluate(model, world, "low", device) + parts = graph.components.detach().cpu().tolist() if step else [None] * 3 + row = { + "step": step, + "metrics": metrics, + "text_ce": parts[0], + "bridge_ce": parts[1], + "alignment_loss": parts[2], + "training_seconds": training_seconds, + "wall_seconds": time.perf_counter() - started, + "examples": step * spec["batch_size"], + "supervised_tokens": step * spec["batch_size"] // 3 * (7 + 9 + 7), + "auxiliary_target_presentations": step * spec["batch_size"], + "estimated_matmul_training_flops": step * flop_step, + "composition_epochs": step * spec["batch_size"] / 3 / sizes[1], + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + write_json(out / "status.json", {"state": "running", "step": step, "budget": spec["steps"]}) + print( + json.dumps( + { + "run": run_name(spec), + "step": step, + "atomic": metrics["common_atomic"]["accuracy"], + "train": metrics["train_composite"]["accuracy"], + "familiar": metrics["familiar_test"]["accuracy"], + "strict": metrics["strict_test"]["accuracy"], + } + ), + flush=True, + ) + model.train() + + measure() + for end in spec["nodes"][1:]: + torch.cuda.synchronize(device) + began = time.perf_counter() + while step < end: + n = min(128, end - step) + indices = [] + for j, stream in enumerate(streams): + drawn = stream.take(n * spec["batch_size"] // 3).reshape(n, -1) + counts[j] += np.bincount(drawn.ravel(), minlength=sizes[j]) + indices.append(drawn + offsets[j]) + indices = np.concatenate(indices, axis=1) + input_hash.update(indices.tobytes()) + indices = torch.as_tensor(indices, device=device) + for j in range(n): + lr.fill_(learning_rate(spec, step + j + 1)) + loss = graph(indices[j]) + step += n + torch.cuda.synchronize(device) + training_seconds += time.perf_counter() - began + if not np.isfinite(float(loss)): + raise FloatingPointError(f"Nonfinite objective at {step}") + measure() + model.eval() + torch.save( + {"spec": spec, "model": model.state_dict(), "optimizer": optimizer.state_dict()}, + out / "model.pt", + ) + np.savez_compressed(out / "exposures.npz", **{f"stratum{j}": c for j, c in enumerate(counts)}) + write_json( + out / "complete.json", + { + "spec": spec, + "source": source, + "finished_utc": utc(), + "metrics": history[-1]["metrics"], + "training_seconds": training_seconds, + "world_sha256": data_digest(world), + "initial_model_sha256": initial_hash, + "sample_stream_sha256": input_hash.hexdigest(), + "model_sha256": file_hash(out / "model.pt"), + }, + ) + write_json(out / "status.json", {"state": "complete", "step": step}) + + +def audit(out, device): + out = Path(out) + # Match trainer arithmetic before comparing generated tokens and NLL. + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + payload = torch.load(out / "model.pt", map_location="cpu", weights_only=False) + spec = payload["spec"] + model = new_model(spec, device) + model.load_state_dict(payload["model"]) + world = build_world(spec) + metrics, predictions = evaluate(model, world, "low", device) + saved = np.load(out / f"predictions-{spec['steps']:06d}.npz") + max_nll_error = 0.0 + for key, actual in predictions.items(): + if key.endswith("nll"): + max_nll_error = max(max_nll_error, float(np.max(np.abs(actual - saved[key])))) + np.testing.assert_allclose(actual, saved[key], rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(actual, saved[key]) + write_json( + out / "audit.json", + {"passed": True, "metrics": metrics, "max_nll_error": max_nll_error, "allow_tf32": True}, + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_composition.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_composition.py new file mode 100644 index 0000000000000000000000000000000000000000..f7bc9b1ea8e7d825eb5f27c33bb4d7e38bb7bcc1 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_composition.py @@ -0,0 +1,543 @@ +"""Development comparison in an unchanged, fully trained pretrained Qwen LM. + +Only training document grouping differs. All weights, native embeddings, +residuals, attention, norms and distinct MLP layers are retained. +""" + +from __future__ import annotations + +import hashlib +import json +import math +import re +import shutil +import time +from collections import Counter +from datetime import datetime, timezone +from pathlib import Path + +import numpy as np +import torch +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +QUESTIONS = ( + ( + "Who is {head}'s mentor?", + "Who mentors {head}?", + "Name the mentor of {head}.", + "Who is the mentor of {head}?", + ), + ( + "Which city does {bridge} live in?", + "What city is {bridge}'s home?", + "Where does {bridge} live?", + "Name the city where {bridge} lives.", + ), + ( + "Which city does {head}'s mentor live in?", + "What city is home to {head}'s mentor?", + "Where does the mentor of {head} live?", + "Name the city where {head}'s mentor lives.", + ), +) +CITIES = ( + "Paris Rome London Berlin Tokyo Oslo Lima Cairo Delhi Seoul Dublin Madrid " + "Vienna Boston Sydney Lisbon" +).split() + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n") + + +def sha(path): + with Path(path).open("rb") as handle: + return hashlib.file_digest(handle, "sha256").hexdigest() + + +def now(): + return datetime.now(timezone.utc).isoformat() + + +def build_world(config): + first = ( + "Rhea Mara Evan Luca Nora Iris Owen Hugo Cora Theo Nina Leon Vera Finn Dana Arlo" + ).split() + last = "Hale Vale Mercer Rowan Keane Flint Arden Voss North Lark".split() + names = [f"{a} {b}" for a in first for b in last] + n = config["target_triples"] + config["background_triples"] + assert 2 * n <= len(names) + rng = np.random.default_rng(config["world_seed"]) + names = rng.permutation(names).tolist() + rows = [] + for split, count in ( + ("target", config["target_triples"]), + ("background", config["background_triples"]), + ): + cities = rng.permutation([CITIES[i % len(CITIES)] for i in range(count)]) + for city in cities: + i = len(rows) + rows.append( + dict(id=i, split=split, head=names[2 * i], bridge=names[2 * i + 1], city=str(city)) + ) + return rows + + +def prompt(row, hop, variant=0): + return "Fictional registry.\nQuestion: " + QUESTIONS[hop][variant].format(**row) + "\nAnswer:" + + +def answer(row, hop): + return row["bridge"] if hop == 0 else row["city"] + + +def encode_document(tokenizer, row, hop, variant): + ids = tokenizer.encode( + prompt(row, hop, variant) + " " + answer(row, hop) + ".", add_special_tokens=False + ) + [tokenizer.eos_token_id] + # The initial token of each atomic document has no within-document predecessor. + # It remains unscored when documents are joined, preserving every target token. + return dict(ids=ids, labels=[-100, *ids[1:]], triple=row["id"], hop=hop, variant=variant) + + +def corpus(tokenizer, world): + records = {} + for row in world: + hops = range(3) if row["split"] == "background" else range(2) + for hop in hops: + for variant in range(4): + records[row["id"], hop, variant] = encode_document(tokenizer, row, hop, variant) + return records + + +def stream(config, world): + rng = np.random.default_rng(config["training_seed"]) + background = [r["id"] for r in world if r["split"] == "background"] + result = [] + for _ in range(config["steps"]): + pairs = [ + [int(i), int(v)] + for i, v in zip( + rng.choice(len(world), config["atomic_pairs_per_step"], replace=False), + rng.integers(4, size=config["atomic_pairs_per_step"]), + strict=True, + ) + ] + compositions = [ + [int(i), int(v)] + for i, v in zip( + rng.choice(background, config["background_compositions_per_step"], replace=False), + rng.integers(4, size=config["background_compositions_per_step"]), + strict=True, + ) + ] + result.append(dict(pairs=pairs, compositions=compositions)) + return result + + +def documents(records, batch, arm): + docs = [] + for i, v in batch["pairs"]: + first, second = records[i, 0, v], records[i, 1, v] + if arm == "separate": + docs.extend([first, second]) + elif arm == "linked": + docs.append( + dict(ids=first["ids"] + second["ids"], labels=first["labels"] + second["labels"]) + ) + else: + raise ValueError(arm) + docs.extend(records[i, 2, v] for i, v in batch["compositions"]) + return docs + + +def batch_tensors(docs, pad_id, device): + width = max(len(d["ids"]) for d in docs) + ids = torch.full((len(docs), width), pad_id, device=device, dtype=torch.long) + labels = torch.full_like(ids, -100) + mask = torch.zeros_like(ids) + for i, doc in enumerate(docs): + n = len(doc["ids"]) + ids[i, :n] = torch.tensor(doc["ids"], device=device) + labels[i, :n] = torch.tensor(doc["labels"], device=device) + mask[i, :n] = 1 + return dict(input_ids=ids, attention_mask=mask, labels=labels) + + +def normalize(text): + return re.sub(r"\s+", " ", text.strip().rstrip(".").strip()).casefold() + + +def grade(text, gold): + first_line = text.strip().split("\n")[0] + return normalize(first_line) == normalize(gold) + + +def evaluation_rows(world): + return [ + dict(**row, hop=hop, prompt=prompt(row, hop), answer=answer(row, hop)) + for row in world + for hop in (range(3) if row["split"] == "target" else [2]) + ] + + +@torch.inference_mode() +def evaluate(model, tokenizer, world, config): + model.eval() + tokenizer.padding_side = "left" + rows = evaluation_rows(world) + results = [] + for start in range(0, len(rows), config["eval_batch"]): + chunk = rows[start : start + config["eval_batch"]] + enc = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(config["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + generated = model.generate( + **enc, + do_sample=False, + max_new_tokens=config["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, enc.input_ids.shape[1] :] + for row, tokens in zip(chunk, generated.cpu().tolist(), strict=True): + # Drop batching padding after the first EOS; retain the actual generated EOS. + if tokenizer.eos_token_id in tokens: + tokens = tokens[: tokens.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tokens, skip_special_tokens=True) + results.append( + dict(**row, tokens=tokens, text=text, correct=grade(text, row["answer"])) + ) + return results + + +def score(rows): + result = {} + for split, hop, key in ( + ("target", 0, "first_hop"), + ("target", 1, "second_hop"), + ("target", 2, "two_hop"), + ("background", 2, "background_two_hop"), + ): + selected = [r for r in rows if r["split"] == split and r["hop"] == hop] + result[key] = sum(r["correct"] for r in selected) / len(selected) + indexed = {(r["id"], r["hop"]): r for r in rows if r["split"] == "target"} + mastered = [ + i for i, h in indexed if h == 0 and indexed[i, 0]["correct"] and indexed[i, 1]["correct"] + ] + result["both_atomic_coverage"] = len(mastered) / sum(h == 0 for _, h in indexed) + result["two_hop_if_both_atomic"] = ( + sum(indexed[i, 2]["correct"] for i in mastered) / len(mastered) if mastered else None + ) + return result + + +def prepare(config_path): + config = read(config_path) + art = Path(config["artifact_root"]) + if (art / "lock.json").exists(): + raise RuntimeError("Development lock already exists; do not overwrite it.") + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + world = build_world(config) + batches = stream(config, world) + records = corpus(tokenizer, world) + assert all(h != 2 or world[i]["split"] == "background" for i, h, _ in records) + stats = {} + for arm in config["arms"]: + counts = Counter() + token_counts = Counter() + input_tokens = supervised_tokens = padded_tokens = attention_cells = 0 + for batch in batches: + docs = documents(records, batch, arm) + for d in docs: + input_tokens += len(d["ids"]) + supervised_tokens += sum(t != -100 for t in d["labels"]) + counts.update(t for t in d["labels"] if t != -100) + token_counts.update(d["ids"]) + width = max(len(d["ids"]) for d in docs) + padded_tokens += len(docs) * width + attention_cells += len(docs) * width**2 + stats[arm] = dict( + input_tokens=input_tokens, + supervised_tokens=supervised_tokens, + padded_tokens=padded_tokens, + attention_cells=attention_cells, + target_token_counts=sorted(counts.items()), + input_token_counts=sorted(token_counts.items()), + ) + for key in ("input_tokens", "supervised_tokens", "target_token_counts", "input_token_counts"): + assert stats["separate"][key] == stats["linked"][key], key + write(art / "world.json", world) + write(art / "stream.json", batches) + write(art / "data-audit.json", dict(status="passed", stats=stats, target_composition_labels=0)) + sources = [ + str(config_path), + __file__, + "scripts/run_small_lm_composition.py", + "tests/test_small_lm_composition.py", + str(art / "development-plan.md"), + ] + frozen = {} + for source in sources: + path = Path(source).resolve() + relative = path.relative_to(Path.cwd()) + dest = art / "source" / relative + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, dest) + frozen[str(relative)] = sha(path) + model_files = { + str(p): sha(p) + for p in Path(config["model_path"]).iterdir() + if p.suffix in (".safetensors", ".json") + } + write( + art / "lock.json", + dict( + status="locked_before_training", + utc=now(), + sources=frozen, + model_files=model_files, + world_sha256=sha(art / "world.json"), + stream_sha256=sha(art / "stream.json"), + ), + ) + print( + json.dumps( + { + "status": "prepared", + "stats": { + a: {k: v for k, v in s.items() if not k.endswith("counts")} + for a, s in stats.items() + }, + } + ), + flush=True, + ) + + +def parameter_samples(model): + names = [ + "model.embed_tokens.weight", + "model.layers.0.self_attn.q_proj.weight", + "model.layers.0.mlp.down_proj.weight", + "model.layers.0.input_layernorm.weight", + "model.layers.27.self_attn.o_proj.weight", + "model.layers.27.mlp.down_proj.weight", + ] + params = dict(model.named_parameters()) + return {n: params[n].detach().flatten()[:4096].clone() for n in names} + + +def train(config_path, arm): + config = read(config_path) + assert arm in config["arms"] + art = Path(config["artifact_root"]) + lock = read(art / "lock.json") + for path, expected in lock["sources"].items(): + assert sha(path) == expected, path + for path, expected in lock["model_files"].items(): + assert sha(path) == expected, path + assert sha(art / "world.json") == lock["world_sha256"] + assert sha(art / "stream.json") == lock["stream_sha256"] + out = Path(config["output_root"]) / arm + out.mkdir(parents=True, exist_ok=True) + if (out / "status.json").exists(): + raise RuntimeError("A run record already exists; preserve it and use a new output root.") + write(out / "status.json", dict(status="running", arm=arm, utc=now())) + begun = time.perf_counter() + torch.set_num_threads(config["cpu_threads"]) + torch.manual_seed(config["training_seed"]) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.set_device(config["device"]) + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + model = AutoModelForCausalLM.from_pretrained( + config["model_path"], + torch_dtype=torch.float32, + attn_implementation="sdpa", + local_files_only=True, + ).to(config["device"]) + model.requires_grad_(True) + assert all(p.requires_grad for p in model.parameters()) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + samples = parameter_samples(model) + world, batches = read(art / "world.json"), read(art / "stream.json") + records = corpus(tokenizer, world) + optimizer = torch.optim.AdamW( + model.parameters(), + lr=config["learning_rate"], + weight_decay=config["weight_decay"], + fused=True, + ) + curve = [] + token_count = 0 + train_seconds = 0.0 + initial_gradients = {} + for step in range(config["steps"] + 1): + if step in config["nodes"]: + rows = evaluate(model, tokenizer, world, config) + write(out / f"predictions-{step:05d}.json", rows) + record = dict(step=step, **score(rows)) + curve.append(record) + write(out / "curve.json", curve) + print(json.dumps(dict(arm=arm, **record)), flush=True) + if step == config["steps"]: + break + rate = config["minimum_learning_rate"] + 0.5 * ( + config["learning_rate"] - config["minimum_learning_rate"] + ) * ( + 1 + + math.cos( + math.pi + * max(0, step - config["warmup_steps"]) + / (config["steps"] - config["warmup_steps"]) + ) + ) + rate *= min(1.0, (step + 1) / config["warmup_steps"]) + for group in optimizer.param_groups: + group["lr"] = rate + model.train() + docs = documents(records, batches[step], arm) + inputs = batch_tensors(docs, tokenizer.pad_token_id, config["device"]) + token_count += int(inputs["labels"].ne(-100).sum()) + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = model(**inputs, use_cache=False).loss + assert torch.isfinite(loss), float(loss) + loss.backward() + if step == 0: + for name, p in model.named_parameters(): + assert p.grad is not None and torch.isfinite(p.grad).all(), name + if name in samples: + initial_gradients[name] = float(p.grad.norm()) + torch.nn.utils.clip_grad_norm_(model.parameters(), config["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 32 == 0: + print( + json.dumps( + dict( + arm=arm, + step=step + 1, + loss=float(loss), + learning_rate=rate, + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + n: bool(not torch.equal(old, parameter_samples(model)[n])) for n, old in samples.items() + } + assert all(changed.values()), changed + parameter_count = sum(p.numel() for p in model.parameters()) + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + reloaded = AutoModelForCausalLM.from_pretrained( + out / "model", + torch_dtype=torch.float32, + attn_implementation="sdpa", + local_files_only=True, + ).to(config["device"]) + reloaded_rows = evaluate(reloaded, tokenizer, world, config) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in reloaded_rows] + write( + out / "reload-audit.json", + dict(status="passed", predictions=len(final_rows), exact_generated_tokens=True), + ) + budget = read(art / "data-audit.json")["stats"][arm] + assert token_count == budget["supervised_tokens"] + summary = dict( + status="complete", + phase="development", + arm=arm, + utc=now(), + metrics=score(final_rows), + model_repo=config["model_repo"], + model_revision=config["model_revision"], + lock_sha256=sha(art / "lock.json"), + parameter_count=parameter_count, + trainable_parameters=parameter_count, + sampled_parameters_changed=changed, + initial_sampled_gradient_norms=initial_gradients, + budget={k: v for k, v in budget.items() if not k.endswith("counts")}, + updates=config["steps"], + train_seconds=train_seconds, + process_seconds=time.perf_counter() - begun, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + train_weight_dtype="float32", + forward_dtype="bfloat16 autocast", + tf32=False, + checkpoint_files={str(p): sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + write(out / "summary.json", summary) + write(out / "status.json", dict(status="complete", utc=now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + config = read(config_path) + art = Path(config["artifact_root"]) + runs, predictions = {}, {} + for arm in config["arms"]: + out = Path(config["output_root"]) / arm + runs[arm] = read(out / "summary.json") + assert runs[arm]["status"] == "complete" + assert read(out / "reload-audit.json")["status"] == "passed" + rows = read(out / f"predictions-{config['steps']:05d}.json") + assert score(rows) == runs[arm]["metrics"] + predictions[arm] = {(r["id"], r["hop"]): r for r in rows if r["split"] == "target"} + common = [ + i + for i, h in predictions["separate"] + if h == 0 + and all(predictions[a][i, hop]["correct"] for a in config["arms"] for hop in (0, 1)) + ] + conditional = { + a: sum(predictions[a][i, 2]["correct"] for i in common) / len(common) if common else None + for a in config["arms"] + } + result = dict( + status="complete", + phase="development_only", + utc=now(), + runs=runs, + common_atomic_n=len(common), + common_atomic_coverage=len(common) / config["target_triples"], + common_atomic_two_hop=conditional, + two_hop_difference=runs["linked"]["metrics"]["two_hop"] + - runs["separate"]["metrics"]["two_hop"], + notes=[ + "One synthetic world and one training seed; no independent confirmation.", + "Natural-language fictional facts; original pretrained Qwen architecture.", + "Exact fact, input-token and supervised-token exposure match.", + "Document grouping changes context, positions and attention work.", + "Linked training co-presents the head and final city; not zero cooccurrence.", + "This behavior comparison does not uniquely identify an MLP mechanism.", + ], + ) + write(art / "summary.json", result) + print(json.dumps({k: v for k, v in result.items() if k != "runs"}), flush=True) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_followup.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_followup.py new file mode 100644 index 0000000000000000000000000000000000000000..4c986ea475b4f0abe83ea3d0411a049344ac0e08 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/small_lm_followup.py @@ -0,0 +1,558 @@ +"""Small full-Qwen development: matched rehearsal, pairing, and factual updates.""" + +from __future__ import annotations + +import copy +import itertools +import json +import math +import shutil +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch +import transformers +from transformers import AutoModelForCausalLM, AutoTokenizer + +from . import small_lm_composition as base + +HELDOUT = ( + "Give the name of the person mentoring {head}.", + "In which city is {bridge} living?", + "In which city is the person mentoring {head} living?", +) + + +def pairing_stream(config, world): + batches = base.stream(config, world) + rng = np.random.default_rng(config["pairing_seed"]) + for batch in batches: + pairs = batch["pairs"] + + def valid(order, pairs=pairs): + return all( + world[i]["city"] != world[pairs[k][0]]["city"] + for (i, _), k in zip(pairs, order, strict=True) + ) + + candidates = (rng.permutation(len(pairs)).tolist() for _ in range(1000)) + order = next((p for p in candidates if valid(p)), None) + if order is None: + order = next( + (list(p) for p in itertools.permutations(range(len(pairs))) if valid(p)), None + ) + if order is None: + raise ValueError("Batch cannot match distinct cities; revise before training.") + batch["second_order"] = order + return batches + + +def training_documents(records, batch, arm, copies=1): + pairs = batch["pairs"] + singles = [records[i, h, v] for i, v in pairs for h in (0, 1)] + docs = [] + if arm == "separate": + docs.extend(singles) + else: + order = range(len(pairs)) if arm == "linked" else batch["second_order"] + if arm not in ("linked", "shuffled"): + raise ValueError(arm) + for (i, v), j in zip(pairs, order, strict=True): + k, w = pairs[j] + first, second = records[i, 0, v], records[k, 1, w] + docs.append( + dict(ids=first["ids"] + second["ids"], labels=first["labels"] + second["labels"]) + ) + docs.extend(singles * copies) + docs.extend(records[i, 2, v] for i, v in batch["compositions"]) + return docs + + +def edit_design(config, world): + rng = np.random.default_rng(config["edit_seed"]) + ids = [] + for city in base.CITIES: + options = [r["id"] for r in world if r["split"] == "target" and r["city"] == city] + ids.extend(int(i) for i in rng.choice(options, len(options) // 2, replace=False)) + cities = rng.permutation(base.CITIES).tolist() + shift = int(rng.integers(1, len(cities))) + mapping = dict(zip(cities, cities[shift:] + cities[:shift], strict=True)) + changed = copy.deepcopy(world) + for row in changed: + if row["id"] in ids: + row["city"] = mapping[row["city"]] + rng = np.random.default_rng(config["edit_training_seed"]) + background = [r["id"] for r in world if r["split"] == "background"] + batches = [] + for _ in range(config["edit_steps"]): + specs = [] + for pool, count, hop in ( + (ids, config["edited_second_per_step"], 1), + (ids, config["replayed_first_per_step"], 0), + (background, config["background_atomic_per_step"], None), + (background, config["background_compositions_edit_per_step"], 2), + ): + for i in rng.choice(pool, count, replace=False): + h = int(rng.integers(2)) if hop is None else hop + specs.append([int(i), h, int(rng.integers(4))]) + batches.append(specs) + return dict(edited_ids=sorted(ids), city_mapping=mapping, world=changed, stream=batches) + + +def view_prompt(row, hop, view): + if view == 0: + return base.prompt(row, hop) + return "Fictional registry.\nQuestion: " + HELDOUT[hop].format(**row) + "\nAnswer:" + + +def evaluation_rows(world, extras=False): + return [ + dict( + **row, + hop=hop, + view=view, + mode="direct", + prompt=view_prompt(row, hop, view), + answer=base.answer(row, hop), + ) + for view in ((0, 1) if extras else (0,)) + for row in world + if view == 0 or row["split"] == "target" + for hop in range(3) + ] + + +def autonomous_rows(world, direct): + lookup = {r["id"]: r for r in world} + result = [] + for first in direct: + if first["split"] != "target" or first["hop"] != 0: + continue + bridge = first["text"].strip().split("\n")[0].strip().rstrip(".").strip() + row = lookup[first["id"]] + substituted = dict(row, bridge=bridge) + result.append( + dict( + **row, + hop=2, + view=first["view"], + mode="autonomous", + prompt=view_prompt(substituted, 1, first["view"]), + answer=row["city"], + generated_bridge=bridge, + first_tokens=first["tokens"], + first_text=first["text"], + first_correct=first["correct"], + ) + ) + return result + + +@torch.inference_mode() +def generate(model, tokenizer, rows, config): + model.eval() + tokenizer.padding_side = "left" + result = [] + for start in range(0, len(rows), config["eval_batch"]): + chunk = rows[start : start + config["eval_batch"]] + x = tokenizer( + [r["prompt"] for r in chunk], + padding=True, + return_tensors="pt", + add_special_tokens=False, + ).to(config["device"]) + with torch.autocast("cuda", dtype=torch.bfloat16): + tokens = model.generate( + **x, + do_sample=False, + max_new_tokens=config["max_new_tokens"], + pad_token_id=tokenizer.pad_token_id, + eos_token_id=tokenizer.eos_token_id, + use_cache=True, + )[:, x.input_ids.shape[1] :] + for row, tok in zip(chunk, tokens.cpu().tolist(), strict=True): + if tokenizer.eos_token_id in tok: + tok = tok[: tok.index(tokenizer.eos_token_id) + 1] + text = tokenizer.decode(tok, skip_special_tokens=True) + result.append(dict(row, tokens=tok, text=text, correct=base.grade(text, row["answer"]))) + return result + + +def evaluate(model, tokenizer, world, config, extras=False): + direct = generate(model, tokenizer, evaluation_rows(world, extras), config) + if not extras: + return direct + return direct + generate(model, tokenizer, autonomous_rows(world, direct), config) + + +def mean_correct(rows): + return sum(r["correct"] for r in rows) / len(rows) if rows else None + + +def metrics(rows, old_world, edit): + primary = [r for r in rows if r["view"] == 0 and r["mode"] == "direct"] + result = base.score(primary) + result["background_atomic"] = mean_correct( + [r for r in primary if r["split"] == "background" and r["hop"] < 2] + ) + edited = set(edit["edited_ids"]) + old = {r["id"]: r for r in old_world} + for view in (0, 1): + subset = [r for r in rows if r["view"] == view] + if not subset: + continue + for pool, keep in (("E", True), ("U", False)): + target = [r for r in subset if r["split"] == "target" and (r["id"] in edited) == keep] + for hop, name in ((0, "first"), (1, "second"), (2, "two")): + cell = [r for r in target if r["hop"] == hop and r["mode"] == "direct"] + result[f"v{view}_{pool}_{name}"] = mean_correct(cell) + if hop == 2 and cell: + result[f"v{view}_{pool}_old_two"] = sum( + base.grade(r["text"], old[r["id"]]["city"]) for r in cell + ) / len(cell) + result[f"v{view}_{pool}_autonomous"] = mean_correct( + [r for r in target if r["mode"] == "autonomous"] + ) + if view == 1: + for hop, name in ((0, "first"), (1, "second"), (2, "two")): + result[f"heldout_{name}"] = mean_correct( + [r for r in subset if r["mode"] == "direct" and r["hop"] == hop] + ) + return result + + +def document_budget(docs): + width = max(len(d["ids"]) for d in docs) + return dict( + input_tokens=sum(len(d["ids"]) for d in docs), + supervised_tokens=sum(sum(t != -100 for t in d["labels"]) for d in docs), + padded_tokens=len(docs) * width, + attention_cells=len(docs) * width**2, + ) + + +def prepare(config_path): + config = base.read(config_path) + art = Path(config["artifact_root"]) + if (art / "lock.json").exists(): + raise RuntimeError("Preserve existing lock.") + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + world = base.build_world(config) + batches = pairing_stream(config, world) + edit = edit_design(config, world) + records = base.corpus(tokenizer, world) + stats = {arm: Counter() for arm in config["arms"]} + for batch in batches: + signatures = [] + for arm in config["arms"]: + docs = training_documents(records, batch, arm, config["standalone_rehearsal_copies"]) + stats[arm].update(document_budget(docs)) + signatures.append( + ( + Counter(t for d in docs for t in d["ids"]), + Counter(t for d in docs for t in d["labels"] if t != -100), + ) + ) + assert all(s == signatures[0] for s in signatures) + changed = base.corpus(tokenizer, edit["world"]) + edit_stats = {branch: Counter() for branch in ("update", "replay")} + for specs in edit["stream"]: + for branch, rec in (("update", changed), ("replay", records)): + docs = [rec[tuple(s)] for s in specs] + edit_stats[branch].update(document_budget(docs)) + assert [len(changed[tuple(s)]["ids"]) for s in specs] == [ + len(records[tuple(s)]["ids"]) for s in specs + ] + assert edit_stats["update"] == edit_stats["replay"] + base.write(art / "world.json", world) + base.write(art / "stream.json", batches) + base.write(art / "edit-design.json", edit) + base.write( + art / "data-audit.json", + dict( + status="passed", + training=stats, + editing=edit_stats, + paired_batch_checks=len(batches), + equal_edit_length_checks=len(edit["stream"]), + target_composition_labels=0, + edit_target_composition_labels=0, + ), + ) + sources = [ + str(config_path), + str(Path(__file__).relative_to(Path.cwd())) if Path(__file__).is_absolute() else __file__, + "src/llm_memory_editability/small_lm_composition.py", + "scripts/run_small_lm_followup.py", + "tests/test_small_lm_followup.py", + str(art / "development-plan.md"), + ] + hashes = {} + for source in sources: + relative = Path(source).resolve().relative_to(Path.cwd()) + dest = art / "source" / relative + dest.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(relative, dest) + hashes[str(relative)] = base.sha(relative) + model_files = { + str(p): base.sha(p) + for p in Path(config["model_path"]).iterdir() + if p.suffix in (".safetensors", ".json") + } + base.write( + art / "lock.json", + dict( + status="locked_before_training", + utc=base.now(), + sources=hashes, + model_files=model_files, + data_files={ + str(art / f): base.sha(art / f) + for f in ("world.json", "stream.json", "edit-design.json", "data-audit.json") + }, + ), + ) + print(json.dumps(dict(status="prepared", training=stats, editing=edit_stats)), flush=True) + + +def check_lock(config): + art = Path(config["artifact_root"]) + lock = base.read(art / "lock.json") + for group in ("sources", "model_files", "data_files"): + for path, digest in lock[group].items(): + assert base.sha(path) == digest, path + + +def learning_rate(step, steps, lr, minimum, warmup): + decay = 0.5 * (1 + math.cos(math.pi * max(0, step - warmup) / (steps - warmup))) + return (minimum + (lr - minimum) * decay) * min(1.0, (step + 1) / warmup) + + +def run(config_path, arm, branch=None): + config = base.read(config_path) + check_lock(config) + assert arm in config["arms"] and branch in (None, "update", "replay") + art = Path(config["artifact_root"]) + root = Path(config["output_root"]) + out = root / ("training" if branch is None else "editing") / arm + if branch: + out = out / branch + if (out / "status.json").exists(): + raise RuntimeError(f"Preserve existing run: {out}") + old_world = base.read(art / "world.json") + edit = base.read(art / "edit-design.json") + # Both update and replay are scored against the SAME edited world. + world = edit["world"] if branch else old_world + source = Path(config["model_path"]) if branch is None else root / "training" / arm / "model" + if branch: + parent = base.read(root / "training" / arm / "summary.json") + for path, digest in parent["checkpoint_files"].items(): + assert base.sha(path) == digest + steps = config["edit_steps"] if branch else config["steps"] + nodes = config["edit_nodes"] if branch else config["nodes"] + seed = config["edit_training_seed"] if branch else config["training_seed"] + prefix = "edit_" if branch else "" + batches = edit["stream"] if branch else base.read(art / "stream.json") + base.write(out / "status.json", dict(status="running", utc=base.now(), arm=arm, branch=branch)) + started = time.perf_counter() + torch.set_num_threads(config["cpu_threads"]) + torch.manual_seed(seed) + torch.backends.cuda.matmul.allow_tf32 = False + torch.backends.cudnn.allow_tf32 = False + torch.cuda.set_device(config["device"]) + torch.cuda.reset_peak_memory_stats() + tokenizer = AutoTokenizer.from_pretrained(config["model_path"], local_files_only=True) + tokenizer.pad_token = tokenizer.eos_token + + def load_model(path): + return AutoModelForCausalLM.from_pretrained( + path, torch_dtype=torch.float32, attn_implementation="sdpa", local_files_only=True + ).to(config["device"]) + + model = load_model(source) + model.requires_grad_(True) + assert model.config.num_hidden_layers == 28 and model.config.hidden_size == 1024 + assert len({id(layer.mlp) for layer in model.model.layers}) == 28 + samples = base.parameter_samples(model) + parameter_count = sum(p.numel() for p in model.parameters()) + records = base.corpus(tokenizer, edit["world"] if branch == "update" else old_world) + optimizer = torch.optim.AdamW( + model.parameters(), + lr=config[prefix + "learning_rate"], + weight_decay=config["weight_decay"], + fused=True, + ) + curve, budget = [], Counter() + train_seconds = 0.0 + for step in range(steps + 1): + if step in nodes: + rows = evaluate(model, tokenizer, world, config, extras=step == steps) + base.write(out / f"predictions-{step:05d}.json", rows) + record = dict(step=step, **metrics(rows, old_world, edit)) + curve.append(record) + base.write(out / "curve.json", curve) + print(json.dumps(dict(arm=arm, branch=branch, **record)), flush=True) + if step == steps: + break + rate = learning_rate( + step, + steps, + config[prefix + "learning_rate"], + config[prefix + "minimum_learning_rate"], + config[prefix + "warmup_steps"], + ) + for group in optimizer.param_groups: + group["lr"] = rate + docs = ( + [records[tuple(s)] for s in batches[step]] + if branch + else training_documents( + records, batches[step], arm, config["standalone_rehearsal_copies"] + ) + ) + budget.update(document_budget(docs)) + inputs = base.batch_tensors(docs, tokenizer.pad_token_id, config["device"]) + model.train() + torch.cuda.synchronize() + tick = time.perf_counter() + optimizer.zero_grad(set_to_none=True) + with torch.autocast("cuda", dtype=torch.bfloat16): + loss = model(**inputs, use_cache=False).loss + assert torch.isfinite(loss) + loss.backward() + if step == 0: + assert all( + p.requires_grad and p.grad is not None and torch.isfinite(p.grad).all() + for p in model.parameters() + ) + torch.nn.utils.clip_grad_norm_(model.parameters(), config["gradient_clip"]) + optimizer.step() + torch.cuda.synchronize() + train_seconds += time.perf_counter() - tick + if (step + 1) % 64 == 0: + print( + json.dumps( + dict( + arm=arm, + branch=branch, + step=step + 1, + loss=float(loss.detach()), + train_seconds=train_seconds, + ) + ), + flush=True, + ) + changed = { + n: not torch.equal(before, base.parameter_samples(model)[n]) + for n, before in samples.items() + } + assert all(changed.values()) + architecture = model.config.to_dict() + model.save_pretrained(out / "model", safe_serialization=True) + tokenizer.save_pretrained(out / "model") + final_rows = rows + del optimizer, model, samples, inputs, loss + torch.cuda.empty_cache() + reloaded = load_model(out / "model") + again = evaluate(reloaded, tokenizer, world, config, extras=True) + assert [r["tokens"] for r in final_rows] == [r["tokens"] for r in again] + assert [r["prompt"] for r in final_rows] == [r["prompt"] for r in again] + base.write( + out / "reload-audit.json", + dict( + status="passed", + predictions=len(again), + exact_generated_tokens=True, + exact_autonomous_prompts=True, + ), + ) + expected = base.read(art / "data-audit.json") + assert budget == expected["editing" if branch else "training"][branch or arm] + # Dense matrix estimate: 3x forward for training; all vocab logits are evaluated. + d, layers, intermediate = 1024, 28, architecture["intermediate_size"] + kv = architecture["num_key_value_heads"] * architecture["head_dim"] + query_width = architecture["num_attention_heads"] * architecture["head_dim"] + attention_projections = 2 * d * query_width + 2 * d * kv + per_token = layers * (attention_projections + 3 * d * intermediate) + per_token += d * architecture["vocab_size"] + flops = ( + 6 * per_token * budget["padded_tokens"] + + 12 + * layers + * (architecture["num_attention_heads"] * architecture["head_dim"]) + * budget["attention_cells"] + ) + summary = dict( + status="complete", + phase="development_only", + arm=arm, + branch=branch, + utc=base.now(), + metrics=metrics(final_rows, old_world, edit), + updates=steps, + parameter_count=parameter_count, + trainable_parameters=parameter_count, + initial_all_gradients_finite=True, + sampled_parameters_changed=changed, + source_checkpoint=str(source), + fresh_optimizer=True, + budget=dict(budget), + estimated_training_matrix_flops=flops, + train_seconds=train_seconds, + process_seconds=time.perf_counter() - started, + peak_gpu_bytes=torch.cuda.max_memory_allocated(), + torch_version=torch.__version__, + transformers_version=transformers.__version__, + gpu=torch.cuda.get_device_name(), + tf32=False, + lock_sha256=base.sha(art / "lock.json"), + checkpoint_files={str(p): base.sha(p) for p in (out / "model").glob("*.safetensors")}, + ) + base.write(out / "summary.json", summary) + base.write(out / "status.json", dict(status="complete", utc=base.now())) + print(json.dumps(summary), flush=True) + + +def report(config_path): + config = base.read(config_path) + check_lock(config) + art, root = Path(config["artifact_root"]), Path(config["output_root"]) + world, edit = base.read(art / "world.json"), base.read(art / "edit-design.json") + runs = {} + checks = 0 + for arm in config["arms"]: + for branch in (None, "update", "replay"): + out = root / ("editing" if branch else "training") / arm + if branch: + out /= branch + key = f"{arm}/{branch or 'training'}" + summary = base.read(out / "summary.json") + assert summary["status"] == "complete" + assert base.read(out / "reload-audit.json")["status"] == "passed" + for node in base.read(out / "curve.json"): + rows = base.read(out / f"predictions-{node['step']:05d}.json") + assert all(base.grade(r["text"], r["answer"]) == r["correct"] for r in rows) + assert dict(step=node["step"], **metrics(rows, world, edit)) == node + checks += len(rows) + assert metrics(rows, world, edit) == summary["metrics"] + runs[key] = summary + result = dict( + status="complete", + phase="single_world_development", + utc=base.now(), + runs=runs, + node_prediction_checks=checks, + total_train_seconds=sum(r["train_seconds"] for r in runs.values()), + total_process_seconds=sum(r["process_seconds"] for r in runs.values()), + total_updates=sum(r["updates"] for r in runs.values()), + total_input_tokens=sum(r["budget"]["input_tokens"] for r in runs.values()), + total_supervised_tokens=sum(r["budget"]["supervised_tokens"] for r in runs.values()), + estimated_training_matrix_flops=sum( + r["estimated_training_matrix_flops"] for r in runs.values() + ), + lock_sha256=base.sha(art / "lock.json"), + ) + base.write(art / "summary.json", result) + print(json.dumps({k: v for k, v in result.items() if k != "runs"}), flush=True) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_composition.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_composition.py new file mode 100644 index 0000000000000000000000000000000000000000..094211c26edecbed2a534bad16c84c42b2cdebd0 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_composition.py @@ -0,0 +1,424 @@ +"""Fact-load experiments in unmodified GPT-2 blocks and depth-shared GPT-2 blocks. + +Template-language data are controlled; the architecture is an ordinary causal LM. +No embeddings/projections are frozen, no intermediate answers are supplied, and +all non-padding next tokens contribute to the training loss. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig +from .grok_depth import EpochStream, GraphStep, SmallGPT, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .text_pretrain import WORDS, atomic_sentence, composite_sentence + +SOURCE_FILES = [ + "src/llm_memory_editability/storage_composition.py", + "src/llm_memory_editability/bios_model.py", + "src/llm_memory_editability/grok_depth.py", + "src/llm_memory_editability/grok_loop_model.py", + "src/llm_memory_editability/text_pretrain.py", + "scripts/run_storage_composition.py", + "tests/test_storage_composition.py", +] +ARCHITECTURES = { + "standard1": (1, 1), + "standard2": (2, 1), + "standard3": (3, 1), + "loop1x2": (1, 2), + "loop1x3": (1, 3), +} + + +def file_hash(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def build_world(spec): + """Keep the target subgraph, vocabulary and candidates fixed across loads. + + Matched low load repeats anchor atomics outside every evaluated chain. + High load teaches distinct distractor atomics. The original development + setting repeated familiar atomics; its results are retained separately. + """ + rng = np.random.default_rng(spec["world"]) + hn, bn, tn = (spec[k] for k in ("heads_n", "bridges_n", "tails_n")) + familiar, strict = spec["familiar_n"], spec["strict_n"] + core = familiar + strict + if not (0 < familiar < core <= min(hn, bn)): + raise ValueError("Invalid disjoint familiar/strict subgraph sizes") + heads = np.arange(len(WORDS), len(WORDS) + hn) + bridges = np.arange(heads[-1] + 1, heads[-1] + 1 + bn) + tails = np.arange(bridges[-1] + 1, bridges[-1] + 1 + tn) + first = [] + for index, head in enumerate(heads): + candidates = ( + bridges[:familiar] + if index < familiar + else bridges[familiar:core] + if index < core + else bridges + ) + first.extend((head, r, rng.choice(candidates)) for r in range(13, 17)) + first = np.asarray(first, dtype=np.int64) + second = np.asarray( + [(b, r, rng.choice(tails)) for b in bridges for r in range(17, 21)], dtype=np.int64 + ) + lookup = {(int(h), int(r)): int(t) for h, r, t in second} + paths = np.asarray( + [ + (h, r1, b, r2, lookup[int(b), r2]) + for h, r1, b in first[: core * 4] + for r2 in range(17, 21) + ], + dtype=np.int64, + ) + familiar_paths = paths[paths[:, 0] < heads[familiar]] + # Hold out entire (head, terminal) pairs, including alternate relation paths. + reserved = rng.random((familiar, tn)) < spec["holdout_fraction"] + held = reserved[familiar_paths[:, 0] - heads[0], familiar_paths[:, 4] - tails[0]] + world = { + "common_atomic": np.concatenate([first[: core * 4], second[: core * 4]]), + "background_atomic": np.concatenate([first[: familiar * 4], second[: familiar * 4]]), + "extra_atomic": np.concatenate([first[core * 4 :], second[core * 4 :]]), + "train_composite": familiar_paths[~held], + "familiar_test": familiar_paths[held], + "strict_test": paths[paths[:, 0] >= heads[familiar]], + } + if spec.get("low_extra") == "anchors": + anchors = spec["anchor_n"] + if not 0 < anchors <= min(hn, bn) - core: + raise ValueError("Anchor entities must be outside the common subgraph") + world["anchor_atomic"] = np.concatenate( + [first[core * 4 : (core + anchors) * 4], second[core * 4 : (core + anchors) * 4]] + ) + if any(not len(rows) for rows in world.values()): + raise ValueError("Empty stratum: do not silently reroll a world") + atoms = np.concatenate([world["common_atomic"], world["extra_atomic"]]) + audit_world(world) + assert len(atoms) == 4 * (hn + bn) + return world + + +def audit_world(world): + atoms = np.concatenate([world["common_atomic"], world["extra_atomic"]]) + lookup = {(int(h), int(r)): int(t) for h, r, t in atoms} + assert len(lookup) == len(atoms) + for name in ("train_composite", "familiar_test", "strict_test"): + for h, r1, b, r2, t in world[name]: + assert lookup[int(h), int(r1)] == b + assert lookup[int(b), int(r2)] == t + train_pairs = {tuple(r[[0, 4]]) for r in world["train_composite"]} + assert not train_pairs & {tuple(r[[0, 4]]) for r in world["familiar_test"]} + train_facts = {(int(h), int(r1), int(b)) for h, r1, b, _r2, _t in world["train_composite"]} | { + (int(b), int(r2), int(t)) for _h, _r1, b, r2, t in world["train_composite"] + } + strict_facts = {(int(h), int(r1), int(b)) for h, r1, b, _r2, _t in world["strict_test"]} | { + (int(b), int(r2), int(t)) for _h, _r1, b, r2, t in world["strict_test"] + } + assert not strict_facts & train_facts + assert not strict_facts & set(map(tuple, world["extra_atomic"])) + if "anchor_atomic" in world: + assert not set(map(tuple, world["anchor_atomic"])) & set(map(tuple, world["common_atomic"])) + assert set(map(tuple, world["anchor_atomic"])) <= set(map(tuple, world["extra_atomic"])) + + +def pack_sentences(rows): + render = atomic_sentence if rows.shape[1] == 3 else composite_sentence + x = np.zeros((len(rows), 9), dtype=np.int64) + labels = np.full_like(x, -100) + for index, row in enumerate(rows): + sentence = render(row) + x[index, : len(sentence) - 1] = sentence[:-1] + labels[index, : len(sentence) - 1] = sentence[1:] + return x, labels + + +class FullTokenStep(GraphStep): + def eager(self): + self.optimizer.zero_grad(set_to_none=True) + tokens, labels = (part[self.index] for part in self.table) + logits = self.model(tokens) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def construct(spec, device): + layers, repeats = ARCHITECTURES[spec["architecture"]] + config = ModelConfig( + vocab_size=len(WORDS) + spec["heads_n"] + spec["bridges_n"] + spec["tails_n"], + width=spec["width"], + layers=layers, + heads=spec["heads"], + context=16, + ) + torch.manual_seed(spec["initialization"]) + if repeats == 1: + model = SmallGPT(config, dropout=spec["dropout"]) + else: + # Same unique-block initialization as standard1, without zeroing residuals. + model = LoopGPT(config, repeats, spec["dropout"], initialization="legacy_unique") + return model.to(device) + + +@torch.no_grad() +def generate_rows(model, rows, device, repeats=None, batch_size=512): + """Greedy answer, then '.', then EOS; feed back every generated token.""" + model.eval() + if rows.shape[1] == 3: + prompts = np.asarray([atomic_sentence(r)[:5] for r in rows]) + else: + prompts = np.asarray([composite_sentence(r)[:7] for r in rows]) + predictions, nlls = [], [] + kwargs = {"repeats": repeats} if isinstance(model, LoopGPT) else {} + for start in range(0, len(rows), batch_size): + tokens = torch.as_tensor(prompts[start : start + batch_size], device=device) + target = torch.as_tensor(rows[start : start + batch_size, -1], device=device) + generated = [] + for i in range(3): + logits = model(tokens, **kwargs)[:, -1] + if i == 0: + nlls.append(F.cross_entropy(logits, target, reduction="none").cpu().numpy()) + next_token = logits.argmax(-1) + generated.append(next_token.cpu().numpy()) + tokens = torch.cat([tokens, next_token[:, None]], dim=1) + predictions.append(np.stack(generated, axis=1)) + pred, nll = np.concatenate(predictions), np.concatenate(nlls) + answer_ok = pred[:, 0] == rows[:, -1] + full_ok = answer_ok & (pred[:, 1] == 5) & (pred[:, 2] == 1) + metrics = { + "n": len(rows), + "answer_accuracy": float(answer_ok.mean()), + "accuracy": float(full_ok.mean()), + "answer_nll": float(nll.mean()), + } + return metrics, {"generated": pred, "correct": full_ok, "answer_nll": nll} + + +def evaluate(model, world, load, device, repeats=None): + metrics, predictions = {}, {} + names = ["common_atomic", "train_composite", "familiar_test", "strict_test"] + if "anchor_atomic" in world: + names.append("anchor_atomic") + if load == "high": + names.append("extra_atomic") + for name in names: + metrics[name], pred = generate_rows(model, world[name], device, repeats) + predictions.update({name + "_" + k: v for k, v in pred.items()}) + for name in ("familiar_test", "strict_test"): + rows = world[name] + first = rows[:, [0, 1, 2]] + second = rows[:, [2, 3, 4]] + _m, p1 = generate_rows(model, first, device, repeats) + _m, p2 = generate_rows(model, second, device, repeats) + covered = p1["correct"] & p2["correct"] + generated_second = second.copy() + generated_second[:, 0] = p1["generated"][:, 0] + _m, autonomous = generate_rows(model, generated_second, device, repeats) + calls_ok = ( + (p1["generated"][:, 1] == 5) & (p1["generated"][:, 2] == 1) & autonomous["correct"] + ) + direct = predictions[name + "_correct"] + metrics[name].update( + { + "atomic_correct_coverage": float(covered.mean()), + "conditional_accuracy": float(direct[covered].mean()) if covered.any() else None, + "autonomous_two_calls": float(calls_ok.mean()), + } + ) + predictions.update({name + "_coverage": covered, name + "_two_calls": calls_ok}) + model.train() + return metrics, predictions + + +def data_digest(world): + digest = hashlib.sha256() + for key, value in sorted(world.items()): + digest.update(key.encode()) + digest.update(str(value.shape).encode()) + digest.update(value.tobytes()) + return digest.hexdigest() + + +def run(spec, out, device="cuda:2"): + out = Path(out) + if (out / "complete.json").exists(): + raise FileExistsError(f"Completed run exists: {out}") + out.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + device = torch.device(device) + torch.cuda.set_device(device) + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + source = {path: file_hash(path) for path in SOURCE_FILES} + write_json( + out / "spec.json", {"spec": spec, "source": source, "data_sha256": data_digest(world)} + ) + model = construct(spec, device) + lr = torch.tensor(spec["lr"], device=device) + opt = make_optimizer(model, lr, spec["weight_decay"]) + low_extra = world["anchor_atomic"] if "anchor_atomic" in world else world["background_atomic"] + extra = world["extra_atomic"] if spec["load"] == "high" else low_extra + strata = [world["common_atomic"], world["train_composite"], extra] + packed = [pack_sentences(rows) for rows in strata] + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) for parts in zip(*packed, strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + if batch % 3: + raise ValueError("Batch must divide into three equal exposure strata") + graph = FullTokenStep(model, opt, table, batch) + history, training_seconds = [], 0.0 + layers, repeats = ARCHITECTURES[spec["architecture"]] + parameters = sum(p.numel() for p in model.parameters()) + flop_step = flops(model.config, repeats, batch, 9, output_positions=9) + start = 0 + + def measure(step, loss=None): + metrics, predictions = evaluate(model, world, spec["load"], device) + row = { + "step": step, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": opt.state_dict(), + "streams": [s.state_dict() for s in streams], + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "counts": counts, + "source": source, + "data_sha256": data_digest(world), + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + write_json( + out / "status.json", + { + "step": step, + "budget": spec["steps"], + "atomic": metrics["common_atomic"]["accuracy"], + "familiar": metrics["familiar_test"]["accuracy"], + "strict": metrics["strict_test"]["accuracy"], + }, + ) + print(json.dumps({"run": str(out), "step": step, "metrics": metrics}), flush=True) + return row + + measure(0) + for end in spec["nodes"]: + if end == 0: + continue + torch.cuda.synchronize() + t0 = time.perf_counter() + while start < end: + n = min(128, end - start) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(spec["lr"] * min(1.0, (start + j + 1) / spec["warmup"])) + last_loss = graph(indices[j]) + start += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - t0 + loss = float(last_loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite loss at {end}") + endpoint = measure(end, loss) + assert start == spec["steps"] + # Prespecified test-time repeat sweep; these weights never change. + repeat_metrics = {} + if isinstance(model, LoopGPT): + for count in spec["test_repeats"]: + metrics, predictions = evaluate(model, world, spec["load"], device, count) + repeat_metrics[str(count)] = metrics + np.savez_compressed(out / f"repeat-{count:02d}.npz", **predictions) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + write_json( + out / "complete.json", + { + "spec": spec, + "finished_utc": utc(), + "parameters": parameters, + "unique_blocks": layers, + "executed_blocks": layers * repeats, + "independent_facts": len(world["common_atomic"]) + + (len(extra) if spec["load"] == "high" or "anchor_atomic" in world else 0), + "training_seconds": training_seconds, + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "examples": start * batch, + "effective_input_tokens": start * batch * 23 // 3, + "supervised_tokens": start * batch * 23 // 3, + "padded_input_tokens": start * batch * 9, + "source": source, + "data_sha256": data_digest(world), + "environment": {"torch": torch.__version__, "gpu": torch.cuda.get_device_name(device)}, + }, + ) + return endpoint + + +def audit_run(out, device="cuda:2"): + """Independently reload the final checkpoint and regenerate all endpoint tokens.""" + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + out = Path(out) + complete = json.loads((out / "complete.json").read_text()) + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + assert saved["step"] == complete["spec"]["steps"] + world = build_world(saved["spec"]) + assert data_digest(world) == saved["data_sha256"] == complete["data_sha256"] + model = construct(saved["spec"], device) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, saved["spec"]["load"], device) + expected = np.load(out / f"predictions-{saved['step']:06d}.npz") + for key, value in predictions.items(): + # Tiny batching/platform differences can affect NLL, never generated tokens. + np.testing.assert_allclose(value, expected[key], rtol=1e-5, atol=1e-5) + assert metrics == complete["endpoint"]["metrics"] + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == saved["step"] * saved["spec"]["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + result = { + "passed": True, + "step": saved["step"], + "prediction_arrays": len(predictions), + "utc": utc(), + } + write_json(out / "audit.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_frontier.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_frontier.py new file mode 100644 index 0000000000000000000000000000000000000000..db36e560aed8b173bb72c836b3d02dc8381bbcc5 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/storage_frontier.py @@ -0,0 +1,262 @@ +"""Stable training and nested fact loads in ordinary GPT/Loop architectures. + +The historical storage_composition implementation is reused without changing its +frozen sources, truth, tokenizer, architecture or full-generation score. +""" + +from __future__ import annotations + +import json +import math +import time +from pathlib import Path + +import numpy as np +import torch + +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import LoopGPT, flops +from .storage_composition import ( + ARCHITECTURES, + FullTokenStep, + construct, + data_digest, + evaluate, + file_hash, + pack_sentences, +) +from .storage_composition import ( + SOURCE_FILES as HISTORICAL_SOURCE_FILES, +) +from .storage_composition import ( + build_world as historical_world, +) + +SOURCE_FILES = [ + *HISTORICAL_SOURCE_FILES, + "src/llm_memory_editability/storage_frontier.py", + "scripts/run_storage_frontier.py", + "tests/test_storage_frontier.py", +] + + +def learning_rate(spec, step): + """One-based update; paired schedules share the exact same warmup.""" + if not 1 <= step <= spec["steps"]: + raise ValueError("Step must be within the training budget") + warmup = spec["warmup"] + if warmup and step <= warmup: + return spec["lr"] * step / warmup + if spec["schedule"] == "constant": + return spec["lr"] + if spec["schedule"] != "cosine": + raise ValueError("Unknown learning-rate schedule") + fraction = (step - warmup) / (spec["steps"] - warmup) + floor = spec["min_lr_ratio"] + return spec["lr"] * (floor + (1 - floor) * (1 + math.cos(math.pi * fraction)) / 2) + + +def build_world(spec): + world = historical_world(spec) + if "extra_count" in spec: + # A world-specific, fixed permutation defines nested distractor fact sets. + # Common facts and every combination example remain bit-identical. + count = spec["extra_count"] + if not 0 < count <= len(world["extra_atomic"]): + raise ValueError("Extra fact count exceeds the fixed master graph") + rng = np.random.default_rng(spec["world"] + 900000) + order = rng.permutation(len(world["extra_atomic"])) + world["extra_atomic"] = world["extra_atomic"][order[:count]] + return world + + +def strata_for(spec, world): + extra = world["extra_atomic"] if spec["load"] == "high" else world["anchor_atomic"] + return [world["common_atomic"], world["train_composite"], extra] + + +def run_name(spec): + load = spec["load"] + if "extra_count" in spec: + load = f"f{spec['extra_count'] + 8 * (spec['familiar_n'] + spec['strict_n'])}" + return ( + f"w{spec['world']}-i{spec['initialization']}-{spec['architecture']}" + f"-d{spec['width']}-{load}-{spec['schedule']}-s{spec['steps']}" + ) + + +def train(spec, out, source, device="cuda:0"): + out = Path(out) + out.mkdir(parents=True, exist_ok=True) + if (out / "latest.pt").exists() or (out / "complete.json").exists(): + raise FileExistsError(f"Do not overwrite an existing training attempt: {out}") + torch.set_num_threads(1) + torch.set_num_interop_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + device = torch.device(device) + torch.cuda.set_device(device) + world = build_world(spec) + np.savez_compressed(out / "world.npz", **world) + digest = data_digest(world) + write_json(out / "spec.json", {"spec": spec, "source": source, "data_sha256": digest}) + model = construct(spec, device) + initial_sha = file_hash(out / "spec.json") + lr = torch.tensor(spec["lr"], device=device) + optimizer = make_optimizer(model, lr, spec["weight_decay"]) + strata = strata_for(spec, world) + table = tuple( + torch.as_tensor(np.concatenate(parts), device=device) + for parts in zip(*(pack_sentences(rows) for rows in strata), strict=True) + ) + sizes = [len(rows) for rows in strata] + offsets = np.cumsum([0, *sizes[:-1]]) + streams = [EpochStream(size, spec["stream_seed"] + i) for i, size in enumerate(sizes)] + counts = [np.zeros(size, dtype=np.int64) for size in sizes] + batch = spec["batch_size"] + if batch % 3: + raise ValueError("Batch must divide into three equal streams") + graph = FullTokenStep(model, optimizer, table, batch) + layers, repeats = ARCHITECTURES[spec["architecture"]] + flop_step = flops(model.config, repeats, batch, 9, output_positions=9) + history, training_seconds, start = [], 0.0, 0 + + def measure(step, loss=None): + metrics, predictions = evaluate(model, world, spec["load"], device) + row = { + "step": step, + "lr": learning_rate(spec, step) if step else 0, + "metrics": metrics, + "loss": loss, + "training_seconds": training_seconds, + "estimated_training_flops": step * flop_step, + } + history.append(row) + write_json(out / "learning.json", history) + np.savez_compressed(out / f"predictions-{step:06d}.npz", **predictions) + state = { + "spec": spec, + "step": step, + "model": model.state_dict(), + "optimizer": optimizer.state_dict(), + "streams": [stream.state_dict() for stream in streams], + "counts": counts, + "cpu_rng": torch.get_rng_state(), + "cuda_rng": torch.cuda.get_rng_state(device), + "source": source, + "data_sha256": digest, + } + torch.save(state, out / "latest.tmp.pt") + (out / "latest.tmp.pt").replace(out / "latest.pt") + write_json(out / "status.json", {"step": step, "budget": spec["steps"]}) + print(json.dumps({"run": run_name(spec), "step": step, "metrics": metrics}), flush=True) + return row + + measure(0) + for end in spec["nodes"]: + if not end: + continue + torch.cuda.synchronize() + started = time.perf_counter() + while start < end: + n = min(128, end - start) + indices = [] + for i, stream in enumerate(streams): + drawn = stream.take(n * batch // 3).reshape(n, batch // 3) + counts[i] += np.bincount(drawn.ravel(), minlength=sizes[i]) + indices.append(drawn + offsets[i]) + indices = torch.as_tensor(np.concatenate(indices, axis=1), device=device) + for j in range(n): + lr.fill_(learning_rate(spec, start + j + 1)) + last_loss = graph(indices[j]) + start += n + torch.cuda.synchronize() + training_seconds += time.perf_counter() - started + loss = float(last_loss) + if not np.isfinite(loss): + raise FloatingPointError(f"Nonfinite training loss at {end}") + endpoint = measure(end, loss) + assert start == spec["steps"] + repeat_metrics = {} + if isinstance(model, LoopGPT): + for repeat in spec["test_repeats"]: + metrics, predictions = evaluate(model, world, spec["load"], device, repeat) + repeat_metrics[str(repeat)] = metrics + np.savez_compressed(out / f"repeat-{repeat:02d}.npz", **predictions) + np.savez_compressed(out / "exposures.npz", **{f"stratum{i}": c for i, c in enumerate(counts)}) + result = { + "spec": spec, + "finished_utc": utc(), + "parameters": sum(p.numel() for p in model.parameters()), + "unique_blocks": layers, + "executed_blocks": layers * repeats, + "independent_facts": len(strata[0]) + len(strata[2]), + "training_seconds": training_seconds, + "endpoint": endpoint, + "repeat_metrics": repeat_metrics, + "source": source, + "data_sha256": digest, + "spec_sha256": initial_sha, + "checkpoint_sha256": file_hash(out / "latest.pt"), + "supervised_tokens": start * batch * 23 // 3, + "padded_input_tokens": start * batch * 9, + "environment": { + "torch": torch.__version__, + "numpy": np.__version__, + "cuda": torch.version.cuda, + "gpu": torch.cuda.get_device_name(device), + "tf32": True, + }, + } + write_json(out / "complete.json", result) + return result + + +def audit(out, device="cuda:0"): + """Independent-process reload: tokens exact, floating NLL tolerance recorded.""" + out = Path(out) + torch.set_num_threads(1) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_device(torch.device(device)) + complete = json.loads((out / "complete.json").read_text()) + saved = torch.load(out / "latest.pt", map_location=device, weights_only=False) + assert saved["step"] == complete["spec"]["steps"] + assert file_hash(out / "latest.pt") == complete["checkpoint_sha256"] + world = build_world(saved["spec"]) + assert data_digest(world) == saved["data_sha256"] == complete["data_sha256"] + model = construct(saved["spec"], device) + model.load_state_dict(saved["model"]) + metrics, predictions = evaluate(model, world, saved["spec"]["load"], device) + expected = np.load(out / f"predictions-{saved['step']:06d}.npz") + max_nll_difference = 0.0 + for key, value in predictions.items(): + if key.endswith("answer_nll"): + max_nll_difference = max(max_nll_difference, float(np.abs(value - expected[key]).max())) + np.testing.assert_allclose(value, expected[key], rtol=1e-5, atol=1e-5) + else: + np.testing.assert_array_equal(value, expected[key]) + for task, values in metrics.items(): + for key, value in values.items(): + reference = complete["endpoint"]["metrics"][task][key] + if key == "answer_nll": + np.testing.assert_allclose(value, reference, rtol=1e-5, atol=1e-5) + else: + assert value == reference + exposures = np.load(out / "exposures.npz") + for i in range(3): + np.testing.assert_array_equal(exposures[f"stratum{i}"], saved["counts"][i]) + assert exposures[f"stratum{i}"].sum() == saved["step"] * saved["spec"]["batch_size"] // 3 + assert np.ptp(exposures[f"stratum{i}"]) <= 1 + result = { + "passed": True, + "step": saved["step"], + "prediction_arrays": len(predictions), + "max_nll_difference": max_nll_difference, + "nll_rtol": 1e-5, + "nll_atol": 1e-5, + "tokens_exact": True, + "utc": utc(), + } + write_json(out / "audit.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_loss_source.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_loss_source.py new file mode 100644 index 0000000000000000000000000000000000000000..6f9377848d4673a2937273cf26a33f8e859874d0 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_loss_source.py @@ -0,0 +1,256 @@ +"""Factorial loss-source interventions on an unchanged text-pretraining stream.""" + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .grok_depth import EpochStream, GraphStep, make_optimizer, write_json +from .grok_loop_model import flops +from .text_pretrain import construct, evaluate, sha + +ARMS = {"AB": (1, 1), "A": (1, 0), "B": (0, 1), "N": (0, 0)} +SPLITS = ("atomic", "background_train", "background_test", "target_train", "target_test") + + +def loss_sources(labels, bounds): + """0=atomic text, 1=background composition, 2=neutral text, -1=ignored.""" + result = np.full(labels.shape, -1, dtype=np.int64) + result[: bounds[1]] = 0 + result[bounds[1] : bounds[2]] = 1 + result[bounds[2] :, :15] = 0 + result[bounds[2] :, 16:] = 2 + result[labels == -100] = -1 + assert np.array_equal(result >= 0, labels != -100) + return result + + +def weights_for(source, arm): + a, b = ARMS[arm] + return ((source == 0) * a + (source == 1) * b + (source == 2)).astype(np.float32) + + +def weighted_loss(logits, labels, weights): + per_token = F.cross_entropy( + logits.flatten(0, 1), labels.flatten(), reduction="none", ignore_index=-100 + ).view_as(labels) + # Removing a source does NOT renormalize the remaining losses. + return (per_token * weights).sum() / (labels != -100).sum() + + +class SourceGraphStep(GraphStep): + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, positions, mask, labels, weights = (t[self.index] for t in self.table) + logits = self.model(x, position_ids=positions, attention_mask=mask) + loss = weighted_loss(logits, labels, weights) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +@torch.inference_mode() +def measure(model, world, table, source, device): + scores, predictions = {}, {} + for split in SPLITS: + scores[split], pred = evaluate(model, world[split], device, composite=split != "atomic") + predictions.update({split + "_" + k: v for k, v in pred.items()}) + atomic = predictions["atomic_answer"] == world["atomic"][:, -1] + known = {(h, r): ok for (h, r, _), ok in zip(world["atomic"], atomic, strict=True)} + eligible = np.array([known[h, r1] and known[b, r2] for h, r1, b, r2, t in world["target_test"]]) + full = (predictions["target_test_answer"] == world["target_test"][:, -1]) & ( + predictions["target_test_stops"] == [5, 1] + ).all(-1) + scores["both_atomics"] = dict( + n=int(eligible.sum()), + coverage=float(eligible.mean()), + accuracy=float(full[eligible].mean()) if eligible.any() else None, + ) + sums, counts = np.zeros(3), np.zeros(3, dtype=np.int64) + for start in range(0, len(table[0]), 128): + x, pos, mask, labels = [ + torch.as_tensor(t[start : start + 128], device=device) for t in table[:4] + ] + logits = model(x, position_ids=pos, attention_mask=mask) + nll = ( + F.cross_entropy( + logits.flatten(0, 1), labels.flatten(), reduction="none", ignore_index=-100 + ) + .view_as(labels) + .cpu() + .numpy() + ) + for group in range(3): + selected = source[start : start + 128] == group + sums[group] += nll[selected].sum(dtype=np.float64) + counts[group] += selected.sum() + scores["training_text_nll"] = { + name: float(sums[i] / counts[i]) + for i, name in enumerate(("atomic", "background", "neutral")) + } + return scores, predictions + + +def run(cfg, name, device): + overrides = cfg["runs"][name] + root = Path(cfg["output_root"]) / name + if (root / "complete.json").exists(): + return + lock = json.loads(Path(cfg["lock"]).read_text()) + for p, digest in lock["sources"].items(): + assert sha(p) == digest, p + assert sha(cfg["config_path"]) == lock["config_sha256"] + assert sha(cfg["plan"]) == lock["plan_sha256"] + for p, expected in lock["inputs"].items(): + assert sha(p) == expected, p + parent = Path(overrides["parent"]) + assert sha(parent / "latest.pt") == lock["parents"][str(parent / "latest.pt")] + root.mkdir(parents=True, exist_ok=True) + state = torch.load(parent / "latest.pt", map_location=device, weights_only=False) + spec = state["spec"] + assert spec["arm"] == "P1" and state["step"] == 32000 + world = dict(np.load(parent / "world.npz")) + stored = np.load(parent / "training-table.npz") + table = tuple(stored[k] for k in ("tokens", "positions", "mask", "labels")) + bounds = np.cumsum( + [0, len(world["atomic"]), len(world["background_train"]), len(world["target_train"])] + ) + source = loss_sources(table[3], bounds) + weights = weights_for(source, overrides["arm"]) + gpu_table = tuple(torch.as_tensor(t, device=device) for t in (*table, weights)) + model = construct(spec, device) + model.load_state_dict(state["model"]) + opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"]) + opt.load_state_dict(state["optimizer"]) + streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(3)] + for stream, saved in zip(streams, state["streams"], strict=True): + stream.load_state_dict(saved) + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + settings = dict( + parent=str(parent), + world=spec["world"], + initialization=spec["initialization"], + arm=overrides["arm"], + steps=cfg["steps"], + parent_sha256=sha(parent / "latest.pt"), + config=cfg["config_path"], + ) + write_json(root / "settings.json", settings) + start, elapsed, histories = 0, 0.0, [] + digest = hashlib.sha256() + # Recovery is deliberately from this branch's saved stream, never its parent's. + if (root / "latest.pt").exists(): + saved = torch.load(root / "latest.pt", map_location=device, weights_only=False) + assert saved["settings"] == settings + model.load_state_dict(saved["model"]) + opt.load_state_dict(saved["optimizer"]) + for stream, value in zip(streams, saved["streams"], strict=True): + stream.load_state_dict(value) + torch.set_rng_state(saved["cpu_rng"].cpu()) + torch.cuda.set_rng_state(saved["cuda_rng"].cpu(), device) + start, elapsed, histories = saved["step"], saved["seconds"], saved["histories"] + # Rebuild the hash of previously consumed paired indices from the parent state. + replay = [EpochStream(bounds[i + 1] - bounds[i], 0) for i in range(3)] + for stream, value in zip(replay, state["streams"], strict=True): + stream.load_state_dict(value) + for _ in range(start): + idx = np.concatenate( + [ + stream.take(n) + lo + for stream, n, lo in zip(replay, spec["batch_parts"], bounds[:-1], strict=True) + ] + ) + digest.update(idx.tobytes()) + initial_vector = torch.nn.utils.parameters_to_vector( + [v for v in state["model"].values()] + ).clone() + + def checkpoint(step): + metrics, predictions = measure(model, world, table, source, device) + record = dict( + step=step, + seconds=elapsed, + metrics=metrics, + parameter_l2_from_source=float( + torch.linalg.vector_norm( + torch.nn.utils.parameters_to_vector(model.parameters()).detach() + - initial_vector + ) + ), + last_loss=None if step == 0 else float(graph.loss), + last_gradient_norm=None if step == 0 else float(graph.grad_norm), + ) + histories.append(record) + np.savez_compressed(root / f"predictions-{step:06d}.npz", **predictions) + write_json(root / "learning.json", histories) + model.train() + current = dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + streams=[s.state_dict() for s in streams], + cpu_rng=torch.get_rng_state(), + cuda_rng=torch.cuda.get_rng_state(device), + step=step, + seconds=elapsed, + histories=histories, + settings=settings, + ) + tmp = root / "latest.tmp" + torch.save(current, tmp) + tmp.replace(root / "latest.pt") + if step == 0 or step == cfg["steps"]: + torch.save( + dict(model=current["model"], step=step, settings=settings), + root / f"weights-{step:06d}.pt", + ) + print( + json.dumps( + dict( + run=name, + step=step, + target=metrics["target_test"]["accuracy"], + atomic=metrics["atomic"]["accuracy"], + background=metrics["background_test"]["accuracy"], + ) + ), + flush=True, + ) + + if start == 0: + checkpoint(0) + graph = SourceGraphStep(model, opt, gpu_table, sum(spec["batch_parts"])) + tick = time.monotonic() + for step in range(start + 1, cfg["steps"] + 1): + idx = np.concatenate( + [ + stream.take(n) + lo + for stream, n, lo in zip(streams, spec["batch_parts"], bounds[:-1], strict=True) + ] + ) + digest.update(idx.tobytes()) + graph(torch.as_tensor(idx, device=device)) + if step in cfg["nodes"]: + torch.cuda.synchronize() + elapsed += time.monotonic() - tick + checkpoint(step) + tick = time.monotonic() + a, b = ARMS[overrides["arm"]] + write_json( + root / "complete.json", + dict( + settings=settings, + final=histories[-1], + sample_trace_sha256=digest.hexdigest(), + visible_supervised_tokens=cfg["steps"] * 1984, + active_supervised_tokens=cfg["steps"] * (1120 * a + 288 * b + 576), + estimated_flops=cfg["steps"] + * flops(model.config, spec["repeats"], 128, 25, output_positions=25), + checkpoint_sha256=sha(root / "latest.pt"), + ), + ) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_pretrain.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_pretrain.py new file mode 100644 index 0000000000000000000000000000000000000000..2682a0925a00e0e8b0eef3781521830d891ef9d7 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_pretrain.py @@ -0,0 +1,401 @@ +"""Paired full-token text pretraining with controlled cross-document access. + +P0/P1 have identical token arrays and labels; only document attention changes. +P2 replaces an isolated neutral record by a derived fact, an explicit change in +supervision. This is controlled template-language pretraining, not a pretrained +natural-language model or a replication of the original bioS scale. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from .bios_model import ModelConfig +from .grok_depth import EpochStream, GraphStep, make_optimizer, write_json +from .grok_loop_model import LoopGPT, flops + +WORDS = [ + "", + "", + "", + "'s", + "is", + ".", + "This", + "record", + "has", + "no", + "additional", + "fact", + "here", + "mentor", + "advisor", + "coach", + "supervisor", + "city", + "district", + "region", + "campus", +] +LENGTH = 26 +PAD, EOS, BOS = 0, 1, 2 + + +def sha(path): + return hashlib.sha256(Path(path).read_bytes()).hexdigest() + + +def vocabulary(spec): + return ( + WORDS + + [f"Person{i:03d}" for i in range(spec["heads_n"])] + + [f"Expert{i:03d}" for i in range(spec["bridges_n"])] + + [f"Place{i:03d}" for i in range(spec["tails_n"])] + ) + + +def atomic_sentence(row): + h, r, t = map(int, row) + return [BOS, h, 3, r, 4, t, 5, EOS] + + +def composite_sentence(row): + h, r1, _b, r2, t = map(int, row) + return [BOS, h, 3, r1, 3, r2, 4, t, 5, EOS] + + +def pack_documents(documents, groups): + """Reset positions per record in every arm; BOS is an exogenous boundary. + + All remaining next-token targets, including names, relations and EOS, are + supervised. The next record's BOS and padding are never prediction targets. + """ + seq, positions, segments = [], [], [] + for doc, group in zip(documents, groups, strict=True): + seq.extend(doc) + positions.extend(range(len(doc))) + segments.extend([group] * len(doc)) + if len(seq) > LENGTH: + raise ValueError("Record exceeds fixed context") + n = len(seq) + seq += [PAD] * (LENGTH - n) + positions += [0] * (LENGTH - n) + segments += list(range(100, 100 + LENGTH - n)) + labels = np.asarray(seq[1:], dtype=np.int64) + labels[(labels == BOS) | (labels == PAD)] = -100 + seg = np.asarray(segments[:-1]) + mask = (seg[:, None] == seg[None, :]) & np.tri(LENGTH - 1, dtype=bool) + return ( + np.asarray(seq[:-1], dtype=np.int64), + np.asarray(positions[:-1], dtype=np.int64), + mask[None], + labels, + ) + + +def build_world(spec): + """One supplied world; complete head-tail pairs held out before rendering.""" + rng = np.random.default_rng(spec["world"]) + hn, bn, tn = spec["heads_n"], spec["bridges_n"], spec["tails_n"] + hs = np.arange(len(WORDS), len(WORDS) + hn) + bs = np.arange(hs[-1] + 1, hs[-1] + 1 + bn) + ts = np.arange(bs[-1] + 1, bs[-1] + 1 + tn) + first = np.array([(h, r, rng.choice(bs)) for h in hs for r in range(13, 17)]) + second = np.array([(b, r, rng.choice(ts)) for b in bs for r in range(17, 21)]) + lookup = {(int(h), int(r)): int(t) for h, r, t in second} + paths = np.array( + [(h, r1, b, r2, lookup[int(b), r2]) for h, r1, b in first for r2 in range(17, 21)], + dtype=np.int64, + ) + reserved = rng.random((hn, tn)) < spec["holdout_fraction"] + held = reserved[paths[:, 0] - hs[0], paths[:, 4] - ts[0]] + background = paths[:, 0] < hs[0] + hn // 2 + groups = { + "atomic_first": first, + "atomic_second": second, + "background_train": paths[background & ~held], + "background_test": paths[background & held], + "target_train": paths[~background & ~held], + "target_test": paths[~background & held], + } + for key, rows in groups.items(): + if not len(rows): + raise ValueError(f"Empty world stratum {key}; do not silently reroll") + train_pairs = {tuple(r[[0, 4]]) for r in paths[~held]} + test_pairs = {tuple(r[[0, 4]]) for r in paths[held]} + assert not train_pairs & test_pairs + # Typed atomics can never expose a head and a tail together. + assert not set(first[:, 0]) & set(second[:, 0]) + assert not set(first[:, 2]) & set(second[:, 2]) + groups["atomic"] = np.concatenate([first, second]) + groups["all_paths"] = paths + return groups + + +def training_table(world, arm): + if arm not in ("P0", "P1", "P2"): + raise ValueError(arm) + packed = [pack_documents([atomic_sentence(r)], [0]) for r in world["atomic"]] + base_end = len(packed) + packed.extend(pack_documents([composite_sentence(r)], [0]) for r in world["background_train"]) + background_end = len(packed) + neutral = [BOS, 6, 7, 8, 9, 10, 11, 12, 5, EOS] + for row in world["target_train"]: + h, r1, b, r2, t = row + third = composite_sentence(row) if arm == "P2" else neutral + packed.append( + pack_documents( + [atomic_sentence([h, r1, b]), atomic_sentence([b, r2, t]), third], + [0, 1, 2] if arm == "P0" else [0, 0, 2], + ) + ) + table = tuple(np.stack([row[i] for row in packed]) for i in range(4)) + return table, [0, base_end, background_end, len(packed)] + + +class TextGPT(LoopGPT): + def forward(self, tokens, position_ids=None, attention_mask=None, patch=None, cache=None): + if position_ids is None: + position_ids = torch.arange(tokens.shape[1], device=tokens.device)[None] + p = self.dropout if self.training else 0.0 + x = F.dropout(self.token(tokens) + self.position(position_ids), p=p, training=self.training) + for layer, block in enumerate(self.iter_blocks()): + z = block.ln1(x) + batch, length, width = z.shape + a = block.attention + q, k, v = a.qkv(z).view(batch, length, 3, a.heads, width // a.heads).unbind(2) + y = F.scaled_dot_product_attention( + q.transpose(1, 2), + k.transpose(1, 2), + v.transpose(1, 2), + attn_mask=attention_mask, + is_causal=attention_mask is None, + dropout_p=p, + ) + attn = F.dropout( + a.proj(y.transpose(1, 2).reshape(batch, length, width)), p=p, training=self.training + ) + mlp = F.dropout(block.mlp(block.ln2(x + attn)), p=p, training=self.training) + if cache is not None: + cache[layer] = { + "attention": attn.detach(), + "mlp": mlp.detach(), + "full": (x + attn + mlp).detach(), + } + if patch is not None and layer == patch["layer"]: + pos, value, component = patch["position"], patch["value"], patch["component"] + if component == "full": + x = x + attn + mlp + x = x.clone() + x[:, pos] = value + continue + if component == "attention": + attn = attn.clone() + attn[:, pos] = value + elif component == "mlp": + mlp = mlp.clone() + mlp[:, pos] = value + else: + raise ValueError(component) + x = x + attn + mlp + return F.linear(self.ln_final(x), self.token.weight) + + +class TextGraphStep(GraphStep): + def eager(self): + self.optimizer.zero_grad(set_to_none=False) + x, positions, mask, labels = (t[self.index] for t in self.table) + logits = self.model(x, position_ids=positions, attention_mask=mask) + loss = F.cross_entropy(logits.flatten(0, 1), labels.flatten(), ignore_index=-100) + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.clip, foreach=True) + self.optimizer.step() + return loss, norm + + +def construct(spec, device): + torch.manual_seed(spec["initialization"]) + cfg = ModelConfig( + vocab_size=len(vocabulary(spec)), + width=spec["width"], + layers=spec["layers"], + heads=spec["heads"], + context=LENGTH, + ) + return TextGPT(cfg, repeats=spec["repeats"], dropout=spec["dropout"]).to(device) + + +@torch.inference_mode() +def evaluate(model, rows, device, composite=False, patch=None, batch_size=256): + model.eval() + encode = composite_sentence if composite else atomic_sentence + prompts = np.asarray([encode(r)[:-3] for r in rows], dtype=np.int64) + answers, stops, probs = [], [], [] + for start in range(0, len(rows), batch_size): + x = torch.as_tensor(prompts[start : start + batch_size], device=device) + intervention = ( + None if patch is None else dict(patch, value=patch["value"][start : start + batch_size]) + ) + logits = model(x, patch=intervention)[:, -1] + target = torch.as_tensor(rows[start : start + batch_size, -1], device=device) + probs.extend(logits.softmax(-1).gather(1, target[:, None]).squeeze(1).tolist()) + prediction = logits.argmax(-1) + answers.extend(prediction.tolist()) + x = torch.cat([x, prediction[:, None]], dim=1) + period = model(x, patch=intervention)[:, -1].argmax(-1) + x = torch.cat([x, period[:, None]], dim=1) + eos = model(x, patch=intervention)[:, -1].argmax(-1) + stops.extend(torch.stack([period, eos], dim=1).tolist()) + ans, stop, probability = np.asarray(answers), np.asarray(stops), np.asarray(probs) + correct = ans == rows[:, -1] + full = correct & (stop[:, 0] == 5) & (stop[:, 1] == EOS) + return dict( + n=len(rows), + answer_accuracy=float(correct.mean()), + accuracy=float(full.mean()), + answer_probability=float(probability.mean()), + ), dict(answer=ans, stops=stop, probability=probability, target=rows[:, -1]) + + +def run(spec, output, device): + output = Path(output) + if (output / "complete.json").exists(): + return json.loads((output / "complete.json").read_text()) + output.mkdir(parents=True, exist_ok=True) + lock = json.loads(Path(spec["source_lock"]).read_text()) + for file, expected in lock["sources"].items(): + assert sha(file) == expected, file + assert lock["config_sha256"] == sha(spec["config_path"]) + torch.set_num_threads(2) + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_per_process_memory_fraction(0.08, device) + world = build_world(spec) + cpu_table, bounds = training_table(world, spec["arm"]) + np.savez_compressed(output / "world.npz", **world) + np.savez_compressed( + output / "training-table.npz", + **{k: v for k, v in zip(("tokens", "positions", "mask", "labels"), cpu_table, strict=True)}, + ) + write_json(output / "spec.json", spec) + write_json(output / "vocabulary.json", vocabulary(spec)) + model = construct(spec, device) + opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"]) + table = tuple(torch.as_tensor(t, device=device) for t in cpu_table) + streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(3)] + latest = output / "latest.pt" + start, elapsed, histories = 0, 0.0, [] + if latest.exists(): + state = torch.load(latest, map_location=device, weights_only=False) + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + for stream, saved in zip(streams, state["streams"], strict=True): + stream.load_state_dict(saved) + start, elapsed, histories = state["step"], state["seconds"], state["histories"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + counts = spec["batch_parts"] + supervised_per_step = sum(n * tokens for n, tokens in zip(counts, [7, 9, 23], strict=True)) + step_flops = flops( + model.config, spec["repeats"], sum(counts), LENGTH - 1, output_positions=LENGTH - 1 + ) + + def checkpoint(step, seconds): + metrics, predictions = {}, {} + for split in ( + "atomic", + "background_train", + "background_test", + "target_train", + "target_test", + ): + metrics[split], preds = evaluate( + model, world[split], device, composite=split != "atomic" + ) + predictions.update({split + "_" + k: v for k, v in preds.items()}) + atomic_ok = predictions["atomic_answer"] == world["atomic"][:, -1] + knowledge = { + (int(h), int(r)): bool(ok) + for (h, r, _t), ok in zip(world["atomic"], atomic_ok, strict=True) + } + eligible = np.array( + [ + knowledge[int(h), int(r1)] and knowledge[int(b), int(r2)] + for h, r1, b, r2, _t in world["target_test"] + ] + ) + target_ok = predictions["target_test_answer"] == world["target_test"][:, -1] + metrics["target_atomic_correct"] = dict( + n=int(eligible.sum()), + coverage=float(eligible.mean()), + answer_accuracy=float(target_ok[eligible].mean()) if eligible.any() else None, + ) + record = dict( + step=step, + seconds=seconds, + supervised_tokens=step * supervised_per_step, + estimated_flops=step * step_flops, + metrics=metrics, + ) + histories.append(record) + np.savez_compressed(output / f"predictions-{step:06d}.npz", **predictions) + write_json(output / "learning.json", histories) + model.train() + state = dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + step=step, + seconds=seconds, + histories=histories, + spec=spec, + streams=[s.state_dict() for s in streams], + cpu_rng=torch.get_rng_state(), + cuda_rng=torch.cuda.get_rng_state(device), + ) + tmp = output / "latest.tmp" + torch.save(state, tmp) + tmp.replace(latest) + if step in spec["weight_nodes"]: + torch.save( + dict(model=state["model"], step=step, spec=spec), output / f"weights-{step:06d}.pt" + ) + print(json.dumps(dict(run=output.name, **record)), flush=True) + + if start == 0: + checkpoint(0, elapsed) + model.train() + graph = TextGraphStep(model, opt, table, sum(counts)) + tick = time.monotonic() + for step in range(start + 1, spec["steps"] + 1): + idx = np.concatenate( + [ + stream.take(n) + offset + for stream, n, offset in zip(streams, counts, bounds[:-1], strict=True) + ] + ) + for group in opt.param_groups: + group["lr"].fill_(spec["lr"] * min(1.0, step / spec["warmup"])) + graph(torch.as_tensor(idx, device=device)) + if step in spec["nodes"]: + torch.cuda.synchronize() + elapsed += time.monotonic() - tick + checkpoint(step, elapsed) + tick = time.monotonic() + result = dict( + status="complete", + final=histories[-1], + parameters=sum(p.numel() for p in model.parameters()), + source_lock_sha256=sha(spec["source_lock"]), + world_sha256=sha(output / "world.npz"), + peak_memory_bytes=torch.cuda.max_memory_allocated(device), + ) + write_json(output / "complete.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_structure.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_structure.py new file mode 100644 index 0000000000000000000000000000000000000000..e8c74f97848144e288267dedd2df039a1f8c1a52 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/text_structure.py @@ -0,0 +1,432 @@ +"""Matched relation-pair support and transfer to atomically trained facts. + +Reuse the full-token text model; change composition support, not atomics, +per-fact role counts, unique chain count, or token marginals. Target heads and +bridges are disjoint from background; answer values are deliberately shared. +""" + +from __future__ import annotations + +import hashlib +import json +import time +from collections import Counter +from pathlib import Path + +import numpy as np +import torch + +from .grok_depth import EpochStream, make_optimizer, utc, write_json +from .grok_loop_model import flops +from .text_pretrain import ( + LENGTH, + WORDS, + TextGraphStep, + atomic_sentence, + composite_sentence, + construct, + evaluate, + pack_documents, + sha, + vocabulary, +) + +ARMS = ("restricted", "broad", "positive") +TESTS = ("id_test", "first_only", "second_only", "background_neither", "strict_test") +SPLITS = ("atomic", "train_composite", "positive_train", *TESTS) + + +def build_world(spec): + """Balanced graph; common head-tail holdout defined before any model exists. + + Each background bridge receives four trained heads per first relation. + Two of its four second facts have composition experience. Restricted + support pairs r1[0:2] only with even r2 and r1[2:4] only with odd r2. + Broad support assigns half the incoming facts of EACH r1 to each active r2. + Thus the relation-pair support has two components versus one, while all + underlying first/second edge counts match exactly. + """ + rng = np.random.default_rng(spec["world"]) + hn, bn, tn = spec["heads_n"], spec["bridges_n"], spec["tails_n"] + if hn != 128 or bn != 32 or tn != 32: + raise ValueError("This version fixes 128 heads, 32 bridges, 32 shared answer values") + hs = np.arange(len(WORDS), len(WORDS) + hn) + bs = np.arange(hs[-1] + 1, hs[-1] + 1 + bn) + ts = np.arange(bs[-1] + 1, bs[-1] + 1 + tn) + first = [] + for heads, bridges in ((hs[:64], bs[:16]), (hs[64:96], bs[:16]), (hs[96:], bs[16:])): + mappings = [rng.permutation(np.tile(bridges, len(heads) // len(bridges))) for _ in range(4)] + first.extend((h, 13 + ri, mappings[ri][i]) for i, h in enumerate(heads) for ri in range(4)) + first = np.asarray(first, dtype=np.int64) + active, inactive = [], [] + for bi, b in enumerate(bs[:16]): + chosen = (17, 18) if bi % 2 == 0 else (19, 20) + active.extend((b, r) for r in chosen) + inactive.extend((b, r) for r in range(17, 21) if r not in chosen) + second = [] + for edges in (active, inactive, [(b, r) for b in bs[16:] for r in range(17, 21)]): + tails = rng.permutation(np.tile(ts, len(edges) // len(ts))) + second.extend((*edge, t) for edge, t in zip(edges, tails, strict=True)) + second = np.asarray(sorted(second), dtype=np.int64) + lookup = {(int(h), int(r)): int(t) for h, r, t in second} + paths = np.asarray( + [(h, r1, b, r2, lookup[int(b), r2]) for h, r1, b in first for r2 in range(17, 21)], + dtype=np.int64, + ) + trained_first = first[:256] + active_set = set(active) + broad_assignment = {} + for b in bs[:16]: + choices = sorted(r for bb, r in active if bb == b) + for r1 in range(13, 17): + incoming = rng.permutation( + trained_first[(trained_first[:, 2] == b) & (trained_first[:, 1] == r1), 0] + ) + if len(incoming) != 4: + raise ValueError("Unbalanced graph") + for i, h in enumerate(incoming): + broad_assignment[int(h), r1] = choices[i // 2] + trains = {} + for arm in ARMS[:2]: + rows = [] + for h, r1, b in trained_first: + choices = sorted(r for bb, r in active if bb == b) + r2 = ( + choices[int(r1 >= 15)] if arm == "restricted" else broad_assignment[int(h), int(r1)] + ) + rows.append((h, r1, b, r2, lookup[int(b), r2])) + trains[arm] = np.asarray(rows, dtype=np.int64) + # Two supervised paths per target person; keep the remaining head-tail + # pairs for an independent positive-control generalization evaluation. + positive = [] + for h in hs[96:]: + candidates = paths[paths[:, 0] == h] + positive.extend(candidates[rng.choice(len(candidates), 2, replace=False)]) + positive = np.asarray(positive, dtype=np.int64) + train_union = np.concatenate([trains["restricted"], trains["broad"], positive]) + pairs = {tuple(row[[0, 4]]) for row in train_union} + held = np.asarray([tuple(row[[0, 4]]) not in pairs for row in paths]) + first_seen = paths[:, 0] < hs[64] + second_seen = np.asarray([(int(b), int(r2)) in active_set for b, r2 in paths[:, [2, 3]]]) + strict = paths[:, 0] >= hs[96] + world = dict( + atomic=np.concatenate([first, second]), + atomic_first=first, + atomic_second=second, + restricted_train=trains["restricted"], + broad_train=trains["broad"], + positive_train=positive, + id_test=paths[held & first_seen & second_seen], + first_only=paths[held & first_seen & ~second_seen], + second_only=paths[held & ~first_seen & second_seen], + background_neither=paths[held & ~first_seen & ~second_seen & ~strict], + strict_test=paths[held & strict], + strict_all=paths[strict], + all_paths=paths, + background_heads=hs[:96], + background_bridges=bs[:16], + target_heads=hs[96:], + target_bridges=bs[16:], + active_second=np.asarray(active, dtype=np.int64), + ) + if any(not len(world[key]) for key in TESTS): + raise ValueError("Empty evaluation stratum; do not reroll worlds") + return world + + +def role_counts(rows): + return ( + Counter(map(tuple, rows[:, :3])), + Counter(map(tuple, rows[:, 2:])), + ) + + +def support_components(rows): + adjacency = {} + for _h, r1, _b, r2, _t in rows: + a, b = (0, int(r1)), (1, int(r2)) + adjacency.setdefault(a, set()).add(b) + adjacency.setdefault(b, set()).add(a) + remaining, components = set(adjacency), [] + while remaining: + stack, found = [min(remaining)], set() + while stack: + node = stack.pop() + if node not in found: + found.add(node) + stack.extend(adjacency[node] - found) + remaining -= found + components.append(sorted(found)) + return components + + +def data_audit(world): + a, b = world["restricted_train"], world["broad_train"] + assert len(a) == len(b) == 256 + assert len(set(map(tuple, a))) == len(set(map(tuple, b))) == 256 + assert role_counts(a) == role_counts(b) + assert Counter(t for row in a for t in composite_sentence(row)) == Counter( + t for row in b for t in composite_sentence(row) + ) + assert len(support_components(a)) == 2 and len(support_components(b)) == 1 + lookup = {(int(h), int(r)): int(t) for h, r, t in world["atomic"]} + for h, r1, bridge, r2, t in world["all_paths"]: + assert lookup[int(h), int(r1)] == bridge and lookup[int(bridge), int(r2)] == t + train_pairs = {tuple(r[[0, 4]]) for rows in (a, b, world["positive_train"]) for r in rows} + assert all(not train_pairs & {tuple(r[[0, 4]]) for r in world[s]} for s in TESTS) + assert not set(world["target_heads"]) & set( + np.concatenate([a[:, 0], a[:, 2], b[:, 0], b[:, 2]]) + ) + assert not set(world["target_bridges"]) & set(world["background_bridges"]) + assert set(world["strict_all"][:, 2]) <= set(world["target_bridges"]) + first_counts, second_counts = role_counts(a) + return dict( + status="passed", + sizes={k: len(v) for k, v in world.items()}, + unique_chains={arm: len(world[arm + "_train"]) for arm in ARMS[:2]}, + relation_pair_counts={ + arm: np.bincount( + (world[arm + "_train"][:, 1] - 13) * 4 + world[arm + "_train"][:, 3] - 17, + minlength=16, + ) + .reshape(4, 4) + .tolist() + for arm in ARMS[:2] + }, + role_counts_match=True, + token_marginals_match=True, + first_edge_usage=list(sorted(set(first_counts.values()))), + second_edge_usage=list(sorted(set(second_counts.values()))), + common_holdout_pairs=True, + isolated_target_heads_and_bridges=True, + shared_answer_values=True, + ) + + +def training_table(world, arm): + if arm not in ARMS: + raise ValueError(arm) + rows = world["restricted_train" if arm == "restricted" else "broad_train"] + if arm == "positive": + rows = np.concatenate([rows, world["positive_train"]]) + packed = [pack_documents([atomic_sentence(r)], [0]) for r in world["atomic"]] + packed.extend(pack_documents([composite_sentence(r)], [0]) for r in rows) + return ( + tuple(np.stack([row[i] for row in packed]) for i in range(4)), + [0, len(world["atomic"]), len(packed)], + rows, + ) + + +def score_predictions(predictions): + correct = predictions["answer"] == predictions["target"] + stops = predictions["stops"] + full = correct & (stops[:, 0] == 5) & (stops[:, 1] == 1) + return dict( + n=len(correct), + answer_accuracy=float(correct.mean()), + accuracy=float(full.mean()), + answer_probability=float(predictions["probability"].mean()), + ) + + +@torch.inference_mode() +def two_calls(model, rows, device): + first = rows[:, :3] + first_scores, first_pred = evaluate(model, first, device) + second = np.c_[first_pred["answer"], rows[:, 3:]] + _scores, pred = evaluate(model, second, device) + first_stops = first_pred["stops"] + format_ok = (first_stops[:, 0] == 5) & (first_stops[:, 1] == 1) + second_full = ( + (pred["answer"] == rows[:, -1]) & (pred["stops"][:, 0] == 5) & (pred["stops"][:, 1] == 1) + ) + first_ok = first_pred["answer"] == rows[:, 2] + scores = score_predictions(pred) + scores.update( + accuracy=float((format_ok & second_full).mean()), + path_accuracy=float((format_ok & first_ok & second_full).mean()), + first_accuracy=first_scores["accuracy"], + ) + pred.update( + first_answer=first_pred["answer"], + first_stops=first_stops, + first_target=rows[:, 2], + first_probability=first_pred["probability"], + ) + return scores, pred + + +def evaluate_all(model, world, train_rows, device): + metrics, predictions = {}, {} + groups = dict(world, train_composite=train_rows) + for split in SPLITS: + scores, pred = evaluate(model, groups[split], device, composite=split != "atomic") + metrics[split] = scores + predictions.update({split + "_" + k: v for k, v in pred.items()}) + atomic_ok = predictions["atomic_answer"] == world["atomic"][:, -1] + knowledge = { + (int(h), int(r)): bool(ok) + for (h, r, _t), ok in zip(world["atomic"], atomic_ok, strict=True) + } + for split in TESTS: + rows = world[split] + eligible = np.asarray( + [knowledge[int(h), int(r1)] and knowledge[int(b), int(r2)] for h, r1, b, r2, _t in rows] + ) + predictions[split + "_eligible"] = eligible + conditional = { + k: predictions[split + "_" + k][eligible] + for k in ("answer", "target", "stops", "probability") + } + metrics[split + "_conditional"] = dict( + n=int(eligible.sum()), coverage=float(eligible.mean()) + ) + if eligible.any(): + metrics[split + "_conditional"].update(score_predictions(conditional)) + else: + metrics[split + "_conditional"].update( + answer_accuracy=None, accuracy=None, answer_probability=None + ) + scores, pred = two_calls(model, rows, device) + metrics[split + "_two_calls"] = scores + predictions.update({split + "_two_calls_" + k: v for k, v in pred.items()}) + return metrics, predictions + + +def verify_lock(config, source_lock): + lock = json.loads(Path(source_lock).read_text()) + assert lock["config_sha256"] == sha(config), config + for file, expected in lock["sources"].items(): + assert sha(file) == expected, file + return lock + + +def run(spec, output, device): + output = Path(output) + verify_lock(spec["config_path"], spec["source_lock"]) + if (output / "complete.json").exists(): + return json.loads((output / "complete.json").read_text()) + output.mkdir(parents=True, exist_ok=True) + torch.set_num_threads(2) + torch.cuda.set_device(device) + torch.backends.cuda.matmul.allow_tf32 = True + torch.backends.cudnn.allow_tf32 = True + torch.cuda.set_per_process_memory_fraction(0.06, device) + world = build_world(spec) + write_json(output / "data-audit.json", data_audit(world)) + cpu_table, bounds, train_rows = training_table(world, spec["arm"]) + np.savez_compressed(output / "world.npz", **world, train_composite=train_rows) + np.savez_compressed( + output / "training-table.npz", + **{k: v for k, v in zip(("tokens", "positions", "mask", "labels"), cpu_table, strict=True)}, + ) + write_json(output / "spec.json", spec) + write_json(output / "vocabulary.json", vocabulary(spec)) + model = construct(spec, device) + initial_hash = { + key: hashlib.sha256(value.detach().cpu().numpy().tobytes()).hexdigest() + for key, value in model.state_dict().items() + } + write_json(output / "initialization-hashes.json", initial_hash) + opt = make_optimizer(model, torch.tensor(spec["lr"], device=device), spec["weight_decay"]) + table = tuple(torch.as_tensor(t, device=device) for t in cpu_table) + streams = [EpochStream(bounds[i + 1] - bounds[i], spec["world"] + 100 + i) for i in range(2)] + latest = output / "latest.pt" + start, elapsed, histories = 0, 0.0, [] + if latest.exists(): + state = torch.load(latest, map_location=device, weights_only=False) + assert state["spec"] == spec + model.load_state_dict(state["model"]) + opt.load_state_dict(state["optimizer"]) + for stream, saved in zip(streams, state["streams"], strict=True): + stream.load_state_dict(saved) + start, elapsed, histories = state["step"], state["seconds"], state["histories"] + torch.set_rng_state(state["cpu_rng"].cpu()) + torch.cuda.set_rng_state(state["cuda_rng"].cpu(), device) + counts = spec["batch_parts"] + supervised_per_step = sum(n * tokens for n, tokens in zip(counts, [7, 9], strict=True)) + step_flops = flops( + model.config, spec["repeats"], sum(counts), LENGTH - 1, output_positions=LENGTH - 1 + ) + started = utc() + + def checkpoint(step, seconds): + metrics, predictions = evaluate_all(model, world, train_rows, device) + record = dict( + step=step, + seconds=seconds, + supervised_tokens=step * supervised_per_step, + estimated_flops=step * step_flops, + metrics=metrics, + ) + histories.append(record) + np.savez_compressed(output / f"predictions-{step:06d}.npz", **predictions) + write_json(output / "learning.json", histories) + model.train() + state = dict( + model=model.state_dict(), + optimizer=opt.state_dict(), + step=step, + seconds=seconds, + histories=histories, + spec=spec, + streams=[s.state_dict() for s in streams], + cpu_rng=torch.get_rng_state(), + cuda_rng=torch.cuda.get_rng_state(device), + ) + tmp = output / "latest.tmp" + torch.save(state, tmp) + tmp.replace(latest) + if step in spec["weight_nodes"]: + torch.save( + dict(model=state["model"], step=step, spec=spec), output / f"weights-{step:06d}.pt" + ) + print( + json.dumps( + dict( + run=output.name, + step=step, + seconds=seconds, + metrics={k: metrics[k] for k in ("atomic", "train_composite", *TESTS)}, + ) + ), + flush=True, + ) + + if start == 0: + checkpoint(0, elapsed) + model.train() + before = {k: v.detach().clone() for k, v in model.state_dict().items()} + graph = TextGraphStep(model, opt, table, sum(counts)) + assert all(torch.equal(before[k], v) for k, v in model.state_dict().items()) + tick = time.monotonic() + for step in range(start + 1, spec["steps"] + 1): + idx = np.concatenate( + [ + stream.take(n) + offset + for stream, n, offset in zip(streams, counts, bounds[:-1], strict=True) + ] + ) + for group in opt.param_groups: + group["lr"].fill_(spec["lr"] * min(1.0, step / spec["warmup"])) + graph(torch.as_tensor(idx, device=device)) + if step in spec["nodes"]: + torch.cuda.synchronize() + elapsed += time.monotonic() - tick + checkpoint(step, elapsed) + tick = time.monotonic() + result = dict( + status="complete", + started_utc=started, + finished_utc=utc(), + final=histories[-1], + parameters=sum(p.numel() for p in model.parameters()), + source_lock_sha256=sha(spec["source_lock"]), + world_sha256=sha(output / "world.npz"), + peak_memory_bytes=torch.cuda.max_memory_allocated(device), + gpu=torch.cuda.get_device_name(device), + torch_version=torch.__version__, + ) + write_json(output / "complete.json", result) + return result diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/twohop_depth.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/twohop_depth.py new file mode 100644 index 0000000000000000000000000000000000000000..19b9a4b76eadef68acf7603b8434567145244311 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/src/llm_memory_editability/twohop_depth.py @@ -0,0 +1,362 @@ +"""Depth, held-out composition, and bridge interventions in random fact worlds. + +Entity IDs and relation IDs are disjoint. A relation is a random permutation; +this makes every atom and each split's answer marginal exactly balanced. +""" + +from __future__ import annotations + +import contextlib +import hashlib +import json +import os +from pathlib import Path + +import numpy as np +import torch +from torch.nn import functional as F + +from llm_memory_editability.bios_model import CausalLM, ModelConfig + +ROOT = Path(os.environ.get("TWOHOP_PROJECT_ROOT", Path(__file__).resolve().parents[2])) +CONFIG = ROOT / "configs/twohop-depth-v1.json" +DATA = ROOT / "data/twohop-depth-v1" +RESULTS = ROOT / "results/twohop-depth-v1" +ART = ROOT / "docs/development-artifacts/twohop-depth-v1" +BOS, EOS, ENTITY = 1, 2, 3 + + +def read(path): + return json.loads(Path(path).read_text()) + + +def write(path, value): + path = Path(path) + path.parent.mkdir(parents=True, exist_ok=True) + temp = path.with_suffix(path.suffix + ".tmp") + temp.write_text(json.dumps(value, ensure_ascii=False, indent=2, allow_nan=False) + "\n") + temp.replace(path) + + +def digest(path): + h = hashlib.sha256() + with Path(path).open("rb") as f: + for block in iter(lambda: f.read(1024 * 1024), b""): + h.update(block) + return h.hexdigest() + + +def world_arrays(seed, cfg): + n, r = cfg["entities"], cfg["relations"] + if r % 2 or r < 2: + raise ValueError("An even relation count is required for balanced coverage") + rng = np.random.default_rng(seed) + maps = np.stack([rng.permutation(n) for _ in range(r)]) + # For each bridge, a regular bipartite graph over first/second relations. + # Each atom occurs in r/2 training compositions in EACH hop role. + orders = np.stack([rng.permutation(r) for _ in range(n)]) + mask = np.zeros((n, r, r), dtype=bool) + for a in range(n): + for r1 in range(r): + b = maps[r1, a] + mask[a, r1, orders[b, (r1 + np.arange(r // 2)) % r]] = True + atoms = np.array([(a, rel) for a in range(n) for rel in range(r)], dtype=np.int64) + comps = np.array( + [(a, r1, r2) for a in range(n) for r1 in range(r) for r2 in range(r)], + dtype=np.int64, + ) + a, r1, r2 = comps.T + bridge = maps[r1, a] + answer = maps[r2, bridge] + selected = rng.choice(np.flatnonzero(~mask.ravel()), cfg["diagnostic_cases"], replace=False) + cases = [] + inverse = np.argsort(maps, axis=1) + for index in selected: + a0, r10, r20 = comps[index] + b0, c0 = bridge[index], answer[index] + # Donor contains only a first-hop prefix; neither its explicit entity nor + # its first-hop answer is the counterfactual final answer. + candidates = [] + for b1 in range(n): + a1, c1 = inverse[r10, b1], maps[r20, b1] + if b1 != b0 and c1 not in {a1, b1, a0, b0, c0}: + candidates.append((int(a1), int(b1), int(c1))) + if not candidates: + raise ValueError("No answer-free bridge donor; increase world size") + a1, b1, c1 = candidates[int(rng.integers(len(candidates)))] + same_r = (r10 + 1) % r + same_a = inverse[same_r, b0] + wrong_candidates = [ + (rr, int(maps[rr, b1])) for rr in range(r) if rr != r20 and maps[rr, b1] not in {c0, c1} + ] + if not wrong_candidates: + raise ValueError("No distinct wrong-relation answer") + wrong_r, wrong_y = wrong_candidates[int(rng.integers(len(wrong_candidates)))] + cases.append([index, a0, r10, r20, b0, c0, a1, b1, c1, same_a, same_r, wrong_r, wrong_y]) + ax = np.c_[np.full(len(atoms), BOS), ENTITY + atoms[:, 0], ENTITY + n + atoms[:, 1]] + cx = np.c_[np.full(len(comps), BOS), ENTITY + a, ENTITY + n + r1, ENTITY + n + r2] + return { + "maps": maps, + "atoms": atoms, + "comps": comps, + "train_mask": mask.ravel(), + "atomic_x": ax, + "atomic_y": ENTITY + maps[atoms[:, 1], atoms[:, 0]], + "composite_x": cx, + "composite_y": ENTITY + answer, + "bridge": ENTITY + bridge, + "cases": np.asarray(cases, dtype=np.int64), + } + + +def audit_world(w, cfg): + n, r = cfg["entities"], cfg["relations"] + maps, comps = w["maps"], w["comps"] + assert all(np.array_equal(np.sort(row), np.arange(n)) for row in maps) + assert len(set(map(tuple, w["atomic_x"]))) == n * r + assert len(set(map(tuple, w["composite_x"]))) == n * r * r + for mask in (w["train_mask"], ~w["train_mask"]): + a, r1, r2 = comps[mask].T + b = maps[r1, a] + assert np.all(np.bincount(a * r + r1, minlength=n * r) == r // 2) + assert np.all(np.bincount(b * r + r2, minlength=n * r) == r // 2) + assert np.all(np.bincount(w["composite_y"][mask] - ENTITY, minlength=n) == r * r // 2) + assert np.all(~w["train_mask"][w["cases"][:, 0]]) + for _, a, r1, r2, b, c, da, db, dc, sa, sr, wr, wy in w["cases"]: + assert maps[r1, a] == b and maps[r2, b] == c + assert maps[r1, da] == db and maps[r2, db] == dc + assert maps[sr, sa] == b and sr != r1 + assert dc not in {da, db, a, b, c} + assert maps[wr, db] == wy and wr != r2 and wy not in {c, dc} + return { + "atoms": n * r, + "train_compositions": int(w["train_mask"].sum()), + "test_compositions": int((~w["train_mask"]).sum()), + "diagnostic_cases": len(w["cases"]), + "every_atom_train_composition_occurrences_per_hop": r // 2, + "balanced_answers": True, + "answer_free_donors": True, + } + + +def stream_indices(length, count, rng): + return np.concatenate([rng.permutation(length) for _ in range((count + length - 1) // length)])[ + :count + ] + + +def make_stream(w, seed, cfg): + rng = np.random.default_rng(seed) + count = cfg["steps"] * cfg["batch_per_kind"] + return { + "atomic": stream_indices(len(w["atomic_x"]), count, rng), + "composite": stream_indices(int(w["train_mask"].sum()), count, rng), + } + + +def build_model(arch, cfg): + return CausalLM( + ModelConfig( + vocab_size=ENTITY + cfg["entities"] + cfg["relations"], + layers=arch["layers"], + width=arch["width"], + heads=arch["heads"], + context=8, + ) + ) + + +def amp(device): + return ( + torch.autocast("cuda", dtype=torch.bfloat16) + if str(device).startswith("cuda") + else contextlib.nullcontext() + ) + + +def training_tensors(w, device): + result = {} + for name, mask in (("atomic", slice(None)), ("composite", w["train_mask"])): + x, y = w[name + "_x"][mask], w[name + "_y"][mask] + full = np.zeros((len(x), 6), dtype=np.int64) + full[:, : x.shape[1]] = x + full[:, x.shape[1]] = y + full[:, x.shape[1] + 1] = EOS + pos = np.tile([x.shape[1] - 1, x.shape[1]], (len(x), 1)) + labels = np.c_[y, np.full(len(x), EOS)] + result[name] = tuple(torch.as_tensor(v, device=device) for v in (full, pos, labels)) + return result + + +def optimizer_for(model, cfg, device): + decay, no_decay = [], [] + for p in model.parameters(): + (decay if p.ndim >= 2 else no_decay).append(p) + return torch.optim.AdamW( + [ + {"params": decay, "weight_decay": cfg["weight_decay"]}, + {"params": no_decay, "weight_decay": 0}, + ], + lr=cfg["lr"], + betas=(0.9, 0.999), + eps=1e-8, + fused=str(device).startswith("cuda"), + ) + + +def train_step(model, optimizer, tensors, indices, step, cfg, device): + parts = [tuple(v[indices[k]] for v in tensors[k]) for k in ("atomic", "composite")] + x, pos, labels = (torch.cat([p[j] for p in parts]) for j in range(3)) + lr = cfg["lr"] * min(1.0, (step + 1) / cfg["warmup"]) + for group in optimizer.param_groups: + group["lr"] = lr + optimizer.zero_grad(set_to_none=True) + with amp(device): + logits = model(x, positions=pos) + losses = F.cross_entropy(logits.float().flatten(0, 1), labels.flatten(), reduction="none") + loss = losses.mean() + loss.backward() + norm = torch.nn.utils.clip_grad_norm_(model.parameters(), cfg["gradient_clip"]) + optimizer.step() + return loss.detach(), norm.detach() + + +@torch.no_grad() +def predict(model, x, y, device, batch=512): + pred, eos, prob = [], [], [] + for start in range(0, len(x), batch): + q = torch.as_tensor(x[start : start + batch], device=device) + target = torch.as_tensor(y[start : start + batch], device=device) + with amp(device): + logits = model(q)[:, -1].float() + answer = logits.argmax(-1) + stop = model(torch.cat([q, answer[:, None]], dim=1))[:, -1].argmax(-1) + pred.extend(answer.cpu().tolist()) + eos.extend(stop.cpu().tolist()) + prob.extend(logits.log_softmax(-1).gather(1, target[:, None]).squeeze(1).cpu().tolist()) + return np.asarray(pred), np.asarray(eos), np.asarray(prob) + + +@torch.no_grad() +def evaluate(model, w, cfg, device): + arrays, metrics = {}, {} + for name, key, mask in ( + ("atomic", "atomic", slice(None)), + ("train", "composite", w["train_mask"]), + ("test", "composite", ~w["train_mask"]), + ): + x, y = w[key + "_x"][mask], w[key + "_y"][mask] + pred, eos, logp = predict(model, x, y, device, cfg["eval_batch"]) + arrays.update({name + "_pred": pred, name + "_eos": eos, name + "_logp": logp}) + metrics.update( + { + name + "_answer": float(np.mean(pred == y)), + name + "_exact": float(np.mean((pred == y) & (eos == EOS))), + name + "_nll": float(-logp.mean()), + } + ) + # Autonomous two-call baseline uses its own generated bridge, never the oracle. + test_ids = np.flatnonzero(~w["train_mask"]) + a, r1, r2 = w["comps"][test_ids].T + bridge_pred = arrays["atomic_pred"][a * cfg["relations"] + r1] + bridge_eos = arrays["atomic_eos"][a * cfg["relations"] + r1] + second_x = np.c_[np.full(len(a), BOS), bridge_pred, ENTITY + cfg["entities"] + r2] + y = w["composite_y"][test_ids] + pred, eos, logp = predict(model, second_x, y, device, cfg["eval_batch"]) + arrays.update( + two_call_pred=pred, two_call_eos=eos, two_call_logp=logp, two_call_bridge=bridge_pred + ) + two_exact = (pred == y) & (eos == EOS) & (bridge_eos == EOS) + metrics["two_call_exact"] = float(two_exact.mean()) + atom_ok = (arrays["atomic_pred"] == w["atomic_y"]) & (arrays["atomic_eos"] == EOS) + b = w["maps"][r1, a] + both = atom_ok[a * cfg["relations"] + r1] & atom_ok[b * cfg["relations"] + r2] + arrays["test_both_atoms_correct"] = both + exact = (arrays["test_pred"] == y) & (arrays["test_eos"] == EOS) + metrics["test_both_atoms_n"] = int(both.sum()) + metrics["test_given_both_atoms"] = float(exact[both].mean()) if both.any() else None + return metrics, arrays + + +@torch.no_grad() +def states_and_logits(model, tokens, device): + # Mirrors bios_model.CausalLM.forward; contract-tested against ordinary forward. + with amp(device): + h = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=device)) + states = [h.clone()] + for block in model.blocks: + h = block(h) + states.append(h.clone()) + logits = F.linear(model.ln_final(h), model.token.weight) + return states, logits.float() + + +@torch.no_grad() +def patched_logits(model, tokens, layer, positions, replacement, device): + with amp(device): + h = model.token(tokens) + model.position(torch.arange(tokens.shape[1], device=device)) + if layer == 0: + h[:, positions] = replacement.to(h.dtype) + for number, block in enumerate(model.blocks, 1): + h = block(h) + if number == layer: + h[:, positions] = replacement.to(h.dtype) + return F.linear(model.ln_final(h), model.token.weight)[:, -1].float() + + +@torch.no_grad() +def diagnostics(model, w, cfg, device): + cases = w["cases"] + q = torch.as_tensor(w["composite_x"][cases[:, 0]], device=device) + dx = np.c_[ + np.full(len(cases), BOS), ENTITY + cases[:, 6], ENTITY + cfg["entities"] + cases[:, 2] + ] + sx = np.c_[ + np.full(len(cases), BOS), ENTITY + cases[:, 9], ENTITY + cfg["entities"] + cases[:, 10] + ] + clean, logits = states_and_logits(model, q, device) + donor, _ = states_and_logits(model, torch.as_tensor(dx, device=device), device) + same, _ = states_and_logits(model, torch.as_tensor(sx, device=device), device) + old = torch.as_tensor(ENTITY + cases[:, 5], device=device) + new = torch.as_tensor(ENTITY + cases[:, 8], device=device) + wrong = torch.as_tensor(ENTITY + cases[:, 12], device=device) + row = torch.arange(len(q), device=device) + baseline = logits[:, -1] + out = { + "case_ids": cases[:, 0], + "clean_pred": baseline.argmax(-1).cpu().numpy(), + "clean_margin": (baseline[row, new] - baseline[row, old]).cpu().numpy(), + "old_y": old.cpu().numpy(), + "new_y": new.cpu().numpy(), + "wrong_y": wrong.cpu().numpy(), + } + # Fixed random orthogonal coordinate permutation preserves perturbation norm. + rng = np.random.default_rng(142899) + perm = torch.as_tensor(rng.permutation(model.config.width), device=device) + signs = torch.as_tensor(rng.choice([-1, 1], model.config.width), device=device) + for layer in range(len(clean)): + with amp(device): + lens = F.linear(model.ln_final(clean[layer]), model.token.weight).float() + out[f"lens_bridge_pos2_{layer}"] = lens[:, 2].argmax(-1).cpu().numpy() + out[f"lens_query_pos3_{layer}"] = lens[:, 3].argmax(-1).cpu().numpy() + delta = donor[layer][:, 2] - clean[layer][:, 2] + random_state = clean[layer][:, 2] + delta[:, perm] * signs + conditions = { + "bridge": ([2], donor[layer][:, [2]]), + "same_bridge": ([2], same[layer][:, [2]]), + "random": ([2], random_state[:, None]), + "source": ([1], donor[layer][:, [1]]), + "prefix": ([1, 2], donor[layer][:, [1, 2]]), + "identity": ([2], clean[layer][:, [2]]), + } + for name, (positions, replacement) in conditions.items(): + z = patched_logits(model, q, layer, positions, replacement, device) + prefix = f"{name}_{layer}" + out[prefix + "_pred"] = z.argmax(-1).cpu().numpy() + out[prefix + "_margin"] = (z[row, new] - z[row, old]).cpu().numpy() + out[prefix + "_max_delta"] = (z - baseline).abs().max(-1).values.cpu().numpy() + return out + + +def run_name(world, seed, architecture): + return f"w{world}-s{seed}-{architecture}" diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_oo_optimizer_attribution.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_oo_optimizer_attribution.py new file mode 100644 index 0000000000000000000000000000000000000000..3784fcaed7f204a0c3c8b5783007432d32b1baa4 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_oo_optimizer_attribution.py @@ -0,0 +1,152 @@ +"""Protect optimizer attribution, historical reuse, and the GPU queue boundary.""" + +import copy +import importlib.util +import sys +from pathlib import Path + +import numpy as np +import pytest + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "scripts")) +SPEC = importlib.util.spec_from_file_location( + "oo_optimizer_controller", ROOT / "scripts/execute_oo_optimizer_attribution.py" +) +module = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(module) + + +def fixture_config(): + return module.read(ROOT / "configs/oo-optimizer-attribution-v1.json") + + +def test_complete_paired_factorial_reuses_only_the_baseline(): + config = fixture_config() + module.validate_matrix(config, module.read(config["historical_config"])) + assert sum(s["steps"] for s in config["runs"]) == 1_800_000 + assert len(config["baseline_curve_carriers"]) == 2 + carriers = [s for s in config["runs"] if s["name"] in config["baseline_curve_carriers"]] + assert {s["initialization"] for s in carriers} == {811201, 811202} + + +@pytest.mark.parametrize( + "key,value", + [ + ("steps", 1500000), + ("sampling_seed", 1), + ("dropout_seed", 1), + ("microbatch_size", 128), + ("repeats", 1), + ("learning_rate", 5e-5), + ], +) +def test_rejects_unpaired_or_duplicate_conditions(key, value): + config = fixture_config() + config["runs"][0][key] = value + with pytest.raises(AssertionError): + module.validate_matrix(config, module.read(config["historical_config"])) + + +def test_historical_training_dependency_closure_and_audits(): + config = fixture_config() + result = module.verify_inputs(config, ROOT) + assert result["passed"] + assert set(result["trainer_dependency_sha256"]) == { + "src/llm_memory_editability/" + name + ".py" + for name in [ + "realworld_composition", + "realworld_composition_data", + "grokking_reproduction", + "grok_depth", + "bios_model", + ] + } + + +def test_queue_needs_every_predecessor_audit(tmp_path): + config = {"wait_for_results_root": str(tmp_path), "wait_for_runs": ["a", "b"]} + state = {"state": "running", "completed": ["a"], "active": {"2": "b"}, "failed": []} + module.write(tmp_path / "controller-state.json", state) + assert module.predecessor_ready(config)[0] is False + state.update(state="complete", completed=["a", "b"], active={}) + module.write(tmp_path / "controller-state.json", state) + module.write(tmp_path / "runs/a/audit.json", {"passed": True}) + with pytest.raises(FileNotFoundError): + module.predecessor_ready(config) + module.write(tmp_path / "runs/b/audit.json", {"passed": False}) + with pytest.raises(AssertionError): + module.predecessor_ready(config) + module.write(tmp_path / "runs/b/audit.json", {"passed": True}) + assert module.predecessor_ready(config)[0] is True + state.update(state="finished_with_failures", failed=["b"]) + module.write(tmp_path / "controller-state.json", state) + with pytest.raises(RuntimeError): + module.predecessor_ready(config) + + +def test_container_stays_in_lm_context_with_a_single_gpu_and_output(tmp_path): + config = copy.deepcopy(fixture_config()) + config.update(repository=str(ROOT), source_root=str(tmp_path / "source")) + out = tmp_path / "runs" / config["runs"][0]["name"] + _, command = module.container_command( + config, tmp_path / "frozen.json", config["runs"][0], out, 4, 1 + ) + assert command[:4] == ["docker", "--context", "lm-memory", "run"] + assert command[command.index("--gpus") + 1] == "device=4" + assert str(tmp_path / "source/scripts/execute_oo_optimizer_attribution.py") in command + assert f"type=bind,src={ROOT},dst={ROOT},readonly" in command + assert f"type=bind,src={out},dst={out}" in command + assert "--read-only" in command and "--network=none" in command + + +def test_report_pairs_both_factors_and_rejects_exposure_drift(tmp_path): + config = fixture_config() + config["results_root"] = str(tmp_path / "results") + for baseline in config["reused_baselines"]: + baseline["path"] = str(tmp_path / baseline["spec"]["name"]) + entries = [(b["spec"], Path(b["path"])) for b in config["reused_baselines"]] + entries += [(s, Path(config["results_root"]) / "runs" / s["name"]) for s in config["runs"]] + for spec, out in entries: + count = ( + 100 + + 20 * (spec["learning_rate"] == 1e-4) + + 30 * (spec["weight_decay"] == 0.3) + + 7 * (spec["learning_rate"] == 1e-4 and spec["weight_decay"] == 0.3) + ) + module.write(out / "audit.json", {"passed": True}) + module.write(out / "run.json", {"initial_model_sha256": str(spec["initialization"])}) + module.write( + out / "endpoint-predictions.json", + {"test_all": [{"role": "OO", "alias_em": int(i < count)} for i in range(1283)]}, + ) + module.write(out / "endpoint.json", {"test_oo": {"alias_em": count / 1283}}) + module.write( + out / "learning.json", + [ + { + k: 512 + for k in [ + "examples", + "supervised_tokens", + "executed_input_tokens", + "effective_input_tokens", + "estimated_matmul_training_flops", + ] + } + ], + ) + for step in config["evaluation_nodes"]: + np.savez(out / f"exposure-{step:07d}.npz", counts=np.array([step, step])) + for name in ["full-curve", "historical-baseline-curve"]: + module.write(out / name / "complete.json", {"passed": True}) + module.write(out / name / "curve.json", []) + module.report(config) + result = module.read(Path(config["results_root"]) / "report.json") + assert len(result["cells"]) == 8 + assert result["mean_contrasts"]["interaction_pp"] == pytest.approx(700 / 1283) + assert result["mean_contrasts"]["joint_recipe_minus_baseline_pp"] == pytest.approx(5700 / 1283) + out = Path(config["results_root"]) / "runs" / config["runs"][0]["name"] + np.savez(out / "exposure-0300000.npz", counts=np.array([300001, 300000])) + with pytest.raises(AssertionError): + module.report(config) diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_parametric_architecture_controller.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_parametric_architecture_controller.py new file mode 100644 index 0000000000000000000000000000000000000000..f7a2d591814a2423edebfef3f4b23496d3bb7367 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_parametric_architecture_controller.py @@ -0,0 +1,114 @@ +"""The stage boundary must not tune on main outcomes or lose a candidate.""" + +import importlib.util +import json +from pathlib import Path + +import pytest + +SPEC = importlib.util.spec_from_file_location( + "architecture_controller", + Path(__file__).resolve().parents[1] / "scripts/execute_parametric_architecture.py", +) +controller = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(controller) + + +def fixture_config(tmp_path): + root = tmp_path / "development" + root.mkdir() + main_data = tmp_path / "main.json" + controller.write(main_data, {"sentinel": "never used for LR selection"}) + old = tmp_path / "historical.json" + controller.write( + old, + [{"step": 32000, "metrics": {"atomic": {"nll": 1.0}, "train_composition": {"nll": 1.0}}}], + ) + config = { + "repository": str(tmp_path), + "tracking": {}, + "runs": [], + "transition": { + "batch": "main", + "results_root": str(tmp_path / "main"), + "data_file": str(main_data), + "data_sha256": controller.digest(main_data), + "historical_reuse_verified": True, + "selection_rule": "fixed 32k fitting NLL", + "historical_development": { + "path": str(old), + "sha256": controller.digest(old), + "selection_score": 1.0, + }, + }, + } + for arm in ["M8", "W8", "IHC8", "HC8", "D8"]: + for lr in [1e-4] if arm == "D8" else [5e-5, 1e-4]: + name = f"{arm}-{lr}" + config["runs"].append( + { + "name": name, + "architecture": arm, + "learning_rate": lr, + "steps": 32000, + "microbatch_size": 128, + } + ) + out = root / "runs" / name + controller.write(out / "audit.json", {"passed": True}) + score = 0.5 if lr == 5e-5 else 2.0 + controller.write( + out / "learning.json", + [ + { + "step": 32000, + "metrics": { + "atomic": {"nll": score}, + "train_composition": {"nll": score}, + "test_oo": {"alias_em": 0.0 if lr == 5e-5 else 1.0}, + }, + } + ], + ) + controller.write(root / "frozen-config.json", config) + return config, root + + +def test_selection_uses_fitting_panels_despite_opposite_oo_scores(tmp_path): + config, root = fixture_config(tmp_path) + main = controller.read(controller.select_main(config, root)) + assert len(main["runs"]) == 12 + assert all(s["learning_rate"] == 5e-5 for s in main["runs"]) + assert {s["initialization"] for s in main["runs"]} == {811201, 811202, 811203} + assert all(s["steps"] == 300000 for s in main["runs"]) + + +def test_changed_dense_recipe_gets_three_new_baselines(tmp_path): + config, root = fixture_config(tmp_path) + p = root / "runs/D8-0.0001/learning.json" + value = controller.read(p) + value[0]["metrics"]["atomic"]["nll"] = 0.0 + value[0]["metrics"]["train_composition"]["nll"] = 0.0 + controller.write(p, value) + main = controller.read(controller.select_main(config, root)) + assert len(main["runs"]) == 15 + assert len([s for s in main["runs"] if s["architecture"] == "D8"]) == 3 + + +@pytest.mark.parametrize("failure", ["missing", "unaudited", "wrong_node", "changed_history"]) +def test_stage_gate_rejects_incomplete_or_changed_evidence(tmp_path, failure): + config, root = fixture_config(tmp_path) + if failure == "missing": + config["runs"].pop() + elif failure == "unaudited": + controller.write(root / "runs/M8-5e-05/audit.json", {"passed": False}) + elif failure == "wrong_node": + p = root / "runs/M8-5e-05/learning.json" + records = controller.read(p) + records[-1]["step"] = 16000 + controller.write(p, records) + else: + Path(config["transition"]["historical_development"]["path"]).write_text(json.dumps([])) + with pytest.raises(AssertionError): + controller.select_main(config, root) + assert not (tmp_path / "docs/development-artifacts/main/frozen-config.json").exists() diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_realworld_composition.py b/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_realworld_composition.py new file mode 100644 index 0000000000000000000000000000000000000000..3d513851d1d0a66c29b2dea609728c255efcbc46 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/source/tests/test_realworld_composition.py @@ -0,0 +1,289 @@ +"""Scientific contracts for variable-answer, source-grounded 2Wiki training.""" + +import ast +import copy +import re +import string +from collections import Counter +from pathlib import Path +from types import SimpleNamespace + +import numpy as np +import pytest +import torch + +from llm_memory_editability import realworld_composition as rw +from llm_memory_editability.realworld_composition_data import ( + Components, + answer_scores, + extract_chain, + normalize_answer, +) + + +def small_config(dropout=0.0): + return dict(vocab_size=31, positions=32, hidden_size=8, attention_heads=2, dropout=dropout) + + +def spec(layers=4, repeats=1): + return dict(initialization=42, unique_layers=layers, repeats=repeats, microbatch_size=2) + + +def records(): + return [ + dict( + id=str(i), + encoded=dict( + prefix=[1, 2, 3], + target=[4] * (i % 3 + 1) + [30], + input=[1, 2, 3] + [4] * (i % 3 + 1), + ), + ) + for i in range(5) + ] + + +def test_author_scoring_parity(): + path = Path( + "docs/development-artifacts/realworld-composition-v1/reference/2wikimultihop_evaluate_v1.1.py" + ) + tree = ast.parse(path.read_text()) + selected = [ + node + for node in tree.body + if isinstance(node, ast.FunctionDef) + and node.name in {"normalize_answer", "f1_score", "exact_match_score"} + ] + scope = dict(re=re, string=string, Counter=Counter) + exec(compile(ast.Module(body=selected, type_ignores=[]), str(path), "exec"), scope) + for prediction in [ + "The United States", + "United States.", + "12 June 1516", + "", + "yes", + "no", + "New-York", + "NY", + ]: + golds = ["United States", "U.S.", "12 June 1516", "New York", "yes"] + assert normalize_answer(prediction) == scope["normalize_answer"](prediction) + expected = ( + max(float(scope["exact_match_score"](prediction, g)) for g in golds), + max(scope["f1_score"](prediction, g)[0] for g in golds), + ) + assert answer_scores(prediction, golds) == expected + + +def test_chain_uses_ids_and_expands_literal_placeholders(): + row = dict( + type="compositional", + evidences_id=[["Q2", "date of death", "date_information"], ["Q1", "father", "Q2"]], + evidences=[["Bridge alias", "date of death", "12 June 1516"], ["Head", "father", "Bridge"]], + ) + edges, _ = extract_chain(row) + assert edges == (("Q1", "father", "Q2"), ("Q2", "date of death", "literal:12 june 1516")) + row["evidences_id"][0][0] = "Q3" + assert extract_chain(row) is None + + +def test_grouping_joins_head_bridge_but_not_shared_tail_answers(): + groups = Components() + groups.union("film1", "director1") + groups.union("director1", "parent1") + groups.union("film2", "director2") + assert groups.find("film1") == groups.find("parent1") + assert groups.find("film1") != groups.find("film2") + + +def test_common_initialization_and_digest_do_not_change_layers(): + models = [ + rw.construct(small_config(), spec(layers, repeat), "cpu") + for layers, repeat in [(8, 1), (4, 2), (4, 1)] + ] + before = [rw.model_digest(m) for m in models] + assert len({rw.shared_prefix_digest(m) for m in models}) == 1 + assert [len(m.transformer.h) for m in models] == [8, 4, 4] + assert [rw.model_digest(m) for m in models] == before + for m in models: + assert ( + m.transformer.wte.weight.data_ptr() + == dict(m.named_parameters())["transformer.wte.weight"].data_ptr() + ) + + +def test_answer_eos_supervision_and_equal_example_weight(): + x, positions, labels = rw.pack(records()[:2], 30, "cpu") + assert positions[0, :2].tolist() == [2, 3] + assert labels[0].tolist() == [4, 30, -100] + assert x[0, :4].tolist() == [1, 2, 3, 4] + logits = torch.randn(2, 3, 31, requires_grad=True) + loss = rw.example_losses(logits, labels) + expected = torch.stack( + [ + torch.nn.functional.cross_entropy( + logits[i, labels[i] != -100], labels[i, labels[i] != -100] + ) + for i in range(2) + ] + ) + torch.testing.assert_close(loss, expected) + loss.mean().backward() + assert torch.equal(logits.grad[0, 2], torch.zeros(31)) + + +@pytest.mark.parametrize("layers,repeats", [(8, 1), (4, 2), (4, 1)]) +def test_causal_prefix_is_unchanged_by_future_padding(layers, repeats): + model = rw.construct(small_config(), spec(layers, repeats), "cpu").eval() + tokens = torch.tensor([[1, 2, 3, 4, 5, 6, 7, 8]]) + baseline = model(tokens, torch.tensor([[2]])) + tokens[:, 3:] = 29 + torch.testing.assert_close(model(tokens, torch.tensor([[2]])), baseline, rtol=0, atol=0) + + +def test_partial_epoch_and_stream_restore_preserve_order(): + stream = rw.BatchStream(7, 91) + a, b = stream.batch(5), stream.batch(5) + assert len(a) == 5 and len(b) == 2 + assert sorted(np.concatenate([a, b]).tolist()) == list(range(7)) + state = stream.state_dict() + next_ids = stream.batch(5) + restored = rw.BatchStream(7, 999) + restored.load_state_dict(state) + assert np.array_equal(next_ids, restored.batch(5)) + + +def test_accumulation_matches_full_batch_with_unequal_answers(): + a = rw.construct(small_config(), spec(), "cpu") + b = rw.construct(small_config(), spec(), "cpu") + opt_a = torch.optim.SGD(a.parameters(), lr=0.001) + opt_b = torch.optim.SGD(b.parameters(), lr=0.001) + full = {**spec(), "microbatch_size": 5} + result_a = rw.update(a, opt_a, records(), full, "cpu", 30) + result_b = rw.update(b, opt_b, records(), spec(), "cpu", 30) + assert abs(result_a["loss"] - result_b["loss"]) < 1e-6 + for left, right in zip(a.parameters(), b.parameters(), strict=True): + torch.testing.assert_close(left, right, rtol=2e-5, atol=1e-7) + + +def test_dropout_adam_restore_reproduces_next_update(): + model = rw.construct(small_config(0.1), spec(), "cpu") + optimizer = rw.optimizer_for(model, 0.001, 0.1) + rw.update(model, optimizer, records(), spec(), "cpu", 30) + saved = ( + copy.deepcopy(model.state_dict()), + copy.deepcopy(optimizer.state_dict()), + torch.get_rng_state(), + ) + rw.update(model, optimizer, records(), spec(), "cpu", 30) + expected = copy.deepcopy(model.state_dict()) + resumed = rw.construct(small_config(0.1), spec(), "cpu") + resumed_opt = rw.optimizer_for(resumed, 0.001, 0.1) + resumed.load_state_dict(saved[0]) + resumed_opt.load_state_dict(saved[1]) + torch.set_rng_state(saved[2]) + rw.update(resumed, resumed_opt, records(), spec(), "cpu", 30) + for key, value in resumed.state_dict().items(): + torch.testing.assert_close(value, expected[key], rtol=0, atol=0) + + +def test_generation_receives_question_prefix_without_gold_answer(): + class Model(torch.nn.Module): + def forward(self, tokens, positions): + assert 27 not in tokens.tolist()[0] + logits = torch.zeros((len(tokens), 1, 31)) + logits[:, :, 30] = 1 + return logits + + tokenizer = SimpleNamespace(eos_token_id=30, decode=lambda ids, **kw: str(ids)) + result = rw.generate(Model(), [[1, 2, 3]], tokenizer, "cpu") + assert result[0]["generated_tokens"] == [30] + + +def test_generation_limits_each_prompt_without_shortening_other_answers(): + class Model(torch.nn.Module): + def forward(self, tokens, positions): + assert tokens.shape[1] <= 8 + assert int(positions.max()) < tokens.shape[1] + logits = torch.zeros((len(tokens), 1, 31)) + logits[:, :, 5] = 1 + return logits + + tokenizer = SimpleNamespace(eos_token_id=30, decode=lambda ids, **kw: str(ids)) + results = rw.generate(Model(), [[1] * 7, [2, 3]], tokenizer, "cpu", limit=4, sequence_limit=8) + assert [len(r["generated_tokens"]) for r in results] == [1, 4] + assert results[0]["context_limit_reached"] and not results[0]["eos"] + assert results[1]["generation_limit_reached"] and not results[1]["context_limit_reached"] + + +def test_invalid_bridge_failure_does_not_lower_mean_answer_nll(): + predictions = [ + dict( + canonical_em=1.0, + alias_em=1.0, + unambiguous_alias_em=1.0, + f1=1.0, + nll=2.0, + eos=True, + truncated=False, + ), + dict( + canonical_em=0.0, + alias_em=0.0, + unambiguous_alias_em=0.0, + f1=0.0, + nll=None, + eos=False, + truncated=True, + ), + ] + result = rw.aggregate(predictions) + assert result["n"] == 2 and result["nll_n"] == 1 + assert result["alias_em"] == 0.5 and result["nll"] == 2.0 + + +def test_autonomous_second_call_uses_emitted_bridge(monkeypatch): + seen = [] + + def fake_evaluate(model, items, tokenizer, device): + seen.extend(r["question"] for r in items) + predictions = [ + dict( + id=r["id"], + prediction="Wrong Person", + canonical_em=0.0, + alias_em=0.0, + unambiguous_alias_em=0.0, + f1=0.0, + nll=1.0, + eos=True, + truncated=False, + role=r.get("role"), + required_role=r.get("required_role"), + ) + for r in items + ] + return rw.aggregate(predictions), predictions + + monkeypatch.setattr(rw, "evaluate", fake_evaluate) + monkeypatch.setattr(rw, "encode_example", lambda *a: {}) + atoms = [dict(id=i, question="Atomic", answer="Gold Bridge") for i in ["a", "b"]] + chain = dict( + id="c", + question="Original question", + answer="Final", + atom_ids=["a", "b"], + edges=[["Q1", "father", "Q2"], ["Q2", "place of birth", "Q3"]], + role="OO", + required_role="OO", + ) + data = dict( + atoms=atoms, + train_compositions=[], + evaluation_compositions=[chain], + panels=dict(atomic=["a", "b"], train_composition=[], test_oo=["c"]), + ) + metrics, _ = rw.evaluate_dataset(None, data, None, "cpu", autonomous=True) + assert "Where was Wrong Person born?" in seen + assert "Where was Gold Bridge born?" not in seen + assert metrics["test_prerequisites_correct"]["coverage"] == 0.0 diff --git a/docs/development-artifacts/oo-optimizer-attribution-v1/validation.json b/docs/development-artifacts/oo-optimizer-attribution-v1/validation.json new file mode 100644 index 0000000000000000000000000000000000000000..31aa8501a4a12df1283fb78dadc55472f92e52d3 --- /dev/null +++ b/docs/development-artifacts/oo-optimizer-attribution-v1/validation.json @@ -0,0 +1,48 @@ +{ + "passed": true, + "tests_passed": 36, + "test_files": [ + "tests/test_oo_optimizer_attribution.py", + "tests/test_realworld_composition.py", + "tests/test_parametric_architecture_controller.py", + "tests/test_parametric_architecture_rolling.py" + ], + "ruff_check": "passed", + "ruff_format_check": "passed", + "frozen_source_hashes_verified": 122, + "cpu_preflight": "cpu-preflight.json", + "gpu_preflight": "pending; mandatory before each training run", + "controller_state": { + "state": "waiting_for_predecessor", + "gpus": [ + 2, + 3, + 4, + 5 + ], + "completed": [], + "failed": [], + "active": {}, + "queued": [ + "loop-lr1e4-wd03-init1", + "loop-lr1e4-wd01-init1", + "loop-lr5e5-wd03-init1", + "loop-lr1e4-wd03-init2", + "loop-lr1e4-wd01-init2", + "loop-lr5e5-wd03-init2" + ], + "predecessor_completed": 6, + "predecessor_total": 15, + "updated_utc": "2026-10-05T00:26:55.972075+00:00" + }, + "local_links_verified": [ + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-budget-attribution-20261005/budget-comparison.png", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-budget-attribution-20261005/summary.json", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-budget-attribution-20261005/recount-audit.json", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/frozen-config.json", + "/ossfs/workspace/llm-memory-editability/results/oo-optimizer-attribution-v1/controller-state.json", + "/ossfs/workspace/llm-memory-editability/docs/results.md", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md" + ] +} diff --git a/docs/development-artifacts/parametric-architecture-main-v1/execution-lock.json b/docs/development-artifacts/parametric-architecture-main-v1/execution-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..0170ef32d034e6bde5d82d09f58cd47da64e8297 --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-main-v1/execution-lock.json @@ -0,0 +1,9 @@ +{ + "config_sha256": "1541476e281e9fae37b647333e7549d69956860a80de1d756cc9e4fe1b242359", + "frozen_utc": "2026-10-04T00:53:58.578902+00:00", + "development_config_sha256": "2ccae651b625950fb0e612c4e0254f81e1a52e4435bbb28d6457f0c8e03279bd", + "environment": { + "torch": "2.6.0+cu126", + "transformers": "4.40.0" + } +} diff --git a/docs/development-artifacts/parametric-architecture-main-v1/frozen-config.json b/docs/development-artifacts/parametric-architecture-main-v1/frozen-config.json new file mode 100644 index 0000000000000000000000000000000000000000..1122440479ac3a2fee47ccf230014fcfe4064bfd --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-main-v1/frozen-config.json @@ -0,0 +1,451 @@ +{ + "model": { + "vocab_size": 50257, + "positions": 1024, + "hidden_size": 768, + "attention_heads": 12, + "dropout": 0.1, + "mlp_ratio": 4, + "sequence_limit": 256, + "generation_limit": 64 + }, + "data_file": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/confirmation-v1.json", + "data_sha256": "f9df622fe531a77aea397d9ac5e46768e175a13c9d60f8ae3b687fdb0274be27", + "tokenizer": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/tokenizer", + "batch": "parametric-architecture-main-v1", + "phase": "main", + "results_root": "/ossfs/workspace/llm-memory-editability/results/parametric-architecture-main-v1", + "gpus": [ + 2, + 3, + 4, + 5 + ], + "evaluation_nodes": [ + 0, + 1000, + 2000, + 4000, + 8000, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "resume_checkpoint_interval": 1000, + "log_interval": 100, + "runs": [ + { + "name": "m8-init1", + "architecture": "M8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "w8-init1", + "architecture": "W8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "ihc8-init1", + "architecture": "IHC8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "hc8-init1", + "architecture": "HC8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "d8-init1", + "architecture": "D8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0 + }, + { + "name": "m8-init2", + "architecture": "M8", + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "w8-init2", + "architecture": "W8", + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "ihc8-init2", + "architecture": "IHC8", + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "hc8-init2", + "architecture": "HC8", + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "d8-init2", + "architecture": "D8", + "initialization": 811202, + "sampling_seed": 812202, + "dropout_seed": 813202, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0 + }, + { + "name": "m8-init3", + "architecture": "M8", + "initialization": 811203, + "sampling_seed": 812203, + "dropout_seed": 813203, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "w8-init3", + "architecture": "W8", + "initialization": 811203, + "sampling_seed": 812203, + "dropout_seed": 813203, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "ihc8-init3", + "architecture": "IHC8", + "initialization": 811203, + "sampling_seed": 812203, + "dropout_seed": 813203, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "hc8-init3", + "architecture": "HC8", + "initialization": 811203, + "sampling_seed": 812203, + "dropout_seed": 813203, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "d8-init3", + "architecture": "D8", + "initialization": 811203, + "sampling_seed": 812203, + "dropout_seed": 813203, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0 + } + ], + "runtime": { + "docker_context": "lm-memory", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "python": "/opt/conda/bin/python", + "cpus": 4, + "memory": "48g" + }, + "tracking": { + "enabled": true, + "entity": "zhusq20", + "project": "llm-memory-editability", + "group": "parametric-architecture-main-v1", + "mode": "online" + }, + "additional_sources": [ + "scripts/profile_parametric_architecture.py", + "scripts/audit_parametric_architecture_history.py", + "tests/test_parametric_architecture.py", + "tests/test_parametric_architecture_train.py", + "docs/development-artifacts/parametric-architecture-execution-v1/protocol.md", + "docs/development-artifacts/parametric-architecture-execution-v1/review.json", + "scripts/report_parametric_architecture.py", + "tests/test_parametric_architecture_report.py", + "tests/test_parametric_architecture_controller.py", + "configs/realworld-composition-confirmation-v1.json", + "docs/development-artifacts/parametric-architecture-execution-v1/gpu-preflight.json", + "docs/development-artifacts/parametric-architecture-execution-v1/historical-compatibility.json", + "docs/development-artifacts/parametric-architecture-design-v1/experiment-spec.json", + "docs/development-artifacts/parametric-architecture-design-v1/moe-design.json", + "docs/development-artifacts/parametric-architecture-design-v1/depth-connections-design.json", + "docs/development-artifacts/parametric-architecture-design-v1/looped-moe-literature.json", + "docs/development-artifacts/parametric-architecture-execution-v1/report-validation.json", + "docs/development-artifacts/parametric-architecture-execution-v1/tests.log" + ], + "launch_enabled": true, + "repository": "/ossfs/workspace/llm-memory-editability", + "source_root": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source", + "frozen_utc": "2026-10-03T20:42:53.677330+00:00", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/configs/realworld-composition-confirmation-v1.json": "e07ca3d7cfe0d14d3d3f36d2a778afd1dc2a688753117aee8008a7ec324d508e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/depth-connections-design.json": "a45f298be32ed1e029a96964020ada13eaf3443aafcb5f76f530919482efd30b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/experiment-spec.json": "4f2dd4f329ebca6731927c4604a4ba7a3fbf8145e3b3f0814b92cd9d5a5ad449", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/looped-moe-literature.json": "4218c5fbf0e1ddc0715c8f152b16dccd73fed52f6929cefaced5e17326adcc10", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/moe-design.json": "cb3a882b8289df8ca0baeb49af5665e743e7d28fd69361e6a4bc6e683612bcfb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/gpu-preflight.json": "d8edbe205f2e0387e137d5f31f0be5aafade4c61386b0d282076cd07fa550fc6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/historical-compatibility.json": "908517a309356502dfd0d8c31119ed51c410394e30558f750762b4c1870578d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/protocol.md": "32eb37d791dcefe9774b855eb25d791f2033c1502011534653d4058fd427d9a4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/report-validation.json": "4b4d694ef99058e9f7991e653a4390c43101352f23de465c1aa38fd7e050594d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/review.json": "9b571ff8574ed58b8f6fc8d71fa842adf701208e026a64addb3e9f5c6037bae7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/tests.log": "e89b8c3179615d3ecfd2aea087d38519e8cc887cbc42e5e8d75e2f8efc39cc5b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/audit_parametric_architecture_history.py": "837fe8a73d327bbd2cb231a2b0bfe2cce5c9cdd897718c7f270c992995d737a7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/execute_parametric_architecture.py": "3181a0ceeed57df55d18373805716a35ac551c455fd2b69dd366b1426be1f288", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/profile_parametric_architecture.py": "139c382840f190622f80d940777ccf6ef50678358a3ccbccd9d4bd0d964cef54", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/report_parametric_architecture.py": "d18bb2dedfe8c3db4a2aed857371095ac3850e51071632c62fc4f9bac481d788", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/run_parametric_architecture.py": "d3ea0e39702fb375342fe2b82c0abfa9d07f7e34e1efd3050c7ac2148755be8f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture.py": "5518c68c1523f73019edc44e56023663545af451055b36134afc07e0efe9a028", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture_controller.py": "493d45cf05261840cfba728e21ba6e7a1ddd84aa7d2c60d1bcf1998d8f374648", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture_report.py": "007c10e8d16208d91fa49fb6189d1f584786f4e94e2a9bdbe074f4d06f5013e0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture_train.py": "2cf9ee8c5299b6a49f110c6f1e04daf17d8c09a3f25f1ea96a67feb2441a9a03" + }, + "execution_lock": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-main-v1/execution-lock.json", + "git_commit": "12aa41ee7ce8e61cd2a594e2a1620ce45ed5a1c9", + "tokenizer_sha256": { + "merges.txt": "1ce1664773c50f3e0cc8842619a93edc4624525b728b188a9e0be33b7726adc5", + "special_tokens_map.json": "8bcf4e58d0970bbcb3b111a4c1e297c082fbf61253b14b3c0c8f2972ccb61ba4", + "tokenizer.json": "a6aa29bf8416d74ad795a73262b1aa3f985564ee338adbee7ffbc5861f78b6b8", + "tokenizer_config.json": "f7cd5e1168079212fdf834ed8113826afe1384b42c39024753c09d3eac9335c0", + "vocab.json": "3ba3c3109ff33976c4bd966589c11ee14fcaa1f4c9e5e154c2ed7f99d80709e7" + }, + "development_selection": "/ossfs/workspace/llm-memory-editability/results/parametric-architecture-development-v1/development-selection.json", + "reporting": { + "historical_config": "/ossfs/workspace/llm-memory-editability/configs/realworld-composition-confirmation-v1.json", + "historical_config_sha256": "e07ca3d7cfe0d14d3d3f36d2a778afd1dc2a688753117aee8008a7ec324d508e", + "historical_reuse_verified": true + } +} diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/amendment.md b/docs/development-artifacts/parametric-architecture-rolling-20261004/amendment.md new file mode 100644 index 0000000000000000000000000000000000000000..f0932cb4d374f7fd16786bc3568b85313dc04933 --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/amendment.md @@ -0,0 +1,9 @@ +# 2026-10-04 主实验分批提前启动修订 + +用户明确要求利用空闲GPU立即启动主实验。取消全体开发完成后统一启动的调度关卡，改为已完成两档32k开发且独立审计通过的架构可先启动。原冻结科学配置、训练源码和选参公式不修改。 + +GPU2/3/4先启动M8/W8/IHC8各自init1，采用原定面板0.5 atomic NLL + 0.5 train_composition NLL选参，同分取较低学习率。不使用测试表现选参。GPU5继续HC8开发。每个主实验从预定随机初始化开始，300k更新，并非开发权重续训。 + +仅替换旧调度进程，保留正在运行的开发容器、Docker客户端与W&B。新调度接管HC8退出与审计检查；全部开发完成后调用原冻结select_main生成完整主配置，逐项核对提前启动的spec、数据、源码、评价节点和运行环境。其余运行进入统一队列，GPU5随开发结束加入。原始冻结文件及历史运行不覆盖。提前运行配置及锁永久保留，最终报告包含这些运行且不重复启动。 + +主实验W&B在训练前启动；追踪或审计失败停止后续派发。每实验独立LM容器。交接证据见handoff.json，提前选择见early-selection.json，最终兼容核验由调度生成final-compatibility.json。相关10项测试及ruff检查通过。 diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/early-config.json b/docs/development-artifacts/parametric-architecture-rolling-20261004/early-config.json new file mode 100644 index 0000000000000000000000000000000000000000..c9eed724c5013e762124ba926f88724613ace022 --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/early-config.json @@ -0,0 +1,274 @@ +{ + "model": { + "vocab_size": 50257, + "positions": 1024, + "hidden_size": 768, + "attention_heads": 12, + "dropout": 0.1, + "mlp_ratio": 4, + "sequence_limit": 256, + "generation_limit": 64 + }, + "data_file": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/confirmation-v1.json", + "data_sha256": "f9df622fe531a77aea397d9ac5e46768e175a13c9d60f8ae3b687fdb0274be27", + "tokenizer": "/ossfs/workspace/llm-memory-editability/data/realworld-composition-v1/tokenizer", + "batch": "parametric-architecture-main-v1", + "phase": "main", + "results_root": "/ossfs/workspace/llm-memory-editability/results/parametric-architecture-main-v1", + "gpus": [ + 2, + 3, + 4, + 5 + ], + "evaluation_nodes": [ + 0, + 1000, + 2000, + 4000, + 8000, + 16000, + 32000, + 64000, + 128000, + 200000, + 300000 + ], + "resume_checkpoint_interval": 1000, + "log_interval": 100, + "runs": [ + { + "name": "m8-init1", + "architecture": "M8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "w8-init1", + "architecture": "W8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 5e-05, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + }, + { + "name": "ihc8-init1", + "architecture": "IHC8", + "initialization": 811201, + "sampling_seed": 812201, + "dropout_seed": 813201, + "steps": 300000, + "batch_size": 512, + "microbatch_size": 512, + "learning_rate": 0.0001, + "weight_decay": 0.1, + "warmup_steps": 2000, + "clip_grad_norm": 1.0, + "balance_coefficient": 0.01 + } + ], + "runtime": { + "docker_context": "lm-memory", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "python": "/opt/conda/bin/python", + "cpus": 4, + "memory": "48g" + }, + "tracking": { + "enabled": true, + "entity": "zhusq20", + "project": "llm-memory-editability", + "group": "parametric-architecture-main-v1", + "mode": "online" + }, + "additional_sources": [ + "scripts/profile_parametric_architecture.py", + "scripts/audit_parametric_architecture_history.py", + "tests/test_parametric_architecture.py", + "tests/test_parametric_architecture_train.py", + "docs/development-artifacts/parametric-architecture-execution-v1/protocol.md", + "docs/development-artifacts/parametric-architecture-execution-v1/review.json", + "scripts/report_parametric_architecture.py", + "tests/test_parametric_architecture_report.py", + "tests/test_parametric_architecture_controller.py", + "configs/realworld-composition-confirmation-v1.json", + "docs/development-artifacts/parametric-architecture-execution-v1/gpu-preflight.json", + "docs/development-artifacts/parametric-architecture-execution-v1/historical-compatibility.json", + "docs/development-artifacts/parametric-architecture-design-v1/experiment-spec.json", + "docs/development-artifacts/parametric-architecture-design-v1/moe-design.json", + "docs/development-artifacts/parametric-architecture-design-v1/depth-connections-design.json", + "docs/development-artifacts/parametric-architecture-design-v1/looped-moe-literature.json", + "docs/development-artifacts/parametric-architecture-execution-v1/report-validation.json", + "docs/development-artifacts/parametric-architecture-execution-v1/tests.log" + ], + "launch_enabled": true, + "repository": "/ossfs/workspace/llm-memory-editability", + "source_root": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source", + "frozen_utc": "2026-10-03T20:42:53.677330+00:00", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/configs/realworld-composition-confirmation-v1.json": "e07ca3d7cfe0d14d3d3f36d2a778afd1dc2a688753117aee8008a7ec324d508e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/depth-connections-design.json": "a45f298be32ed1e029a96964020ada13eaf3443aafcb5f76f530919482efd30b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/experiment-spec.json": "4f2dd4f329ebca6731927c4604a4ba7a3fbf8145e3b3f0814b92cd9d5a5ad449", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/looped-moe-literature.json": "4218c5fbf0e1ddc0715c8f152b16dccd73fed52f6929cefaced5e17326adcc10", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-design-v1/moe-design.json": "cb3a882b8289df8ca0baeb49af5665e743e7d28fd69361e6a4bc6e683612bcfb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/gpu-preflight.json": "d8edbe205f2e0387e137d5f31f0be5aafade4c61386b0d282076cd07fa550fc6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/historical-compatibility.json": "908517a309356502dfd0d8c31119ed51c410394e30558f750762b4c1870578d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/protocol.md": "32eb37d791dcefe9774b855eb25d791f2033c1502011534653d4058fd427d9a4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/report-validation.json": "4b4d694ef99058e9f7991e653a4390c43101352f23de465c1aa38fd7e050594d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/review.json": "9b571ff8574ed58b8f6fc8d71fa842adf701208e026a64addb3e9f5c6037bae7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/tests.log": "e89b8c3179615d3ecfd2aea087d38519e8cc887cbc42e5e8d75e2f8efc39cc5b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/audit_parametric_architecture_history.py": "837fe8a73d327bbd2cb231a2b0bfe2cce5c9cdd897718c7f270c992995d737a7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/execute_parametric_architecture.py": "3181a0ceeed57df55d18373805716a35ac551c455fd2b69dd366b1426be1f288", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/profile_parametric_architecture.py": "139c382840f190622f80d940777ccf6ef50678358a3ccbccd9d4bd0d964cef54", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/report_parametric_architecture.py": "d18bb2dedfe8c3db4a2aed857371095ac3850e51071632c62fc4f9bac481d788", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/run_parametric_architecture.py": "d3ea0e39702fb375342fe2b82c0abfa9d07f7e34e1efd3050c7ac2148755be8f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture.py": "5518c68c1523f73019edc44e56023663545af451055b36134afc07e0efe9a028", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture_controller.py": "493d45cf05261840cfba728e21ba6e7a1ddd84aa7d2c60d1bcf1998d8f374648", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture_report.py": "007c10e8d16208d91fa49fb6189d1f584786f4e94e2a9bdbe074f4d06f5013e0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/tests/test_parametric_architecture_train.py": "2cf9ee8c5299b6a49f110c6f1e04daf17d8c09a3f25f1ea96a67feb2441a9a03" + }, + "execution_lock": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-rolling-20261004/early-lock.json", + "git_commit": "12aa41ee7ce8e61cd2a594e2a1620ce45ed5a1c9", + "tokenizer_sha256": { + "merges.txt": "1ce1664773c50f3e0cc8842619a93edc4624525b728b188a9e0be33b7726adc5", + "special_tokens_map.json": "8bcf4e58d0970bbcb3b111a4c1e297c082fbf61253b14b3c0c8f2972ccb61ba4", + "tokenizer.json": "a6aa29bf8416d74ad795a73262b1aa3f985564ee338adbee7ffbc5861f78b6b8", + "tokenizer_config.json": "f7cd5e1168079212fdf834ed8113826afe1384b42c39024753c09d3eac9335c0", + "vocab.json": "3ba3c3109ff33976c4bd966589c11ee14fcaa1f4c9e5e154c2ed7f99d80709e7" + }, + "development_selection": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-rolling-20261004/early-selection.json", + "reporting": { + "historical_config": "/ossfs/workspace/llm-memory-editability/configs/realworld-composition-confirmation-v1.json", + "historical_config_sha256": "e07ca3d7cfe0d14d3d3f36d2a778afd1dc2a688753117aee8008a7ec324d508e", + "historical_reuse_verified": true + } +} diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/early-lock.json b/docs/development-artifacts/parametric-architecture-rolling-20261004/early-lock.json new file mode 100644 index 0000000000000000000000000000000000000000..fedb9c0aecd4ae9397ff8ce26344020d80e65613 --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/early-lock.json @@ -0,0 +1,8 @@ +{ + "config_sha256": "0489f71ebd8b49a509bda0a1c0a365843d9812200455911ef3360e813afa4b51", + "frozen_utc": "2026-10-04T00:08:45.778170+00:00", + "environment": { + "torch": "2.6.0+cu126", + "transformers": "4.40.0" + } +} diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/early-selection.json b/docs/development-artifacts/parametric-architecture-rolling-20261004/early-selection.json new file mode 100644 index 0000000000000000000000000000000000000000..941cdab685f4101202c56098659af9f58768ca26 --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/early-selection.json @@ -0,0 +1,61 @@ +{ + "rule": "32k fixed historical development panel: 0.5 per-example answer+EOS NLL atomic + 0.5 train_composition; lower LR wins exact tie. No main-test access. Any failure stops scheduling for review.", + "candidates": [ + { + "architecture": "M8", + "learning_rate": 5e-05, + "score": 0.0013079095223207354, + "run": "m8-lr5e5" + }, + { + "architecture": "M8", + "learning_rate": 0.0001, + "score": 4.049456405198477e-05, + "run": "m8-lr1e4" + }, + { + "architecture": "W8", + "learning_rate": 5e-05, + "score": 1.605441273485765e-05, + "run": "w8-lr5e5" + }, + { + "architecture": "W8", + "learning_rate": 0.0001, + "score": 2.4015881474929198e-05, + "run": "w8-lr1e4" + }, + { + "architecture": "IHC8", + "learning_rate": 5e-05, + "score": 0.0027583780558558487, + "run": "ihc8-lr5e5" + }, + { + "architecture": "IHC8", + "learning_rate": 0.0001, + "score": 0.0003974547820572338, + "run": "ihc8-lr1e4" + } + ], + "choices": { + "M8": { + "architecture": "M8", + "learning_rate": 0.0001, + "score": 4.049456405198477e-05, + "run": "m8-lr1e4" + }, + "W8": { + "architecture": "W8", + "learning_rate": 5e-05, + "score": 1.605441273485765e-05, + "run": "w8-lr5e5" + }, + "IHC8": { + "architecture": "IHC8", + "learning_rate": 0.0001, + "score": 0.0003974547820572338, + "run": "ihc8-lr1e4" + } + } +} diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/final-compatibility.json b/docs/development-artifacts/parametric-architecture-rolling-20261004/final-compatibility.json new file mode 100644 index 0000000000000000000000000000000000000000..08259093a37fff16f5a8c11a40e1a7d1054e8d67 --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/final-compatibility.json @@ -0,0 +1,10 @@ +{ + "passed": true, + "utc": "2026-10-04T00:53:58.993560+00:00", + "final_config_sha256": "1541476e281e9fae37b647333e7549d69956860a80de1d756cc9e4fe1b242359", + "early_runs": [ + "m8-init1", + "w8-init1", + "ihc8-init1" + ] +} diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/handoff.json b/docs/development-artifacts/parametric-architecture-rolling-20261004/handoff.json new file mode 100644 index 0000000000000000000000000000000000000000..49f9fb0bd6db7f74c30b6a804d42cc906b1e6a7c --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/handoff.json @@ -0,0 +1,48 @@ +{ + "old_controller": { + "pid": 185538, + "command": [ + "/ossfs/workspace/llm-memory-editability/.venv/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/source/scripts/execute_parametric_architecture.py", + "controller", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/parametric-architecture-development-v1/frozen-config.json" + ] + }, + "development_state": { + "state": "running", + "started_utc": "2026-10-03T20:43:13.164767+00:00", + "gpus": [ + 2, + 3, + 4, + 5 + ], + "completed": [ + "m8-lr5e5", + "ihc8-lr5e5", + "w8-lr5e5", + "hc8-lr5e5", + "m8-lr1e4", + "d8-lr1e4", + "ihc8-lr1e4", + "w8-lr1e4" + ], + "failed": [], + "active": { + "5": { + "name": "hc8-lr1e4", + "container": "lm-architecture-dd83c20dfc65a41b64e8", + "pid": 429207 + } + }, + "phase": "development", + "queued": [], + "updated_utc": "2026-10-04T00:08:43.764404+00:00" + }, + "early_config_sha256": "0489f71ebd8b49a509bda0a1c0a365843d9812200455911ef3360e813afa4b51", + "scheduler_sha256": "17e76aec3248464835a9adc4c0367849eccc3a74846e3ee01e4c52e0c205315f", + "authorization": "User requested starting main experiments on idle GPUs immediately", + "utc": "2026-10-04T00:08:45.806769+00:00" +} diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler-process.json b/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler-process.json new file mode 100644 index 0000000000000000000000000000000000000000..97ad7b3145f9d37e29d4424cdb977040d2601203 --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler-process.json @@ -0,0 +1 @@ +{"pid": 68177, "script": "/ossfs/workspace/llm-memory-editability/scripts/roll_parametric_architecture.py"} \ No newline at end of file diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler-source.py b/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler-source.py new file mode 100644 index 0000000000000000000000000000000000000000..e66bdb3b581b9cba247931b27cbcf76cc5dcfcfd --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler-source.py @@ -0,0 +1,301 @@ +"""User-authorized early main runs; retain the frozen trainer and final selector.""" + +import fcntl +import importlib.util +import math +import os +import signal +import subprocess +import sys +import time +import traceback +from pathlib import Path + +REPO = Path(__file__).resolve().parents[1] +DEV = REPO / "results/parametric-architecture-development-v1" +ART = REPO / "docs/development-artifacts/parametric-architecture-rolling-20261004" + + +def load_controller(config): + spec = importlib.util.spec_from_file_location( + "frozen_controller", + Path(config["source_root"]) / "scripts/execute_parametric_architecture.py", + ) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + return module + + +def early_config(c, config): + candidates, choices, runs = [], {}, [] + for architecture in ("M8", "W8", "IHC8"): + specs = [s for s in config["runs"] if s["architecture"] == architecture] + assert len(specs) == 2 and {s["learning_rate"] for s in specs} == {5e-5, 1e-4} + rows = [] + for spec in specs: + out = DEV / "runs" / spec["name"] + assert c.read(out / "audit.json")["passed"] is True + record = c.read(out / "learning.json")[-1] + assert record["step"] == spec["steps"] == 32000 + metrics = record["metrics"] + score = (metrics["atomic"]["nll"] + metrics["train_composition"]["nll"]) / 2 + assert math.isfinite(score) + rows.append( + dict( + architecture=architecture, + learning_rate=spec["learning_rate"], + score=score, + run=spec["name"], + ) + ) + selected = min(rows, key=lambda r: (r["score"], r["learning_rate"])) + candidates.extend(rows) + choices[architecture] = selected + spec = dict(next(s for s in specs if s["name"] == selected["run"])) + spec.update( + name=architecture.lower() + "-init1", + steps=300000, + initialization=811201, + sampling_seed=812201, + dropout_seed=813201, + ) + runs.append(spec) + t = config["transition"] + main = dict(config) + main.pop("transition") + main.update( + batch=t["batch"], + phase="main", + data_file=t["data_file"], + data_sha256=t["data_sha256"], + results_root=t["results_root"], + evaluation_nodes=[0, 1000, 2000, 4000, 8000, 16000, 32000, 64000, 128000, 200000, 300000], + development_selection=str(ART / "early-selection.json"), + tracking={**config["tracking"], "group": t["batch"]}, + runs=runs, + execution_lock=str(ART / "early-lock.json"), + ) + main["reporting"] = { + **t.get("reporting", {}), + "historical_reuse_verified": t["historical_reuse_verified"], + } + return main, dict(rule=t["selection_rule"], candidates=candidates, choices=choices) + + +def inspect(c, name): + return c.json.loads( + subprocess.check_output(["docker", "--context", "lm-memory", "inspect", name], text=True) + )[0] + + +def run(): + config = __import__("json").loads((DEV / "frozen-config.json").read_text()) + c = load_controller(config) + ART.mkdir(parents=True, exist_ok=True) + assert c.digest(DEV / "frozen-config.json") == c.read(config["execution_lock"])["config_sha256"] + for path, digest in config["source_files"].items(): + assert c.digest(path) == digest + early, selection = early_config(c, config) + assert c.digest(early["data_file"]) == early["data_sha256"] + root = Path(early["results_root"]) + assert not (root / "controller-process.json").exists(), "Main controller already exists" + state = c.read(DEV / "controller-state.json") + assert not state["failed"] and not state.get("tracking_failure") and not state["queued"] + assert list(state["active"]) == ["5"] + dev_item = state["active"]["5"] + assert inspect(c, dev_item["container"])["State"]["Running"] + devices = subprocess.check_output( + ["nvidia-smi", "--query-gpu=index,memory.used", "--format=csv,noheader,nounits"], text=True + ) + for line in devices.splitlines(): + gpu, memory = map(int, line.split(",")) + if gpu in (2, 3, 4): + assert memory < 1024, (gpu, memory) + old = c.read(DEV / "controller-process.json") + assert "execute_parametric_architecture.py" in Path(f"/proc/{old['pid']}/cmdline").read_text() + early_path = ART / "early-config.json" + assert not early_path.exists(), "Existing early freeze: inspect recovery before relaunch" + c.write(early_path, early) + c.write(ART / "early-selection.json", selection) + c.write( + early["execution_lock"], + dict( + config_sha256=c.digest(early_path), + frozen_utc=c.now(), + environment={"torch": "2.6.0+cu126", "transformers": "4.40.0"}, + ), + ) + c.write( + ART / "handoff.json", + dict( + old_controller=old, + development_state=state, + early_config_sha256=c.digest(early_path), + scheduler_sha256=c.digest(__file__), + authorization="User requested starting main experiments on idle GPUs immediately", + utc=c.now(), + ), + ) + # Signal only the scheduler PID. The active Docker client, container and tracker survive. + os.kill(old["pid"], signal.SIGTERM) + dev_lock = (DEV / "controller.lock").open("a") + fcntl.flock(dev_lock, fcntl.LOCK_EX) + root.mkdir(parents=True, exist_ok=True) + main_lock = (root / "controller.lock").open("a") + fcntl.flock(main_lock, fcntl.LOCK_EX | fcntl.LOCK_NB) + c.write(root / "controller-process.json", dict(pid=os.getpid(), command=sys.argv)) + c.write(DEV / "rolling-controller.json", dict(pid=os.getpid(), command=sys.argv)) + c.write(root / "frozen-config.json", early) + ms = dict( + state="running", + phase="main", + started_utc=c.now(), + gpus=[2, 3, 4, 5], + completed=[], + failed=[], + active={}, + queued=[], + pending_development=["HC8"], + ) + c.write(root / "controller-state.json", ms) + tracking = [ + str(REPO / ".venv-wandb/bin/python"), + "-u", + "-m", + "llm_memory_editability.interface_tracking", + "--root", + str(root), + "--defaults", + str(Path(config["source_root"]) / "configs/experiment-tracking-defaults.json"), + ] + log = (root / "tracking.log").open("a") + tracker = subprocess.Popen( + tracking, + env=c.host_env(config["source_root"]), + stdout=log, + stderr=subprocess.STDOUT, + start_new_session=True, + ) + c.write(root / "tracking-process.json", dict(pid=tracker.pid, command=tracking)) + deadline = time.monotonic() + 45 + while not (root / "tracking-ready.json").exists(): + assert tracker.poll() is None and time.monotonic() < deadline + time.sleep(0.2) + active, queue = {}, [(s, early, early_path) for s in early["runs"]] + final_path = None + try: + while active or queue or final_path is None: + assert tracker.poll() is None, "Main W&B tracker exited" + if final_path is None: + os.kill(c.read(DEV / "tracking-process.json")["pid"], 0) + info = inspect(c, dev_item["container"]) + if not info["State"]["Running"]: + out = DEV / "runs" / dev_item["name"] + c.write(out / "container-inspect.json", [info]) + assert info["State"]["ExitCode"] == 0 and c.read(out / "audit.json")["passed"] + state["completed"].append(dev_item["name"]) + state.update( + state="complete", active={}, finished_utc=c.now(), updated_utc=c.now() + ) + c.write(DEV / "controller-state.json", state) + final_path = c.select_main(config, DEV) + final = c.read(final_path) + for spec in early["runs"]: + assert spec == next(s for s in final["runs"] if s["name"] == spec["name"]) + for key in ("data_sha256", "source_files", "evaluation_nodes", "runtime"): + assert early[key] == final[key] + c.write(root / "frozen-config.json", final) + c.write( + ART / "final-compatibility.json", + dict( + passed=True, + utc=c.now(), + final_config_sha256=c.digest(final_path), + early_runs=[s["name"] for s in early["runs"]], + ), + ) + early_names = {s["name"] for s in early["runs"]} + queue.extend( + (s, final, final_path) + for s in final["runs"] + if s["name"] not in early_names + ) + ms["pending_development"] = [] + for gpu, item in list(active.items()): + if item["process"].poll() is None: + continue + item["log"].close() + out = root / "runs" / item["name"] + c.write(out / "container-inspect.json", [inspect(c, item["container"])]) + passed = item["process"].returncode == 0 and (out / "audit.json").exists() + passed = passed and c.read(out / "audit.json").get("passed") is True + ms["completed" if passed else "failed"].append(item["name"]) + del active[gpu] + if ms["failed"]: + queue.clear() + for gpu in [2, 3, 4] + ([5] if final_path is not None else []): + if gpu in active or not queue: + continue + spec, cfg, path = queue.pop(0) + out = root / "runs" / spec["name"] + assert not out.exists(), f"Duplicate run {out}" + out.mkdir(parents=True) + name, command = c.container_command(cfg, path, spec, out, gpu, 1) + c.write(out / "container-command-1.json", dict(name=name, command=command)) + worker_log = (out / "worker.log").open("a") + proc = subprocess.Popen(command, stdout=worker_log, stderr=subprocess.STDOUT) + active[gpu] = dict(process=proc, name=spec["name"], container=name, log=worker_log) + for _ in range(60): + try: + info = inspect(c, name) + except subprocess.CalledProcessError: + time.sleep(0.2) + continue + if info["State"].get("Running"): + c.write( + out / "container-runtime.json", + dict( + physical_gpu=gpu, + host_pid=info["State"]["Pid"], + container_id=info["Id"], + image=info["Image"], + cpus=cfg["runtime"]["cpus"], + memory=cfg["runtime"]["memory"], + ), + ) + break + time.sleep(0.2) + ms.update( + active={ + str(g): {k: x[k] for k in ("name", "container")} for g, x in active.items() + }, + queued=[s["name"] for s, _, _ in queue], + updated_utc=c.now(), + ) + c.write(root / "controller-state.json", ms) + time.sleep(3) + if not ms["failed"]: + subprocess.run( + [ + sys.executable, + str(Path(config["source_root"]) / "scripts/report_parametric_architecture.py"), + "--config", + str(final_path), + "--out", + str(root / "report"), + ], + env=c.host_env(config["source_root"]), + check=True, + ) + ms.update( + state="finished_with_failures" if ms["failed"] else "complete", finished_utc=c.now() + ) + c.write(root / "controller-state.json", ms) + except BaseException: + ms.update(state="controller_error", error=traceback.format_exc(), updated_utc=c.now()) + c.write(root / "controller-state.json", ms) + raise + + +if __name__ == "__main__": + run() diff --git a/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler.log b/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler.log new file mode 100644 index 0000000000000000000000000000000000000000..2dc6b188fbe8b2f6bfef54c65697e9b3a48c2c3e --- /dev/null +++ b/docs/development-artifacts/parametric-architecture-rolling-20261004/scheduler.log @@ -0,0 +1,15 @@ +error: no such object: lm-architecture-a609772b7596665d29fb +error: no such object: lm-architecture-beed9aeb7b3a62333571 +error: no such object: lm-architecture-e44eb0a8969681d4071e +error: no such object: lm-architecture-3d331581a1613a4ffd85 +error: no such object: lm-architecture-e14a1f19aada20b16760 +error: no such object: lm-architecture-fe3cb340daa4d28e26d8 +error: no such object: lm-architecture-b598cb1a4764bfaeeb71 +error: no such object: lm-architecture-4fc6713db2b9bad094db +error: no such object: lm-architecture-7acc43df79ac4d6b8689 +error: no such object: lm-architecture-e0258c9f90c6a06f507b +error: no such object: lm-architecture-5395aef4f16e6c1f9114 +error: no such object: lm-architecture-1e573385491f7985f05d +error: no such object: lm-architecture-61af1141bc3e19bad789 +error: no such object: lm-architecture-beeeec3d46986483b71d +error: no such object: lm-architecture-70969259f23e4245f265 diff --git a/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/PKG-INFO b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..1b329a89d021e1c2d99eb92d7450d61e081f5fe8 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/PKG-INFO @@ -0,0 +1,102 @@ +Metadata-Version: 2.4 +Name: llm-memory-editability +Version: 0.1.0 +Summary: Controlled experiments on shared representations and knowledge editability +Project-URL: Repository, https://github.com/zhusq20/llm-memory-editability +Project-URL: Issues, https://github.com/zhusq20/llm-memory-editability/issues +Requires-Python: >=3.10 +Description-Content-Type: text/markdown +Requires-Dist: numpy<3,>=1.26 +Provides-Extra: dev +Requires-Dist: pytest<10,>=8; extra == "dev" +Requires-Dist: ruff<1,>=0.6; extra == "dev" +Provides-Extra: neural +Requires-Dist: torch<3,>=2.5; extra == "neural" +Provides-Extra: bios-original +Requires-Dist: torch==2.8.0; extra == "bios-original" +Requires-Dist: tokenizers==0.22.2; extra == "bios-original" +Provides-Extra: analysis +Requires-Dist: matplotlib<4,>=3.9; extra == "analysis" + +# LLM Memory: Learning and Editability + +研究参数中的知识存储与多跳计算原理。当前关注原子事实的存储表征、可组合存储的容量与稳定性；Loop用于操纵计算深度。本轮直接使用完整标准Transformer/Loop作受控训练；历史简化架构证据与完整预训练模型复核各保留其适用范围。 + +## 当前状态 + +- **标准Transformer/Loop事实负载实验已完成。** 完整GPT-2形式，标准1/2/3层及共享1层循环2/3次，宽256、4头、MLP1024，全部参数训练。24条开发、30条新世界确认及2条事后诊断，56端点重载通过。1024/6144事实、测试必要事实曝光匹配；标准1层新组合32.66%/22.10%，Loop×2为40.66%/32.27%，Loop×3为43.33%/37.00%。单跳接近100%，严格无组合角色池仍0%–1.76%；标准2层一个终点发生训练退化，完整保留，不作容量证据。见[完整结果与边界](docs/results.md#standard-storage-composition)、[逐世界图](docs/development-artifacts/storage-composition-v1/confirmation/per-world.png)和[完成清单](docs/development-artifacts/storage-composition-v1/completion-manifest.json)。 + +- **完整Qwen3-0.6B快速开发已完成。** 三臂共同独立复习后，分开/无关联拼接/关联拼接的两单跳均100%，未训练两跳为6.25%/4.69%/15.63%，自主两次调用均100%。六个更新/原事实复习分支及九端点重载完成：新单跳全部学会，直接两跳更新收益依条件变化，未回放事实保持明显下降。一个世界、一个种子，尚非新世界确认或唯一MLP机制。见[完整结果](docs/results.md#small-lm-composition-v2)、[图](docs/development-artifacts/small-lm-composition-v2/comparison.png)与[研究计划](docs/hebbian-learning-plan-v1.md#next-experiment)。 + +- **简化架构的机制验证：固定调用过程后的新知识组合已完成。** 开发校准后，三个新世界×两个初始化×两臂的12项正式比较及全部重载核验通过。普通交叉熵/加入统一输出表示约束，原知识两跳99.46%/99.97%；冻结注意力并换入只接受单跳训练的新事实MLP后，单跳均100%、两跳66.39%/94.66%，六配对均改善。它支持其架构条件下的知识复用收益，是继续检验真实LM的依据，不直接等同于真实LM结论。见[结果](docs/results.md#memory-reuse)、[主图](docs/development-artifacts/memory-reuse-v1/confirmation/report/comparison.png)与[完成清单](docs/development-artifacts/memory-reuse-v1/completion-manifest.json)。 + +- **组合练习结构与跨事实迁移实验已完成。** 3条开发、三个新世界×两个初始化×两臂的12条正式训练，15端点和99节点审计通过。逐事实组合使用次数、唯一训练链数及token边际匹配；广搭配相对受限搭配，熟悉事实新链15.11%→66.30%，严格独立目标1.57%→2.16%，单跳与自主两次调用均100%。主要收益是局部搭配泛化，跨事实调用仍很弱。见[结果](docs/results.md#text-structure)、[学习曲线](docs/development-artifacts/text-structure-v1/confirmation/comparison.png)与[完成核验](docs/development-artifacts/text-structure-v1/confirmation/verified-completion.json)。 + +- **损失来源与参数变化实验已完成。** 4条开发、24条冻结后续续训及72个参数互换状态均完成。原子＋背景组合训练与仅原子训练的目标组合为84.59%/43.10%，两者单跳100%；四臂显示强交互。后者换入中性对照分支的MLP后恢复至70.96%，单跳仍100%，注意力也有部分贡献。既有三个世界的结果支持部分训练归因，尚非唯一内部机制。见[完整结果](docs/results.md#text-loss-source)、[参数互换图](docs/development-artifacts/text-loss-source-v1/followup/report/weights.png)与[完成清单](docs/development-artifacts/text-loss-source-v1/completion-manifest.json)。 + +- **文本预训练归因比较已完成。** 3条开发、18条新世界确认训练及36个节点内部干预全部完成。独立事实/联合上下文/再加入组合结果的未见组合正确率为69.16%/82.88%/99.84%，全部单跳100%；P0/P1严格匹配文本及监督，但P1收益在第三个世界反向。局部状态可交换，但单点转向未随能力单调增强。见[结果与边界](docs/results.md#text-pretraining)、[图](docs/development-artifacts/text-pretrain-v1/report/comparison.png)与[完成清单](docs/development-artifacts/text-pretrain-v1/completion-manifest.json)。 + +- **bioS同权重诊断已完成。** 18端点、6,912条生成复核通过；MP任务权重常用问法下，直接月份奇偶76.56%，自主提取再判断100%。预训练主体张量在适配后完全保持，原生续写下降不能称为主体记忆被擦除。见[同权重结果](docs/results.md#bios-same-weight)。 + +- **循环监督与长循环检查已完成。** 2条开发与12条后续续训、18个模型的R1…64检查完成并通过审计。多终点相对单终点的OOD差异在R4/R8/R16为+16.98/+1.25/−12.26个百分点，未建立普遍稳健性改善。原始状态持续移动且幅度增长，归一化变化变小不能直接解释为不动点收敛。见[结果与限制](docs/results.md#grok-loop-supervision)、[曲线](docs/development-artifacts/grok-loop-supervision-v1/followup-report/comparison.png)和[完成清单](docs/development-artifacts/grok-loop-supervision-v1/completion-manifest.json)。 + +- **事实使用经历的四臂开发及三个新世界确认已完成。** 共16条128k训练、320个节点，直接回答与自主调用重载审计全部通过。三个确认世界中，同一事实组接受组合训练、对应原子重复、仅基础单跳训练后的未见组合正确率为100.00%/25.01%/3.01%；主比较涉及的原子事实全部答对。见[完整结果](docs/results.md#grok-usage)、[形成曲线](docs/development-artifacts/grok-usage-v1/report-confirmation/role-aligned-learning-confirmation.png)与[完成清单](docs/development-artifacts/grok-usage-v1/completion-manifest.json)。 + +- **Loop Transformer 对照实验已完成。** 15条开发、6条敏感性及90条正式训练，111个终点GPU审计、210个机制评价和42个循环扫描全部完成。三个正式世界中，循环模型两/三/四跳的ID留出组合均接近100%；两跳L2的纯OOD组合为6.29%，三/四跳仍约1%。见[完整结果](docs/results.md#grok-loop)、[主汇总](docs/development-artifacts/grok-loop-v1/main-report/summary.json)和[完成清单](docs/development-artifacts/grok-loop-v1/completion-manifest.json)。 +上述历史两到四跳小Transformer只对最终答案与EOS计算交叉熵；新增文本批次从随机初始化做完整下一词元训练。 + +- **连续评分复盘与两跳同桥供体实验已完成。** 111条轨迹、2,997节点的连续评分未显示大幅模式切换，低OOD表现也不是EOS失分。在图定义的共同供体子集上，L1/L2使用ID首跳完整状态的正确率为40.58%/38.94%，使用OOD供体为8.06%/12.33%；三个世界差异均为正。该子集只覆盖3.11%–8.16%的OOD题目，本次只评价35个既有端点、零新增训练。见[复盘](docs/results.md#grok-loop-continuous)与[供体结果](docs/results.md#grok-loop-same-bridge)。 +- **历史配方的深度比较已完成。** 两跳2/3/4层留出准确率为96.44%/98.40%/98.29%；三跳独立世界的3/4层均值为90.29%/97.04%。该配方的四跳6层尚未学会大部分留出组合，区别于新Loop批次的开发结果。见[完整结果](docs/results.md#depth-hop-extension)与[八页对比图册](docs/development-artifacts/hop-depth-comparison-v1/complete-comparison.pdf)。 +- **历史首跳状态置换已完成。** 两层模型第一块的r1位置换入纯首跳供体后，89.31%的答案正确转向新路径，h位置对照为0.13%。该历史批次未拆分注意力与MLP；Loop批次已单独完成子层比较。见[历史机制结果](docs/results.md#grok-depth-bridge)与[Loop机制报告](docs/development-artifacts/grok-loop-v1/mechanism-report/summary.json)。 +- **原版bioS复盘、18端点抽样重载与36个预训练权重评价已完成。** 570万预测复算一致；规范六属性QA的S/M/MP为5.07%/35.65%/99.96%，留出问法仍有缺口。固定人物中，S的日期和出生地原生续写均100%，之后QA仅14.06%/1.56%，因此弱QA不能简单解释为没有记住事实。日期比较的训练题能答对，新日期对即使给真值仍失败，规则泛化前提尚未建立。见[完整结果](docs/results.md#bios-original)与[形成曲线](docs/development-artifacts/bios-original-trajectory-v1/native-attribute-curves.png)。100k矩阵与日期更新未执行。 + +**当前受控训练证据支持：事实可被单跳提取，并不保证它能用于未见组合；组合使用经历带来原子重复无法补足的收益。** 既有状态置换进一步支持首跳信息的下游可用性差异。历史使用经历比较采用一个初始化；新增文本比较采用三个世界、两个初始化，仍未定位唯一内部机制，也不直接建立自然语言预训练定律。 + +当前主线是[参数存储与多跳计算原理](docs/hebbian-learning-plan-v1.md#frontier-question-20261001)。既有组合经历、记忆替换和循环计算结果提供工具，尚未建立可组合存储的容量规律；原子掌握、有效操作、目标曝光和参数预算分别核查。知识更新开发保留为历史支线，旧低组合分数或长循环单跳退化不直接解释为存储能力上限。 + +## 文档入口 + +| 文档 | 内容 | +| --- | --- | +| [当前计划与理论依据](docs/hebbian-learning-plan-v1.md) | 训练目标、下一轮实验、理论与待办 | +| [研究结果汇总](docs/results.md) | 各批次最终状态、核心数字、适用范围及产物 | +| [实验协议](docs/experimental-protocol.md) | 统一评价与记录规范、脚本依赖的历史契约 | +| [冻结模型两跳报告](docs/twohop-frozen-results-v1.md) | Qwen两跳实测、精度复核和复现命令 | +| [开发指南](CONTRIBUTING.md) | 安装、检查、数据与文档维护规则 | + +## 开发与复现 + +Python ≥3.10。仓库中的超大结果JSON使用Git LFS保存；克隆后运行 `git lfs install` 和 `git lfs pull` 获取完整文件。 + +CPU工程检查环境： + +```bash +python -m venv .venv +source .venv/bin/activate +python -m pip install torch --index-url https://download.pytorch.org/whl/cpu +python -m pip install -e '.[neural,dev]' +python -m pytest +ruff check . +ruff format --check . +``` + +绘图依赖：`python -m pip install -e '.[analysis]'`。原版bioS的专用依赖见 [pyproject.toml](pyproject.toml) 的 `bios-original`；正式GPU实验使用各批冻结环境和配置，CPU环境不代替实验环境。 + +完整测试还需要相关批次的本地 `data/`、`results/` 与固定模型tokenizer，按下述复现入口准备；这些大体积产物默认不随仓库提交。 + +只读查看原版bioS状态： + +```bash +.venv/bin/python scripts/run_bios_original.py status +``` + +完整运行命令与前提见[当前计划](docs/hebbian-learning-plan-v1.md#reproduction)及[两跳报告](docs/twohop-frozen-results-v1.md)。旧批次的精确复现使用对应源码快照、配置和冻结契约。 + +## 目录 + +- `src/llm_memory_editability/`：模型、数据与实验实现；`scripts/`：运行、分析、审计入口；`tests/`：契约检查。 +- `configs/`：批次配置、来源清单和环境记录。 +- `docs/development-artifacts/`：冻结设计、源码快照、小型汇总、图表和审计证据，保持原始内容。 +- `data/`、`results/`、`checkpoints/`：本地数据、模型和大体积运行产物，默认不纳入版本控制。 + +`memory-editability` 与 `memory-editability-neural` 是工程示例入口，其结果不作为正式研究证据。 diff --git a/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/SOURCES.txt b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..57598bd9f3f29fcb7ba59d5379be82ef955c8b96 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/SOURCES.txt @@ -0,0 +1,197 @@ +README.md +pyproject.toml +src/llm_memory_editability/__init__.py +src/llm_memory_editability/__main__.py +src/llm_memory_editability/architecture_bridge.py +src/llm_memory_editability/architecture_bridge_toy.py +src/llm_memory_editability/bios_analysis.py +src/llm_memory_editability/bios_branch.py +src/llm_memory_editability/bios_capacity.py +src/llm_memory_editability/bios_causal_paths.py +src/llm_memory_editability/bios_confirmation_stats.py +src/llm_memory_editability/bios_context_control.py +src/llm_memory_editability/bios_context_gradient.py +src/llm_memory_editability/bios_cross.py +src/llm_memory_editability/bios_cross_continue.py +src/llm_memory_editability/bios_cross_scale.py +src/llm_memory_editability/bios_cross_train.py +src/llm_memory_editability/bios_data.py +src/llm_memory_editability/bios_direction.py +src/llm_memory_editability/bios_direction_cross.py +src/llm_memory_editability/bios_direction_formation.py +src/llm_memory_editability/bios_direction_refresh.py +src/llm_memory_editability/bios_edit.py +src/llm_memory_editability/bios_followup.py +src/llm_memory_editability/bios_measure.py +src/llm_memory_editability/bios_mechanism_causal.py +src/llm_memory_editability/bios_mechanism_causal_v2.py +src/llm_memory_editability/bios_mechanism_edit.py +src/llm_memory_editability/bios_mechanism_interventions.py +src/llm_memory_editability/bios_model.py +src/llm_memory_editability/bios_organization.py +src/llm_memory_editability/bios_organization_train.py +src/llm_memory_editability/bios_original_data.py +src/llm_memory_editability/bios_original_diagnostics.py +src/llm_memory_editability/bios_original_model.py +src/llm_memory_editability/bios_original_report.py +src/llm_memory_editability/bios_original_train.py +src/llm_memory_editability/bios_path_diagnostics.py +src/llm_memory_editability/bios_path_minimal.py +src/llm_memory_editability/bios_path_transfer.py +src/llm_memory_editability/bios_readout_control.py +src/llm_memory_editability/bios_relation_response.py +src/llm_memory_editability/bios_shortcut_confirmation.py +src/llm_memory_editability/bios_shortcut_confirmation_sets.py +src/llm_memory_editability/bios_shortcut_control.py +src/llm_memory_editability/bios_shortcut_edit.py +src/llm_memory_editability/bios_shortcut_edit_v2.py +src/llm_memory_editability/bios_shortcut_matched_edit.py +src/llm_memory_editability/bios_train.py +src/llm_memory_editability/cli.py +src/llm_memory_editability/experiments.py +src/llm_memory_editability/grok_depth.py +src/llm_memory_editability/grok_depth_bridge.py +src/llm_memory_editability/grok_depth_data.py +src/llm_memory_editability/grok_depth_extension.py +src/llm_memory_editability/grok_loop_data.py +src/llm_memory_editability/grok_loop_mechanism.py +src/llm_memory_editability/grok_loop_model.py +src/llm_memory_editability/grok_loop_same_bridge.py +src/llm_memory_editability/grok_loop_same_bridge_eval.py +src/llm_memory_editability/grok_loop_supervision.py +src/llm_memory_editability/grok_loop_train.py +src/llm_memory_editability/grok_multihop.py +src/llm_memory_editability/grok_multihop_data.py +src/llm_memory_editability/grok_usage_data.py +src/llm_memory_editability/grok_usage_train.py +src/llm_memory_editability/hebbian_data.py +src/llm_memory_editability/hebbian_followup.py +src/llm_memory_editability/hebbian_future.py +src/llm_memory_editability/hebbian_interface.py +src/llm_memory_editability/hebbian_learning.py +src/llm_memory_editability/hebbian_model.py +src/llm_memory_editability/hebbian_statistics.py +src/llm_memory_editability/hebbian_train.py +src/llm_memory_editability/low_rank.py +src/llm_memory_editability/memory_reuse.py +src/llm_memory_editability/neural.py +src/llm_memory_editability/neural_data.py +src/llm_memory_editability/neural_models.py +src/llm_memory_editability/qwen_constraints.py +src/llm_memory_editability/qwen_path_learning.py +src/llm_memory_editability/qwen_path_train.py +src/llm_memory_editability/small_lm_composition.py +src/llm_memory_editability/small_lm_followup.py +src/llm_memory_editability/storage_composition.py +src/llm_memory_editability/text_loss_source.py +src/llm_memory_editability/text_pretrain.py +src/llm_memory_editability/text_structure.py +src/llm_memory_editability/twohop_depth.py +src/llm_memory_editability.egg-info/PKG-INFO +src/llm_memory_editability.egg-info/SOURCES.txt +src/llm_memory_editability.egg-info/dependency_links.txt +src/llm_memory_editability.egg-info/entry_points.txt +src/llm_memory_editability.egg-info/requires.txt +src/llm_memory_editability.egg-info/top_level.txt +tests/test_architecture_bridge.py +tests/test_architecture_bridge_algebra.py +tests/test_architecture_bridge_endpoints.py +tests/test_architecture_bridge_report.py +tests/test_architecture_bridge_toy.py +tests/test_bios.py +tests/test_bios_analysis.py +tests/test_bios_capacity.py +tests/test_bios_causal_paths.py +tests/test_bios_confirmation_common_u.py +tests/test_bios_confirmation_report.py +tests/test_bios_confirmation_stats.py +tests/test_bios_confirmation_summary.py +tests/test_bios_context_control.py +tests/test_bios_context_gradient.py +tests/test_bios_context_summary.py +tests/test_bios_cross.py +tests/test_bios_cross_continue.py +tests/test_bios_cross_scale.py +tests/test_bios_direction.py +tests/test_bios_direction_analysis.py +tests/test_bios_direction_cross.py +tests/test_bios_direction_formation.py +tests/test_bios_followup.py +tests/test_bios_followup_summary.py +tests/test_bios_mechanism_causal.py +tests/test_bios_mechanism_causal_summary.py +tests/test_bios_mechanism_causal_v2.py +tests/test_bios_mechanism_edit.py +tests/test_bios_mechanism_error_summary.py +tests/test_bios_mechanism_interventions.py +tests/test_bios_mechanism_path_summary.py +tests/test_bios_organization_data.py +tests/test_bios_organization_report.py +tests/test_bios_organization_runner.py +tests/test_bios_organization_train.py +tests/test_bios_original.py +tests/test_bios_original_diagnostics.py +tests/test_bios_original_report.py +tests/test_bios_original_trajectory.py +tests/test_bios_path_diagnostics.py +tests/test_bios_path_minimal.py +tests/test_bios_path_minimal_summary.py +tests/test_bios_path_transfer.py +tests/test_bios_path_transfer_summary.py +tests/test_bios_readout_control.py +tests/test_bios_relation_response.py +tests/test_bios_shortcut_confirmation.py +tests/test_bios_shortcut_confirmation_preparation.py +tests/test_bios_shortcut_confirmation_sets.py +tests/test_bios_shortcut_confirmation_worker.py +tests/test_bios_shortcut_control.py +tests/test_bios_shortcut_edit.py +tests/test_bios_shortcut_edit_v2.py +tests/test_bios_shortcut_matched_edit.py +tests/test_grok_depth_bridge.py +tests/test_grok_depth_data.py +tests/test_grok_depth_extension.py +tests/test_grok_depth_extension_report.py +tests/test_grok_depth_report.py +tests/test_grok_depth_training.py +tests/test_grok_loop_atomic_timing.py +tests/test_grok_loop_confirmation_data_audit.py +tests/test_grok_loop_continuous.py +tests/test_grok_loop_data.py +tests/test_grok_loop_finalize.py +tests/test_grok_loop_mechanism.py +tests/test_grok_loop_mechanism_report.py +tests/test_grok_loop_model.py +tests/test_grok_loop_postprocess.py +tests/test_grok_loop_recurrence.py +tests/test_grok_loop_report.py +tests/test_grok_loop_same_bridge.py +tests/test_grok_loop_same_bridge_eval.py +tests/test_grok_loop_same_bridge_report.py +tests/test_grok_loop_schedule.py +tests/test_grok_loop_supervision.py +tests/test_grok_multihop.py +tests/test_grok_usage_data.py +tests/test_grok_usage_report.py +tests/test_grok_usage_training.py +tests/test_hebbian_data.py +tests/test_hebbian_followup.py +tests/test_hebbian_future.py +tests/test_hebbian_interface.py +tests/test_hebbian_learning.py +tests/test_hebbian_reporting.py +tests/test_low_rank.py +tests/test_memory_reuse.py +tests/test_neural.py +tests/test_qwen_constraints.py +tests/test_qwen_path_learning.py +tests/test_small_lm_composition.py +tests/test_small_lm_followup.py +tests/test_storage_composition.py +tests/test_storage_continuation.py +tests/test_text_loss_source.py +tests/test_text_pretrain.py +tests/test_text_structure.py +tests/test_twohop_depth.py +tests/test_twohop_frozen_contract.py +tests/test_twohop_hebbian_contract.py \ No newline at end of file diff --git a/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/dependency_links.txt b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/entry_points.txt b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..4ea18da621bd49e1fd367f01cdac6588b0228b6a --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/entry_points.txt @@ -0,0 +1,3 @@ +[console_scripts] +memory-editability = llm_memory_editability.cli:main +memory-editability-neural = llm_memory_editability.neural:main diff --git a/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/requires.txt b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/requires.txt new file mode 100644 index 0000000000000000000000000000000000000000..d1124bb5624c21ddead08e844b5e1dde79db8aa4 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/requires.txt @@ -0,0 +1,15 @@ +numpy<3,>=1.26 + +[analysis] +matplotlib<4,>=3.9 + +[bios-original] +torch==2.8.0 +tokenizers==0.22.2 + +[dev] +pytest<10,>=8 +ruff<1,>=0.6 + +[neural] +torch<3,>=2.5 diff --git a/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/top_level.txt b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..a31adc20b30f8c1ba6c6480f2b5e67b9f94941f5 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/confirmation/confirmation-source/src/llm_memory_editability.egg-info/top_level.txt @@ -0,0 +1 @@ +llm_memory_editability diff --git a/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/PKG-INFO b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..1b329a89d021e1c2d99eb92d7450d61e081f5fe8 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/PKG-INFO @@ -0,0 +1,102 @@ +Metadata-Version: 2.4 +Name: llm-memory-editability +Version: 0.1.0 +Summary: Controlled experiments on shared representations and knowledge editability +Project-URL: Repository, https://github.com/zhusq20/llm-memory-editability +Project-URL: Issues, https://github.com/zhusq20/llm-memory-editability/issues +Requires-Python: >=3.10 +Description-Content-Type: text/markdown +Requires-Dist: numpy<3,>=1.26 +Provides-Extra: dev +Requires-Dist: pytest<10,>=8; extra == "dev" +Requires-Dist: ruff<1,>=0.6; extra == "dev" +Provides-Extra: neural +Requires-Dist: torch<3,>=2.5; extra == "neural" +Provides-Extra: bios-original +Requires-Dist: torch==2.8.0; extra == "bios-original" +Requires-Dist: tokenizers==0.22.2; extra == "bios-original" +Provides-Extra: analysis +Requires-Dist: matplotlib<4,>=3.9; extra == "analysis" + +# LLM Memory: Learning and Editability + +研究参数中的知识存储与多跳计算原理。当前关注原子事实的存储表征、可组合存储的容量与稳定性；Loop用于操纵计算深度。本轮直接使用完整标准Transformer/Loop作受控训练；历史简化架构证据与完整预训练模型复核各保留其适用范围。 + +## 当前状态 + +- **标准Transformer/Loop事实负载实验已完成。** 完整GPT-2形式，标准1/2/3层及共享1层循环2/3次，宽256、4头、MLP1024，全部参数训练。24条开发、30条新世界确认及2条事后诊断，56端点重载通过。1024/6144事实、测试必要事实曝光匹配；标准1层新组合32.66%/22.10%，Loop×2为40.66%/32.27%，Loop×3为43.33%/37.00%。单跳接近100%，严格无组合角色池仍0%–1.76%；标准2层一个终点发生训练退化，完整保留，不作容量证据。见[完整结果与边界](docs/results.md#standard-storage-composition)、[逐世界图](docs/development-artifacts/storage-composition-v1/confirmation/per-world.png)和[完成清单](docs/development-artifacts/storage-composition-v1/completion-manifest.json)。 + +- **完整Qwen3-0.6B快速开发已完成。** 三臂共同独立复习后，分开/无关联拼接/关联拼接的两单跳均100%，未训练两跳为6.25%/4.69%/15.63%，自主两次调用均100%。六个更新/原事实复习分支及九端点重载完成：新单跳全部学会，直接两跳更新收益依条件变化，未回放事实保持明显下降。一个世界、一个种子，尚非新世界确认或唯一MLP机制。见[完整结果](docs/results.md#small-lm-composition-v2)、[图](docs/development-artifacts/small-lm-composition-v2/comparison.png)与[研究计划](docs/hebbian-learning-plan-v1.md#next-experiment)。 + +- **简化架构的机制验证：固定调用过程后的新知识组合已完成。** 开发校准后，三个新世界×两个初始化×两臂的12项正式比较及全部重载核验通过。普通交叉熵/加入统一输出表示约束，原知识两跳99.46%/99.97%；冻结注意力并换入只接受单跳训练的新事实MLP后，单跳均100%、两跳66.39%/94.66%，六配对均改善。它支持其架构条件下的知识复用收益，是继续检验真实LM的依据，不直接等同于真实LM结论。见[结果](docs/results.md#memory-reuse)、[主图](docs/development-artifacts/memory-reuse-v1/confirmation/report/comparison.png)与[完成清单](docs/development-artifacts/memory-reuse-v1/completion-manifest.json)。 + +- **组合练习结构与跨事实迁移实验已完成。** 3条开发、三个新世界×两个初始化×两臂的12条正式训练，15端点和99节点审计通过。逐事实组合使用次数、唯一训练链数及token边际匹配；广搭配相对受限搭配，熟悉事实新链15.11%→66.30%，严格独立目标1.57%→2.16%，单跳与自主两次调用均100%。主要收益是局部搭配泛化，跨事实调用仍很弱。见[结果](docs/results.md#text-structure)、[学习曲线](docs/development-artifacts/text-structure-v1/confirmation/comparison.png)与[完成核验](docs/development-artifacts/text-structure-v1/confirmation/verified-completion.json)。 + +- **损失来源与参数变化实验已完成。** 4条开发、24条冻结后续续训及72个参数互换状态均完成。原子＋背景组合训练与仅原子训练的目标组合为84.59%/43.10%，两者单跳100%；四臂显示强交互。后者换入中性对照分支的MLP后恢复至70.96%，单跳仍100%，注意力也有部分贡献。既有三个世界的结果支持部分训练归因，尚非唯一内部机制。见[完整结果](docs/results.md#text-loss-source)、[参数互换图](docs/development-artifacts/text-loss-source-v1/followup/report/weights.png)与[完成清单](docs/development-artifacts/text-loss-source-v1/completion-manifest.json)。 + +- **文本预训练归因比较已完成。** 3条开发、18条新世界确认训练及36个节点内部干预全部完成。独立事实/联合上下文/再加入组合结果的未见组合正确率为69.16%/82.88%/99.84%，全部单跳100%；P0/P1严格匹配文本及监督，但P1收益在第三个世界反向。局部状态可交换，但单点转向未随能力单调增强。见[结果与边界](docs/results.md#text-pretraining)、[图](docs/development-artifacts/text-pretrain-v1/report/comparison.png)与[完成清单](docs/development-artifacts/text-pretrain-v1/completion-manifest.json)。 + +- **bioS同权重诊断已完成。** 18端点、6,912条生成复核通过；MP任务权重常用问法下，直接月份奇偶76.56%，自主提取再判断100%。预训练主体张量在适配后完全保持，原生续写下降不能称为主体记忆被擦除。见[同权重结果](docs/results.md#bios-same-weight)。 + +- **循环监督与长循环检查已完成。** 2条开发与12条后续续训、18个模型的R1…64检查完成并通过审计。多终点相对单终点的OOD差异在R4/R8/R16为+16.98/+1.25/−12.26个百分点，未建立普遍稳健性改善。原始状态持续移动且幅度增长，归一化变化变小不能直接解释为不动点收敛。见[结果与限制](docs/results.md#grok-loop-supervision)、[曲线](docs/development-artifacts/grok-loop-supervision-v1/followup-report/comparison.png)和[完成清单](docs/development-artifacts/grok-loop-supervision-v1/completion-manifest.json)。 + +- **事实使用经历的四臂开发及三个新世界确认已完成。** 共16条128k训练、320个节点，直接回答与自主调用重载审计全部通过。三个确认世界中，同一事实组接受组合训练、对应原子重复、仅基础单跳训练后的未见组合正确率为100.00%/25.01%/3.01%；主比较涉及的原子事实全部答对。见[完整结果](docs/results.md#grok-usage)、[形成曲线](docs/development-artifacts/grok-usage-v1/report-confirmation/role-aligned-learning-confirmation.png)与[完成清单](docs/development-artifacts/grok-usage-v1/completion-manifest.json)。 + +- **Loop Transformer 对照实验已完成。** 15条开发、6条敏感性及90条正式训练，111个终点GPU审计、210个机制评价和42个循环扫描全部完成。三个正式世界中，循环模型两/三/四跳的ID留出组合均接近100%；两跳L2的纯OOD组合为6.29%，三/四跳仍约1%。见[完整结果](docs/results.md#grok-loop)、[主汇总](docs/development-artifacts/grok-loop-v1/main-report/summary.json)和[完成清单](docs/development-artifacts/grok-loop-v1/completion-manifest.json)。 +上述历史两到四跳小Transformer只对最终答案与EOS计算交叉熵；新增文本批次从随机初始化做完整下一词元训练。 + +- **连续评分复盘与两跳同桥供体实验已完成。** 111条轨迹、2,997节点的连续评分未显示大幅模式切换，低OOD表现也不是EOS失分。在图定义的共同供体子集上，L1/L2使用ID首跳完整状态的正确率为40.58%/38.94%，使用OOD供体为8.06%/12.33%；三个世界差异均为正。该子集只覆盖3.11%–8.16%的OOD题目，本次只评价35个既有端点、零新增训练。见[复盘](docs/results.md#grok-loop-continuous)与[供体结果](docs/results.md#grok-loop-same-bridge)。 +- **历史配方的深度比较已完成。** 两跳2/3/4层留出准确率为96.44%/98.40%/98.29%；三跳独立世界的3/4层均值为90.29%/97.04%。该配方的四跳6层尚未学会大部分留出组合，区别于新Loop批次的开发结果。见[完整结果](docs/results.md#depth-hop-extension)与[八页对比图册](docs/development-artifacts/hop-depth-comparison-v1/complete-comparison.pdf)。 +- **历史首跳状态置换已完成。** 两层模型第一块的r1位置换入纯首跳供体后，89.31%的答案正确转向新路径，h位置对照为0.13%。该历史批次未拆分注意力与MLP；Loop批次已单独完成子层比较。见[历史机制结果](docs/results.md#grok-depth-bridge)与[Loop机制报告](docs/development-artifacts/grok-loop-v1/mechanism-report/summary.json)。 +- **原版bioS复盘、18端点抽样重载与36个预训练权重评价已完成。** 570万预测复算一致；规范六属性QA的S/M/MP为5.07%/35.65%/99.96%，留出问法仍有缺口。固定人物中，S的日期和出生地原生续写均100%，之后QA仅14.06%/1.56%，因此弱QA不能简单解释为没有记住事实。日期比较的训练题能答对，新日期对即使给真值仍失败，规则泛化前提尚未建立。见[完整结果](docs/results.md#bios-original)与[形成曲线](docs/development-artifacts/bios-original-trajectory-v1/native-attribute-curves.png)。100k矩阵与日期更新未执行。 + +**当前受控训练证据支持：事实可被单跳提取，并不保证它能用于未见组合；组合使用经历带来原子重复无法补足的收益。** 既有状态置换进一步支持首跳信息的下游可用性差异。历史使用经历比较采用一个初始化；新增文本比较采用三个世界、两个初始化，仍未定位唯一内部机制，也不直接建立自然语言预训练定律。 + +当前主线是[参数存储与多跳计算原理](docs/hebbian-learning-plan-v1.md#frontier-question-20261001)。既有组合经历、记忆替换和循环计算结果提供工具，尚未建立可组合存储的容量规律；原子掌握、有效操作、目标曝光和参数预算分别核查。知识更新开发保留为历史支线，旧低组合分数或长循环单跳退化不直接解释为存储能力上限。 + +## 文档入口 + +| 文档 | 内容 | +| --- | --- | +| [当前计划与理论依据](docs/hebbian-learning-plan-v1.md) | 训练目标、下一轮实验、理论与待办 | +| [研究结果汇总](docs/results.md) | 各批次最终状态、核心数字、适用范围及产物 | +| [实验协议](docs/experimental-protocol.md) | 统一评价与记录规范、脚本依赖的历史契约 | +| [冻结模型两跳报告](docs/twohop-frozen-results-v1.md) | Qwen两跳实测、精度复核和复现命令 | +| [开发指南](CONTRIBUTING.md) | 安装、检查、数据与文档维护规则 | + +## 开发与复现 + +Python ≥3.10。仓库中的超大结果JSON使用Git LFS保存；克隆后运行 `git lfs install` 和 `git lfs pull` 获取完整文件。 + +CPU工程检查环境： + +```bash +python -m venv .venv +source .venv/bin/activate +python -m pip install torch --index-url https://download.pytorch.org/whl/cpu +python -m pip install -e '.[neural,dev]' +python -m pytest +ruff check . +ruff format --check . +``` + +绘图依赖：`python -m pip install -e '.[analysis]'`。原版bioS的专用依赖见 [pyproject.toml](pyproject.toml) 的 `bios-original`；正式GPU实验使用各批冻结环境和配置，CPU环境不代替实验环境。 + +完整测试还需要相关批次的本地 `data/`、`results/` 与固定模型tokenizer，按下述复现入口准备；这些大体积产物默认不随仓库提交。 + +只读查看原版bioS状态： + +```bash +.venv/bin/python scripts/run_bios_original.py status +``` + +完整运行命令与前提见[当前计划](docs/hebbian-learning-plan-v1.md#reproduction)及[两跳报告](docs/twohop-frozen-results-v1.md)。旧批次的精确复现使用对应源码快照、配置和冻结契约。 + +## 目录 + +- `src/llm_memory_editability/`：模型、数据与实验实现；`scripts/`：运行、分析、审计入口；`tests/`：契约检查。 +- `configs/`：批次配置、来源清单和环境记录。 +- `docs/development-artifacts/`：冻结设计、源码快照、小型汇总、图表和审计证据，保持原始内容。 +- `data/`、`results/`、`checkpoints/`：本地数据、模型和大体积运行产物，默认不纳入版本控制。 + +`memory-editability` 与 `memory-editability-neural` 是工程示例入口，其结果不作为正式研究证据。 diff --git a/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/SOURCES.txt b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..57598bd9f3f29fcb7ba59d5379be82ef955c8b96 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/SOURCES.txt @@ -0,0 +1,197 @@ +README.md +pyproject.toml +src/llm_memory_editability/__init__.py +src/llm_memory_editability/__main__.py +src/llm_memory_editability/architecture_bridge.py +src/llm_memory_editability/architecture_bridge_toy.py +src/llm_memory_editability/bios_analysis.py +src/llm_memory_editability/bios_branch.py +src/llm_memory_editability/bios_capacity.py +src/llm_memory_editability/bios_causal_paths.py +src/llm_memory_editability/bios_confirmation_stats.py +src/llm_memory_editability/bios_context_control.py +src/llm_memory_editability/bios_context_gradient.py +src/llm_memory_editability/bios_cross.py +src/llm_memory_editability/bios_cross_continue.py +src/llm_memory_editability/bios_cross_scale.py +src/llm_memory_editability/bios_cross_train.py +src/llm_memory_editability/bios_data.py +src/llm_memory_editability/bios_direction.py +src/llm_memory_editability/bios_direction_cross.py +src/llm_memory_editability/bios_direction_formation.py +src/llm_memory_editability/bios_direction_refresh.py +src/llm_memory_editability/bios_edit.py +src/llm_memory_editability/bios_followup.py +src/llm_memory_editability/bios_measure.py +src/llm_memory_editability/bios_mechanism_causal.py +src/llm_memory_editability/bios_mechanism_causal_v2.py +src/llm_memory_editability/bios_mechanism_edit.py +src/llm_memory_editability/bios_mechanism_interventions.py +src/llm_memory_editability/bios_model.py +src/llm_memory_editability/bios_organization.py +src/llm_memory_editability/bios_organization_train.py +src/llm_memory_editability/bios_original_data.py +src/llm_memory_editability/bios_original_diagnostics.py +src/llm_memory_editability/bios_original_model.py +src/llm_memory_editability/bios_original_report.py +src/llm_memory_editability/bios_original_train.py +src/llm_memory_editability/bios_path_diagnostics.py +src/llm_memory_editability/bios_path_minimal.py +src/llm_memory_editability/bios_path_transfer.py +src/llm_memory_editability/bios_readout_control.py +src/llm_memory_editability/bios_relation_response.py +src/llm_memory_editability/bios_shortcut_confirmation.py +src/llm_memory_editability/bios_shortcut_confirmation_sets.py +src/llm_memory_editability/bios_shortcut_control.py +src/llm_memory_editability/bios_shortcut_edit.py +src/llm_memory_editability/bios_shortcut_edit_v2.py +src/llm_memory_editability/bios_shortcut_matched_edit.py +src/llm_memory_editability/bios_train.py +src/llm_memory_editability/cli.py +src/llm_memory_editability/experiments.py +src/llm_memory_editability/grok_depth.py +src/llm_memory_editability/grok_depth_bridge.py +src/llm_memory_editability/grok_depth_data.py +src/llm_memory_editability/grok_depth_extension.py +src/llm_memory_editability/grok_loop_data.py +src/llm_memory_editability/grok_loop_mechanism.py +src/llm_memory_editability/grok_loop_model.py +src/llm_memory_editability/grok_loop_same_bridge.py +src/llm_memory_editability/grok_loop_same_bridge_eval.py +src/llm_memory_editability/grok_loop_supervision.py +src/llm_memory_editability/grok_loop_train.py +src/llm_memory_editability/grok_multihop.py +src/llm_memory_editability/grok_multihop_data.py +src/llm_memory_editability/grok_usage_data.py +src/llm_memory_editability/grok_usage_train.py +src/llm_memory_editability/hebbian_data.py +src/llm_memory_editability/hebbian_followup.py +src/llm_memory_editability/hebbian_future.py +src/llm_memory_editability/hebbian_interface.py +src/llm_memory_editability/hebbian_learning.py +src/llm_memory_editability/hebbian_model.py +src/llm_memory_editability/hebbian_statistics.py +src/llm_memory_editability/hebbian_train.py +src/llm_memory_editability/low_rank.py +src/llm_memory_editability/memory_reuse.py +src/llm_memory_editability/neural.py +src/llm_memory_editability/neural_data.py +src/llm_memory_editability/neural_models.py +src/llm_memory_editability/qwen_constraints.py +src/llm_memory_editability/qwen_path_learning.py +src/llm_memory_editability/qwen_path_train.py +src/llm_memory_editability/small_lm_composition.py +src/llm_memory_editability/small_lm_followup.py +src/llm_memory_editability/storage_composition.py +src/llm_memory_editability/text_loss_source.py +src/llm_memory_editability/text_pretrain.py +src/llm_memory_editability/text_structure.py +src/llm_memory_editability/twohop_depth.py +src/llm_memory_editability.egg-info/PKG-INFO +src/llm_memory_editability.egg-info/SOURCES.txt +src/llm_memory_editability.egg-info/dependency_links.txt +src/llm_memory_editability.egg-info/entry_points.txt +src/llm_memory_editability.egg-info/requires.txt +src/llm_memory_editability.egg-info/top_level.txt +tests/test_architecture_bridge.py +tests/test_architecture_bridge_algebra.py +tests/test_architecture_bridge_endpoints.py +tests/test_architecture_bridge_report.py +tests/test_architecture_bridge_toy.py +tests/test_bios.py +tests/test_bios_analysis.py +tests/test_bios_capacity.py +tests/test_bios_causal_paths.py +tests/test_bios_confirmation_common_u.py +tests/test_bios_confirmation_report.py +tests/test_bios_confirmation_stats.py +tests/test_bios_confirmation_summary.py +tests/test_bios_context_control.py +tests/test_bios_context_gradient.py +tests/test_bios_context_summary.py +tests/test_bios_cross.py +tests/test_bios_cross_continue.py +tests/test_bios_cross_scale.py +tests/test_bios_direction.py +tests/test_bios_direction_analysis.py +tests/test_bios_direction_cross.py +tests/test_bios_direction_formation.py +tests/test_bios_followup.py +tests/test_bios_followup_summary.py +tests/test_bios_mechanism_causal.py +tests/test_bios_mechanism_causal_summary.py +tests/test_bios_mechanism_causal_v2.py +tests/test_bios_mechanism_edit.py +tests/test_bios_mechanism_error_summary.py +tests/test_bios_mechanism_interventions.py +tests/test_bios_mechanism_path_summary.py +tests/test_bios_organization_data.py +tests/test_bios_organization_report.py +tests/test_bios_organization_runner.py +tests/test_bios_organization_train.py +tests/test_bios_original.py +tests/test_bios_original_diagnostics.py +tests/test_bios_original_report.py +tests/test_bios_original_trajectory.py +tests/test_bios_path_diagnostics.py +tests/test_bios_path_minimal.py +tests/test_bios_path_minimal_summary.py +tests/test_bios_path_transfer.py +tests/test_bios_path_transfer_summary.py +tests/test_bios_readout_control.py +tests/test_bios_relation_response.py +tests/test_bios_shortcut_confirmation.py +tests/test_bios_shortcut_confirmation_preparation.py +tests/test_bios_shortcut_confirmation_sets.py +tests/test_bios_shortcut_confirmation_worker.py +tests/test_bios_shortcut_control.py +tests/test_bios_shortcut_edit.py +tests/test_bios_shortcut_edit_v2.py +tests/test_bios_shortcut_matched_edit.py +tests/test_grok_depth_bridge.py +tests/test_grok_depth_data.py +tests/test_grok_depth_extension.py +tests/test_grok_depth_extension_report.py +tests/test_grok_depth_report.py +tests/test_grok_depth_training.py +tests/test_grok_loop_atomic_timing.py +tests/test_grok_loop_confirmation_data_audit.py +tests/test_grok_loop_continuous.py +tests/test_grok_loop_data.py +tests/test_grok_loop_finalize.py +tests/test_grok_loop_mechanism.py +tests/test_grok_loop_mechanism_report.py +tests/test_grok_loop_model.py +tests/test_grok_loop_postprocess.py +tests/test_grok_loop_recurrence.py +tests/test_grok_loop_report.py +tests/test_grok_loop_same_bridge.py +tests/test_grok_loop_same_bridge_eval.py +tests/test_grok_loop_same_bridge_report.py +tests/test_grok_loop_schedule.py +tests/test_grok_loop_supervision.py +tests/test_grok_multihop.py +tests/test_grok_usage_data.py +tests/test_grok_usage_report.py +tests/test_grok_usage_training.py +tests/test_hebbian_data.py +tests/test_hebbian_followup.py +tests/test_hebbian_future.py +tests/test_hebbian_interface.py +tests/test_hebbian_learning.py +tests/test_hebbian_reporting.py +tests/test_low_rank.py +tests/test_memory_reuse.py +tests/test_neural.py +tests/test_qwen_constraints.py +tests/test_qwen_path_learning.py +tests/test_small_lm_composition.py +tests/test_small_lm_followup.py +tests/test_storage_composition.py +tests/test_storage_continuation.py +tests/test_text_loss_source.py +tests/test_text_pretrain.py +tests/test_text_structure.py +tests/test_twohop_depth.py +tests/test_twohop_frozen_contract.py +tests/test_twohop_hebbian_contract.py \ No newline at end of file diff --git a/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/dependency_links.txt b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/entry_points.txt b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..4ea18da621bd49e1fd367f01cdac6588b0228b6a --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/entry_points.txt @@ -0,0 +1,3 @@ +[console_scripts] +memory-editability = llm_memory_editability.cli:main +memory-editability-neural = llm_memory_editability.neural:main diff --git a/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/requires.txt b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/requires.txt new file mode 100644 index 0000000000000000000000000000000000000000..d1124bb5624c21ddead08e844b5e1dde79db8aa4 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/requires.txt @@ -0,0 +1,15 @@ +numpy<3,>=1.26 + +[analysis] +matplotlib<4,>=3.9 + +[bios-original] +torch==2.8.0 +tokenizers==0.22.2 + +[dev] +pytest<10,>=8 +ruff<1,>=0.6 + +[neural] +torch<3,>=2.5 diff --git a/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/top_level.txt b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..a31adc20b30f8c1ba6c6480f2b5e67b9f94941f5 --- /dev/null +++ b/docs/development-artifacts/realworld-composition-v1/development-source/src/llm_memory_editability.egg-info/top_level.txt @@ -0,0 +1 @@ +llm_memory_editability diff --git a/docs/experimental-protocol.md b/docs/experimental-protocol.md index 85d9aba5970c12374dd8d4ffb014e4b79b13f054..446439586cceb6d57d43e03e62b41d058a49a02d 100644 --- a/docs/experimental-protocol.md +++ b/docs/experimental-protocol.md @@ -1,6 +1,6 @@ # 实验协议与复现约定 -更新：2026-10-02。当前研究方向、理论与待办见[计划](hebbian-learning-plan-v1.md)，最终状态与数字见[结果汇总](results.md)。本协议集中保留共同规则及现有脚本需要读取的历史契约。历史完整协议已存在于[执行时冻结快照](development-artifacts/qwen-path-learning-v1/execution-source/docs/experimental-protocol.md)，不再维护另一份状态长文。 +更新：2026-10-02。当前研究方向、理论与待办见[计划](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/hebbian-learning-plan-v1.md)，最终状态与数字见[结果汇总](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/results.md)。本协议集中保留共同规则及现有脚本需要读取的历史契约。历史完整协议已存在于[执行时冻结快照](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/development-artifacts/qwen-path-learning-v1/execution-source/docs/experimental-protocol.md)，不再维护另一份状态长文。 ## 研究范围与证据 @@ -21,7 +21,7 @@ 每批分别记录初始化来源、计损失的词元位置、样本配比和可更新参数；“预训练/微调”不能代替这些定义。同为交叉熵，既可监督全序列，也可只监督答案。 -grok两/三/四跳为随机初始化、全部参数训练、最终实体与EOS等权监督；没有中间答案目标。训练EOS时使用正确答案，生成评价时使用模型自产答案。历史深度批次按合并数据集逐例采样，改变组合数量也改变混合比例；Loop批次每批固定32条单跳与224条组合，两流分别均匀遍历，组合覆盖变化不改变每步单跳占比。公式和实现入口见[当前训练目标](hebbian-learning-plan-v1.md#training-objective)。 +grok两/三/四跳为随机初始化、全部参数训练、最终实体与EOS等权监督；没有中间答案目标。训练EOS时使用正确答案，生成评价时使用模型自产答案。历史深度批次按合并数据集逐例采样，改变组合数量也改变混合比例；Loop批次每批固定32条单跳与224条组合，两流分别均匀遍历，组合覆盖变化不改变每步单跳占比。公式和实现入口见[当前训练目标](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/hebbian-learning-plan-v1.md#training-objective)。 ## 评价与统计 @@ -33,11 +33,11 @@ E成功、D传播、U损伤及局部保持分别报告。损伤分母只含编 按独立世界或预定案例单位做配对分析，同一模型的种子、层、查询和精度重测的相关性须说明。置信区间、多重校正和预定/事后分析分别注明。历史确认与停止规则保留；后续探索可以研究小效应与负结果，不事后删臂。 -少量世界优先公开逐世界差值和原始分母；查询级区间不解释为跨世界泛化区间。机制干预先指定部位、供体可访问信息及覆盖；逐题最佳部位只作探索上界，激活修复不等于参数编辑。新批的竞争解释、有限比较与预算见[整改设计](hebbian-learning-plan-v1.md#research-rectification)。 +少量世界优先公开逐世界差值和原始分母；查询级区间不解释为跨世界泛化区间。机制干预先指定部位、供体可访问信息及覆盖；逐题最佳部位只作探索上界，激活修复不等于参数编辑。新批的竞争解释、有限比较与预算见[整改设计](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/hebbian-learning-plan-v1.md#research-rectification)。 -存储与多跳计算的新比较以[根本问题定义](hebbian-learning-plan-v1.md#frontier-question-20261001)为准：独立参数量、事实负载、逻辑跳数与展开轮数分别记录；固定词表和参数时，不能随实体数增长Embedding后称等容量。区分规定输入上的单跳提取、链上全部必要事实与完整多跳结果；逐轮检查原子和格式，轮数不假定等于跳数。原子事实、目标路径及等价首尾关系的训练曝光分开核查；每事实曝光匹配与总训练计算匹配是不同协议。有限训练的负载边界称经验容量，不直接作为架构上限。旧批评分不追溯改变。 +存储与多跳计算的新比较以[根本问题定义](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/hebbian-learning-plan-v1.md#frontier-question-20261001)为准：独立参数量、事实负载、逻辑跳数与展开轮数分别记录；固定词表和参数时，不能随实体数增长Embedding后称等容量。区分规定输入上的单跳提取、链上全部必要事实与完整多跳结果；逐轮检查原子和格式，轮数不假定等于跳数。原子事实、目标路径及等价首尾关系的训练曝光分开核查；每事实曝光匹配与总训练计算匹配是不同协议。有限训练的负载边界称经验容量，不直接作为架构上限。旧批评分不追溯改变。 -本次用户授权的storage-composition-v1使用完整标准Transformer和Loop Transformer，全部Embedding、位置、Q/K/V、输出投影、残差、LayerNorm和4倍MLP保留并训练；过度简化记忆网络仅保留历史结论。固定词表和测试子图，低/高负载为1024/6144，必要原子总曝光匹配。主评分、背景操作、严格无组合角色池与轮数诊断见[当前计划](hebbian-learning-plan-v1.md#standard-storage-composition)和[开发修订](development-artifacts/storage-composition-v1/amendment-20261001.md)。 +本次用户授权的storage-composition-v1使用完整标准Transformer和Loop Transformer，全部Embedding、位置、Q/K/V、输出投影、残差、LayerNorm和4倍MLP保留并训练；过度简化记忆网络仅保留历史结论。固定词表和测试子图，低/高负载为1024/6144，必要原子总曝光匹配。主评分、背景操作、严格无组合角色池与轮数诊断见[当前计划](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/hebbian-learning-plan-v1.md#standard-storage-composition)和[开发修订](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/development-artifacts/storage-composition-v1/amendment-20261001.md)。 ## 执行与复现 @@ -49,7 +49,7 @@ E成功、D传播、U损伤及局部保持分别报告。损伤分母只含编 ## 历史契约兼容段落 -以下§16–18属于已经完成的历史实验，其中的“下一步”“本轮未执行”均为当时判断；最新结论见[历史批次汇总](results.md#organization)。保留原编号及正文，是因为 `bios_context_gradient`、`bios_followup`、`bios_path_transfer`、`bios_path_minimal` 和Jacobian脚本按这些标题提取契约。原冻结版本仍以各批 `preregistration.md` 为准；这里仅将已删除报告的链接改指向统一汇总。 +以下§16–18属于已经完成的历史实验，其中的“下一步”“本轮未执行”均为当时判断；最新结论见[历史批次汇总](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/results.md#organization)。保留原编号及正文，是因为 `bios_context_gradient`、`bios_followup`、`bios_path_transfer`、`bios_path_minimal` 和Jacobian脚本按这些标题提取契约。原冻结版本仍以各批 `preregistration.md` 为准；这里仅将已删除报告的链接改指向统一汇总。 ## 16. v2.11 上下文统计与真实早期梯度：独立开发实验 @@ -87,7 +87,7 @@ E成功、D传播、U损伤及局部保持分别报告。损伤分母只含编 主答案终点的position平均余弦为0.294758，8个配对均为正（0.285295–0.314340），shuffled为0.003046；32/128步分别为0.417277/0.370646，shuffled为0.004572/0.004762。全部24个嵌套对比的position方向预测均高于对应shuffled，不把它们视为24个独立世界。token版本方向几乎相同；含位置版本改善幅度但仍不准确：0/32/128步相对向量误差1.155656/2.323419/2.642302，范数比0.944658/2.555004/2.841119。全部答案对比的原始向量误差均大于零预测基线1；未事后拟合比例。EOS方向预测接近零或不稳定，combined余弦为0.260532/0.317912/0.339491。 -阻断跨事实注意力后，主投影梯度的最大相对消减残差4.33437×10⁻⁸；监督bigram不变、上下文统计差异消失，符合配对控制。当前结论是“数据统计提供部分可重复的早期方向信号，但原始向量近似不准”，值得继续追踪，尚不解释后期知识组织或编辑收益。下一项有区分度的建议是复用同状态，保留完整网络和反传、仅改为均匀注意力，区分QK选择与省略下游变换两种误差来源；本轮未执行。完整边界与数据见[实验报告](results.md#organization)和[全部数值](development-artifacts/context-gradient-v1/report.md)。 +阻断跨事实注意力后，主投影梯度的最大相对消减残差4.33437×10⁻⁸；监督bigram不变、上下文统计差异消失，符合配对控制。当前结论是“数据统计提供部分可重复的早期方向信号，但原始向量近似不准”，值得继续追踪，尚不解释后期知识组织或编辑收益。下一项有区分度的建议是复用同状态，保留完整网络和反传、仅改为均匀注意力，区分QK选择与省略下游变换两种误差来源；本轮未执行。完整边界与数据见[实验报告](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/results.md#organization)和[全部数值](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/development-artifacts/context-gradient-v1/report.md)。 ## 17. v2.12 组织×编辑监督配比与第一层均匀注意力对照 @@ -135,7 +135,7 @@ R接近U而U仍远离P时，优先检查P省略的残差/下游变换及完整 保留50%类平衡作为行为候选、25%作为较温和参照；不继续把它称为组织匹配劣势的修复。下一轮验证需要区分平均传播收益与组织匹配条件获益较少两项预测；连接v2.9时在共同E39目标下重做对照，其事实均匀基线为3/39，不能混用E93的3/93。独立新世界的具体矩阵围绕更新后的预测另立；本轮不因完整机制未识别而否决部分行为收益。 -机制下一项优先做第一层输出投影的逐位置梯度分解：在完整均匀第一层网络中区分监督位置与非监督位置经后续层反传的贡献，再替换零残差基线误差信号，以定位统计预测缺口。使用真实反向信号的分解只算诊断，不冒称独立语料预测器。本轮未新增自然语言或大规模训练。[完整结果](results.md#organization)与[完成审计](development-artifacts/followup-v1/audit.json)保留所有配比、配对块、分母、曲线与来源。 +机制下一项优先做第一层输出投影的逐位置梯度分解：在完整均匀第一层网络中区分监督位置与非监督位置经后续层反传的贡献，再替换零残差基线误差信号，以定位统计预测缺口。使用真实反向信号的分解只算诊断，不冒称独立语料预测器。本轮未新增自然语言或大规模训练。[完整结果](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/results.md#organization)与[完成审计](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/development-artifacts/followup-v1/audit.json)保留所有配比、配对块、分母、曲线与来源。 ## 18. v2.13 Transformer计算路径与知识促进／干扰 @@ -217,9 +217,9 @@ full：原模型完整反传。no_cross：仅将第5–7层attention输入到输 阶段A/B、两层最小模型及局部Jacobian核验均已完成。成熟模型的24个冲突案例中，23个正确答案概率增加，却24个都失去相对冲突答案的竞争优势；原主步长未改变自由生成。最小模型表明高度相似特征仍可对应相反更新，真实参数敏感度不可省略。跨位置路径在2/6案例有局部因果作用，但48条完整轨迹中的冲突配对查询仍全部失败；不将局部改善写成普遍修复。 -下一候选转为控制真实MLP特征可变性及新旧答案对比方向，并联合评价源成功、竞争margin及实际生成；具体训练范围、预算和独立世界另锁。本轮不继续增加样本或挑层追求正结果。所有阶段、负结果、数学适用范围与完整计数见[结果报告](results.md#organization)。 +下一候选转为控制真实MLP特征可变性及新旧答案对比方向，并联合评价源成功、竞争margin及实际生成；具体训练范围、预算和独立世界另锁。本轮不继续增加样本或挑层追求正结果。所有阶段、负结果、数学适用范围与完整计数见[结果报告](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/results.md#organization)。 -本轮最终相关测试39项通过，13个新增Python文件的格式／静态检查通过；文档本地链接与全部冻结输入核验通过。完成清单见[阶段A/B完成清单](development-artifacts/path-transfer-v1/completion.json)及[最小模型与数学核验完成清单](development-artifacts/path-minimal-v1/completion.json)。 +本轮最终相关测试39项通过，13个新增Python文件的格式／静态检查通过；文档本地链接与全部冻结输入核验通过。完成清单见[阶段A/B完成清单](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/development-artifacts/path-transfer-v1/completion.json)及[最小模型与数学核验完成清单](https://huggingface.co/datasets/zsqzz/llm-memory-editability/blob/main/docs/development-artifacts/path-minimal-v1/completion.json)。 ### 18.10 完成后复盘：区分监督信息、局部可行性与特征重组 diff --git a/docs/hebbian-learning-plan-v1.md b/docs/hebbian-learning-plan-v1.md index 3713222f16c28e206ee2408114284217bccda2e9..229670b3be0b1943267242214f76e58a7a791ce8 100644 --- a/docs/hebbian-learning-plan-v1.md +++ b/docs/hebbian-learning-plan-v1.md @@ -1,5 +1,161 @@ # 当前研究计划与理论依据 + +## 2026-10-06：从知识存储密度到组合容量 + +**状态：2026-10-06首批9项扫描及17项连续调用/学习控制全部完成；09:04按用户批准的新计划启动论文方法支持的组合覆盖与知识负载曲线。** 工作标题保持 **Transformers as Associative Memories: Exploring the Scaling of Storage and Compositional Recall**。主轴为知识信息量相对于参数量的增长，先研究两跳；少量宽度和架构比较仍等待有效原生组合参照。 + +**当前执行：** [冻结协议](development-artifacts/composition-data-curves-v1/protocol.md)、[配置](development-artifacts/composition-data-curves-v1/frozen-config.json)、[状态](../results/composition-data-curves-v1/controller-state.json)。复用已成功的随机关系图、答案/EOS目标及Grokking优化配方，明确校准固定大词表、较小宽度和更密图的适配。开发只用一个世界，成功后冻结深度与曝光；正式在三个新世界中保持图/测试集不变，取7档嵌套独立组合支持，分别在128k等计算节点和每例4000曝光节点比较。开发需要长预算时统一采用预定8000曝光，不按正式测试选配方。 + +09:44按用户授权[扩展并行调度](development-artifacts/composition-data-curves-parallel-20261006/amendment.md)：GPU0–4立即用于新曲线，GPU6–7在旧OO批次全部完成并审计后接入，GPU5保持旧HC8。原训练、数据、门槛与预算不变；负载任务按实体数降序调度。恢复入口为该修订冻结脚本及schedule.json。 + +09:07开发128k固定终点已通过：四层全原子/训练组合100%、完整II86.64%（门槛用固定评价集86.62%），两层II52.34%保留。现冻结四层、464,896参数、4000曝光，21条正式支持矩阵已开始；没有使用预定512k延长分支。最高负载为1.692 bits/参数，正式结果尚未齐全。 + +三个正式低负载锚点均通过后，固定词表、参数量、phi及每例曝光，扩展N=128–4096的6档闭合图。独立知识熵为16N log2 N，组合支持不增加独立bits；不同N的图事实并非嵌套，更多更新也改变累计优化/衰减，因此本轮建立受控行为曲线，不直接证明串扰机制。预定正式新训练36条，开发2条或4条，最多40条/64 GPU小时；GPU0–1独立LM容器，全部轨迹、低分和失败保留并在线追踪。 + +首批普通2层、宽64、102,976参数的0.159/0.398/1.352/5.171 bits/参数四档，主扫描原子100.00%/93.34%/21.81%/1.39%，II为0.68%/0.54%/0.83%/1.32%。固定目标背景对照也已全部完成。低负载组合尚未学成，故不能把当前C₂不达标解释成容量压缩或串扰。用户要求的完整探测及保留全部结果已经落实，见[结果](results.md#capacity-scaling-development-v1)。 + +**下一步已执行的关键比较。** 结合Physics 3.3的知识计量/曝光、Grokked Transformers的拟合后泛化与正则，以及compositionality gap的必要原子及显式调用比较，冻结[连续调用与学习成本协议](development-artifacts/capacity-recall-controls-v1/protocol.md)。对9个旧检查点比较直接组合、自主两次原子调用、错桥与oracle；H=256/1024/4096各训练原子曝光匹配及总计算匹配两条控制；最低负载同父状态延长280k更新，比较后期wd=.01/.1。新训练8条，GPU0–1独立容器，W&B在线，最多18 GPU小时含审计；旧GPU2–7矩阵继续运行。 + +本轮首先回答容量曲线中的失败属于已存知识不可在原生任务中复用、派生监督的学习成本，还是有限优化。外部拆题成功只建立该调用协议的可用性，不能替代原生组合能力或证明内部串扰。只有建立可解释的原生组合曲线，才继续少量宽度与新世界容量确认。任务、模型和原评分保持，细节与冻结源码见协议；不因某个结果有利临时扩展矩阵。 + +**07:19依据首批早期开发结果补充。** 等计算原子复习在低负载出现100%→29.10%的拟合后退化，因此另冻[4项较低学习率配对](development-artifacts/capacity-stability-check-v1/protocol.md)：只在H=256/4096比较mixed与atomic_replay，共同lr=.001。它在原17项后自动接续，原矩阵、旧终点及原生组合的长期优化继续保留。该验证用于区分训练内容效应和优化不稳定；没有增加模型尺度或独立世界，不能称容量确认。 + +### 核心问题与论文故事线 + +**模型能够以多高的密度存储知识，又能在多高的密度下可靠地组合这些知识？两种容量的差距如何随规模变化，什么架构操作能够改变它？** + +复合答案由原子事实决定，不增加一份与原子世界独立的知识信息；但连续计算可能要求中间状态具有更高的可用精度。单跳只需正确候选得分最高，内部向量仍可含有其他关联的串扰。把该向量用于下一次计算可能放大干扰；非线性选择、重编码或训练得到的表示也可能消除它。串扰是候选机制，尚不是对现有 Transformer 失败的归因。 + +论文按以下逻辑建立贡献：先统一知识量与参数口径，测单跳可承载的负载；再测同一知识世界中留出组合的能力，检验是否存在“单跳仍可靠、组合已下降”的区间；随后用限定模型推导及针对性的结构比较解释差距；最后在真实事实与自然名称上检验适用范围。原子编辑与知识变化后的复用仅作需要时的辅助证据，不作为论文中心。 + +| 文献基础 | 已有工作解决了什么 | 本研究希望进一步解释什么 | +| --- | --- | --- | +| [Physics of Language Models 3.3，ICLR 2025](https://proceedings.iclr.cc/paper_files/paper/2025/file/26d3c9a66836ded8f34a944f2bfe868e-Paper-Conference.pdf) | 用知识信息量衡量存储；充分训练的受控实验中约 2 bits/parameter | 相同知识密度下，连续组合是否需要额外的表示或计算条件 | +| [Physics of Language Models 3.2，ICLR 2025](https://proceedings.iclr.cc/paper_files/paper/2025/file/d5494c8747276d3cdb2598e5617de89d-Paper-Conference.pdf) | 提取成功可与分类、比较等知识操作失败并存 | 这种能力差距随负载与模型规模如何变化，什么结构能移动其边界 | +| [Meta Looped MoE，2026-09-30 预印本](https://arxiv.org/html/2609.40316v1) | 联合研究参数、数据、循环、稀疏度与 loss/下游效率 | 在可计量的知识世界中解释存储与组合容量的关系；不以重新拟合资源效率曲线为中心 | + +2 bits/parameter 是原文条件下的经验容量比例，不是每条事实占 2 bits，也不是所有 Transformer 不可突破的上限。原文的信息论定理支持知识量估计，不证明普适常数 2。其训练曝光、知识 token 损失、未使用词表行的参数处理、总参数与激活参数区别，均需在适配时明确。详细阅读与定义见 [Physics of Language Models 对接记录](development-artifacts/compositional-capacity-discussion-20261006/physics-of-language-connection.md)。 + +### 量化定义与希望区分的尺度关系 + +给定固定的地址、关系与取值字典，若 N 个属性值相互独立且各为 M 选一均匀随机变量，则原子知识世界 Z 的条件信息量为 `B=H(Z)=N log₂ M`。平均属性值负对数概率为 ℓ₁（nats）时，可使用经验量 `B_hat=N(log₂ M−ℓ₁/ln 2)`。跨随机世界的期望有信息论解释，单个世界的数值不等于已知的真实互信息。随机名字、词典或相关事实需另计其联合信息，不能直接套用此简式。 + +区分数据要求的负载 `ρ_data=B/P` 与实际掌握的经验密度 `ρ_learned=B_hat/P`。主扫描操纵前者，同时报告后者；不能通过增加未学会的事实宣称提高了存储密度，也不只留下达到指定知识水平的模型。P 同时报实际全部参数和按原文口径调整的参数，绑定权重与共享循环只计一次，MoE 的存储分母计全部专家；推理激活量和训练计算另列。 + +在固定世界生成器、架构族、训练流程、组合支持、查询分布及误差要求下，定义： + +- **C₁(P)**：达到指定原子提取准确率时，可承载的最大原子世界信息量。 +- **C_h(P)**：同时满足同一原子要求和指定 h 跳留出组合准确率时，可承载的最大原子世界信息量。 + +组合容量的单位是满足使用要求的知识库 bits。多条复合查询共享事实，不能把其答案 bits 当作独立新知识累加。`C_h≤C₁` 来自定义的包含关系，不是新增理论贡献。原文基于损失估计的峰值约 2 bits/parameter，也不意味着我们指定准确率时恰有 `C₁=2P`。有限预算、有限负载网格只能给出该协议下的容量边界估计或区间，不能称任意参数解的表达能力上限；未跨过阈值时只报界，不外推容量。 + +有价值的区分包括：组合损失是否大致为常数比例（如 `C₂≈κC₁`）；该比例是否随规模继续下降；结构改变是否能缩小差距或改变其尺度。`C₁∝P、C₂∝P^α且α<1` 仅是可能被检验的情形，不预设幂律或指数。少量尺度点先建立趋势与不确定性，不据两三个点宣布新 scaling law。 + +### 已有证据的用途与缺口 + +| 已有材料 | 可以支撑的用途 | 尚不能支撑的主张 | +| --- | --- | --- | +| 真实图约 65,968 条事实，D8 约 96.1M 参数，单跳接近全对而严格组合较低 | 存储与组合行为分离的研究动机；既有架构的适用范围 | 当前已经达到知识存储饱和，或组合低分由串扰唯一造成 | +| 实体编码、自产桥重编码、表示对齐及覆盖实验 | 中间表示与后续使用值得研究；提供开发基线 | 编码变更是纯纠错因果效应，或辅助监督的收益就是原生架构优势 | +| 长训练与优化归因 | 提醒固定步数和 GPU 时间不能互相代替；学习阶段可能影响边界 | 所有负结果都只需延长训练即可解决 | +| 本轮随机线性记忆推导与 CPU 验算 | 某一明确构造中，串扰可随连续组合加剧 | 已发现学习后 Transformer 的容量定律或共享 Loop 的噪声规律 | + +现有真实事实尚未完成相容的熵与参数核算。每条关联假设为 20 bits 时，6.6 万条仅约 132 万 bits、约 0.014 bits/当前总参数；这只是量纲示例，不是实际知识熵估计。下一步有理由缩小模型以接近容量边界，而非继续扩大模型并把固定负载准确率称为容量。 + +### 接下来实验的顺序与决定逻辑 + +| 阶段 | 主要问题与最小比较 | 产物及后续决定 | +| --- | --- | --- | +| 0：校准计量与任务 | 复用官方知识位计数、事实曝光方法和现有小 Transformer/数据实现；写清可组合随机世界对原版 bioS 的适配。用一个小普通模型、少量负载检查原子学习及低负载两跳，确定共同词表、渲染规则、留出链与组合角色覆盖。 | 信息量、参数与曝光核算表，以及低负载学习曲线。若需要原版 bioS 的小型基准校准，单列辅助比较，不照搬其完整矩阵。低负载也不能组合时先处理操作学习，暂不解释组合容量边界。 | +| 1：测两种能力随负载变化 | 先在一个宽度定位从欠载到原子下降的区间，再用少量宽度核验归一化。主轴是 B/P，跳数固定为 2，组合支持的构造与曝光规则固定。 | 全负载单跳/两跳曲线、实际掌握 bits、C₁/C₂ 的可观测边界及不确定性。分别报告熟悉事实新链和只受原子训练事实的组合，不混合筛选。 | +| 2：区分负载效应与事实难度 | 保持一组目标链、必要事实及其曝光，增加其他关联的存储要求；记录背景事实实际学会多少。目标链与答案难度保持，背景新增部分和总训练代价明示。 | 检验目标单跳仍可靠时，两跳是否随其他知识增加而下降。若只因必要原子变差，归入提取问题；若损失稳定但无负载依赖，不强称压缩导致的容量分离。 | +| 3：解释架构作用 | 先在代表性的低负载、临界附近与较高负载比较普通模型和共享块模型；按观测选择一个中间纠错/重编码操作，提供相应监督和计算对照。 | 在相近知识密度及必要原子水平下，结构能否移动组合边界。额外计算、参数增加、监督增加分别解释；不把所有架构与全部尺度相乘。 | +| 4：检验适用范围 | 核心受控规律成立后，在新随机世界确认；三跳、自然名称和既有真实图各按需要作有限延伸。 | 区分随机世界中的规律与真实知识的适用范围。真实图无增益也保留；不以必须超过当前真实 OO 分数作为全部理论工作的成立条件。 | + +开发确定负载档位、准确率要求、预算和分析后，在独立世界上冻结确认比较；开发/确认分开。随机初始化嵌套在世界内，查询、种子和不同层不充当独立世界。先粗定位边界再在开发集加点，不用正式测试反复选择临界区或最好节点。 + +主要评价保留完整测试池的自由生成正确率、原子知识 token NLL、训练组合拟合、必要事实正确率，以及共同必要原子正确子集的覆盖与组合成绩。词表候选内排序只能作为另报诊断，不能悄悄替代原评分。跨负载、跨架构的条件子集若成员不同，必须披露；用于直接配对时另报共同成员。 + +固定每条事实曝光与固定训练 FLOPs 随 B 变化不能同时成立。主容量比较以明确的逐事实曝光/学习充分性规则为准，记录总计算；在代表性的边界点补固定 FLOPs 或延长训练的复核，判断边界是否仍被优化明显推动。阶段 2 单独固定目标事实与组合支持曝光，背景每条曝光和总 FLOPs 的变化另记，不声称所有量同时匹配。 + +内部重编码采用模型自产预测，不给真实中间实体；oracle 独立报告。若操作需要首跳监督，基线获得同样监督；若增加解码、编码表或执行计算，应计入资源并给针对性对照。普通 Transformer 的某一层或一次 Loop 不预设为一跳，干预位置需有任务和行为依据。MoE、mHC 仅在需要检验存储分配或状态传递时追加一个明确比较，旧批次按其原问题解释，不预设任何架构获胜。 + +### 理论推进与写作落点 + +限定的随机单位球编码、外积叠加记忆、独立阶段模型中，任一错误候选分数的方差已推得：一跳为 `2/d+(N−2)/d²`，两跳为 `3/d+3(N−2)/d²+(N²−3N+3)/d³`。推导、假设、CPU 样本与重编码代价见 [串扰推导与核验](development-artifacts/compositional-capacity-discussion-20261006/note.md)。这提供一个具体机制原型；由二阶矩推准确率边界还需控制正确分数波动、候选依赖及尾部。共享权重需另行处理误差相关，随机编码表的资源也不能从端到端模型参数中隐去。 + +理论目标分三层：信息论说明存储的是同一原子世界，组合查询不自动增加独立知识熵；在明确计算模型内证明何种状态/纠错条件产生或减轻组合代价；最后用训练后网络的负载曲线和针对性操作检验对应机制。经典容量下界、代数恒等式或 toy 验算不独立充当 Transformer 新机制。 + +论文主图候选为：**知识密度—单跳/两跳曲线**、**C₁/C₂ 随规模的边界**、**代表负载上改变计算结构的干预**。正文先提出计量与问题，再给受控行为、条件性理论和机制比较，最后给真实事实边界；不把“有些架构稍高几分”作为故事主轴。若两种容量近似同比增长，应报告其条件；若纠错不能改变差距，收窄机制；若只有 toy 出现分离，不将其写成普通 Transformer 的性质。 + +论文定位与中英文问题表述同步见 [论文草稿](paper-framing.md)。本节替代此前“主要扫描独立深度与循环计算”的讨论候选；下文按日期保留的计划、已授权待办及各批冻结契约仍分别有效，不自动并入新负载矩阵。 + +## 2026-10-05：先匹配预算，再归因OO差距 + +用户要求核对合成数据在同等训练预算下的OO，并开展原因归因。历史逐例复算已完成：[预算曲线与审计](results.md#oo-budget-attribution-20261005)。相同300k步时旧合成最高为24.45%，不是其1500k终点81.34%；但真实300k已经消耗与旧合成1500k相近的训练段GPU时间，估算乘法FLOPs约为其1.96倍。因此更新/事实曝光、执行词元和计算时间需分开解释，不能仅用“多训一会”或“真实图更难”代替检验。 + +**当前新增执行项：优化配置的2×2配对归因。** 同一真实图、Loop4×2、两个初始化、各300k步，学习率5e-5/1e-4与weight decay .1/.3完全交叉；旧基线两条通过训练依赖、数据、tokenizer和初始化兼容核验后复用，新增六条。完整OO曲线与单跳/训练拟合同时报告，主分析是各因素和交互的配对差；一个已观察图上的两种子不代表独立世界，也不通过选择最高测试节点宣称grokking。见[冻结设计](development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md)。 + +10月5日13:24，按用户要求将该批移到D157终止后释放的GPU 6–7独立并行，首批两条通过实际CUDA预飞与历史step0全预测复现后已进入正式训练，后续各条沿用相同预飞。原先等待架构批次的条件仅用于GPU资源复用；历史Loop基线已完成，故按[调度修订](development-artifacts/oo-optimizer-attribution-parallel-20261005/amendment.md)解除等待。GPU 2–5的15条架构主实验继续原队列，LM专属Docker、W&B和六条归因实验的科学配置保持不变。本轮只检验优化方案能解释多少有限预算差距；实体编码/地址分配的已有控制继续作为独立证据，图结构与组合覆盖是否需要新增干预在本轮后据结果决定。此前D24等补充仍按各自边界保留为计划，不自动乘入本次矩阵。 + +## 2026-10-04用户澄清：深度方向的计算设计与双能力评价 + +本轮研究表述聚焦深度方向的不同计算组织方式（operator/design）如何影响知识与组合推理。“深度维度的scaling”不表示新增多个层数或循环次数档位，不能据此扩展operator×depth网格。沿用已确定的代表架构及必要对照，同时报告单跳事实提取和未见组合能力；单跳表现描述已训练事实的可提取性，不直接称为知识容量上限。独立层、共享重复与跨层连接分别说明其计算作用；MoE作为层内参数选择方式比较，不能把所有架构差异都归为纯深度效应。本轮澄清不新增宽度、数据量、训练时长或其它交叉扫描，也不改写已冻结运行。 + + +## 2026-10-04补充计划：参数匹配与层间连接的必要对照 + +**状态：按用户要求记入后续计划，尚未实现或启动。** 本节补充架构可比性的缺口；正在执行的七臂比较、冻结源码、学习率选择和预算继续按[原执行协议](development-artifacts/parametric-architecture-execution-v1/protocol.md)进行。本次写入不向调度器追加运行。保留“研究计算设计、不铺开层数网格”的约束：仅提出一个近等参数dense参照，以及在同一深度上的必要连接对照，不扩展为operator×depth×width扫描。下列参数量是按现有算子形状的理论核算，执行前仍需实例化核验。 + +**同日按用户进一步收敛：取消现代算子骨架迁移实验及其预算。** 补充工作集中于现有骨架内的参数匹配、层间连接和结果可比性，不将现代算子复核保留为待办或必要前提。 + +### 优先级与要排除的解释 + +| 顺序 | 补充工作 | 最小比较 | 要排除的解释及启动条件 | +| --- | --- | --- | --- | +| P0，随首轮分析完成 | 核对曝光、计算与学习前提 | 原七臂已有轨迹和检查点 | 分开“事实没学会”“事实会答但组合失败”和计算预算差异；优先复用已有产物，不新增训练。 | +| P1，优先补齐 | 参数分配更均衡的dense基线 | 新D24与已有M8、W8 | 判断MoE对照结果是否依赖W8过度集中于FFN的参数分配。无论首轮谁领先，只要讨论近等总参数的dense/MoE比较，就保留此项。 | +| P2，条件性补充 | 单一较深设置的mHC三臂 | D24、IHC24、HC24 | 若要解释八层结果的深度适用范围，或主张深层传递/稳定性作用，补此项；不以HC8必须先胜出为条件。仅报告八层结果时可后移。 | + +此前计划的Loop×MoE四臂交互仍单列；本节不将它与上述补充相乘，也不增加事实负载、名称编码、训练时长或新知识阶段的交叉网格。需要归因具体路由机制时，再沿原设计§6开展针对性干预，不把观察专家分工当作因果证据。 + +### P0：现有结果先按真正匹配的条件解释 + +保留L4R2−D4的等参数比较、L4R2−D8_hist的近等执行计算比较、M8−D8_calib的近等激活FFN计算比较、M8−W8的近等总参数比较，以及HC8−IHC8的连接比较。七臂不合成“完全公平”的单一排名。HC8比IHC8多786,704参数及混合开销；IHC8本身仍有可学习的跨流汇入/写回，不能称四路完全独立。 + +共同报告全部单跳、训练组合、全测试池及II/IO/OI/OO自由生成、必要事实共同正确子集的覆盖与成绩。以预定终点和完整学习曲线为主，不按每臂最优测试节点比较；单跳相近的分析是补充，保留所有未掌握事实和失败运行。重新利用已有记录对齐逐事实曝光、监督token、FLOPs估计、峰值显存和墙钟；在共同计算预算内取各臂最近且不超过预算的已存节点，披露预算间隙及曝光差异，不通过插值生成准确率。缺少对应节点或完整核算时报告缺口，不声称已经等计算。 + +共同学习率的已有开发轨迹可作训练设置敏感性分析。若正式三初始化使用各自校准后的学习率，主结论明确是“同额有限校准后的架构与训练方案比较”；单个开发初始化不足以建立正式同学习率结论。MoE的路由/分发、mHC的Sinkhorn和内存访问另计；当前实现的吞吐只代表该实现与硬件，不外推生产融合算子的速度。 + +### P1：增加D24，检验dense参数分配是否影响比较 + +候选D24使用24个独立块、隐藏宽768、12个注意力头、普通GELU FFN宽3072；保留原tokenizer、词表、位置、绑定读出、数据及答案/EOS监督。它保持普通FFN与注意力的比例，把额外参数分配到更多完整块。按现有GPT-2含偏置和LayerNorm的口径，固定部分为39,385,344参数，每块7,087,872参数，因此D24合计**209,494,272**，与M8的209,500,416仅差6,144（约0.00293%）；W8为209,408,256。 + +新增D24−M8和D24−W8，原M8−W8继续保留。前者检验稀疏浅层与普通较深模型在近等总参数下的取舍；后者检验将参数集中于宽FFN或分配到完整层的影响。深度、注意力参数分配、串行计算及优化均不同，不能归因为单独的稀疏路由效应，也不能称D24是该参数预算下最优dense。D24与W8的主要线性投影乘法量接近，但D24的attention分数计算、执行次数及实际耗时不同；与M8更不能声称等计算。 + +为D24提供同样的两档学习率5e-5/1e-4、一个开发初始化、固定32k终点；选择沿用0.5×原子NLL+0.5×训练组合NLL，不看正式组合分数。随后三个配对初始化各300k。独立记录24层初始化/残差投影缩放，建立可扩展深度的构造与参数核验；现实现固定构造八块，不能只修改配置层数便宣称已得到D24。与历史M8/W8复用前核对数据、采样、监督及优化契约；不同深度不声称初始函数相同。 + +### P2：复用D24，补同深度的连接三臂 + +在确需讨论深层适用性时，增加IHC24与HC24，均保持D24的注意力/FFN主干；每个注意力和MLP子层使用四流连接，分别固定残差混合为单位阵、或采用完整mHC约束混合。沿用首轮pre/post控制器与最终取流均值后LN的适配方式，并明确其与原论文的差异。三臂复制同一个24层参考的核心张量，新控制器使用独立初始化流。 + +主要比较IHC24−D24和HC24−IHC24，分别检验多流读写的整体作用与额外残差混合的作用；理论总参数依次为209,494,272、210,821,856、213,181,968。三臂各自记录参数差、活动状态内存和计算开销。依据[mHC的方法与实验](https://arxiv.org/html/2512.24880v2#S4)及[正式版](https://proceedings.mlr.press/v306/xie26aa.html)，同时记录非有限值、梯度/残差量级与混合矩阵行列和误差，作为训练稳定性检查，不另建表现预测器，也不把数值稳定当作知识保持的证明。 + +保留全部八层结果作范围参照；若深度相关初始化或训练设置不同，跨八/二十四层的差异不称纯深度交互。一个新增深度点也不支持scaling law。若二十四层仍无增益或发生优化困难，如实记录，不自动继续加深或延长。D24仅在与P1的数据、初始化、优化和评价契约完全兼容时复用；需要改动时先单列新增预算，不能事后改写P1来凑配对。 + +### 补充预算与执行边界 + +| 项目 | 新增开发训练 | 新增正式训练 | 候选新增更新总数 | +| --- | --- | --- | ---: | +| P0已有产物分析 | 0 | 0 | 0；必要重算评价的GPU耗时另记 | +| P1 D24 | 1臂×2学习率×32k | 1臂×3初始化×300k | 964,000 | +| P2 IHC24/HC24，兼容复用D24 | 2臂×2学习率×32k | 2臂×3初始化×300k | 1,928,000 | + +P1与P2都开展且D24可复用时合计2,892,000更新，不能重复计算D24。P2仍按上述条件决定是否开展，上表不是全部自动执行的预算；旧Loop×MoE预算也不自动相加。更新数仅用于列清工作量，GPU时长需实测，不能把不同架构的一步当相同计算。各项沿用同额开发、固定终点、完整负结果和独立重载；不以出现预期架构优势为进入正式比较的条件。 + +落实任一新增项前，另冻结配置、初始化规则、数据哈希、评价节点与实际资源预算；本节仅为计划，当前新增训练数为零。执行时继续使用LM专属固定镜像和`docker --context lm-memory`、每实验独立容器，并按当时资源核对GPU分配；启用既定W&B追踪。不得编辑现有运行所依赖的冻结文件或为此停止其它实验。 + ## 2026-10-04用户补充：以架构设计空间组织下一阶段研究 @@ -330,6 +486,8 @@ storage-stability-v1的24条新开发和独立端点复算全部完成。12个 ## 预训练与知识使用：已完成比较与解释边界 +**2026-10-04，预训练隐式监督的推导补充。** next-token CE在共享输入/输出embedding时，对输出端状态的梯度为预测分布加权embedding减去正确token embedding；中间层收到的是经过后续网络Jacobian变换的信号。相同因果前缀下，原子训练也塑造组合题会使用的早期状态，但答对不保证该状态接近输入embedding或可被第二跳复用。现有覆盖实验各臂均已有显式首跳CE，不能将10.25%→92.12%解释为从纯预训练到有中间监督的效应。完整[数学推导、适用条件与三项待验证猜想](memory-scaling-theory.md#pretraining-implicit-alignment-20261004)区分表示选择、使用经历及编辑不同步解释；本次仅更新研究解释，无新增实验或预算。 + **主张目标。** 先建立受控文本预训练的行为因果效应，再检验其中一个内部传递过程。工作假说是：组合经历同时塑造事实的检索状态及后续计算对该状态的使用方式；共享参数和单跳正确都不足以保证二者匹配。这是假说，不是已识别的唯一机制。研究对象写成 `h → b → t`：事实存储、首跳检索、跨位置传递、第二跳使用及答案读出均可能产生差距。 本次复算12个使用经历确认端点的108个九格单元，预测、真值、EOS、概率及跨臂查询身份均与原汇总一致。按训练角色对齐，第一/第二条边都参加过组合、仅第一条参加、仅第二条参加、两条都未参加时，正确率分别为100.00%/41.48%/48.94%/3.01%；对应原子重复为25.01%。[数据与复算](development-artifacts/knowledge-use-review-v1/summary.json)保留逐世界分母。不同角色行有不同查询，且原训练没有限定事实只能在某个位置出现；这是事后描述，不能把中间两行的差解释为首跳/次跳的独立因果效应。它提示全链失败值得分段检验。 diff --git a/docs/memory-scaling-theory.md b/docs/memory-scaling-theory.md index b3775f2d6f60bb0a0ea099072546062c30119d0d..8b29680b89cef79481d40069bbf2c69a43b0e38d 100644 --- a/docs/memory-scaling-theory.md +++ b/docs/memory-scaling-theory.md @@ -317,3 +317,79 @@ S_t=\alpha_t S_{t-1}+\beta_t(v_t-\alpha_tS_{t-1}k_t)k_t^\top. **mHC的混合稳定不等于语义信息保持。** 对固定双随机矩阵H，$H\mathbf1=\mathbf1$、$\mathbf1^\top H=\mathbf1^\top$，且 $\|H\|_2\le1$；矩阵乘积仍双随机。但 $H=\mathbf1\mathbf1^\top/n$ 会把所有流替换为均值，完全消去流间差异。因此[mHC正式论文](https://proceedings.mlr.press/v306/xie26aa.html)的约束给固定线性残差混合以稳定性质，不能推出实体可分辨性或知识不遗忘；输入相关H的导数和pre/post分支也使全网络Jacobian超出这个界。普通残差、同多流但H为I、完整mHC的比较才能分开状态扩展与混合作用。 以上分析将架构比较的预算分为总参数、激活计算、每例活动记忆、执行次数和训练曝光。一次实验无法只用“相同参数量”消除它们的差异；应根据待检验命题分别匹配并报告资源，而非先假定统一的长度×深度×宽度幂律。 + + +## 13. 预训练是否隐含中间表示监督：梯度推导与待验证解释 + +2026-10-04，依据用户讨论补充。**普通next-token prediction已经提供答案身份的梯度信号；输入输出权重共享时，输出端信号直接涉及输入embedding。但这不保证某个早期状态与正确实体embedding对齐，也不保证事实能用于下一跳。** 以下是给定模型形式下的直接推导，不是新增实验、文献新颖性主张或自然预训练模型的机制确认。相关观测见[对齐覆盖与编辑传播](results.md#memory-interface-next)。 + +### 13.1 输出端：交叉熵包含正确token方向，但不是向量相等约束 + +设前缀为x、正确下一token为y，h是最终归一化后送入线性输出头的向量，输出权重行为u_v。先固定当前参数，以无偏置输出头为例： + +\[ +p_v=\frac{\exp(u_v^\top h)}{\sum_w\exp(u_w^\top h)},\qquad +L=-\log p_y, +\qquad +\frac{\partial L}{\partial h}=\sum_vp_vu_v-u_y. +\] + +若输入输出共享权重，则u_v=e_v，e_v为输入embedding。负梯度含有指向正确token向量的分量，以及远离当前预测分布加权平均向量的分量。若把h暂时当作独立优化变量，一步下降为 + +\[ +h^+=h+\eta\left(e_y-\sum_vp_ve_v\right). +\] + +这是一种相对候选的判别信号，**不能据此声称每次参数更新都增加h与e_y的余弦相似度**。CE依赖的是logit间隔： + +\[ +L=\log\left(1+\sum_{v\ne y}\exp\bigl(-(u_y-u_v)^\top h\bigr)\right). +\] + +因此低CE只要求这些间隔足够大，不一般要求h的方向等于e_y；输出权重差张成空间的正交分量也不受这一输出约束区分。是否存在非零正交分量取决于实际秩。若输入输出不共享，梯度直接涉及u_y，不能将它换成输入向量e_y。 + +真正训练优化的是共享参数θ而非自由变量h。固定输出头、只考虑单个样本和普通SGD时，令A=∂h/∂θ，一阶近似为Δh=−ηAAᵀ(∂L/∂h)。多样本、共享输出权重、Adam及其他损失还会改变这一更新。因此上述负梯度是局部监督方向，不是完整训练轨迹的保证。 + +### 13.2 中间层：监督经过后续计算的Jacobian变换 + +取一个早期位置的状态z，并把后续输出写为h=F(z;c)，其中c代表固定的其他边界状态与上下文；最终归一化也包含在F内。链式法则给出该输出损失的贡献： + +\[ +\frac{\partial L}{\partial z} +=J_F(z;c)^\top\left(\sum_vp_vu_v-u_y\right). +\] + +完整序列损失还须对所有受该状态影响的预测位置求和。正确答案信号确实可能传到z，但会被后续网络旋转、缩放、混合或消去；不能保证每个位置都收到非零信号。训练要求的是“z经后续计算能得到正确输出”，不是“z本身必须等于正确实体的输入向量”。答对不唯一确定内部编码；共享参数也不自动把不同情境的编码统一。 + +### 13.3 为什么单条事实训练可能监督组合题的早期状态 + +在本项目受控模板中，原子题与对应组合题在首关系位置具有相同的token前缀、位置和注意力可见范围。固定同一模型，关闭dropout或耦合同一随机掩码，因果网络在该位置的早期状态相同；后面的第二关系与组合答案不能影响它。 + +因此，原子文本中预测首跳实体的损失，经由上述梯度塑造的状态，也是对应组合题在这一位置使用的状态。**严格组合留出不等于其早期事实状态从未受监督：相关原子事实仍参加训练。** 这个结论依赖完全相同的因果前缀；自然语言中问法、tokenization、位置或上下文不同，只能提出迁移假说，不能套用状态相等结论。 + +还应区分teacher forcing与内部组合。标准预训练在后续位置读到的通常是真实前缀token；文本中写出桥实体后，下一句可以直接使用它的输入embedding。这提供组合使用的机会，但不强迫模型在没有显式桥token时先自行产生桥状态、再完成第二跳。多token实体还涉及逐token条件化，上述单token公式不能直接解释为完整实体向量对齐。 + +### 13.4 与已执行的显式监督比较 + +实际[状态提取](../src/llm_memory_editability/representation_alignment.py)在首执行Transformer块结束后的首关系位置；这是残差状态，不是MLP单独输出。既有[覆盖实验损失](../src/llm_memory_editability/alignment_coverage.py)为 + +\[ +L_{\rm total}=L_{\rm text}+0.3L_{\rm bridge}+0.3L_{\rm align}, +\qquad +L_{\rm align}=\operatorname{Reduce}_{\rm mask} +\left\|\frac{z}{\|z\|}-\frac{\operatorname{sg}(e_b)}{\|\operatorname{sg}(e_b)\|}\right\|^2. +\] + +b为训练数据提供的正确首跳实体，sg表示停止该参照分支的梯度；非零向量下单例项等于2−2cos(z,e_b)，实现使用带数值保护的normalize。L_bridge通过共享输出头与最终LayerNorm直接监督该早期状态读出b；全模型参与训练，embedding仍可由其他路径更新。Reduce按冻结方案使用全batch均值或选中样本均值。 + +**覆盖实验四臂都保留相同的显式首跳CE，只有几何项的mask和归一化改变。** 严格组合正确率10.25%（关闭几何项）、25.55%/23.80%（仅组合，两种归一化）、92.12%（原子及组合）不能描述为“纯预训练与中间监督”的比较，也不能解释为从完全无监督到有监督。原先全文CE、首跳CE、再加对齐的三臂比较另见[结果](results.md#representation-alignment)，不要混用两个实验的分母与处理。 + +### 13.5 猜想、现有支持与不能推出的结论 + +1. **表示选择猜想。** 原子CE允许多种可正确读出的内部编码；显式对齐可能偏向后续计算更容易复用的一类编码。覆盖扩展和自产桥重编码的收益与此相容，但也可能涉及优化难度、正则化及多个模块的共同适应；尚未识别唯一中介，更未证明embedding对齐是必要条件。 +2. **使用经历猜想。** 组合文本和共享计算可能间接促成类似的功能兼容，不一定形成与输入embedding相同的几何。若无显式对齐的模型能稳定完成跨关系反事实复用，即使余弦不高，也应保留为功能复用的证据，不能以几何不相似否定它。 +3. **编辑不同步猜想。** 修改原子输出可能改变后层读出，而没有同步更新组合使用的早期状态或后续解释方式。现有“原子写入成功但派生答案仍旧”的结果与此相容，却未排除分布漂移、其他上下文路径和知识保持损伤；单凭CE梯度不能定位失败位置。 + +进一步区分这些解释，应围绕同一事实在原子/组合情境中的实际行为与状态干预，分别核对早期身份、跨关系复用及编辑后的同步变化，并控制原子掌握、目标写入、保持和训练曝光。这里仅记录待检验问题，不增加训练预算、启动新实验或把内部特征改造成表现预测器。 + +**结论层级。** CE梯度、Jacobian传递和相同因果前缀的状态一致性是带条件的数学结论；覆盖实验收益是既有受控观测；“对齐使事实编码更便于后续使用”仍是机制猜想。当前不能据此宣称自然预训练必然形成或完全缺乏这种接口，也不能外推普遍的知识编辑能力。 diff --git a/docs/paper-framing.md b/docs/paper-framing.md index 40ad905e0cc7909dead2ad07220e26eb1e270e23..e278eb8a62c1f26a7e455f81e755d2e69d1a9a45 100644 --- a/docs/paper-framing.md +++ b/docs/paper-framing.md @@ -1,6 +1,8 @@ # 论文标题与正文术语草稿 -2026-10-02。本文统一记录工作标题、术语写法，以及可用于论文摘要、引言和理论定义的正文。研究范围沿用[当前计划](hebbian-learning-plan-v1.md)：普通Transformer的宽度与独立层数、共享参数后的重复计算、训练支持与时长、数据组织。数学证明见[理论推导](memory-scaling-theory.md)，实测依据见[结果汇总](results.md)。本稿没有新增训练或修改既有实验契约。 +**2026-10-06更新。** 工作标题与知识密度主线不变。首批9项负载/背景扫描已全部完成，最低负载原子100%、II仅0.68%，四档未形成可靠原生组合；目前不能将其解释为组合容量压缩。下一步已启动同权重连续调用参照、原子训练/等计算复习控制，以及低负载配对长期优化，见[当前计划](hebbian-learning-plan-v1.md#capacity-scaling-mainline-20261006)与[冻结协议](development-artifacts/capacity-recall-controls-v1/protocol.md)。这些比较检验学习与调用条件对操作性容量的影响；外部两次调用的成功不等于Transformer内部组合机制成立。 + +本文维护论文定位和问题表述。摘要与引言已从此前多维扫描改为负载主轴；新容量曲线尚未实验确认，因此当前摘要是研究计划表述，正式投稿时再依据结果改写。既有证据保留在§7及[结果汇总](results.md)，经典理论见[理论文档](memory-scaling-theory.md)，本轮限定构造的计算见[串扰推导](development-artifacts/compositional-capacity-discussion-20261006/note.md)。 ## 1. 当前工作标题 @@ -10,7 +12,7 @@ 主标题采用经典总称 **Associative Memories（联想记忆）**，正文用 **heteroassociative memory（异联想记忆）** 精确定义事实关联。标题主体是Transformers，覆盖普通独立层数叠加和共享块重复执行；Loop是区分参数与执行深度作用的关键比较之一。 -副标题中的Exploring表达研究动作，the scaling of中的scaling作名词，指存储与组合检索随尺度变化的行为。Storage指事实记忆的形成与提取，Compositional Recall指在未训练的组合查询中使用已学事实。考察的尺度包括模型规模、执行深度、训练支持和优化时长；这里研究这些维度的作用和交互，尚不宣称已发现经验幂律。参数存储容量的数学背景与当前固定负载下的行为测量分别说明。 +副标题中的Exploring表达研究动作，the scaling of中的scaling作名词。Storage指事实记忆的形成与提取，Compositional Recall指在未训练的组合查询中使用已学事实。当前主轴是知识信息量相对于参数量的增长，先固定两跳；少量宽度检验尺度，独立/共享计算和必要的中间纠错比较解释机制。训练支持和优化时长作为需控制和核查的条件，不再各自展开完整扫描。当前尚未建立经验幂律或Transformer容量上限。 Scaling Laws for Storage and Compositional Recall可用于已经建立明确尺度关系的论文标题，例如给出带适用条件的数学尺度定律或经过验证的经验函数关系。目前采用Exploring the Scaling of，准确表达对尺度效应的研究；是否升级为Scaling Laws由最终推导和实测决定。 @@ -25,26 +27,30 @@ Scaling Laws for Storage and Compositional Recall可用于已经建立明确尺 | 正文后续描述关联类型 | heteroassociative retrieval / associations | 异联想检索／关联；不需要每段重复完整类别名 | | 经典对照类别 | autoassociative memory | 自联想记忆；由部分或受损线索恢复原模式 | | 本文的组合任务 | compositional recall | 组合检索；对训练未出现的组合查询使用已学事实 | +| 知识计量 | knowledge bits / knowledge density | 原子世界信息量／每参数承载的知识信息；数据负载与实测掌握量分开 | +| 本文的容量边界 | storage capacity / compositional capacity | 指定协议和准确率下可承载的原子知识库信息量；组合容量附加多跳使用要求 | | 神经网络架构维度 | width / parameter depth / execution depth | 宽度／独立参数块层数／实际执行块数；参数总量另报 | -| 训练维度 | training support / optimization duration | 独立训练例及其结构／优化时长；曝光与监督token另报 | +| 训练条件 | training support / optimization duration | 独立训练例及其结构／优化时长；曝光与监督token另报 | 统一采用连写的heteroassociative；文献中的hetero-associative指同一术语。Hetero-associated不是这里采用的类别名称。“异”指关联模式的不同，不要求它们具有不同维度或属于不同感官模态。Compositional Recall是本文任务的操作描述，不把整个标题声称为已有的专门理论名称。 -## 3. 英文摘要草稿 +## 3. 英文研究摘要草稿 + +**状态：实验前的问题与方法表述，尚不是报告新容量结论的投稿摘要。** -Transformers can recall learned facts, yet successful atomic recall does not guarantee that those facts can be used in a new composition. We study Transformers as associative memories and ask how scaling affects both factual storage and compositional recall. We distinguish model width and parameter depth from execution depth, and examine training support, data organization, and optimization duration. Our theoretical analysis connects classical associative storage with identifiability of learned interfaces and error propagation through a specified sequence of computations, under explicit assumptions. Controlled experiments with standard and parameter-shared Transformers show that accurate atomic recall can coexist with weak compositional recall, and that the benefit of additional computation depends on compositional training support. Generalization to new combinations of familiar facts and transfer to facts trained only through atomic queries are evaluated separately. Together, these results motivate studying scaling through the formation, accessibility, and compositional use of factual memory. +How densely can Transformers store factual knowledge while retaining the ability to compose it? We propose to study Transformers as associative memories using controlled knowledge worlds with measurable information content. The central comparison is between the knowledge load supported by reliable atomic recall and the load supported when held-out compositional recall is also required. We will vary knowledge bits per parameter, initially at a fixed two-hop task, and examine whether the resulting capacity gap depends on model scale and computational structure. An analysis of a specified random linear memory construction motivates interference across successive retrievals as one possible source of the gap. Controlled comparisons of independent and shared computation, followed by targeted intermediate-state interventions, will test its relevance to trained Transformers. The study separates information storage, learning conditions, and the resources required to use stored knowledge, while treating real-fact experiments as tests of the scope of any observed regularity. -**中文对应稿。** Transformer能够提取已学事实，但单跳提取成功并不保证这些事实能够用于新的组合。本文将Transformer作为联想记忆系统进行研究，考察不同scaling维度如何影响事实存储与组合检索。我们区分模型宽度、独立参数层数与执行深度，并研究训练支持、数据组织和优化时长的作用。理论部分在明确假设下，将经典关联存储、所学接口的可辨识性，以及给定计算过程中的误差传播联系起来。普通Transformer与参数共享Transformer的受控实验表明，准确的单跳提取可以与较弱的组合检索并存，额外计算的收益依赖组合训练支持。我们分别评价熟悉事实的新组合，以及只接受单跳训练事实的组合迁移。研究由此围绕事实记忆的形成、可访问性和组合使用解释scaling的作用。 +**中文对应稿。** Transformer能够以多高的密度存储事实，同时保持组合这些事实的能力？我们拟以信息量可计量的受控知识世界，将Transformer作为联想记忆研究。核心比较是：可靠单跳提取所支持的知识负载，与同时要求留出组合正确时所支持的负载。主实验改变每参数的知识信息量，先固定两跳，检验两种容量的差距是否依赖模型规模和计算结构。限定随机线性记忆构造中的推导提示，连续检索的串扰可能是差距来源之一。通过独立与共享计算比较及针对性的中间状态操作，检验其对训练后Transformer的解释力。研究区分知识信息存储、学习条件和使用知识所需的计算资源，并以真实事实检验所得规律的适用范围。 -摘要中的事实存储使用行为操作定义；当前实测尚未建立模型的信息论容量上限。额外计算的条件性收益来自已完成的配对比较，不能把开发中的宽度变化或所有数据组织效应都写成已确认规律。 +已有准确单跳与较弱组合并存的结果只作为动机，不能填入“发现组合容量呈次线性增长”“纠错恢复容量”等尚未建立的结论。正式摘要须依据最终曲线、理论条件和结构比较统一重写。 ## 4. 英文引言草稿 ### 4.1 研究问题 -Language models must both retain facts and use them when answering new questions. A model may correctly answer two atomic queries, such as which entity is related to a subject and which entity is related to the intermediate answer, while failing to answer their composition. This motivates a distinction between factual recall and the ability to use recalled information in a subsequent computation. We ask how model scale, computational depth, and training experience affect this distinction. +Knowledge capacity can be measured in bits per parameter, providing a quantitative account of how much factual information a model retains. Compositional questions do not add independent information to the underlying facts, but answering them may impose additional requirements on the computation performed with those facts. We ask whether the knowledge load compatible with reliable composition scales in the same way as the load compatible with atomic recall, and whether architectural choices change their relationship. [Physics of Language Models, Part 3.3](https://proceedings.iclr.cc/paper_files/paper/2025/file/26d3c9a66836ded8f34a944f2bfe868e-Paper-Conference.pdf). -**中文对应稿。** 语言模型既需要保留事实，也需要在新问题中使用事实。即使模型能够分别答对两条单跳查询，它仍可能无法回答两者的组合。这要求我们区分事实提取和提取结果在后续计算中的可用性。本文研究模型规模、计算深度与训练经历如何影响这种分离。 +**中文对应稿。** 每参数的知识bits为事实存储提供了定量单位。组合问题不增加独立于原子事实的新信息，但回答它们可能对使用事实的计算提出额外要求。本文研究可靠组合所支持的知识负载，是否与可靠单跳提取所支持的负载遵循相同尺度，以及架构选择能否改变两者的关系。原文约2 bits/parameter是受控实验中的经验关系，不直接作为本研究给定准确率下的容量常数。 ### 4.2 经典理论背景与术语首次出现 @@ -54,15 +60,15 @@ Associative memory provides a classical framework for studying how stored patter ### 4.3 从单次关联到组合使用 -The central question is whether learned associations can be used compositionally. In a two-hop query, information obtained from the first fact must be made usable for the second relation. Classical sequence-processing memories study the retrieval of stored pattern sequences; our task instead evaluates held-out compositions of learned facts. We therefore distinguish sequence replay, new combinations of familiar facts, and composition involving facts that received only atomic training. Successful endpoint prediction is behavioral evidence; identifying a reusable internal retrieval process requires additional analysis or intervention. [Kawamura and Okada, 2002](https://arxiv.org/abs/cond-mat/0202431). +Prior work already shows that retrieving a stored fact and manipulating it are distinct capabilities. Our question concerns how this distinction changes as knowledge load increases. In a two-hop query, information from the first association must remain usable for the second relation; successful atomic decoding alone does not specify that intermediate computation. We evaluate held-out compositions and distinguish new chains of facts practiced in composition from chains involving facts trained only through atomic queries. Identifying an internal mechanism requires evidence beyond endpoint accuracy. [Physics of Language Models, Part 3.2](https://proceedings.iclr.cc/paper_files/paper/2025/file/d5494c8747276d3cdb2598e5617de89d-Paper-Conference.pdf). -**中文对应稿。** 核心问题是所学关联能否被组合使用。两跳查询要求首条事实提供的信息能够供第二种关系使用。经典序列处理记忆研究已存模式序列的检索；本文评价已学事实构成的留出组合。因此，已存序列的回放、熟悉事实的新组合和只受单跳训练事实的组合分别定义。端点回答正确提供行为证据，内部是否存在可复用的检索过程需要相应分析或干预。 +**中文对应稿。** 已有工作已区分知识提取与知识操作。本文进一步追问这种差距如何随知识负载变化。两跳查询要求首条关联提供的信息能用于下一种关系；单跳解码成功并不确定内部如何完成后继计算。评价分别报告熟悉事实的新链和只受原子训练事实的组合，端点正确率之外仍需证据才能归因内部机制。 -### 4.4 覆盖完整scaling范围 +### 4.4 收缩scaling主轴与架构比较 -We investigate width, parameter depth, execution depth, training support, and optimization duration within this framework. Standard Transformers increase depth through distinct learned blocks, while looped Transformers reuse a shared block. Comparing them helps examine how parameterization and repeated computation affect factual recall and compositional use. Training support and data organization determine which uses of facts are practiced, while continued optimization changes learning within that support. Our goal is to explain the conditions under which scaling improves the use of memory, including interactions and failures. +The primary axis is knowledge information per model parameter, initially with a fixed two-hop task. A small set of model widths will test whether normalization by parameter count is sufficient to describe both atomic and compositional recall. Independent and shared computation will be compared at representative loads, with total parameters, execution cost, supervision, and factual exposure reported separately. Intermediate-state interventions will be introduced only to distinguish specific explanations of the observed curves. Additional hop lengths and real-fact tasks will test the scope of the resulting account. -**中文对应稿。** 在这一框架下，我们研究宽度、独立参数层数、执行深度、训练支持和优化时长。普通Transformer通过不同的可学习块增加深度，Loop Transformer则重复执行共享块。两者的比较有助于分析参数化与重复计算怎样影响事实提取和组合使用。训练支持和数据组织决定哪些事实使用方式受到练习，持续优化则改变同一支持范围内的学习程度。本文解释scaling改善记忆使用的条件，并保留交互、平台和退化。 +**中文对应稿。** 主轴为每参数的知识信息量，先固定两跳。少量宽度用于检验参数归一化能否同时描述单跳与组合；普通独立块和共享计算在代表负载上比较，分别记录总参数、执行代价、监督与事实曝光。中间状态操作针对曲线提出具体解释，再用额外跳数和真实事实检验范围。此设计不展开深度、专家数、连接流数、监督覆盖与训练时长的全交叉。 ## 5. 正文定义与数学落点 @@ -96,23 +102,23 @@ k(a,r_1)\xrightarrow{M}v_b 这里的 \(A_{r_2}\) 表示受关系条件控制的接口算子。它是需要明确假设的理论对象；当前端到端GPT训练没有给予这种状态监督，也未证明某一层或某一次循环正好实现一个箭头。该图式提出“单跳可解码的返回值是否适合下一次调用”的机制问题。 -### 5.4 连接各个scaling维度的理论段落 +### 5.4 容量定义与理论落点 -Our analysis separates associative storage, learning of usable interfaces, and execution of a specified computation. Storage depends on the representation and interference among learned associations. Interface learning depends on the constraints supplied by training and on optimization within those constraints. Compositional execution requires the resulting states to remain compatible with subsequent operations and final decoding. We derive statements about these components in controlled models with explicit assumptions, and use Transformer experiments to examine the corresponding behavioral questions. +Let B be the information content of a controlled atomic knowledge world and P the model parameter count. Under a fixed training protocol and evaluation distribution, define C₁(P) as the largest B meeting an atomic-recall requirement, and C_h(P) as the largest B meeting both that requirement and an h-hop compositional-recall requirement. These are operational capacities under the specified protocol. Compositional answers share the information in the atomic world and must not be counted as independent stored bits. The theoretical question is which constraints on intermediate computation can produce a gap between these capacities and which operations can reduce it. -**中文对应稿。** 理论部分区分关联存储、可用接口的学习，以及给定计算过程的执行。存储依赖表示与关联之间的干扰；接口学习依赖训练提供的约束和约束范围内的优化；组合执行要求状态能够供后续操作和最终解码使用。本文在明确假设的受控模型中推导这些条件，再用Transformer实验检验相应的行为问题。 +**中文对应稿。** B为受控原子世界的信息量，P为参数数目。在固定训练和评价协议下，C₁(P)表示满足单跳要求的最大B，C_h(P)还要求满足h跳组合准确率。这是指定协议下的操作性容量；有限网格只估计其边界，不能写成所有参数解的表达能力上限。复合答案共享原子信息，不能重复计数。理论需解释什么中间计算约束会产生差距，以及什么操作可以减轻它。 -具体推导沿用[理论文档](memory-scaling-theory.md)：固定特征平方损失下的接口可辨识性与谱学习、给定理想计算过程下的有限步误差传播。普通GPT使用可学习表示、交叉熵和Adam，这些条件证明不直接等同于其内部机制。宽度、参数深度和执行深度可能共同影响多个组件，不能预设每个scaling维度只改变一个条件。 +当前[串扰推导](development-artifacts/compositional-capacity-discussion-20261006/note.md)在随机编码、外积叠加、独立阶段的限定构造中得到错误分数二阶矩：一跳为`2/d+(N−2)/d²`，两跳多出随N²增长的项。它尚不是准确率阈值定理，也不直接覆盖学习后的非线性网络或共享权重Loop。理论后续需处理尾部、正确分数波动、误差依赖和纠错资源，并与训练后的负载曲线对应。既有[理论文档](memory-scaling-theory.md)中的接口可辨识性与误差传播作为条件性背景，不将多个经典关系拼接为已确认的新机制。 ## 6. 架构与实验部分怎样写 -**可直接采用的英文段落。** We compare standard Transformers with distinct learned blocks and looped Transformers that repeatedly apply a shared block. We report width, total parameter count, parameter depth, and execution depth separately. Comparisons with matched numbers of block applications help study the role of parameter sharing, while varying the execution depth of the same weights examines the effect of additional computation. Training support, per-fact exposure, optimization steps, supervised tokens, and computational cost are recorded separately. Initialization and training differences are reported with each comparison. +**实验设计表述。** The first comparison will measure atomic and held-out two-hop recall as the information content of the training world increases. A targeted comparison will preserve the queried facts and compositional support while increasing the requirement to store other associations. Standard and looped Transformers will then be compared at representative loads. We will report all-query accuracy, required-fact recall, and the coverage and accuracy of the subset with correctly recalled constituent facts. Knowledge-token loss and information estimates will accompany accuracy, while factual exposure, training cost, inference cost, and any auxiliary supervision will be reported separately. **中文执行约定。** 普通模型与共享块模型都是研究对象。等执行块数不等于等参数、等初始化或等训练FLOPs；同权重改变测试循环也包含训练与测试执行分布的变化。训练支持不能只用链数描述，还需报告逐事实曝光、角色覆盖和搭配结构。标题里的Storage不要求把全部知识预设为某一个MLP独占。 ## 7. 当前结果支持怎样的正文表述 -本节是写作证据索引，数值由[latent-confirmation-v1结果](results.md#latent-confirmation)维护。三个新世界、两个配对初始化，宽128、每条128k步，48条训练与重载已完成；以下主成绩先在每世界平均初始化，再等权平均世界。 +本节是既有实验的写作证据索引，用于研究动机、开发基线和适用范围；这些固定负载比较不能替代新主线的容量曲线。数值由[latent-confirmation-v1结果](results.md#latent-confirmation)维护。三个新世界、两个配对初始化，宽128、每条128k步，48条训练与重载已完成；以下主成绩先在每世界平均初始化，再等权平均世界。 | 架构 | 256条组合支持：熟悉事实新链 | 完整组合支持：熟悉事实新链 | | --- | ---: | ---: | @@ -139,4 +145,4 @@ Our analysis separates associative storage, learning of usable interfaces, and e | Kawamura与Okada，2002，[Transient Dynamics for Sequence Processing Neural Networks](https://arxiv.org/abs/cond-mat/0202431) | 提供序列联想记忆动态理论背景；经典存序列检索与本文留出事实组合分别定义 | | Geva等，2021，[Transformer Feed-Forward Layers Are Key-Value Memories](https://aclanthology.org/2021.emnlp-main.446/) | 将Transformer前馈层作为键值记忆的直接研究背景；整体模型和组合计算仍需对应证据 | -本文希望推进的问题是：参数与表示规模、独立和共享的执行深度、训练支持及优化时长，在什么条件下改变事实存储和组合使用；哪些观察能够由接口学习与误差传播解释。贡献由最终推导和关键比较建立，已有记忆类别作为理论背景。 +本文希望推进的问题是：知识存储密度增长时，可靠单跳与可靠组合所支持的负载如何变化，以及计算结构如何影响两者的差距。Physics of Language Models 3.3提供信息量测量基础，Part 3.2提供存储与操作分离的已有证据；我们的贡献需由负载规律、明确假设下的推导和关键结构比较建立。经典记忆类别作为理论背景，原标题保持不变。 diff --git a/docs/results.md b/docs/results.md index 58ee9ff16a994df0d3a2511579d0108c75bba22c..b5920c04b48ac92876821d71cd8d60642514b33a 100644 --- a/docs/results.md +++ b/docs/results.md @@ -1,11 +1,86 @@ # 研究结果汇总 + +## 组合支持与知识负载曲线：已启动 + +**2026-10-06 09:07，开发两条完成并重载通过，三个新世界的21条组合覆盖矩阵已启动。** 用户批准最近论文方法复核后的两阶段计划。[协议](development-artifacts/composition-data-curves-v1/protocol.md)、[冻结配置](development-artifacts/composition-data-curves-v1/frozen-config.json)、[实时状态](../results/composition-data-curves-v1/controller-state.json)、[W&B项目](https://wandb.ai/zhusq20/llm-memory-editability)。30项数据/预算/评分/隔离测试、静态检查、实际CUDA计算以及1024步工程预检的独立重载均通过。 + +**09:44调度更新：** 按用户要求使用空闲GPU2–4，现为GPU0–4五卡并行；GPU6–7在旧OO归因批次六项全部完成并审计后自动接入。保留原容器和W&B进程，科学配置与三个正式锚点门槛不变；负载阶段按实体数降序派发以减少尾部等待。新增三卡实际FP32/BF16计算及19项相关契约测试通过。[调度修订与恢复入口](development-artifacts/composition-data-curves-parallel-20261006/amendment.md)。 + +开发N=128、phi=7.2的128k固定终点如下；均为答案加模型自产EOS。四层通过预定开发门槛，正式深度已固定为4、参数464,896、目标每例4000曝光；未进入512k长校准分支，两层低分完整保留。[选择记录](../results/composition-data-curves-v1/development-selection.json)、[开发学习曲线](../results/composition-data-curves-v1/report/development-learning.png)。两个W&B运行均已远端核验为finished、完整记录至128k。 + +| 开发候选 | 全原子 | 训练组合评价集 | 固定II评价2048题 | 完整预留II 2926题 | +| --- | ---: | ---: | ---: | ---: | +| 两层，宽64 | 99.80% | 99.37% | 52.34% | 52.73% | +| 四层，宽64 | 100.00% | 100.00% | 86.62% | 86.64% | + +这建立了本轮低负载组合基线；不同支持量及知识负载的规律仍需等待正式矩阵完成。 + +复用原两跳Grokking方法，在新开发世界确认固定词表与窄模型的组合前提；随后三个新世界×7档独立组合样本数，给出等128k计算与等每例曝光两种曲线。正式低负载锚点全部成功后，同一四层模型扩展到6档知识量，原子提取、原生II和OO分别报告，最低档复用。知识密度范围0.031–1.692 bits/参数；正式曲线不得倒过来选模型。 + +原子事实为随机关系图而非先前的四关系有类型任务；独立组合样本为嵌套、无重复、预留测试固定。每个N的独立知识量16N log2 N，组合答案不重复计bits。三个世界族等权，不把问法/节点/初始化当独立世界；闭合图随N变化，累计更新与衰减也随曝光预算改变，不把负载下降单独解释为内部容量或串扰。全部轨迹、预测、两预算权重、重载审计及曲线由冻结控制器持久保存到`results/composition-data-curves-v1/`，当前尚无本轮最终结论。 + + +## 存储与组合容量：首批九项完成 + +**2026-10-06 06:41全部完成。** 三项校准、三项主负载和三项固定目标背景对照均完成训练、独立重载及W&B追踪。按用户要求保留完整扫描、低分、失败尝试及05:05因前提未满足而停止的历史记录。[原始汇总](../results/capacity-scaling-development-v1/summary.json)、[控制器](../results/capacity-scaling-development-v1/controller-state.json)、[完整扫描修订](development-artifacts/capacity-scaling-full-scan-20261006/amendment.md)。 + +主扫描使用普通2层、宽64、102,976参数；同一开发世界、同一初始化、lr=.003、每例3000曝光。下表是独立审计终点，非最好测试节点。II表示两条必要事实均曾在训练组合中承担相应角色的新链。 + +| H | 数据bits/参数 | 实测学习bits/参数 | 单跳全池 | 训练组合 | 留出II | II必要事实全对覆盖 | +| ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| 256 | 0.159 | 0.159 | 100.00% | 100.00% | 0.68% | 100.00% | +| 1024 | 0.398 | 0.383 | 93.34% | 94.58% | 0.54% | 90.04% | +| 4096 | 1.352 | 0.627 | 21.81% | 45.75% | 0.83% | 12.60% | +| 16384 | 5.171 | 0.198 | 1.39% | 8.79% | 1.32% | 0.05% | + +固定H=256目标链和组合支持，只增加背景原子：总H=1024/4096/16384的全原子为100.00%/74.46%/7.54%，背景原子为100.00%/73.10%/6.89%，目标II为1.02%/0.68%/0.45%。相应学习密度0.398/1.151/0.971。主扫描增加组合支持，背景臂没有，两者训练内容与更新数不同，不能将差异直接归因于存储串扰。 + +**解释。** 最低负载也未形成可靠原生组合，C₂在全部采样点均未达标；不能估计其尺度指数。原子95%阈值在主扫描的已测成功/失败点为16,384/40,960 bits，仅是指定训练协议的网格结果，非表达能力上限。高负载部分模型连训练组合也未拟合；3,000曝光不自动等于充分优化。增加未学会的知识不构成存储密度提高。 + +两条1000曝光校准lr=.001/.003的原子与训练组合均100%、II为0.68%/1.14%；按原子及训练组合NLL选择lr=.003。唯一3000曝光校准II为0.68%。旧控制器停止事实、随后完整扫描授权及源文件不改写。全部旧任务已释放GPU0–1，新矩阵见下节。 + + +## 容量主线下一步：连续调用与学习成本控制 + +**2026-10-06 07:50，17项全部完成并通过重载/W&B核验，开发批次。** [冻结协议与文献依据](development-artifacts/capacity-recall-controls-v1/protocol.md)、[17项执行配置](development-artifacts/capacity-recall-controls-v1/frozen-config.json)、[实时状态](../results/capacity-recall-controls-v1/controller-state.json)。保留知识世界、模型、初始化和原评分；9个旧权重只读评估，另有8条新训练，GPU0–1各自独立容器，W&B在线记录。19项相关测试及静态检查通过。 + +关键比较是同权重直接组合与模型自产桥的两次原子调用；错桥、oracle分别报告。H=256/1024/4096各增加原子3000曝光和等旧混合训练计算的原子复习；最低负载同父检查点、同后续流比较wd=.01/.1的额外280k更新。它检验表观容量对知识使用协议、训练内容和学习充分性的依赖，不增加宽度/架构网格，不把外部拆题称为隐式组合。最多18 GPU小时是含审计的保守上界，全部分支按固定预算保留。 + +**实际结果：9/9旧检查点评估均已完成且重载通过。** 最低负载自产桥II/OO均100%，原生II0.68%，错桥II0%；主扫描其余三个负载的自产桥II为90.09%/12.84%/0.59%。固定目标背景对照为100%/70.91%/2.16%。前两原子全对时，精确两次调用成功是该算法的预期，不能作为内部机制的新发现；全池曲线区分当前提取失败与原生组合失败。[当前汇总](../results/capacity-recall-controls-v1/report.md)、[曲线](../results/capacity-recall-controls-v1/recall-comparison.png)。8条新增训练也已完成；最低负载额外280k更新后，wd=.01/.1的原生II仍分别0.57%/1.02%，因此保留负结果并转向经过验证的数据/操作训练配方。 + +**07:19训练进度：新增8条已有4条审计完成。** H=256的atomic/atomic_replay原子终点为100%/29.10%；H=1024两者终点均100%，同负载旧mixed为93.34%。H=1024复习中途退化后恢复，说明终点和完整轨迹必须同时解释。H=4096两臂正在训练，两条低负载长期续训排在其后；当前13/17项已审计，无失败。不能据两个低负载开发点确认派生监督必然占用额外容量。 + +本批自动输出逐例预测、学习曲线、曝光、独立审计及`results/capacity-recall-controls-v1/summary.json`、`summary.csv`、`report.md`；未完成前不宣称训练结果。[W&B项目](https://wandb.ai/zhusq20/llm-memory-editability)。 + + +## 容量开发附批：核查训练退化 + +**2026-10-06 07:19冻结并排队。** 新原子复习控制H=256在300/1000曝光达到100%，3000曝光终点仅29.10%，且独立审计通过；原子训练的同负载终点仍100%。H=1024原子3000曝光也为100%，复习臂中途出现退化。这些结果使“派生监督单独压低存储容量”的解释尚不充分，必须保留完整轨迹并排除优化不稳定。 + +独立增加4项有界开发验证：H=256/4096 × 混合训练/等计算原子复习；共同lr=.001、wd=.01、3000曝光，其余原配对条件不变。原lr=.003终点全部保留，新的配对不改写原矩阵。等待前批17项完成并审计，再自动使用GPU0–1；不占GPU3或其它实验资源。最多6 GPU小时含审计，一个已观察开发世界，非确认。[触发证据与协议](development-artifacts/capacity-stability-check-v1/protocol.md)、[冻结配置](development-artifacts/capacity-stability-check-v1/frozen-config.json)、[实时状态](../results/capacity-stability-check-v1/controller-state.json)。 + + +## OO预算复核与优化配置归因 + +**2026-10-06 07:12进度：新增六条中四条完成并审计，另两条在GPU6–7训练；两个旧基线复用，完整2×2归因待本批结束。** + +2026-10-05。独立复算81个历史预测池通过。固定300k更新时，合成φ7.2/Loop在lr=1e-4、wd=.1/.3下OO为3.49%/24.45%；真实图Loop的lr=5e-5/wd=.1为16.73%（三个初始化均值）。旧合成81.34%来自1500k，不能与真实300k当作同更新比较。 + +但两者训练段GPU时间分别约6.50与6.64小时，均为L20X；真实300k的执行输入词元和按一致乘法口径估计的训练FLOPs分别为旧合成1500k的2.13与1.96倍。相同步数不等于相同计算；真实曲线较低也不能简单归因于GPU训练时间不足。合成CUDA graphs与真实动态序列实现不同，实体编码、图、曝光、优化和评分也不同，这仍是历史资源复盘，不是纯数据因果效应。[预算曲线](development-artifacts/oo-budget-attribution-20261005/budget-comparison.png)、[数据及边界](development-artifacts/oo-budget-attribution-20261005/summary.json)、[逐池审计](development-artifacts/oo-budget-attribution-20261005/recount-audit.json)。 + +**10月5日13:24，按用户要求改为GPU 6–7独立并行，首批两条已通过CUDA预飞并进入正式训练。** 固定真实图与Loop4×2、两个配对初始化及300k预算，交叉学习率5e-5/1e-4与wd=.1/.3；复用两条原基线，新增六条、合计1.8M更新。逐节点核对曝光与终点FLOPs，补评八条轨迹0/16k/32k/64k/128k/200k/300k的完整1283题OO；旧64题面板保留且不冒充全池曲线。原36项测试与固定镜像内两个初始化哈希/CPU前向核验已通过，本次调度修订及相关契约40项测试通过；首批两卡各8步CUDA实算及历史step0全预测复现通过，后续每条训练前仍执行相同预飞。D157终止后释放GPU 6–7，原等待控制器已替换；这批只依赖已完成的旧Loop基线，不使用架构主实验结果选参，故移除资源等待。GPU 2–5架构队列继续原样运行。独立LM容器与W&B、六条配置及原冻结源码不变，修订仅改变资源分配和启动顺序，不增加预算。[原冻结协议](development-artifacts/oo-optimizer-attribution-v1/source/docs/development-artifacts/oo-optimizer-attribution-v1/protocol.md)、[调度修订](development-artifacts/oo-optimizer-attribution-parallel-20261005/amendment.md)、[执行配置](development-artifacts/oo-optimizer-attribution-parallel-20261005/execution-config.json)、[实时状态](../results/oo-optimizer-attribution-v1/controller-state.json)。本轮识别优化配置的有限预算作用，不预先宣称找到了唯一机制，也不自动追加长跑或大矩阵。 + -## 参数知识架构：四卡开发进行中 +## 参数知识架构：开发与主实验分批并行 + +**2026-10-06 07:12进度：15条主训练已有12条完成并审计，W8/HC8/D8的init3仍在GPU2/5/4运行；GPU3已空闲。完整配对总结尚待三项结束。** + +2026-10-04 08:09，按用户要求取消全部开发完成后的统一启动关卡。M8/W8/IHC8两档32k开发及重载均完成，依原面板NLL分别选择1e-4/5e-5/1e-4，已在GPU2/3/4启动各自init1的300k主实验；GPU5继续HC8开发。其余主运行待最后开发审计完成后按原选择规则自动接入。提前运行保留独立配置和锁，并与最终主配置逐项核对；训练代码、数据、种子及预算不变。见[调度修订](development-artifacts/parametric-architecture-rolling-20261004/amendment.md)、[主实验实时状态](../results/parametric-architecture-main-v1/controller-state.json)。 2026-10-04。GPU2–5已启动M8/W8/IHC8/HC8首批开发，独立LM容器与W&B记录运行。81项相关测试、实际尺寸参数/历史路径核验、四卡BF16前后向同步、batch512最长序列压力检查均通过；9个工程profile共36次更新单独保留，不计为科学结果。旧D4/D8/Loop九条300k基线的原始预测与审计身份通过复核。 -本轮九条新增32k开发只按原固定面板的原子与训练组合NLL选择学习率；全部独立重载后自动封存主阶段四新增臂×三个初始化×300k，D8设置变化时补三条配对基线。主阶段结束后自动生成逐seed、配对差、均值/样本标准差和必要事实共同正确子集。一个真实图上的初始化重复不解释为独立世界。当前为执行状态，尚无新的架构效果结论；Loop×MoE与知识新增/改写不包含在这批预算。 +本轮九条新增32k开发只按原固定面板的原子与训练组合NLL选择学习率；已完成架构按上述修订提前启动，全部独立重载后封存完整主阶段四新增臂×三个初始化×300k，D8设置变化时补三条配对基线。主阶段结束后自动生成逐seed、配对差、均值/样本标准差和必要事实共同正确子集。一个真实图上的初始化重复不解释为独立世界。当前为执行状态，尚无新的架构效果结论；Loop×MoE与知识新增/改写不包含在这批预算。 见[冻结执行协议](development-artifacts/parametric-architecture-development-v1/source/docs/development-artifacts/parametric-architecture-execution-v1/protocol.md)、[冻结配置](development-artifacts/parametric-architecture-development-v1/frozen-config.json)、[实时状态](../results/parametric-architecture-development-v1/controller-state.json)、[GPU预飞](development-artifacts/parametric-architecture-execution-v1/gpu-preflight.json)与[W&B](https://wandb.ai/zhusq20/llm-memory-editability)。 @@ -52,6 +127,8 @@ D主表先逐目标平均，再初始化／世界等权；回放R与必要原子 **解释与下一步。** 本模板中原子与组合查询的首关系因果前缀相同，因此all直接对齐了严格事实在后续组合中复用的原子状态；严格事实仍没有组合题训练。结果支持把已知原子事实训练成可供后续计算使用的表示；尚未区分首跳、次跳、锚点原子的贡献。整个embedding／attention／MLP联合学习，收益属于受控训练干预，不能单独归因MLP或外推自然预训练LM。下一轮优先检验编辑是否同步更新早期桥状态：在开发集匹配原子写入及保持水平，比较普通CE编辑、额外早期CE、早期CE加新目标表示对齐，D不参与校准选参。这是待检验假说，本轮未执行。 +**预训练监督的解释补充（2026-10-04）。** 普通next-token CE本身会经反向传播监督事实状态；权重共享时，输出端梯度直接涉及正确token的输入embedding，但不能由此推出指定早期层的方向对齐。上述覆盖四臂均保留显式首跳CE，变化的是几何监督范围及归一化。其收益与“在已有事实监督上进一步选择便于复用的表示”相容，不证明普通预训练没有这种能力。见[完整推导、条件与待验证猜想](memory-scaling-theory.md#pretraining-implicit-alignment-20261004)；此补充不改变原实验结果或冻结契约。 + 全部实验使用独立LM容器，固定环境归档保存在[容器记录](development-artifacts/memory-interface-next-v1/container/archive-manifest.json)。最初误用D157 daemon做镜像工程检查的经过与LM隔离修正在[记录](development-artifacts/memory-interface-next-v1/container/isolation-correction.md)。短评价的W&B旧追踪器存在结束扫描竞态，遗漏的10项后来按原run身份补同步，科学文件哈希未变；不追补已结束进程的GPU时间序列，见[补同步验收](../results/bridge-reencoding-confirmation-v1/tracking-recovery/20261004-terminal-drain/verification.json)。 最终[W&B逐运行核验](development-artifacts/memory-interface-next-v1/wandb-final-audit.json)确认67/67均finished且审计通过，全部历史步序与本地学习节点逐项相同。GPU2–5已释放。 @@ -83,7 +160,7 @@ D主表先逐目标平均，再初始化／世界等权；回放R与必要原子 在同一显式关系顺序检查点上，用已审计的自产首跳答案构造下一次单跳输入、不提供正确桥：普通／Loop的OO从20.97／19.33%到99.84／99.69%。同样的关系信息与权重、全部3,729题、两模型共7,458条生成重新计分通过；额外调用与重新编码未匹配FLOPs，不能唯一归因某个内部模块。宽256单词元Loop第一轮即可OO75.06%，完整两轮85.11%，四轮82.31%，也不支持固定“一轮一跳”。[反馈设计](development-artifacts/realworld-loop-diagnosis-v1/bridge-feedback-design.md)、[反馈复算](development-artifacts/realworld-loop-diagnosis-v1/bridge-feedback-summary.json)。 -**解释边界。** 当前结果支持：复杂名称的实体识别／中间表示是共同瓶颈；当首跳近似头实体查表时，普通模型也可获得高OO，Loop的优势不能从多事实共享实体的合成图直接外推。尚未分离实体表示中的每个因素，也未确认唯一神经实现或普遍架构结论。[原论文附录C/E.2](https://arxiv.org/html/2405.15071v3)分别讨论多词元带来的额外学习与单词元参数共享实验；两者不是自然表达下Loop优势的直接证明。旧合成φ7.2/wd.1的OO从300k的3.49%到1500k的53.29%，跨数据比较还受训练时长影响。 +**解释边界。** 当前结果支持：复杂名称的实体识别／中间表示是共同瓶颈；当首跳近似头实体查表时，普通模型也可获得高OO，Loop的优势不能从多事实共享实体的合成图直接外推。尚未分离实体表示中的每个因素，也未确认唯一神经实现或普遍架构结论。[原论文附录C/E.2](https://arxiv.org/html/2405.15071v3)分别讨论多词元带来的额外学习与单词元参数共享实验；两者不是自然表达下Loop优势的直接证明。旧合成φ7.2/wd.1的OO从300k的3.49%到1500k的53.29%，跨数据比较还受更新数、曝光和优化设置影响；[10月5日预算复核](#oo-budget-attribution-20261005)显示两批训练段GPU时间接近，不能笼统归因为真实实验运行时间较短。 产物：[真实图各阶段复算](development-artifacts/realworld-loop-diagnosis-v1/summary.json)、[图结构与旧结果](development-artifacts/realworld-loop-diagnosis-v1/existing-evidence.json)、[实体表示设计](development-artifacts/realworld-loop-entity-v1/design.md)、[第二初始化](development-artifacts/realworld-loop-entity-replica-v1/design.md)。[完成记录](development-artifacts/realworld-loop-diagnosis-v1/completion.json)、[汇总图](development-artifacts/realworld-loop-diagnosis-v1/diagnosis-overview.png)。W&B组为`realworld-loop-diagnosis-v1`，原始预测、检查点和优化器保留在各`results/realworld-loop-*-v1/`目录。 diff --git a/results/capacity-recall-controls-v1/controller-process.json b/results/capacity-recall-controls-v1/controller-process.json new file mode 100644 index 0000000000000000000000000000000000000000..f470b5c225064015e8cbd0e1f2ccc3b93db85f3e --- /dev/null +++ b/results/capacity-recall-controls-v1/controller-process.json @@ -0,0 +1,12 @@ +{ + "pid": 328744, + "command": [ + "/ossfs/workspace/llm-memory-editability/.venv/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "controller", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json" + ], + "utc": "2026-10-05T23:12:03.266781+00:00" +} diff --git a/results/capacity-recall-controls-v1/controller-state.json b/results/capacity-recall-controls-v1/controller-state.json new file mode 100644 index 0000000000000000000000000000000000000000..d35db3d1c062a51d6032416ab2e562ad582b4751 --- /dev/null +++ b/results/capacity-recall-controls-v1/controller-state.json @@ -0,0 +1,33 @@ +{ + "state": "complete", + "started_utc": "2026-10-05T23:12:04.795036+00:00", + "gpus": [ + 0, + 1 + ], + "completed": [ + "recall-calibration-lr0.001", + "recall-calibration-lr0.003", + "recall-calibration-long", + "recall-load-h1024", + "recall-load-h4096", + "recall-load-h16384", + "recall-background-h1024", + "recall-background-h4096", + "recall-background-h16384", + "atomic-h256", + "atomic_replay-h256", + "atomic-h1024", + "atomic_replay-h1024", + "atomic-h4096", + "atomic_replay-h4096", + "continuation-wd0.01", + "continuation-wd0.1" + ], + "failed": [], + "active": {}, + "phase": "development", + "queued": [], + "updated_utc": "2026-10-05T23:50:16.131633+00:00", + "finished_utc": "2026-10-05T23:50:19.155055+00:00" +} diff --git a/results/capacity-recall-controls-v1/controller.log b/results/capacity-recall-controls-v1/controller.log new file mode 100644 index 0000000000000000000000000000000000000000..208e2fc134cf7e715a6b5b050dee51a60c4c915a --- /dev/null +++ b/results/capacity-recall-controls-v1/controller.log @@ -0,0 +1 @@ +{"audited": 17, "expected": 17} diff --git a/results/capacity-recall-controls-v1/frozen-config.json b/results/capacity-recall-controls-v1/frozen-config.json new file mode 100644 index 0000000000000000000000000000000000000000..a1428368249876e306410b62ed70a72da9bd7b5d --- /dev/null +++ b/results/capacity-recall-controls-v1/frozen-config.json @@ -0,0 +1,736 @@ +{ + "batch": "capacity-recall-controls-v1", + "phase": "development", + "scope": "Learning sufficiency and inference-computation controls at fixed knowledge worlds, no new width/architecture or scaling-law fit.", + "results_root": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1", + "gpus": [ + 0, + 1 + ], + "runtime": { + "docker_context": "lm-memory", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "python": "/opt/conda/bin/python", + "cpus": 2, + "memory": "12g" + }, + "tracking": { + "enabled": true, + "entity": "zhusq20", + "project": "llm-memory-editability", + "group": "capacity-recall-controls-v1", + "mode": "online" + }, + "runs": [ + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 1000, + "batch_size": 512, + "learning_rate": 0.001, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-calibration-lr0.001", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.001", + "evaluation_only": true, + "parent_checkpoint_sha256": "12742f5209e46ec02ad20034b4af7bf73dfc44a3a35da73043c4e2dfe05e1fe3" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 1000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-calibration-lr0.003", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.003", + "evaluation_only": true, + "parent_checkpoint_sha256": "dfec03711c24a5f98dd47b70d6a9215d8a57c5cace4ea66c04d0bf13d0bd6e64" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-calibration-long", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "evaluation_only": true, + "parent_checkpoint_sha256": "acce1dcffba24adaa1567f194e127e2c93c0e5db167b0c0cd1ed6a282461e706" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-load-h1024", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024", + "evaluation_only": true, + "parent_checkpoint_sha256": "4dcd2a2de244f6148e0a4795c8dbfd8dfd96f5bc52f1130c9bd8d8e3bf96e42b" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-load-h4096", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096", + "evaluation_only": true, + "parent_checkpoint_sha256": "1e42f08da93caadbb75e8745c1f1f73d254845d63dd43c37bd9063fe9093e91d" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 16384, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-load-h16384", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h16384", + "evaluation_only": true, + "parent_checkpoint_sha256": "ffe7719c9c72dc9863ea1b07881e21152bed831d8433ee50c539d03187e0fb5f" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-background-h1024", + "support_heads_n": 256, + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h1024", + "evaluation_only": true, + "parent_checkpoint_sha256": "7b48f05ff4c68d92e8886424d468f98d2e863cbf85d744699d01db6247fceacf" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-background-h4096", + "support_heads_n": 256, + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h4096", + "evaluation_only": true, + "parent_checkpoint_sha256": "eccc5ea77b121c9432b91883df4606759e71dffb647cfac86da0951926db123a" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 16384, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-background-h16384", + "support_heads_n": 256, + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h16384", + "evaluation_only": true, + "parent_checkpoint_sha256": "b1b040167f1e6219386bc57273eedbba09e268a7560e661b43436bb543f2b644" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic-h256", + "training_mode": "atomic", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic_replay-h256", + "training_mode": "atomic_replay", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic-h1024", + "training_mode": "atomic", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic_replay-h1024", + "training_mode": "atomic_replay", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic-h4096", + "training_mode": "atomic", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic_replay-h4096", + "training_mode": "atomic_replay", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 40000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 1000, + 3000, + 10000, + 20000, + 40000 + ], + "checkpoint_epochs": 1000, + "log_steps": 5000, + "max_wall_seconds": 7200, + "name": "continuation-wd0.01", + "training_mode": "mixed", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "parent_checkpoint_sha256": "acce1dcffba24adaa1567f194e127e2c93c0e5db167b0c0cd1ed6a282461e706" + }, + { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 40000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.1, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 1000, + 3000, + 10000, + 20000, + 40000 + ], + "checkpoint_epochs": 1000, + "log_steps": 5000, + "max_wall_seconds": 7200, + "name": "continuation-wd0.1", + "training_mode": "mixed", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "parent_checkpoint_sha256": "acce1dcffba24adaa1567f194e127e2c93c0e5db167b0c0cd1ed6a282461e706" + } + ], + "budget": { + "new_training_runs": 8, + "old_checkpoints_reused": 9, + "maximum_gpu_hours_including_audit": 17, + "no_score_based_early_stop": true, + "no_automatic_matrix_expansion": true + }, + "additional_sources": [ + "scripts/execute_parametric_architecture.py", + "scripts/execute_capacity_scaling.py", + "scripts/run_capacity_scaling.py", + "scripts/run_capacity_controls.py", + "scripts/capacity_serial_recall.py", + "scripts/evaluate_capacity_recall.py", + "scripts/execute_capacity_controls.py", + "scripts/report_capacity_controls.py", + "tests/test_capacity_controls.py", + "tests/test_capacity_scaling.py", + "docs/development-artifacts/capacity-recall-controls-v1/protocol.md" + ], + "repository": "/ossfs/workspace/llm-memory-editability", + "source_root": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "execution_lock": "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/execution-lock.json", + "frozen_utc": "2026-10-05T23:11:53.390411+00:00", + "git_commit": "b7b1741e5c840b68612c4eeb4fb2248ad5f2be61" +} diff --git a/results/capacity-recall-controls-v1/plot-provenance.json b/results/capacity-recall-controls-v1/plot-provenance.json new file mode 100644 index 0000000000000000000000000000000000000000..23703f1066f6086113934e6b9eea372733533de1 --- /dev/null +++ b/results/capacity-recall-controls-v1/plot-provenance.json @@ -0,0 +1,12 @@ +{ + "source": "results/capacity-recall-controls-v1/summary.json", + "source_sha256": "098f497195248e8d266a17a553df12dbf2b6c35771d6c58c2b798c84e4518c5a", + "script_sha256": "fa6166622ea58b9920c1323d806bbee6814eaccb7e5242fe968c788d1764ed24", + "audited": 9, + "selected": [ + "recall-calibration-long", + "recall-load-h1024", + "recall-load-h4096", + "recall-load-h16384" + ] +} diff --git a/results/capacity-recall-controls-v1/recall-comparison.pdf b/results/capacity-recall-controls-v1/recall-comparison.pdf new file mode 100644 index 0000000000000000000000000000000000000000..75984f381cd9ee3ca6a02c3f19505c13c3d76284 Binary files /dev/null and b/results/capacity-recall-controls-v1/recall-comparison.pdf differ diff --git a/results/capacity-recall-controls-v1/recall-comparison.png b/results/capacity-recall-controls-v1/recall-comparison.png new file mode 100644 index 0000000000000000000000000000000000000000..b4561d66880e2a78c3d4447f05dbfe3e9c649a9d --- /dev/null +++ b/results/capacity-recall-controls-v1/recall-comparison.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:58304887b7c6425bef03adff93a75c0e8fde6002f29246cd9564ae3f81f488e3 +size 146693 diff --git a/results/capacity-recall-controls-v1/report.md b/results/capacity-recall-controls-v1/report.md new file mode 100644 index 0000000000000000000000000000000000000000..c2896317908651a6a45939535be3f81eb691dbda --- /dev/null +++ b/results/capacity-recall-controls-v1/report.md @@ -0,0 +1,29 @@ +# 存储、连续调用与学习控制 + +完成重载审计 17/17；一个开发世界、一个初始化。 + +| 运行 | bits/参数 | 单跳 | 直接II | 自产桥II | 错桥II | 自产桥OO | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | +| recall-calibration-lr0.001 | 0.159 | 100.00% | 0.68% | 100.00% | 0.00% | 100.00% | +| recall-calibration-lr0.003 | 0.159 | 100.00% | 1.14% | 100.00% | 0.00% | 100.00% | +| recall-calibration-long | 0.159 | 100.00% | 0.68% | 100.00% | 0.00% | 100.00% | +| recall-load-h1024 | 0.398 | 93.34% | 0.54% | 90.09% | 0.39% | 88.62% | +| recall-load-h4096 | 1.352 | 21.81% | 0.83% | 12.84% | 0.63% | 12.26% | +| recall-load-h16384 | 5.171 | 1.39% | 1.32% | 0.59% | 0.83% | 0.34% | +| recall-background-h1024 | 0.398 | 100.00% | 1.02% | 100.00% | 0.00% | 100.00% | +| recall-background-h4096 | 1.352 | 74.46% | 0.68% | 70.91% | 0.45% | 75.55% | +| recall-background-h16384 | 5.171 | 7.54% | 0.45% | 2.16% | 0.68% | 2.76% | +| atomic-h256 | 0.159 | 100.00% | 0.00% | 100.00% | 0.00% | 100.00% | +| atomic_replay-h256 | 0.159 | 29.10% | 0.00% | 10.80% | 0.45% | 6.99% | +| atomic-h1024 | 0.398 | 100.00% | 0.00% | 100.00% | 0.39% | 100.00% | +| atomic_replay-h1024 | 0.398 | 100.00% | 0.00% | 100.00% | 0.39% | 100.00% | +| atomic-h4096 | 1.352 | 71.65% | 0.00% | 64.31% | 0.49% | 64.11% | +| atomic_replay-h4096 | 1.352 | 76.79% | 0.00% | 65.28% | 1.07% | 69.53% | +| continuation-wd0.01 | 0.159 | 100.00% | 0.57% | 100.00% | 0.00% | 100.00% | +| continuation-wd0.1 | 0.159 | 100.00% | 1.02% | 100.00% | 0.00% | 100.00% | + +自产桥使用模型自行生成的实体及公开拆题规则，增加一次调用；oracle单列。它不证明网络内部已学会组合，也不单独证明串扰机制。 + +原子复习对照与旧混合训练匹配样本总数、更新数及名义矩阵计算，但多了原子曝光；原子单独训练匹配原子曝光，总计算较少。两个对照共同解释训练配方成本。 + +后续先依据原生组合的完整学习轨迹判断学习前提；在其建立前，不拟合组合容量尺度律。 diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/audit.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..4be4439a5676caf0b056f98dd4b96e1724491109 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "bc532147aec498c6e878d08ab2c16389553eb6e51e02d1e195c580b8605f6d0e", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 6.343187124002725e-05, + "knowledge_nll": 6.321673572529107e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 6.535269494634122e-05, + "knowledge_nll": 6.520927126985043e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32767.614660230018 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 5.574858369072899e-05, + "knowledge_nll": 5.524660082301125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.918383107038 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.4780502319336, + "knowledge_nll": 60.92633056640625, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.73646545410156, + "knowledge_nll": 60.789772033691406, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.14728546142578, + "knowledge_nll": 60.069427490234375, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 89.3138198852539, + "knowledge_nll": 59.68183898925781, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.79078674316406, + "knowledge_nll": 60.41696548461914, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40959.5330433478, + "learned_bits_per_parameter": 0.3977580508404657 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 15360000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:16:07.403110+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/complete.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..4be4439a5676caf0b056f98dd4b96e1724491109 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "bc532147aec498c6e878d08ab2c16389553eb6e51e02d1e195c580b8605f6d0e", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 6.343187124002725e-05, + "knowledge_nll": 6.321673572529107e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 6.535269494634122e-05, + "knowledge_nll": 6.520927126985043e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32767.614660230018 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 5.574858369072899e-05, + "knowledge_nll": 5.524660082301125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.918383107038 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.4780502319336, + "knowledge_nll": 60.92633056640625, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.73646545410156, + "knowledge_nll": 60.789772033691406, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.14728546142578, + "knowledge_nll": 60.069427490234375, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 89.3138198852539, + "knowledge_nll": 59.68183898925781, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.79078674316406, + "knowledge_nll": 60.41696548461914, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40959.5330433478, + "learned_bits_per_parameter": 0.3977580508404657 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 15360000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:16:07.403110+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/container-command-1.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..4caa73897051e73b1ae49845eecb6925586d13c6 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-efac2daf2e15820debe1", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-efac2daf2e15820debe1", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h1024,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h1024", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h1024" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/container-inspect.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..4ba4743eb91df43e371daaf29ccddfb9fa593fb9 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78", + "Created": "2026-10-05T23:13:57.644934021Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h1024" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:13:57.654806627Z", + "FinishedAt": "2026-10-05T23:16:08.080314091Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78/ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78-json.log", + "Name": "/lm-capctrl-efac2daf2e15820debe1", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h1024", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h1024" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/f04890a5ba880ccf10b7659cfc043d369ad54e03c6c64772a8e4cebd495f83ed-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/f04890a5ba880ccf10b7659cfc043d369ad54e03c6c64772a8e4cebd495f83ed/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/f04890a5ba880ccf10b7659cfc043d369ad54e03c6c64772a8e4cebd495f83ed/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/f04890a5ba880ccf10b7659cfc043d369ad54e03c6c64772a8e4cebd495f83ed/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h1024", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h1024", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "ce8dbf393004", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "TORCH_HOME=/tmp/torch", + "PHYSICAL_GPU=1", + "PYTHONDONTWRITEBYTECODE=1", + "MKL_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h1024" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/container-runtime.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..a8a5af605358ed9974cb3f186ffd9e695bbb970e --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 334572, + "container_id": "ce8dbf393004def9ebf861f7eace9ae5373c2f6ad3ccbe17465e3bf787d88f78", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/learning.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..69385d828ff235dbae3d006ef5992def86689550 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/learning.json @@ -0,0 +1,1237 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.86443328857422, + "knowledge_nll": 12.675850868225098, + "identifier_accuracy": 0.0, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.454959869384766, + "knowledge_nll": 12.738142013549805, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.45623016357422, + "knowledge_nll": 12.748790740966797, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.442459106445312, + "knowledge_nll": 12.72464370727539, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 19.457590103149414, + "knowledge_nll": 12.738996505737305, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.454479217529297, + "knowledge_nll": 12.738774299621582, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.39597557857632637, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 86559232, + "created_utc": "2026-10-05T23:14:03.969851+00:00" + }, + { + "step": 100, + "epoch": 10, + "cumulative_step": 100, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0048828125, + "answer_nll": 5.5905256271362305, + "knowledge_nll": 5.57071590423584, + "identifier_accuracy": 0.0048828125, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 25.865991592407227, + "knowledge_nll": 15.159479141235352, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.0048828125, + "second_atomic_accuracy": 0.00439453125, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 25.92813491821289, + "knowledge_nll": 15.212459564208984, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.00537109375, + "second_atomic_accuracy": 0.00244140625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 25.852794647216797, + "knowledge_nll": 15.163931846618652, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.00537109375, + "second_atomic_accuracy": 0.00390625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 25.886585235595703, + "knowledge_nll": 15.170295715332031, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.003178639542275906, + "second_atomic_accuracy": 0.0019071837253655435, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 25.873517990112305, + "knowledge_nll": 15.170705795288086, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.933556854724884, + "training_seconds": 0.49966470897197723, + "wall_seconds": 1.2887680381536484, + "examples": 51200, + "supervised_tokens": 307200, + "executed_input_tokens": 1433600, + "estimated_matmul_training_flops": 441856819200, + "atomic_epochs": 10.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:04.862679+00:00" + }, + { + "step": 300, + "epoch": 30, + "cumulative_step": 300, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0068359375, + "answer_nll": 5.547954559326172, + "knowledge_nll": 5.54464054107666, + "identifier_accuracy": 0.0068359375, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 29.888866424560547, + "knowledge_nll": 18.01879119873047, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.001953125, + "second_atomic_accuracy": 0.009765625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 29.984703063964844, + "knowledge_nll": 18.086875915527344, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.01904296875, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 29.83235740661621, + "knowledge_nll": 18.021331787109375, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.0048828125, + "second_atomic_accuracy": 0.0048828125, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 29.937484741210938, + "knowledge_nll": 18.06194305419922, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.01652892561983471, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 29.90966033935547, + "knowledge_nll": 18.031017303466797, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.9252755045890808, + "training_seconds": 1.2221772074699402, + "wall_seconds": 2.398868940770626, + "examples": 153600, + "supervised_tokens": 921600, + "executed_input_tokens": 4300800, + "estimated_matmul_training_flops": 1325570457600, + "atomic_epochs": 30.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:05.972709+00:00" + }, + { + "step": 1000, + "epoch": 100, + "cumulative_step": 1000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.06640625, + "answer_nll": 4.371599197387695, + "knowledge_nll": 4.369657039642334, + "identifier_accuracy": 0.06640625, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 33.1290283203125, + "knowledge_nll": 16.978315353393555, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.0625, + "second_atomic_accuracy": 0.083984375, + "both_atomic_n": 12, + "both_atomic_coverage": 0.005859375, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 33.380455017089844, + "knowledge_nll": 16.848186492919922, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.06640625, + "second_atomic_accuracy": 0.1015625, + "both_atomic_n": 12, + "both_atomic_coverage": 0.005859375, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 33.273372650146484, + "knowledge_nll": 17.037343978881836, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.0576171875, + "second_atomic_accuracy": 0.08984375, + "both_atomic_n": 8, + "both_atomic_coverage": 0.00390625, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 33.662811279296875, + "knowledge_nll": 17.00943374633789, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.06102987921169739, + "second_atomic_accuracy": 0.10998092816274635, + "both_atomic_n": 14, + "both_atomic_coverage": 0.008900190718372537, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 33.17208480834961, + "knowledge_nll": 16.936538696289062, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.7667071223258972, + "training_seconds": 3.690600272268057, + "wall_seconds": 5.39340441301465, + "examples": 512000, + "supervised_tokens": 3072000, + "executed_input_tokens": 14336000, + "estimated_matmul_training_flops": 4418568192000, + "atomic_epochs": 100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:08.967353+00:00" + }, + { + "step": 2000, + "epoch": 200, + "cumulative_step": 2000, + "metrics": {}, + "loss": 0.0005494210054166615, + "training_seconds": 7.444970205426216, + "wall_seconds": 9.437058310955763, + "examples": 1024000, + "supervised_tokens": 6144000, + "executed_input_tokens": 28672000, + "estimated_matmul_training_flops": 8837136384000, + "atomic_epochs": 200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:13.011030+00:00" + }, + { + "step": 3000, + "epoch": 300, + "cumulative_step": 3000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0009371991036459804, + "knowledge_nll": 0.0009208854753524065, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 68.17748260498047, + "knowledge_nll": 45.45548629760742, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 68.20050048828125, + "knowledge_nll": 45.060943603515625, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 68.3951644897461, + "knowledge_nll": 45.702842712402344, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 68.91256713867188, + "knowledge_nll": 45.72802734375, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 68.28761291503906, + "knowledge_nll": 45.384765625, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.0001579884992679581, + "training_seconds": 11.082978431135416, + "wall_seconds": 13.71276343986392, + "examples": 1536000, + "supervised_tokens": 9216000, + "executed_input_tokens": 43008000, + "estimated_matmul_training_flops": 13255704576000, + "atomic_epochs": 300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:17.286678+00:00" + }, + { + "step": 4000, + "epoch": 400, + "cumulative_step": 4000, + "metrics": {}, + "loss": 8.508832979714498e-05, + "training_seconds": 14.681950941681862, + "wall_seconds": 17.60285560786724, + "examples": 2048000, + "supervised_tokens": 12288000, + "executed_input_tokens": 57344000, + "estimated_matmul_training_flops": 17674272768000, + "atomic_epochs": 400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:21.176731+00:00" + }, + { + "step": 5000, + "epoch": 500, + "cumulative_step": 5000, + "metrics": {}, + "loss": 4.975076808477752e-05, + "training_seconds": 18.201787166297436, + "wall_seconds": 21.418689224869013, + "examples": 2560000, + "supervised_tokens": 15360000, + "executed_input_tokens": 71680000, + "estimated_matmul_training_flops": 22092840960000, + "atomic_epochs": 500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:24.992600+00:00" + }, + { + "step": 6000, + "epoch": 600, + "cumulative_step": 6000, + "metrics": {}, + "loss": 2.9358021492953412e-05, + "training_seconds": 21.70967347547412, + "wall_seconds": 25.219146858900785, + "examples": 3072000, + "supervised_tokens": 18432000, + "executed_input_tokens": 86016000, + "estimated_matmul_training_flops": 26511409152000, + "atomic_epochs": 600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:28.793078+00:00" + }, + { + "step": 7000, + "epoch": 700, + "cumulative_step": 7000, + "metrics": {}, + "loss": 1.796401193132624e-05, + "training_seconds": 25.228560004383326, + "wall_seconds": 29.019448701292276, + "examples": 3584000, + "supervised_tokens": 21504000, + "executed_input_tokens": 100352000, + "estimated_matmul_training_flops": 30929977344000, + "atomic_epochs": 700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:32.593369+00:00" + }, + { + "step": 8000, + "epoch": 800, + "cumulative_step": 8000, + "metrics": {}, + "loss": 1.1055807590309996e-05, + "training_seconds": 28.75463266298175, + "wall_seconds": 32.837862972170115, + "examples": 4096000, + "supervised_tokens": 24576000, + "executed_input_tokens": 114688000, + "estimated_matmul_training_flops": 35348545536000, + "atomic_epochs": 800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:36.411833+00:00" + }, + { + "step": 9000, + "epoch": 900, + "cumulative_step": 9000, + "metrics": {}, + "loss": 6.433680482587079e-06, + "training_seconds": 32.259405344724655, + "wall_seconds": 36.62217069044709, + "examples": 4608000, + "supervised_tokens": 27648000, + "executed_input_tokens": 129024000, + "estimated_matmul_training_flops": 39767113728000, + "atomic_epochs": 900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:40.196108+00:00" + }, + { + "step": 10000, + "epoch": 1000, + "cumulative_step": 10000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 2.2730197088094428e-05, + "knowledge_nll": 2.211831815657206e-05, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 82.20355224609375, + "knowledge_nll": 55.02802658081055, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 82.13705444335938, + "knowledge_nll": 54.64201354980469, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 82.40220642089844, + "knowledge_nll": 55.25059509277344, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 83.01239776611328, + "knowledge_nll": 55.420318603515625, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 82.3180160522461, + "knowledge_nll": 55.04753494262695, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 3.863210167764919e-06, + "training_seconds": 35.7844134606421, + "wall_seconds": 40.744907058775425, + "examples": 5120000, + "supervised_tokens": 30720000, + "executed_input_tokens": 143360000, + "estimated_matmul_training_flops": 44185681920000, + "atomic_epochs": 1000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:44.318819+00:00" + }, + { + "step": 11000, + "epoch": 1100, + "cumulative_step": 11000, + "metrics": {}, + "loss": 2.2709025415679207e-06, + "training_seconds": 39.27117042243481, + "wall_seconds": 44.51737080141902, + "examples": 5632000, + "supervised_tokens": 33792000, + "executed_input_tokens": 157696000, + "estimated_matmul_training_flops": 48604250112000, + "atomic_epochs": 1100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:48.091310+00:00" + }, + { + "step": 12000, + "epoch": 1200, + "cumulative_step": 12000, + "metrics": {}, + "loss": 1.36900143843377e-06, + "training_seconds": 42.74465172365308, + "wall_seconds": 48.274829406291246, + "examples": 6144000, + "supervised_tokens": 36864000, + "executed_input_tokens": 172032000, + "estimated_matmul_training_flops": 53022818304000, + "atomic_epochs": 1200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:51.848681+00:00" + }, + { + "step": 13000, + "epoch": 1300, + "cumulative_step": 13000, + "metrics": {}, + "loss": 7.648863515896664e-07, + "training_seconds": 46.23350494354963, + "wall_seconds": 52.051517371088266, + "examples": 6656000, + "supervised_tokens": 39936000, + "executed_input_tokens": 186368000, + "estimated_matmul_training_flops": 57441386496000, + "atomic_epochs": 1300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:55.625358+00:00" + }, + { + "step": 14000, + "epoch": 1400, + "cumulative_step": 14000, + "metrics": {}, + "loss": 4.4098092644162534e-07, + "training_seconds": 49.79371624812484, + "wall_seconds": 55.900155890733004, + "examples": 7168000, + "supervised_tokens": 43008000, + "executed_input_tokens": 200704000, + "estimated_matmul_training_flops": 61859954688000, + "atomic_epochs": 1400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:59.474037+00:00" + }, + { + "step": 15000, + "epoch": 1500, + "cumulative_step": 15000, + "metrics": {}, + "loss": 2.5894641453305667e-07, + "training_seconds": 53.278279796242714, + "wall_seconds": 59.671137280762196, + "examples": 7680000, + "supervised_tokens": 46080000, + "executed_input_tokens": 215040000, + "estimated_matmul_training_flops": 66278522880000, + "atomic_epochs": 1500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:03.245055+00:00" + }, + { + "step": 16000, + "epoch": 1600, + "cumulative_step": 16000, + "metrics": {}, + "loss": 1.5304733835819206e-07, + "training_seconds": 56.891017846763134, + "wall_seconds": 63.58739659562707, + "examples": 8192000, + "supervised_tokens": 49152000, + "executed_input_tokens": 229376000, + "estimated_matmul_training_flops": 70697091072000, + "atomic_epochs": 1600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:07.161331+00:00" + }, + { + "step": 17000, + "epoch": 1700, + "cumulative_step": 17000, + "metrics": {}, + "loss": 9.371432696525517e-08, + "training_seconds": 60.391264989972115, + "wall_seconds": 67.39521553367376, + "examples": 8704000, + "supervised_tokens": 52224000, + "executed_input_tokens": 243712000, + "estimated_matmul_training_flops": 75115659264000, + "atomic_epochs": 1700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:10.969122+00:00" + }, + { + "step": 18000, + "epoch": 1800, + "cumulative_step": 18000, + "metrics": {}, + "loss": 5.778079881224585e-08, + "training_seconds": 63.930141888558865, + "wall_seconds": 71.22909298539162, + "examples": 9216000, + "supervised_tokens": 55296000, + "executed_input_tokens": 258048000, + "estimated_matmul_training_flops": 79534227456000, + "atomic_epochs": 1800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:14.802961+00:00" + }, + { + "step": 19000, + "epoch": 1900, + "cumulative_step": 19000, + "metrics": {}, + "loss": 3.577830653966885e-08, + "training_seconds": 67.63540022820234, + "wall_seconds": 75.23449509590864, + "examples": 9728000, + "supervised_tokens": 58368000, + "executed_input_tokens": 272384000, + "estimated_matmul_training_flops": 83952795648000, + "atomic_epochs": 1900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:18.808334+00:00" + }, + { + "step": 20000, + "epoch": 2000, + "cumulative_step": 20000, + "metrics": {}, + "loss": 2.3671113069667626e-08, + "training_seconds": 71.179822281003, + "wall_seconds": 79.07128040120006, + "examples": 10240000, + "supervised_tokens": 61440000, + "executed_input_tokens": 286720000, + "estimated_matmul_training_flops": 88371363840000, + "atomic_epochs": 2000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:22.645127+00:00" + }, + { + "step": 21000, + "epoch": 2100, + "cumulative_step": 21000, + "metrics": {}, + "loss": 0.7118761539459229, + "training_seconds": 74.83676226064563, + "wall_seconds": 83.03287884220481, + "examples": 10752000, + "supervised_tokens": 64512000, + "executed_input_tokens": 301056000, + "estimated_matmul_training_flops": 92789932032000, + "atomic_epochs": 2100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:26.606773+00:00" + }, + { + "step": 22000, + "epoch": 2200, + "cumulative_step": 22000, + "metrics": {}, + "loss": 0.12838195264339447, + "training_seconds": 78.37874126434326, + "wall_seconds": 86.86981659755111, + "examples": 11264000, + "supervised_tokens": 67584000, + "executed_input_tokens": 315392000, + "estimated_matmul_training_flops": 97208500224000, + "atomic_epochs": 2200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:30.443718+00:00" + }, + { + "step": 23000, + "epoch": 2300, + "cumulative_step": 23000, + "metrics": {}, + "loss": 0.06886986643075943, + "training_seconds": 82.02510608360171, + "wall_seconds": 91.53761695325375, + "examples": 11776000, + "supervised_tokens": 70656000, + "executed_input_tokens": 329728000, + "estimated_matmul_training_flops": 101627068416000, + "atomic_epochs": 2300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:35.111518+00:00" + }, + { + "step": 24000, + "epoch": 2400, + "cumulative_step": 24000, + "metrics": {}, + "loss": 0.0002425342536298558, + "training_seconds": 85.59156242385507, + "wall_seconds": 95.3893394432962, + "examples": 12288000, + "supervised_tokens": 73728000, + "executed_input_tokens": 344064000, + "estimated_matmul_training_flops": 106045636608000, + "atomic_epochs": 2400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:38.963242+00:00" + }, + { + "step": 25000, + "epoch": 2500, + "cumulative_step": 25000, + "metrics": {}, + "loss": 9.837334073381498e-05, + "training_seconds": 89.09877760708332, + "wall_seconds": 99.18292828276753, + "examples": 12800000, + "supervised_tokens": 76800000, + "executed_input_tokens": 358400000, + "estimated_matmul_training_flops": 110464204800000, + "atomic_epochs": 2500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:42.756782+00:00" + }, + { + "step": 26000, + "epoch": 2600, + "cumulative_step": 26000, + "metrics": {}, + "loss": 6.440577999455854e-05, + "training_seconds": 92.58487570658326, + "wall_seconds": 102.95207846909761, + "examples": 13312000, + "supervised_tokens": 79872000, + "executed_input_tokens": 372736000, + "estimated_matmul_training_flops": 114882772992000, + "atomic_epochs": 2600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:46.525929+00:00" + }, + { + "step": 27000, + "epoch": 2700, + "cumulative_step": 27000, + "metrics": {}, + "loss": 4.014914156869054e-05, + "training_seconds": 96.10900523886085, + "wall_seconds": 106.76634157076478, + "examples": 13824000, + "supervised_tokens": 82944000, + "executed_input_tokens": 387072000, + "estimated_matmul_training_flops": 119301341184000, + "atomic_epochs": 2700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:50.340288+00:00" + }, + { + "step": 28000, + "epoch": 2800, + "cumulative_step": 28000, + "metrics": {}, + "loss": 2.8668562663369812e-05, + "training_seconds": 99.60678503289819, + "wall_seconds": 110.54745886474848, + "examples": 14336000, + "supervised_tokens": 86016000, + "executed_input_tokens": 401408000, + "estimated_matmul_training_flops": 123719909376000, + "atomic_epochs": 2800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:54.121428+00:00" + }, + { + "step": 29000, + "epoch": 2900, + "cumulative_step": 29000, + "metrics": {}, + "loss": 1.720644831948448e-05, + "training_seconds": 103.12708124145865, + "wall_seconds": 114.36176979541779, + "examples": 14848000, + "supervised_tokens": 89088000, + "executed_input_tokens": 415744000, + "estimated_matmul_training_flops": 128138477568000, + "atomic_epochs": 2900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:57.935718+00:00" + }, + { + "step": 30000, + "epoch": 3000, + "cumulative_step": 30000, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 6.343187124002725e-05, + "knowledge_nll": 6.321673572529107e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 6.535269494634122e-05, + "knowledge_nll": 6.520927126985043e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32767.614660230018 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 5.574858369072899e-05, + "knowledge_nll": 5.524660082301125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.918383107038 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.4780502319336, + "knowledge_nll": 60.92633056640625, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.73646545410156, + "knowledge_nll": 60.789772033691406, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.14728546142578, + "knowledge_nll": 60.069427490234375, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 89.3138198852539, + "knowledge_nll": 59.68183898925781, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.79078674316406, + "knowledge_nll": 60.41696548461914, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40959.5330433478, + "learned_bits_per_parameter": 0.3977580508404657 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 1.0915021448454354e-05, + "training_seconds": 106.63424841314554, + "wall_seconds": 118.88702230527997, + "examples": 15360000, + "supervised_tokens": 92160000, + "executed_input_tokens": 430080000, + "estimated_matmul_training_flops": 132557045760000, + "atomic_epochs": 3000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:02.460939+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/preflight.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/run.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/run.json new file mode 100644 index 0000000000000000000000000000000000000000..f788450d2c74ca2bb8362a1223757c613de27ad5 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/run.json @@ -0,0 +1,195 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic-h1024", + "training_mode": "atomic", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024" + }, + "world_sha256": "bc532147aec498c6e878d08ab2c16389553eb6e51e02d1e195c580b8605f6d0e", + "initial_model_sha256": "92086c98673d3bc1f9a6571266eec6d392bba58e3b70733208be49cad5e48d4f", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 5120, + "composition_examples": 4673, + "evaluation_nodes": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 0, + "parent_examples": 0, + "training_mode": "atomic", + "created_utc": "2026-10-05T23:14:03.527442+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/status.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/status.json new file mode 100644 index 0000000000000000000000000000000000000000..00700617401f2547ef66cf57368aac09732a948e --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 30000 +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/trained.json b/results/capacity-recall-controls-v1/runs/atomic-h1024/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..872f330b40bd47dfc38ae43e641a86a704d2e722 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "2feaf22fcc9991ba968315116149e48e8b1eb037098e5aee5c36ebea07c4980b", + "epochs": 3000, + "step": 30000, + "training_pid": 44, + "created_utc": "2026-10-05T23:16:02.562332+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h1024/worker.log b/results/capacity-recall-controls-v1/runs/atomic-h1024/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..56f58cabbfce94fb2243c90024a1ebc83ba621eb --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h1024/worker.log @@ -0,0 +1,33 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.86443328857422, "knowledge_nll": 12.675850868225098, "identifier_accuracy": 0.0, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.454959869384766, "knowledge_nll": 12.738142013549805, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.45623016357422, "knowledge_nll": 12.748790740966797, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.442459106445312, "knowledge_nll": 12.72464370727539, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 19.457590103149414, "knowledge_nll": 12.738996505737305, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.454479217529297, "knowledge_nll": 12.738774299621582, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 100, "epoch": 10, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0048828125, "answer_nll": 5.5905256271362305, "knowledge_nll": 5.57071590423584, "identifier_accuracy": 0.0048828125, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 25.865991592407227, "knowledge_nll": 15.159479141235352, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.0048828125, "second_atomic_accuracy": 0.00439453125, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 25.92813491821289, "knowledge_nll": 15.212459564208984, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.00537109375, "second_atomic_accuracy": 0.00244140625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 25.852794647216797, "knowledge_nll": 15.163931846618652, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.00537109375, "second_atomic_accuracy": 0.00390625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 25.886585235595703, "knowledge_nll": 15.170295715332031, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.003178639542275906, "second_atomic_accuracy": 0.0019071837253655435, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 25.873517990112305, "knowledge_nll": 15.170705795288086, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 300, "epoch": 30, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0068359375, "answer_nll": 5.547954559326172, "knowledge_nll": 5.54464054107666, "identifier_accuracy": 0.0068359375, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 29.888866424560547, "knowledge_nll": 18.01879119873047, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.001953125, "second_atomic_accuracy": 0.009765625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 29.984703063964844, "knowledge_nll": 18.086875915527344, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.01904296875, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 29.83235740661621, "knowledge_nll": 18.021331787109375, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.0048828125, "second_atomic_accuracy": 0.0048828125, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 29.937484741210938, "knowledge_nll": 18.06194305419922, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.01652892561983471, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 29.90966033935547, "knowledge_nll": 18.031017303466797, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 1000, "epoch": 100, "metrics": {"atomic": {"n": 2048, "accuracy": 0.06640625, "answer_nll": 4.371599197387695, "knowledge_nll": 4.369657039642334, "identifier_accuracy": 0.06640625, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 33.1290283203125, "knowledge_nll": 16.978315353393555, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.0625, "second_atomic_accuracy": 0.083984375, "both_atomic_n": 12, "both_atomic_coverage": 0.005859375, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 33.380455017089844, "knowledge_nll": 16.848186492919922, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.06640625, "second_atomic_accuracy": 0.1015625, "both_atomic_n": 12, "both_atomic_coverage": 0.005859375, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 33.273372650146484, "knowledge_nll": 17.037343978881836, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.0576171875, "second_atomic_accuracy": 0.08984375, "both_atomic_n": 8, "both_atomic_coverage": 0.00390625, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 33.662811279296875, "knowledge_nll": 17.00943374633789, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.06102987921169739, "second_atomic_accuracy": 0.10998092816274635, "both_atomic_n": 14, "both_atomic_coverage": 0.008900190718372537, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 33.17208480834961, "knowledge_nll": 16.936538696289062, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 2000, "epoch": 200, "metrics": {}} +{"step": 3000, "epoch": 300, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.0009371991036459804, "knowledge_nll": 0.0009208854753524065, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 68.17748260498047, "knowledge_nll": 45.45548629760742, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 68.20050048828125, "knowledge_nll": 45.060943603515625, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 68.3951644897461, "knowledge_nll": 45.702842712402344, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 68.91256713867188, "knowledge_nll": 45.72802734375, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 68.28761291503906, "knowledge_nll": 45.384765625, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 4000, "epoch": 400, "metrics": {}} +{"step": 5000, "epoch": 500, "metrics": {}} +{"step": 6000, "epoch": 600, "metrics": {}} +{"step": 7000, "epoch": 700, "metrics": {}} +{"step": 8000, "epoch": 800, "metrics": {}} +{"step": 9000, "epoch": 900, "metrics": {}} +{"step": 10000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 2.2730197088094428e-05, "knowledge_nll": 2.211831815657206e-05, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 82.20355224609375, "knowledge_nll": 55.02802658081055, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 82.13705444335938, "knowledge_nll": 54.64201354980469, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 82.40220642089844, "knowledge_nll": 55.25059509277344, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 83.01239776611328, "knowledge_nll": 55.420318603515625, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 82.3180160522461, "knowledge_nll": 55.04753494262695, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 11000, "epoch": 1100, "metrics": {}} +{"step": 12000, "epoch": 1200, "metrics": {}} +{"step": 13000, "epoch": 1300, "metrics": {}} +{"step": 14000, "epoch": 1400, "metrics": {}} +{"step": 15000, "epoch": 1500, "metrics": {}} +{"step": 16000, "epoch": 1600, "metrics": {}} +{"step": 17000, "epoch": 1700, "metrics": {}} +{"step": 18000, "epoch": 1800, "metrics": {}} +{"step": 19000, "epoch": 1900, "metrics": {}} +{"step": 20000, "epoch": 2000, "metrics": {}} +{"step": 21000, "epoch": 2100, "metrics": {}} +{"step": 22000, "epoch": 2200, "metrics": {}} +{"step": 23000, "epoch": 2300, "metrics": {}} +{"step": 24000, "epoch": 2400, "metrics": {}} +{"step": 25000, "epoch": 2500, "metrics": {}} +{"step": 26000, "epoch": 2600, "metrics": {}} +{"step": 27000, "epoch": 2700, "metrics": {}} +{"step": 28000, "epoch": 2800, "metrics": {}} +{"step": 29000, "epoch": 2900, "metrics": {}} +{"step": 30000, "epoch": 3000, "metrics": {"atomic": {"n": 5120, "accuracy": 1.0, "answer_nll": 6.343187124002725e-05, "knowledge_nll": 6.321673572529107e-05, "identifier_accuracy": 1.0, "full_population": true}, "atomic_first": {"n": 4096, "accuracy": 1.0, "answer_nll": 6.535269494634122e-05, "knowledge_nll": 6.520927126985043e-05, "identifier_accuracy": 1.0, "learned_bits_raw": 32767.614660230018}, "atomic_second": {"n": 1024, "accuracy": 1.0, "answer_nll": 5.574858369072899e-05, "knowledge_nll": 5.524660082301125e-05, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.918383107038}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 90.4780502319336, "knowledge_nll": 60.92633056640625, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 90.73646545410156, "knowledge_nll": 60.789772033691406, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 89.14728546142578, "knowledge_nll": 60.069427490234375, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 89.3138198852539, "knowledge_nll": 59.68183898925781, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 89.79078674316406, "knowledge_nll": 60.41696548461914, "identifier_accuracy": 0.0, "population_n": 4673}, "information": {"independent_facts": 5120, "world_bits": 40960.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 0.3977625854568055, "composition_independent_bits": 0, "learned_bits_raw": 40959.5330433478, "learned_bits_per_parameter": 0.3977580508404657}, "serial_II": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 2048, "accuracy": 0.00390625, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.00390625, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 2048, "accuracy": 0.00439453125, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.00439453125, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 2048, "accuracy": 0.001953125, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.001953125, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 1573, "accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 1573, "accuracy": 0.003814367450731087, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.003814367450731087, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 1573, "accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/audit.json b/results/capacity-recall-controls-v1/runs/atomic-h256/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..bf89de233342f38e8cbab0081c865b23271fac4d --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 1.852807258728717e-06, + "knowledge_nll": 1.6105470876937034e-06, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.9262070054537617e-06, + "knowledge_nll": 1.6569385934417369e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997552171938 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.7794075120036723e-06, + "knowledge_nll": 1.5641555819456698e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997689242111 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 75.06710815429688, + "knowledge_nll": 46.6080436706543, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 74.91608428955078, + "knowledge_nll": 46.640281677246094, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 75.52379608154297, + "knowledge_nll": 47.41034698486328, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 74.99325561523438, + "knowledge_nll": 46.99372863769531, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 75.2520980834961, + "knowledge_nll": 47.073333740234375, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.995241414048, + "learned_bits_per_parameter": 0.15910498797209105 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 6144000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:13:56.149201+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/complete.json b/results/capacity-recall-controls-v1/runs/atomic-h256/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..bf89de233342f38e8cbab0081c865b23271fac4d --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 1.852807258728717e-06, + "knowledge_nll": 1.6105470876937034e-06, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.9262070054537617e-06, + "knowledge_nll": 1.6569385934417369e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997552171938 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.7794075120036723e-06, + "knowledge_nll": 1.5641555819456698e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997689242111 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 75.06710815429688, + "knowledge_nll": 46.6080436706543, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 74.91608428955078, + "knowledge_nll": 46.640281677246094, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 75.52379608154297, + "knowledge_nll": 47.41034698486328, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 74.99325561523438, + "knowledge_nll": 46.99372863769531, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 75.2520980834961, + "knowledge_nll": 47.073333740234375, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.995241414048, + "learned_bits_per_parameter": 0.15910498797209105 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 6144000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:13:56.149201+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/container-command-1.json b/results/capacity-recall-controls-v1/runs/atomic-h256/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..f80990dce207cb137826b296da1b33835cde9033 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-8eee2eeac5c3dc74faa0", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-8eee2eeac5c3dc74faa0", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h256,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h256", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h256" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/container-inspect.json b/results/capacity-recall-controls-v1/runs/atomic-h256/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..800e605212917dd171e63a844344801d0d72b383 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046", + "Created": "2026-10-05T23:12:56.24269605Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h256" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:56.252399986Z", + "FinishedAt": "2026-10-05T23:13:56.679796788Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046/0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046-json.log", + "Name": "/lm-capctrl-8eee2eeac5c3dc74faa0", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h256", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h256" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/a7f40c122d8dda494d9cfe1179a8064b279d2723df27b67bda06432f35f6a669-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/a7f40c122d8dda494d9cfe1179a8064b279d2723df27b67bda06432f35f6a669/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/a7f40c122d8dda494d9cfe1179a8064b279d2723df27b67bda06432f35f6a669/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/a7f40c122d8dda494d9cfe1179a8064b279d2723df27b67bda06432f35f6a669/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h256", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h256", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "0db586863b4d", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PHYSICAL_GPU=1", + "OMP_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "PYTHONDONTWRITEBYTECODE=1", + "MKL_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h256" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/container-runtime.json b/results/capacity-recall-controls-v1/runs/atomic-h256/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..239973df7242ffeb86273d9d6bdc67598828638a --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 333110, + "container_id": "0db586863b4db75fa1d0702b0c8f125911f51e1aa296cbfb1d80b6dcfbb67046", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/learning.json b/results/capacity-recall-controls-v1/runs/atomic-h256/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..fed5ab6967d3bdf6e19919db69b1b5bd1041ec2c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/learning.json @@ -0,0 +1,1237 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.800018310546875, + "knowledge_nll": 12.712567329406738, + "identifier_accuracy": 0.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 19.480695724487305, + "knowledge_nll": 12.7626314163208, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 19.454242706298828, + "knowledge_nll": 12.749253273010254, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 19.46780776977539, + "knowledge_nll": 12.748907089233398, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 19.464326858520508, + "knowledge_nll": 12.742711067199707, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 19.463520050048828, + "knowledge_nll": 12.744767189025879, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.30284489318728447, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 85190656, + "created_utc": "2026-10-05T23:13:01.779208+00:00" + }, + { + "step": 40, + "epoch": 10, + "cumulative_step": 40, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0048828125, + "answer_nll": 8.901926040649414, + "knowledge_nll": 6.9030327796936035, + "identifier_accuracy": 0.0048828125, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 15.652323722839355, + "knowledge_nll": 10.784801483154297, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.007954545454545454, + "second_atomic_accuracy": 0.0011363636363636363, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 15.656925201416016, + "knowledge_nll": 10.773126602172852, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.005611672278338945, + "second_atomic_accuracy": 0.001122334455667789, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 15.646695137023926, + "knowledge_nll": 10.805266380310059, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.00980392156862745, + "second_atomic_accuracy": 0.006535947712418301, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 15.604581832885742, + "knowledge_nll": 10.802746772766113, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.003676470588235294, + "second_atomic_accuracy": 0.001838235294117647, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 15.642736434936523, + "knowledge_nll": 10.78939151763916, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 1.5219136476516724, + "training_seconds": 0.25334208086133003, + "wall_seconds": 0.7636227793991566, + "examples": 20480, + "supervised_tokens": 122880, + "executed_input_tokens": 573440, + "estimated_matmul_training_flops": 176742727680, + "atomic_epochs": 10.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:02.237117+00:00" + }, + { + "step": 120, + "epoch": 30, + "cumulative_step": 120, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.005859375, + "answer_nll": 5.55775260925293, + "knowledge_nll": 5.544159889221191, + "identifier_accuracy": 0.005859375, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 25.206432342529297, + "knowledge_nll": 14.658283233642578, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.005681818181818182, + "second_atomic_accuracy": 0.003409090909090909, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 25.164470672607422, + "knowledge_nll": 14.659943580627441, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.010101010101010102, + "second_atomic_accuracy": 0.008978675645342313, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 25.14978790283203, + "knowledge_nll": 14.66584300994873, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.004901960784313725, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 25.15885353088379, + "knowledge_nll": 14.697410583496094, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.012867647058823529, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 25.197120666503906, + "knowledge_nll": 14.666191101074219, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 0.9269183278083801, + "training_seconds": 0.5328799970448017, + "wall_seconds": 1.2770621255040169, + "examples": 61440, + "supervised_tokens": 368640, + "executed_input_tokens": 1720320, + "estimated_matmul_training_flops": 530228183040, + "atomic_epochs": 30.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:02.750572+00:00" + }, + { + "step": 400, + "epoch": 100, + "cumulative_step": 400, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.080078125, + "answer_nll": 4.215720176696777, + "knowledge_nll": 4.210657119750977, + "identifier_accuracy": 0.080078125, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 31.343717575073242, + "knowledge_nll": 16.952714920043945, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.08295454545454546, + "second_atomic_accuracy": 0.06704545454545455, + "both_atomic_n": 5, + "both_atomic_coverage": 0.005681818181818182, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 31.320571899414062, + "knowledge_nll": 17.067842483520508, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.08305274971941638, + "second_atomic_accuracy": 0.10549943883277217, + "both_atomic_n": 8, + "both_atomic_coverage": 0.008978675645342313, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 31.460132598876953, + "knowledge_nll": 16.943090438842773, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.07026143790849673, + "second_atomic_accuracy": 0.08333333333333333, + "both_atomic_n": 5, + "both_atomic_coverage": 0.008169934640522876, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 31.1539306640625, + "knowledge_nll": 16.725696563720703, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.06066176470588235, + "second_atomic_accuracy": 0.11580882352941177, + "both_atomic_n": 3, + "both_atomic_coverage": 0.0055147058823529415, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 31.40705108642578, + "knowledge_nll": 17.00884246826172, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 0.7458921074867249, + "training_seconds": 1.5073458664119244, + "wall_seconds": 2.563479892909527, + "examples": 204800, + "supervised_tokens": 1228800, + "executed_input_tokens": 5734400, + "estimated_matmul_training_flops": 1767427276800, + "atomic_epochs": 100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:04.037025+00:00" + }, + { + "step": 800, + "epoch": 200, + "cumulative_step": 800, + "metrics": {}, + "loss": 0.0007335824775509536, + "training_seconds": 2.904424238950014, + "wall_seconds": 4.130927931517363, + "examples": 409600, + "supervised_tokens": 2457600, + "executed_input_tokens": 11468800, + "estimated_matmul_training_flops": 3534854553600, + "atomic_epochs": 200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:05.604445+00:00" + }, + { + "step": 1200, + "epoch": 300, + "cumulative_step": 1200, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0015741009265184402, + "knowledge_nll": 0.0014703938504680991, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 55.78326416015625, + "knowledge_nll": 34.247161865234375, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 55.75180435180664, + "knowledge_nll": 34.48973846435547, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 55.813934326171875, + "knowledge_nll": 34.49649429321289, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 55.5450325012207, + "knowledge_nll": 34.2850456237793, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 55.98625946044922, + "knowledge_nll": 34.685909271240234, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 0.00026584701845422387, + "training_seconds": 4.365317400544882, + "wall_seconds": 5.939616475254297, + "examples": 614400, + "supervised_tokens": 3686400, + "executed_input_tokens": 17203200, + "estimated_matmul_training_flops": 5302281830400, + "atomic_epochs": 300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:07.413121+00:00" + }, + { + "step": 1600, + "epoch": 400, + "cumulative_step": 1600, + "metrics": {}, + "loss": 0.00015673240704927593, + "training_seconds": 5.784421011805534, + "wall_seconds": 7.538071762770414, + "examples": 819200, + "supervised_tokens": 4915200, + "executed_input_tokens": 22937600, + "estimated_matmul_training_flops": 7069709107200, + "atomic_epochs": 400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:09.011564+00:00" + }, + { + "step": 2000, + "epoch": 500, + "cumulative_step": 2000, + "metrics": {}, + "loss": 0.00010618821397656575, + "training_seconds": 7.155248023569584, + "wall_seconds": 9.078349005430937, + "examples": 1024000, + "supervised_tokens": 6144000, + "executed_input_tokens": 28672000, + "estimated_matmul_training_flops": 8837136384000, + "atomic_epochs": 500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:10.551842+00:00" + }, + { + "step": 2400, + "epoch": 600, + "cumulative_step": 2400, + "metrics": {}, + "loss": 7.70350088714622e-05, + "training_seconds": 8.556219007819891, + "wall_seconds": 10.64826824516058, + "examples": 1228800, + "supervised_tokens": 7372800, + "executed_input_tokens": 34406400, + "estimated_matmul_training_flops": 10604563660800, + "atomic_epochs": 600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:12.121801+00:00" + }, + { + "step": 2800, + "epoch": 700, + "cumulative_step": 2800, + "metrics": {}, + "loss": 5.740542837884277e-05, + "training_seconds": 9.940020933747292, + "wall_seconds": 12.208147171884775, + "examples": 1433600, + "supervised_tokens": 8601600, + "executed_input_tokens": 40140800, + "estimated_matmul_training_flops": 12371990937600, + "atomic_epochs": 700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:13.681634+00:00" + }, + { + "step": 3200, + "epoch": 800, + "cumulative_step": 3200, + "metrics": {}, + "loss": 4.433423964655958e-05, + "training_seconds": 11.330118466168642, + "wall_seconds": 13.78154019638896, + "examples": 1638400, + "supervised_tokens": 9830400, + "executed_input_tokens": 45875200, + "estimated_matmul_training_flops": 14139418214400, + "atomic_epochs": 800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:15.255038+00:00" + }, + { + "step": 3600, + "epoch": 900, + "cumulative_step": 3600, + "metrics": {}, + "loss": 3.323618511785753e-05, + "training_seconds": 12.738105796277523, + "wall_seconds": 15.361937925219536, + "examples": 1843200, + "supervised_tokens": 11059200, + "executed_input_tokens": 51609600, + "estimated_matmul_training_flops": 15906845491200, + "atomic_epochs": 900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:16.835470+00:00" + }, + { + "step": 4000, + "epoch": 1000, + "cumulative_step": 4000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00016123394016176462, + "knowledge_nll": 0.00014242669567465782, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 62.216880798339844, + "knowledge_nll": 38.551055908203125, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 62.00447463989258, + "knowledge_nll": 38.61696243286133, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 62.191471099853516, + "knowledge_nll": 38.85482406616211, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 62.04867172241211, + "knowledge_nll": 38.64834976196289, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 62.35482406616211, + "knowledge_nll": 38.96231460571289, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 2.7721851438400336e-05, + "training_seconds": 14.101580899208784, + "wall_seconds": 18.121656596660614, + "examples": 2048000, + "supervised_tokens": 12288000, + "executed_input_tokens": 57344000, + "estimated_matmul_training_flops": 17674272768000, + "atomic_epochs": 1000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:19.595153+00:00" + }, + { + "step": 4400, + "epoch": 1100, + "cumulative_step": 4400, + "metrics": {}, + "loss": 2.1588000890915282e-05, + "training_seconds": 15.475526802241802, + "wall_seconds": 19.66128907352686, + "examples": 2252800, + "supervised_tokens": 13516800, + "executed_input_tokens": 63078400, + "estimated_matmul_training_flops": 19441700044800, + "atomic_epochs": 1100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:21.134806+00:00" + }, + { + "step": 4800, + "epoch": 1200, + "cumulative_step": 4800, + "metrics": {}, + "loss": 1.6937608961598016e-05, + "training_seconds": 16.863219883292913, + "wall_seconds": 21.21758099272847, + "examples": 2457600, + "supervised_tokens": 14745600, + "executed_input_tokens": 68812800, + "estimated_matmul_training_flops": 21209127321600, + "atomic_epochs": 1200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:22.691068+00:00" + }, + { + "step": 5200, + "epoch": 1300, + "cumulative_step": 5200, + "metrics": {}, + "loss": 1.3684541045222431e-05, + "training_seconds": 18.242623332887888, + "wall_seconds": 22.767869766801596, + "examples": 2662400, + "supervised_tokens": 15974400, + "executed_input_tokens": 74547200, + "estimated_matmul_training_flops": 22976554598400, + "atomic_epochs": 1300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:24.241398+00:00" + }, + { + "step": 5600, + "epoch": 1400, + "cumulative_step": 5600, + "metrics": {}, + "loss": 1.0952132470265497e-05, + "training_seconds": 19.620887719094753, + "wall_seconds": 24.319294303655624, + "examples": 2867200, + "supervised_tokens": 17203200, + "executed_input_tokens": 80281600, + "estimated_matmul_training_flops": 24743981875200, + "atomic_epochs": 1400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:25.792806+00:00" + }, + { + "step": 6000, + "epoch": 1500, + "cumulative_step": 6000, + "metrics": {}, + "loss": 8.809458449832164e-06, + "training_seconds": 21.002781584858894, + "wall_seconds": 25.872805207967758, + "examples": 3072000, + "supervised_tokens": 18432000, + "executed_input_tokens": 86016000, + "estimated_matmul_training_flops": 26511409152000, + "atomic_epochs": 1500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:27.346319+00:00" + }, + { + "step": 6400, + "epoch": 1600, + "cumulative_step": 6400, + "metrics": {}, + "loss": 7.019269105512649e-06, + "training_seconds": 22.406428191810846, + "wall_seconds": 27.603564765304327, + "examples": 3276800, + "supervised_tokens": 19660800, + "executed_input_tokens": 91750400, + "estimated_matmul_training_flops": 28278836428800, + "atomic_epochs": 1600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:29.077058+00:00" + }, + { + "step": 6800, + "epoch": 1700, + "cumulative_step": 6800, + "metrics": {}, + "loss": 5.725102255382808e-06, + "training_seconds": 23.801379051059484, + "wall_seconds": 29.167111076414585, + "examples": 3481600, + "supervised_tokens": 20889600, + "executed_input_tokens": 97484800, + "estimated_matmul_training_flops": 30046263705600, + "atomic_epochs": 1700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:30.640643+00:00" + }, + { + "step": 7200, + "epoch": 1800, + "cumulative_step": 7200, + "metrics": {}, + "loss": 4.556078692985466e-06, + "training_seconds": 25.24148302152753, + "wall_seconds": 30.793409556150436, + "examples": 3686400, + "supervised_tokens": 22118400, + "executed_input_tokens": 103219200, + "estimated_matmul_training_flops": 31813690982400, + "atomic_epochs": 1800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:32.266917+00:00" + }, + { + "step": 7600, + "epoch": 1900, + "cumulative_step": 7600, + "metrics": {}, + "loss": 3.6449071103561437e-06, + "training_seconds": 26.624874502420425, + "wall_seconds": 32.369852900505066, + "examples": 3891200, + "supervised_tokens": 23347200, + "executed_input_tokens": 108953600, + "estimated_matmul_training_flops": 33581118259200, + "atomic_epochs": 1900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:33.843344+00:00" + }, + { + "step": 8000, + "epoch": 2000, + "cumulative_step": 8000, + "metrics": {}, + "loss": 2.9522805107262684e-06, + "training_seconds": 28.014841496944427, + "wall_seconds": 33.93620090186596, + "examples": 4096000, + "supervised_tokens": 24576000, + "executed_input_tokens": 114688000, + "estimated_matmul_training_flops": 35348545536000, + "atomic_epochs": 2000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:35.409694+00:00" + }, + { + "step": 8400, + "epoch": 2100, + "cumulative_step": 8400, + "metrics": {}, + "loss": 2.303968585692928e-06, + "training_seconds": 29.434545774012804, + "wall_seconds": 35.53346931561828, + "examples": 4300800, + "supervised_tokens": 25804800, + "executed_input_tokens": 120422400, + "estimated_matmul_training_flops": 37115972812800, + "atomic_epochs": 2100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:37.007053+00:00" + }, + { + "step": 8800, + "epoch": 2200, + "cumulative_step": 8800, + "metrics": {}, + "loss": 1.9029976101592183e-06, + "training_seconds": 30.90367928519845, + "wall_seconds": 37.18839894235134, + "examples": 4505600, + "supervised_tokens": 27033600, + "executed_input_tokens": 126156800, + "estimated_matmul_training_flops": 38883400089600, + "atomic_epochs": 2200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:38.661967+00:00" + }, + { + "step": 9200, + "epoch": 2300, + "cumulative_step": 9200, + "metrics": {}, + "loss": 1.4973310271670925e-06, + "training_seconds": 32.36832970008254, + "wall_seconds": 38.83509421348572, + "examples": 4710400, + "supervised_tokens": 28262400, + "executed_input_tokens": 131891200, + "estimated_matmul_training_flops": 40650827366400, + "atomic_epochs": 2300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:40.308602+00:00" + }, + { + "step": 9600, + "epoch": 2400, + "cumulative_step": 9600, + "metrics": {}, + "loss": 1.201404188577726e-06, + "training_seconds": 33.76614273712039, + "wall_seconds": 40.40443155169487, + "examples": 4915200, + "supervised_tokens": 29491200, + "executed_input_tokens": 137625600, + "estimated_matmul_training_flops": 42418254643200, + "atomic_epochs": 2400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:41.877972+00:00" + }, + { + "step": 10000, + "epoch": 2500, + "cumulative_step": 10000, + "metrics": {}, + "loss": 9.734250170367886e-07, + "training_seconds": 35.23193572089076, + "wall_seconds": 42.043341498821974, + "examples": 5120000, + "supervised_tokens": 30720000, + "executed_input_tokens": 143360000, + "estimated_matmul_training_flops": 44185681920000, + "atomic_epochs": 2500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:43.516838+00:00" + }, + { + "step": 10400, + "epoch": 2600, + "cumulative_step": 10400, + "metrics": {}, + "loss": 7.647702204849338e-07, + "training_seconds": 36.62184916064143, + "wall_seconds": 43.60996602848172, + "examples": 5324800, + "supervised_tokens": 31948800, + "executed_input_tokens": 149094400, + "estimated_matmul_training_flops": 45953109196800, + "atomic_epochs": 2600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:45.083464+00:00" + }, + { + "step": 10800, + "epoch": 2700, + "cumulative_step": 10800, + "metrics": {}, + "loss": 6.187470944496454e-07, + "training_seconds": 38.055029559880495, + "wall_seconds": 45.530785869807005, + "examples": 5529600, + "supervised_tokens": 33177600, + "executed_input_tokens": 154828800, + "estimated_matmul_training_flops": 47720536473600, + "atomic_epochs": 2700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:47.004295+00:00" + }, + { + "step": 11200, + "epoch": 2800, + "cumulative_step": 11200, + "metrics": {}, + "loss": 4.867322900281579e-07, + "training_seconds": 39.483997739851475, + "wall_seconds": 47.1258926615119, + "examples": 5734400, + "supervised_tokens": 34406400, + "executed_input_tokens": 160563200, + "estimated_matmul_training_flops": 49487963750400, + "atomic_epochs": 2800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:48.599388+00:00" + }, + { + "step": 11600, + "epoch": 2900, + "cumulative_step": 11600, + "metrics": {}, + "loss": 3.8902112464711536e-07, + "training_seconds": 40.865204770118, + "wall_seconds": 48.69068878144026, + "examples": 5939200, + "supervised_tokens": 35635200, + "executed_input_tokens": 166297600, + "estimated_matmul_training_flops": 51255391027200, + "atomic_epochs": 2900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:50.164183+00:00" + }, + { + "step": 12000, + "epoch": 3000, + "cumulative_step": 12000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 1.852807258728717e-06, + "knowledge_nll": 1.6105470876937034e-06, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.9262070054537617e-06, + "knowledge_nll": 1.6569385934417369e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997552171938 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.7794075120036723e-06, + "knowledge_nll": 1.5641555819456698e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997689242111 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 75.06710815429688, + "knowledge_nll": 46.6080436706543, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 74.91608428955078, + "knowledge_nll": 46.640281677246094, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 75.52379608154297, + "knowledge_nll": 47.41034698486328, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 74.99325561523438, + "knowledge_nll": 46.99372863769531, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 75.2520980834961, + "knowledge_nll": 47.073333740234375, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.995241414048, + "learned_bits_per_parameter": 0.15910498797209105 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 3.0341712431436463e-07, + "training_seconds": 42.25510339811444, + "wall_seconds": 50.583598494529724, + "examples": 6144000, + "supervised_tokens": 36864000, + "executed_input_tokens": 172032000, + "estimated_matmul_training_flops": 53022818304000, + "atomic_epochs": 3000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:52.057197+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/preflight.json b/results/capacity-recall-controls-v1/runs/atomic-h256/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/run.json b/results/capacity-recall-controls-v1/runs/atomic-h256/run.json new file mode 100644 index 0000000000000000000000000000000000000000..15122d8fcab3355260a6504ff47751734ff6ecec --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/run.json @@ -0,0 +1,195 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic-h256", + "training_mode": "atomic", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long" + }, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "initial_model_sha256": "92086c98673d3bc1f9a6571266eec6d392bba58e3b70733208be49cad5e48d4f", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 2048, + "composition_examples": 1169, + "evaluation_nodes": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 0, + "parent_examples": 0, + "training_mode": "atomic", + "created_utc": "2026-10-05T23:13:01.425550+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/status.json b/results/capacity-recall-controls-v1/runs/atomic-h256/status.json new file mode 100644 index 0000000000000000000000000000000000000000..10a7ffb28ac350a8bbbf31965dee0e6df72a9134 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 12000 +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/trained.json b/results/capacity-recall-controls-v1/runs/atomic-h256/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..35cf249d43e4fc303f7265d7ad9c79fa74252ba5 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "e3db7c00639fa933038e766bdea6f27eea357703546b025f6dd8394e7bc2286b", + "epochs": 3000, + "step": 12000, + "training_pid": 44, + "created_utc": "2026-10-05T23:13:52.168524+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h256/worker.log b/results/capacity-recall-controls-v1/runs/atomic-h256/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..c19e963d947b23800c0cf89dccda7b2e7564b7dc --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h256/worker.log @@ -0,0 +1,33 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.800018310546875, "knowledge_nll": 12.712567329406738, "identifier_accuracy": 0.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 19.480695724487305, "knowledge_nll": 12.7626314163208, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 19.454242706298828, "knowledge_nll": 12.749253273010254, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 19.46780776977539, "knowledge_nll": 12.748907089233398, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 19.464326858520508, "knowledge_nll": 12.742711067199707, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 19.463520050048828, "knowledge_nll": 12.744767189025879, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 40, "epoch": 10, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0048828125, "answer_nll": 8.901926040649414, "knowledge_nll": 6.9030327796936035, "identifier_accuracy": 0.0048828125, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 15.652323722839355, "knowledge_nll": 10.784801483154297, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.007954545454545454, "second_atomic_accuracy": 0.0011363636363636363, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 15.656925201416016, "knowledge_nll": 10.773126602172852, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.005611672278338945, "second_atomic_accuracy": 0.001122334455667789, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 15.646695137023926, "knowledge_nll": 10.805266380310059, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.00980392156862745, "second_atomic_accuracy": 0.006535947712418301, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 15.604581832885742, "knowledge_nll": 10.802746772766113, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.003676470588235294, "second_atomic_accuracy": 0.001838235294117647, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 15.642736434936523, "knowledge_nll": 10.78939151763916, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 120, "epoch": 30, "metrics": {"atomic": {"n": 2048, "accuracy": 0.005859375, "answer_nll": 5.55775260925293, "knowledge_nll": 5.544159889221191, "identifier_accuracy": 0.005859375, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 25.206432342529297, "knowledge_nll": 14.658283233642578, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.005681818181818182, "second_atomic_accuracy": 0.003409090909090909, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 25.164470672607422, "knowledge_nll": 14.659943580627441, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.010101010101010102, "second_atomic_accuracy": 0.008978675645342313, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 25.14978790283203, "knowledge_nll": 14.66584300994873, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.004901960784313725, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 25.15885353088379, "knowledge_nll": 14.697410583496094, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.012867647058823529, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 25.197120666503906, "knowledge_nll": 14.666191101074219, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 400, "epoch": 100, "metrics": {"atomic": {"n": 2048, "accuracy": 0.080078125, "answer_nll": 4.215720176696777, "knowledge_nll": 4.210657119750977, "identifier_accuracy": 0.080078125, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 31.343717575073242, "knowledge_nll": 16.952714920043945, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.08295454545454546, "second_atomic_accuracy": 0.06704545454545455, "both_atomic_n": 5, "both_atomic_coverage": 0.005681818181818182, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 31.320571899414062, "knowledge_nll": 17.067842483520508, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.08305274971941638, "second_atomic_accuracy": 0.10549943883277217, "both_atomic_n": 8, "both_atomic_coverage": 0.008978675645342313, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 31.460132598876953, "knowledge_nll": 16.943090438842773, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.07026143790849673, "second_atomic_accuracy": 0.08333333333333333, "both_atomic_n": 5, "both_atomic_coverage": 0.008169934640522876, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 31.1539306640625, "knowledge_nll": 16.725696563720703, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.06066176470588235, "second_atomic_accuracy": 0.11580882352941177, "both_atomic_n": 3, "both_atomic_coverage": 0.0055147058823529415, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 31.40705108642578, "knowledge_nll": 17.00884246826172, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 800, "epoch": 200, "metrics": {}} +{"step": 1200, "epoch": 300, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.0015741009265184402, "knowledge_nll": 0.0014703938504680991, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 55.78326416015625, "knowledge_nll": 34.247161865234375, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 55.75180435180664, "knowledge_nll": 34.48973846435547, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 55.813934326171875, "knowledge_nll": 34.49649429321289, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 55.5450325012207, "knowledge_nll": 34.2850456237793, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 55.98625946044922, "knowledge_nll": 34.685909271240234, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 1600, "epoch": 400, "metrics": {}} +{"step": 2000, "epoch": 500, "metrics": {}} +{"step": 2400, "epoch": 600, "metrics": {}} +{"step": 2800, "epoch": 700, "metrics": {}} +{"step": 3200, "epoch": 800, "metrics": {}} +{"step": 3600, "epoch": 900, "metrics": {}} +{"step": 4000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.00016123394016176462, "knowledge_nll": 0.00014242669567465782, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 62.216880798339844, "knowledge_nll": 38.551055908203125, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 62.00447463989258, "knowledge_nll": 38.61696243286133, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 62.191471099853516, "knowledge_nll": 38.85482406616211, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 62.04867172241211, "knowledge_nll": 38.64834976196289, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 62.35482406616211, "knowledge_nll": 38.96231460571289, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 4400, "epoch": 1100, "metrics": {}} +{"step": 4800, "epoch": 1200, "metrics": {}} +{"step": 5200, "epoch": 1300, "metrics": {}} +{"step": 5600, "epoch": 1400, "metrics": {}} +{"step": 6000, "epoch": 1500, "metrics": {}} +{"step": 6400, "epoch": 1600, "metrics": {}} +{"step": 6800, "epoch": 1700, "metrics": {}} +{"step": 7200, "epoch": 1800, "metrics": {}} +{"step": 7600, "epoch": 1900, "metrics": {}} +{"step": 8000, "epoch": 2000, "metrics": {}} +{"step": 8400, "epoch": 2100, "metrics": {}} +{"step": 8800, "epoch": 2200, "metrics": {}} +{"step": 9200, "epoch": 2300, "metrics": {}} +{"step": 9600, "epoch": 2400, "metrics": {}} +{"step": 10000, "epoch": 2500, "metrics": {}} +{"step": 10400, "epoch": 2600, "metrics": {}} +{"step": 10800, "epoch": 2700, "metrics": {}} +{"step": 11200, "epoch": 2800, "metrics": {}} +{"step": 11600, "epoch": 2900, "metrics": {}} +{"step": 12000, "epoch": 3000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 1.852807258728717e-06, "knowledge_nll": 1.6105470876937034e-06, "identifier_accuracy": 1.0, "full_population": true}, "atomic_first": {"n": 1024, "accuracy": 1.0, "answer_nll": 1.9262070054537617e-06, "knowledge_nll": 1.6569385934417369e-06, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.997552171938}, "atomic_second": {"n": 1024, "accuracy": 1.0, "answer_nll": 1.7794075120036723e-06, "knowledge_nll": 1.5641555819456698e-06, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.997689242111}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 75.06710815429688, "knowledge_nll": 46.6080436706543, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 74.91608428955078, "knowledge_nll": 46.640281677246094, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 75.52379608154297, "knowledge_nll": 47.41034698486328, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 74.99325561523438, "knowledge_nll": 46.99372863769531, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 75.2520980834961, "knowledge_nll": 47.073333740234375, "identifier_accuracy": 0.0, "population_n": 1169}, "information": {"independent_facts": 2048, "world_bits": 16384.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 0.15910503418272218, "composition_independent_bits": 0, "learned_bits_raw": 16383.995241414048, "learned_bits_per_parameter": 0.15910498797209105}, "serial_II": {"n": 880, "accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 880, "accuracy": 0.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 880, "accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 891, "accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 891, "accuracy": 0.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 891, "accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 612, "accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 612, "accuracy": 0.006535947712418301, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.006535947712418301, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 612, "accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 544, "accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 544, "accuracy": 0.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 544, "accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/audit.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..84d5c0eb857c2b7e281d51d4baeb82968eabc196 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "8694a4dec375266f0b68eee9976ded8af1f46a59146a604ffc4e58cd9f731eef", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7165096507352942, + "answer_nll": 0.9351626634597778, + "knowledge_nll": 0.935147225856781, + "identifier_accuracy": 0.7165096507352942, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.70599365234375, + "answer_nll": 0.9714698195457458, + "knowledge_nll": 0.971454918384552, + "identifier_accuracy": 0.70599365234375, + "learned_bits_raw": 108109.6078426016 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.884765625, + "answer_nll": 0.35424816608428955, + "knowledge_nll": 0.3542240560054779, + "identifier_accuracy": 0.884765625, + "learned_bits_raw": 7668.697816102218 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.22854614257812, + "knowledge_nll": 49.78916931152344, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.7109375, + "second_atomic_accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.97843170166016, + "knowledge_nll": 50.494781494140625, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.7001953125, + "second_atomic_accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.48211669921875, + "knowledge_nll": 49.74689483642578, + "identifier_accuracy": 0.00048828125, + "population_n": 13308, + "first_atomic_accuracy": 0.70458984375, + "second_atomic_accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.88727569580078, + "knowledge_nll": 50.95634460449219, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.7177734375, + "second_atomic_accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.36808013916016, + "knowledge_nll": 49.981666564941406, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 115778.30552662114, + "learned_bits_per_parameter": 1.1243231969257026 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.64306640625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0015232292460015233, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.61572265625, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.001589825119236884, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6123046875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00537109375, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.004788507581803671, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.64111328125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0053475935828877, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 52224000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:23:02.414099+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/complete.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..84d5c0eb857c2b7e281d51d4baeb82968eabc196 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "8694a4dec375266f0b68eee9976ded8af1f46a59146a604ffc4e58cd9f731eef", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7165096507352942, + "answer_nll": 0.9351626634597778, + "knowledge_nll": 0.935147225856781, + "identifier_accuracy": 0.7165096507352942, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.70599365234375, + "answer_nll": 0.9714698195457458, + "knowledge_nll": 0.971454918384552, + "identifier_accuracy": 0.70599365234375, + "learned_bits_raw": 108109.6078426016 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.884765625, + "answer_nll": 0.35424816608428955, + "knowledge_nll": 0.3542240560054779, + "identifier_accuracy": 0.884765625, + "learned_bits_raw": 7668.697816102218 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.22854614257812, + "knowledge_nll": 49.78916931152344, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.7109375, + "second_atomic_accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.97843170166016, + "knowledge_nll": 50.494781494140625, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.7001953125, + "second_atomic_accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.48211669921875, + "knowledge_nll": 49.74689483642578, + "identifier_accuracy": 0.00048828125, + "population_n": 13308, + "first_atomic_accuracy": 0.70458984375, + "second_atomic_accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.88727569580078, + "knowledge_nll": 50.95634460449219, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.7177734375, + "second_atomic_accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.36808013916016, + "knowledge_nll": 49.981666564941406, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 115778.30552662114, + "learned_bits_per_parameter": 1.1243231969257026 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.64306640625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0015232292460015233, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.61572265625, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.001589825119236884, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6123046875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00537109375, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.004788507581803671, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.64111328125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0053475935828877, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 52224000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:23:02.414099+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/container-command-1.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..0eb90ed059fb44b76762d9daa218983490655c37 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-063ec7692b7ddc21e0be", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-063ec7692b7ddc21e0be", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h4096,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h4096", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h4096" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/container-inspect.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..5b2363b0af52a60aa2b0b565a0202ab85747d082 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df", + "Created": "2026-10-05T23:16:09.300752119Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h4096" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:16:09.309725357Z", + "FinishedAt": "2026-10-05T23:23:02.916165144Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df/1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df-json.log", + "Name": "/lm-capctrl-063ec7692b7ddc21e0be", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h4096", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h4096" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/64ecca82329e75e3b24eb5fd48f782d9840e8b9d74bda11ae2fe5f933675d010-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/64ecca82329e75e3b24eb5fd48f782d9840e8b9d74bda11ae2fe5f933675d010/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/64ecca82329e75e3b24eb5fd48f782d9840e8b9d74bda11ae2fe5f933675d010/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/64ecca82329e75e3b24eb5fd48f782d9840e8b9d74bda11ae2fe5f933675d010/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h4096", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic-h4096", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "1326e6dc7cf6", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PHYSICAL_GPU=1", + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PYTHONDONTWRITEBYTECODE=1", + "MKL_NUM_THREADS=4", + "TORCH_HOME=/tmp/torch", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic-h4096" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/container-runtime.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..895769b5f7ae34b8e7c543eccc85a7cc01f6a2dd --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 336937, + "container_id": "1326e6dc7cf6bc95a2840086d927b26d3abb9ef90761787b856067d760f298df", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/learning.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..8756e7b36bfea221d7b602d17b24c43f8bac5c31 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/learning.json @@ -0,0 +1,1579 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.918397903442383, + "knowledge_nll": 12.682050704956055, + "identifier_accuracy": 0.0, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.449495315551758, + "knowledge_nll": 12.73082160949707, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.451412200927734, + "knowledge_nll": 12.738428115844727, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.451452255249023, + "knowledge_nll": 12.735528945922852, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.456905364990234, + "knowledge_nll": 12.742338180541992, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.455768585205078, + "knowledge_nll": 12.733171463012695, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.4786559008061886, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 93564928, + "created_utc": "2026-10-05T23:16:15.139874+00:00" + }, + { + "step": 340, + "epoch": 10, + "cumulative_step": 340, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0048828125, + "answer_nll": 5.55714225769043, + "knowledge_nll": 5.554952144622803, + "identifier_accuracy": 0.0048828125, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 34.939483642578125, + "knowledge_nll": 18.0362606048584, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.0009765625, + "second_atomic_accuracy": 0.0029296875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 35.00710678100586, + "knowledge_nll": 18.07924461364746, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.00830078125, + "second_atomic_accuracy": 0.00830078125, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 34.93748474121094, + "knowledge_nll": 18.037094116210938, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.00390625, + "second_atomic_accuracy": 0.00244140625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 34.97959899902344, + "knowledge_nll": 18.045307159423828, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.0068359375, + "second_atomic_accuracy": 0.00634765625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 34.94676971435547, + "knowledge_nll": 18.047203063964844, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.9268788695335388, + "training_seconds": 1.4293753430247307, + "wall_seconds": 2.3696563094854355, + "examples": 174080, + "supervised_tokens": 1044480, + "executed_input_tokens": 4874240, + "estimated_matmul_training_flops": 1502313185280, + "atomic_epochs": 10.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:16:17.030796+00:00" + }, + { + "step": 1020, + "epoch": 30, + "cumulative_step": 1020, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0009765625, + "answer_nll": 5.55418586730957, + "knowledge_nll": 5.553859710693359, + "identifier_accuracy": 0.0009765625, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 37.866943359375, + "knowledge_nll": 18.111173629760742, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.00390625, + "second_atomic_accuracy": 0.0048828125, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 38.09527587890625, + "knowledge_nll": 18.15799331665039, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.00341796875, + "second_atomic_accuracy": 0.0126953125, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 38.02764129638672, + "knowledge_nll": 18.095767974853516, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.00341796875, + "second_atomic_accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 37.92219924926758, + "knowledge_nll": 18.11306381225586, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.00146484375, + "second_atomic_accuracy": 0.01123046875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 37.990535736083984, + "knowledge_nll": 18.112926483154297, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.9255064129829407, + "training_seconds": 4.1174476109445095, + "wall_seconds": 5.646812044084072, + "examples": 522240, + "supervised_tokens": 3133440, + "executed_input_tokens": 14622720, + "estimated_matmul_training_flops": 4506939555840, + "atomic_epochs": 30.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:16:20.308302+00:00" + }, + { + "step": 3400, + "epoch": 100, + "cumulative_step": 3400, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.00830078125, + "answer_nll": 5.548836708068848, + "knowledge_nll": 5.5487213134765625, + "identifier_accuracy": 0.00830078125, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.07551193237305, + "knowledge_nll": 20.53970718383789, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.0009765625, + "second_atomic_accuracy": 0.0029296875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.37554931640625, + "knowledge_nll": 20.493831634521484, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.00732421875, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.27153015136719, + "knowledge_nll": 20.477514266967773, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.0078125, + "second_atomic_accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.052486419677734, + "knowledge_nll": 20.363731384277344, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.0078125, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.23309326171875, + "knowledge_nll": 20.53664779663086, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.9231705069541931, + "training_seconds": 13.462414640933275, + "wall_seconds": 15.92382987588644, + "examples": 1740800, + "supervised_tokens": 10444800, + "executed_input_tokens": 48742400, + "estimated_matmul_training_flops": 15023131852800, + "atomic_epochs": 100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:16:30.585127+00:00" + }, + { + "step": 5000, + "epoch": 147.05882352941177, + "cumulative_step": 5000, + "metrics": {}, + "loss": 0.9078102111816406, + "training_seconds": 19.189996536821127, + "wall_seconds": 22.05718544125557, + "examples": 2560000, + "supervised_tokens": 15360000, + "executed_input_tokens": 71680000, + "estimated_matmul_training_flops": 22092840960000, + "atomic_epochs": 147.05882352941177, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:16:36.718454+00:00" + }, + { + "step": 6800, + "epoch": 200, + "cumulative_step": 6800, + "metrics": {}, + "loss": 0.8498695492744446, + "training_seconds": 25.748698480427265, + "wall_seconds": 29.032088339328766, + "examples": 3481600, + "supervised_tokens": 20889600, + "executed_input_tokens": 97484800, + "estimated_matmul_training_flops": 30046263705600, + "atomic_epochs": 200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:16:43.693315+00:00" + }, + { + "step": 10000, + "epoch": 294.11764705882354, + "cumulative_step": 10000, + "metrics": {}, + "loss": 0.5492868423461914, + "training_seconds": 37.29282734543085, + "wall_seconds": 41.312841821461916, + "examples": 5120000, + "supervised_tokens": 30720000, + "executed_input_tokens": 143360000, + "estimated_matmul_training_flops": 44185681920000, + "atomic_epochs": 294.11764705882354, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:16:55.974088+00:00" + }, + { + "step": 10200, + "epoch": 300, + "cumulative_step": 10200, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.22998046875, + "answer_nll": 3.1515653133392334, + "knowledge_nll": 3.151440143585205, + "identifier_accuracy": 0.22998046875, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 70.5671615600586, + "knowledge_nll": 34.852394104003906, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.1953125, + "second_atomic_accuracy": 0.69970703125, + "both_atomic_n": 272, + "both_atomic_coverage": 0.1328125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 70.98748016357422, + "knowledge_nll": 34.68799591064453, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.20458984375, + "second_atomic_accuracy": 0.73583984375, + "both_atomic_n": 307, + "both_atomic_coverage": 0.14990234375, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 70.72868347167969, + "knowledge_nll": 34.67470169067383, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.20556640625, + "second_atomic_accuracy": 0.69775390625, + "both_atomic_n": 291, + "both_atomic_coverage": 0.14208984375, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 70.27263641357422, + "knowledge_nll": 34.437442779541016, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.2041015625, + "second_atomic_accuracy": 0.7685546875, + "both_atomic_n": 323, + "both_atomic_coverage": 0.15771484375, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 70.93522644042969, + "knowledge_nll": 34.80216979980469, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.5586172938346863, + "training_seconds": 38.00700996443629, + "wall_seconds": 42.460791397839785, + "examples": 5222400, + "supervised_tokens": 31334400, + "executed_input_tokens": 146227200, + "estimated_matmul_training_flops": 45069395558400, + "atomic_epochs": 300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:16:57.121934+00:00" + }, + { + "step": 13600, + "epoch": 400, + "cumulative_step": 13600, + "metrics": {}, + "loss": 0.47427210211753845, + "training_seconds": 50.38166879862547, + "wall_seconds": 55.6067311167717, + "examples": 6963200, + "supervised_tokens": 41779200, + "executed_input_tokens": 194969600, + "estimated_matmul_training_flops": 60092527411200, + "atomic_epochs": 400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:17:10.267992+00:00" + }, + { + "step": 15000, + "epoch": 441.1764705882353, + "cumulative_step": 15000, + "metrics": {}, + "loss": 0.4088139235973358, + "training_seconds": 55.433482468128204, + "wall_seconds": 61.02822209894657, + "examples": 7680000, + "supervised_tokens": 46080000, + "executed_input_tokens": 215040000, + "estimated_matmul_training_flops": 66278522880000, + "atomic_epochs": 441.1764705882353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:17:15.689402+00:00" + }, + { + "step": 17000, + "epoch": 500, + "cumulative_step": 17000, + "metrics": {}, + "loss": 0.4093848764896393, + "training_seconds": 62.678115494549274, + "wall_seconds": 68.72195200622082, + "examples": 8704000, + "supervised_tokens": 52224000, + "executed_input_tokens": 243712000, + "estimated_matmul_training_flops": 75115659264000, + "atomic_epochs": 500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:17:23.383187+00:00" + }, + { + "step": 20000, + "epoch": 588.2352941176471, + "cumulative_step": 20000, + "metrics": {}, + "loss": 0.35261818766593933, + "training_seconds": 73.65659710764885, + "wall_seconds": 80.39177725464106, + "examples": 10240000, + "supervised_tokens": 61440000, + "executed_input_tokens": 286720000, + "estimated_matmul_training_flops": 88371363840000, + "atomic_epochs": 588.2352941176471, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:17:35.053012+00:00" + }, + { + "step": 20400, + "epoch": 600, + "cumulative_step": 20400, + "metrics": {}, + "loss": 0.38586553931236267, + "training_seconds": 75.09412990882993, + "wall_seconds": 82.70775561407208, + "examples": 10444800, + "supervised_tokens": 62668800, + "executed_input_tokens": 292454400, + "estimated_matmul_training_flops": 90138791116800, + "atomic_epochs": 600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:17:37.368956+00:00" + }, + { + "step": 23800, + "epoch": 700, + "cumulative_step": 23800, + "metrics": {}, + "loss": 0.3378361463546753, + "training_seconds": 87.33464121073484, + "wall_seconds": 95.71034064143896, + "examples": 12185600, + "supervised_tokens": 73113600, + "executed_input_tokens": 341196800, + "estimated_matmul_training_flops": 105161922969600, + "atomic_epochs": 700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:17:50.371589+00:00" + }, + { + "step": 25000, + "epoch": 735.2941176470588, + "cumulative_step": 25000, + "metrics": {}, + "loss": 0.2823137938976288, + "training_seconds": 91.6415401250124, + "wall_seconds": 100.340910281986, + "examples": 12800000, + "supervised_tokens": 76800000, + "executed_input_tokens": 358400000, + "estimated_matmul_training_flops": 110464204800000, + "atomic_epochs": 735.2941176470588, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:17:55.002100+00:00" + }, + { + "step": 27200, + "epoch": 800, + "cumulative_step": 27200, + "metrics": {}, + "loss": 0.3369438648223877, + "training_seconds": 99.57443399727345, + "wall_seconds": 108.76115001365542, + "examples": 13926400, + "supervised_tokens": 83558400, + "executed_input_tokens": 389939200, + "estimated_matmul_training_flops": 120185054822400, + "atomic_epochs": 800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:03.422327+00:00" + }, + { + "step": 30000, + "epoch": 882.3529411764706, + "cumulative_step": 30000, + "metrics": {}, + "loss": 0.2935076653957367, + "training_seconds": 109.83209979906678, + "wall_seconds": 119.68112216517329, + "examples": 15360000, + "supervised_tokens": 92160000, + "executed_input_tokens": 430080000, + "estimated_matmul_training_flops": 132557045760000, + "atomic_epochs": 882.3529411764706, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:14.342314+00:00" + }, + { + "step": 30600, + "epoch": 900, + "cumulative_step": 30600, + "metrics": {}, + "loss": 0.33460697531700134, + "training_seconds": 111.97351156175137, + "wall_seconds": 121.98537196591496, + "examples": 15667200, + "supervised_tokens": 94003200, + "executed_input_tokens": 438681600, + "estimated_matmul_training_flops": 135208186675200, + "atomic_epochs": 900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:16.646555+00:00" + }, + { + "step": 34000, + "epoch": 1000, + "cumulative_step": 34000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.548828125, + "answer_nll": 1.5592328310012817, + "knowledge_nll": 1.5592232942581177, + "identifier_accuracy": 0.548828125, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 116.27950286865234, + "knowledge_nll": 52.80556106567383, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.5234375, + "second_atomic_accuracy": 0.89501953125, + "both_atomic_n": 949, + "both_atomic_coverage": 0.46337890625, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 116.55720520019531, + "knowledge_nll": 53.22972869873047, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.52978515625, + "second_atomic_accuracy": 0.9423828125, + "both_atomic_n": 1026, + "both_atomic_coverage": 0.5009765625, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 116.32867431640625, + "knowledge_nll": 52.82170104980469, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.5263671875, + "second_atomic_accuracy": 0.89599609375, + "both_atomic_n": 966, + "both_atomic_coverage": 0.4716796875, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 115.96151733398438, + "knowledge_nll": 52.92300796508789, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.5283203125, + "second_atomic_accuracy": 0.9375, + "both_atomic_n": 1007, + "both_atomic_coverage": 0.49169921875, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 116.40193939208984, + "knowledge_nll": 52.59864044189453, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.31636086106300354, + "training_seconds": 124.20568400993943, + "wall_seconds": 135.4017266407609, + "examples": 17408000, + "supervised_tokens": 104448000, + "executed_input_tokens": 487424000, + "estimated_matmul_training_flops": 150231318528000, + "atomic_epochs": 1000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:30.062936+00:00" + }, + { + "step": 35000, + "epoch": 1029.4117647058824, + "cumulative_step": 35000, + "metrics": {}, + "loss": 0.29473960399627686, + "training_seconds": 127.9219872020185, + "wall_seconds": 139.40424343943596, + "examples": 17920000, + "supervised_tokens": 107520000, + "executed_input_tokens": 501760000, + "estimated_matmul_training_flops": 154649886720000, + "atomic_epochs": 1029.4117647058824, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:34.065391+00:00" + }, + { + "step": 37400, + "epoch": 1100, + "cumulative_step": 37400, + "metrics": {}, + "loss": 0.291384220123291, + "training_seconds": 136.52718267217278, + "wall_seconds": 148.53267453238368, + "examples": 19148800, + "supervised_tokens": 114892800, + "executed_input_tokens": 536166400, + "estimated_matmul_training_flops": 165254450380800, + "atomic_epochs": 1100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:43.193830+00:00" + }, + { + "step": 40000, + "epoch": 1176.4705882352941, + "cumulative_step": 40000, + "metrics": {}, + "loss": 0.2508707642555237, + "training_seconds": 145.94679940119386, + "wall_seconds": 159.4592254087329, + "examples": 20480000, + "supervised_tokens": 122880000, + "executed_input_tokens": 573440000, + "estimated_matmul_training_flops": 176742727680000, + "atomic_epochs": 1176.4705882352941, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:54.120389+00:00" + }, + { + "step": 40800, + "epoch": 1200, + "cumulative_step": 40800, + "metrics": {}, + "loss": 0.27984973788261414, + "training_seconds": 148.82786829024553, + "wall_seconds": 162.54419180378318, + "examples": 20889600, + "supervised_tokens": 125337600, + "executed_input_tokens": 584908800, + "estimated_matmul_training_flops": 180277582233600, + "atomic_epochs": 1200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:57.205363+00:00" + }, + { + "step": 44200, + "epoch": 1300, + "cumulative_step": 44200, + "metrics": {}, + "loss": 0.2625585198402405, + "training_seconds": 161.09513058513403, + "wall_seconds": 175.58054028078914, + "examples": 22630400, + "supervised_tokens": 135782400, + "executed_input_tokens": 633651200, + "estimated_matmul_training_flops": 195300714086400, + "atomic_epochs": 1300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:10.241728+00:00" + }, + { + "step": 45000, + "epoch": 1323.5294117647059, + "cumulative_step": 45000, + "metrics": {}, + "loss": 0.24781878292560577, + "training_seconds": 163.99946911633015, + "wall_seconds": 178.73103165253997, + "examples": 23040000, + "supervised_tokens": 138240000, + "executed_input_tokens": 645120000, + "estimated_matmul_training_flops": 198835568640000, + "atomic_epochs": 1323.5294117647059, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:13.392142+00:00" + }, + { + "step": 47600, + "epoch": 1400, + "cumulative_step": 47600, + "metrics": {}, + "loss": 0.28106942772865295, + "training_seconds": 173.41661797091365, + "wall_seconds": 188.71717211604118, + "examples": 24371200, + "supervised_tokens": 146227200, + "executed_input_tokens": 682393600, + "estimated_matmul_training_flops": 210323845939200, + "atomic_epochs": 1400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:23.378343+00:00" + }, + { + "step": 50000, + "epoch": 1470.5882352941176, + "cumulative_step": 50000, + "metrics": {}, + "loss": 0.24959169328212738, + "training_seconds": 182.06765447184443, + "wall_seconds": 197.93626170232892, + "examples": 25600000, + "supervised_tokens": 153600000, + "executed_input_tokens": 716800000, + "estimated_matmul_training_flops": 220928409600000, + "atomic_epochs": 1470.5882352941176, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:32.597365+00:00" + }, + { + "step": 51000, + "epoch": 1500, + "cumulative_step": 51000, + "metrics": {}, + "loss": 0.2537613809108734, + "training_seconds": 185.66913335770369, + "wall_seconds": 201.78282180801034, + "examples": 26112000, + "supervised_tokens": 156672000, + "executed_input_tokens": 731136000, + "estimated_matmul_training_flops": 225346977792000, + "atomic_epochs": 1500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:36.443980+00:00" + }, + { + "step": 54400, + "epoch": 1600, + "cumulative_step": 54400, + "metrics": {}, + "loss": 0.2549106776714325, + "training_seconds": 198.13198360055685, + "wall_seconds": 215.02816075459123, + "examples": 27852800, + "supervised_tokens": 167116800, + "executed_input_tokens": 779878400, + "estimated_matmul_training_flops": 240370109644800, + "atomic_epochs": 1600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:49.689343+00:00" + }, + { + "step": 55000, + "epoch": 1617.6470588235295, + "cumulative_step": 55000, + "metrics": {}, + "loss": 0.2544589340686798, + "training_seconds": 200.26429496705532, + "wall_seconds": 217.36281671002507, + "examples": 28160000, + "supervised_tokens": 168960000, + "executed_input_tokens": 788480000, + "estimated_matmul_training_flops": 243021250560000, + "atomic_epochs": 1617.6470588235295, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:52.023930+00:00" + }, + { + "step": 57800, + "epoch": 1700, + "cumulative_step": 57800, + "metrics": {}, + "loss": 0.24833934009075165, + "training_seconds": 210.3576719649136, + "wall_seconds": 228.06036611273885, + "examples": 29593600, + "supervised_tokens": 177561600, + "executed_input_tokens": 828620800, + "estimated_matmul_training_flops": 255393241497600, + "atomic_epochs": 1700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:02.721523+00:00" + }, + { + "step": 60000, + "epoch": 1764.7058823529412, + "cumulative_step": 60000, + "metrics": {}, + "loss": 0.2190898209810257, + "training_seconds": 218.24501482397318, + "wall_seconds": 236.47213027998805, + "examples": 30720000, + "supervised_tokens": 184320000, + "executed_input_tokens": 860160000, + "estimated_matmul_training_flops": 265114091520000, + "atomic_epochs": 1764.7058823529412, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:11.133269+00:00" + }, + { + "step": 61200, + "epoch": 1800, + "cumulative_step": 61200, + "metrics": {}, + "loss": 0.24517832696437836, + "training_seconds": 222.56681273505092, + "wall_seconds": 241.08162144944072, + "examples": 31334400, + "supervised_tokens": 188006400, + "executed_input_tokens": 877363200, + "estimated_matmul_training_flops": 270416373350400, + "atomic_epochs": 1800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:15.742812+00:00" + }, + { + "step": 64600, + "epoch": 1900, + "cumulative_step": 64600, + "metrics": {}, + "loss": 0.2451639175415039, + "training_seconds": 234.7929235883057, + "wall_seconds": 254.07494655624032, + "examples": 33075200, + "supervised_tokens": 198451200, + "executed_input_tokens": 926105600, + "estimated_matmul_training_flops": 285439505203200, + "atomic_epochs": 1900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:28.736077+00:00" + }, + { + "step": 65000, + "epoch": 1911.764705882353, + "cumulative_step": 65000, + "metrics": {}, + "loss": 0.26125892996788025, + "training_seconds": 236.29174979403615, + "wall_seconds": 255.74450950697064, + "examples": 33280000, + "supervised_tokens": 199680000, + "executed_input_tokens": 931840000, + "estimated_matmul_training_flops": 287206932480000, + "atomic_epochs": 1911.764705882353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:30.405620+00:00" + }, + { + "step": 68000, + "epoch": 2000, + "cumulative_step": 68000, + "metrics": {}, + "loss": 0.21484751999378204, + "training_seconds": 247.2265676036477, + "wall_seconds": 267.4850465245545, + "examples": 34816000, + "supervised_tokens": 208896000, + "executed_input_tokens": 974848000, + "estimated_matmul_training_flops": 300462637056000, + "atomic_epochs": 2000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:42.146207+00:00" + }, + { + "step": 70000, + "epoch": 2058.823529411765, + "cumulative_step": 70000, + "metrics": {}, + "loss": 0.2102993279695511, + "training_seconds": 254.51620326191187, + "wall_seconds": 275.2667791284621, + "examples": 35840000, + "supervised_tokens": 215040000, + "executed_input_tokens": 1003520000, + "estimated_matmul_training_flops": 309299773440000, + "atomic_epochs": 2058.823529411765, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:49.927932+00:00" + }, + { + "step": 71400, + "epoch": 2100, + "cumulative_step": 71400, + "metrics": {}, + "loss": 0.2438260167837143, + "training_seconds": 259.5142023935914, + "wall_seconds": 281.3409280218184, + "examples": 36556800, + "supervised_tokens": 219340800, + "executed_input_tokens": 1023590400, + "estimated_matmul_training_flops": 315485768908800, + "atomic_epochs": 2100.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:56.002097+00:00" + }, + { + "step": 74800, + "epoch": 2200, + "cumulative_step": 74800, + "metrics": {}, + "loss": 0.2311636358499527, + "training_seconds": 271.74123419448733, + "wall_seconds": 294.33210675418377, + "examples": 38297600, + "supervised_tokens": 229785600, + "executed_input_tokens": 1072332800, + "estimated_matmul_training_flops": 330508900761600, + "atomic_epochs": 2200.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:08.993217+00:00" + }, + { + "step": 75000, + "epoch": 2205.8823529411766, + "cumulative_step": 75000, + "metrics": {}, + "loss": 0.22026561200618744, + "training_seconds": 272.47437835484743, + "wall_seconds": 295.19916842132807, + "examples": 38400000, + "supervised_tokens": 230400000, + "executed_input_tokens": 1075200000, + "estimated_matmul_training_flops": 331392614400000, + "atomic_epochs": 2205.8823529411766, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:09.860273+00:00" + }, + { + "step": 78200, + "epoch": 2300, + "cumulative_step": 78200, + "metrics": {}, + "loss": 0.21557550132274628, + "training_seconds": 283.9504702091217, + "wall_seconds": 307.442227602005, + "examples": 40038400, + "supervised_tokens": 240230400, + "executed_input_tokens": 1121075200, + "estimated_matmul_training_flops": 345532032614400, + "atomic_epochs": 2300.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:22.103391+00:00" + }, + { + "step": 80000, + "epoch": 2352.9411764705883, + "cumulative_step": 80000, + "metrics": {}, + "loss": 0.20322072505950928, + "training_seconds": 290.51249681413174, + "wall_seconds": 314.44899126142263, + "examples": 40960000, + "supervised_tokens": 245760000, + "executed_input_tokens": 1146880000, + "estimated_matmul_training_flops": 353485455360000, + "atomic_epochs": 2352.9411764705883, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:29.110107+00:00" + }, + { + "step": 81600, + "epoch": 2400, + "cumulative_step": 81600, + "metrics": {}, + "loss": 0.21753539144992828, + "training_seconds": 296.2484092004597, + "wall_seconds": 320.5566578246653, + "examples": 41779200, + "supervised_tokens": 250675200, + "executed_input_tokens": 1169817600, + "estimated_matmul_training_flops": 360555164467200, + "atomic_epochs": 2400.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:35.217776+00:00" + }, + { + "step": 85000, + "epoch": 2500, + "cumulative_step": 85000, + "metrics": {}, + "loss": 0.20513488352298737, + "training_seconds": 308.5125801227987, + "wall_seconds": 333.5909368209541, + "examples": 43520000, + "supervised_tokens": 261120000, + "executed_input_tokens": 1218560000, + "estimated_matmul_training_flops": 375578296320000, + "atomic_epochs": 2500.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:48.252090+00:00" + }, + { + "step": 88400, + "epoch": 2600, + "cumulative_step": 88400, + "metrics": {}, + "loss": 0.2144704908132553, + "training_seconds": 320.8227873891592, + "wall_seconds": 346.6753051504493, + "examples": 45260800, + "supervised_tokens": 271564800, + "executed_input_tokens": 1267302400, + "estimated_matmul_training_flops": 390601428172800, + "atomic_epochs": 2600.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:01.336467+00:00" + }, + { + "step": 90000, + "epoch": 2647.0588235294117, + "cumulative_step": 90000, + "metrics": {}, + "loss": 0.17351870238780975, + "training_seconds": 326.6402629390359, + "wall_seconds": 352.9261645972729, + "examples": 46080000, + "supervised_tokens": 276480000, + "executed_input_tokens": 1290240000, + "estimated_matmul_training_flops": 397671137280000, + "atomic_epochs": 2647.0588235294117, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:07.587305+00:00" + }, + { + "step": 91800, + "epoch": 2700, + "cumulative_step": 91800, + "metrics": {}, + "loss": 0.21208612620830536, + "training_seconds": 333.1710846349597, + "wall_seconds": 359.87431585788727, + "examples": 47001600, + "supervised_tokens": 282009600, + "executed_input_tokens": 1316044800, + "estimated_matmul_training_flops": 405624560025600, + "atomic_epochs": 2700.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:14.535438+00:00" + }, + { + "step": 95000, + "epoch": 2794.1176470588234, + "cumulative_step": 95000, + "metrics": {}, + "loss": 0.177230104804039, + "training_seconds": 344.7646546252072, + "wall_seconds": 372.19201853498816, + "examples": 48640000, + "supervised_tokens": 291840000, + "executed_input_tokens": 1361920000, + "estimated_matmul_training_flops": 419763978240000, + "atomic_epochs": 2794.1176470588234, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:26.853163+00:00" + }, + { + "step": 95200, + "epoch": 2800, + "cumulative_step": 95200, + "metrics": {}, + "loss": 0.20396125316619873, + "training_seconds": 345.4855513498187, + "wall_seconds": 373.00323717296124, + "examples": 48742400, + "supervised_tokens": 292454400, + "executed_input_tokens": 1364787200, + "estimated_matmul_training_flops": 420647691878400, + "atomic_epochs": 2800.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:27.664346+00:00" + }, + { + "step": 98600, + "epoch": 2900, + "cumulative_step": 98600, + "metrics": {}, + "loss": 0.18677592277526855, + "training_seconds": 357.85517692938447, + "wall_seconds": 386.14051616564393, + "examples": 50483200, + "supervised_tokens": 302899200, + "executed_input_tokens": 1413529600, + "estimated_matmul_training_flops": 435670823731200, + "atomic_epochs": 2900.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:40.801661+00:00" + }, + { + "step": 100000, + "epoch": 2941.176470588235, + "cumulative_step": 100000, + "metrics": {}, + "loss": 0.17607396841049194, + "training_seconds": 362.88329884037375, + "wall_seconds": 391.53338070213795, + "examples": 51200000, + "supervised_tokens": 307200000, + "executed_input_tokens": 1433600000, + "estimated_matmul_training_flops": 441856819200000, + "atomic_epochs": 2941.176470588235, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:46.194483+00:00" + }, + { + "step": 102000, + "epoch": 3000, + "cumulative_step": 102000, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7165096507352942, + "answer_nll": 0.9351626634597778, + "knowledge_nll": 0.935147225856781, + "identifier_accuracy": 0.7165096507352942, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.70599365234375, + "answer_nll": 0.9714698195457458, + "knowledge_nll": 0.971454918384552, + "identifier_accuracy": 0.70599365234375, + "learned_bits_raw": 108109.6078426016 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.884765625, + "answer_nll": 0.35424816608428955, + "knowledge_nll": 0.3542240560054779, + "identifier_accuracy": 0.884765625, + "learned_bits_raw": 7668.697816102218 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.22854614257812, + "knowledge_nll": 49.78916931152344, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.7109375, + "second_atomic_accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.97843170166016, + "knowledge_nll": 50.494781494140625, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.7001953125, + "second_atomic_accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.48211669921875, + "knowledge_nll": 49.74689483642578, + "identifier_accuracy": 0.00048828125, + "population_n": 13308, + "first_atomic_accuracy": 0.70458984375, + "second_atomic_accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.88727569580078, + "knowledge_nll": 50.95634460449219, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.7177734375, + "second_atomic_accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.36808013916016, + "knowledge_nll": 49.981666564941406, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 115778.30552662114, + "learned_bits_per_parameter": 1.1243231969257026 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.64306640625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0015232292460015233, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.61572265625, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.001589825119236884, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6123046875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00537109375, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.004788507581803671, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.64111328125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0053475935828877, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 0.19359396398067474, + "training_seconds": 370.2270343378186, + "wall_seconds": 400.3384733647108, + "examples": 52224000, + "supervised_tokens": 313344000, + "executed_input_tokens": 1462272000, + "estimated_matmul_training_flops": 450693955584000, + "atomic_epochs": 3000.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:54.999660+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/preflight.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/run.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/run.json new file mode 100644 index 0000000000000000000000000000000000000000..4722a7572c3f3d387658aa80e4e0af287c8c96ad --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/run.json @@ -0,0 +1,195 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic-h4096", + "training_mode": "atomic", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096" + }, + "world_sha256": "8694a4dec375266f0b68eee9976ded8af1f46a59146a604ffc4e58cd9f731eef", + "initial_model_sha256": "92086c98673d3bc1f9a6571266eec6d392bba58e3b70733208be49cad5e48d4f", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 17408, + "composition_examples": 18469, + "evaluation_nodes": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 0, + "parent_examples": 0, + "training_mode": "atomic", + "created_utc": "2026-10-05T23:16:14.608374+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/status.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/status.json new file mode 100644 index 0000000000000000000000000000000000000000..63eb2b759c1e2b2dc341fc75ef8ba35c6ad1b7ac --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 102000 +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/trained.json b/results/capacity-recall-controls-v1/runs/atomic-h4096/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..ddf404766c672884cf70a14b899b7d80745cdbd8 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "9266034670815003c5e32b40e2c8a7ee8c5e0fe9c609b9474ab2655466e0842f", + "epochs": 3000, + "step": 102000, + "training_pid": 44, + "created_utc": "2026-10-05T23:22:55.110301+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic-h4096/worker.log b/results/capacity-recall-controls-v1/runs/atomic-h4096/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..b872c58b3a240cabe0d8e7c8d999220c29be6ca8 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic-h4096/worker.log @@ -0,0 +1,52 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.918397903442383, "knowledge_nll": 12.682050704956055, "identifier_accuracy": 0.0, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.449495315551758, "knowledge_nll": 12.73082160949707, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.451412200927734, "knowledge_nll": 12.738428115844727, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.451452255249023, "knowledge_nll": 12.735528945922852, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.456905364990234, "knowledge_nll": 12.742338180541992, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.455768585205078, "knowledge_nll": 12.733171463012695, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 340, "epoch": 10, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0048828125, "answer_nll": 5.55714225769043, "knowledge_nll": 5.554952144622803, "identifier_accuracy": 0.0048828125, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 34.939483642578125, "knowledge_nll": 18.0362606048584, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.0009765625, "second_atomic_accuracy": 0.0029296875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 35.00710678100586, "knowledge_nll": 18.07924461364746, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.00830078125, "second_atomic_accuracy": 0.00830078125, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 34.93748474121094, "knowledge_nll": 18.037094116210938, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.00390625, "second_atomic_accuracy": 0.00244140625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 34.97959899902344, "knowledge_nll": 18.045307159423828, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.0068359375, "second_atomic_accuracy": 0.00634765625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 34.94676971435547, "knowledge_nll": 18.047203063964844, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 1020, "epoch": 30, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0009765625, "answer_nll": 5.55418586730957, "knowledge_nll": 5.553859710693359, "identifier_accuracy": 0.0009765625, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 37.866943359375, "knowledge_nll": 18.111173629760742, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.00390625, "second_atomic_accuracy": 0.0048828125, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 38.09527587890625, "knowledge_nll": 18.15799331665039, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.00341796875, "second_atomic_accuracy": 0.0126953125, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 38.02764129638672, "knowledge_nll": 18.095767974853516, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.00341796875, "second_atomic_accuracy": 0.00341796875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 37.92219924926758, "knowledge_nll": 18.11306381225586, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.00146484375, "second_atomic_accuracy": 0.01123046875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 37.990535736083984, "knowledge_nll": 18.112926483154297, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 3400, "epoch": 100, "metrics": {"atomic": {"n": 2048, "accuracy": 0.00830078125, "answer_nll": 5.548836708068848, "knowledge_nll": 5.5487213134765625, "identifier_accuracy": 0.00830078125, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.07551193237305, "knowledge_nll": 20.53970718383789, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.0009765625, "second_atomic_accuracy": 0.0029296875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.37554931640625, "knowledge_nll": 20.493831634521484, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.00732421875, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.27153015136719, "knowledge_nll": 20.477514266967773, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.0078125, "second_atomic_accuracy": 0.00341796875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.052486419677734, "knowledge_nll": 20.363731384277344, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.0078125, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.23309326171875, "knowledge_nll": 20.53664779663086, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 5000, "epoch": 147.05882352941177, "metrics": {}} +{"step": 6800, "epoch": 200, "metrics": {}} +{"step": 10000, "epoch": 294.11764705882354, "metrics": {}} +{"step": 10200, "epoch": 300, "metrics": {"atomic": {"n": 2048, "accuracy": 0.22998046875, "answer_nll": 3.1515653133392334, "knowledge_nll": 3.151440143585205, "identifier_accuracy": 0.22998046875, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 70.5671615600586, "knowledge_nll": 34.852394104003906, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.1953125, "second_atomic_accuracy": 0.69970703125, "both_atomic_n": 272, "both_atomic_coverage": 0.1328125, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 70.98748016357422, "knowledge_nll": 34.68799591064453, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.20458984375, "second_atomic_accuracy": 0.73583984375, "both_atomic_n": 307, "both_atomic_coverage": 0.14990234375, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 70.72868347167969, "knowledge_nll": 34.67470169067383, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.20556640625, "second_atomic_accuracy": 0.69775390625, "both_atomic_n": 291, "both_atomic_coverage": 0.14208984375, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 70.27263641357422, "knowledge_nll": 34.437442779541016, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.2041015625, "second_atomic_accuracy": 0.7685546875, "both_atomic_n": 323, "both_atomic_coverage": 0.15771484375, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 70.93522644042969, "knowledge_nll": 34.80216979980469, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 13600, "epoch": 400, "metrics": {}} +{"step": 15000, "epoch": 441.1764705882353, "metrics": {}} +{"step": 17000, "epoch": 500, "metrics": {}} +{"step": 20000, "epoch": 588.2352941176471, "metrics": {}} +{"step": 20400, "epoch": 600, "metrics": {}} +{"step": 23800, "epoch": 700, "metrics": {}} +{"step": 25000, "epoch": 735.2941176470588, "metrics": {}} +{"step": 27200, "epoch": 800, "metrics": {}} +{"step": 30000, "epoch": 882.3529411764706, "metrics": {}} +{"step": 30600, "epoch": 900, "metrics": {}} +{"step": 34000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 0.548828125, "answer_nll": 1.5592328310012817, "knowledge_nll": 1.5592232942581177, "identifier_accuracy": 0.548828125, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 116.27950286865234, "knowledge_nll": 52.80556106567383, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.5234375, "second_atomic_accuracy": 0.89501953125, "both_atomic_n": 949, "both_atomic_coverage": 0.46337890625, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 116.55720520019531, "knowledge_nll": 53.22972869873047, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.52978515625, "second_atomic_accuracy": 0.9423828125, "both_atomic_n": 1026, "both_atomic_coverage": 0.5009765625, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 116.32867431640625, "knowledge_nll": 52.82170104980469, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.5263671875, "second_atomic_accuracy": 0.89599609375, "both_atomic_n": 966, "both_atomic_coverage": 0.4716796875, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 115.96151733398438, "knowledge_nll": 52.92300796508789, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.5283203125, "second_atomic_accuracy": 0.9375, "both_atomic_n": 1007, "both_atomic_coverage": 0.49169921875, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 116.40193939208984, "knowledge_nll": 52.59864044189453, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 35000, "epoch": 1029.4117647058824, "metrics": {}} +{"step": 37400, "epoch": 1100, "metrics": {}} +{"step": 40000, "epoch": 1176.4705882352941, "metrics": {}} +{"step": 40800, "epoch": 1200, "metrics": {}} +{"step": 44200, "epoch": 1300, "metrics": {}} +{"step": 45000, "epoch": 1323.5294117647059, "metrics": {}} +{"step": 47600, "epoch": 1400, "metrics": {}} +{"step": 50000, "epoch": 1470.5882352941176, "metrics": {}} +{"step": 51000, "epoch": 1500, "metrics": {}} +{"step": 54400, "epoch": 1600, "metrics": {}} +{"step": 55000, "epoch": 1617.6470588235295, "metrics": {}} +{"step": 57800, "epoch": 1700, "metrics": {}} +{"step": 60000, "epoch": 1764.7058823529412, "metrics": {}} +{"step": 61200, "epoch": 1800, "metrics": {}} +{"step": 64600, "epoch": 1900, "metrics": {}} +{"step": 65000, "epoch": 1911.764705882353, "metrics": {}} +{"step": 68000, "epoch": 2000, "metrics": {}} +{"step": 70000, "epoch": 2058.823529411765, "metrics": {}} +{"step": 71400, "epoch": 2100, "metrics": {}} +{"step": 74800, "epoch": 2200, "metrics": {}} +{"step": 75000, "epoch": 2205.8823529411766, "metrics": {}} +{"step": 78200, "epoch": 2300, "metrics": {}} +{"step": 80000, "epoch": 2352.9411764705883, "metrics": {}} +{"step": 81600, "epoch": 2400, "metrics": {}} +{"step": 85000, "epoch": 2500, "metrics": {}} +{"step": 88400, "epoch": 2600, "metrics": {}} +{"step": 90000, "epoch": 2647.0588235294117, "metrics": {}} +{"step": 91800, "epoch": 2700, "metrics": {}} +{"step": 95000, "epoch": 2794.1176470588234, "metrics": {}} +{"step": 95200, "epoch": 2800, "metrics": {}} +{"step": 98600, "epoch": 2900, "metrics": {}} +{"step": 100000, "epoch": 2941.176470588235, "metrics": {}} +{"step": 102000, "epoch": 3000, "metrics": {"atomic": {"n": 17408, "accuracy": 0.7165096507352942, "answer_nll": 0.9351626634597778, "knowledge_nll": 0.935147225856781, "identifier_accuracy": 0.7165096507352942, "full_population": true}, "atomic_first": {"n": 16384, "accuracy": 0.70599365234375, "answer_nll": 0.9714698195457458, "knowledge_nll": 0.971454918384552, "identifier_accuracy": 0.70599365234375, "learned_bits_raw": 108109.6078426016}, "atomic_second": {"n": 1024, "accuracy": 0.884765625, "answer_nll": 0.35424816608428955, "knowledge_nll": 0.3542240560054779, "identifier_accuracy": 0.884765625, "learned_bits_raw": 7668.697816102218}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 123.22854614257812, "knowledge_nll": 49.78916931152344, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.7109375, "second_atomic_accuracy": 0.89013671875, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 123.97843170166016, "knowledge_nll": 50.494781494140625, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.7001953125, "second_atomic_accuracy": 0.8798828125, "both_atomic_n": 1258, "both_atomic_coverage": 0.6142578125, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 123.48211669921875, "knowledge_nll": 49.74689483642578, "identifier_accuracy": 0.00048828125, "population_n": 13308, "first_atomic_accuracy": 0.70458984375, "second_atomic_accuracy": 0.86279296875, "both_atomic_n": 1253, "both_atomic_coverage": 0.61181640625, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 123.88727569580078, "knowledge_nll": 50.95634460449219, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.7177734375, "second_atomic_accuracy": 0.89501953125, "both_atomic_n": 1309, "both_atomic_coverage": 0.63916015625, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 123.36808013916016, "knowledge_nll": 49.981666564941406, "identifier_accuracy": 0.0, "population_n": 18469}, "information": {"independent_facts": 17408, "world_bits": 139264.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 1.3523927905531385, "composition_independent_bits": 0, "learned_bits_raw": 115778.30552662114, "learned_bits_per_parameter": 1.1243231969257026}, "serial_II": {"n": 2048, "accuracy": 0.64306640625, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.99951171875, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 2048, "accuracy": 0.0048828125, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 0.0015232292460015233, "valid_bridge_fraction": 0.99951171875, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 2048, "accuracy": 0.89013671875, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.99951171875, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 2048, "accuracy": 0.61572265625, "both_atomic_n": 1258, "both_atomic_coverage": 0.6142578125, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 2048, "accuracy": 0.0048828125, "both_atomic_n": 1258, "both_atomic_coverage": 0.6142578125, "both_atomic_composition_accuracy": 0.001589825119236884, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 2048, "accuracy": 0.8798828125, "both_atomic_n": 1258, "both_atomic_coverage": 0.6142578125, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 2048, "accuracy": 0.6123046875, "both_atomic_n": 1253, "both_atomic_coverage": 0.61181640625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 2048, "accuracy": 0.00537109375, "both_atomic_n": 1253, "both_atomic_coverage": 0.61181640625, "both_atomic_composition_accuracy": 0.004788507581803671, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 2048, "accuracy": 0.86279296875, "both_atomic_n": 1253, "both_atomic_coverage": 0.61181640625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 2048, "accuracy": 0.64111328125, "both_atomic_n": 1309, "both_atomic_coverage": 0.63916015625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 2048, "accuracy": 0.0087890625, "both_atomic_n": 1309, "both_atomic_coverage": 0.63916015625, "both_atomic_composition_accuracy": 0.0053475935828877, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 2048, "accuracy": 0.89501953125, "both_atomic_n": 1309, "both_atomic_coverage": 0.63916015625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/audit.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..672d882d6f5d991053ad60c369e2fd66609e7e4b --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "bc532147aec498c6e878d08ab2c16389553eb6e51e02d1e195c580b8605f6d0e", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00031458126613870263, + "knowledge_nll": 0.00031447564833797514, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00034317426616325974, + "knowledge_nll": 0.00034307054011151195, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32765.972700500402 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00020020920783281326, + "knowledge_nll": 0.0002000961685553193, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.704393983922 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 152.88522338867188, + "knowledge_nll": 81.95446014404297, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.7292022705078, + "knowledge_nll": 83.51936340332031, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.1458740234375, + "knowledge_nll": 82.13455963134766, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 155.16091918945312, + "knowledge_nll": 83.30101776123047, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 153.95921325683594, + "knowledge_nll": 82.60690307617188, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40957.67709461331, + "learned_bits_per_parameter": 0.39774002772115163 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 29379000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:18:43.392833+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/complete.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..672d882d6f5d991053ad60c369e2fd66609e7e4b --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "bc532147aec498c6e878d08ab2c16389553eb6e51e02d1e195c580b8605f6d0e", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00031458126613870263, + "knowledge_nll": 0.00031447564833797514, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00034317426616325974, + "knowledge_nll": 0.00034307054011151195, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32765.972700500402 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00020020920783281326, + "knowledge_nll": 0.0002000961685553193, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.704393983922 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 152.88522338867188, + "knowledge_nll": 81.95446014404297, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.7292022705078, + "knowledge_nll": 83.51936340332031, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.1458740234375, + "knowledge_nll": 82.13455963134766, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 155.16091918945312, + "knowledge_nll": 83.30101776123047, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 153.95921325683594, + "knowledge_nll": 82.60690307617188, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40957.67709461331, + "learned_bits_per_parameter": 0.39774002772115163 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 29379000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:18:43.392833+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-command-1.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..6736ebbb21db2ed0b681a95c2c15fc8b7d2b75f3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-851b87d2df399fa8e0e2", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-851b87d2df399fa8e0e2", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h1024,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h1024", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h1024" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-inspect.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..23468c058a44b43aa071f5da2173450cd65c98b6 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb", + "Created": "2026-10-05T23:14:43.461526988Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h1024" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:14:43.471863448Z", + "FinishedAt": "2026-10-05T23:18:44.706815121Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb/0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb-json.log", + "Name": "/lm-capctrl-851b87d2df399fa8e0e2", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h1024", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h1024" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/0890a58fc56f224fbe3ebb668a3590dee05ca8ca367e4f87e9d5e277aa25327c-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/0890a58fc56f224fbe3ebb668a3590dee05ca8ca367e4f87e9d5e277aa25327c/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/0890a58fc56f224fbe3ebb668a3590dee05ca8ca367e4f87e9d5e277aa25327c/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/0890a58fc56f224fbe3ebb668a3590dee05ca8ca367e4f87e9d5e277aa25327c/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h1024", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h1024", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "0e75ff1ca329", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PHYSICAL_GPU=0", + "PYTHONDONTWRITEBYTECODE=1", + "OMP_NUM_THREADS=4", + "MKL_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "TORCH_HOME=/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "XDG_CACHE_HOME=/tmp/cache", + "TRITON_CACHE_DIR=/tmp/triton", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h1024" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-runtime.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..2f429df6ed506c3a5edd59f5aa9e21252526e1a1 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 335597, + "container_id": "0e75ff1ca329af6e39abc1e594efa6f0a84028bef4aace522744467dd9e4c5eb", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/learning.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..a7e5670b7d12cec70cae8abe15abe5e998992d09 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/learning.json @@ -0,0 +1,1237 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.86443328857422, + "knowledge_nll": 12.675850868225098, + "identifier_accuracy": 0.0, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.454959869384766, + "knowledge_nll": 12.738142013549805, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.45623016357422, + "knowledge_nll": 12.748790740966797, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.442459106445312, + "knowledge_nll": 12.72464370727539, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 19.457590103149414, + "knowledge_nll": 12.738996505737305, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.454479217529297, + "knowledge_nll": 12.738774299621582, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.3788784183561802, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 86559232, + "created_utc": "2026-10-05T23:14:49.139702+00:00" + }, + { + "step": 200, + "epoch": 10, + "cumulative_step": 200, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0078125, + "answer_nll": 5.560964584350586, + "knowledge_nll": 5.555086135864258, + "identifier_accuracy": 0.0078125, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 28.61090850830078, + "knowledge_nll": 16.582462310791016, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0009765625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 28.699665069580078, + "knowledge_nll": 16.66507339477539, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.01025390625, + "second_atomic_accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 28.592594146728516, + "knowledge_nll": 16.59225082397461, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.0048828125, + "second_atomic_accuracy": 0.0009765625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 28.650732040405273, + "knowledge_nll": 16.617090225219727, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.036236490781945324, + "second_atomic_accuracy": 0.003178639542275906, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 28.62204360961914, + "knowledge_nll": 16.59872055053711, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.9267985820770264, + "training_seconds": 0.892419945448637, + "wall_seconds": 1.6762100234627724, + "examples": 97930, + "supervised_tokens": 587580, + "executed_input_tokens": 2742040, + "estimated_matmul_training_flops": 845137466880, + "atomic_epochs": 19.126953125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:50.437121+00:00" + }, + { + "step": 600, + "epoch": 30, + "cumulative_step": 600, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.00390625, + "answer_nll": 5.5576887130737305, + "knowledge_nll": 5.5549397468566895, + "identifier_accuracy": 0.00390625, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 31.414688110351562, + "knowledge_nll": 22.783666610717773, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.0048828125, + "second_atomic_accuracy": 0.0009765625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 31.288028717041016, + "knowledge_nll": 22.83930206298828, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.005859375, + "second_atomic_accuracy": 0.001953125, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 31.37946128845215, + "knowledge_nll": 22.76251983642578, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.001953125, + "second_atomic_accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 31.377153396606445, + "knowledge_nll": 22.7894344329834, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.0019071837253655435, + "second_atomic_accuracy": 0.003178639542275906, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 31.384674072265625, + "knowledge_nll": 22.802854537963867, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.9231440424919128, + "training_seconds": 2.2891800366342068, + "wall_seconds": 3.5327021665871143, + "examples": 293790, + "supervised_tokens": 1762740, + "executed_input_tokens": 8226120, + "estimated_matmul_training_flops": 2535412400640, + "atomic_epochs": 57.380859375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:52.293510+00:00" + }, + { + "step": 2000, + "epoch": 100, + "cumulative_step": 2000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.01025390625, + "answer_nll": 5.397185325622559, + "knowledge_nll": 5.396487236022949, + "identifier_accuracy": 0.01025390625, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 30.79526138305664, + "knowledge_nll": 19.08661651611328, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.01220703125, + "second_atomic_accuracy": 0.0087890625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 30.90575408935547, + "knowledge_nll": 19.1127986907959, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.0107421875, + "second_atomic_accuracy": 0.01123046875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 30.86226463317871, + "knowledge_nll": 19.094703674316406, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.01171875, + "second_atomic_accuracy": 0.00634765625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 31.054073333740234, + "knowledge_nll": 19.016054153442383, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.02288620470438652, + "second_atomic_accuracy": 0.00572155117609663, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 30.78527069091797, + "knowledge_nll": 19.11118507385254, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.8905754685401917, + "training_seconds": 7.264921095222235, + "wall_seconds": 9.194660864770412, + "examples": 979300, + "supervised_tokens": 5875800, + "executed_input_tokens": 27420400, + "estimated_matmul_training_flops": 8451374668800, + "atomic_epochs": 191.26953125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:14:57.955512+00:00" + }, + { + "step": 4000, + "epoch": 200, + "cumulative_step": 4000, + "metrics": {}, + "loss": 0.15545417368412018, + "training_seconds": 14.312929794192314, + "wall_seconds": 16.74400758743286, + "examples": 1958600, + "supervised_tokens": 11751600, + "executed_input_tokens": 54840800, + "estimated_matmul_training_flops": 16902749337600, + "atomic_epochs": 382.5390625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:05.504895+00:00" + }, + { + "step": 6000, + "epoch": 300, + "cumulative_step": 6000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.90966796875, + "answer_nll": 0.29131802916526794, + "knowledge_nll": 0.2912478446960449, + "identifier_accuracy": 0.90966796875, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 93.29458618164062, + "knowledge_nll": 54.75498962402344, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.91259765625, + "second_atomic_accuracy": 0.9287109375, + "both_atomic_n": 1739, + "both_atomic_coverage": 0.84912109375, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 92.94587707519531, + "knowledge_nll": 54.71247482299805, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.9130859375, + "second_atomic_accuracy": 0.91845703125, + "both_atomic_n": 1717, + "both_atomic_coverage": 0.83837890625, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 93.00596618652344, + "knowledge_nll": 54.00278854370117, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.92138671875, + "second_atomic_accuracy": 0.92431640625, + "both_atomic_n": 1739, + "both_atomic_coverage": 0.84912109375, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 92.56111145019531, + "knowledge_nll": 52.93830490112305, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.9351557533375715, + "second_atomic_accuracy": 0.9357914812460267, + "both_atomic_n": 1376, + "both_atomic_coverage": 0.8747616020343293, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 93.28491973876953, + "knowledge_nll": 54.414093017578125, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.06318937242031097, + "training_seconds": 21.206842988729477, + "wall_seconds": 24.37064103782177, + "examples": 2937900, + "supervised_tokens": 17627400, + "executed_input_tokens": 82261200, + "estimated_matmul_training_flops": 25354124006400, + "atomic_epochs": 573.80859375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:13.131492+00:00" + }, + { + "step": 8000, + "epoch": 400, + "cumulative_step": 8000, + "metrics": {}, + "loss": 0.00014921127876732498, + "training_seconds": 28.305501651018858, + "wall_seconds": 31.975350938737392, + "examples": 3917200, + "supervised_tokens": 23503200, + "executed_input_tokens": 109681600, + "estimated_matmul_training_flops": 33805498675200, + "atomic_epochs": 765.078125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:20.736225+00:00" + }, + { + "step": 10000, + "epoch": 500, + "cumulative_step": 10000, + "metrics": {}, + "loss": 4.501758303376846e-05, + "training_seconds": 35.2252798601985, + "wall_seconds": 39.38790926337242, + "examples": 4896500, + "supervised_tokens": 29379000, + "executed_input_tokens": 137102000, + "estimated_matmul_training_flops": 42256873344000, + "atomic_epochs": 956.34765625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:28.148795+00:00" + }, + { + "step": 12000, + "epoch": 600, + "cumulative_step": 12000, + "metrics": {}, + "loss": 0.00021157316223252565, + "training_seconds": 42.39003084972501, + "wall_seconds": 47.055122908204794, + "examples": 5875800, + "supervised_tokens": 35254800, + "executed_input_tokens": 164522400, + "estimated_matmul_training_flops": 50708248012800, + "atomic_epochs": 1147.6171875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:35.816000+00:00" + }, + { + "step": 14000, + "epoch": 700, + "cumulative_step": 14000, + "metrics": {}, + "loss": 4.2770381696755067e-05, + "training_seconds": 49.451187681406736, + "wall_seconds": 54.61058774963021, + "examples": 6855100, + "supervised_tokens": 41130600, + "executed_input_tokens": 191942800, + "estimated_matmul_training_flops": 59159622681600, + "atomic_epochs": 1338.88671875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:43.371454+00:00" + }, + { + "step": 16000, + "epoch": 800, + "cumulative_step": 16000, + "metrics": {}, + "loss": 2.002320616156794e-05, + "training_seconds": 56.36751461774111, + "wall_seconds": 62.01793197542429, + "examples": 7834400, + "supervised_tokens": 47006400, + "executed_input_tokens": 219363200, + "estimated_matmul_training_flops": 67610997350400, + "atomic_epochs": 1530.15625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:50.778770+00:00" + }, + { + "step": 18000, + "epoch": 900, + "cumulative_step": 18000, + "metrics": {}, + "loss": 8.941678970586509e-06, + "training_seconds": 63.32546513900161, + "wall_seconds": 69.46938078477979, + "examples": 8813700, + "supervised_tokens": 52882200, + "executed_input_tokens": 246783600, + "estimated_matmul_training_flops": 76062372019200, + "atomic_epochs": 1721.42578125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:15:58.230225+00:00" + }, + { + "step": 20000, + "epoch": 1000, + "cumulative_step": 20000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.43310546875, + "answer_nll": 2.0994153022766113, + "knowledge_nll": 2.0994133949279785, + "identifier_accuracy": 0.43310546875, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 72.84380340576172, + "knowledge_nll": 38.31366729736328, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 0.42041015625, + "second_atomic_accuracy": 0.4814453125, + "both_atomic_n": 412, + "both_atomic_coverage": 0.201171875, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 73.34969329833984, + "knowledge_nll": 39.41017532348633, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 0.41748046875, + "second_atomic_accuracy": 0.4951171875, + "both_atomic_n": 411, + "both_atomic_coverage": 0.20068359375, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 73.49813842773438, + "knowledge_nll": 38.30183410644531, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 0.43603515625, + "second_atomic_accuracy": 0.455078125, + "both_atomic_n": 393, + "both_atomic_coverage": 0.19189453125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 72.717041015625, + "knowledge_nll": 38.40132141113281, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 0.4195804195804196, + "second_atomic_accuracy": 0.48951048951048953, + "both_atomic_n": 317, + "both_atomic_coverage": 0.20152574698029244, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 73.35298156738281, + "knowledge_nll": 38.78681945800781, + "identifier_accuracy": 0.0, + "population_n": 4673 + } + }, + "loss": 0.36924657225608826, + "training_seconds": 70.33167361468077, + "wall_seconds": 77.25846024230123, + "examples": 9793000, + "supervised_tokens": 58758000, + "executed_input_tokens": 274204000, + "estimated_matmul_training_flops": 84513746688000, + "atomic_epochs": 1912.6953125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:06.019323+00:00" + }, + { + "step": 22000, + "epoch": 1100, + "cumulative_step": 22000, + "metrics": {}, + "loss": 0.000160969328135252, + "training_seconds": 77.30042912065983, + "wall_seconds": 84.72246019914746, + "examples": 10772300, + "supervised_tokens": 64633800, + "executed_input_tokens": 301624400, + "estimated_matmul_training_flops": 92965121356800, + "atomic_epochs": 2103.96484375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:13.483278+00:00" + }, + { + "step": 24000, + "epoch": 1200, + "cumulative_step": 24000, + "metrics": {}, + "loss": 5.368307756725699e-05, + "training_seconds": 84.25266295671463, + "wall_seconds": 92.17136221379042, + "examples": 11751600, + "supervised_tokens": 70509600, + "executed_input_tokens": 329044800, + "estimated_matmul_training_flops": 101416496025600, + "atomic_epochs": 2295.234375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:20.932160+00:00" + }, + { + "step": 26000, + "epoch": 1300, + "cumulative_step": 26000, + "metrics": {}, + "loss": 2.5772955268621445e-05, + "training_seconds": 91.30573381111026, + "wall_seconds": 99.715111926198, + "examples": 12730900, + "supervised_tokens": 76385400, + "executed_input_tokens": 356465200, + "estimated_matmul_training_flops": 109867870694400, + "atomic_epochs": 2486.50390625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:28.475950+00:00" + }, + { + "step": 28000, + "epoch": 1400, + "cumulative_step": 28000, + "metrics": {}, + "loss": 0.0003445084730628878, + "training_seconds": 98.2270402237773, + "wall_seconds": 107.12098383903503, + "examples": 13710200, + "supervised_tokens": 82261200, + "executed_input_tokens": 383885600, + "estimated_matmul_training_flops": 118319245363200, + "atomic_epochs": 2677.7734375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:35.881861+00:00" + }, + { + "step": 30000, + "epoch": 1500, + "cumulative_step": 30000, + "metrics": {}, + "loss": 3.679623841890134e-05, + "training_seconds": 105.12671828269958, + "wall_seconds": 114.50935806334019, + "examples": 14689500, + "supervised_tokens": 88137000, + "executed_input_tokens": 411306000, + "estimated_matmul_training_flops": 126770620032000, + "atomic_epochs": 2869.04296875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:43.270171+00:00" + }, + { + "step": 32000, + "epoch": 1600, + "cumulative_step": 32000, + "metrics": {}, + "loss": 1.8561215256340802e-05, + "training_seconds": 112.03512885048985, + "wall_seconds": 121.92162293568254, + "examples": 15668800, + "supervised_tokens": 94012800, + "executed_input_tokens": 438726400, + "estimated_matmul_training_flops": 135221994700800, + "atomic_epochs": 3060.3125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:50.682436+00:00" + }, + { + "step": 34000, + "epoch": 1700, + "cumulative_step": 34000, + "metrics": {}, + "loss": 7.0942978709354065e-06, + "training_seconds": 118.99292853474617, + "wall_seconds": 129.37514032796025, + "examples": 16648100, + "supervised_tokens": 99888600, + "executed_input_tokens": 466146800, + "estimated_matmul_training_flops": 143673369369600, + "atomic_epochs": 3251.58203125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:16:58.135995+00:00" + }, + { + "step": 36000, + "epoch": 1800, + "cumulative_step": 36000, + "metrics": {}, + "loss": 3.2354296308767516e-06, + "training_seconds": 125.99808395653963, + "wall_seconds": 136.8785966783762, + "examples": 17627400, + "supervised_tokens": 105764400, + "executed_input_tokens": 493567200, + "estimated_matmul_training_flops": 152124744038400, + "atomic_epochs": 3442.8515625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:05.639399+00:00" + }, + { + "step": 38000, + "epoch": 1900, + "cumulative_step": 38000, + "metrics": {}, + "loss": 1.2134850067013758e-06, + "training_seconds": 132.89571047574282, + "wall_seconds": 144.26559779420495, + "examples": 18606700, + "supervised_tokens": 111640200, + "executed_input_tokens": 520987600, + "estimated_matmul_training_flops": 160576118707200, + "atomic_epochs": 3634.12109375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:13.026424+00:00" + }, + { + "step": 40000, + "epoch": 2000, + "cumulative_step": 40000, + "metrics": {}, + "loss": 4.007262077720952e-07, + "training_seconds": 139.87234804034233, + "wall_seconds": 151.73956295102835, + "examples": 19586000, + "supervised_tokens": 117516000, + "executed_input_tokens": 548408000, + "estimated_matmul_training_flops": 169027493376000, + "atomic_epochs": 3825.390625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:20.500415+00:00" + }, + { + "step": 42000, + "epoch": 2100, + "cumulative_step": 42000, + "metrics": {}, + "loss": 1.4916440704837441e-07, + "training_seconds": 147.25186536088586, + "wall_seconds": 159.62320280075073, + "examples": 20565300, + "supervised_tokens": 123391800, + "executed_input_tokens": 575828400, + "estimated_matmul_training_flops": 177478868044800, + "atomic_epochs": 4016.66015625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:28.384015+00:00" + }, + { + "step": 44000, + "epoch": 2200, + "cumulative_step": 44000, + "metrics": {}, + "loss": 5.165735572632002e-08, + "training_seconds": 154.19323220849037, + "wall_seconds": 167.06021993234754, + "examples": 21544600, + "supervised_tokens": 129267600, + "executed_input_tokens": 603248800, + "estimated_matmul_training_flops": 185930242713600, + "atomic_epochs": 4207.9296875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:35.821029+00:00" + }, + { + "step": 46000, + "epoch": 2300, + "cumulative_step": 46000, + "metrics": {}, + "loss": 1.9868211964535476e-08, + "training_seconds": 161.10062585398555, + "wall_seconds": 174.75724840164185, + "examples": 22523900, + "supervised_tokens": 135143400, + "executed_input_tokens": 630669200, + "estimated_matmul_training_flops": 194381617382400, + "atomic_epochs": 4399.19921875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:43.518079+00:00" + }, + { + "step": 48000, + "epoch": 2400, + "cumulative_step": 48000, + "metrics": {}, + "loss": 0.17882989346981049, + "training_seconds": 168.1093094199896, + "wall_seconds": 182.25660142302513, + "examples": 23503200, + "supervised_tokens": 141019200, + "executed_input_tokens": 658089600, + "estimated_matmul_training_flops": 202832992051200, + "atomic_epochs": 4590.46875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:51.017443+00:00" + }, + { + "step": 50000, + "epoch": 2500, + "cumulative_step": 50000, + "metrics": {}, + "loss": 0.042228858917951584, + "training_seconds": 175.07018795609474, + "wall_seconds": 189.70561205223203, + "examples": 24482500, + "supervised_tokens": 146895000, + "executed_input_tokens": 685510000, + "estimated_matmul_training_flops": 211284366720000, + "atomic_epochs": 4781.73828125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:17:58.466419+00:00" + }, + { + "step": 52000, + "epoch": 2600, + "cumulative_step": 52000, + "metrics": {}, + "loss": 0.0451405830681324, + "training_seconds": 182.01262006163597, + "wall_seconds": 197.1437288299203, + "examples": 25461800, + "supervised_tokens": 152770800, + "executed_input_tokens": 712930400, + "estimated_matmul_training_flops": 219735741388800, + "atomic_epochs": 4973.0078125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:18:05.904526+00:00" + }, + { + "step": 54000, + "epoch": 2700, + "cumulative_step": 54000, + "metrics": {}, + "loss": 8.948385220719501e-05, + "training_seconds": 188.95352743566036, + "wall_seconds": 204.5760423503816, + "examples": 26441100, + "supervised_tokens": 158646600, + "executed_input_tokens": 740350800, + "estimated_matmul_training_flops": 228187116057600, + "atomic_epochs": 5164.27734375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:18:13.336883+00:00" + }, + { + "step": 56000, + "epoch": 2800, + "cumulative_step": 56000, + "metrics": {}, + "loss": 2.9560951588791795e-05, + "training_seconds": 195.9356056675315, + "wall_seconds": 212.0530275180936, + "examples": 27420400, + "supervised_tokens": 164522400, + "executed_input_tokens": 767771200, + "estimated_matmul_training_flops": 236638490726400, + "atomic_epochs": 5355.546875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:18:20.813867+00:00" + }, + { + "step": 58000, + "epoch": 2900, + "cumulative_step": 58000, + "metrics": {}, + "loss": 0.00017861959349829704, + "training_seconds": 202.85447497293353, + "wall_seconds": 219.4635189138353, + "examples": 28399700, + "supervised_tokens": 170398200, + "executed_input_tokens": 795191600, + "estimated_matmul_training_flops": 245089865395200, + "atomic_epochs": 5546.81640625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:18:28.224307+00:00" + }, + { + "step": 60000, + "epoch": 3000, + "cumulative_step": 60000, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00031458126613870263, + "knowledge_nll": 0.00031447564833797514, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00034317426616325974, + "knowledge_nll": 0.00034307054011151195, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32765.972700500402 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00020020920783281326, + "knowledge_nll": 0.0002000961685553193, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.704393983922 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 152.88522338867188, + "knowledge_nll": 81.95446014404297, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.7292022705078, + "knowledge_nll": 83.51936340332031, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.1458740234375, + "knowledge_nll": 82.13455963134766, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 155.16091918945312, + "knowledge_nll": 83.30101776123047, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 153.95921325683594, + "knowledge_nll": 82.60690307617188, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40957.67709461331, + "learned_bits_per_parameter": 0.39774002772115163 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 5.6006865634117275e-05, + "training_seconds": 209.9312109015882, + "wall_seconds": 227.79693263024092, + "examples": 29379000, + "supervised_tokens": 176274000, + "executed_input_tokens": 822612000, + "estimated_matmul_training_flops": 253541240064000, + "atomic_epochs": 5738.0859375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 135967232, + "created_utc": "2026-10-05T23:18:36.557727+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/preflight.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/run.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/run.json new file mode 100644 index 0000000000000000000000000000000000000000..9192cd33faebb261d0e21b72c297d276d1f736a2 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/run.json @@ -0,0 +1,195 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic_replay-h1024", + "training_mode": "atomic_replay", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024" + }, + "world_sha256": "bc532147aec498c6e878d08ab2c16389553eb6e51e02d1e195c580b8605f6d0e", + "initial_model_sha256": "92086c98673d3bc1f9a6571266eec6d392bba58e3b70733208be49cad5e48d4f", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 5120, + "composition_examples": 4673, + "evaluation_nodes": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 0, + "parent_examples": 0, + "training_mode": "atomic_replay", + "created_utc": "2026-10-05T23:14:48.710310+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/status.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/status.json new file mode 100644 index 0000000000000000000000000000000000000000..994595985c7b50cfb4ef281a99f1d97a992d1e9f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 60000 +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/trained.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..77cefbc60da64cd11911d76f11db3dde88e82880 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "a8910bda390d1ac2018d3412f8c7c10e119667c005ed5a8c671fda500cac00fb", + "epochs": 3000, + "step": 60000, + "training_pid": 44, + "created_utc": "2026-10-05T23:18:36.666238+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/worker.log b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..68c9547b42f214b8d6710d4b8c3b5467263e34c3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h1024/worker.log @@ -0,0 +1,33 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.86443328857422, "knowledge_nll": 12.675850868225098, "identifier_accuracy": 0.0, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.454959869384766, "knowledge_nll": 12.738142013549805, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.45623016357422, "knowledge_nll": 12.748790740966797, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.442459106445312, "knowledge_nll": 12.72464370727539, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 19.457590103149414, "knowledge_nll": 12.738996505737305, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.454479217529297, "knowledge_nll": 12.738774299621582, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 200, "epoch": 10, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0078125, "answer_nll": 5.560964584350586, "knowledge_nll": 5.555086135864258, "identifier_accuracy": 0.0078125, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 28.61090850830078, "knowledge_nll": 16.582462310791016, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0009765625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 28.699665069580078, "knowledge_nll": 16.66507339477539, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.01025390625, "second_atomic_accuracy": 0.00341796875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 28.592594146728516, "knowledge_nll": 16.59225082397461, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.0048828125, "second_atomic_accuracy": 0.0009765625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 28.650732040405273, "knowledge_nll": 16.617090225219727, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.036236490781945324, "second_atomic_accuracy": 0.003178639542275906, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 28.62204360961914, "knowledge_nll": 16.59872055053711, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 600, "epoch": 30, "metrics": {"atomic": {"n": 2048, "accuracy": 0.00390625, "answer_nll": 5.5576887130737305, "knowledge_nll": 5.5549397468566895, "identifier_accuracy": 0.00390625, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 31.414688110351562, "knowledge_nll": 22.783666610717773, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.0048828125, "second_atomic_accuracy": 0.0009765625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 31.288028717041016, "knowledge_nll": 22.83930206298828, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.005859375, "second_atomic_accuracy": 0.001953125, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 31.37946128845215, "knowledge_nll": 22.76251983642578, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.001953125, "second_atomic_accuracy": 0.00341796875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 31.377153396606445, "knowledge_nll": 22.7894344329834, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.0019071837253655435, "second_atomic_accuracy": 0.003178639542275906, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 31.384674072265625, "knowledge_nll": 22.802854537963867, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 2000, "epoch": 100, "metrics": {"atomic": {"n": 2048, "accuracy": 0.01025390625, "answer_nll": 5.397185325622559, "knowledge_nll": 5.396487236022949, "identifier_accuracy": 0.01025390625, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 30.79526138305664, "knowledge_nll": 19.08661651611328, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.01220703125, "second_atomic_accuracy": 0.0087890625, "both_atomic_n": 1, "both_atomic_coverage": 0.00048828125, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 30.90575408935547, "knowledge_nll": 19.1127986907959, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.0107421875, "second_atomic_accuracy": 0.01123046875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 30.86226463317871, "knowledge_nll": 19.094703674316406, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.01171875, "second_atomic_accuracy": 0.00634765625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 31.054073333740234, "knowledge_nll": 19.016054153442383, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.02288620470438652, "second_atomic_accuracy": 0.00572155117609663, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 30.78527069091797, "knowledge_nll": 19.11118507385254, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 4000, "epoch": 200, "metrics": {}} +{"step": 6000, "epoch": 300, "metrics": {"atomic": {"n": 2048, "accuracy": 0.90966796875, "answer_nll": 0.29131802916526794, "knowledge_nll": 0.2912478446960449, "identifier_accuracy": 0.90966796875, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 93.29458618164062, "knowledge_nll": 54.75498962402344, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.91259765625, "second_atomic_accuracy": 0.9287109375, "both_atomic_n": 1739, "both_atomic_coverage": 0.84912109375, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 92.94587707519531, "knowledge_nll": 54.71247482299805, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.9130859375, "second_atomic_accuracy": 0.91845703125, "both_atomic_n": 1717, "both_atomic_coverage": 0.83837890625, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 93.00596618652344, "knowledge_nll": 54.00278854370117, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.92138671875, "second_atomic_accuracy": 0.92431640625, "both_atomic_n": 1739, "both_atomic_coverage": 0.84912109375, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 92.56111145019531, "knowledge_nll": 52.93830490112305, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.9351557533375715, "second_atomic_accuracy": 0.9357914812460267, "both_atomic_n": 1376, "both_atomic_coverage": 0.8747616020343293, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 93.28491973876953, "knowledge_nll": 54.414093017578125, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 8000, "epoch": 400, "metrics": {}} +{"step": 10000, "epoch": 500, "metrics": {}} +{"step": 12000, "epoch": 600, "metrics": {}} +{"step": 14000, "epoch": 700, "metrics": {}} +{"step": 16000, "epoch": 800, "metrics": {}} +{"step": 18000, "epoch": 900, "metrics": {}} +{"step": 20000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 0.43310546875, "answer_nll": 2.0994153022766113, "knowledge_nll": 2.0994133949279785, "identifier_accuracy": 0.43310546875, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 72.84380340576172, "knowledge_nll": 38.31366729736328, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 0.42041015625, "second_atomic_accuracy": 0.4814453125, "both_atomic_n": 412, "both_atomic_coverage": 0.201171875, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 73.34969329833984, "knowledge_nll": 39.41017532348633, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 0.41748046875, "second_atomic_accuracy": 0.4951171875, "both_atomic_n": 411, "both_atomic_coverage": 0.20068359375, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 73.49813842773438, "knowledge_nll": 38.30183410644531, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 0.43603515625, "second_atomic_accuracy": 0.455078125, "both_atomic_n": 393, "both_atomic_coverage": 0.19189453125, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 72.717041015625, "knowledge_nll": 38.40132141113281, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 0.4195804195804196, "second_atomic_accuracy": 0.48951048951048953, "both_atomic_n": 317, "both_atomic_coverage": 0.20152574698029244, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 73.35298156738281, "knowledge_nll": 38.78681945800781, "identifier_accuracy": 0.0, "population_n": 4673}}} +{"step": 22000, "epoch": 1100, "metrics": {}} +{"step": 24000, "epoch": 1200, "metrics": {}} +{"step": 26000, "epoch": 1300, "metrics": {}} +{"step": 28000, "epoch": 1400, "metrics": {}} +{"step": 30000, "epoch": 1500, "metrics": {}} +{"step": 32000, "epoch": 1600, "metrics": {}} +{"step": 34000, "epoch": 1700, "metrics": {}} +{"step": 36000, "epoch": 1800, "metrics": {}} +{"step": 38000, "epoch": 1900, "metrics": {}} +{"step": 40000, "epoch": 2000, "metrics": {}} +{"step": 42000, "epoch": 2100, "metrics": {}} +{"step": 44000, "epoch": 2200, "metrics": {}} +{"step": 46000, "epoch": 2300, "metrics": {}} +{"step": 48000, "epoch": 2400, "metrics": {}} +{"step": 50000, "epoch": 2500, "metrics": {}} +{"step": 52000, "epoch": 2600, "metrics": {}} +{"step": 54000, "epoch": 2700, "metrics": {}} +{"step": 56000, "epoch": 2800, "metrics": {}} +{"step": 58000, "epoch": 2900, "metrics": {}} +{"step": 60000, "epoch": 3000, "metrics": {"atomic": {"n": 5120, "accuracy": 1.0, "answer_nll": 0.00031458126613870263, "knowledge_nll": 0.00031447564833797514, "identifier_accuracy": 1.0, "full_population": true}, "atomic_first": {"n": 4096, "accuracy": 1.0, "answer_nll": 0.00034317426616325974, "knowledge_nll": 0.00034307054011151195, "identifier_accuracy": 1.0, "learned_bits_raw": 32765.972700500402}, "atomic_second": {"n": 1024, "accuracy": 1.0, "answer_nll": 0.00020020920783281326, "knowledge_nll": 0.0002000961685553193, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.704393983922}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 152.88522338867188, "knowledge_nll": 81.95446014404297, "identifier_accuracy": 0.0, "population_n": 4402, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 154.7292022705078, "knowledge_nll": 83.51936340332031, "identifier_accuracy": 0.0, "population_n": 2629, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 154.1458740234375, "knowledge_nll": 82.13455963134766, "identifier_accuracy": 0.0, "population_n": 3107, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 1573, "accuracy": 0.0, "answer_nll": 155.16091918945312, "knowledge_nll": 83.30101776123047, "identifier_accuracy": 0.0, "population_n": 1573, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 153.95921325683594, "knowledge_nll": 82.60690307617188, "identifier_accuracy": 0.0, "population_n": 4673}, "information": {"independent_facts": 5120, "world_bits": 40960.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 0.3977625854568055, "composition_independent_bits": 0, "learned_bits_raw": 40957.67709461331, "learned_bits_per_parameter": 0.39774002772115163}, "serial_II": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 2048, "accuracy": 0.00390625, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.00390625, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 2048, "accuracy": 0.00439453125, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.00439453125, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 2048, "accuracy": 0.001953125, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.001953125, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 2048, "accuracy": 1.0, "both_atomic_n": 2048, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 1573, "accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 1573, "accuracy": 0.003814367450731087, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.003814367450731087, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 1573, "accuracy": 1.0, "both_atomic_n": 1573, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/audit.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..771ee49c4ab1ef77cc6a757e1dad15ee8ed8a20c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.291015625, + "answer_nll": 2.560638427734375, + "knowledge_nll": 2.5604748725891113, + "identifier_accuracy": 0.291015625, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 0.2236328125, + "answer_nll": 2.7695472240448, + "knowledge_nll": 2.76949405670166, + "identifier_accuracy": 0.2236328125, + "learned_bits_raw": 4100.571810432059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.3583984375, + "answer_nll": 2.35172963142395, + "knowledge_nll": 2.3514554500579834, + "identifier_accuracy": 0.3583984375, + "learned_bits_raw": 4718.148488529942 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 63.565555572509766, + "knowledge_nll": 29.89066505432129, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.23863636363636365, + "second_atomic_accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 64.41242218017578, + "knowledge_nll": 30.54340362548828, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.20987654320987653, + "second_atomic_accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 64.0531005859375, + "knowledge_nll": 30.21320915222168, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.24673202614379086, + "second_atomic_accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 63.25845718383789, + "knowledge_nll": 29.904817581176758, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.19301470588235295, + "second_atomic_accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 63.29830551147461, + "knowledge_nll": 29.5711612701416, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 8818.719946741532, + "learned_bits_per_parameter": 0.08563859488367709 + }, + "serial_II": { + "n": 880, + "accuracy": 0.10795454545454546, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.07295173961840629, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.09640522875816994, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.004901960784313725, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.06985294117647059, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 9651000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:14:40.348607+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/complete.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..771ee49c4ab1ef77cc6a757e1dad15ee8ed8a20c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.291015625, + "answer_nll": 2.560638427734375, + "knowledge_nll": 2.5604748725891113, + "identifier_accuracy": 0.291015625, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 0.2236328125, + "answer_nll": 2.7695472240448, + "knowledge_nll": 2.76949405670166, + "identifier_accuracy": 0.2236328125, + "learned_bits_raw": 4100.571810432059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.3583984375, + "answer_nll": 2.35172963142395, + "knowledge_nll": 2.3514554500579834, + "identifier_accuracy": 0.3583984375, + "learned_bits_raw": 4718.148488529942 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 63.565555572509766, + "knowledge_nll": 29.89066505432129, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.23863636363636365, + "second_atomic_accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 64.41242218017578, + "knowledge_nll": 30.54340362548828, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.20987654320987653, + "second_atomic_accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 64.0531005859375, + "knowledge_nll": 30.21320915222168, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.24673202614379086, + "second_atomic_accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 63.25845718383789, + "knowledge_nll": 29.904817581176758, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.19301470588235295, + "second_atomic_accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 63.29830551147461, + "knowledge_nll": 29.5711612701416, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 8818.719946741532, + "learned_bits_per_parameter": 0.08563859488367709 + }, + "serial_II": { + "n": 880, + "accuracy": 0.10795454545454546, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.07295173961840629, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.09640522875816994, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.004901960784313725, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.06985294117647059, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 9651000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:14:40.348607+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-command-1.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..4ac2ac06e05dee0fb021e38321f55a0597e35594 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-dbb34e5665d728349515", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-dbb34e5665d728349515", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h256,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h256", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h256" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-inspect.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..fcb3c8256d430dd3436e39889aab38e853b96a92 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7", + "Created": "2026-10-05T23:13:05.701007904Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h256" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:13:05.713725073Z", + "FinishedAt": "2026-10-05T23:14:41.097611457Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7/58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7-json.log", + "Name": "/lm-capctrl-dbb34e5665d728349515", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h256", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h256" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/ea10bac87200ead9fc9bd4e4ce799ac843df67263c71bb23fd7f6d4fa791e08e-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/ea10bac87200ead9fc9bd4e4ce799ac843df67263c71bb23fd7f6d4fa791e08e/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/ea10bac87200ead9fc9bd4e4ce799ac843df67263c71bb23fd7f6d4fa791e08e/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/ea10bac87200ead9fc9bd4e4ce799ac843df67263c71bb23fd7f6d4fa791e08e/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h256", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h256", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "58a9b7647f25", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PYTHONDONTWRITEBYTECODE=1", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "TRITON_CACHE_DIR=/tmp/triton", + "PHYSICAL_GPU=0", + "OMP_NUM_THREADS=4", + "MKL_NUM_THREADS=4", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h256" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-runtime.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..3ca1698d148d632e29e30911c4a97aa8e49651ff --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 333525, + "container_id": "58a9b7647f25d4576f736071dbb19ca42809fdb37bc7d2473d35c49f8f44d4f7", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/learning.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..afb92e2908ac1079bed9c30130fbcaacdc29f836 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/learning.json @@ -0,0 +1,1309 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.800018310546875, + "knowledge_nll": 12.712567329406738, + "identifier_accuracy": 0.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 19.480695724487305, + "knowledge_nll": 12.7626314163208, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 19.454242706298828, + "knowledge_nll": 12.749253273010254, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 19.46780776977539, + "knowledge_nll": 12.748907089233398, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 19.464326858520508, + "knowledge_nll": 12.742711067199707, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 19.463520050048828, + "knowledge_nll": 12.744767189025879, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.3207201920449734, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 85190656, + "created_utc": "2026-10-05T23:13:11.562866+00:00" + }, + { + "step": 70, + "epoch": 10, + "cumulative_step": 70, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.005859375, + "answer_nll": 5.723837852478027, + "knowledge_nll": 5.620140552520752, + "identifier_accuracy": 0.005859375, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 21.466371536254883, + "knowledge_nll": 13.222684860229492, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.0022727272727272726, + "second_atomic_accuracy": 0.0011363636363636363, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 21.480058670043945, + "knowledge_nll": 13.236153602600098, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.006734006734006734, + "second_atomic_accuracy": 0.003367003367003367, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 21.445405960083008, + "knowledge_nll": 13.226515769958496, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.011437908496732025, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 21.480541229248047, + "knowledge_nll": 13.25053596496582, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.03860294117647059, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 21.474767684936523, + "knowledge_nll": 13.233658790588379, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 0.9568157196044922, + "training_seconds": 0.4007802717387676, + "wall_seconds": 0.9384335950016975, + "examples": 32170, + "supervised_tokens": 193020, + "executed_input_tokens": 900760, + "estimated_matmul_training_flops": 277627614720, + "atomic_epochs": 15.7080078125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:12.180507+00:00" + }, + { + "step": 210, + "epoch": 30, + "cumulative_step": 210, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.00390625, + "answer_nll": 5.533601760864258, + "knowledge_nll": 5.527665138244629, + "identifier_accuracy": 0.00390625, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 26.675439834594727, + "knowledge_nll": 16.357038497924805, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.003409090909090909, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 26.669998168945312, + "knowledge_nll": 16.365840911865234, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.003367003367003367, + "second_atomic_accuracy": 0.008978675645342313, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 26.468109130859375, + "knowledge_nll": 16.353334426879883, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0016339869281045752, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 26.443098068237305, + "knowledge_nll": 16.342512130737305, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.007352941176470588, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 26.646108627319336, + "knowledge_nll": 16.37232208251953, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 0.9342085123062134, + "training_seconds": 0.9109615869820118, + "wall_seconds": 1.737604919821024, + "examples": 96510, + "supervised_tokens": 579060, + "executed_input_tokens": 2702280, + "estimated_matmul_training_flops": 832882844160, + "atomic_epochs": 47.1240234375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:12.979677+00:00" + }, + { + "step": 700, + "epoch": 100, + "cumulative_step": 700, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.4189453125, + "answer_nll": 2.0690298080444336, + "knowledge_nll": 2.0670032501220703, + "identifier_accuracy": 0.4189453125, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 38.700340270996094, + "knowledge_nll": 23.0335750579834, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.4159090909090909, + "second_atomic_accuracy": 0.4409090909090909, + "both_atomic_n": 180, + "both_atomic_coverage": 0.20454545454545456, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 38.8272819519043, + "knowledge_nll": 23.28221893310547, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.4489337822671156, + "second_atomic_accuracy": 0.4175084175084175, + "both_atomic_n": 167, + "both_atomic_coverage": 0.18742985409652077, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 38.75544357299805, + "knowledge_nll": 23.287168502807617, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.369281045751634, + "second_atomic_accuracy": 0.44607843137254904, + "both_atomic_n": 92, + "both_atomic_coverage": 0.1503267973856209, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 38.034210205078125, + "knowledge_nll": 22.723217010498047, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.3713235294117647, + "second_atomic_accuracy": 0.4227941176470588, + "both_atomic_n": 86, + "both_atomic_coverage": 0.15808823529411764, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 38.7315673828125, + "knowledge_nll": 23.12601661682129, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 0.37235525250434875, + "training_seconds": 2.643298964947462, + "wall_seconds": 3.8070876076817513, + "examples": 321700, + "supervised_tokens": 1930200, + "executed_input_tokens": 9007600, + "estimated_matmul_training_flops": 2776276147200, + "atomic_epochs": 157.080078125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:15.049306+00:00" + }, + { + "step": 1400, + "epoch": 200, + "cumulative_step": 1400, + "metrics": {}, + "loss": 0.00020653560932260007, + "training_seconds": 5.101283863186836, + "wall_seconds": 6.51081545650959, + "examples": 643400, + "supervised_tokens": 3860400, + "executed_input_tokens": 18015200, + "estimated_matmul_training_flops": 5552552294400, + "atomic_epochs": 314.16015625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:17.753046+00:00" + }, + { + "step": 2100, + "epoch": 300, + "cumulative_step": 2100, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0005333680892363191, + "knowledge_nll": 0.0005042148986831307, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 58.717655181884766, + "knowledge_nll": 39.43427658081055, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 59.30015182495117, + "knowledge_nll": 40.4374885559082, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 59.47480010986328, + "knowledge_nll": 40.29357147216797, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 58.912757873535156, + "knowledge_nll": 40.33546447753906, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 59.121177673339844, + "knowledge_nll": 40.02766418457031, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 9.084690100280568e-05, + "training_seconds": 7.565431918948889, + "wall_seconds": 9.652733247727156, + "examples": 965100, + "supervised_tokens": 5790600, + "executed_input_tokens": 27022800, + "estimated_matmul_training_flops": 8328828441600, + "atomic_epochs": 471.240234375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:20.894870+00:00" + }, + { + "step": 2800, + "epoch": 400, + "cumulative_step": 2800, + "metrics": {}, + "loss": 5.4910466133151203e-05, + "training_seconds": 10.029702186584473, + "wall_seconds": 12.344532527029514, + "examples": 1286800, + "supervised_tokens": 7720800, + "executed_input_tokens": 36030400, + "estimated_matmul_training_flops": 11105104588800, + "atomic_epochs": 628.3203125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:23.586680+00:00" + }, + { + "step": 3500, + "epoch": 500, + "cumulative_step": 3500, + "metrics": {}, + "loss": 3.753379132831469e-05, + "training_seconds": 12.453919392079115, + "wall_seconds": 14.996182713657618, + "examples": 1608500, + "supervised_tokens": 9651000, + "executed_input_tokens": 45038000, + "estimated_matmul_training_flops": 13881380736000, + "atomic_epochs": 785.400390625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:26.238307+00:00" + }, + { + "step": 4200, + "epoch": 600, + "cumulative_step": 4200, + "metrics": {}, + "loss": 2.586275149951689e-05, + "training_seconds": 14.897530935704708, + "wall_seconds": 17.838438656181097, + "examples": 1930200, + "supervised_tokens": 11581200, + "executed_input_tokens": 54045600, + "estimated_matmul_training_flops": 16657656883200, + "atomic_epochs": 942.48046875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:29.080589+00:00" + }, + { + "step": 4900, + "epoch": 700, + "cumulative_step": 4900, + "metrics": {}, + "loss": 1.9479568436508998e-05, + "training_seconds": 17.341479070484638, + "wall_seconds": 20.509217251092196, + "examples": 2251900, + "supervised_tokens": 13511400, + "executed_input_tokens": 63053200, + "estimated_matmul_training_flops": 19433933030400, + "atomic_epochs": 1099.560546875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:31.751283+00:00" + }, + { + "step": 5000, + "epoch": 714.3183089835251, + "cumulative_step": 5000, + "metrics": {}, + "loss": 1.7971784473047592e-05, + "training_seconds": 17.68745331093669, + "wall_seconds": 20.959682747721672, + "examples": 2297962, + "supervised_tokens": 13787772, + "executed_input_tokens": 64342936, + "estimated_matmul_training_flops": 19831448827392, + "atomic_epochs": 1122.0517578125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:32.201744+00:00" + }, + { + "step": 5600, + "epoch": 800, + "cumulative_step": 5600, + "metrics": {}, + "loss": 1.2286661331017967e-05, + "training_seconds": 19.798530969768763, + "wall_seconds": 23.246143855154514, + "examples": 2573600, + "supervised_tokens": 15441600, + "executed_input_tokens": 72060800, + "estimated_matmul_training_flops": 22210209177600, + "atomic_epochs": 1256.640625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:34.488248+00:00" + }, + { + "step": 6300, + "epoch": 900, + "cumulative_step": 6300, + "metrics": {}, + "loss": 9.021536243380979e-06, + "training_seconds": 22.24038379266858, + "wall_seconds": 25.920802276581526, + "examples": 2895300, + "supervised_tokens": 17371800, + "executed_input_tokens": 81068400, + "estimated_matmul_training_flops": 24986485324800, + "atomic_epochs": 1413.720703125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:37.162924+00:00" + }, + { + "step": 7000, + "epoch": 1000, + "cumulative_step": 7000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 3.924619886674918e-05, + "knowledge_nll": 3.5438377381069586e-05, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 67.23571014404297, + "knowledge_nll": 44.04039764404297, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 67.92912292480469, + "knowledge_nll": 45.098121643066406, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 68.09056854248047, + "knowledge_nll": 44.890663146972656, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 67.73210906982422, + "knowledge_nll": 45.20768356323242, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 67.88339233398438, + "knowledge_nll": 44.78683853149414, + "identifier_accuracy": 0.0, + "population_n": 1169 + } + }, + "loss": 6.710447451041546e-06, + "training_seconds": 24.681005224585533, + "wall_seconds": 28.767707105726004, + "examples": 3217000, + "supervised_tokens": 19302000, + "executed_input_tokens": 90076000, + "estimated_matmul_training_flops": 27762761472000, + "atomic_epochs": 1570.80078125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:40.009823+00:00" + }, + { + "step": 7700, + "epoch": 1100, + "cumulative_step": 7700, + "metrics": {}, + "loss": 4.437018560565775e-06, + "training_seconds": 27.1416920684278, + "wall_seconds": 31.467961329966784, + "examples": 3538700, + "supervised_tokens": 21232200, + "executed_input_tokens": 99083600, + "estimated_matmul_training_flops": 30539037619200, + "atomic_epochs": 1727.880859375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:42.710098+00:00" + }, + { + "step": 8400, + "epoch": 1200, + "cumulative_step": 8400, + "metrics": {}, + "loss": 3.1976694572222186e-06, + "training_seconds": 29.636620186269283, + "wall_seconds": 34.21153662726283, + "examples": 3860400, + "supervised_tokens": 23162400, + "executed_input_tokens": 108091200, + "estimated_matmul_training_flops": 33315313766400, + "atomic_epochs": 1884.9609375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:45.453662+00:00" + }, + { + "step": 9100, + "epoch": 1300, + "cumulative_step": 9100, + "metrics": {}, + "loss": 2.2042679574951762e-06, + "training_seconds": 32.085248585790396, + "wall_seconds": 37.54543283209205, + "examples": 4182100, + "supervised_tokens": 25092600, + "executed_input_tokens": 117098800, + "estimated_matmul_training_flops": 36091589913600, + "atomic_epochs": 2042.041015625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:48.787557+00:00" + }, + { + "step": 9800, + "epoch": 1400, + "cumulative_step": 9800, + "metrics": {}, + "loss": 1.4666819652120466e-06, + "training_seconds": 34.58693899959326, + "wall_seconds": 40.27419388666749, + "examples": 4503800, + "supervised_tokens": 27022800, + "executed_input_tokens": 126106400, + "estimated_matmul_training_flops": 38867866060800, + "atomic_epochs": 2199.12109375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:51.516284+00:00" + }, + { + "step": 10000, + "epoch": 1428.6366179670501, + "cumulative_step": 10000, + "metrics": {}, + "loss": 1.3461462913255673e-06, + "training_seconds": 35.287258729338646, + "wall_seconds": 41.1101613342762, + "examples": 4595924, + "supervised_tokens": 27575544, + "executed_input_tokens": 128685872, + "estimated_matmul_training_flops": 39662897654784, + "atomic_epochs": 2244.103515625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:52.352230+00:00" + }, + { + "step": 10500, + "epoch": 1500, + "cumulative_step": 10500, + "metrics": {}, + "loss": 1.0165656476601725e-06, + "training_seconds": 37.14175785705447, + "wall_seconds": 43.123144667595625, + "examples": 4825500, + "supervised_tokens": 28953000, + "executed_input_tokens": 135114000, + "estimated_matmul_training_flops": 41644142208000, + "atomic_epochs": 2356.201171875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:54.365211+00:00" + }, + { + "step": 11200, + "epoch": 1600, + "cumulative_step": 11200, + "metrics": {}, + "loss": 6.979902309467434e-07, + "training_seconds": 39.57841430231929, + "wall_seconds": 45.79374798387289, + "examples": 5147200, + "supervised_tokens": 30883200, + "executed_input_tokens": 144121600, + "estimated_matmul_training_flops": 44420418355200, + "atomic_epochs": 2513.28125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:57.035874+00:00" + }, + { + "step": 11900, + "epoch": 1700, + "cumulative_step": 11900, + "metrics": {}, + "loss": 4.776590571964334e-07, + "training_seconds": 42.07041684910655, + "wall_seconds": 48.51999391615391, + "examples": 5468900, + "supervised_tokens": 32813400, + "executed_input_tokens": 153129200, + "estimated_matmul_training_flops": 47196694502400, + "atomic_epochs": 2670.361328125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:13:59.762067+00:00" + }, + { + "step": 12600, + "epoch": 1800, + "cumulative_step": 12600, + "metrics": {}, + "loss": 3.1802838407202216e-07, + "training_seconds": 44.57658372446895, + "wall_seconds": 51.262880720198154, + "examples": 5790600, + "supervised_tokens": 34743600, + "executed_input_tokens": 162136800, + "estimated_matmul_training_flops": 49972970649600, + "atomic_epochs": 2827.44140625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:02.505013+00:00" + }, + { + "step": 13300, + "epoch": 1900, + "cumulative_step": 13300, + "metrics": {}, + "loss": 2.1361752544635237e-07, + "training_seconds": 47.19240749254823, + "wall_seconds": 54.115682516247034, + "examples": 6112300, + "supervised_tokens": 36673800, + "executed_input_tokens": 171144400, + "estimated_matmul_training_flops": 52749246796800, + "atomic_epochs": 2984.521484375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:05.357811+00:00" + }, + { + "step": 14000, + "epoch": 2000, + "cumulative_step": 14000, + "metrics": {}, + "loss": 1.42777082601242e-07, + "training_seconds": 49.64134180545807, + "wall_seconds": 56.80066088587046, + "examples": 6434000, + "supervised_tokens": 38604000, + "executed_input_tokens": 180152000, + "estimated_matmul_training_flops": 55525522944000, + "atomic_epochs": 3141.6015625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:08.042754+00:00" + }, + { + "step": 14700, + "epoch": 2100, + "cumulative_step": 14700, + "metrics": {}, + "loss": 9.893000196825597e-08, + "training_seconds": 52.09526900202036, + "wall_seconds": 59.490799840539694, + "examples": 6755700, + "supervised_tokens": 40534200, + "executed_input_tokens": 189159600, + "estimated_matmul_training_flops": 58301799091200, + "atomic_epochs": 3298.681640625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:10.732943+00:00" + }, + { + "step": 15000, + "epoch": 2142.954926950575, + "cumulative_step": 15000, + "metrics": {}, + "loss": 8.494436798400784e-08, + "training_seconds": 53.3323594070971, + "wall_seconds": 60.87847521901131, + "examples": 6893886, + "supervised_tokens": 41363316, + "executed_input_tokens": 193028808, + "estimated_matmul_training_flops": 59494346482176, + "atomic_epochs": 3366.1552734375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:12.120564+00:00" + }, + { + "step": 15400, + "epoch": 2200, + "cumulative_step": 15400, + "metrics": {}, + "loss": 6.672979679933633e-08, + "training_seconds": 54.79830797761679, + "wall_seconds": 62.480928134173155, + "examples": 7077400, + "supervised_tokens": 42464400, + "executed_input_tokens": 198167200, + "estimated_matmul_training_flops": 61078075238400, + "atomic_epochs": 3455.76171875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:13.723084+00:00" + }, + { + "step": 16100, + "epoch": 2300, + "cumulative_step": 16100, + "metrics": {}, + "loss": 4.56283792971135e-08, + "training_seconds": 57.279043316841125, + "wall_seconds": 65.20232526957989, + "examples": 7399100, + "supervised_tokens": 44394600, + "executed_input_tokens": 207174800, + "estimated_matmul_training_flops": 63854351385600, + "atomic_epochs": 3612.841796875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:16.444444+00:00" + }, + { + "step": 16800, + "epoch": 2400, + "cumulative_step": 16800, + "metrics": {}, + "loss": 3.302234219404454e-08, + "training_seconds": 59.714180778712034, + "wall_seconds": 67.88493384793401, + "examples": 7720800, + "supervised_tokens": 46324800, + "executed_input_tokens": 216182400, + "estimated_matmul_training_flops": 66630627532800, + "atomic_epochs": 3769.921875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:19.127031+00:00" + }, + { + "step": 17500, + "epoch": 2500, + "cumulative_step": 17500, + "metrics": {}, + "loss": 2.2060566706727514e-08, + "training_seconds": 62.14904450625181, + "wall_seconds": 70.56189731135964, + "examples": 8042500, + "supervised_tokens": 48255000, + "executed_input_tokens": 225190000, + "estimated_matmul_training_flops": 69406903680000, + "atomic_epochs": 3927.001953125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:21.804025+00:00" + }, + { + "step": 18200, + "epoch": 2600, + "cumulative_step": 18200, + "metrics": {}, + "loss": 1.7949902897385073e-08, + "training_seconds": 64.61448793113232, + "wall_seconds": 73.26251646503806, + "examples": 8364200, + "supervised_tokens": 50185200, + "executed_input_tokens": 234197600, + "estimated_matmul_training_flops": 72183179827200, + "atomic_epochs": 4084.08203125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:24.504604+00:00" + }, + { + "step": 18900, + "epoch": 2700, + "cumulative_step": 18900, + "metrics": {}, + "loss": 1.507243752030263e-08, + "training_seconds": 67.03943733125925, + "wall_seconds": 75.94404232874513, + "examples": 8685900, + "supervised_tokens": 52115400, + "executed_input_tokens": 243205200, + "estimated_matmul_training_flops": 74959455974400, + "atomic_epochs": 4241.162109375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:27.186167+00:00" + }, + { + "step": 19600, + "epoch": 2800, + "cumulative_step": 19600, + "metrics": {}, + "loss": 1.2194972143220184e-08, + "training_seconds": 69.47359759360552, + "wall_seconds": 78.61855298280716, + "examples": 9007600, + "supervised_tokens": 54045600, + "executed_input_tokens": 252212800, + "estimated_matmul_training_flops": 77735732121600, + "atomic_epochs": 4398.2421875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:29.860640+00:00" + }, + { + "step": 20000, + "epoch": 2857.1591544917624, + "cumulative_step": 20000, + "metrics": {}, + "loss": 1.8083179398331595e-08, + "training_seconds": 70.87804041802883, + "wall_seconds": 80.19588223472238, + "examples": 9191481, + "supervised_tokens": 55148886, + "executed_input_tokens": 257361468, + "estimated_matmul_training_flops": 79322628093696, + "atomic_epochs": 4488.02783203125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:31.438005+00:00" + }, + { + "step": 20300, + "epoch": 2900, + "cumulative_step": 20300, + "metrics": {}, + "loss": 3.4481348991394043, + "training_seconds": 71.91882248967886, + "wall_seconds": 81.3487127609551, + "examples": 9329300, + "supervised_tokens": 55975800, + "executed_input_tokens": 261220400, + "estimated_matmul_training_flops": 80512008268800, + "atomic_epochs": 4555.322265625, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:32.590791+00:00" + }, + { + "step": 21000, + "epoch": 3000, + "cumulative_step": 21000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.291015625, + "answer_nll": 2.560638427734375, + "knowledge_nll": 2.5604748725891113, + "identifier_accuracy": 0.291015625, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 0.2236328125, + "answer_nll": 2.7695472240448, + "knowledge_nll": 2.76949405670166, + "identifier_accuracy": 0.2236328125, + "learned_bits_raw": 4100.571810432059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.3583984375, + "answer_nll": 2.35172963142395, + "knowledge_nll": 2.3514554500579834, + "identifier_accuracy": 0.3583984375, + "learned_bits_raw": 4718.148488529942 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 63.565555572509766, + "knowledge_nll": 29.89066505432129, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.23863636363636365, + "second_atomic_accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 64.41242218017578, + "knowledge_nll": 30.54340362548828, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.20987654320987653, + "second_atomic_accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 64.0531005859375, + "knowledge_nll": 30.21320915222168, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.24673202614379086, + "second_atomic_accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 63.25845718383789, + "knowledge_nll": 29.904817581176758, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.19301470588235295, + "second_atomic_accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 63.29830551147461, + "knowledge_nll": 29.5711612701416, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 8818.719946741532, + "learned_bits_per_parameter": 0.08563859488367709 + }, + "serial_II": { + "n": 880, + "accuracy": 0.10795454545454546, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.07295173961840629, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.09640522875816994, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.004901960784313725, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.06985294117647059, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 0.4606338441371918, + "training_seconds": 74.36193596571684, + "wall_seconds": 84.54179046303034, + "examples": 9651000, + "supervised_tokens": 57906000, + "executed_input_tokens": 270228000, + "estimated_matmul_training_flops": 83288284416000, + "atomic_epochs": 4712.40234375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 133991936, + "created_utc": "2026-10-05T23:14:35.783892+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/preflight.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/run.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/run.json new file mode 100644 index 0000000000000000000000000000000000000000..4e32325a5ad9baa3da8b9fd0e1db50756a6cb8b8 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/run.json @@ -0,0 +1,195 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic_replay-h256", + "training_mode": "atomic_replay", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long" + }, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "initial_model_sha256": "92086c98673d3bc1f9a6571266eec6d392bba58e3b70733208be49cad5e48d4f", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 2048, + "composition_examples": 1169, + "evaluation_nodes": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 0, + "parent_examples": 0, + "training_mode": "atomic_replay", + "created_utc": "2026-10-05T23:13:11.191289+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/status.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/status.json new file mode 100644 index 0000000000000000000000000000000000000000..936f1b54de758ce0bdadc57e6c1bbd2e986cf5de --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 21000 +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/trained.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..7a578c8d2f991f93523064f82a7ef24a5d3db41f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "682ceda3a598df804690edbf60e68878a651f5acbb11397e13587a78451dd035", + "epochs": 3000, + "step": 21000, + "training_pid": 44, + "created_utc": "2026-10-05T23:14:35.885080+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h256/worker.log b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..d7ce99734b7fdb310edaa09cc9223986893438d8 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h256/worker.log @@ -0,0 +1,37 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.800018310546875, "knowledge_nll": 12.712567329406738, "identifier_accuracy": 0.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 19.480695724487305, "knowledge_nll": 12.7626314163208, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 19.454242706298828, "knowledge_nll": 12.749253273010254, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 19.46780776977539, "knowledge_nll": 12.748907089233398, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 19.464326858520508, "knowledge_nll": 12.742711067199707, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 19.463520050048828, "knowledge_nll": 12.744767189025879, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 70, "epoch": 10, "metrics": {"atomic": {"n": 2048, "accuracy": 0.005859375, "answer_nll": 5.723837852478027, "knowledge_nll": 5.620140552520752, "identifier_accuracy": 0.005859375, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 21.466371536254883, "knowledge_nll": 13.222684860229492, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.0022727272727272726, "second_atomic_accuracy": 0.0011363636363636363, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 21.480058670043945, "knowledge_nll": 13.236153602600098, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.006734006734006734, "second_atomic_accuracy": 0.003367003367003367, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 21.445405960083008, "knowledge_nll": 13.226515769958496, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.011437908496732025, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 21.480541229248047, "knowledge_nll": 13.25053596496582, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.03860294117647059, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 21.474767684936523, "knowledge_nll": 13.233658790588379, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 210, "epoch": 30, "metrics": {"atomic": {"n": 2048, "accuracy": 0.00390625, "answer_nll": 5.533601760864258, "knowledge_nll": 5.527665138244629, "identifier_accuracy": 0.00390625, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 26.675439834594727, "knowledge_nll": 16.357038497924805, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.003409090909090909, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 26.669998168945312, "knowledge_nll": 16.365840911865234, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.003367003367003367, "second_atomic_accuracy": 0.008978675645342313, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 26.468109130859375, "knowledge_nll": 16.353334426879883, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0016339869281045752, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 26.443098068237305, "knowledge_nll": 16.342512130737305, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.007352941176470588, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 26.646108627319336, "knowledge_nll": 16.37232208251953, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 700, "epoch": 100, "metrics": {"atomic": {"n": 2048, "accuracy": 0.4189453125, "answer_nll": 2.0690298080444336, "knowledge_nll": 2.0670032501220703, "identifier_accuracy": 0.4189453125, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 38.700340270996094, "knowledge_nll": 23.0335750579834, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.4159090909090909, "second_atomic_accuracy": 0.4409090909090909, "both_atomic_n": 180, "both_atomic_coverage": 0.20454545454545456, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 38.8272819519043, "knowledge_nll": 23.28221893310547, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.4489337822671156, "second_atomic_accuracy": 0.4175084175084175, "both_atomic_n": 167, "both_atomic_coverage": 0.18742985409652077, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 38.75544357299805, "knowledge_nll": 23.287168502807617, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.369281045751634, "second_atomic_accuracy": 0.44607843137254904, "both_atomic_n": 92, "both_atomic_coverage": 0.1503267973856209, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 38.034210205078125, "knowledge_nll": 22.723217010498047, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.3713235294117647, "second_atomic_accuracy": 0.4227941176470588, "both_atomic_n": 86, "both_atomic_coverage": 0.15808823529411764, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 38.7315673828125, "knowledge_nll": 23.12601661682129, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 1400, "epoch": 200, "metrics": {}} +{"step": 2100, "epoch": 300, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.0005333680892363191, "knowledge_nll": 0.0005042148986831307, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 58.717655181884766, "knowledge_nll": 39.43427658081055, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 59.30015182495117, "knowledge_nll": 40.4374885559082, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 59.47480010986328, "knowledge_nll": 40.29357147216797, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 58.912757873535156, "knowledge_nll": 40.33546447753906, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 59.121177673339844, "knowledge_nll": 40.02766418457031, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 2800, "epoch": 400, "metrics": {}} +{"step": 3500, "epoch": 500, "metrics": {}} +{"step": 4200, "epoch": 600, "metrics": {}} +{"step": 4900, "epoch": 700, "metrics": {}} +{"step": 5000, "epoch": 714.3183089835251, "metrics": {}} +{"step": 5600, "epoch": 800, "metrics": {}} +{"step": 6300, "epoch": 900, "metrics": {}} +{"step": 7000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 3.924619886674918e-05, "knowledge_nll": 3.5438377381069586e-05, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 67.23571014404297, "knowledge_nll": 44.04039764404297, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 67.92912292480469, "knowledge_nll": 45.098121643066406, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 68.09056854248047, "knowledge_nll": 44.890663146972656, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 67.73210906982422, "knowledge_nll": 45.20768356323242, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 67.88339233398438, "knowledge_nll": 44.78683853149414, "identifier_accuracy": 0.0, "population_n": 1169}}} +{"step": 7700, "epoch": 1100, "metrics": {}} +{"step": 8400, "epoch": 1200, "metrics": {}} +{"step": 9100, "epoch": 1300, "metrics": {}} +{"step": 9800, "epoch": 1400, "metrics": {}} +{"step": 10000, "epoch": 1428.6366179670501, "metrics": {}} +{"step": 10500, "epoch": 1500, "metrics": {}} +{"step": 11200, "epoch": 1600, "metrics": {}} +{"step": 11900, "epoch": 1700, "metrics": {}} +{"step": 12600, "epoch": 1800, "metrics": {}} +{"step": 13300, "epoch": 1900, "metrics": {}} +{"step": 14000, "epoch": 2000, "metrics": {}} +{"step": 14700, "epoch": 2100, "metrics": {}} +{"step": 15000, "epoch": 2142.954926950575, "metrics": {}} +{"step": 15400, "epoch": 2200, "metrics": {}} +{"step": 16100, "epoch": 2300, "metrics": {}} +{"step": 16800, "epoch": 2400, "metrics": {}} +{"step": 17500, "epoch": 2500, "metrics": {}} +{"step": 18200, "epoch": 2600, "metrics": {}} +{"step": 18900, "epoch": 2700, "metrics": {}} +{"step": 19600, "epoch": 2800, "metrics": {}} +{"step": 20000, "epoch": 2857.1591544917624, "metrics": {}} +{"step": 20300, "epoch": 2900, "metrics": {}} +{"step": 21000, "epoch": 3000, "metrics": {"atomic": {"n": 2048, "accuracy": 0.291015625, "answer_nll": 2.560638427734375, "knowledge_nll": 2.5604748725891113, "identifier_accuracy": 0.291015625, "full_population": true}, "atomic_first": {"n": 1024, "accuracy": 0.2236328125, "answer_nll": 2.7695472240448, "knowledge_nll": 2.76949405670166, "identifier_accuracy": 0.2236328125, "learned_bits_raw": 4100.571810432059}, "atomic_second": {"n": 1024, "accuracy": 0.3583984375, "answer_nll": 2.35172963142395, "knowledge_nll": 2.3514554500579834, "identifier_accuracy": 0.3583984375, "learned_bits_raw": 4718.148488529942}, "II": {"n": 880, "accuracy": 0.0, "answer_nll": 63.565555572509766, "knowledge_nll": 29.89066505432129, "identifier_accuracy": 0.0, "population_n": 880, "first_atomic_accuracy": 0.23863636363636365, "second_atomic_accuracy": 0.3886363636363636, "both_atomic_n": 91, "both_atomic_coverage": 0.10340909090909091, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 891, "accuracy": 0.0, "answer_nll": 64.41242218017578, "knowledge_nll": 30.54340362548828, "identifier_accuracy": 0.0, "population_n": 891, "first_atomic_accuracy": 0.20987654320987653, "second_atomic_accuracy": 0.37373737373737376, "both_atomic_n": 60, "both_atomic_coverage": 0.06734006734006734, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 612, "accuracy": 0.0, "answer_nll": 64.0531005859375, "knowledge_nll": 30.21320915222168, "identifier_accuracy": 0.0, "population_n": 612, "first_atomic_accuracy": 0.24673202614379086, "second_atomic_accuracy": 0.32516339869281047, "both_atomic_n": 57, "both_atomic_coverage": 0.09313725490196079, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 63.25845718383789, "knowledge_nll": 29.904817581176758, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 0.19301470588235295, "second_atomic_accuracy": 0.34191176470588236, "both_atomic_n": 33, "both_atomic_coverage": 0.06066176470588235, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 0.0, "answer_nll": 63.29830551147461, "knowledge_nll": 29.5711612701416, "identifier_accuracy": 0.0, "population_n": 1169}, "information": {"independent_facts": 2048, "world_bits": 16384.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 0.15910503418272218, "composition_independent_bits": 0, "learned_bits_raw": 8818.719946741532, "learned_bits_per_parameter": 0.08563859488367709}, "serial_II": {"n": 880, "accuracy": 0.10795454545454546, "both_atomic_n": 91, "both_atomic_coverage": 0.10340909090909091, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9988636363636364, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 880, "accuracy": 0.004545454545454545, "both_atomic_n": 91, "both_atomic_coverage": 0.10340909090909091, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 0.9988636363636364, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 880, "accuracy": 0.3886363636363636, "both_atomic_n": 91, "both_atomic_coverage": 0.10340909090909091, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9988636363636364, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 891, "accuracy": 0.07295173961840629, "both_atomic_n": 60, "both_atomic_coverage": 0.06734006734006734, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9955106621773289, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 891, "accuracy": 0.004489337822671156, "both_atomic_n": 60, "both_atomic_coverage": 0.06734006734006734, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 0.9955106621773289, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 891, "accuracy": 0.37373737373737376, "both_atomic_n": 60, "both_atomic_coverage": 0.06734006734006734, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9955106621773289, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 612, "accuracy": 0.09640522875816994, "both_atomic_n": 57, "both_atomic_coverage": 0.09313725490196079, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9983660130718954, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 612, "accuracy": 0.004901960784313725, "both_atomic_n": 57, "both_atomic_coverage": 0.09313725490196079, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 0.9983660130718954, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 612, "accuracy": 0.32516339869281047, "both_atomic_n": 57, "both_atomic_coverage": 0.09313725490196079, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9983660130718954, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 544, "accuracy": 0.06985294117647059, "both_atomic_n": 33, "both_atomic_coverage": 0.06066176470588235, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9944852941176471, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 544, "accuracy": 0.007352941176470588, "both_atomic_n": 33, "both_atomic_coverage": 0.06066176470588235, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 0.9944852941176471, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 544, "accuracy": 0.34191176470588236, "both_atomic_n": 33, "both_atomic_coverage": 0.06066176470588235, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.9944852941176471, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/audit.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..a949aa97b5ecb53bef3756b375ad77f5e521960c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "8694a4dec375266f0b68eee9976ded8af1f46a59146a604ffc4e58cd9f731eef", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7679227941176471, + "answer_nll": 0.7522584199905396, + "knowledge_nll": 0.7521635293960571, + "identifier_accuracy": 0.7679227941176471, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.76165771484375, + "answer_nll": 0.7713814973831177, + "knowledge_nll": 0.7713284492492676, + "identifier_accuracy": 0.76165771484375, + "learned_bits_raw": 112840.02031815077 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8681640625, + "answer_nll": 0.4462886154651642, + "knowledge_nll": 0.4455249607563019, + "identifier_accuracy": 0.8681640625, + "learned_bits_raw": 7533.817188889225 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 134.19708251953125, + "knowledge_nll": 68.98158264160156, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.75537109375, + "second_atomic_accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 132.91983032226562, + "knowledge_nll": 67.88194274902344, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.78173828125, + "second_atomic_accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.59744262695312, + "knowledge_nll": 68.44195556640625, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.75927734375, + "second_atomic_accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.86203002929688, + "knowledge_nll": 67.7496566772461, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.77197265625, + "second_atomic_accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.4477081298828, + "knowledge_nll": 68.21073913574219, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 120373.83772717779, + "learned_bits_per_parameter": 1.1689504129814499 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.65283203125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0107421875, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.005251312828207052, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.69140625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.004953998584571833, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6416015625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00927734375, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.006854531607006854, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.6953125, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.005637773079633545, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 107631000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:32:28.655405+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/complete.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..a949aa97b5ecb53bef3756b375ad77f5e521960c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "8694a4dec375266f0b68eee9976ded8af1f46a59146a604ffc4e58cd9f731eef", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7679227941176471, + "answer_nll": 0.7522584199905396, + "knowledge_nll": 0.7521635293960571, + "identifier_accuracy": 0.7679227941176471, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.76165771484375, + "answer_nll": 0.7713814973831177, + "knowledge_nll": 0.7713284492492676, + "identifier_accuracy": 0.76165771484375, + "learned_bits_raw": 112840.02031815077 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8681640625, + "answer_nll": 0.4462886154651642, + "knowledge_nll": 0.4455249607563019, + "identifier_accuracy": 0.8681640625, + "learned_bits_raw": 7533.817188889225 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 134.19708251953125, + "knowledge_nll": 68.98158264160156, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.75537109375, + "second_atomic_accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 132.91983032226562, + "knowledge_nll": 67.88194274902344, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.78173828125, + "second_atomic_accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.59744262695312, + "knowledge_nll": 68.44195556640625, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.75927734375, + "second_atomic_accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.86203002929688, + "knowledge_nll": 67.7496566772461, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.77197265625, + "second_atomic_accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.4477081298828, + "knowledge_nll": 68.21073913574219, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 120373.83772717779, + "learned_bits_per_parameter": 1.1689504129814499 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.65283203125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0107421875, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.005251312828207052, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.69140625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.004953998584571833, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6416015625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00927734375, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.006854531607006854, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.6953125, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.005637773079633545, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 107631000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:32:28.655405+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-command-1.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..83a6b2ac8350a9deb6ae1b6e110fef714c7fc58d --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-ecae10dca03b7c88dbc0", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-ecae10dca03b7c88dbc0", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h4096,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h4096", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h4096" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-inspect.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..771b448bc418797cc5298004c741111b19ad1825 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3", + "Created": "2026-10-05T23:18:47.251228035Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h4096" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:18:47.280678103Z", + "FinishedAt": "2026-10-05T23:32:29.770242417Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3/dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3-json.log", + "Name": "/lm-capctrl-ecae10dca03b7c88dbc0", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h4096", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h4096" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/04e0acd423abf2534401b227d1b4de3c0699ced7f713965513a3702ae6c0e636-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/04e0acd423abf2534401b227d1b4de3c0699ced7f713965513a3702ae6c0e636/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/04e0acd423abf2534401b227d1b4de3c0699ced7f713965513a3702ae6c0e636/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/04e0acd423abf2534401b227d1b4de3c0699ced7f713965513a3702ae6c0e636/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h4096", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/atomic_replay-h4096", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "dbb21db71132", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PYTHONDONTWRITEBYTECODE=1", + "MKL_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PHYSICAL_GPU=0", + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "atomic_replay-h4096" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-runtime.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..532bcb1ea8a99ea6fa40493f2d4d3776ca269daa --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 339364, + "container_id": "dbb21db71132bd210397c9385c4ec797c195e1d02678cbd50b79ff3f3c4f4cd3", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/learning.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..5598aa6f615ecbe42c1356333550b801b2fceceb --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/learning.json @@ -0,0 +1,1993 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.918397903442383, + "knowledge_nll": 12.682050704956055, + "identifier_accuracy": 0.0, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.449495315551758, + "knowledge_nll": 12.73082160949707, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.451412200927734, + "knowledge_nll": 12.738428115844727, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.451452255249023, + "knowledge_nll": 12.735528945922852, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.456905364990234, + "knowledge_nll": 12.742338180541992, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.0, + "second_atomic_accuracy": 0.0, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 19.455768585205078, + "knowledge_nll": 12.733171463012695, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.47710608690977097, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 93564928, + "created_utc": "2026-10-05T23:18:53.108514+00:00" + }, + { + "step": 710, + "epoch": 10, + "cumulative_step": 710, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.00390625, + "answer_nll": 5.557476043701172, + "knowledge_nll": 5.556796550750732, + "identifier_accuracy": 0.00390625, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 35.83441162109375, + "knowledge_nll": 18.677949905395508, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.0048828125, + "second_atomic_accuracy": 0.00244140625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 35.88724899291992, + "knowledge_nll": 18.711505889892578, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.0029296875, + "second_atomic_accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 35.8245849609375, + "knowledge_nll": 18.673749923706055, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.00439453125, + "second_atomic_accuracy": 0.00244140625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 35.86714172363281, + "knowledge_nll": 18.68665885925293, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.00439453125, + "second_atomic_accuracy": 0.005859375, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 35.828369140625, + "knowledge_nll": 18.67756462097168, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.9235492944717407, + "training_seconds": 2.616352241486311, + "wall_seconds": 3.6550970189273357, + "examples": 358770, + "supervised_tokens": 2152620, + "executed_input_tokens": 10045560, + "estimated_matmul_training_flops": 3096190840320, + "atomic_epochs": 20.609489889705884, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:18:56.286529+00:00" + }, + { + "step": 2130, + "epoch": 30, + "cumulative_step": 2130, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.00390625, + "answer_nll": 5.552380561828613, + "knowledge_nll": 5.552249431610107, + "identifier_accuracy": 0.00390625, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.311920166015625, + "knowledge_nll": 20.87296485900879, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.005859375, + "second_atomic_accuracy": 0.00634765625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.34716033935547, + "knowledge_nll": 20.86599349975586, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.00390625, + "second_atomic_accuracy": 0.0068359375, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.38417053222656, + "knowledge_nll": 20.880338668823242, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.00537109375, + "second_atomic_accuracy": 0.0068359375, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.29503631591797, + "knowledge_nll": 20.853330612182617, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.001953125, + "second_atomic_accuracy": 0.0068359375, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 40.43214416503906, + "knowledge_nll": 20.875328063964844, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.9238333702087402, + "training_seconds": 7.634138271212578, + "wall_seconds": 9.527822867035866, + "examples": 1076310, + "supervised_tokens": 6457860, + "executed_input_tokens": 30136680, + "estimated_matmul_training_flops": 9288572520960, + "atomic_epochs": 61.828469669117645, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:02.159258+00:00" + }, + { + "step": 5000, + "epoch": 70.42812944226105, + "cumulative_step": 5000, + "metrics": {}, + "loss": 0.919612467288971, + "training_seconds": 17.714075580239296, + "wall_seconds": 20.645647779107094, + "examples": 2526750, + "supervised_tokens": 15160500, + "executed_input_tokens": 70749000, + "estimated_matmul_training_flops": 21805892928000, + "atomic_epochs": 145.14878216911765, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:13.277176+00:00" + }, + { + "step": 7100, + "epoch": 100, + "cumulative_step": 7100, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.0244140625, + "answer_nll": 5.174500465393066, + "knowledge_nll": 5.1744160652160645, + "identifier_accuracy": 0.0244140625, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 44.857818603515625, + "knowledge_nll": 24.48758888244629, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.02197265625, + "second_atomic_accuracy": 0.04150390625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 44.74576187133789, + "knowledge_nll": 24.207469940185547, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.02392578125, + "second_atomic_accuracy": 0.0419921875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 45.278900146484375, + "knowledge_nll": 24.48851203918457, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.025390625, + "second_atomic_accuracy": 0.044921875, + "both_atomic_n": 4, + "both_atomic_coverage": 0.001953125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 45.372257232666016, + "knowledge_nll": 24.30008888244629, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.02587890625, + "second_atomic_accuracy": 0.0478515625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 44.944759368896484, + "knowledge_nll": 24.40655517578125, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.8840407133102417, + "training_seconds": 25.121994238346815, + "wall_seconds": 28.848853182047606, + "examples": 3587700, + "supervised_tokens": 21526200, + "executed_input_tokens": 100455600, + "estimated_matmul_training_flops": 30961908403200, + "atomic_epochs": 206.0948988970588, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:21.480295+00:00" + }, + { + "step": 10000, + "epoch": 140.8562588845221, + "cumulative_step": 10000, + "metrics": {}, + "loss": 0.5798653960227966, + "training_seconds": 35.286708772182465, + "wall_seconds": 39.68714673444629, + "examples": 5053500, + "supervised_tokens": 30321000, + "executed_input_tokens": 141498000, + "estimated_matmul_training_flops": 43611785856000, + "atomic_epochs": 290.2975643382353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:32.318630+00:00" + }, + { + "step": 14200, + "epoch": 200, + "cumulative_step": 14200, + "metrics": {}, + "loss": 0.43539851903915405, + "training_seconds": 50.22418124601245, + "wall_seconds": 55.54017185047269, + "examples": 7175400, + "supervised_tokens": 43052400, + "executed_input_tokens": 200911200, + "estimated_matmul_training_flops": 61923816806400, + "atomic_epochs": 412.1897977941176, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:48.171694+00:00" + }, + { + "step": 15000, + "epoch": 211.27114864676534, + "cumulative_step": 15000, + "metrics": {}, + "loss": 0.39184847474098206, + "training_seconds": 53.01861226558685, + "wall_seconds": 58.594679184257984, + "examples": 7579775, + "supervised_tokens": 45478650, + "executed_input_tokens": 212233700, + "estimated_matmul_training_flops": 65413579526400, + "atomic_epochs": 435.41906020220586, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:19:51.226113+00:00" + }, + { + "step": 20000, + "epoch": 281.6992780890264, + "cumulative_step": 20000, + "metrics": {}, + "loss": 0.34458911418914795, + "training_seconds": 70.57535494491458, + "wall_seconds": 77.2258457429707, + "examples": 10106525, + "supervised_tokens": 60639150, + "executed_input_tokens": 282982700, + "estimated_matmul_training_flops": 87219472454400, + "atomic_epochs": 580.5678423713235, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:09.857384+00:00" + }, + { + "step": 21300, + "epoch": 300, + "cumulative_step": 21300, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.4716796875, + "answer_nll": 1.8662351369857788, + "knowledge_nll": 1.8662127256393433, + "identifier_accuracy": 0.4716796875, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 101.216796875, + "knowledge_nll": 57.501739501953125, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.43603515625, + "second_atomic_accuracy": 0.818359375, + "both_atomic_n": 731, + "both_atomic_coverage": 0.35693359375, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 101.19676208496094, + "knowledge_nll": 56.78607177734375, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.45849609375, + "second_atomic_accuracy": 0.71337890625, + "both_atomic_n": 683, + "both_atomic_coverage": 0.33349609375, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 101.42655181884766, + "knowledge_nll": 56.917686462402344, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.42919921875, + "second_atomic_accuracy": 0.787109375, + "both_atomic_n": 688, + "both_atomic_coverage": 0.3359375, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 101.86469268798828, + "knowledge_nll": 56.68741989135742, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.43212890625, + "second_atomic_accuracy": 0.70556640625, + "both_atomic_n": 629, + "both_atomic_coverage": 0.30712890625, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 100.59654998779297, + "knowledge_nll": 56.65807342529297, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.3448130190372467, + "training_seconds": 75.1671715900302, + "wall_seconds": 82.4837856888771, + "examples": 10763100, + "supervised_tokens": 64578600, + "executed_input_tokens": 301366800, + "estimated_matmul_training_flops": 92885725209600, + "atomic_epochs": 618.2846966911765, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:15.115232+00:00" + }, + { + "step": 25000, + "epoch": 352.1141678512696, + "cumulative_step": 25000, + "metrics": {}, + "loss": 0.3075505197048187, + "training_seconds": 88.1795090585947, + "wall_seconds": 96.34551925212145, + "examples": 12632800, + "supervised_tokens": 75796800, + "executed_input_tokens": 353718400, + "estimated_matmul_training_flops": 109021266124800, + "atomic_epochs": 725.6893382352941, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:28.976997+00:00" + }, + { + "step": 28400, + "epoch": 400, + "cumulative_step": 28400, + "metrics": {}, + "loss": 0.2512570917606354, + "training_seconds": 100.67069347575307, + "wall_seconds": 109.5843614526093, + "examples": 14350800, + "supervised_tokens": 86104800, + "executed_input_tokens": 401822400, + "estimated_matmul_training_flops": 123847633612800, + "atomic_epochs": 824.3795955882352, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:42.215975+00:00" + }, + { + "step": 30000, + "epoch": 422.5422972935307, + "cumulative_step": 30000, + "metrics": {}, + "loss": 0.2798539698123932, + "training_seconds": 106.33180843666196, + "wall_seconds": 115.66265711560845, + "examples": 15159550, + "supervised_tokens": 90957300, + "executed_input_tokens": 424467400, + "estimated_matmul_training_flops": 130827159052800, + "atomic_epochs": 870.8381204044117, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:20:48.294092+00:00" + }, + { + "step": 35000, + "epoch": 492.9704267357917, + "cumulative_step": 35000, + "metrics": {}, + "loss": 0.28497210144996643, + "training_seconds": 123.8450520709157, + "wall_seconds": 134.24671396240592, + "examples": 17686300, + "supervised_tokens": 106117800, + "executed_input_tokens": 495216400, + "estimated_matmul_training_flops": 152633051980800, + "atomic_epochs": 1015.9869025735294, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:06.878245+00:00" + }, + { + "step": 35500, + "epoch": 500, + "cumulative_step": 35500, + "metrics": {}, + "loss": 0.1824016273021698, + "training_seconds": 125.66347295790911, + "wall_seconds": 136.22193055599928, + "examples": 17938500, + "supervised_tokens": 107631000, + "executed_input_tokens": 502278000, + "estimated_matmul_training_flops": 154809542016000, + "atomic_epochs": 1030.4744944852941, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:08.853342+00:00" + }, + { + "step": 40000, + "epoch": 563.385316498035, + "cumulative_step": 40000, + "metrics": {}, + "loss": 0.25373345613479614, + "training_seconds": 141.3642034381628, + "wall_seconds": 152.9245734103024, + "examples": 20212575, + "supervised_tokens": 121275450, + "executed_input_tokens": 565952100, + "estimated_matmul_training_flops": 174434845651200, + "atomic_epochs": 1161.1083984375, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:25.556032+00:00" + }, + { + "step": 42600, + "epoch": 600, + "cumulative_step": 42600, + "metrics": {}, + "loss": 0.2408369928598404, + "training_seconds": 150.50448857992887, + "wall_seconds": 162.64381628856063, + "examples": 21526200, + "supervised_tokens": 129157200, + "executed_input_tokens": 602733600, + "estimated_matmul_training_flops": 185771450419200, + "atomic_epochs": 1236.569393382353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:35.275273+00:00" + }, + { + "step": 45000, + "epoch": 633.813445940296, + "cumulative_step": 45000, + "metrics": {}, + "loss": 0.257953017950058, + "training_seconds": 158.89209873601794, + "wall_seconds": 171.6047867462039, + "examples": 22739325, + "supervised_tokens": 136435950, + "executed_input_tokens": 636701100, + "estimated_matmul_training_flops": 196240738579200, + "atomic_epochs": 1306.2571806066176, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:21:44.236221+00:00" + }, + { + "step": 49700, + "epoch": 700, + "cumulative_step": 49700, + "metrics": {}, + "loss": 0.2553056478500366, + "training_seconds": 175.53382671251893, + "wall_seconds": 189.2687641121447, + "examples": 25113900, + "supervised_tokens": 150683400, + "executed_input_tokens": 703189200, + "estimated_matmul_training_flops": 216733358822400, + "atomic_epochs": 1442.6642922794117, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:01.900238+00:00" + }, + { + "step": 50000, + "epoch": 704.2283357025392, + "cumulative_step": 50000, + "metrics": {}, + "loss": 0.2334921509027481, + "training_seconds": 176.59745144098997, + "wall_seconds": 190.4853602424264, + "examples": 25265600, + "supervised_tokens": 151593600, + "executed_input_tokens": 707436800, + "estimated_matmul_training_flops": 218042532249600, + "atomic_epochs": 1451.3786764705883, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:03.116861+00:00" + }, + { + "step": 55000, + "epoch": 774.6564651448003, + "cumulative_step": 55000, + "metrics": {}, + "loss": 0.22122621536254883, + "training_seconds": 194.2898928411305, + "wall_seconds": 209.24613308906555, + "examples": 27792350, + "supervised_tokens": 166754100, + "executed_input_tokens": 778185800, + "estimated_matmul_training_flops": 239848425177600, + "atomic_epochs": 1596.5274586397059, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:21.877582+00:00" + }, + { + "step": 56800, + "epoch": 800, + "cumulative_step": 56800, + "metrics": {}, + "loss": 0.1759495586156845, + "training_seconds": 200.62368273735046, + "wall_seconds": 215.990623857826, + "examples": 28701600, + "supervised_tokens": 172209600, + "executed_input_tokens": 803644800, + "estimated_matmul_training_flops": 247695267225600, + "atomic_epochs": 1648.7591911764705, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:28.622049+00:00" + }, + { + "step": 60000, + "epoch": 845.0713549070435, + "cumulative_step": 60000, + "metrics": {}, + "loss": 0.23007769882678986, + "training_seconds": 211.8030624911189, + "wall_seconds": 227.9068552814424, + "examples": 30318625, + "supervised_tokens": 181911750, + "executed_input_tokens": 848921500, + "estimated_matmul_training_flops": 261650218848000, + "atomic_epochs": 1741.6489545036766, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:40.538292+00:00" + }, + { + "step": 63900, + "epoch": 900, + "cumulative_step": 63900, + "metrics": {}, + "loss": 0.2119460254907608, + "training_seconds": 225.64217379316688, + "wall_seconds": 242.59083154425025, + "examples": 32289300, + "supervised_tokens": 193735800, + "executed_input_tokens": 904100400, + "estimated_matmul_training_flops": 278657175628800, + "atomic_epochs": 1854.8540900735295, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:55.222258+00:00" + }, + { + "step": 65000, + "epoch": 915.4994843493046, + "cumulative_step": 65000, + "metrics": {}, + "loss": 0.19600480794906616, + "training_seconds": 229.49262355268002, + "wall_seconds": 246.7480411939323, + "examples": 32845375, + "supervised_tokens": 197072250, + "executed_input_tokens": 919670500, + "estimated_matmul_training_flops": 283456111776000, + "atomic_epochs": 1886.7977366727941, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:22:59.379456+00:00" + }, + { + "step": 70000, + "epoch": 985.9276137915656, + "cumulative_step": 70000, + "metrics": {}, + "loss": 0.21399341523647308, + "training_seconds": 247.37817598506808, + "wall_seconds": 265.7448144480586, + "examples": 35372125, + "supervised_tokens": 212232750, + "executed_input_tokens": 990419500, + "estimated_matmul_training_flops": 305262004704000, + "atomic_epochs": 2031.9465188419117, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:23:18.376243+00:00" + }, + { + "step": 71000, + "epoch": 1000, + "cumulative_step": 71000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.6826171875, + "answer_nll": 1.0290497541427612, + "knowledge_nll": 1.0289418697357178, + "identifier_accuracy": 0.6826171875, + "full_population": false + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 118.90726470947266, + "knowledge_nll": 62.134525299072266, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.6630859375, + "second_atomic_accuracy": 0.88671875, + "both_atomic_n": 1199, + "both_atomic_coverage": 0.58544921875, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 119.82754516601562, + "knowledge_nll": 61.85590362548828, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.68603515625, + "second_atomic_accuracy": 0.86181640625, + "both_atomic_n": 1207, + "both_atomic_coverage": 0.58935546875, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 119.66930389404297, + "knowledge_nll": 61.70161056518555, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.669921875, + "second_atomic_accuracy": 0.9052734375, + "both_atomic_n": 1237, + "both_atomic_coverage": 0.60400390625, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 120.35173034667969, + "knowledge_nll": 61.72099304199219, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.6552734375, + "second_atomic_accuracy": 0.8359375, + "both_atomic_n": 1122, + "both_atomic_coverage": 0.5478515625, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 118.78276824951172, + "knowledge_nll": 61.89915466308594, + "identifier_accuracy": 0.0, + "population_n": 18469 + } + }, + "loss": 0.18975363671779633, + "training_seconds": 250.87985474988818, + "wall_seconds": 269.85651344433427, + "examples": 35877000, + "supervised_tokens": 215262000, + "executed_input_tokens": 1004556000, + "estimated_matmul_training_flops": 309619084032000, + "atomic_epochs": 2060.9489889705883, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:23:22.487948+00:00" + }, + { + "step": 75000, + "epoch": 1056.342503553809, + "cumulative_step": 75000, + "metrics": {}, + "loss": 0.172085240483284, + "training_seconds": 264.9473054036498, + "wall_seconds": 284.83307602629066, + "examples": 37898400, + "supervised_tokens": 227390400, + "executed_input_tokens": 1061155200, + "estimated_matmul_training_flops": 327063798374400, + "atomic_epochs": 2177.0680147058824, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:23:37.464482+00:00" + }, + { + "step": 78100, + "epoch": 1100, + "cumulative_step": 78100, + "metrics": {}, + "loss": 0.2081821858882904, + "training_seconds": 275.7471803240478, + "wall_seconds": 296.3061558715999, + "examples": 39464700, + "supervised_tokens": 236788200, + "executed_input_tokens": 1105011600, + "estimated_matmul_training_flops": 340580992435200, + "atomic_epochs": 2267.043887867647, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:23:48.937596+00:00" + }, + { + "step": 80000, + "epoch": 1126.77063299607, + "cumulative_step": 80000, + "metrics": {}, + "loss": 0.1912885159254074, + "training_seconds": 282.43010107427835, + "wall_seconds": 303.46991408243775, + "examples": 40425150, + "supervised_tokens": 242550900, + "executed_input_tokens": 1131904200, + "estimated_matmul_training_flops": 348869691302400, + "atomic_epochs": 2322.216796875, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:23:56.101341+00:00" + }, + { + "step": 85000, + "epoch": 1197.185522758313, + "cumulative_step": 85000, + "metrics": {}, + "loss": 0.16688990592956543, + "training_seconds": 300.2033664472401, + "wall_seconds": 322.32991798967123, + "examples": 42951425, + "supervised_tokens": 257708550, + "executed_input_tokens": 1202639900, + "estimated_matmul_training_flops": 370671484972800, + "atomic_epochs": 2467.3382927389707, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:24:14.961384+00:00" + }, + { + "step": 85200, + "epoch": 1200, + "cumulative_step": 85200, + "metrics": {}, + "loss": 0.19502218067646027, + "training_seconds": 300.9074918553233, + "wall_seconds": 323.1217986792326, + "examples": 43052400, + "supervised_tokens": 258314400, + "executed_input_tokens": 1205467200, + "estimated_matmul_training_flops": 371542900838400, + "atomic_epochs": 2473.138786764706, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:24:15.753212+00:00" + }, + { + "step": 90000, + "epoch": 1267.6136522005743, + "cumulative_step": 90000, + "metrics": {}, + "loss": 0.17098866403102875, + "training_seconds": 317.8720100335777, + "wall_seconds": 341.1868466101587, + "examples": 45478175, + "supervised_tokens": 272869050, + "executed_input_tokens": 1273388900, + "estimated_matmul_training_flops": 392477377900800, + "atomic_epochs": 2612.4870749080883, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:24:33.818295+00:00" + }, + { + "step": 92300, + "epoch": 1300, + "cumulative_step": 92300, + "metrics": {}, + "loss": 0.1884806752204895, + "training_seconds": 325.94181153550744, + "wall_seconds": 349.7718792781234, + "examples": 46640100, + "supervised_tokens": 279840600, + "executed_input_tokens": 1305922800, + "estimated_matmul_training_flops": 402504809241600, + "atomic_epochs": 2679.233685661765, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:24:42.403273+00:00" + }, + { + "step": 95000, + "epoch": 1338.0285419628174, + "cumulative_step": 95000, + "metrics": {}, + "loss": 0.14707942306995392, + "training_seconds": 335.44121070206165, + "wall_seconds": 360.08974931389093, + "examples": 48004450, + "supervised_tokens": 288026700, + "executed_input_tokens": 1344124600, + "estimated_matmul_training_flops": 414279171571200, + "atomic_epochs": 2757.608570772059, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:24:52.721172+00:00" + }, + { + "step": 99400, + "epoch": 1400, + "cumulative_step": 99400, + "metrics": {}, + "loss": 0.17278455197811127, + "training_seconds": 350.9835195466876, + "wall_seconds": 376.57942666858435, + "examples": 50227800, + "supervised_tokens": 301366800, + "executed_input_tokens": 1406378400, + "estimated_matmul_training_flops": 433466717644800, + "atomic_epochs": 2885.3285845588234, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:25:09.210866+00:00" + }, + { + "step": 100000, + "epoch": 1408.4566714050784, + "cumulative_step": 100000, + "metrics": {}, + "loss": 0.16921697556972504, + "training_seconds": 353.08044143021107, + "wall_seconds": 379.33243626356125, + "examples": 50531200, + "supervised_tokens": 303187200, + "executed_input_tokens": 1414873600, + "estimated_matmul_training_flops": 436085064499200, + "atomic_epochs": 2902.7573529411766, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:25:11.963850+00:00" + }, + { + "step": 105000, + "epoch": 1478.8848008473394, + "cumulative_step": 105000, + "metrics": {}, + "loss": 0.17685365676879883, + "training_seconds": 370.64108980447054, + "wall_seconds": 398.7938267365098, + "examples": 53057950, + "supervised_tokens": 318347700, + "executed_input_tokens": 1485622600, + "estimated_matmul_training_flops": 457890957427200, + "atomic_epochs": 3047.906135110294, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:25:31.425251+00:00" + }, + { + "step": 106500, + "epoch": 1500, + "cumulative_step": 106500, + "metrics": {}, + "loss": 0.10832008719444275, + "training_seconds": 375.9193470440805, + "wall_seconds": 404.4245095513761, + "examples": 53815500, + "supervised_tokens": 322893000, + "executed_input_tokens": 1506834000, + "estimated_matmul_training_flops": 464428626048000, + "atomic_epochs": 3091.4234834558824, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:25:37.055984+00:00" + }, + { + "step": 110000, + "epoch": 1549.2996906095827, + "cumulative_step": 110000, + "metrics": {}, + "loss": 0.14184091985225677, + "training_seconds": 388.20906936749816, + "wall_seconds": 417.51964876800776, + "examples": 55584225, + "supervised_tokens": 333505350, + "executed_input_tokens": 1556358300, + "estimated_matmul_training_flops": 479692751097600, + "atomic_epochs": 3193.027630974265, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:25:50.151044+00:00" + }, + { + "step": 113600, + "epoch": 1600, + "cumulative_step": 113600, + "metrics": {}, + "loss": 0.140433669090271, + "training_seconds": 400.78664879500866, + "wall_seconds": 430.87444953620434, + "examples": 57403200, + "supervised_tokens": 344419200, + "executed_input_tokens": 1607289600, + "estimated_matmul_training_flops": 495390534451200, + "atomic_epochs": 3297.518382352941, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:26:03.505917+00:00" + }, + { + "step": 115000, + "epoch": 1619.7278200518438, + "cumulative_step": 115000, + "metrics": {}, + "loss": 0.17099298536777496, + "training_seconds": 405.7928557433188, + "wall_seconds": 436.26037222892046, + "examples": 58110975, + "supervised_tokens": 348665850, + "executed_input_tokens": 1627107300, + "estimated_matmul_training_flops": 501498644025600, + "atomic_epochs": 3338.1764131433824, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:26:08.891832+00:00" + }, + { + "step": 120000, + "epoch": 1690.142709814087, + "cumulative_step": 120000, + "metrics": {}, + "loss": 0.16432853043079376, + "training_seconds": 423.26676777377725, + "wall_seconds": 455.0275316648185, + "examples": 60637250, + "supervised_tokens": 363823500, + "executed_input_tokens": 1697843000, + "estimated_matmul_training_flops": 523300437696000, + "atomic_epochs": 3483.297909007353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:26:27.658961+00:00" + }, + { + "step": 120700, + "epoch": 1700, + "cumulative_step": 120700, + "metrics": {}, + "loss": 0.19016918540000916, + "training_seconds": 425.7144112177193, + "wall_seconds": 457.658100720495, + "examples": 60990900, + "supervised_tokens": 365945400, + "executed_input_tokens": 1707745200, + "estimated_matmul_training_flops": 526352442854400, + "atomic_epochs": 3503.61328125, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:26:30.289509+00:00" + }, + { + "step": 125000, + "epoch": 1760.570839256348, + "cumulative_step": 125000, + "metrics": {}, + "loss": 0.1467762589454651, + "training_seconds": 440.84137907624245, + "wall_seconds": 473.7545027770102, + "examples": 63164000, + "supervised_tokens": 378984000, + "executed_input_tokens": 1768592000, + "estimated_matmul_training_flops": 545106330624000, + "atomic_epochs": 3628.4466911764707, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:26:46.385902+00:00" + }, + { + "step": 127800, + "epoch": 1800, + "cumulative_step": 127800, + "metrics": {}, + "loss": 0.2265365570783615, + "training_seconds": 450.6234562918544, + "wall_seconds": 484.15504878759384, + "examples": 64578600, + "supervised_tokens": 387471600, + "executed_input_tokens": 1808200800, + "estimated_matmul_training_flops": 557314351257600, + "atomic_epochs": 3709.708180147059, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:26:56.786489+00:00" + }, + { + "step": 130000, + "epoch": 1830.9989686986091, + "cumulative_step": 130000, + "metrics": {}, + "loss": 0.15143851935863495, + "training_seconds": 458.31585482135415, + "wall_seconds": 492.37385615706444, + "examples": 65690750, + "supervised_tokens": 394144500, + "executed_input_tokens": 1839341000, + "estimated_matmul_training_flops": 566912223552000, + "atomic_epochs": 3773.5954733455883, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:27:05.005257+00:00" + }, + { + "step": 134900, + "epoch": 1900, + "cumulative_step": 134900, + "metrics": {}, + "loss": 0.13971558213233948, + "training_seconds": 475.80285549908876, + "wall_seconds": 510.9176733456552, + "examples": 68166300, + "supervised_tokens": 408997800, + "executed_input_tokens": 1908656400, + "estimated_matmul_training_flops": 588276259660800, + "atomic_epochs": 3915.8030790441176, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:27:23.549097+00:00" + }, + { + "step": 135000, + "epoch": 1901.4138584608525, + "cumulative_step": 135000, + "metrics": {}, + "loss": 0.14841227233409882, + "training_seconds": 476.1538875102997, + "wall_seconds": 511.36865002289414, + "examples": 68217025, + "supervised_tokens": 409302150, + "executed_input_tokens": 1910076700, + "estimated_matmul_training_flops": 588714017222400, + "atomic_epochs": 3918.716969209559, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:27:24.000023+00:00" + }, + { + "step": 140000, + "epoch": 1971.8419879031135, + "cumulative_step": 140000, + "metrics": {}, + "loss": 0.15093249082565308, + "training_seconds": 493.82746256142855, + "wall_seconds": 530.1168030239642, + "examples": 70743775, + "supervised_tokens": 424462650, + "executed_input_tokens": 1980825700, + "estimated_matmul_training_flops": 610519910150400, + "atomic_epochs": 4063.8657513786766, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:27:42.748248+00:00" + }, + { + "step": 142000, + "epoch": 2000, + "cumulative_step": 142000, + "metrics": {}, + "loss": 0.15878579020500183, + "training_seconds": 500.8274655379355, + "wall_seconds": 537.5723291113973, + "examples": 71754000, + "supervised_tokens": 430524000, + "executed_input_tokens": 2009112000, + "estimated_matmul_training_flops": 619238168064000, + "atomic_epochs": 4121.897977941177, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:27:50.203762+00:00" + }, + { + "step": 145000, + "epoch": 2042.2568776653566, + "cumulative_step": 145000, + "metrics": {}, + "loss": 0.16407376527786255, + "training_seconds": 511.3298069052398, + "wall_seconds": 548.7766263447702, + "examples": 73270050, + "supervised_tokens": 439620300, + "executed_input_tokens": 2051561400, + "estimated_matmul_training_flops": 632321703820800, + "atomic_epochs": 4208.987247242647, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:28:01.408073+00:00" + }, + { + "step": 149100, + "epoch": 2100, + "cumulative_step": 149100, + "metrics": {}, + "loss": 0.1369096338748932, + "training_seconds": 525.9109174087644, + "wall_seconds": 564.2657094784081, + "examples": 75341700, + "supervised_tokens": 452050200, + "executed_input_tokens": 2109567600, + "estimated_matmul_training_flops": 650200076467200, + "atomic_epochs": 4327.992876838235, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:28:16.897143+00:00" + }, + { + "step": 150000, + "epoch": 2112.685007107618, + "cumulative_step": 150000, + "metrics": {}, + "loss": 0.1633506566286087, + "training_seconds": 529.1544636264443, + "wall_seconds": 567.7781363688409, + "examples": 75796800, + "supervised_tokens": 454780800, + "executed_input_tokens": 2122310400, + "estimated_matmul_training_flops": 654127596748800, + "atomic_epochs": 4354.136029411765, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:28:20.409537+00:00" + }, + { + "step": 155000, + "epoch": 2183.099896869861, + "cumulative_step": 155000, + "metrics": {}, + "loss": 0.11803704500198364, + "training_seconds": 546.6934239082038, + "wall_seconds": 586.3880637846887, + "examples": 78323075, + "supervised_tokens": 469938450, + "executed_input_tokens": 2193046100, + "estimated_matmul_training_flops": 675929390419200, + "atomic_epochs": 4499.257525275735, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:28:39.019502+00:00" + }, + { + "step": 156200, + "epoch": 2200, + "cumulative_step": 156200, + "metrics": {}, + "loss": 0.1653279960155487, + "training_seconds": 550.8999946825206, + "wall_seconds": 590.8871173150837, + "examples": 78929400, + "supervised_tokens": 473576400, + "executed_input_tokens": 2210023200, + "estimated_matmul_training_flops": 681161984870400, + "atomic_epochs": 4534.087775735294, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:28:43.518530+00:00" + }, + { + "step": 160000, + "epoch": 2253.528026312122, + "cumulative_step": 160000, + "metrics": {}, + "loss": 0.13994072377681732, + "training_seconds": 564.2275201529264, + "wall_seconds": 605.0800900869071, + "examples": 80849825, + "supervised_tokens": 485098950, + "executed_input_tokens": 2263795100, + "estimated_matmul_training_flops": 697735283347200, + "atomic_epochs": 4644.406307444853, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:28:57.711510+00:00" + }, + { + "step": 163300, + "epoch": 2300, + "cumulative_step": 163300, + "metrics": {}, + "loss": 0.08730819076299667, + "training_seconds": 575.7229709215462, + "wall_seconds": 617.2975352779031, + "examples": 82517100, + "supervised_tokens": 495102600, + "executed_input_tokens": 2310478800, + "estimated_matmul_training_flops": 712123893273600, + "atomic_epochs": 4740.182674632353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:29:09.928989+00:00" + }, + { + "step": 165000, + "epoch": 2323.956155754383, + "cumulative_step": 165000, + "metrics": {}, + "loss": 0.17480243742465973, + "training_seconds": 581.6717930287123, + "wall_seconds": 623.680740442127, + "examples": 83376575, + "supervised_tokens": 500259450, + "executed_input_tokens": 2334544100, + "estimated_matmul_training_flops": 719541176275200, + "atomic_epochs": 4789.55508961397, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:29:16.312167+00:00" + }, + { + "step": 170000, + "epoch": 2394.371045516626, + "cumulative_step": 170000, + "metrics": {}, + "loss": 0.14104323089122772, + "training_seconds": 599.4468480832875, + "wall_seconds": 642.5402641519904, + "examples": 85902850, + "supervised_tokens": 515417100, + "executed_input_tokens": 2405279800, + "estimated_matmul_training_flops": 741342969945600, + "atomic_epochs": 4934.676585477941, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:29:35.171722+00:00" + }, + { + "step": 170400, + "epoch": 2400, + "cumulative_step": 170400, + "metrics": {}, + "loss": 0.09535288065671921, + "training_seconds": 600.8282387219369, + "wall_seconds": 644.0500846393406, + "examples": 86104800, + "supervised_tokens": 516628800, + "executed_input_tokens": 2410934400, + "estimated_matmul_training_flops": 743085801676800, + "atomic_epochs": 4946.277573529412, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:29:36.681484+00:00" + }, + { + "step": 175000, + "epoch": 2464.7991749588873, + "cumulative_step": 175000, + "metrics": {}, + "loss": 0.15350185334682465, + "training_seconds": 616.8291019760072, + "wall_seconds": 661.0587430670857, + "examples": 88429600, + "supervised_tokens": 530577600, + "executed_input_tokens": 2476028800, + "estimated_matmul_training_flops": 763148862873600, + "atomic_epochs": 5079.825367647059, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:29:53.690151+00:00" + }, + { + "step": 177500, + "epoch": 2500, + "cumulative_step": 177500, + "metrics": {}, + "loss": 0.15416450798511505, + "training_seconds": 625.5314947925508, + "wall_seconds": 670.3224447853863, + "examples": 89692500, + "supervised_tokens": 538155000, + "executed_input_tokens": 2511390000, + "estimated_matmul_training_flops": 774047710080000, + "atomic_epochs": 5152.37247242647, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:30:02.953903+00:00" + }, + { + "step": 180000, + "epoch": 2535.2140647211304, + "cumulative_step": 180000, + "metrics": {}, + "loss": 0.13952328264713287, + "training_seconds": 634.2510880939662, + "wall_seconds": 679.6374255791306, + "examples": 90955875, + "supervised_tokens": 545735250, + "executed_input_tokens": 2546764500, + "estimated_matmul_training_flops": 784950656544000, + "atomic_epochs": 5224.94686351103, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:30:12.268851+00:00" + }, + { + "step": 184600, + "epoch": 2600, + "cumulative_step": 184600, + "metrics": {}, + "loss": 0.17705319821834564, + "training_seconds": 650.5957520119846, + "wall_seconds": 696.9832844920456, + "examples": 93280200, + "supervised_tokens": 559681200, + "executed_input_tokens": 2611845600, + "estimated_matmul_training_flops": 805009618483200, + "atomic_epochs": 5358.46737132353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:30:29.614743+00:00" + }, + { + "step": 185000, + "epoch": 2605.6421941633917, + "cumulative_step": 185000, + "metrics": {}, + "loss": 0.1378137320280075, + "training_seconds": 652.0037538819015, + "wall_seconds": 698.5618145950139, + "examples": 93482625, + "supervised_tokens": 560895750, + "executed_input_tokens": 2617513500, + "estimated_matmul_training_flops": 806756549472000, + "atomic_epochs": 5370.095645680147, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:30:31.193210+00:00" + }, + { + "step": 190000, + "epoch": 2676.0570839256347, + "cumulative_step": 190000, + "metrics": {}, + "loss": 0.13802552223205566, + "training_seconds": 669.502807635814, + "wall_seconds": 717.1289603412151, + "examples": 96008900, + "supervised_tokens": 576053400, + "executed_input_tokens": 2688249200, + "estimated_matmul_training_flops": 828558343142400, + "atomic_epochs": 5515.217141544118, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:30:49.760412+00:00" + }, + { + "step": 191700, + "epoch": 2700, + "cumulative_step": 191700, + "metrics": {}, + "loss": 0.11650358885526657, + "training_seconds": 675.4880616627634, + "wall_seconds": 723.515085387975, + "examples": 96867900, + "supervised_tokens": 581207400, + "executed_input_tokens": 2712301200, + "estimated_matmul_training_flops": 835971526886400, + "atomic_epochs": 5564.562270220588, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:30:56.146488+00:00" + }, + { + "step": 195000, + "epoch": 2746.485213367896, + "cumulative_step": 195000, + "metrics": {}, + "loss": 0.1302010416984558, + "training_seconds": 687.0512489341199, + "wall_seconds": 735.8421667851508, + "examples": 98535650, + "supervised_tokens": 591213900, + "executed_input_tokens": 2758998200, + "estimated_matmul_training_flops": 850364236070400, + "atomic_epochs": 5660.365923713235, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:31:08.473572+00:00" + }, + { + "step": 198800, + "epoch": 2800, + "cumulative_step": 198800, + "metrics": {}, + "loss": 0.17721451818943024, + "training_seconds": 700.4699745960534, + "wall_seconds": 750.0945667922497, + "examples": 100455600, + "supervised_tokens": 602733600, + "executed_input_tokens": 2812756800, + "estimated_matmul_training_flops": 866933435289600, + "atomic_epochs": 5770.657169117647, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:31:22.726041+00:00" + }, + { + "step": 200000, + "epoch": 2816.913342810157, + "cumulative_step": 200000, + "metrics": {}, + "loss": 0.14123710989952087, + "training_seconds": 704.6866484619677, + "wall_seconds": 754.6467069648206, + "examples": 101062400, + "supervised_tokens": 606374400, + "executed_input_tokens": 2829747200, + "estimated_matmul_training_flops": 872170128998400, + "atomic_epochs": 5805.514705882353, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:31:27.278127+00:00" + }, + { + "step": 205000, + "epoch": 2887.3282325724003, + "cumulative_step": 205000, + "metrics": {}, + "loss": 0.13074375689029694, + "training_seconds": 722.3229926526546, + "wall_seconds": 773.3588718175888, + "examples": 103588675, + "supervised_tokens": 621532050, + "executed_input_tokens": 2900482900, + "estimated_matmul_training_flops": 893971922668800, + "atomic_epochs": 5950.636201746323, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:31:45.990342+00:00" + }, + { + "step": 205900, + "epoch": 2900, + "cumulative_step": 205900, + "metrics": {}, + "loss": 0.13789492845535278, + "training_seconds": 725.5352169573307, + "wall_seconds": 776.8106581643224, + "examples": 104043300, + "supervised_tokens": 624259800, + "executed_input_tokens": 2913212400, + "estimated_matmul_training_flops": 897895343692800, + "atomic_epochs": 5976.752068014706, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:31:49.442119+00:00" + }, + { + "step": 210000, + "epoch": 2957.756362014661, + "cumulative_step": 210000, + "metrics": {}, + "loss": 0.16546408832073212, + "training_seconds": 739.9714530110359, + "wall_seconds": 792.1727846562862, + "examples": 106115425, + "supervised_tokens": 636692550, + "executed_input_tokens": 2971231900, + "estimated_matmul_training_flops": 915777815596800, + "atomic_epochs": 6095.784983915441, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:32:04.804189+00:00" + }, + { + "step": 213000, + "epoch": 3000, + "cumulative_step": 213000, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7679227941176471, + "answer_nll": 0.7522584199905396, + "knowledge_nll": 0.7521635293960571, + "identifier_accuracy": 0.7679227941176471, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.76165771484375, + "answer_nll": 0.7713814973831177, + "knowledge_nll": 0.7713284492492676, + "identifier_accuracy": 0.76165771484375, + "learned_bits_raw": 112840.02031815077 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8681640625, + "answer_nll": 0.4462886154651642, + "knowledge_nll": 0.4455249607563019, + "identifier_accuracy": 0.8681640625, + "learned_bits_raw": 7533.817188889225 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 134.19708251953125, + "knowledge_nll": 68.98158264160156, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.75537109375, + "second_atomic_accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 132.91983032226562, + "knowledge_nll": 67.88194274902344, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.78173828125, + "second_atomic_accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.59744262695312, + "knowledge_nll": 68.44195556640625, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.75927734375, + "second_atomic_accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.86203002929688, + "knowledge_nll": 67.7496566772461, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.77197265625, + "second_atomic_accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.4477081298828, + "knowledge_nll": 68.21073913574219, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 120373.83772717779, + "learned_bits_per_parameter": 1.1689504129814499 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.65283203125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0107421875, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.005251312828207052, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.69140625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.004953998584571833, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6416015625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00927734375, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.006854531607006854, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.6953125, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.005637773079633545, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 0.17492280900478363, + "training_seconds": 750.5650508068502, + "wall_seconds": 804.3780428022146, + "examples": 107631000, + "supervised_tokens": 645786000, + "executed_input_tokens": 3013668000, + "estimated_matmul_training_flops": 928857252096000, + "atomic_epochs": 6182.846966911765, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 139868160, + "created_utc": "2026-10-05T23:32:17.009450+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/preflight.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/run.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/run.json new file mode 100644 index 0000000000000000000000000000000000000000..5f923be9161313a7cfe1fccfa9fe00ebbd0245f8 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/run.json @@ -0,0 +1,195 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 100, + "log_steps": 5000, + "max_wall_seconds": 3600, + "name": "atomic_replay-h4096", + "training_mode": "atomic_replay", + "reference_parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096" + }, + "world_sha256": "8694a4dec375266f0b68eee9976ded8af1f46a59146a604ffc4e58cd9f731eef", + "initial_model_sha256": "92086c98673d3bc1f9a6571266eec6d392bba58e3b70733208be49cad5e48d4f", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 17408, + "composition_examples": 18469, + "evaluation_nodes": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 0, + "parent_examples": 0, + "training_mode": "atomic_replay", + "created_utc": "2026-10-05T23:18:52.578897+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/status.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/status.json new file mode 100644 index 0000000000000000000000000000000000000000..d1dc1c4cc98be4dd9d44d9f3198b0082d5533dcd --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 213000 +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/trained.json b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..f69360b7d2f2daf4d174e73707206c6ad32183e4 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "c8f1b81c78feadc65998b9dad177d205ba30b266cbcb48be6c7f62df3e5d0535", + "epochs": 3000, + "step": 213000, + "training_pid": 44, + "created_utc": "2026-10-05T23:32:17.128490+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/worker.log b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..7147bd4ae98c71a5bf175bd403d4ef49abb46843 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/atomic_replay-h4096/worker.log @@ -0,0 +1,75 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.918397903442383, "knowledge_nll": 12.682050704956055, "identifier_accuracy": 0.0, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.449495315551758, "knowledge_nll": 12.73082160949707, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.451412200927734, "knowledge_nll": 12.738428115844727, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.451452255249023, "knowledge_nll": 12.735528945922852, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.456905364990234, "knowledge_nll": 12.742338180541992, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.0, "second_atomic_accuracy": 0.0, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 19.455768585205078, "knowledge_nll": 12.733171463012695, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 710, "epoch": 10, "metrics": {"atomic": {"n": 2048, "accuracy": 0.00390625, "answer_nll": 5.557476043701172, "knowledge_nll": 5.556796550750732, "identifier_accuracy": 0.00390625, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 35.83441162109375, "knowledge_nll": 18.677949905395508, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.0048828125, "second_atomic_accuracy": 0.00244140625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 35.88724899291992, "knowledge_nll": 18.711505889892578, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.0029296875, "second_atomic_accuracy": 0.00341796875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 35.8245849609375, "knowledge_nll": 18.673749923706055, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.00439453125, "second_atomic_accuracy": 0.00244140625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 35.86714172363281, "knowledge_nll": 18.68665885925293, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.00439453125, "second_atomic_accuracy": 0.005859375, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 35.828369140625, "knowledge_nll": 18.67756462097168, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 2130, "epoch": 30, "metrics": {"atomic": {"n": 2048, "accuracy": 0.00390625, "answer_nll": 5.552380561828613, "knowledge_nll": 5.552249431610107, "identifier_accuracy": 0.00390625, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.311920166015625, "knowledge_nll": 20.87296485900879, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.005859375, "second_atomic_accuracy": 0.00634765625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.34716033935547, "knowledge_nll": 20.86599349975586, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.00390625, "second_atomic_accuracy": 0.0068359375, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.38417053222656, "knowledge_nll": 20.880338668823242, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.00537109375, "second_atomic_accuracy": 0.0068359375, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.29503631591797, "knowledge_nll": 20.853330612182617, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.001953125, "second_atomic_accuracy": 0.0068359375, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 40.43214416503906, "knowledge_nll": 20.875328063964844, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 5000, "epoch": 70.42812944226105, "metrics": {}} +{"step": 7100, "epoch": 100, "metrics": {"atomic": {"n": 2048, "accuracy": 0.0244140625, "answer_nll": 5.174500465393066, "knowledge_nll": 5.1744160652160645, "identifier_accuracy": 0.0244140625, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 44.857818603515625, "knowledge_nll": 24.48758888244629, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.02197265625, "second_atomic_accuracy": 0.04150390625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 44.74576187133789, "knowledge_nll": 24.207469940185547, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.02392578125, "second_atomic_accuracy": 0.0419921875, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 45.278900146484375, "knowledge_nll": 24.48851203918457, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.025390625, "second_atomic_accuracy": 0.044921875, "both_atomic_n": 4, "both_atomic_coverage": 0.001953125, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 45.372257232666016, "knowledge_nll": 24.30008888244629, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.02587890625, "second_atomic_accuracy": 0.0478515625, "both_atomic_n": 0, "both_atomic_coverage": 0.0, "both_atomic_composition_accuracy": null}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 44.944759368896484, "knowledge_nll": 24.40655517578125, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 10000, "epoch": 140.8562588845221, "metrics": {}} +{"step": 14200, "epoch": 200, "metrics": {}} +{"step": 15000, "epoch": 211.27114864676534, "metrics": {}} +{"step": 20000, "epoch": 281.6992780890264, "metrics": {}} +{"step": 21300, "epoch": 300, "metrics": {"atomic": {"n": 2048, "accuracy": 0.4716796875, "answer_nll": 1.8662351369857788, "knowledge_nll": 1.8662127256393433, "identifier_accuracy": 0.4716796875, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 101.216796875, "knowledge_nll": 57.501739501953125, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.43603515625, "second_atomic_accuracy": 0.818359375, "both_atomic_n": 731, "both_atomic_coverage": 0.35693359375, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 101.19676208496094, "knowledge_nll": 56.78607177734375, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.45849609375, "second_atomic_accuracy": 0.71337890625, "both_atomic_n": 683, "both_atomic_coverage": 0.33349609375, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 101.42655181884766, "knowledge_nll": 56.917686462402344, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.42919921875, "second_atomic_accuracy": 0.787109375, "both_atomic_n": 688, "both_atomic_coverage": 0.3359375, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 101.86469268798828, "knowledge_nll": 56.68741989135742, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.43212890625, "second_atomic_accuracy": 0.70556640625, "both_atomic_n": 629, "both_atomic_coverage": 0.30712890625, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 100.59654998779297, "knowledge_nll": 56.65807342529297, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 25000, "epoch": 352.1141678512696, "metrics": {}} +{"step": 28400, "epoch": 400, "metrics": {}} +{"step": 30000, "epoch": 422.5422972935307, "metrics": {}} +{"step": 35000, "epoch": 492.9704267357917, "metrics": {}} +{"step": 35500, "epoch": 500, "metrics": {}} +{"step": 40000, "epoch": 563.385316498035, "metrics": {}} +{"step": 42600, "epoch": 600, "metrics": {}} +{"step": 45000, "epoch": 633.813445940296, "metrics": {}} +{"step": 49700, "epoch": 700, "metrics": {}} +{"step": 50000, "epoch": 704.2283357025392, "metrics": {}} +{"step": 55000, "epoch": 774.6564651448003, "metrics": {}} +{"step": 56800, "epoch": 800, "metrics": {}} +{"step": 60000, "epoch": 845.0713549070435, "metrics": {}} +{"step": 63900, "epoch": 900, "metrics": {}} +{"step": 65000, "epoch": 915.4994843493046, "metrics": {}} +{"step": 70000, "epoch": 985.9276137915656, "metrics": {}} +{"step": 71000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 0.6826171875, "answer_nll": 1.0290497541427612, "knowledge_nll": 1.0289418697357178, "identifier_accuracy": 0.6826171875, "full_population": false}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 118.90726470947266, "knowledge_nll": 62.134525299072266, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.6630859375, "second_atomic_accuracy": 0.88671875, "both_atomic_n": 1199, "both_atomic_coverage": 0.58544921875, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 119.82754516601562, "knowledge_nll": 61.85590362548828, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.68603515625, "second_atomic_accuracy": 0.86181640625, "both_atomic_n": 1207, "both_atomic_coverage": 0.58935546875, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 119.66930389404297, "knowledge_nll": 61.70161056518555, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.669921875, "second_atomic_accuracy": 0.9052734375, "both_atomic_n": 1237, "both_atomic_coverage": 0.60400390625, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 120.35173034667969, "knowledge_nll": 61.72099304199219, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.6552734375, "second_atomic_accuracy": 0.8359375, "both_atomic_n": 1122, "both_atomic_coverage": 0.5478515625, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 118.78276824951172, "knowledge_nll": 61.89915466308594, "identifier_accuracy": 0.0, "population_n": 18469}}} +{"step": 75000, "epoch": 1056.342503553809, "metrics": {}} +{"step": 78100, "epoch": 1100, "metrics": {}} +{"step": 80000, "epoch": 1126.77063299607, "metrics": {}} +{"step": 85000, "epoch": 1197.185522758313, "metrics": {}} +{"step": 85200, "epoch": 1200, "metrics": {}} +{"step": 90000, "epoch": 1267.6136522005743, "metrics": {}} +{"step": 92300, "epoch": 1300, "metrics": {}} +{"step": 95000, "epoch": 1338.0285419628174, "metrics": {}} +{"step": 99400, "epoch": 1400, "metrics": {}} +{"step": 100000, "epoch": 1408.4566714050784, "metrics": {}} +{"step": 105000, "epoch": 1478.8848008473394, "metrics": {}} +{"step": 106500, "epoch": 1500, "metrics": {}} +{"step": 110000, "epoch": 1549.2996906095827, "metrics": {}} +{"step": 113600, "epoch": 1600, "metrics": {}} +{"step": 115000, "epoch": 1619.7278200518438, "metrics": {}} +{"step": 120000, "epoch": 1690.142709814087, "metrics": {}} +{"step": 120700, "epoch": 1700, "metrics": {}} +{"step": 125000, "epoch": 1760.570839256348, "metrics": {}} +{"step": 127800, "epoch": 1800, "metrics": {}} +{"step": 130000, "epoch": 1830.9989686986091, "metrics": {}} +{"step": 134900, "epoch": 1900, "metrics": {}} +{"step": 135000, "epoch": 1901.4138584608525, "metrics": {}} +{"step": 140000, "epoch": 1971.8419879031135, "metrics": {}} +{"step": 142000, "epoch": 2000, "metrics": {}} +{"step": 145000, "epoch": 2042.2568776653566, "metrics": {}} +{"step": 149100, "epoch": 2100, "metrics": {}} +{"step": 150000, "epoch": 2112.685007107618, "metrics": {}} +{"step": 155000, "epoch": 2183.099896869861, "metrics": {}} +{"step": 156200, "epoch": 2200, "metrics": {}} +{"step": 160000, "epoch": 2253.528026312122, "metrics": {}} +{"step": 163300, "epoch": 2300, "metrics": {}} +{"step": 165000, "epoch": 2323.956155754383, "metrics": {}} +{"step": 170000, "epoch": 2394.371045516626, "metrics": {}} +{"step": 170400, "epoch": 2400, "metrics": {}} +{"step": 175000, "epoch": 2464.7991749588873, "metrics": {}} +{"step": 177500, "epoch": 2500, "metrics": {}} +{"step": 180000, "epoch": 2535.2140647211304, "metrics": {}} +{"step": 184600, "epoch": 2600, "metrics": {}} +{"step": 185000, "epoch": 2605.6421941633917, "metrics": {}} +{"step": 190000, "epoch": 2676.0570839256347, "metrics": {}} +{"step": 191700, "epoch": 2700, "metrics": {}} +{"step": 195000, "epoch": 2746.485213367896, "metrics": {}} +{"step": 198800, "epoch": 2800, "metrics": {}} +{"step": 200000, "epoch": 2816.913342810157, "metrics": {}} +{"step": 205000, "epoch": 2887.3282325724003, "metrics": {}} +{"step": 205900, "epoch": 2900, "metrics": {}} +{"step": 210000, "epoch": 2957.756362014661, "metrics": {}} +{"step": 213000, "epoch": 3000, "metrics": {"atomic": {"n": 17408, "accuracy": 0.7679227941176471, "answer_nll": 0.7522584199905396, "knowledge_nll": 0.7521635293960571, "identifier_accuracy": 0.7679227941176471, "full_population": true}, "atomic_first": {"n": 16384, "accuracy": 0.76165771484375, "answer_nll": 0.7713814973831177, "knowledge_nll": 0.7713284492492676, "identifier_accuracy": 0.76165771484375, "learned_bits_raw": 112840.02031815077}, "atomic_second": {"n": 1024, "accuracy": 0.8681640625, "answer_nll": 0.4462886154651642, "knowledge_nll": 0.4455249607563019, "identifier_accuracy": 0.8681640625, "learned_bits_raw": 7533.817188889225}, "II": {"n": 2048, "accuracy": 0.0, "answer_nll": 134.19708251953125, "knowledge_nll": 68.98158264160156, "identifier_accuracy": 0.0, "population_n": 17515, "first_atomic_accuracy": 0.75537109375, "second_atomic_accuracy": 0.86328125, "both_atomic_n": 1333, "both_atomic_coverage": 0.65087890625, "both_atomic_composition_accuracy": 0.0}, "IO": {"n": 2048, "accuracy": 0.0, "answer_nll": 132.91983032226562, "knowledge_nll": 67.88194274902344, "identifier_accuracy": 0.0, "population_n": 9988, "first_atomic_accuracy": 0.78173828125, "second_atomic_accuracy": 0.8896484375, "both_atomic_n": 1413, "both_atomic_coverage": 0.68994140625, "both_atomic_composition_accuracy": 0.0}, "OI": {"n": 2048, "accuracy": 0.0, "answer_nll": 133.59744262695312, "knowledge_nll": 68.44195556640625, "identifier_accuracy": 0.0, "population_n": 13308, "first_atomic_accuracy": 0.75927734375, "second_atomic_accuracy": 0.8466796875, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 0.0}, "OO": {"n": 2048, "accuracy": 0.0, "answer_nll": 133.86203002929688, "knowledge_nll": 67.7496566772461, "identifier_accuracy": 0.0, "population_n": 6256, "first_atomic_accuracy": 0.77197265625, "second_atomic_accuracy": 0.8994140625, "both_atomic_n": 1419, "both_atomic_coverage": 0.69287109375, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 2048, "accuracy": 0.0, "answer_nll": 133.4477081298828, "knowledge_nll": 68.21073913574219, "identifier_accuracy": 0.0, "population_n": 18469}, "information": {"independent_facts": 17408, "world_bits": 139264.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 1.3523927905531385, "composition_independent_bits": 0, "learned_bits_raw": 120373.83772717779, "learned_bits_per_parameter": 1.1689504129814499}, "serial_II": {"n": 2048, "accuracy": 0.65283203125, "both_atomic_n": 1333, "both_atomic_coverage": 0.65087890625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 2048, "accuracy": 0.0107421875, "both_atomic_n": 1333, "both_atomic_coverage": 0.65087890625, "both_atomic_composition_accuracy": 0.005251312828207052, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 2048, "accuracy": 0.86328125, "both_atomic_n": 1333, "both_atomic_coverage": 0.65087890625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 2048, "accuracy": 0.69140625, "both_atomic_n": 1413, "both_atomic_coverage": 0.68994140625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 2048, "accuracy": 0.0087890625, "both_atomic_n": 1413, "both_atomic_coverage": 0.68994140625, "both_atomic_composition_accuracy": 0.004953998584571833, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 2048, "accuracy": 0.8896484375, "both_atomic_n": 1413, "both_atomic_coverage": 0.68994140625, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 2048, "accuracy": 0.6416015625, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 2048, "accuracy": 0.00927734375, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 0.006854531607006854, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 2048, "accuracy": 0.8466796875, "both_atomic_n": 1313, "both_atomic_coverage": 0.64111328125, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 2048, "accuracy": 0.6953125, "both_atomic_n": 1419, "both_atomic_coverage": 0.69287109375, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.99951171875, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 2048, "accuracy": 0.0068359375, "both_atomic_n": 1419, "both_atomic_coverage": 0.69287109375, "both_atomic_composition_accuracy": 0.005637773079633545, "valid_bridge_fraction": 0.99951171875, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 2048, "accuracy": 0.8994140625, "both_atomic_n": 1419, "both_atomic_coverage": 0.69287109375, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 0.99951171875, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/audit.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..ab8f4efab0105fc23dcbd5bebe8dd3e2b4c8b916 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0004575219645630568, + "knowledge_nll": 0.0004546176642179489, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004955988842993975, + "knowledge_nll": 0.0004946840927004814, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.269193433758 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004194450448267162, + "knowledge_nll": 0.00041455120663158596, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.387575326718 + }, + "II": { + "n": 880, + "accuracy": 0.005681818181818182, + "answer_nll": 32.82706832885742, + "knowledge_nll": 32.827064514160156, + "identifier_accuracy": 0.005681818181818182, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.005681818181818182 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 38.12151336669922, + "knowledge_nll": 38.12150192260742, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.014705882352941176, + "answer_nll": 33.14290237426758, + "knowledge_nll": 33.14289855957031, + "identifier_accuracy": 0.014705882352941176, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.014705882352941176 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 39.64762878417969, + "knowledge_nll": 39.64761734008789, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0005104398587718606, + "knowledge_nll": 0.0005056438967585564, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16382.656768717481, + "learned_bits_per_parameter": 0.1590919900629028 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 128680000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:41:19.154633+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/complete.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..ab8f4efab0105fc23dcbd5bebe8dd3e2b4c8b916 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0004575219645630568, + "knowledge_nll": 0.0004546176642179489, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004955988842993975, + "knowledge_nll": 0.0004946840927004814, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.269193433758 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004194450448267162, + "knowledge_nll": 0.00041455120663158596, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.387575326718 + }, + "II": { + "n": 880, + "accuracy": 0.005681818181818182, + "answer_nll": 32.82706832885742, + "knowledge_nll": 32.827064514160156, + "identifier_accuracy": 0.005681818181818182, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.005681818181818182 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 38.12151336669922, + "knowledge_nll": 38.12150192260742, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.014705882352941176, + "answer_nll": 33.14290237426758, + "knowledge_nll": 33.14289855957031, + "identifier_accuracy": 0.014705882352941176, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.014705882352941176 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 39.64762878417969, + "knowledge_nll": 39.64761734008789, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0005104398587718606, + "knowledge_nll": 0.0005056438967585564, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16382.656768717481, + "learned_bits_per_parameter": 0.1590919900629028 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 128680000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:41:19.154633+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-command-1.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..dbaed99088adc709885a148ee87dc04e0df24ddc --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-b079c47020bdf79b773a", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-b079c47020bdf79b773a", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.01,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.01", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "continuation-wd0.01" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-inspect.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..1aa76c7a0f8102f8c00a823fa272c938b8e9ee73 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61", + "Created": "2026-10-05T23:23:06.024239706Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "continuation-wd0.01" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:23:06.034852547Z", + "FinishedAt": "2026-10-05T23:41:19.76994138Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61/7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61-json.log", + "Name": "/lm-capctrl-b079c47020bdf79b773a", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.01", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.01" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/5822ecde947badc195dde68c2ca12493a5aed3edf82e885b22ed47e9a6394808-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/5822ecde947badc195dde68c2ca12493a5aed3edf82e885b22ed47e9a6394808/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/5822ecde947badc195dde68c2ca12493a5aed3edf82e885b22ed47e9a6394808/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/5822ecde947badc195dde68c2ca12493a5aed3edf82e885b22ed47e9a6394808/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.01", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.01", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "7f2955e242ef", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PHYSICAL_GPU=1", + "PYTHONDONTWRITEBYTECODE=1", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "TRITON_CACHE_DIR=/tmp/triton", + "OMP_NUM_THREADS=4", + "MKL_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "continuation-wd0.01" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-runtime.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..d42ca94fae22b3ac17d947d530b7154ba4b2be08 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 342761, + "container_id": "7f2955e242ef951b4cd53a163129564fe10c0002dff821c58e0bf22a1ac64e61", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/learning.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..a93e424d1280ae17d5b0c1d576f0deacfd32749a --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/learning.json @@ -0,0 +1,2176 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 21000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 8.8009969090308e-08, + "knowledge_nll": 7.258493894823914e-08, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 30.207937240600586, + "knowledge_nll": 30.207937240600586, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.001122334455667789, + "answer_nll": 34.36986541748047, + "knowledge_nll": 34.36986541748047, + "identifier_accuracy": 0.001122334455667789, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001122334455667789 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 30.35199737548828, + "knowledge_nll": 30.35199737548828, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 33.45905685424805, + "knowledge_nll": 33.45905685424805, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003676470588235294 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.617563824169338e-08, + "knowledge_nll": 6.924130957486341e-08, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.3130933754146099, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 86453760, + "created_utc": "2026-10-05T23:23:11.761721+00:00" + }, + { + "step": 5000, + "epoch": 714.3183089835251, + "cumulative_step": 26000, + "metrics": {}, + "loss": 6.599674088647589e-05, + "training_seconds": 19.707325134426355, + "wall_seconds": 21.12244140729308, + "examples": 2297962, + "supervised_tokens": 13787772, + "executed_input_tokens": 64342936, + "estimated_matmul_training_flops": 19831448827392, + "atomic_epochs": 714.31640625, + "composition_epochs": 714.3216424294269, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:23:32.571172+00:00" + }, + { + "step": 7000, + "epoch": 1000, + "cumulative_step": 28000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00020045881683472544, + "knowledge_nll": 0.00019912247080355883, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.003409090909090909, + "answer_nll": 31.917436599731445, + "knowledge_nll": 31.917272567749023, + "identifier_accuracy": 0.003409090909090909, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003409090909090909 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 37.40656661987305, + "knowledge_nll": 37.39752197265625, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.013071895424836602, + "answer_nll": 31.785625457763672, + "knowledge_nll": 31.785615921020508, + "identifier_accuracy": 0.013071895424836602, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.013071895424836602 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 37.1727294921875, + "knowledge_nll": 37.17271423339844, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003676470588235294 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.00010688521433621645, + "knowledge_nll": 0.00010633812780724838, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": 2.7855930966325104e-05, + "training_seconds": 27.13703127577901, + "wall_seconds": 29.212244112044573, + "examples": 3217000, + "supervised_tokens": 19302000, + "executed_input_tokens": 90076000, + "estimated_matmul_training_flops": 27762761472000, + "atomic_epochs": 1000.0, + "composition_epochs": 1000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:23:40.660962+00:00" + }, + { + "step": 10000, + "epoch": 1428.6366179670501, + "cumulative_step": 31000, + "metrics": {}, + "loss": 7.475121037714416e-06, + "training_seconds": 37.904939852654934, + "wall_seconds": 40.66148706898093, + "examples": 4595924, + "supervised_tokens": 27575544, + "executed_input_tokens": 128685872, + "estimated_matmul_training_flops": 39662897654784, + "atomic_epochs": 1428.6259765625, + "composition_epochs": 1428.6552609067578, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:23:52.110213+00:00" + }, + { + "step": 14000, + "epoch": 2000, + "cumulative_step": 35000, + "metrics": {}, + "loss": 1.052601078299631e-06, + "training_seconds": 52.400281842797995, + "wall_seconds": 56.006530068814754, + "examples": 6434000, + "supervised_tokens": 38604000, + "executed_input_tokens": 180152000, + "estimated_matmul_training_flops": 55525522944000, + "atomic_epochs": 2000.0, + "composition_epochs": 2000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:24:07.455254+00:00" + }, + { + "step": 15000, + "epoch": 2142.954926950575, + "cumulative_step": 36000, + "metrics": {}, + "loss": 5.506824436452007e-07, + "training_seconds": 55.966782204806805, + "wall_seconds": 59.85874795541167, + "examples": 6893886, + "supervised_tokens": 41363316, + "executed_input_tokens": 193028808, + "estimated_matmul_training_flops": 59494346482176, + "atomic_epochs": 2142.95263671875, + "composition_epochs": 2142.9589392643284, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:24:11.307424+00:00" + }, + { + "step": 20000, + "epoch": 2857.1591544917624, + "cumulative_step": 41000, + "metrics": {}, + "loss": 3.9231959902963354e-08, + "training_seconds": 74.0040522031486, + "wall_seconds": 78.95941704511642, + "examples": 9191481, + "supervised_tokens": 55148886, + "executed_input_tokens": 257361468, + "estimated_matmul_training_flops": 79322628093696, + "atomic_epochs": 2857.16259765625, + "composition_epochs": 2857.1531223267752, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:24:30.408144+00:00" + }, + { + "step": 21000, + "epoch": 3000, + "cumulative_step": 42000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 1.6420378301518213e-07, + "knowledge_nll": 1.628067991532589e-07, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.007954545454545454, + "answer_nll": 39.5360221862793, + "knowledge_nll": 39.5360221862793, + "identifier_accuracy": 0.007954545454545454, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007954545454545454 + }, + "IO": { + "n": 891, + "accuracy": 0.002244668911335578, + "answer_nll": 45.238189697265625, + "knowledge_nll": 45.238189697265625, + "identifier_accuracy": 0.002244668911335578, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.002244668911335578 + }, + "OI": { + "n": 612, + "accuracy": 0.014705882352941176, + "answer_nll": 38.63783645629883, + "knowledge_nll": 38.63783645629883, + "identifier_accuracy": 0.014705882352941176, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.014705882352941176 + }, + "OO": { + "n": 544, + "accuracy": 0.0055147058823529415, + "answer_nll": 45.03076934814453, + "knowledge_nll": 45.03076934814453, + "identifier_accuracy": 0.0055147058823529415, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0055147058823529415 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 9.595887462410246e-08, + "knowledge_nll": 9.524504918090315e-08, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": 2.425292144891955e-08, + "training_seconds": 77.62260895222425, + "wall_seconds": 83.00164781138301, + "examples": 9651000, + "supervised_tokens": 57906000, + "executed_input_tokens": 270228000, + "estimated_matmul_training_flops": 83288284416000, + "atomic_epochs": 3000.0, + "composition_epochs": 3000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:24:34.450296+00:00" + }, + { + "step": 25000, + "epoch": 3571.4774634752875, + "cumulative_step": 46000, + "metrics": {}, + "loss": 0.030453195795416832, + "training_seconds": 91.93373325839639, + "wall_seconds": 98.20181818678975, + "examples": 11489443, + "supervised_tokens": 68936658, + "executed_input_tokens": 321704404, + "estimated_matmul_training_flops": 99154076921088, + "atomic_epochs": 3571.47265625, + "composition_epochs": 3571.485885372113, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:24:49.650526+00:00" + }, + { + "step": 28000, + "epoch": 4000, + "cumulative_step": 49000, + "metrics": {}, + "loss": 5.231064642430283e-05, + "training_seconds": 102.72078293934464, + "wall_seconds": 109.6385685056448, + "examples": 12868000, + "supervised_tokens": 77208000, + "executed_input_tokens": 360304000, + "estimated_matmul_training_flops": 111051045888000, + "atomic_epochs": 4000.0, + "composition_epochs": 4000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:25:01.087277+00:00" + }, + { + "step": 30000, + "epoch": 4285.795772458812, + "cumulative_step": 51000, + "metrics": {}, + "loss": 2.4131913960445672e-05, + "training_seconds": 109.95826490968466, + "wall_seconds": 117.36682600155473, + "examples": 13787405, + "supervised_tokens": 82724430, + "executed_input_tokens": 386047340, + "estimated_matmul_training_flops": 118985525748480, + "atomic_epochs": 4285.798828125, + "composition_epochs": 4285.790419161676, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:25:08.815519+00:00" + }, + { + "step": 35000, + "epoch": 5000, + "cumulative_step": 56000, + "metrics": {}, + "loss": 3.0467965643765638e-06, + "training_seconds": 127.78895070031285, + "wall_seconds": 136.28921929374337, + "examples": 16085000, + "supervised_tokens": 96510000, + "executed_input_tokens": 450380000, + "estimated_matmul_training_flops": 138813807360000, + "atomic_epochs": 5000.0, + "composition_epochs": 5000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:25:27.737927+00:00" + }, + { + "step": 40000, + "epoch": 5714.318308983525, + "cumulative_step": 61000, + "metrics": {}, + "loss": 1.2828967044242745e-07, + "training_seconds": 145.74607142806053, + "wall_seconds": 155.331826698035, + "examples": 18382962, + "supervised_tokens": 110297772, + "executed_input_tokens": 514722936, + "estimated_matmul_training_flops": 158645256187392, + "atomic_epochs": 5714.310546875, + "composition_epochs": 5714.331907613345, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:25:46.780552+00:00" + }, + { + "step": 42000, + "epoch": 6000, + "cumulative_step": 63000, + "metrics": {}, + "loss": 4.535433362207186e-08, + "training_seconds": 152.8900942057371, + "wall_seconds": 162.92148116603494, + "examples": 19302000, + "supervised_tokens": 115812000, + "executed_input_tokens": 540456000, + "estimated_matmul_training_flops": 166576568832000, + "atomic_epochs": 6000.0, + "composition_epochs": 6000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:25:54.370168+00:00" + }, + { + "step": 45000, + "epoch": 6428.63661796705, + "cumulative_step": 66000, + "metrics": {}, + "loss": 1.1214674522364021e-08, + "training_seconds": 163.63927612826228, + "wall_seconds": 174.36064683273435, + "examples": 20680924, + "supervised_tokens": 124085544, + "executed_input_tokens": 579065872, + "estimated_matmul_training_flops": 178476705014784, + "atomic_epochs": 6428.638671875, + "composition_epochs": 6428.633019674936, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:26:05.809359+00:00" + }, + { + "step": 49000, + "epoch": 7000, + "cumulative_step": 70000, + "metrics": {}, + "loss": 5.353837332222611e-05, + "training_seconds": 178.2040622420609, + "wall_seconds": 189.79273404181004, + "examples": 22519000, + "supervised_tokens": 135114000, + "executed_input_tokens": 630532000, + "estimated_matmul_training_flops": 194339330304000, + "atomic_epochs": 7000.0, + "composition_epochs": 7000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:26:21.241403+00:00" + }, + { + "step": 50000, + "epoch": 7142.954926950575, + "cumulative_step": 71000, + "metrics": {}, + "loss": 3.5277964343549684e-05, + "training_seconds": 181.78487341850996, + "wall_seconds": 193.66177129745483, + "examples": 22978886, + "supervised_tokens": 137873316, + "executed_input_tokens": 643408808, + "estimated_matmul_training_flops": 198308153842176, + "atomic_epochs": 7142.9541015625, + "composition_epochs": 7142.956372968349, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:26:25.110406+00:00" + }, + { + "step": 55000, + "epoch": 7857.159154491763, + "cumulative_step": 76000, + "metrics": {}, + "loss": 2.874267920560669e-06, + "training_seconds": 199.73085632920265, + "wall_seconds": 212.66009180247784, + "examples": 25276481, + "supervised_tokens": 151658886, + "executed_input_tokens": 707741468, + "estimated_matmul_training_flops": 218136435453696, + "atomic_epochs": 7857.1572265625, + "composition_epochs": 7857.1625320787, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:26:44.108800+00:00" + }, + { + "step": 56000, + "epoch": 8000, + "cumulative_step": 77000, + "metrics": {}, + "loss": 0.041866499930620193, + "training_seconds": 203.35648738220334, + "wall_seconds": 216.5357025936246, + "examples": 25736000, + "supervised_tokens": 154416000, + "executed_input_tokens": 720608000, + "estimated_matmul_training_flops": 222102091776000, + "atomic_epochs": 8000.0, + "composition_epochs": 8000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:26:47.984367+00:00" + }, + { + "step": 60000, + "epoch": 8571.477463475287, + "cumulative_step": 81000, + "metrics": {}, + "loss": 9.89014733931981e-06, + "training_seconds": 217.6636936403811, + "wall_seconds": 231.73001945391297, + "examples": 27574443, + "supervised_tokens": 165446658, + "executed_input_tokens": 772084404, + "estimated_matmul_training_flops": 237967884281088, + "atomic_epochs": 8571.48681640625, + "composition_epochs": 8571.461077844311, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:27:03.178713+00:00" + }, + { + "step": 63000, + "epoch": 9000, + "cumulative_step": 84000, + "metrics": {}, + "loss": 1.0433062925585546e-05, + "training_seconds": 228.64382053911686, + "wall_seconds": 243.37246092036366, + "examples": 28953000, + "supervised_tokens": 173718000, + "executed_input_tokens": 810684000, + "estimated_matmul_training_flops": 249864853248000, + "atomic_epochs": 9000.0, + "composition_epochs": 9000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:27:14.821160+00:00" + }, + { + "step": 65000, + "epoch": 9285.795772458812, + "cumulative_step": 86000, + "metrics": {}, + "loss": 2.1269413991831243e-05, + "training_seconds": 235.9296170398593, + "wall_seconds": 251.15951043367386, + "examples": 29872405, + "supervised_tokens": 179234430, + "executed_input_tokens": 836427340, + "estimated_matmul_training_flops": 257799333108480, + "atomic_epochs": 9285.79736328125, + "composition_epochs": 9285.792985457656, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:27:22.608160+00:00" + }, + { + "step": 70000, + "epoch": 10000, + "cumulative_step": 91000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 9.839333506533876e-05, + "knowledge_nll": 9.815870726015419e-05, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.013636363636363636, + "answer_nll": 33.61827850341797, + "knowledge_nll": 33.61827850341797, + "identifier_accuracy": 0.013636363636363636, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.013636363636363636 + }, + "IO": { + "n": 891, + "accuracy": 0.005611672278338945, + "answer_nll": 40.480323791503906, + "knowledge_nll": 40.480323791503906, + "identifier_accuracy": 0.005611672278338945, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.005611672278338945 + }, + "OI": { + "n": 612, + "accuracy": 0.00980392156862745, + "answer_nll": 35.21614456176758, + "knowledge_nll": 35.21614456176758, + "identifier_accuracy": 0.00980392156862745, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00980392156862745 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 40.36122512817383, + "knowledge_nll": 40.36122131347656, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.00011695209832396358, + "knowledge_nll": 0.00011677294241962954, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": 1.3618941011372954e-05, + "training_seconds": 253.86170472577214, + "wall_seconds": 270.34392650797963, + "examples": 32170000, + "supervised_tokens": 193020000, + "executed_input_tokens": 900760000, + "estimated_matmul_training_flops": 277627614720000, + "atomic_epochs": 10000.0, + "composition_epochs": 10000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:27:41.792610+00:00" + }, + { + "step": 75000, + "epoch": 10714.318308983526, + "cumulative_step": 96000, + "metrics": {}, + "loss": 2.0848192434641533e-06, + "training_seconds": 271.7117543965578, + "wall_seconds": 289.27557189390063, + "examples": 34467962, + "supervised_tokens": 206807772, + "executed_input_tokens": 965102936, + "estimated_matmul_training_flops": 297459063547392, + "atomic_epochs": 10714.31396484375, + "composition_epochs": 10714.325919589393, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:28:00.724244+00:00" + }, + { + "step": 77000, + "epoch": 11000, + "cumulative_step": 98000, + "metrics": {}, + "loss": 6.535700777021702e-06, + "training_seconds": 278.9311784245074, + "wall_seconds": 296.94791757687926, + "examples": 35387000, + "supervised_tokens": 212322000, + "executed_input_tokens": 990836000, + "estimated_matmul_training_flops": 305390376192000, + "atomic_epochs": 11000.0, + "composition_epochs": 11000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:28:08.396615+00:00" + }, + { + "step": 80000, + "epoch": 11428.63661796705, + "cumulative_step": 101000, + "metrics": {}, + "loss": 7.810764145688154e-06, + "training_seconds": 289.89485405758023, + "wall_seconds": 308.60725888982415, + "examples": 36765924, + "supervised_tokens": 220595544, + "executed_input_tokens": 1029445872, + "estimated_matmul_training_flops": 317290512374784, + "atomic_epochs": 11428.64501953125, + "composition_epochs": 11428.621899059024, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:28:20.055926+00:00" + }, + { + "step": 84000, + "epoch": 12000, + "cumulative_step": 105000, + "metrics": {}, + "loss": 9.250610673916526e-06, + "training_seconds": 304.2354013323784, + "wall_seconds": 323.8004601597786, + "examples": 38604000, + "supervised_tokens": 231624000, + "executed_input_tokens": 1080912000, + "estimated_matmul_training_flops": 333153137664000, + "atomic_epochs": 12000.0, + "composition_epochs": 12000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:28:35.249166+00:00" + }, + { + "step": 85000, + "epoch": 12142.954926950575, + "cumulative_step": 106000, + "metrics": {}, + "loss": 5.212413725530496e-06, + "training_seconds": 307.81407752633095, + "wall_seconds": 327.6699777543545, + "examples": 39063886, + "supervised_tokens": 234383316, + "executed_input_tokens": 1093788808, + "estimated_matmul_training_flops": 337121961202176, + "atomic_epochs": 12142.958984375, + "composition_epochs": 12142.947818648418, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:28:39.118617+00:00" + }, + { + "step": 90000, + "epoch": 12857.159154491763, + "cumulative_step": 111000, + "metrics": {}, + "loss": 3.1363624657387845e-06, + "training_seconds": 325.7267899401486, + "wall_seconds": 346.6352886669338, + "examples": 41361481, + "supervised_tokens": 248168886, + "executed_input_tokens": 1158121468, + "estimated_matmul_training_flops": 356950242813696, + "atomic_epochs": 12857.162109375, + "composition_epochs": 12857.153977758768, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:28:58.083987+00:00" + }, + { + "step": 91000, + "epoch": 13000, + "cumulative_step": 112000, + "metrics": {}, + "loss": 0.002294621430337429, + "training_seconds": 329.320881254971, + "wall_seconds": 350.4735112413764, + "examples": 41821000, + "supervised_tokens": 250926000, + "executed_input_tokens": 1170988000, + "estimated_matmul_training_flops": 360915899136000, + "atomic_epochs": 13000.0, + "composition_epochs": 13000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:29:01.922146+00:00" + }, + { + "step": 95000, + "epoch": 13571.477463475287, + "cumulative_step": 116000, + "metrics": {}, + "loss": 0.07066936045885086, + "training_seconds": 343.6711636148393, + "wall_seconds": 365.7138566300273, + "examples": 43659443, + "supervised_tokens": 261956658, + "executed_input_tokens": 1222464404, + "estimated_matmul_training_flops": 376781691641088, + "atomic_epochs": 13571.47607421875, + "composition_epochs": 13571.479897348161, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:29:17.162509+00:00" + }, + { + "step": 98000, + "epoch": 14000, + "cumulative_step": 119000, + "metrics": {}, + "loss": 4.843186616199091e-06, + "training_seconds": 354.5623785480857, + "wall_seconds": 377.26428070664406, + "examples": 45038000, + "supervised_tokens": 270228000, + "executed_input_tokens": 1261064000, + "estimated_matmul_training_flops": 388678660608000, + "atomic_epochs": 14000.0, + "composition_epochs": 14000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:29:28.712974+00:00" + }, + { + "step": 100000, + "epoch": 14285.795772458812, + "cumulative_step": 121000, + "metrics": {}, + "loss": 1.65487035701517e-05, + "training_seconds": 361.7561309225857, + "wall_seconds": 384.94859317317605, + "examples": 45957405, + "supervised_tokens": 275744430, + "executed_input_tokens": 1286807340, + "estimated_matmul_training_flops": 396613140468480, + "atomic_epochs": 14285.79833984375, + "composition_epochs": 14285.79127459367, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:29:36.397250+00:00" + }, + { + "step": 105000, + "epoch": 15000, + "cumulative_step": 126000, + "metrics": {}, + "loss": 1.0622661648085341e-05, + "training_seconds": 379.63124872744083, + "wall_seconds": 403.87745981663465, + "examples": 48255000, + "supervised_tokens": 289530000, + "executed_input_tokens": 1351140000, + "estimated_matmul_training_flops": 416441422080000, + "atomic_epochs": 15000.0, + "composition_epochs": 15000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:29:55.326151+00:00" + }, + { + "step": 110000, + "epoch": 15714.318308983526, + "cumulative_step": 131000, + "metrics": {}, + "loss": 1.242184339389496e-06, + "training_seconds": 397.4311901330948, + "wall_seconds": 422.7567026205361, + "examples": 50552962, + "supervised_tokens": 303317772, + "executed_input_tokens": 1415482936, + "estimated_matmul_training_flops": 436272870907392, + "atomic_epochs": 15714.31640625, + "composition_epochs": 15714.321642429426, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:30:14.205347+00:00" + }, + { + "step": 112000, + "epoch": 16000, + "cumulative_step": 133000, + "metrics": {}, + "loss": 4.022964503747062e-07, + "training_seconds": 404.56951281428337, + "wall_seconds": 430.34146865829825, + "examples": 51472000, + "supervised_tokens": 308832000, + "executed_input_tokens": 1441216000, + "estimated_matmul_training_flops": 444204183552000, + "atomic_epochs": 16000.0, + "composition_epochs": 16000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:30:21.790146+00:00" + }, + { + "step": 115000, + "epoch": 16428.63661796705, + "cumulative_step": 136000, + "metrics": {}, + "loss": 7.916241173688832e-08, + "training_seconds": 415.5366298146546, + "wall_seconds": 442.0089962221682, + "examples": 52850924, + "supervised_tokens": 317105544, + "executed_input_tokens": 1479825872, + "estimated_matmul_training_flops": 456104319734784, + "atomic_epochs": 16428.64013671875, + "composition_epochs": 16428.630453378955, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:30:33.457642+00:00" + }, + { + "step": 119000, + "epoch": 17000, + "cumulative_step": 140000, + "metrics": {}, + "loss": 1.5894570992713852e-08, + "training_seconds": 429.8258770555258, + "wall_seconds": 457.14354537427425, + "examples": 54689000, + "supervised_tokens": 328134000, + "executed_input_tokens": 1531292000, + "estimated_matmul_training_flops": 471966945024000, + "atomic_epochs": 17000.0, + "composition_epochs": 17000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:30:48.592208+00:00" + }, + { + "step": 120000, + "epoch": 17142.954926950573, + "cumulative_step": 141000, + "metrics": {}, + "loss": 9.584860904965353e-09, + "training_seconds": 433.51628579199314, + "wall_seconds": 461.1320769377053, + "examples": 55148886, + "supervised_tokens": 330893316, + "executed_input_tokens": 1544168808, + "estimated_matmul_training_flops": 475935768562176, + "atomic_epochs": 17142.95556640625, + "composition_epochs": 17142.95380667237, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:30:52.580713+00:00" + }, + { + "step": 125000, + "epoch": 17857.15915449176, + "cumulative_step": 146000, + "metrics": {}, + "loss": 2.850133205356542e-05, + "training_seconds": 451.4154681712389, + "wall_seconds": 480.08118180930614, + "examples": 57446481, + "supervised_tokens": 344678886, + "executed_input_tokens": 1608501468, + "estimated_matmul_training_flops": 495764050173696, + "atomic_epochs": 17857.1484375, + "composition_epochs": 17857.177929854577, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:31:11.529874+00:00" + }, + { + "step": 126000, + "epoch": 18000, + "cumulative_step": 147000, + "metrics": {}, + "loss": 1.4620599358750042e-05, + "training_seconds": 455.0170771293342, + "wall_seconds": 483.9339472800493, + "examples": 57906000, + "supervised_tokens": 347436000, + "executed_input_tokens": 1621368000, + "estimated_matmul_training_flops": 499729706496000, + "atomic_epochs": 18000.0, + "composition_epochs": 18000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:31:15.382592+00:00" + }, + { + "step": 130000, + "epoch": 18571.477463475287, + "cumulative_step": 151000, + "metrics": {}, + "loss": 4.694033577834489e-06, + "training_seconds": 469.3704605028033, + "wall_seconds": 499.18029200285673, + "examples": 59744443, + "supervised_tokens": 358466658, + "executed_input_tokens": 1672844404, + "estimated_matmul_training_flops": 515595499001088, + "atomic_epochs": 18571.4677734375, + "composition_epochs": 18571.494439692044, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:31:30.628998+00:00" + }, + { + "step": 133000, + "epoch": 19000, + "cumulative_step": 154000, + "metrics": {}, + "loss": 8.088386493909638e-07, + "training_seconds": 480.2230742536485, + "wall_seconds": 510.68983022496104, + "examples": 61123000, + "supervised_tokens": 366738000, + "executed_input_tokens": 1711444000, + "estimated_matmul_training_flops": 527492467968000, + "atomic_epochs": 19000.0, + "composition_epochs": 19000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:31:42.138483+00:00" + }, + { + "step": 135000, + "epoch": 19285.795772458812, + "cumulative_step": 156000, + "metrics": {}, + "loss": 2.946855772734125e-07, + "training_seconds": 487.3946208246052, + "wall_seconds": 518.3541921526194, + "examples": 62042405, + "supervised_tokens": 372254430, + "executed_input_tokens": 1737187340, + "estimated_matmul_training_flops": 535426947828480, + "atomic_epochs": 19285.8056640625, + "composition_epochs": 19285.778443113773, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:31:49.802845+00:00" + }, + { + "step": 140000, + "epoch": 20000, + "cumulative_step": 161000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 1.4813846860306512e-07, + "knowledge_nll": 1.4662506941931497e-07, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.011363636363636364, + "answer_nll": 37.84402847290039, + "knowledge_nll": 37.84402847290039, + "identifier_accuracy": 0.011363636363636364, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.011363636363636364 + }, + "IO": { + "n": 891, + "accuracy": 0.001122334455667789, + "answer_nll": 43.6075439453125, + "knowledge_nll": 43.6075439453125, + "identifier_accuracy": 0.001122334455667789, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001122334455667789 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 37.610809326171875, + "knowledge_nll": 37.610809326171875, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.008169934640522876 + }, + "OO": { + "n": 544, + "accuracy": 0.009191176470588236, + "answer_nll": 43.57343673706055, + "knowledge_nll": 43.57343673706055, + "identifier_accuracy": 0.009191176470588236, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.009191176470588236 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 1.86309108585192e-07, + "knowledge_nll": 1.8528935186168383e-07, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": 3.137807524922209e-08, + "training_seconds": 505.58942491561174, + "wall_seconds": 537.7390483468771, + "examples": 64340000, + "supervised_tokens": 386040000, + "executed_input_tokens": 1801520000, + "estimated_matmul_training_flops": 555255229440000, + "atomic_epochs": 20000.0, + "composition_epochs": 20000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:32:09.187712+00:00" + }, + { + "step": 145000, + "epoch": 20714.318308983526, + "cumulative_step": 166000, + "metrics": {}, + "loss": 1.1602725891179944e-08, + "training_seconds": 523.5902910083532, + "wall_seconds": 556.829039953649, + "examples": 66637962, + "supervised_tokens": 399827772, + "executed_input_tokens": 1865862936, + "estimated_matmul_training_flops": 575086678267392, + "atomic_epochs": 20714.3125, + "composition_epochs": 20714.328485885373, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:32:28.277729+00:00" + }, + { + "step": 147000, + "epoch": 21000, + "cumulative_step": 168000, + "metrics": {}, + "loss": 2.938112993433606e-05, + "training_seconds": 530.7497923150659, + "wall_seconds": 564.429984536022, + "examples": 67557000, + "supervised_tokens": 405342000, + "executed_input_tokens": 1891596000, + "estimated_matmul_training_flops": 583017990912000, + "atomic_epochs": 21000.0, + "composition_epochs": 21000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:32:35.878629+00:00" + }, + { + "step": 150000, + "epoch": 21428.63661796705, + "cumulative_step": 171000, + "metrics": {}, + "loss": 6.174650479806587e-06, + "training_seconds": 541.6171121522784, + "wall_seconds": 576.0119983516634, + "examples": 68935924, + "supervised_tokens": 413615544, + "executed_input_tokens": 1930205872, + "estimated_matmul_training_flops": 594918127094784, + "atomic_epochs": 21428.638671875, + "composition_epochs": 21428.633019674937, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:32:47.460689+00:00" + }, + { + "step": 154000, + "epoch": 22000, + "cumulative_step": 175000, + "metrics": {}, + "loss": 8.910722499422263e-06, + "training_seconds": 555.9678464531898, + "wall_seconds": 591.212351873517, + "examples": 70774000, + "supervised_tokens": 424644000, + "executed_input_tokens": 1981672000, + "estimated_matmul_training_flops": 610780752384000, + "atomic_epochs": 22000.0, + "composition_epochs": 22000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:02.661013+00:00" + }, + { + "step": 155000, + "epoch": 22142.954926950573, + "cumulative_step": 176000, + "metrics": {}, + "loss": 5.851290552527644e-06, + "training_seconds": 559.6051389798522, + "wall_seconds": 595.143042486161, + "examples": 71233886, + "supervised_tokens": 427403316, + "executed_input_tokens": 1994548808, + "estimated_matmul_training_flops": 614749575922176, + "atomic_epochs": 22142.955078125, + "composition_epochs": 22142.954662104363, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:06.591684+00:00" + }, + { + "step": 160000, + "epoch": 22857.15915449176, + "cumulative_step": 181000, + "metrics": {}, + "loss": 3.240221815303812e-07, + "training_seconds": 577.5741915777326, + "wall_seconds": 614.1669875979424, + "examples": 73531481, + "supervised_tokens": 441188886, + "executed_input_tokens": 2058881468, + "estimated_matmul_training_flops": 634577857533696, + "atomic_epochs": 22857.15478515625, + "composition_epochs": 22857.166809238664, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:25.615669+00:00" + }, + { + "step": 161000, + "epoch": 23000, + "cumulative_step": 182000, + "metrics": {}, + "loss": 1.9018663977021788e-07, + "training_seconds": 581.1829258091748, + "wall_seconds": 618.0275330655277, + "examples": 73991000, + "supervised_tokens": 443946000, + "executed_input_tokens": 2071748000, + "estimated_matmul_training_flops": 638543513856000, + "atomic_epochs": 23000.0, + "composition_epochs": 23000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:29.476187+00:00" + }, + { + "step": 165000, + "epoch": 23571.477463475287, + "cumulative_step": 186000, + "metrics": {}, + "loss": 2.9569489967684603e-08, + "training_seconds": 595.6419005393982, + "wall_seconds": 633.3783296905458, + "examples": 75829443, + "supervised_tokens": 454976658, + "executed_input_tokens": 2123224404, + "estimated_matmul_training_flops": 654409306361088, + "atomic_epochs": 23571.48876953125, + "composition_epochs": 23571.457656116338, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:44.826975+00:00" + }, + { + "step": 168000, + "epoch": 24000, + "cumulative_step": 189000, + "metrics": {}, + "loss": 1.4387326885412222e-08, + "training_seconds": 606.474297977984, + "wall_seconds": 644.8695645183325, + "examples": 77208000, + "supervised_tokens": 463248000, + "executed_input_tokens": 2161824000, + "estimated_matmul_training_flops": 666306275328000, + "atomic_epochs": 24000.0, + "composition_epochs": 24000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:56.318207+00:00" + }, + { + "step": 170000, + "epoch": 24285.795772458812, + "cumulative_step": 191000, + "metrics": {}, + "loss": 1.8975695681433535e-08, + "training_seconds": 613.7222998924553, + "wall_seconds": 652.6043245010078, + "examples": 78127405, + "supervised_tokens": 468764430, + "executed_input_tokens": 2187567340, + "estimated_matmul_training_flops": 674240755188480, + "atomic_epochs": 24285.79248046875, + "composition_epochs": 24285.80153977759, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:04.053016+00:00" + }, + { + "step": 175000, + "epoch": 25000, + "cumulative_step": 196000, + "metrics": {}, + "loss": 7.0679548116459046e-06, + "training_seconds": 631.7009534910321, + "wall_seconds": 671.6353710182011, + "examples": 80425000, + "supervised_tokens": 482550000, + "executed_input_tokens": 2251900000, + "estimated_matmul_training_flops": 694069036800000, + "atomic_epochs": 25000.0, + "composition_epochs": 25000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:23.084028+00:00" + }, + { + "step": 180000, + "epoch": 25714.318308983526, + "cumulative_step": 201000, + "metrics": {}, + "loss": 6.0892557485203724e-06, + "training_seconds": 649.5825457386672, + "wall_seconds": 690.6040895096958, + "examples": 82722962, + "supervised_tokens": 496337772, + "executed_input_tokens": 2316242936, + "estimated_matmul_training_flops": 713900485627392, + "atomic_epochs": 25714.31689453125, + "composition_epochs": 25714.320786997432, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:42.052784+00:00" + }, + { + "step": 182000, + "epoch": 26000, + "cumulative_step": 203000, + "metrics": {}, + "loss": 1.967621301446343e-06, + "training_seconds": 656.9814022183418, + "wall_seconds": 698.4706454239786, + "examples": 83642000, + "supervised_tokens": 501852000, + "executed_input_tokens": 2341976000, + "estimated_matmul_training_flops": 721831798272000, + "atomic_epochs": 26000.0, + "composition_epochs": 26000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:49.919290+00:00" + }, + { + "step": 185000, + "epoch": 26428.63661796705, + "cumulative_step": 206000, + "metrics": {}, + "loss": 3.264669601321657e-07, + "training_seconds": 667.7979722619057, + "wall_seconds": 710.4265155494213, + "examples": 85020924, + "supervised_tokens": 510125544, + "executed_input_tokens": 2380585872, + "estimated_matmul_training_flops": 733731934454784, + "atomic_epochs": 26428.63623046875, + "composition_epochs": 26428.637296834902, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:01.875171+00:00" + }, + { + "step": 189000, + "epoch": 27000, + "cumulative_step": 210000, + "metrics": {}, + "loss": 5.069820119274482e-08, + "training_seconds": 682.27966125682, + "wall_seconds": 725.7714404501021, + "examples": 86859000, + "supervised_tokens": 521154000, + "executed_input_tokens": 2432052000, + "estimated_matmul_training_flops": 749594559744000, + "atomic_epochs": 27000.0, + "composition_epochs": 27000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:17.220131+00:00" + }, + { + "step": 190000, + "epoch": 27142.954926950573, + "cumulative_step": 211000, + "metrics": {}, + "loss": 3.399327042075129e-08, + "training_seconds": 685.881434071809, + "wall_seconds": 729.6590441167355, + "examples": 87318886, + "supervised_tokens": 523913316, + "executed_input_tokens": 2444928808, + "estimated_matmul_training_flops": 753563383282176, + "atomic_epochs": 27142.9580078125, + "composition_epochs": 27142.949529512403, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:21.107682+00:00" + }, + { + "step": 195000, + "epoch": 27857.15915449176, + "cumulative_step": 216000, + "metrics": {}, + "loss": 0.01813543401658535, + "training_seconds": 703.7588025145233, + "wall_seconds": 748.5899967625737, + "examples": 89616481, + "supervised_tokens": 537698886, + "executed_input_tokens": 2509261468, + "estimated_matmul_training_flops": 773391664893696, + "atomic_epochs": 27857.16455078125, + "composition_epochs": 27857.149700598802, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:40.038646+00:00" + }, + { + "step": 196000, + "epoch": 28000, + "cumulative_step": 217000, + "metrics": {}, + "loss": 2.2313713998300955e-05, + "training_seconds": 707.3443885818124, + "wall_seconds": 752.4187260568142, + "examples": 90076000, + "supervised_tokens": 540456000, + "executed_input_tokens": 2522128000, + "estimated_matmul_training_flops": 777357321216000, + "atomic_epochs": 28000.0, + "composition_epochs": 28000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:43.867416+00:00" + }, + { + "step": 200000, + "epoch": 28571.477463475287, + "cumulative_step": 221000, + "metrics": {}, + "loss": 2.3663108095206553e-06, + "training_seconds": 721.8592661321163, + "wall_seconds": 767.8375252708793, + "examples": 91914443, + "supervised_tokens": 551486658, + "executed_input_tokens": 2573604404, + "estimated_matmul_training_flops": 793223113721088, + "atomic_epochs": 28571.48095703125, + "composition_epochs": 28571.471343028228, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:59.286160+00:00" + }, + { + "step": 203000, + "epoch": 29000, + "cumulative_step": 224000, + "metrics": {}, + "loss": 5.881514880456962e-06, + "training_seconds": 732.5574479587376, + "wall_seconds": 779.1840962767601, + "examples": 93293000, + "supervised_tokens": 559758000, + "executed_input_tokens": 2612204000, + "estimated_matmul_training_flops": 805120082688000, + "atomic_epochs": 29000.0, + "composition_epochs": 29000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:10.632746+00:00" + }, + { + "step": 205000, + "epoch": 29285.795772458812, + "cumulative_step": 226000, + "metrics": {}, + "loss": 2.279697355334065e-06, + "training_seconds": 739.8119254410267, + "wall_seconds": 786.9303232170641, + "examples": 94212405, + "supervised_tokens": 565274430, + "executed_input_tokens": 2637947340, + "estimated_matmul_training_flops": 813054562548480, + "atomic_epochs": 29285.79736328125, + "composition_epochs": 29285.792985457658, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:18.378965+00:00" + }, + { + "step": 210000, + "epoch": 30000, + "cumulative_step": 231000, + "metrics": {}, + "loss": 1.449693769473015e-07, + "training_seconds": 757.7308904714882, + "wall_seconds": 805.8954870514572, + "examples": 96510000, + "supervised_tokens": 579060000, + "executed_input_tokens": 2702280000, + "estimated_matmul_training_flops": 832882844160000, + "atomic_epochs": 30000.0, + "composition_epochs": 30000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:37.344159+00:00" + }, + { + "step": 215000, + "epoch": 30714.318308983526, + "cumulative_step": 236000, + "metrics": {}, + "loss": 1.8238399235315228e-08, + "training_seconds": 775.8299869410694, + "wall_seconds": 825.0864914543927, + "examples": 98807962, + "supervised_tokens": 592847772, + "executed_input_tokens": 2766622936, + "estimated_matmul_training_flops": 852714292987392, + "atomic_epochs": 30714.3251953125, + "composition_epochs": 30714.30624465355, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:56.535186+00:00" + }, + { + "step": 217000, + "epoch": 31000, + "cumulative_step": 238000, + "metrics": {}, + "loss": 1.5209460357823446e-08, + "training_seconds": 783.0605078190565, + "wall_seconds": 832.7700171098113, + "examples": 99727000, + "supervised_tokens": 598362000, + "executed_input_tokens": 2792356000, + "estimated_matmul_training_flops": 860645605632000, + "atomic_epochs": 31000.0, + "composition_epochs": 31000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:04.218664+00:00" + }, + { + "step": 220000, + "epoch": 31428.63661796705, + "cumulative_step": 241000, + "metrics": {}, + "loss": 5.8991314290324226e-05, + "training_seconds": 793.8948691561818, + "wall_seconds": 844.3030840978026, + "examples": 101105924, + "supervised_tokens": 606635544, + "executed_input_tokens": 2830965872, + "estimated_matmul_training_flops": 872545741814784, + "atomic_epochs": 31428.63232421875, + "composition_epochs": 31428.644140290846, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:15.751757+00:00" + }, + { + "step": 224000, + "epoch": 32000, + "cumulative_step": 245000, + "metrics": {}, + "loss": 4.703620106738526e-06, + "training_seconds": 808.2879547402263, + "wall_seconds": 859.5537835434079, + "examples": 102944000, + "supervised_tokens": 617664000, + "executed_input_tokens": 2882432000, + "estimated_matmul_training_flops": 888408367104000, + "atomic_epochs": 32000.0, + "composition_epochs": 32000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:31.002432+00:00" + }, + { + "step": 225000, + "epoch": 32142.954926950573, + "cumulative_step": 246000, + "metrics": {}, + "loss": 2.369962658121949e-06, + "training_seconds": 811.917763993144, + "wall_seconds": 863.4689830802381, + "examples": 103403886, + "supervised_tokens": 620423316, + "executed_input_tokens": 2895308808, + "estimated_matmul_training_flops": 892377190642176, + "atomic_epochs": 32142.958984375, + "composition_epochs": 32142.947818648416, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:34.917687+00:00" + }, + { + "step": 230000, + "epoch": 32857.15915449176, + "cumulative_step": 251000, + "metrics": {}, + "loss": 1.4846831675185967e-07, + "training_seconds": 829.8859561532736, + "wall_seconds": 882.898520346731, + "examples": 105701481, + "supervised_tokens": 634208886, + "executed_input_tokens": 2959641468, + "estimated_matmul_training_flops": 912205472253696, + "atomic_epochs": 32857.158203125, + "composition_epochs": 32857.16082121471, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:54.347186+00:00" + }, + { + "step": 231000, + "epoch": 33000, + "cumulative_step": 252000, + "metrics": {}, + "loss": 8.673502804867894e-08, + "training_seconds": 833.4827701933682, + "wall_seconds": 886.7498973496258, + "examples": 106161000, + "supervised_tokens": 636966000, + "executed_input_tokens": 2972508000, + "estimated_matmul_training_flops": 916171128576000, + "atomic_epochs": 33000.0, + "composition_epochs": 33000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:58.198556+00:00" + }, + { + "step": 235000, + "epoch": 33571.47746347529, + "cumulative_step": 256000, + "metrics": {}, + "loss": 2.448602032245617e-08, + "training_seconds": 847.9945580214262, + "wall_seconds": 902.1604494079947, + "examples": 107999443, + "supervised_tokens": 647996658, + "executed_input_tokens": 3023984404, + "estimated_matmul_training_flops": 932036921081088, + "atomic_epochs": 33571.48681640625, + "composition_epochs": 33571.46107784431, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:13.609133+00:00" + }, + { + "step": 238000, + "epoch": 34000, + "cumulative_step": 259000, + "metrics": {}, + "loss": 1.8772034593439457e-08, + "training_seconds": 858.6891011036932, + "wall_seconds": 913.5044457241893, + "examples": 109378000, + "supervised_tokens": 656268000, + "executed_input_tokens": 3062584000, + "estimated_matmul_training_flops": 943933890048000, + "atomic_epochs": 34000.0, + "composition_epochs": 34000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:24.953097+00:00" + }, + { + "step": 240000, + "epoch": 34285.79577245881, + "cumulative_step": 261000, + "metrics": {}, + "loss": 3.844625462079421e-05, + "training_seconds": 865.8577072434127, + "wall_seconds": 921.1777039803565, + "examples": 110297405, + "supervised_tokens": 661784430, + "executed_input_tokens": 3088327340, + "estimated_matmul_training_flops": 951868369908480, + "atomic_epochs": 34285.7919921875, + "composition_epochs": 34285.80239520958, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:32.626352+00:00" + }, + { + "step": 245000, + "epoch": 35000, + "cumulative_step": 266000, + "metrics": {}, + "loss": 2.2318004084809218e-06, + "training_seconds": 883.7340582869947, + "wall_seconds": 940.1041540615261, + "examples": 112595000, + "supervised_tokens": 675570000, + "executed_input_tokens": 3152660000, + "estimated_matmul_training_flops": 971696651520000, + "atomic_epochs": 35000.0, + "composition_epochs": 35000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:51.552857+00:00" + }, + { + "step": 250000, + "epoch": 35714.31830898352, + "cumulative_step": 271000, + "metrics": {}, + "loss": 1.2894935252916184e-07, + "training_seconds": 901.7590992152691, + "wall_seconds": 959.2255833745003, + "examples": 114892962, + "supervised_tokens": 689357772, + "executed_input_tokens": 3217002936, + "estimated_matmul_training_flops": 991528100347392, + "atomic_epochs": 35714.31298828125, + "composition_epochs": 35714.32763045338, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:10.674231+00:00" + }, + { + "step": 252000, + "epoch": 36000, + "cumulative_step": 273000, + "metrics": {}, + "loss": 5.0424155517703184e-08, + "training_seconds": 908.8922821171582, + "wall_seconds": 966.8092257939279, + "examples": 115812000, + "supervised_tokens": 694872000, + "executed_input_tokens": 3242736000, + "estimated_matmul_training_flops": 999459412992000, + "atomic_epochs": 36000.0, + "composition_epochs": 36000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:18.257878+00:00" + }, + { + "step": 255000, + "epoch": 36428.63661796705, + "cumulative_step": 276000, + "metrics": {}, + "loss": 1.84324253638124e-08, + "training_seconds": 919.7075017169118, + "wall_seconds": 978.7687387689948, + "examples": 117190924, + "supervised_tokens": 703145544, + "executed_input_tokens": 3281345872, + "estimated_matmul_training_flops": 1011359549174784, + "atomic_epochs": 36428.62841796875, + "composition_epochs": 36428.65098374679, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:30.217418+00:00" + }, + { + "step": 259000, + "epoch": 37000, + "cumulative_step": 280000, + "metrics": {}, + "loss": 0.017420092597603798, + "training_seconds": 934.0509933643043, + "wall_seconds": 993.9609804823995, + "examples": 119029000, + "supervised_tokens": 714174000, + "executed_input_tokens": 3332812000, + "estimated_matmul_training_flops": 1027222174464000, + "atomic_epochs": 37000.0, + "composition_epochs": 37000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:45.409636+00:00" + }, + { + "step": 260000, + "epoch": 37142.95492695057, + "cumulative_step": 281000, + "metrics": {}, + "loss": 3.763721906580031e-05, + "training_seconds": 937.6751291975379, + "wall_seconds": 997.8708658479154, + "examples": 119488886, + "supervised_tokens": 716933316, + "executed_input_tokens": 3345688808, + "estimated_matmul_training_flops": 1031190998002176, + "atomic_epochs": 37142.94970703125, + "composition_epochs": 37142.96407185629, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:49.319502+00:00" + }, + { + "step": 265000, + "epoch": 37857.15915449176, + "cumulative_step": 286000, + "metrics": {}, + "loss": 2.5195565740432357e-06, + "training_seconds": 955.5788963809609, + "wall_seconds": 1016.8323783352971, + "examples": 121786481, + "supervised_tokens": 730718886, + "executed_input_tokens": 3410021468, + "estimated_matmul_training_flops": 1051019279613696, + "atomic_epochs": 37857.16455078125, + "composition_epochs": 37857.149700598806, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:08.281058+00:00" + }, + { + "step": 266000, + "epoch": 38000, + "cumulative_step": 287000, + "metrics": {}, + "loss": 1.4565375749953091e-06, + "training_seconds": 959.2221479527652, + "wall_seconds": 1020.7267675288022, + "examples": 122246000, + "supervised_tokens": 733476000, + "executed_input_tokens": 3422888000, + "estimated_matmul_training_flops": 1054984935936000, + "atomic_epochs": 38000.0, + "composition_epochs": 38000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:12.175433+00:00" + }, + { + "step": 270000, + "epoch": 38571.47746347529, + "cumulative_step": 291000, + "metrics": {}, + "loss": 1.5386221718927118e-07, + "training_seconds": 973.4581175409257, + "wall_seconds": 1035.8579750098288, + "examples": 124084443, + "supervised_tokens": 744506658, + "executed_input_tokens": 3474364404, + "estimated_matmul_training_flops": 1070850728441088, + "atomic_epochs": 38571.4697265625, + "composition_epochs": 38571.49101796407, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:27.306635+00:00" + }, + { + "step": 273000, + "epoch": 39000, + "cumulative_step": 294000, + "metrics": {}, + "loss": 3.6447893592139735e-08, + "training_seconds": 984.1772943623364, + "wall_seconds": 1047.7411427386105, + "examples": 125463000, + "supervised_tokens": 752778000, + "executed_input_tokens": 3512964000, + "estimated_matmul_training_flops": 1082747697408000, + "atomic_epochs": 39000.0, + "composition_epochs": 39000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:39.189847+00:00" + }, + { + "step": 275000, + "epoch": 39285.79577245881, + "cumulative_step": 296000, + "metrics": {}, + "loss": 1.9829409225735617e-08, + "training_seconds": 991.2967338226736, + "wall_seconds": 1055.336072023958, + "examples": 126382405, + "supervised_tokens": 758294430, + "executed_input_tokens": 3538707340, + "estimated_matmul_training_flops": 1090682177268480, + "atomic_epochs": 39285.7939453125, + "composition_epochs": 39285.79897348161, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:46.784720+00:00" + }, + { + "step": 280000, + "epoch": 40000, + "cumulative_step": 301000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0004575219645630568, + "knowledge_nll": 0.0004546176642179489, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004955988842993975, + "knowledge_nll": 0.0004946840927004814, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.269193433758 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004194450448267162, + "knowledge_nll": 0.00041455120663158596, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.387575326718 + }, + "II": { + "n": 880, + "accuracy": 0.005681818181818182, + "answer_nll": 32.82706832885742, + "knowledge_nll": 32.827064514160156, + "identifier_accuracy": 0.005681818181818182, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.005681818181818182 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 38.12151336669922, + "knowledge_nll": 38.12150192260742, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.014705882352941176, + "answer_nll": 33.14290237426758, + "knowledge_nll": 33.14289855957031, + "identifier_accuracy": 0.014705882352941176, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.014705882352941176 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 39.64762878417969, + "knowledge_nll": 39.64761734008789, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0005104398587718606, + "knowledge_nll": 0.0005056438967585564, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16382.656768717481, + "learned_bits_per_parameter": 0.1590919900629028 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 7.611632463522255e-05, + "training_seconds": 1009.3053239621222, + "wall_seconds": 1074.856882944703, + "examples": 128680000, + "supervised_tokens": 772080000, + "executed_input_tokens": 3603040000, + "estimated_matmul_training_flops": 1110510458880000, + "atomic_epochs": 40000.0, + "composition_epochs": 40000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:41:06.305564+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/preflight.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/run.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/run.json new file mode 100644 index 0000000000000000000000000000000000000000..47744f948066acfdfbc0dde4d283b1f52a80fc49 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/run.json @@ -0,0 +1,194 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 40000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 1000, + 3000, + 10000, + 20000, + 40000 + ], + "checkpoint_epochs": 1000, + "log_steps": 5000, + "max_wall_seconds": 7200, + "name": "continuation-wd0.01", + "training_mode": "mixed", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "parent_checkpoint_sha256": "acce1dcffba24adaa1567f194e127e2c93c0e5db167b0c0cd1ed6a282461e706" + }, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "initial_model_sha256": "bd597539c1fbbcc5e70056dd44333b039a58ac87c638b60cbb858671e48e7dac", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 2048, + "composition_examples": 1169, + "evaluation_nodes": [ + 0, + 1000, + 3000, + 10000, + 20000, + 40000 + ], + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 21000, + "parent_examples": 9651000, + "training_mode": "mixed", + "created_utc": "2026-10-05T23:23:11.400395+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/status.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/status.json new file mode 100644 index 0000000000000000000000000000000000000000..1f01386bef488be4ded6211494413d7dd4c5f596 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 280000 +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/trained.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..7867dbb3760a9e744dfaf16c3f2c3a4b0ce538f3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "4a1264c790415c4162c6396f7c02214e95016f49c8f2e610ffafa4b4e02fc99c", + "epochs": 40000, + "step": 280000, + "training_pid": 44, + "created_utc": "2026-10-05T23:41:06.404302+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.01/worker.log b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..5b6df1c1970559bba266e09c98213f4c706840b6 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.01/worker.log @@ -0,0 +1,89 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 8.8009969090308e-08, "knowledge_nll": 7.258493894823914e-08, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.006818181818181818, "answer_nll": 30.207937240600586, "knowledge_nll": 30.207937240600586, "identifier_accuracy": 0.006818181818181818, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.006818181818181818}, "IO": {"n": 891, "accuracy": 0.001122334455667789, "answer_nll": 34.36986541748047, "knowledge_nll": 34.36986541748047, "identifier_accuracy": 0.001122334455667789, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.001122334455667789}, "OI": {"n": 612, "accuracy": 0.006535947712418301, "answer_nll": 30.35199737548828, "knowledge_nll": 30.35199737548828, "identifier_accuracy": 0.006535947712418301, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.006535947712418301}, "OO": {"n": 544, "accuracy": 0.003676470588235294, "answer_nll": 33.45905685424805, "knowledge_nll": 33.45905685424805, "identifier_accuracy": 0.003676470588235294, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.003676470588235294}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 7.617563824169338e-08, "knowledge_nll": 6.924130957486341e-08, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 5000, "epoch": 714.3183089835251, "metrics": {}} +{"step": 7000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.00020045881683472544, "knowledge_nll": 0.00019912247080355883, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.003409090909090909, "answer_nll": 31.917436599731445, "knowledge_nll": 31.917272567749023, "identifier_accuracy": 0.003409090909090909, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.003409090909090909}, "IO": {"n": 891, "accuracy": 0.004489337822671156, "answer_nll": 37.40656661987305, "knowledge_nll": 37.39752197265625, "identifier_accuracy": 0.004489337822671156, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.004489337822671156}, "OI": {"n": 612, "accuracy": 0.013071895424836602, "answer_nll": 31.785625457763672, "knowledge_nll": 31.785615921020508, "identifier_accuracy": 0.013071895424836602, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.013071895424836602}, "OO": {"n": 544, "accuracy": 0.003676470588235294, "answer_nll": 37.1727294921875, "knowledge_nll": 37.17271423339844, "identifier_accuracy": 0.003676470588235294, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.003676470588235294}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 0.00010688521433621645, "knowledge_nll": 0.00010633812780724838, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 10000, "epoch": 1428.6366179670501, "metrics": {}} +{"step": 14000, "epoch": 2000, "metrics": {}} +{"step": 15000, "epoch": 2142.954926950575, "metrics": {}} +{"step": 20000, "epoch": 2857.1591544917624, "metrics": {}} +{"step": 21000, "epoch": 3000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 1.6420378301518213e-07, "knowledge_nll": 1.628067991532589e-07, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.007954545454545454, "answer_nll": 39.5360221862793, "knowledge_nll": 39.5360221862793, "identifier_accuracy": 0.007954545454545454, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.007954545454545454}, "IO": {"n": 891, "accuracy": 0.002244668911335578, "answer_nll": 45.238189697265625, "knowledge_nll": 45.238189697265625, "identifier_accuracy": 0.002244668911335578, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.002244668911335578}, "OI": {"n": 612, "accuracy": 0.014705882352941176, "answer_nll": 38.63783645629883, "knowledge_nll": 38.63783645629883, "identifier_accuracy": 0.014705882352941176, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.014705882352941176}, "OO": {"n": 544, "accuracy": 0.0055147058823529415, "answer_nll": 45.03076934814453, "knowledge_nll": 45.03076934814453, "identifier_accuracy": 0.0055147058823529415, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0055147058823529415}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 9.595887462410246e-08, "knowledge_nll": 9.524504918090315e-08, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 25000, "epoch": 3571.4774634752875, "metrics": {}} +{"step": 28000, "epoch": 4000, "metrics": {}} +{"step": 30000, "epoch": 4285.795772458812, "metrics": {}} +{"step": 35000, "epoch": 5000, "metrics": {}} +{"step": 40000, "epoch": 5714.318308983525, "metrics": {}} +{"step": 42000, "epoch": 6000, "metrics": {}} +{"step": 45000, "epoch": 6428.63661796705, "metrics": {}} +{"step": 49000, "epoch": 7000, "metrics": {}} +{"step": 50000, "epoch": 7142.954926950575, "metrics": {}} +{"step": 55000, "epoch": 7857.159154491763, "metrics": {}} +{"step": 56000, "epoch": 8000, "metrics": {}} +{"step": 60000, "epoch": 8571.477463475287, "metrics": {}} +{"step": 63000, "epoch": 9000, "metrics": {}} +{"step": 65000, "epoch": 9285.795772458812, "metrics": {}} +{"step": 70000, "epoch": 10000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 9.839333506533876e-05, "knowledge_nll": 9.815870726015419e-05, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.013636363636363636, "answer_nll": 33.61827850341797, "knowledge_nll": 33.61827850341797, "identifier_accuracy": 0.013636363636363636, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.013636363636363636}, "IO": {"n": 891, "accuracy": 0.005611672278338945, "answer_nll": 40.480323791503906, "knowledge_nll": 40.480323791503906, "identifier_accuracy": 0.005611672278338945, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.005611672278338945}, "OI": {"n": 612, "accuracy": 0.00980392156862745, "answer_nll": 35.21614456176758, "knowledge_nll": 35.21614456176758, "identifier_accuracy": 0.00980392156862745, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.00980392156862745}, "OO": {"n": 544, "accuracy": 0.007352941176470588, "answer_nll": 40.36122512817383, "knowledge_nll": 40.36122131347656, "identifier_accuracy": 0.007352941176470588, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.007352941176470588}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 0.00011695209832396358, "knowledge_nll": 0.00011677294241962954, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 75000, "epoch": 10714.318308983526, "metrics": {}} +{"step": 77000, "epoch": 11000, "metrics": {}} +{"step": 80000, "epoch": 11428.63661796705, "metrics": {}} +{"step": 84000, "epoch": 12000, "metrics": {}} +{"step": 85000, "epoch": 12142.954926950575, "metrics": {}} +{"step": 90000, "epoch": 12857.159154491763, "metrics": {}} +{"step": 91000, "epoch": 13000, "metrics": {}} +{"step": 95000, "epoch": 13571.477463475287, "metrics": {}} +{"step": 98000, "epoch": 14000, "metrics": {}} +{"step": 100000, "epoch": 14285.795772458812, "metrics": {}} +{"step": 105000, "epoch": 15000, "metrics": {}} +{"step": 110000, "epoch": 15714.318308983526, "metrics": {}} +{"step": 112000, "epoch": 16000, "metrics": {}} +{"step": 115000, "epoch": 16428.63661796705, "metrics": {}} +{"step": 119000, "epoch": 17000, "metrics": {}} +{"step": 120000, "epoch": 17142.954926950573, "metrics": {}} +{"step": 125000, "epoch": 17857.15915449176, "metrics": {}} +{"step": 126000, "epoch": 18000, "metrics": {}} +{"step": 130000, "epoch": 18571.477463475287, "metrics": {}} +{"step": 133000, "epoch": 19000, "metrics": {}} +{"step": 135000, "epoch": 19285.795772458812, "metrics": {}} +{"step": 140000, "epoch": 20000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 1.4813846860306512e-07, "knowledge_nll": 1.4662506941931497e-07, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.011363636363636364, "answer_nll": 37.84402847290039, "knowledge_nll": 37.84402847290039, "identifier_accuracy": 0.011363636363636364, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.011363636363636364}, "IO": {"n": 891, "accuracy": 0.001122334455667789, "answer_nll": 43.6075439453125, "knowledge_nll": 43.6075439453125, "identifier_accuracy": 0.001122334455667789, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.001122334455667789}, "OI": {"n": 612, "accuracy": 0.008169934640522876, "answer_nll": 37.610809326171875, "knowledge_nll": 37.610809326171875, "identifier_accuracy": 0.008169934640522876, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.008169934640522876}, "OO": {"n": 544, "accuracy": 0.009191176470588236, "answer_nll": 43.57343673706055, "knowledge_nll": 43.57343673706055, "identifier_accuracy": 0.009191176470588236, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.009191176470588236}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 1.86309108585192e-07, "knowledge_nll": 1.8528935186168383e-07, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 145000, "epoch": 20714.318308983526, "metrics": {}} +{"step": 147000, "epoch": 21000, "metrics": {}} +{"step": 150000, "epoch": 21428.63661796705, "metrics": {}} +{"step": 154000, "epoch": 22000, "metrics": {}} +{"step": 155000, "epoch": 22142.954926950573, "metrics": {}} +{"step": 160000, "epoch": 22857.15915449176, "metrics": {}} +{"step": 161000, "epoch": 23000, "metrics": {}} +{"step": 165000, "epoch": 23571.477463475287, "metrics": {}} +{"step": 168000, "epoch": 24000, "metrics": {}} +{"step": 170000, "epoch": 24285.795772458812, "metrics": {}} +{"step": 175000, "epoch": 25000, "metrics": {}} +{"step": 180000, "epoch": 25714.318308983526, "metrics": {}} +{"step": 182000, "epoch": 26000, "metrics": {}} +{"step": 185000, "epoch": 26428.63661796705, "metrics": {}} +{"step": 189000, "epoch": 27000, "metrics": {}} +{"step": 190000, "epoch": 27142.954926950573, "metrics": {}} +{"step": 195000, "epoch": 27857.15915449176, "metrics": {}} +{"step": 196000, "epoch": 28000, "metrics": {}} +{"step": 200000, "epoch": 28571.477463475287, "metrics": {}} +{"step": 203000, "epoch": 29000, "metrics": {}} +{"step": 205000, "epoch": 29285.795772458812, "metrics": {}} +{"step": 210000, "epoch": 30000, "metrics": {}} +{"step": 215000, "epoch": 30714.318308983526, "metrics": {}} +{"step": 217000, "epoch": 31000, "metrics": {}} +{"step": 220000, "epoch": 31428.63661796705, "metrics": {}} +{"step": 224000, "epoch": 32000, "metrics": {}} +{"step": 225000, "epoch": 32142.954926950573, "metrics": {}} +{"step": 230000, "epoch": 32857.15915449176, "metrics": {}} +{"step": 231000, "epoch": 33000, "metrics": {}} +{"step": 235000, "epoch": 33571.47746347529, "metrics": {}} +{"step": 238000, "epoch": 34000, "metrics": {}} +{"step": 240000, "epoch": 34285.79577245881, "metrics": {}} +{"step": 245000, "epoch": 35000, "metrics": {}} +{"step": 250000, "epoch": 35714.31830898352, "metrics": {}} +{"step": 252000, "epoch": 36000, "metrics": {}} +{"step": 255000, "epoch": 36428.63661796705, "metrics": {}} +{"step": 259000, "epoch": 37000, "metrics": {}} +{"step": 260000, "epoch": 37142.95492695057, "metrics": {}} +{"step": 265000, "epoch": 37857.15915449176, "metrics": {}} +{"step": 266000, "epoch": 38000, "metrics": {}} +{"step": 270000, "epoch": 38571.47746347529, "metrics": {}} +{"step": 273000, "epoch": 39000, "metrics": {}} +{"step": 275000, "epoch": 39285.79577245881, "metrics": {}} +{"step": 280000, "epoch": 40000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.0004575219645630568, "knowledge_nll": 0.0004546176642179489, "identifier_accuracy": 1.0, "full_population": true}, "atomic_first": {"n": 1024, "accuracy": 1.0, "answer_nll": 0.0004955988842993975, "knowledge_nll": 0.0004946840927004814, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.269193433758}, "atomic_second": {"n": 1024, "accuracy": 1.0, "answer_nll": 0.0004194450448267162, "knowledge_nll": 0.00041455120663158596, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.387575326718}, "II": {"n": 880, "accuracy": 0.005681818181818182, "answer_nll": 32.82706832885742, "knowledge_nll": 32.827064514160156, "identifier_accuracy": 0.005681818181818182, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.005681818181818182}, "IO": {"n": 891, "accuracy": 0.004489337822671156, "answer_nll": 38.12151336669922, "knowledge_nll": 38.12150192260742, "identifier_accuracy": 0.004489337822671156, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.004489337822671156}, "OI": {"n": 612, "accuracy": 0.014705882352941176, "answer_nll": 33.14290237426758, "knowledge_nll": 33.14289855957031, "identifier_accuracy": 0.014705882352941176, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.014705882352941176}, "OO": {"n": 544, "accuracy": 0.007352941176470588, "answer_nll": 39.64762878417969, "knowledge_nll": 39.64761734008789, "identifier_accuracy": 0.007352941176470588, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.007352941176470588}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 0.0005104398587718606, "knowledge_nll": 0.0005056438967585564, "identifier_accuracy": 1.0, "population_n": 1169}, "information": {"independent_facts": 2048, "world_bits": 16384.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 0.15910503418272218, "composition_independent_bits": 0, "learned_bits_raw": 16382.656768717481, "learned_bits_per_parameter": 0.1590919900629028}, "serial_II": {"n": 880, "accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 880, "accuracy": 0.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 880, "accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 891, "accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 891, "accuracy": 0.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 891, "accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 612, "accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 612, "accuracy": 0.006535947712418301, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.006535947712418301, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 612, "accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 544, "accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 544, "accuracy": 0.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 544, "accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/audit.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..2893725973791a5b91f7b51e0204a521bd2a4a2a --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/audit.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00023144441365730017, + "knowledge_nll": 0.00022873673879075795, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000221588445128873, + "knowledge_nll": 0.00021811686747241765, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.67777165001 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00024130038218572736, + "knowledge_nll": 0.00023935661010909826, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.646393759326 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 28.51885223388672, + "knowledge_nll": 28.51885223388672, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 32.9504508972168, + "knowledge_nll": 32.9504508972168, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 29.162445068359375, + "knowledge_nll": 29.162445068359375, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.008169934640522876 + }, + "OO": { + "n": 544, + "accuracy": 0.0055147058823529415, + "answer_nll": 34.03778076171875, + "knowledge_nll": 34.03778076171875, + "identifier_accuracy": 0.0055147058823529415, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0055147058823529415 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0002445103309582919, + "knowledge_nll": 0.00024392938939854503, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.324165409336, + "learned_bits_per_parameter": 0.1590984711525922 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 128680000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:50:14.077153+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/complete.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..2893725973791a5b91f7b51e0204a521bd2a4a2a --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/complete.json @@ -0,0 +1,239 @@ +{ + "passed": true, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "max_nll_difference": 0.0, + "prediction_arrays": 49, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00023144441365730017, + "knowledge_nll": 0.00022873673879075795, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000221588445128873, + "knowledge_nll": 0.00021811686747241765, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.67777165001 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00024130038218572736, + "knowledge_nll": 0.00023935661010909826, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.646393759326 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 28.51885223388672, + "knowledge_nll": 28.51885223388672, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 32.9504508972168, + "knowledge_nll": 32.9504508972168, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 29.162445068359375, + "knowledge_nll": 29.162445068359375, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.008169934640522876 + }, + "OO": { + "n": 544, + "accuracy": 0.0055147058823529415, + "answer_nll": 34.03778076171875, + "knowledge_nll": 34.03778076171875, + "identifier_accuracy": 0.0055147058823529415, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0055147058823529415 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0002445103309582919, + "knowledge_nll": 0.00024392938939854503, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.324165409336, + "learned_bits_per_parameter": 0.1590984711525922 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "examples": 128680000, + "training_pid": 44, + "audit_pid": 49, + "separate_process": true, + "created_utc": "2026-10-05T23:50:14.077153+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-command-1.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..3ee8e1aa3d1c9122ea62d4ee4673b97e45974e9f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-2c03f374ae28bf5649f4", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-2c03f374ae28bf5649f4", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.1,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.1", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "continuation-wd0.1" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-inspect.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..79ee6f65c7924f64214db59e93e1cdbf3316a343 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1", + "Created": "2026-10-05T23:32:32.140503806Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "continuation-wd0.1" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:32:32.155386395Z", + "FinishedAt": "2026-10-05T23:50:14.639387792Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1/4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1-json.log", + "Name": "/lm-capctrl-2c03f374ae28bf5649f4", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.1", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.1" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/3b8b5e3bb91534a8e43083aea47e030d82993142db5c64236b6685bec5f1ea53-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/3b8b5e3bb91534a8e43083aea47e030d82993142db5c64236b6685bec5f1ea53/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/3b8b5e3bb91534a8e43083aea47e030d82993142db5c64236b6685bec5f1ea53/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/3b8b5e3bb91534a8e43083aea47e030d82993142db5c64236b6685bec5f1ea53/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.1", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/continuation-wd0.1", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "4f0ba6d1e1b8", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PHYSICAL_GPU=0", + "OMP_NUM_THREADS=4", + "MKL_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "PYTHONDONTWRITEBYTECODE=1", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "continuation-wd0.1" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-runtime.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..bf9ff0da2e119ac7827bb9cb7e5f5787196a8c23 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 347893, + "container_id": "4f0ba6d1e1b8bd35b9c4cdb34e3a98f1b09332bc8d13cfd4793313f87b7dcfd1", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/learning.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..e20813dd635761468bf56bc42f2ac42cee561bb0 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/learning.json @@ -0,0 +1,2176 @@ +[ + { + "step": 0, + "epoch": 0, + "cumulative_step": 21000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 8.8009969090308e-08, + "knowledge_nll": 7.258493894823914e-08, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 30.207937240600586, + "knowledge_nll": 30.207937240600586, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.001122334455667789, + "answer_nll": 34.36986541748047, + "knowledge_nll": 34.36986541748047, + "identifier_accuracy": 0.001122334455667789, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001122334455667789 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 30.35199737548828, + "knowledge_nll": 30.35199737548828, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 33.45905685424805, + "knowledge_nll": 33.45905685424805, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003676470588235294 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.617563824169338e-08, + "knowledge_nll": 6.924130957486341e-08, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": null, + "training_seconds": 0.0, + "wall_seconds": 0.34207700565457344, + "examples": 0, + "supervised_tokens": 0, + "executed_input_tokens": 0, + "estimated_matmul_training_flops": 0, + "atomic_epochs": 0.0, + "composition_epochs": 0.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 86453760, + "created_utc": "2026-10-05T23:32:37.961902+00:00" + }, + { + "step": 5000, + "epoch": 714.3183089835251, + "cumulative_step": 26000, + "metrics": {}, + "loss": 0.0003224336542189121, + "training_seconds": 17.780135456472635, + "wall_seconds": 19.218876991420984, + "examples": 2297962, + "supervised_tokens": 13787772, + "executed_input_tokens": 64342936, + "estimated_matmul_training_flops": 19831448827392, + "atomic_epochs": 714.31640625, + "composition_epochs": 714.3216424294269, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:32:56.838851+00:00" + }, + { + "step": 7000, + "epoch": 1000, + "cumulative_step": 28000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.8359375, + "answer_nll": 0.5615983009338379, + "knowledge_nll": 0.561251163482666, + "identifier_accuracy": 0.8359375, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.007954545454545454, + "answer_nll": 14.075479507446289, + "knowledge_nll": 14.075122833251953, + "identifier_accuracy": 0.007954545454545454, + "population_n": 880, + "first_atomic_accuracy": 0.8522727272727273, + "second_atomic_accuracy": 0.8363636363636363, + "both_atomic_n": 625, + "both_atomic_coverage": 0.7102272727272727, + "both_atomic_composition_accuracy": 0.008 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 17.10542106628418, + "knowledge_nll": 17.105072021484375, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.8395061728395061, + "second_atomic_accuracy": 0.8327721661054994, + "both_atomic_n": 622, + "both_atomic_coverage": 0.6980920314253648, + "both_atomic_composition_accuracy": 0.001607717041800643 + }, + "OI": { + "n": 612, + "accuracy": 0.00980392156862745, + "answer_nll": 14.615715980529785, + "knowledge_nll": 14.615387916564941, + "identifier_accuracy": 0.00980392156862745, + "population_n": 612, + "first_atomic_accuracy": 0.8349673202614379, + "second_atomic_accuracy": 0.8349673202614379, + "both_atomic_n": 423, + "both_atomic_coverage": 0.6911764705882353, + "both_atomic_composition_accuracy": 0.009456264775413711 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 16.885244369506836, + "knowledge_nll": 16.88490867614746, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 0.8915441176470589, + "second_atomic_accuracy": 0.8106617647058824, + "both_atomic_n": 394, + "both_atomic_coverage": 0.7242647058823529, + "both_atomic_composition_accuracy": 0.005076142131979695 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.8100940975192472, + "answer_nll": 0.6056006550788879, + "knowledge_nll": 0.6053181886672974, + "identifier_accuracy": 0.8100940975192472, + "population_n": 1169 + } + }, + "loss": 0.11997377872467041, + "training_seconds": 24.721020977944136, + "wall_seconds": 26.743276841938496, + "examples": 3217000, + "supervised_tokens": 19302000, + "executed_input_tokens": 90076000, + "estimated_matmul_training_flops": 27762761472000, + "atomic_epochs": 1000.0, + "composition_epochs": 1000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:04.363117+00:00" + }, + { + "step": 10000, + "epoch": 1428.6366179670501, + "cumulative_step": 31000, + "metrics": {}, + "loss": 0.0001549747830722481, + "training_seconds": 35.09229414537549, + "wall_seconds": 37.80427277088165, + "examples": 4595924, + "supervised_tokens": 27575544, + "executed_input_tokens": 128685872, + "estimated_matmul_training_flops": 39662897654784, + "atomic_epochs": 1428.6259765625, + "composition_epochs": 1428.6552609067578, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:15.424119+00:00" + }, + { + "step": 14000, + "epoch": 2000, + "cumulative_step": 35000, + "metrics": {}, + "loss": 0.00024624672369100153, + "training_seconds": 49.05861047282815, + "wall_seconds": 52.61897869408131, + "examples": 6434000, + "supervised_tokens": 38604000, + "executed_input_tokens": 180152000, + "estimated_matmul_training_flops": 55525522944000, + "atomic_epochs": 2000.0, + "composition_epochs": 2000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:30.238816+00:00" + }, + { + "step": 15000, + "epoch": 2142.954926950575, + "cumulative_step": 36000, + "metrics": {}, + "loss": 0.0003312370681669563, + "training_seconds": 52.55662437155843, + "wall_seconds": 56.416925862431526, + "examples": 6893886, + "supervised_tokens": 41363316, + "executed_input_tokens": 193028808, + "estimated_matmul_training_flops": 59494346482176, + "atomic_epochs": 2142.95263671875, + "composition_epochs": 2142.9589392643284, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:34.036759+00:00" + }, + { + "step": 20000, + "epoch": 2857.1591544917624, + "cumulative_step": 41000, + "metrics": {}, + "loss": 0.00022119730419944972, + "training_seconds": 70.11478703096509, + "wall_seconds": 75.03545850887895, + "examples": 9191481, + "supervised_tokens": 55148886, + "executed_input_tokens": 257361468, + "estimated_matmul_training_flops": 79322628093696, + "atomic_epochs": 2857.16259765625, + "composition_epochs": 2857.1531223267752, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:52.655348+00:00" + }, + { + "step": 21000, + "epoch": 3000, + "cumulative_step": 42000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0007717089029029012, + "knowledge_nll": 0.0007571857422590256, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.004545454545454545, + "answer_nll": 23.6054630279541, + "knowledge_nll": 23.605453491210938, + "identifier_accuracy": 0.004545454545454545, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004545454545454545 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 25.621326446533203, + "knowledge_nll": 25.62131118774414, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 23.100923538208008, + "knowledge_nll": 23.100908279418945, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.008169934640522876 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 24.528362274169922, + "knowledge_nll": 24.528348922729492, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0006576638552360237, + "knowledge_nll": 0.0006470823427662253, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": 0.0001350198726868257, + "training_seconds": 73.59337209165096, + "wall_seconds": 78.93587162718177, + "examples": 9651000, + "supervised_tokens": 57906000, + "executed_input_tokens": 270228000, + "estimated_matmul_training_flops": 83288284416000, + "atomic_epochs": 3000.0, + "composition_epochs": 3000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:33:56.555681+00:00" + }, + { + "step": 25000, + "epoch": 3571.4774634752875, + "cumulative_step": 46000, + "metrics": {}, + "loss": 0.0001249630149686709, + "training_seconds": 87.49317547678947, + "wall_seconds": 93.72836246713996, + "examples": 11489443, + "supervised_tokens": 68936658, + "executed_input_tokens": 321704404, + "estimated_matmul_training_flops": 99154076921088, + "atomic_epochs": 3571.47265625, + "composition_epochs": 3571.485885372113, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:11.348142+00:00" + }, + { + "step": 28000, + "epoch": 4000, + "cumulative_step": 49000, + "metrics": {}, + "loss": 0.00016601655806880444, + "training_seconds": 97.9846833832562, + "wall_seconds": 104.86973239853978, + "examples": 12868000, + "supervised_tokens": 77208000, + "executed_input_tokens": 360304000, + "estimated_matmul_training_flops": 111051045888000, + "atomic_epochs": 4000.0, + "composition_epochs": 4000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:22.489563+00:00" + }, + { + "step": 30000, + "epoch": 4285.795772458812, + "cumulative_step": 51000, + "metrics": {}, + "loss": 9.276284981751814e-05, + "training_seconds": 105.25766806304455, + "wall_seconds": 112.62679770588875, + "examples": 13787405, + "supervised_tokens": 82724430, + "executed_input_tokens": 386047340, + "estimated_matmul_training_flops": 118985525748480, + "atomic_epochs": 4285.798828125, + "composition_epochs": 4285.790419161676, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:30.246633+00:00" + }, + { + "step": 35000, + "epoch": 5000, + "cumulative_step": 56000, + "metrics": {}, + "loss": 0.00011944577272515744, + "training_seconds": 122.74630166217685, + "wall_seconds": 131.17346072942019, + "examples": 16085000, + "supervised_tokens": 96510000, + "executed_input_tokens": 450380000, + "estimated_matmul_training_flops": 138813807360000, + "atomic_epochs": 5000.0, + "composition_epochs": 5000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:34:48.793260+00:00" + }, + { + "step": 40000, + "epoch": 5714.318308983525, + "cumulative_step": 61000, + "metrics": {}, + "loss": 0.00019173625332769006, + "training_seconds": 140.14360094070435, + "wall_seconds": 149.74933915957808, + "examples": 18382962, + "supervised_tokens": 110297772, + "executed_input_tokens": 514722936, + "estimated_matmul_training_flops": 158645256187392, + "atomic_epochs": 5714.310546875, + "composition_epochs": 5714.331907613345, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:07.369189+00:00" + }, + { + "step": 42000, + "epoch": 6000, + "cumulative_step": 63000, + "metrics": {}, + "loss": 6.631071300944313e-05, + "training_seconds": 147.22171729803085, + "wall_seconds": 157.2723856344819, + "examples": 19302000, + "supervised_tokens": 115812000, + "executed_input_tokens": 540456000, + "estimated_matmul_training_flops": 166576568832000, + "atomic_epochs": 6000.0, + "composition_epochs": 6000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:14.892210+00:00" + }, + { + "step": 45000, + "epoch": 6428.63661796705, + "cumulative_step": 66000, + "metrics": {}, + "loss": 0.00015038739365991205, + "training_seconds": 157.61987775564194, + "wall_seconds": 168.35513265430927, + "examples": 20680924, + "supervised_tokens": 124085544, + "executed_input_tokens": 579065872, + "estimated_matmul_training_flops": 178476705014784, + "atomic_epochs": 6428.638671875, + "composition_epochs": 6428.633019674936, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:25.974921+00:00" + }, + { + "step": 49000, + "epoch": 7000, + "cumulative_step": 70000, + "metrics": {}, + "loss": 0.0001521260419394821, + "training_seconds": 171.83849629759789, + "wall_seconds": 183.43816628679633, + "examples": 22519000, + "supervised_tokens": 135114000, + "executed_input_tokens": 630532000, + "estimated_matmul_training_flops": 194339330304000, + "atomic_epochs": 7000.0, + "composition_epochs": 7000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:41.057997+00:00" + }, + { + "step": 50000, + "epoch": 7142.954926950575, + "cumulative_step": 71000, + "metrics": {}, + "loss": 0.00016323052113875747, + "training_seconds": 175.3180723376572, + "wall_seconds": 187.20678624883294, + "examples": 22978886, + "supervised_tokens": 137873316, + "executed_input_tokens": 643408808, + "estimated_matmul_training_flops": 198308153842176, + "atomic_epochs": 7142.9541015625, + "composition_epochs": 7142.956372968349, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:35:44.826528+00:00" + }, + { + "step": 55000, + "epoch": 7857.159154491763, + "cumulative_step": 76000, + "metrics": {}, + "loss": 0.00013943279918748885, + "training_seconds": 192.85167264565825, + "wall_seconds": 205.79542867839336, + "examples": 25276481, + "supervised_tokens": 151658886, + "executed_input_tokens": 707741468, + "estimated_matmul_training_flops": 218136435453696, + "atomic_epochs": 7857.1572265625, + "composition_epochs": 7857.1625320787, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:03.415198+00:00" + }, + { + "step": 56000, + "epoch": 8000, + "cumulative_step": 77000, + "metrics": {}, + "loss": 7.226763409562409e-05, + "training_seconds": 196.3245509788394, + "wall_seconds": 209.51510839536786, + "examples": 25736000, + "supervised_tokens": 154416000, + "executed_input_tokens": 720608000, + "estimated_matmul_training_flops": 222102091776000, + "atomic_epochs": 8000.0, + "composition_epochs": 8000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:07.134921+00:00" + }, + { + "step": 60000, + "epoch": 8571.477463475287, + "cumulative_step": 81000, + "metrics": {}, + "loss": 6.526928336825222e-05, + "training_seconds": 210.23108561336994, + "wall_seconds": 224.31653996556997, + "examples": 27574443, + "supervised_tokens": 165446658, + "executed_input_tokens": 772084404, + "estimated_matmul_training_flops": 237967884281088, + "atomic_epochs": 8571.48681640625, + "composition_epochs": 8571.461077844311, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:21.936346+00:00" + }, + { + "step": 63000, + "epoch": 9000, + "cumulative_step": 84000, + "metrics": {}, + "loss": 0.0001254789240192622, + "training_seconds": 220.64538560807705, + "wall_seconds": 235.38780050724745, + "examples": 28953000, + "supervised_tokens": 173718000, + "executed_input_tokens": 810684000, + "estimated_matmul_training_flops": 249864853248000, + "atomic_epochs": 9000.0, + "composition_epochs": 9000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:33.007567+00:00" + }, + { + "step": 65000, + "epoch": 9285.795772458812, + "cumulative_step": 86000, + "metrics": {}, + "loss": 3.259154982515611e-05, + "training_seconds": 227.592379078269, + "wall_seconds": 242.82221047207713, + "examples": 29872405, + "supervised_tokens": 179234430, + "executed_input_tokens": 836427340, + "estimated_matmul_training_flops": 257799333108480, + "atomic_epochs": 9285.79736328125, + "composition_epochs": 9285.792985457656, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:40.441987+00:00" + }, + { + "step": 70000, + "epoch": 10000, + "cumulative_step": 91000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.94775390625, + "answer_nll": 0.18432310223579407, + "knowledge_nll": 0.18426406383514404, + "identifier_accuracy": 0.94775390625, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.011363636363636364, + "answer_nll": 23.311870574951172, + "knowledge_nll": 23.311843872070312, + "identifier_accuracy": 0.011363636363636364, + "population_n": 880, + "first_atomic_accuracy": 0.946590909090909, + "second_atomic_accuracy": 0.9318181818181818, + "both_atomic_n": 775, + "both_atomic_coverage": 0.8806818181818182, + "both_atomic_composition_accuracy": 0.011612903225806452 + }, + "IO": { + "n": 891, + "accuracy": 0.005611672278338945, + "answer_nll": 28.514150619506836, + "knowledge_nll": 28.514095306396484, + "identifier_accuracy": 0.005611672278338945, + "population_n": 891, + "first_atomic_accuracy": 0.9517396184062851, + "second_atomic_accuracy": 0.9506172839506173, + "both_atomic_n": 805, + "both_atomic_coverage": 0.9034792368125701, + "both_atomic_composition_accuracy": 0.004968944099378882 + }, + "OI": { + "n": 612, + "accuracy": 0.013071895424836602, + "answer_nll": 24.52414321899414, + "knowledge_nll": 24.52406883239746, + "identifier_accuracy": 0.013071895424836602, + "population_n": 612, + "first_atomic_accuracy": 0.9640522875816994, + "second_atomic_accuracy": 0.9313725490196079, + "both_atomic_n": 551, + "both_atomic_coverage": 0.9003267973856209, + "both_atomic_composition_accuracy": 0.010889292196007259 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 27.604249954223633, + "knowledge_nll": 27.60422706604004, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 0.9595588235294118, + "second_atomic_accuracy": 0.9669117647058824, + "both_atomic_n": 505, + "both_atomic_coverage": 0.9283088235294118, + "both_atomic_composition_accuracy": 0.007920792079207921 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.9546621043627032, + "answer_nll": 0.13290147483348846, + "knowledge_nll": 0.132859468460083, + "identifier_accuracy": 0.9546621043627032, + "population_n": 1169 + } + }, + "loss": 0.05531798675656319, + "training_seconds": 245.16874459385872, + "wall_seconds": 261.64365861192346, + "examples": 32170000, + "supervised_tokens": 193020000, + "executed_input_tokens": 900760000, + "estimated_matmul_training_flops": 277627614720000, + "atomic_epochs": 10000.0, + "composition_epochs": 10000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:36:59.263455+00:00" + }, + { + "step": 75000, + "epoch": 10714.318308983526, + "cumulative_step": 96000, + "metrics": {}, + "loss": 0.0233480054885149, + "training_seconds": 262.5708829648793, + "wall_seconds": 280.1327415704727, + "examples": 34467962, + "supervised_tokens": 206807772, + "executed_input_tokens": 965102936, + "estimated_matmul_training_flops": 297459063547392, + "atomic_epochs": 10714.31396484375, + "composition_epochs": 10714.325919589393, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:17.752489+00:00" + }, + { + "step": 77000, + "epoch": 11000, + "cumulative_step": 98000, + "metrics": {}, + "loss": 7.879848271841183e-05, + "training_seconds": 269.70876935869455, + "wall_seconds": 287.73275319859385, + "examples": 35387000, + "supervised_tokens": 212322000, + "executed_input_tokens": 990836000, + "estimated_matmul_training_flops": 305390376192000, + "atomic_epochs": 11000.0, + "composition_epochs": 11000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:25.352510+00:00" + }, + { + "step": 80000, + "epoch": 11428.63661796705, + "cumulative_step": 101000, + "metrics": {}, + "loss": 0.00011220444139325991, + "training_seconds": 280.1803215816617, + "wall_seconds": 298.89984571933746, + "examples": 36765924, + "supervised_tokens": 220595544, + "executed_input_tokens": 1029445872, + "estimated_matmul_training_flops": 317290512374784, + "atomic_epochs": 11428.64501953125, + "composition_epochs": 11428.621899059024, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:36.519638+00:00" + }, + { + "step": 84000, + "epoch": 12000, + "cumulative_step": 105000, + "metrics": {}, + "loss": 0.004517704714089632, + "training_seconds": 294.0964386500418, + "wall_seconds": 313.6617610231042, + "examples": 38604000, + "supervised_tokens": 231624000, + "executed_input_tokens": 1080912000, + "estimated_matmul_training_flops": 333153137664000, + "atomic_epochs": 12000.0, + "composition_epochs": 12000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:51.281573+00:00" + }, + { + "step": 85000, + "epoch": 12142.954926950575, + "cumulative_step": 106000, + "metrics": {}, + "loss": 0.000122694720630534, + "training_seconds": 297.5651649348438, + "wall_seconds": 317.4180793091655, + "examples": 39063886, + "supervised_tokens": 234383316, + "executed_input_tokens": 1093788808, + "estimated_matmul_training_flops": 337121961202176, + "atomic_epochs": 12142.958984375, + "composition_epochs": 12142.947818648418, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:37:55.037833+00:00" + }, + { + "step": 90000, + "epoch": 12857.159154491763, + "cumulative_step": 111000, + "metrics": {}, + "loss": 0.0001076640110113658, + "training_seconds": 315.16641598939896, + "wall_seconds": 336.07880072668195, + "examples": 41361481, + "supervised_tokens": 248168886, + "executed_input_tokens": 1158121468, + "estimated_matmul_training_flops": 356950242813696, + "atomic_epochs": 12857.162109375, + "composition_epochs": 12857.153977758768, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:13.698571+00:00" + }, + { + "step": 91000, + "epoch": 13000, + "cumulative_step": 112000, + "metrics": {}, + "loss": 4.93232328153681e-05, + "training_seconds": 318.7050945945084, + "wall_seconds": 339.86692187190056, + "examples": 41821000, + "supervised_tokens": 250926000, + "executed_input_tokens": 1170988000, + "estimated_matmul_training_flops": 360915899136000, + "atomic_epochs": 13000.0, + "composition_epochs": 13000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:17.486669+00:00" + }, + { + "step": 95000, + "epoch": 13571.477463475287, + "cumulative_step": 116000, + "metrics": {}, + "loss": 4.723484380519949e-05, + "training_seconds": 332.55863961577415, + "wall_seconds": 354.604878783226, + "examples": 43659443, + "supervised_tokens": 261956658, + "executed_input_tokens": 1222464404, + "estimated_matmul_training_flops": 376781691641088, + "atomic_epochs": 13571.47607421875, + "composition_epochs": 13571.479897348161, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:32.224647+00:00" + }, + { + "step": 98000, + "epoch": 14000, + "cumulative_step": 119000, + "metrics": {}, + "loss": 0.0001148340743384324, + "training_seconds": 343.05627646669745, + "wall_seconds": 365.7562934681773, + "examples": 45038000, + "supervised_tokens": 270228000, + "executed_input_tokens": 1261064000, + "estimated_matmul_training_flops": 388678660608000, + "atomic_epochs": 14000.0, + "composition_epochs": 14000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:43.376085+00:00" + }, + { + "step": 100000, + "epoch": 14285.795772458812, + "cumulative_step": 121000, + "metrics": {}, + "loss": 0.06092342361807823, + "training_seconds": 350.0164988860488, + "wall_seconds": 373.20790027827024, + "examples": 45957405, + "supervised_tokens": 275744430, + "executed_input_tokens": 1286807340, + "estimated_matmul_training_flops": 396613140468480, + "atomic_epochs": 14285.79833984375, + "composition_epochs": 14285.79127459367, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:38:50.827713+00:00" + }, + { + "step": 105000, + "epoch": 15000, + "cumulative_step": 126000, + "metrics": {}, + "loss": 0.022769680246710777, + "training_seconds": 367.54614244401455, + "wall_seconds": 391.78994055464864, + "examples": 48255000, + "supervised_tokens": 289530000, + "executed_input_tokens": 1351140000, + "estimated_matmul_training_flops": 416441422080000, + "atomic_epochs": 15000.0, + "composition_epochs": 15000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:09.409710+00:00" + }, + { + "step": 110000, + "epoch": 15714.318308983526, + "cumulative_step": 131000, + "metrics": {}, + "loss": 9.09421723918058e-05, + "training_seconds": 384.9359843246639, + "wall_seconds": 410.26497212424874, + "examples": 50552962, + "supervised_tokens": 303317772, + "executed_input_tokens": 1415482936, + "estimated_matmul_training_flops": 436272870907392, + "atomic_epochs": 15714.31640625, + "composition_epochs": 15714.321642429426, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:27.884742+00:00" + }, + { + "step": 112000, + "epoch": 16000, + "cumulative_step": 133000, + "metrics": {}, + "loss": 2.0151253920630552e-05, + "training_seconds": 391.84631364420056, + "wall_seconds": 417.6189507879317, + "examples": 51472000, + "supervised_tokens": 308832000, + "executed_input_tokens": 1441216000, + "estimated_matmul_training_flops": 444204183552000, + "atomic_epochs": 16000.0, + "composition_epochs": 16000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:35.238734+00:00" + }, + { + "step": 115000, + "epoch": 16428.63661796705, + "cumulative_step": 136000, + "metrics": {}, + "loss": 3.176984318997711e-05, + "training_seconds": 402.26355696097016, + "wall_seconds": 428.7237174473703, + "examples": 52850924, + "supervised_tokens": 317105544, + "executed_input_tokens": 1479825872, + "estimated_matmul_training_flops": 456104319734784, + "atomic_epochs": 16428.64013671875, + "composition_epochs": 16428.630453378955, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:39:46.343471+00:00" + }, + { + "step": 119000, + "epoch": 17000, + "cumulative_step": 140000, + "metrics": {}, + "loss": 3.8447520637419075e-05, + "training_seconds": 416.27084874361753, + "wall_seconds": 443.5858336649835, + "examples": 54689000, + "supervised_tokens": 328134000, + "executed_input_tokens": 1531292000, + "estimated_matmul_training_flops": 471966945024000, + "atomic_epochs": 17000.0, + "composition_epochs": 17000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:01.205646+00:00" + }, + { + "step": 120000, + "epoch": 17142.954926950573, + "cumulative_step": 141000, + "metrics": {}, + "loss": 0.021611398085951805, + "training_seconds": 419.7180675826967, + "wall_seconds": 447.3163424655795, + "examples": 55148886, + "supervised_tokens": 330893316, + "executed_input_tokens": 1544168808, + "estimated_matmul_training_flops": 475935768562176, + "atomic_epochs": 17142.95556640625, + "composition_epochs": 17142.95380667237, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:04.936078+00:00" + }, + { + "step": 125000, + "epoch": 17857.15915449176, + "cumulative_step": 146000, + "metrics": {}, + "loss": 9.532279364066198e-05, + "training_seconds": 437.18639235943556, + "wall_seconds": 465.84426041319966, + "examples": 57446481, + "supervised_tokens": 344678886, + "executed_input_tokens": 1608501468, + "estimated_matmul_training_flops": 495764050173696, + "atomic_epochs": 17857.1484375, + "composition_epochs": 17857.177929854577, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:23.464027+00:00" + }, + { + "step": 126000, + "epoch": 18000, + "cumulative_step": 147000, + "metrics": {}, + "loss": 6.370939081534743e-05, + "training_seconds": 440.6371007449925, + "wall_seconds": 469.5432984866202, + "examples": 57906000, + "supervised_tokens": 347436000, + "executed_input_tokens": 1621368000, + "estimated_matmul_training_flops": 499729706496000, + "atomic_epochs": 18000.0, + "composition_epochs": 18000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:27.163044+00:00" + }, + { + "step": 130000, + "epoch": 18571.477463475287, + "cumulative_step": 151000, + "metrics": {}, + "loss": 2.2285896193352528e-05, + "training_seconds": 454.582229513675, + "wall_seconds": 485.04217175394297, + "examples": 59744443, + "supervised_tokens": 358466658, + "executed_input_tokens": 1672844404, + "estimated_matmul_training_flops": 515595499001088, + "atomic_epochs": 18571.4677734375, + "composition_epochs": 18571.494439692044, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:42.661956+00:00" + }, + { + "step": 133000, + "epoch": 19000, + "cumulative_step": 154000, + "metrics": {}, + "loss": 3.851681685773656e-05, + "training_seconds": 465.0088535770774, + "wall_seconds": 496.11621499434114, + "examples": 61123000, + "supervised_tokens": 366738000, + "executed_input_tokens": 1711444000, + "estimated_matmul_training_flops": 527492467968000, + "atomic_epochs": 19000.0, + "composition_epochs": 19000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:40:53.735963+00:00" + }, + { + "step": 135000, + "epoch": 19285.795772458812, + "cumulative_step": 156000, + "metrics": {}, + "loss": 9.248044079868123e-05, + "training_seconds": 471.9453880786896, + "wall_seconds": 503.52898287028074, + "examples": 62042405, + "supervised_tokens": 372254430, + "executed_input_tokens": 1737187340, + "estimated_matmul_training_flops": 535426947828480, + "atomic_epochs": 19285.8056640625, + "composition_epochs": 19285.778443113773, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:41:01.148774+00:00" + }, + { + "step": 140000, + "epoch": 20000, + "cumulative_step": 161000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00029119409737177193, + "knowledge_nll": 0.0002880606916733086, + "identifier_accuracy": 1.0, + "full_population": false + }, + "II": { + "n": 880, + "accuracy": 0.00909090909090909, + "answer_nll": 28.287612915039062, + "knowledge_nll": 28.28761100769043, + "identifier_accuracy": 0.00909090909090909, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00909090909090909 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 32.99225616455078, + "knowledge_nll": 32.992252349853516, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003367003367003367 + }, + "OI": { + "n": 612, + "accuracy": 0.00980392156862745, + "answer_nll": 29.74803352355957, + "knowledge_nll": 29.748031616210938, + "identifier_accuracy": 0.00980392156862745, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00980392156862745 + }, + "OO": { + "n": 544, + "accuracy": 0.0055147058823529415, + "answer_nll": 33.166160583496094, + "knowledge_nll": 33.166160583496094, + "identifier_accuracy": 0.0055147058823529415, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0055147058823529415 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.00029048367287032306, + "knowledge_nll": 0.000289041519863531, + "identifier_accuracy": 1.0, + "population_n": 1169 + } + }, + "loss": 5.179596701054834e-05, + "training_seconds": 489.42187153548, + "wall_seconds": 522.2853139713407, + "examples": 64340000, + "supervised_tokens": 386040000, + "executed_input_tokens": 1801520000, + "estimated_matmul_training_flops": 555255229440000, + "atomic_epochs": 20000.0, + "composition_epochs": 20000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:41:19.905081+00:00" + }, + { + "step": 145000, + "epoch": 20714.318308983526, + "cumulative_step": 166000, + "metrics": {}, + "loss": 0.00010431490954943001, + "training_seconds": 506.98800460621715, + "wall_seconds": 541.6335736550391, + "examples": 66637962, + "supervised_tokens": 399827772, + "executed_input_tokens": 1865862936, + "estimated_matmul_training_flops": 575086678267392, + "atomic_epochs": 20714.3125, + "composition_epochs": 20714.328485885373, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:41:39.253331+00:00" + }, + { + "step": 147000, + "epoch": 21000, + "cumulative_step": 168000, + "metrics": {}, + "loss": 2.5416769858566113e-05, + "training_seconds": 514.2155739627779, + "wall_seconds": 549.3149167187512, + "examples": 67557000, + "supervised_tokens": 405342000, + "executed_input_tokens": 1891596000, + "estimated_matmul_training_flops": 583017990912000, + "atomic_epochs": 21000.0, + "composition_epochs": 21000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:41:46.934658+00:00" + }, + { + "step": 150000, + "epoch": 21428.63661796705, + "cumulative_step": 171000, + "metrics": {}, + "loss": 3.236373231629841e-05, + "training_seconds": 524.6332806609571, + "wall_seconds": 560.4180251546204, + "examples": 68935924, + "supervised_tokens": 413615544, + "executed_input_tokens": 1930205872, + "estimated_matmul_training_flops": 594918127094784, + "atomic_epochs": 21428.638671875, + "composition_epochs": 21428.633019674937, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:41:58.037804+00:00" + }, + { + "step": 154000, + "epoch": 22000, + "cumulative_step": 175000, + "metrics": {}, + "loss": 6.21482395217754e-05, + "training_seconds": 538.508499160409, + "wall_seconds": 575.1384763903916, + "examples": 70774000, + "supervised_tokens": 424644000, + "executed_input_tokens": 1981672000, + "estimated_matmul_training_flops": 610780752384000, + "atomic_epochs": 22000.0, + "composition_epochs": 22000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:42:12.758246+00:00" + }, + { + "step": 155000, + "epoch": 22142.954926950573, + "cumulative_step": 176000, + "metrics": {}, + "loss": 2.118640077242162e-05, + "training_seconds": 541.9646584764123, + "wall_seconds": 578.88351534307, + "examples": 71233886, + "supervised_tokens": 427403316, + "executed_input_tokens": 1994548808, + "estimated_matmul_training_flops": 614749575922176, + "atomic_epochs": 22142.955078125, + "composition_epochs": 22142.954662104363, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:42:16.503255+00:00" + }, + { + "step": 160000, + "epoch": 22857.15915449176, + "cumulative_step": 181000, + "metrics": {}, + "loss": 0.000131830558530055, + "training_seconds": 559.5073791071773, + "wall_seconds": 597.485343337059, + "examples": 73531481, + "supervised_tokens": 441188886, + "executed_input_tokens": 2058881468, + "estimated_matmul_training_flops": 634577857533696, + "atomic_epochs": 22857.15478515625, + "composition_epochs": 22857.166809238664, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:42:35.105111+00:00" + }, + { + "step": 161000, + "epoch": 23000, + "cumulative_step": 182000, + "metrics": {}, + "loss": 7.745652692392468e-05, + "training_seconds": 562.9434151463211, + "wall_seconds": 601.1644280850887, + "examples": 73991000, + "supervised_tokens": 443946000, + "executed_input_tokens": 2071748000, + "estimated_matmul_training_flops": 638543513856000, + "atomic_epochs": 23000.0, + "composition_epochs": 23000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:42:38.784173+00:00" + }, + { + "step": 165000, + "epoch": 23571.477463475287, + "cumulative_step": 186000, + "metrics": {}, + "loss": 5.9103633248014376e-05, + "training_seconds": 576.8254446014762, + "wall_seconds": 615.9371736459434, + "examples": 75829443, + "supervised_tokens": 454976658, + "executed_input_tokens": 2123224404, + "estimated_matmul_training_flops": 654409306361088, + "atomic_epochs": 23571.48876953125, + "composition_epochs": 23571.457656116338, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:42:53.556939+00:00" + }, + { + "step": 168000, + "epoch": 24000, + "cumulative_step": 189000, + "metrics": {}, + "loss": 5.064344441052526e-05, + "training_seconds": 587.1924441084266, + "wall_seconds": 626.9658921211958, + "examples": 77208000, + "supervised_tokens": 463248000, + "executed_input_tokens": 2161824000, + "estimated_matmul_training_flops": 666306275328000, + "atomic_epochs": 24000.0, + "composition_epochs": 24000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:43:04.585645+00:00" + }, + { + "step": 170000, + "epoch": 24285.795772458812, + "cumulative_step": 191000, + "metrics": {}, + "loss": 0.09195980429649353, + "training_seconds": 594.1681314148009, + "wall_seconds": 634.4352751858532, + "examples": 78127405, + "supervised_tokens": 468764430, + "executed_input_tokens": 2187567340, + "estimated_matmul_training_flops": 674240755188480, + "atomic_epochs": 24285.79248046875, + "composition_epochs": 24285.80153977759, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:43:12.055020+00:00" + }, + { + "step": 175000, + "epoch": 25000, + "cumulative_step": 196000, + "metrics": {}, + "loss": 0.015382322482764721, + "training_seconds": 612.0138284899294, + "wall_seconds": 653.3838641867042, + "examples": 80425000, + "supervised_tokens": 482550000, + "executed_input_tokens": 2251900000, + "estimated_matmul_training_flops": 694069036800000, + "atomic_epochs": 25000.0, + "composition_epochs": 25000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:43:31.003628+00:00" + }, + { + "step": 180000, + "epoch": 25714.318308983526, + "cumulative_step": 201000, + "metrics": {}, + "loss": 4.020042979391292e-05, + "training_seconds": 629.4338136203587, + "wall_seconds": 671.906829982996, + "examples": 82722962, + "supervised_tokens": 496337772, + "executed_input_tokens": 2316242936, + "estimated_matmul_training_flops": 713900485627392, + "atomic_epochs": 25714.31689453125, + "composition_epochs": 25714.320786997432, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:43:49.526605+00:00" + }, + { + "step": 182000, + "epoch": 26000, + "cumulative_step": 203000, + "metrics": {}, + "loss": 9.130096441367641e-05, + "training_seconds": 636.3700469993055, + "wall_seconds": 679.2936055697501, + "examples": 83642000, + "supervised_tokens": 501852000, + "executed_input_tokens": 2341976000, + "estimated_matmul_training_flops": 721831798272000, + "atomic_epochs": 26000.0, + "composition_epochs": 26000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:43:56.913357+00:00" + }, + { + "step": 185000, + "epoch": 26428.63661796705, + "cumulative_step": 206000, + "metrics": {}, + "loss": 0.37190738320350647, + "training_seconds": 646.7669520676136, + "wall_seconds": 690.369275175035, + "examples": 85020924, + "supervised_tokens": 510125544, + "executed_input_tokens": 2380585872, + "estimated_matmul_training_flops": 733731934454784, + "atomic_epochs": 26428.63623046875, + "composition_epochs": 26428.637296834902, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:44:07.989072+00:00" + }, + { + "step": 189000, + "epoch": 27000, + "cumulative_step": 210000, + "metrics": {}, + "loss": 5.685434371116571e-05, + "training_seconds": 660.6183684431016, + "wall_seconds": 705.0689898058772, + "examples": 86859000, + "supervised_tokens": 521154000, + "executed_input_tokens": 2432052000, + "estimated_matmul_training_flops": 749594559744000, + "atomic_epochs": 27000.0, + "composition_epochs": 27000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:44:22.688780+00:00" + }, + { + "step": 190000, + "epoch": 27142.954926950573, + "cumulative_step": 211000, + "metrics": {}, + "loss": 0.030704805627465248, + "training_seconds": 664.0650233216584, + "wall_seconds": 708.7923107147217, + "examples": 87318886, + "supervised_tokens": 523913316, + "executed_input_tokens": 2444928808, + "estimated_matmul_training_flops": 753563383282176, + "atomic_epochs": 27142.9580078125, + "composition_epochs": 27142.949529512403, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:44:26.412047+00:00" + }, + { + "step": 195000, + "epoch": 27857.15915449176, + "cumulative_step": 216000, + "metrics": {}, + "loss": 0.009806857444345951, + "training_seconds": 681.5419096909463, + "wall_seconds": 727.3313081003726, + "examples": 89616481, + "supervised_tokens": 537698886, + "executed_input_tokens": 2509261468, + "estimated_matmul_training_flops": 773391664893696, + "atomic_epochs": 27857.16455078125, + "composition_epochs": 27857.149700598802, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:44:44.951069+00:00" + }, + { + "step": 196000, + "epoch": 28000, + "cumulative_step": 217000, + "metrics": {}, + "loss": 0.00010275889508193359, + "training_seconds": 685.0196907706559, + "wall_seconds": 731.8208291009068, + "examples": 90076000, + "supervised_tokens": 540456000, + "executed_input_tokens": 2522128000, + "estimated_matmul_training_flops": 777357321216000, + "atomic_epochs": 28000.0, + "composition_epochs": 28000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:44:49.440575+00:00" + }, + { + "step": 200000, + "epoch": 28571.477463475287, + "cumulative_step": 221000, + "metrics": {}, + "loss": 0.0033856527879834175, + "training_seconds": 698.9394628591835, + "wall_seconds": 746.6414737179875, + "examples": 91914443, + "supervised_tokens": 551486658, + "executed_input_tokens": 2573604404, + "estimated_matmul_training_flops": 793223113721088, + "atomic_epochs": 28571.48095703125, + "composition_epochs": 28571.471343028228, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:45:04.261242+00:00" + }, + { + "step": 203000, + "epoch": 29000, + "cumulative_step": 224000, + "metrics": {}, + "loss": 0.01882677711546421, + "training_seconds": 709.3623190969229, + "wall_seconds": 757.7155790477991, + "examples": 93293000, + "supervised_tokens": 559758000, + "executed_input_tokens": 2612204000, + "estimated_matmul_training_flops": 805120082688000, + "atomic_epochs": 29000.0, + "composition_epochs": 29000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:45:15.335360+00:00" + }, + { + "step": 205000, + "epoch": 29285.795772458812, + "cumulative_step": 226000, + "metrics": {}, + "loss": 7.432398706441745e-05, + "training_seconds": 716.3230892270803, + "wall_seconds": 765.1615514010191, + "examples": 94212405, + "supervised_tokens": 565274430, + "executed_input_tokens": 2637947340, + "estimated_matmul_training_flops": 813054562548480, + "atomic_epochs": 29285.79736328125, + "composition_epochs": 29285.792985457658, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:45:22.781304+00:00" + }, + { + "step": 210000, + "epoch": 30000, + "cumulative_step": 231000, + "metrics": {}, + "loss": 0.05307997763156891, + "training_seconds": 733.8465985022485, + "wall_seconds": 783.7382511496544, + "examples": 96510000, + "supervised_tokens": 579060000, + "executed_input_tokens": 2702280000, + "estimated_matmul_training_flops": 832882844160000, + "atomic_epochs": 30000.0, + "composition_epochs": 30000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:45:41.358063+00:00" + }, + { + "step": 215000, + "epoch": 30714.318308983526, + "cumulative_step": 236000, + "metrics": {}, + "loss": 0.00012711351155303419, + "training_seconds": 751.1160618178546, + "wall_seconds": 802.1012702658772, + "examples": 98807962, + "supervised_tokens": 592847772, + "executed_input_tokens": 2766622936, + "estimated_matmul_training_flops": 852714292987392, + "atomic_epochs": 30714.3251953125, + "composition_epochs": 30714.30624465355, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:45:59.721020+00:00" + }, + { + "step": 217000, + "epoch": 31000, + "cumulative_step": 238000, + "metrics": {}, + "loss": 5.383797542890534e-05, + "training_seconds": 758.041813865304, + "wall_seconds": 809.4747809432447, + "examples": 99727000, + "supervised_tokens": 598362000, + "executed_input_tokens": 2792356000, + "estimated_matmul_training_flops": 860645605632000, + "atomic_epochs": 31000.0, + "composition_epochs": 31000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:46:07.094526+00:00" + }, + { + "step": 220000, + "epoch": 31428.63661796705, + "cumulative_step": 241000, + "metrics": {}, + "loss": 6.0099413531133905e-05, + "training_seconds": 768.4089030884206, + "wall_seconds": 820.5289182960987, + "examples": 101105924, + "supervised_tokens": 606635544, + "executed_input_tokens": 2830965872, + "estimated_matmul_training_flops": 872545741814784, + "atomic_epochs": 31428.63232421875, + "composition_epochs": 31428.644140290846, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:46:18.148660+00:00" + }, + { + "step": 224000, + "epoch": 32000, + "cumulative_step": 245000, + "metrics": {}, + "loss": 0.07776755839586258, + "training_seconds": 782.1726623363793, + "wall_seconds": 835.1491823680699, + "examples": 102944000, + "supervised_tokens": 617664000, + "executed_input_tokens": 2882432000, + "estimated_matmul_training_flops": 888408367104000, + "atomic_epochs": 32000.0, + "composition_epochs": 32000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:46:32.768948+00:00" + }, + { + "step": 225000, + "epoch": 32142.954926950573, + "cumulative_step": 246000, + "metrics": {}, + "loss": 0.00011580040882108733, + "training_seconds": 785.6303202845156, + "wall_seconds": 838.8940125517547, + "examples": 103403886, + "supervised_tokens": 620423316, + "executed_input_tokens": 2895308808, + "estimated_matmul_training_flops": 892377190642176, + "atomic_epochs": 32142.958984375, + "composition_epochs": 32142.947818648416, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:46:36.513770+00:00" + }, + { + "step": 230000, + "epoch": 32857.15915449176, + "cumulative_step": 251000, + "metrics": {}, + "loss": 4.436519884620793e-05, + "training_seconds": 803.0861305817962, + "wall_seconds": 857.4110161736608, + "examples": 105701481, + "supervised_tokens": 634208886, + "executed_input_tokens": 2959641468, + "estimated_matmul_training_flops": 912205472253696, + "atomic_epochs": 32857.158203125, + "composition_epochs": 32857.16082121471, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:46:55.030847+00:00" + }, + { + "step": 231000, + "epoch": 33000, + "cumulative_step": 252000, + "metrics": {}, + "loss": 0.011168931610882282, + "training_seconds": 806.5768241174519, + "wall_seconds": 861.1650205999613, + "examples": 106161000, + "supervised_tokens": 636966000, + "executed_input_tokens": 2972508000, + "estimated_matmul_training_flops": 916171128576000, + "atomic_epochs": 33000.0, + "composition_epochs": 33000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:46:58.784796+00:00" + }, + { + "step": 235000, + "epoch": 33571.47746347529, + "cumulative_step": 256000, + "metrics": {}, + "loss": 8.054768841248006e-05, + "training_seconds": 820.5034636929631, + "wall_seconds": 875.9985327795148, + "examples": 107999443, + "supervised_tokens": 647996658, + "executed_input_tokens": 3023984404, + "estimated_matmul_training_flops": 932036921081088, + "atomic_epochs": 33571.48681640625, + "composition_epochs": 33571.46107784431, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:47:13.618293+00:00" + }, + { + "step": 238000, + "epoch": 34000, + "cumulative_step": 259000, + "metrics": {}, + "loss": 8.668920054333284e-05, + "training_seconds": 830.9261011481285, + "wall_seconds": 887.0708017423749, + "examples": 109378000, + "supervised_tokens": 656268000, + "executed_input_tokens": 3062584000, + "estimated_matmul_training_flops": 943933890048000, + "atomic_epochs": 34000.0, + "composition_epochs": 34000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:47:24.690550+00:00" + }, + { + "step": 240000, + "epoch": 34285.79577245881, + "cumulative_step": 261000, + "metrics": {}, + "loss": 3.018758252437692e-05, + "training_seconds": 837.8531083464622, + "wall_seconds": 894.4944282434881, + "examples": 110297405, + "supervised_tokens": 661784430, + "executed_input_tokens": 3088327340, + "estimated_matmul_training_flops": 951868369908480, + "atomic_epochs": 34285.7919921875, + "composition_epochs": 34285.80239520958, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:47:32.114172+00:00" + }, + { + "step": 245000, + "epoch": 35000, + "cumulative_step": 266000, + "metrics": {}, + "loss": 0.015299023129045963, + "training_seconds": 855.3809789381921, + "wall_seconds": 913.0840426497161, + "examples": 112595000, + "supervised_tokens": 675570000, + "executed_input_tokens": 3152660000, + "estimated_matmul_training_flops": 971696651520000, + "atomic_epochs": 35000.0, + "composition_epochs": 35000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:47:50.703810+00:00" + }, + { + "step": 250000, + "epoch": 35714.31830898352, + "cumulative_step": 271000, + "metrics": {}, + "loss": 2.5239891328965314e-05, + "training_seconds": 872.6633461900055, + "wall_seconds": 931.4758836552501, + "examples": 114892962, + "supervised_tokens": 689357772, + "executed_input_tokens": 3217002936, + "estimated_matmul_training_flops": 991528100347392, + "atomic_epochs": 35714.31298828125, + "composition_epochs": 35714.32763045338, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:48:09.095677+00:00" + }, + { + "step": 252000, + "epoch": 36000, + "cumulative_step": 273000, + "metrics": {}, + "loss": 0.00011468918819446117, + "training_seconds": 879.6741493158042, + "wall_seconds": 938.9349142313004, + "examples": 115812000, + "supervised_tokens": 694872000, + "executed_input_tokens": 3242736000, + "estimated_matmul_training_flops": 999459412992000, + "atomic_epochs": 36000.0, + "composition_epochs": 36000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:48:16.554678+00:00" + }, + { + "step": 255000, + "epoch": 36428.63661796705, + "cumulative_step": 276000, + "metrics": {}, + "loss": 7.159486995078623e-05, + "training_seconds": 890.0480382405221, + "wall_seconds": 949.9993087500334, + "examples": 117190924, + "supervised_tokens": 703145544, + "executed_input_tokens": 3281345872, + "estimated_matmul_training_flops": 1011359549174784, + "atomic_epochs": 36428.62841796875, + "composition_epochs": 36428.65098374679, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:48:27.619093+00:00" + }, + { + "step": 259000, + "epoch": 37000, + "cumulative_step": 280000, + "metrics": {}, + "loss": 3.1621635571355e-05, + "training_seconds": 903.885728251189, + "wall_seconds": 964.689399510622, + "examples": 119029000, + "supervised_tokens": 714174000, + "executed_input_tokens": 3332812000, + "estimated_matmul_training_flops": 1027222174464000, + "atomic_epochs": 37000.0, + "composition_epochs": 37000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:48:42.309180+00:00" + }, + { + "step": 260000, + "epoch": 37142.95492695057, + "cumulative_step": 281000, + "metrics": {}, + "loss": 0.011715494096279144, + "training_seconds": 907.4071495682001, + "wall_seconds": 968.4961419738829, + "examples": 119488886, + "supervised_tokens": 716933316, + "executed_input_tokens": 3345688808, + "estimated_matmul_training_flops": 1031190998002176, + "atomic_epochs": 37142.94970703125, + "composition_epochs": 37142.96407185629, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:48:46.115898+00:00" + }, + { + "step": 265000, + "epoch": 37857.15915449176, + "cumulative_step": 286000, + "metrics": {}, + "loss": 4.6011442464077845e-05, + "training_seconds": 924.958381049335, + "wall_seconds": 987.1164307594299, + "examples": 121786481, + "supervised_tokens": 730718886, + "executed_input_tokens": 3410021468, + "estimated_matmul_training_flops": 1051019279613696, + "atomic_epochs": 37857.16455078125, + "composition_epochs": 37857.149700598806, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:49:04.736184+00:00" + }, + { + "step": 266000, + "epoch": 38000, + "cumulative_step": 287000, + "metrics": {}, + "loss": 0.03433425351977348, + "training_seconds": 928.4032758772373, + "wall_seconds": 990.8077454529703, + "examples": 122246000, + "supervised_tokens": 733476000, + "executed_input_tokens": 3422888000, + "estimated_matmul_training_flops": 1054984935936000, + "atomic_epochs": 38000.0, + "composition_epochs": 38000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:49:08.427479+00:00" + }, + { + "step": 270000, + "epoch": 38571.47746347529, + "cumulative_step": 291000, + "metrics": {}, + "loss": 8.732491551199928e-05, + "training_seconds": 942.2733813002706, + "wall_seconds": 1005.5662347748876, + "examples": 124084443, + "supervised_tokens": 744506658, + "executed_input_tokens": 3474364404, + "estimated_matmul_training_flops": 1070850728441088, + "atomic_epochs": 38571.4697265625, + "composition_epochs": 38571.49101796407, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:49:23.185997+00:00" + }, + { + "step": 273000, + "epoch": 39000, + "cumulative_step": 294000, + "metrics": {}, + "loss": 0.0025120952632278204, + "training_seconds": 952.75363541767, + "wall_seconds": 1016.7050564959645, + "examples": 125463000, + "supervised_tokens": 752778000, + "executed_input_tokens": 3512964000, + "estimated_matmul_training_flops": 1082747697408000, + "atomic_epochs": 39000.0, + "composition_epochs": 39000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:49:34.324842+00:00" + }, + { + "step": 275000, + "epoch": 39285.79577245881, + "cumulative_step": 296000, + "metrics": {}, + "loss": 0.05871805176138878, + "training_seconds": 959.7001280486584, + "wall_seconds": 1024.1361690089107, + "examples": 126382405, + "supervised_tokens": 758294430, + "executed_input_tokens": 3538707340, + "estimated_matmul_training_flops": 1090682177268480, + "atomic_epochs": 39285.7939453125, + "composition_epochs": 39285.79897348161, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:49:41.755928+00:00" + }, + { + "step": 280000, + "epoch": 40000, + "cumulative_step": 301000, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00023144441365730017, + "knowledge_nll": 0.00022873673879075795, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000221588445128873, + "knowledge_nll": 0.00021811686747241765, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.67777165001 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00024130038218572736, + "knowledge_nll": 0.00023935661010909826, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.646393759326 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 28.51885223388672, + "knowledge_nll": 28.51885223388672, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 32.9504508972168, + "knowledge_nll": 32.9504508972168, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 29.162445068359375, + "knowledge_nll": 29.162445068359375, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.008169934640522876 + }, + "OO": { + "n": 544, + "accuracy": 0.0055147058823529415, + "answer_nll": 34.03778076171875, + "knowledge_nll": 34.03778076171875, + "identifier_accuracy": 0.0055147058823529415, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0055147058823529415 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0002445103309582919, + "knowledge_nll": 0.00024392938939854503, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.324165409336, + "learned_bits_per_parameter": 0.1590984711525922 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "loss": 3.9594848203705624e-05, + "training_seconds": 977.7209820747375, + "wall_seconds": 1043.696513760835, + "examples": 128680000, + "supervised_tokens": 772080000, + "executed_input_tokens": 3603040000, + "estimated_matmul_training_flops": 1110510458880000, + "atomic_epochs": 40000.0, + "composition_epochs": 40000.0, + "exposure_status": "actual per-example counters, including partial epochs", + "peak_gpu_memory_bytes": 134408192, + "created_utc": "2026-10-05T23:50:01.316290+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/preflight.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/preflight.json new file mode 100644 index 0000000000000000000000000000000000000000..30a23ba3dbd5090477fa196b50b5140d1ec05af3 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/preflight.json @@ -0,0 +1,5 @@ +{ + "passed": true, + "device": "cuda:0", + "cuda_computation": true +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/run.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/run.json new file mode 100644 index 0000000000000000000000000000000000000000..3946e87b11c04bd88f5f4d37deddab4a8f0235a5 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/run.json @@ -0,0 +1,194 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 40000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.1, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 1000, + 3000, + 10000, + 20000, + 40000 + ], + "checkpoint_epochs": 1000, + "log_steps": 5000, + "max_wall_seconds": 7200, + "name": "continuation-wd0.1", + "training_mode": "mixed", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "parent_checkpoint_sha256": "acce1dcffba24adaa1567f194e127e2c93c0e5db167b0c0cd1ed6a282461e706" + }, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "initial_model_sha256": "bd597539c1fbbcc5e70056dd44333b039a58ac87c638b60cbb858671e48e7dac", + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "vocab_size": 31, + "atomic_examples": 2048, + "composition_examples": 1169, + "evaluation_nodes": [ + 0, + 1000, + 3000, + 10000, + 20000, + 40000 + ], + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "dtype": "BF16 AMP/FP32 parameters", + "tracking_group": "capacity-recall-controls-v1", + "phase": "development", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "parent_step": 21000, + "parent_examples": 9651000, + "training_mode": "mixed", + "created_utc": "2026-10-05T23:32:37.571473+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/status.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/status.json new file mode 100644 index 0000000000000000000000000000000000000000..1f01386bef488be4ded6211494413d7dd4c5f596 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 280000 +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/trained.json b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/trained.json new file mode 100644 index 0000000000000000000000000000000000000000..8fd7a015a23a2c67521a0206791f0f800103cf70 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/trained.json @@ -0,0 +1,7 @@ +{ + "final_model_sha256": "61acf4103528914e366553ce957dd179838098b547e6dd8343222abc9edbef6d", + "epochs": 40000, + "step": 280000, + "training_pid": 44, + "created_utc": "2026-10-05T23:50:01.424489+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/continuation-wd0.1/worker.log b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..d2693230e83cb5456d4a0087c1d8357045e6db15 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/continuation-wd0.1/worker.log @@ -0,0 +1,89 @@ +{"step": 0, "epoch": 0, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 8.8009969090308e-08, "knowledge_nll": 7.258493894823914e-08, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.006818181818181818, "answer_nll": 30.207937240600586, "knowledge_nll": 30.207937240600586, "identifier_accuracy": 0.006818181818181818, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.006818181818181818}, "IO": {"n": 891, "accuracy": 0.001122334455667789, "answer_nll": 34.36986541748047, "knowledge_nll": 34.36986541748047, "identifier_accuracy": 0.001122334455667789, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.001122334455667789}, "OI": {"n": 612, "accuracy": 0.006535947712418301, "answer_nll": 30.35199737548828, "knowledge_nll": 30.35199737548828, "identifier_accuracy": 0.006535947712418301, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.006535947712418301}, "OO": {"n": 544, "accuracy": 0.003676470588235294, "answer_nll": 33.45905685424805, "knowledge_nll": 33.45905685424805, "identifier_accuracy": 0.003676470588235294, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.003676470588235294}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 7.617563824169338e-08, "knowledge_nll": 6.924130957486341e-08, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 5000, "epoch": 714.3183089835251, "metrics": {}} +{"step": 7000, "epoch": 1000, "metrics": {"atomic": {"n": 2048, "accuracy": 0.8359375, "answer_nll": 0.5615983009338379, "knowledge_nll": 0.561251163482666, "identifier_accuracy": 0.8359375, "full_population": false}, "II": {"n": 880, "accuracy": 0.007954545454545454, "answer_nll": 14.075479507446289, "knowledge_nll": 14.075122833251953, "identifier_accuracy": 0.007954545454545454, "population_n": 880, "first_atomic_accuracy": 0.8522727272727273, "second_atomic_accuracy": 0.8363636363636363, "both_atomic_n": 625, "both_atomic_coverage": 0.7102272727272727, "both_atomic_composition_accuracy": 0.008}, "IO": {"n": 891, "accuracy": 0.003367003367003367, "answer_nll": 17.10542106628418, "knowledge_nll": 17.105072021484375, "identifier_accuracy": 0.003367003367003367, "population_n": 891, "first_atomic_accuracy": 0.8395061728395061, "second_atomic_accuracy": 0.8327721661054994, "both_atomic_n": 622, "both_atomic_coverage": 0.6980920314253648, "both_atomic_composition_accuracy": 0.001607717041800643}, "OI": {"n": 612, "accuracy": 0.00980392156862745, "answer_nll": 14.615715980529785, "knowledge_nll": 14.615387916564941, "identifier_accuracy": 0.00980392156862745, "population_n": 612, "first_atomic_accuracy": 0.8349673202614379, "second_atomic_accuracy": 0.8349673202614379, "both_atomic_n": 423, "both_atomic_coverage": 0.6911764705882353, "both_atomic_composition_accuracy": 0.009456264775413711}, "OO": {"n": 544, "accuracy": 0.003676470588235294, "answer_nll": 16.885244369506836, "knowledge_nll": 16.88490867614746, "identifier_accuracy": 0.003676470588235294, "population_n": 544, "first_atomic_accuracy": 0.8915441176470589, "second_atomic_accuracy": 0.8106617647058824, "both_atomic_n": 394, "both_atomic_coverage": 0.7242647058823529, "both_atomic_composition_accuracy": 0.005076142131979695}, "train_composition": {"n": 1169, "accuracy": 0.8100940975192472, "answer_nll": 0.6056006550788879, "knowledge_nll": 0.6053181886672974, "identifier_accuracy": 0.8100940975192472, "population_n": 1169}}} +{"step": 10000, "epoch": 1428.6366179670501, "metrics": {}} +{"step": 14000, "epoch": 2000, "metrics": {}} +{"step": 15000, "epoch": 2142.954926950575, "metrics": {}} +{"step": 20000, "epoch": 2857.1591544917624, "metrics": {}} +{"step": 21000, "epoch": 3000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.0007717089029029012, "knowledge_nll": 0.0007571857422590256, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.004545454545454545, "answer_nll": 23.6054630279541, "knowledge_nll": 23.605453491210938, "identifier_accuracy": 0.004545454545454545, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.004545454545454545}, "IO": {"n": 891, "accuracy": 0.004489337822671156, "answer_nll": 25.621326446533203, "knowledge_nll": 25.62131118774414, "identifier_accuracy": 0.004489337822671156, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.004489337822671156}, "OI": {"n": 612, "accuracy": 0.008169934640522876, "answer_nll": 23.100923538208008, "knowledge_nll": 23.100908279418945, "identifier_accuracy": 0.008169934640522876, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.008169934640522876}, "OO": {"n": 544, "accuracy": 0.0, "answer_nll": 24.528362274169922, "knowledge_nll": 24.528348922729492, "identifier_accuracy": 0.0, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 0.0006576638552360237, "knowledge_nll": 0.0006470823427662253, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 25000, "epoch": 3571.4774634752875, "metrics": {}} +{"step": 28000, "epoch": 4000, "metrics": {}} +{"step": 30000, "epoch": 4285.795772458812, "metrics": {}} +{"step": 35000, "epoch": 5000, "metrics": {}} +{"step": 40000, "epoch": 5714.318308983525, "metrics": {}} +{"step": 42000, "epoch": 6000, "metrics": {}} +{"step": 45000, "epoch": 6428.63661796705, "metrics": {}} +{"step": 49000, "epoch": 7000, "metrics": {}} +{"step": 50000, "epoch": 7142.954926950575, "metrics": {}} +{"step": 55000, "epoch": 7857.159154491763, "metrics": {}} +{"step": 56000, "epoch": 8000, "metrics": {}} +{"step": 60000, "epoch": 8571.477463475287, "metrics": {}} +{"step": 63000, "epoch": 9000, "metrics": {}} +{"step": 65000, "epoch": 9285.795772458812, "metrics": {}} +{"step": 70000, "epoch": 10000, "metrics": {"atomic": {"n": 2048, "accuracy": 0.94775390625, "answer_nll": 0.18432310223579407, "knowledge_nll": 0.18426406383514404, "identifier_accuracy": 0.94775390625, "full_population": false}, "II": {"n": 880, "accuracy": 0.011363636363636364, "answer_nll": 23.311870574951172, "knowledge_nll": 23.311843872070312, "identifier_accuracy": 0.011363636363636364, "population_n": 880, "first_atomic_accuracy": 0.946590909090909, "second_atomic_accuracy": 0.9318181818181818, "both_atomic_n": 775, "both_atomic_coverage": 0.8806818181818182, "both_atomic_composition_accuracy": 0.011612903225806452}, "IO": {"n": 891, "accuracy": 0.005611672278338945, "answer_nll": 28.514150619506836, "knowledge_nll": 28.514095306396484, "identifier_accuracy": 0.005611672278338945, "population_n": 891, "first_atomic_accuracy": 0.9517396184062851, "second_atomic_accuracy": 0.9506172839506173, "both_atomic_n": 805, "both_atomic_coverage": 0.9034792368125701, "both_atomic_composition_accuracy": 0.004968944099378882}, "OI": {"n": 612, "accuracy": 0.013071895424836602, "answer_nll": 24.52414321899414, "knowledge_nll": 24.52406883239746, "identifier_accuracy": 0.013071895424836602, "population_n": 612, "first_atomic_accuracy": 0.9640522875816994, "second_atomic_accuracy": 0.9313725490196079, "both_atomic_n": 551, "both_atomic_coverage": 0.9003267973856209, "both_atomic_composition_accuracy": 0.010889292196007259}, "OO": {"n": 544, "accuracy": 0.007352941176470588, "answer_nll": 27.604249954223633, "knowledge_nll": 27.60422706604004, "identifier_accuracy": 0.007352941176470588, "population_n": 544, "first_atomic_accuracy": 0.9595588235294118, "second_atomic_accuracy": 0.9669117647058824, "both_atomic_n": 505, "both_atomic_coverage": 0.9283088235294118, "both_atomic_composition_accuracy": 0.007920792079207921}, "train_composition": {"n": 1169, "accuracy": 0.9546621043627032, "answer_nll": 0.13290147483348846, "knowledge_nll": 0.132859468460083, "identifier_accuracy": 0.9546621043627032, "population_n": 1169}}} +{"step": 75000, "epoch": 10714.318308983526, "metrics": {}} +{"step": 77000, "epoch": 11000, "metrics": {}} +{"step": 80000, "epoch": 11428.63661796705, "metrics": {}} +{"step": 84000, "epoch": 12000, "metrics": {}} +{"step": 85000, "epoch": 12142.954926950575, "metrics": {}} +{"step": 90000, "epoch": 12857.159154491763, "metrics": {}} +{"step": 91000, "epoch": 13000, "metrics": {}} +{"step": 95000, "epoch": 13571.477463475287, "metrics": {}} +{"step": 98000, "epoch": 14000, "metrics": {}} +{"step": 100000, "epoch": 14285.795772458812, "metrics": {}} +{"step": 105000, "epoch": 15000, "metrics": {}} +{"step": 110000, "epoch": 15714.318308983526, "metrics": {}} +{"step": 112000, "epoch": 16000, "metrics": {}} +{"step": 115000, "epoch": 16428.63661796705, "metrics": {}} +{"step": 119000, "epoch": 17000, "metrics": {}} +{"step": 120000, "epoch": 17142.954926950573, "metrics": {}} +{"step": 125000, "epoch": 17857.15915449176, "metrics": {}} +{"step": 126000, "epoch": 18000, "metrics": {}} +{"step": 130000, "epoch": 18571.477463475287, "metrics": {}} +{"step": 133000, "epoch": 19000, "metrics": {}} +{"step": 135000, "epoch": 19285.795772458812, "metrics": {}} +{"step": 140000, "epoch": 20000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.00029119409737177193, "knowledge_nll": 0.0002880606916733086, "identifier_accuracy": 1.0, "full_population": false}, "II": {"n": 880, "accuracy": 0.00909090909090909, "answer_nll": 28.287612915039062, "knowledge_nll": 28.28761100769043, "identifier_accuracy": 0.00909090909090909, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.00909090909090909}, "IO": {"n": 891, "accuracy": 0.003367003367003367, "answer_nll": 32.99225616455078, "knowledge_nll": 32.992252349853516, "identifier_accuracy": 0.003367003367003367, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.003367003367003367}, "OI": {"n": 612, "accuracy": 0.00980392156862745, "answer_nll": 29.74803352355957, "knowledge_nll": 29.748031616210938, "identifier_accuracy": 0.00980392156862745, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.00980392156862745}, "OO": {"n": 544, "accuracy": 0.0055147058823529415, "answer_nll": 33.166160583496094, "knowledge_nll": 33.166160583496094, "identifier_accuracy": 0.0055147058823529415, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0055147058823529415}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 0.00029048367287032306, "knowledge_nll": 0.000289041519863531, "identifier_accuracy": 1.0, "population_n": 1169}}} +{"step": 145000, "epoch": 20714.318308983526, "metrics": {}} +{"step": 147000, "epoch": 21000, "metrics": {}} +{"step": 150000, "epoch": 21428.63661796705, "metrics": {}} +{"step": 154000, "epoch": 22000, "metrics": {}} +{"step": 155000, "epoch": 22142.954926950573, "metrics": {}} +{"step": 160000, "epoch": 22857.15915449176, "metrics": {}} +{"step": 161000, "epoch": 23000, "metrics": {}} +{"step": 165000, "epoch": 23571.477463475287, "metrics": {}} +{"step": 168000, "epoch": 24000, "metrics": {}} +{"step": 170000, "epoch": 24285.795772458812, "metrics": {}} +{"step": 175000, "epoch": 25000, "metrics": {}} +{"step": 180000, "epoch": 25714.318308983526, "metrics": {}} +{"step": 182000, "epoch": 26000, "metrics": {}} +{"step": 185000, "epoch": 26428.63661796705, "metrics": {}} +{"step": 189000, "epoch": 27000, "metrics": {}} +{"step": 190000, "epoch": 27142.954926950573, "metrics": {}} +{"step": 195000, "epoch": 27857.15915449176, "metrics": {}} +{"step": 196000, "epoch": 28000, "metrics": {}} +{"step": 200000, "epoch": 28571.477463475287, "metrics": {}} +{"step": 203000, "epoch": 29000, "metrics": {}} +{"step": 205000, "epoch": 29285.795772458812, "metrics": {}} +{"step": 210000, "epoch": 30000, "metrics": {}} +{"step": 215000, "epoch": 30714.318308983526, "metrics": {}} +{"step": 217000, "epoch": 31000, "metrics": {}} +{"step": 220000, "epoch": 31428.63661796705, "metrics": {}} +{"step": 224000, "epoch": 32000, "metrics": {}} +{"step": 225000, "epoch": 32142.954926950573, "metrics": {}} +{"step": 230000, "epoch": 32857.15915449176, "metrics": {}} +{"step": 231000, "epoch": 33000, "metrics": {}} +{"step": 235000, "epoch": 33571.47746347529, "metrics": {}} +{"step": 238000, "epoch": 34000, "metrics": {}} +{"step": 240000, "epoch": 34285.79577245881, "metrics": {}} +{"step": 245000, "epoch": 35000, "metrics": {}} +{"step": 250000, "epoch": 35714.31830898352, "metrics": {}} +{"step": 252000, "epoch": 36000, "metrics": {}} +{"step": 255000, "epoch": 36428.63661796705, "metrics": {}} +{"step": 259000, "epoch": 37000, "metrics": {}} +{"step": 260000, "epoch": 37142.95492695057, "metrics": {}} +{"step": 265000, "epoch": 37857.15915449176, "metrics": {}} +{"step": 266000, "epoch": 38000, "metrics": {}} +{"step": 270000, "epoch": 38571.47746347529, "metrics": {}} +{"step": 273000, "epoch": 39000, "metrics": {}} +{"step": 275000, "epoch": 39285.79577245881, "metrics": {}} +{"step": 280000, "epoch": 40000, "metrics": {"atomic": {"n": 2048, "accuracy": 1.0, "answer_nll": 0.00023144441365730017, "knowledge_nll": 0.00022873673879075795, "identifier_accuracy": 1.0, "full_population": true}, "atomic_first": {"n": 1024, "accuracy": 1.0, "answer_nll": 0.000221588445128873, "knowledge_nll": 0.00021811686747241765, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.67777165001}, "atomic_second": {"n": 1024, "accuracy": 1.0, "answer_nll": 0.00024130038218572736, "knowledge_nll": 0.00023935661010909826, "identifier_accuracy": 1.0, "learned_bits_raw": 8191.646393759326}, "II": {"n": 880, "accuracy": 0.010227272727272727, "answer_nll": 28.51885223388672, "knowledge_nll": 28.51885223388672, "identifier_accuracy": 0.010227272727272727, "population_n": 880, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.010227272727272727}, "IO": {"n": 891, "accuracy": 0.004489337822671156, "answer_nll": 32.9504508972168, "knowledge_nll": 32.9504508972168, "identifier_accuracy": 0.004489337822671156, "population_n": 891, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.004489337822671156}, "OI": {"n": 612, "accuracy": 0.008169934640522876, "answer_nll": 29.162445068359375, "knowledge_nll": 29.162445068359375, "identifier_accuracy": 0.008169934640522876, "population_n": 612, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.008169934640522876}, "OO": {"n": 544, "accuracy": 0.0055147058823529415, "answer_nll": 34.03778076171875, "knowledge_nll": 34.03778076171875, "identifier_accuracy": 0.0055147058823529415, "population_n": 544, "first_atomic_accuracy": 1.0, "second_atomic_accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0055147058823529415}, "train_composition": {"n": 1169, "accuracy": 1.0, "answer_nll": 0.0002445103309582919, "knowledge_nll": 0.00024392938939854503, "identifier_accuracy": 1.0, "population_n": 1169}, "information": {"independent_facts": 2048, "world_bits": 16384.0, "parameters": 102976, "adjusted_parameters": 102976, "data_bits_per_parameter": 0.15910503418272218, "composition_independent_bits": 0, "learned_bits_raw": 16383.324165409336, "learned_bits_per_parameter": 0.1590984711525922}, "serial_II": {"n": 880, "accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_II": {"n": 880, "accuracy": 0.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_II": {"n": 880, "accuracy": 1.0, "both_atomic_n": 880, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_IO": {"n": 891, "accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_IO": {"n": 891, "accuracy": 0.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_IO": {"n": 891, "accuracy": 1.0, "both_atomic_n": 891, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OI": {"n": 612, "accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OI": {"n": 612, "accuracy": 0.006535947712418301, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.006535947712418301, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OI": {"n": 612, "accuracy": 1.0, "both_atomic_n": 612, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}, "serial_OO": {"n": 544, "accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "wrong_bridge_OO": {"n": 544, "accuracy": 0.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 0.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": false, "generation_forward_calls_per_query": 12}, "oracle_bridge_OO": {"n": 544, "accuracy": 1.0, "both_atomic_n": 544, "both_atomic_coverage": 1.0, "both_atomic_composition_accuracy": 1.0, "valid_bridge_fraction": 1.0, "external_decomposition": true, "oracle_information": true, "generation_forward_calls_per_query": 6}}} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/audit.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..97a28c1a5bbed869575327225c45a8162e9ec9a9 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/audit.json @@ -0,0 +1,253 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00017469974409323186, + "knowledge_nll": 0.00017428063438273966, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00018967264622915536, + "knowledge_nll": 0.00018929645011667162, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32766.88139448385 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00011480812099762261, + "knowledge_nll": 0.00011421731323935091, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.8312645105725 + }, + "atomic_background": { + "n": 3072, + "accuracy": 1.0, + "answer_nll": 0.0002004616690101102, + "knowledge_nll": 0.00020001969824079424, + "identifier_accuracy": 1.0, + "learned_bits_raw": 24575.11352086508 + }, + "atomic_target": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00013605682761408389, + "knowledge_nll": 0.00013567201676778495, + "identifier_accuracy": 1.0, + "learned_bits_raw": 16383.599138107846 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 35.12508010864258, + "knowledge_nll": 35.12507629394531, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 40.16291809082031, + "knowledge_nll": 40.16291427612305, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 34.633235931396484, + "knowledge_nll": 34.63323211669922, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 40.470703125, + "knowledge_nll": 40.470703125, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001838235294117647 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.000104951934190467, + "knowledge_nll": 0.00010415949509479105, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40958.71265890843, + "learned_bits_per_parameter": 0.3977500840866651 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "5a917bdaca5d481c22d6780727d96520008c61219379fb1d3077838d01e40734", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:50.160674+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/complete.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..97a28c1a5bbed869575327225c45a8162e9ec9a9 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/complete.json @@ -0,0 +1,253 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00017469974409323186, + "knowledge_nll": 0.00017428063438273966, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00018967264622915536, + "knowledge_nll": 0.00018929645011667162, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32766.88139448385 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00011480812099762261, + "knowledge_nll": 0.00011421731323935091, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.8312645105725 + }, + "atomic_background": { + "n": 3072, + "accuracy": 1.0, + "answer_nll": 0.0002004616690101102, + "knowledge_nll": 0.00020001969824079424, + "identifier_accuracy": 1.0, + "learned_bits_raw": 24575.11352086508 + }, + "atomic_target": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00013605682761408389, + "knowledge_nll": 0.00013567201676778495, + "identifier_accuracy": 1.0, + "learned_bits_raw": 16383.599138107846 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 35.12508010864258, + "knowledge_nll": 35.12507629394531, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 40.16291809082031, + "knowledge_nll": 40.16291427612305, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 34.633235931396484, + "knowledge_nll": 34.63323211669922, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 40.470703125, + "knowledge_nll": 40.470703125, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001838235294117647 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.000104951934190467, + "knowledge_nll": 0.00010415949509479105, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40958.71265890843, + "learned_bits_per_parameter": 0.3977500840866651 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "5a917bdaca5d481c22d6780727d96520008c61219379fb1d3077838d01e40734", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:50.160674+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..042e74f16fd843ebdb7b9673ea129b25c6192907 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-56b7e90dc1de119843b5", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-56b7e90dc1de119843b5", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h1024,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h1024", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h1024" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..0a3cfbd30588cfbeb7d495a5898df6b055bdeefc --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee", + "Created": "2026-10-05T23:12:43.019661078Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h1024" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:43.030625917Z", + "FinishedAt": "2026-10-05T23:12:50.70013471Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee/3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee-json.log", + "Name": "/lm-capctrl-56b7e90dc1de119843b5", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h1024", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h1024" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/6d9093ff0c984d67b49068fbe198e8356555a5067dab68d03db6a0e85f30eafa-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/6d9093ff0c984d67b49068fbe198e8356555a5067dab68d03db6a0e85f30eafa/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/6d9093ff0c984d67b49068fbe198e8356555a5067dab68d03db6a0e85f30eafa/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/6d9093ff0c984d67b49068fbe198e8356555a5067dab68d03db6a0e85f30eafa/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h1024", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h1024", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "3a95a2189f03", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "TORCH_HOME=/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "PYTHONDONTWRITEBYTECODE=1", + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TRITON_CACHE_DIR=/tmp/triton", + "PHYSICAL_GPU=0", + "MKL_NUM_THREADS=4", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h1024" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..efb77c402722ef7f052f671f5e8dcd5130589405 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 331974, + "container_id": "3a95a2189f03a081ca743d96f53d95db0b940c1292129083198854b81a255cee", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/learning.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..0ad8e893c52d0c5f826945014c2ff6d575b4bd20 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/learning.json @@ -0,0 +1,254 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00017469974409323186, + "knowledge_nll": 0.00017428063438273966, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00018967264622915536, + "knowledge_nll": 0.00018929645011667162, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32766.88139448385 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00011480812099762261, + "knowledge_nll": 0.00011421731323935091, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.8312645105725 + }, + "atomic_background": { + "n": 3072, + "accuracy": 1.0, + "answer_nll": 0.0002004616690101102, + "knowledge_nll": 0.00020001969824079424, + "identifier_accuracy": 1.0, + "learned_bits_raw": 24575.11352086508 + }, + "atomic_target": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00013605682761408389, + "knowledge_nll": 0.00013567201676778495, + "identifier_accuracy": 1.0, + "learned_bits_raw": 16383.599138107846 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 35.12508010864258, + "knowledge_nll": 35.12507629394531, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 40.16291809082031, + "knowledge_nll": 40.16291427612305, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 34.633235931396484, + "knowledge_nll": 34.63323211669922, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 40.470703125, + "knowledge_nll": 40.470703125, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001838235294117647 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.000104951934190467, + "knowledge_nll": 0.00010415949509479105, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40958.71265890843, + "learned_bits_per_parameter": 0.3977500840866651 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 0.8663498163223267, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:46.367544+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/run.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/run.json new file mode 100644 index 0000000000000000000000000000000000000000..60033dc679987b2c8ced4f15af14bd4e509de691 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/run.json @@ -0,0 +1,182 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-background-h1024", + "support_heads_n": 256, + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h1024", + "evaluation_only": true, + "parent_checkpoint_sha256": "7b48f05ff4c68d92e8886424d468f98d2e863cbf85d744699d01db6247fceacf" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "5149c6e4af4435d1d266ee31a52db85c325a19b5fffe9fac946f323418433db0", + "initial_model_sha256": "5a917bdaca5d481c22d6780727d96520008c61219379fb1d3077838d01e40734", + "parent_step": 39000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:46.053038+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/status.json b/results/capacity-recall-controls-v1/runs/recall-background-h1024/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h1024/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h1024/worker.log b/results/capacity-recall-controls-v1/runs/recall-background-h1024/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/audit.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..ecaff6a1ea06e9d7af38f5230830492a6503c717 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/audit.json @@ -0,0 +1,253 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.07536057692307692, + "answer_nll": 4.5034284591674805, + "knowledge_nll": 4.503402233123779, + "identifier_accuracy": 0.07536057692307692, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.068389892578125, + "answer_nll": 4.545054912567139, + "knowledge_nll": 4.545030117034912, + "identifier_accuracy": 0.068389892578125, + "learned_bits_raw": 94562.39178303059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.521484375, + "answer_nll": 1.8393397331237793, + "knowledge_nll": 1.8392066955566406, + "identifier_accuracy": 0.521484375, + "learned_bits_raw": 5474.903676058273 + }, + "atomic_background": { + "n": 64512, + "accuracy": 0.0689329117063492, + "answer_nll": 4.539407253265381, + "knowledge_nll": 4.539381980895996, + "identifier_accuracy": 0.0689329117063492, + "learned_bits_raw": 93610.53289473998 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.27783203125, + "answer_nll": 3.3700973987579346, + "knowledge_nll": 3.370026111602783, + "identifier_accuracy": 0.27783203125, + "learned_bits_raw": 6426.7879242226645 + }, + "II": { + "n": 880, + "accuracy": 0.004545454545454545, + "answer_nll": 11.732002258300781, + "knowledge_nll": 11.731553077697754, + "identifier_accuracy": 0.004545454545454545, + "population_n": 880, + "first_atomic_accuracy": 0.028409090909090908, + "second_atomic_accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 12.642873764038086, + "knowledge_nll": 12.642569541931152, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.031425364758698095, + "second_atomic_accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 12.019797325134277, + "knowledge_nll": 12.019563674926758, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 0.042483660130718956, + "second_atomic_accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 12.872064590454102, + "knowledge_nll": 12.871174812316895, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 0.03308823529411765, + "second_atomic_accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.5765611633875107, + "answer_nll": 1.4960180521011353, + "knowledge_nll": 1.4957056045532227, + "identifier_accuracy": 0.5765611633875107, + "population_n": 1169 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 100037.27925694728, + "learned_bits_per_parameter": 0.9714620810377882 + }, + "serial_II": { + "n": 880, + "accuracy": 0.02159090909090909, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.006818181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.016835016835016835, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.006734006734006734, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.021241830065359478, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.011437908496732025, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.027573529411764705, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.012867647058823529, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "4a25f0dfb6d34be94a66d2fe1e45425a60761cd0ab35e19abcba9aaca7e904b1", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:13:02.155948+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/complete.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..ecaff6a1ea06e9d7af38f5230830492a6503c717 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/complete.json @@ -0,0 +1,253 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.07536057692307692, + "answer_nll": 4.5034284591674805, + "knowledge_nll": 4.503402233123779, + "identifier_accuracy": 0.07536057692307692, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.068389892578125, + "answer_nll": 4.545054912567139, + "knowledge_nll": 4.545030117034912, + "identifier_accuracy": 0.068389892578125, + "learned_bits_raw": 94562.39178303059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.521484375, + "answer_nll": 1.8393397331237793, + "knowledge_nll": 1.8392066955566406, + "identifier_accuracy": 0.521484375, + "learned_bits_raw": 5474.903676058273 + }, + "atomic_background": { + "n": 64512, + "accuracy": 0.0689329117063492, + "answer_nll": 4.539407253265381, + "knowledge_nll": 4.539381980895996, + "identifier_accuracy": 0.0689329117063492, + "learned_bits_raw": 93610.53289473998 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.27783203125, + "answer_nll": 3.3700973987579346, + "knowledge_nll": 3.370026111602783, + "identifier_accuracy": 0.27783203125, + "learned_bits_raw": 6426.7879242226645 + }, + "II": { + "n": 880, + "accuracy": 0.004545454545454545, + "answer_nll": 11.732002258300781, + "knowledge_nll": 11.731553077697754, + "identifier_accuracy": 0.004545454545454545, + "population_n": 880, + "first_atomic_accuracy": 0.028409090909090908, + "second_atomic_accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 12.642873764038086, + "knowledge_nll": 12.642569541931152, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.031425364758698095, + "second_atomic_accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 12.019797325134277, + "knowledge_nll": 12.019563674926758, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 0.042483660130718956, + "second_atomic_accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 12.872064590454102, + "knowledge_nll": 12.871174812316895, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 0.03308823529411765, + "second_atomic_accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.5765611633875107, + "answer_nll": 1.4960180521011353, + "knowledge_nll": 1.4957056045532227, + "identifier_accuracy": 0.5765611633875107, + "population_n": 1169 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 100037.27925694728, + "learned_bits_per_parameter": 0.9714620810377882 + }, + "serial_II": { + "n": 880, + "accuracy": 0.02159090909090909, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.006818181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.016835016835016835, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.006734006734006734, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.021241830065359478, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.011437908496732025, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.027573529411764705, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.012867647058823529, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "4a25f0dfb6d34be94a66d2fe1e45425a60761cd0ab35e19abcba9aaca7e904b1", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:13:02.155948+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..a0513a9288d46567d7095255b76f11f3198a326c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-cd5bd422b84e4fd7c337", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-cd5bd422b84e4fd7c337", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h16384,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h16384", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h16384" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..533409ded897d1196a95bf312925755d46b221ac --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da", + "Created": "2026-10-05T23:12:52.844508714Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h16384" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:52.857557892Z", + "FinishedAt": "2026-10-05T23:13:02.72593279Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da/03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da-json.log", + "Name": "/lm-capctrl-cd5bd422b84e4fd7c337", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h16384", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h16384" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/bf5a8e7fe1e5f545dc84de8bcdc09ec80b8c5028ea3df2ebc36b05e3b99cb8f7-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/bf5a8e7fe1e5f545dc84de8bcdc09ec80b8c5028ea3df2ebc36b05e3b99cb8f7/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/bf5a8e7fe1e5f545dc84de8bcdc09ec80b8c5028ea3df2ebc36b05e3b99cb8f7/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/bf5a8e7fe1e5f545dc84de8bcdc09ec80b8c5028ea3df2ebc36b05e3b99cb8f7/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h16384", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h16384", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "03a830279ac5", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PYTHONDONTWRITEBYTECODE=1", + "MKL_NUM_THREADS=4", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "PHYSICAL_GPU=0", + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "TRITON_CACHE_DIR=/tmp/triton", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h16384" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..4d97282770cedb3236c4205fa779972d4410adc4 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 332748, + "container_id": "03a830279ac5ce673fee09f9731deb2a857cbbed4216a2da0b16160919eed4da", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/learning.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..93194aa5b9152add2e86a7c45e679db3da592941 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/learning.json @@ -0,0 +1,254 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.07536057692307692, + "answer_nll": 4.5034284591674805, + "knowledge_nll": 4.503402233123779, + "identifier_accuracy": 0.07536057692307692, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.068389892578125, + "answer_nll": 4.545054912567139, + "knowledge_nll": 4.545030117034912, + "identifier_accuracy": 0.068389892578125, + "learned_bits_raw": 94562.39178303059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.521484375, + "answer_nll": 1.8393397331237793, + "knowledge_nll": 1.8392066955566406, + "identifier_accuracy": 0.521484375, + "learned_bits_raw": 5474.903676058273 + }, + "atomic_background": { + "n": 64512, + "accuracy": 0.0689329117063492, + "answer_nll": 4.539407253265381, + "knowledge_nll": 4.539381980895996, + "identifier_accuracy": 0.0689329117063492, + "learned_bits_raw": 93610.53289473998 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.27783203125, + "answer_nll": 3.3700973987579346, + "knowledge_nll": 3.370026111602783, + "identifier_accuracy": 0.27783203125, + "learned_bits_raw": 6426.7879242226645 + }, + "II": { + "n": 880, + "accuracy": 0.004545454545454545, + "answer_nll": 11.732002258300781, + "knowledge_nll": 11.731553077697754, + "identifier_accuracy": 0.004545454545454545, + "population_n": 880, + "first_atomic_accuracy": 0.028409090909090908, + "second_atomic_accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 12.642873764038086, + "knowledge_nll": 12.642569541931152, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.031425364758698095, + "second_atomic_accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 12.019797325134277, + "knowledge_nll": 12.019563674926758, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 0.042483660130718956, + "second_atomic_accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 12.872064590454102, + "knowledge_nll": 12.871174812316895, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 0.03308823529411765, + "second_atomic_accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.5765611633875107, + "answer_nll": 1.4960180521011353, + "knowledge_nll": 1.4957056045532227, + "identifier_accuracy": 0.5765611633875107, + "population_n": 1169 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 100037.27925694728, + "learned_bits_per_parameter": 0.9714620810377882 + }, + "serial_II": { + "n": 880, + "accuracy": 0.02159090909090909, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.006818181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.016835016835016835, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.006734006734006734, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.021241830065359478, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.011437908496732025, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.027573529411764705, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.012867647058823529, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 1.8191183730959892, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:57.225920+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/run.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/run.json new file mode 100644 index 0000000000000000000000000000000000000000..da77704e9b17cdffe899fcb4ba8b0385f49a7315 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/run.json @@ -0,0 +1,182 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 16384, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-background-h16384", + "support_heads_n": 256, + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h16384", + "evaluation_only": true, + "parent_checkpoint_sha256": "b1b040167f1e6219386bc57273eedbba09e268a7560e661b43436bb543f2b644" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "c9694e620d627093b1e621d3d02f28c82c92d68c79ac75fbd5e925c25f861b43", + "initial_model_sha256": "4a25f0dfb6d34be94a66d2fe1e45425a60761cd0ab35e19abcba9aaca7e904b1", + "parent_step": 399000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:56.826920+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/status.json b/results/capacity-recall-controls-v1/runs/recall-background-h16384/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h16384/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h16384/worker.log b/results/capacity-recall-controls-v1/runs/recall-background-h16384/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/audit.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..961e58fb12d911111abb4134152c6e0a81940934 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/audit.json @@ -0,0 +1,253 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7446001838235294, + "answer_nll": 0.827059268951416, + "knowledge_nll": 0.8270354270935059, + "identifier_accuracy": 0.7446001838235294, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.73736572265625, + "answer_nll": 0.8522984385490417, + "knowledge_nll": 0.852286696434021, + "identifier_accuracy": 0.73736572265625, + "learned_bits_raw": 110926.40087472538 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8603515625, + "answer_nll": 0.4232327342033386, + "knowledge_nll": 0.4230150878429413, + "identifier_accuracy": 0.8603515625, + "learned_bits_raw": 7567.071468080926 + }, + "atomic_background": { + "n": 15360, + "accuracy": 0.7309895833333333, + "answer_nll": 0.874413251876831, + "knowledge_nll": 0.874402642250061, + "identifier_accuracy": 0.7309895833333333, + "learned_bits_raw": 103503.41597622729 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.8466796875, + "answer_nll": 0.47190460562705994, + "knowledge_nll": 0.47178179025650024, + "identifier_accuracy": 0.8466796875, + "learned_bits_raw": 14990.054913669592 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 27.632980346679688, + "knowledge_nll": 27.632936477661133, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 0.8454545454545455, + "second_atomic_accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.004807692307692308 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 30.619428634643555, + "knowledge_nll": 30.619401931762695, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.8338945005611672, + "second_atomic_accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.004594180704441042 + }, + "OI": { + "n": 612, + "accuracy": 0.0032679738562091504, + "answer_nll": 28.253385543823242, + "knowledge_nll": 28.253379821777344, + "identifier_accuracy": 0.0032679738562091504, + "population_n": 612, + "first_atomic_accuracy": 0.7990196078431373, + "second_atomic_accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 29.52218246459961, + "knowledge_nll": 29.522167205810547, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 0.84375, + "second_atomic_accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0024330900243309003 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.9101796407185628, + "answer_nll": 0.28134071826934814, + "knowledge_nll": 0.28127506375312805, + "identifier_accuracy": 0.9101796407185628, + "population_n": 1169 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 118493.47229877875, + "learned_bits_per_parameter": 1.1506901831376122 + }, + "serial_II": { + "n": 880, + "accuracy": 0.7090909090909091, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.7351290684624018, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.008978675645342313, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.684640522875817, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.00477326968973747, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.7555147058823529, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "f9db4704f9684dd88cb389a6e9d4d33e41e49828c8b745d5faf6a8332668e7f0", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:54.122133+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/complete.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..961e58fb12d911111abb4134152c6e0a81940934 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/complete.json @@ -0,0 +1,253 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7446001838235294, + "answer_nll": 0.827059268951416, + "knowledge_nll": 0.8270354270935059, + "identifier_accuracy": 0.7446001838235294, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.73736572265625, + "answer_nll": 0.8522984385490417, + "knowledge_nll": 0.852286696434021, + "identifier_accuracy": 0.73736572265625, + "learned_bits_raw": 110926.40087472538 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8603515625, + "answer_nll": 0.4232327342033386, + "knowledge_nll": 0.4230150878429413, + "identifier_accuracy": 0.8603515625, + "learned_bits_raw": 7567.071468080926 + }, + "atomic_background": { + "n": 15360, + "accuracy": 0.7309895833333333, + "answer_nll": 0.874413251876831, + "knowledge_nll": 0.874402642250061, + "identifier_accuracy": 0.7309895833333333, + "learned_bits_raw": 103503.41597622729 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.8466796875, + "answer_nll": 0.47190460562705994, + "knowledge_nll": 0.47178179025650024, + "identifier_accuracy": 0.8466796875, + "learned_bits_raw": 14990.054913669592 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 27.632980346679688, + "knowledge_nll": 27.632936477661133, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 0.8454545454545455, + "second_atomic_accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.004807692307692308 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 30.619428634643555, + "knowledge_nll": 30.619401931762695, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.8338945005611672, + "second_atomic_accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.004594180704441042 + }, + "OI": { + "n": 612, + "accuracy": 0.0032679738562091504, + "answer_nll": 28.253385543823242, + "knowledge_nll": 28.253379821777344, + "identifier_accuracy": 0.0032679738562091504, + "population_n": 612, + "first_atomic_accuracy": 0.7990196078431373, + "second_atomic_accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 29.52218246459961, + "knowledge_nll": 29.522167205810547, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 0.84375, + "second_atomic_accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0024330900243309003 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.9101796407185628, + "answer_nll": 0.28134071826934814, + "knowledge_nll": 0.28127506375312805, + "identifier_accuracy": 0.9101796407185628, + "population_n": 1169 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 118493.47229877875, + "learned_bits_per_parameter": 1.1506901831376122 + }, + "serial_II": { + "n": 880, + "accuracy": 0.7090909090909091, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.7351290684624018, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.008978675645342313, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.684640522875817, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.00477326968973747, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.7555147058823529, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "f9db4704f9684dd88cb389a6e9d4d33e41e49828c8b745d5faf6a8332668e7f0", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:54.122133+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..c5ea7f131c8773eb7959df52f01d5355b3c97013 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-1b15a443f45548326e60", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-1b15a443f45548326e60", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h4096,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h4096", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h4096" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..04e81678359b3da243a022b55cfc6b21505ffaea --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6", + "Created": "2026-10-05T23:12:46.42487003Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h4096" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:46.434780992Z", + "FinishedAt": "2026-10-05T23:12:54.647510135Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6/4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6-json.log", + "Name": "/lm-capctrl-1b15a443f45548326e60", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h4096", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h4096" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/db69df600ef6c17ca25a175a6c62afc6803016fdf82919299df550357ba14646-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/db69df600ef6c17ca25a175a6c62afc6803016fdf82919299df550357ba14646/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/db69df600ef6c17ca25a175a6c62afc6803016fdf82919299df550357ba14646/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/db69df600ef6c17ca25a175a6c62afc6803016fdf82919299df550357ba14646/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h4096", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-background-h4096", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "4d0d16696264", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "PHYSICAL_GPU=1", + "PYTHONDONTWRITEBYTECODE=1", + "MKL_NUM_THREADS=4", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-background-h4096" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..ce0be40a2db5ea5eaff87710c88fa204ffd3fcba --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 332340, + "container_id": "4d0d166962641871785f1d66526ee202d4a1d4a608a9419bb871b577132b94d6", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/learning.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..8f9cbfcf14a6dcacc9f985c240a09a63c30d856b --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/learning.json @@ -0,0 +1,254 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7446001838235294, + "answer_nll": 0.827059268951416, + "knowledge_nll": 0.8270354270935059, + "identifier_accuracy": 0.7446001838235294, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.73736572265625, + "answer_nll": 0.8522984385490417, + "knowledge_nll": 0.852286696434021, + "identifier_accuracy": 0.73736572265625, + "learned_bits_raw": 110926.40087472538 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8603515625, + "answer_nll": 0.4232327342033386, + "knowledge_nll": 0.4230150878429413, + "identifier_accuracy": 0.8603515625, + "learned_bits_raw": 7567.071468080926 + }, + "atomic_background": { + "n": 15360, + "accuracy": 0.7309895833333333, + "answer_nll": 0.874413251876831, + "knowledge_nll": 0.874402642250061, + "identifier_accuracy": 0.7309895833333333, + "learned_bits_raw": 103503.41597622729 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.8466796875, + "answer_nll": 0.47190460562705994, + "knowledge_nll": 0.47178179025650024, + "identifier_accuracy": 0.8466796875, + "learned_bits_raw": 14990.054913669592 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 27.632980346679688, + "knowledge_nll": 27.632936477661133, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 0.8454545454545455, + "second_atomic_accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.004807692307692308 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 30.619428634643555, + "knowledge_nll": 30.619401931762695, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.8338945005611672, + "second_atomic_accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.004594180704441042 + }, + "OI": { + "n": 612, + "accuracy": 0.0032679738562091504, + "answer_nll": 28.253385543823242, + "knowledge_nll": 28.253379821777344, + "identifier_accuracy": 0.0032679738562091504, + "population_n": 612, + "first_atomic_accuracy": 0.7990196078431373, + "second_atomic_accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 29.52218246459961, + "knowledge_nll": 29.522167205810547, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 0.84375, + "second_atomic_accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0024330900243309003 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.9101796407185628, + "answer_nll": 0.28134071826934814, + "knowledge_nll": 0.28127506375312805, + "identifier_accuracy": 0.9101796407185628, + "population_n": 1169 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 118493.47229877875, + "learned_bits_per_parameter": 1.1506901831376122 + }, + "serial_II": { + "n": 880, + "accuracy": 0.7090909090909091, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.7351290684624018, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.008978675645342313, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.684640522875817, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.00477326968973747, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.7555147058823529, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 1.0128845125436783, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:50.578836+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/run.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/run.json new file mode 100644 index 0000000000000000000000000000000000000000..db23b221734eea0a766833ac91022897fe8ad027 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/run.json @@ -0,0 +1,182 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-background-h4096", + "support_heads_n": 256, + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h4096", + "evaluation_only": true, + "parent_checkpoint_sha256": "eccc5ea77b121c9432b91883df4606759e71dffb647cfac86da0951926db123a" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "de9a99f9fcf46a2a965e521c7e219021a60dd193d1416958ffbeb8329e2a98de", + "initial_model_sha256": "f9db4704f9684dd88cb389a6e9d4d33e41e49828c8b745d5faf6a8332668e7f0", + "parent_step": 111000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:50.306545+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/status.json b/results/capacity-recall-controls-v1/runs/recall-background-h4096/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-background-h4096/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-background-h4096/worker.log b/results/capacity-recall-controls-v1/runs/recall-background-h4096/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/audit.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..aa0edf2f64fbd143b79efee1d3e21286c521302c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/audit.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 8.8009969090308e-08, + "knowledge_nll": 7.258493894823914e-08, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 9.348148921617394e-08, + "knowledge_nll": 7.69505135167492e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999886319489 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 8.253844896444207e-08, + "knowledge_nll": 6.821937148515644e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999899218177 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 30.207937240600586, + "knowledge_nll": 30.207937240600586, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.001122334455667789, + "answer_nll": 34.36986541748047, + "knowledge_nll": 34.36986541748047, + "identifier_accuracy": 0.001122334455667789, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001122334455667789 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 30.35199737548828, + "knowledge_nll": 30.35199737548828, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 33.45905685424805, + "knowledge_nll": 33.45905685424805, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003676470588235294 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.617563824169338e-08, + "knowledge_nll": 6.924130957486341e-08, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.999785537677, + "learned_bits_per_parameter": 0.15910503210007843 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "bd597539c1fbbcc5e70056dd44333b039a58ac87c638b60cbb858671e48e7dac", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 50, + "created_utc": "2026-10-05T23:12:31.855927+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/complete.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..aa0edf2f64fbd143b79efee1d3e21286c521302c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/complete.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 8.8009969090308e-08, + "knowledge_nll": 7.258493894823914e-08, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 9.348148921617394e-08, + "knowledge_nll": 7.69505135167492e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999886319489 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 8.253844896444207e-08, + "knowledge_nll": 6.821937148515644e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999899218177 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 30.207937240600586, + "knowledge_nll": 30.207937240600586, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.001122334455667789, + "answer_nll": 34.36986541748047, + "knowledge_nll": 34.36986541748047, + "identifier_accuracy": 0.001122334455667789, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001122334455667789 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 30.35199737548828, + "knowledge_nll": 30.35199737548828, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 33.45905685424805, + "knowledge_nll": 33.45905685424805, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003676470588235294 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.617563824169338e-08, + "knowledge_nll": 6.924130957486341e-08, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.999785537677, + "learned_bits_per_parameter": 0.15910503210007843 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "bd597539c1fbbcc5e70056dd44333b039a58ac87c638b60cbb858671e48e7dac", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 50, + "created_utc": "2026-10-05T23:12:31.855927+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..9befce71ee144acca183f66b398983cb1e4a8ec0 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-5e44ff448d062e3cc30b", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-5e44ff448d062e3cc30b", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-long,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-long", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-long" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..bcbad829c58d4c251b0b9b9cdd9a3e6955fb30e7 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2", + "Created": "2026-10-05T23:12:23.439952774Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-long" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:23.450110385Z", + "FinishedAt": "2026-10-05T23:12:32.45540958Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2/c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2-json.log", + "Name": "/lm-capctrl-5e44ff448d062e3cc30b", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-long", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-long" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/fd8fe01bf8b0cca06d6492313b8bcc167eb3d98b7daf1a42ce7d10b5ed82f8e8-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/fd8fe01bf8b0cca06d6492313b8bcc167eb3d98b7daf1a42ce7d10b5ed82f8e8/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/fd8fe01bf8b0cca06d6492313b8bcc167eb3d98b7daf1a42ce7d10b5ed82f8e8/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/fd8fe01bf8b0cca06d6492313b8bcc167eb3d98b7daf1a42ce7d10b5ed82f8e8/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-long", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-long", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "c18aea979704", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "MKL_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PHYSICAL_GPU=0", + "PYTHONDONTWRITEBYTECODE=1", + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-long" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..ba525129ecc4037caef8d4a111dcb33807f39c9b --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 330181, + "container_id": "c18aea9797047dd0de8c21e87f6d3705c405e2eb47aba75fa283beabd1939ad2", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/learning.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..125c5ddc45dee715a6aef634ab5e7ffc26edf510 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/learning.json @@ -0,0 +1,238 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 8.8009969090308e-08, + "knowledge_nll": 7.258493894823914e-08, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 9.348148921617394e-08, + "knowledge_nll": 7.69505135167492e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999886319489 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 8.253844896444207e-08, + "knowledge_nll": 6.821937148515644e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999899218177 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 30.207937240600586, + "knowledge_nll": 30.207937240600586, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.001122334455667789, + "answer_nll": 34.36986541748047, + "knowledge_nll": 34.36986541748047, + "identifier_accuracy": 0.001122334455667789, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001122334455667789 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 30.35199737548828, + "knowledge_nll": 30.35199737548828, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 33.45905685424805, + "knowledge_nll": 33.45905685424805, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003676470588235294 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.617563824169338e-08, + "knowledge_nll": 6.924130957486341e-08, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.999785537677, + "learned_bits_per_parameter": 0.15910503210007843 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 0.6391959525644779, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:27.459247+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/run.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/run.json new file mode 100644 index 0000000000000000000000000000000000000000..5c30348eec2337b9e91e3af46095e93137be6b09 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/run.json @@ -0,0 +1,181 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-calibration-long", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "evaluation_only": true, + "parent_checkpoint_sha256": "acce1dcffba24adaa1567f194e127e2c93c0e5db167b0c0cd1ed6a282461e706" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "initial_model_sha256": "bd597539c1fbbcc5e70056dd44333b039a58ac87c638b60cbb858671e48e7dac", + "parent_step": 21000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 45, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:27.326945+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/status.json b/results/capacity-recall-controls-v1/runs/recall-calibration-long/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-long/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-long/worker.log b/results/capacity-recall-controls-v1/runs/recall-calibration-long/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/audit.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..3c1bfdbb2e630b37acf42c8c9e292d9b2aa9a788 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/audit.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00021412948262877762, + "knowledge_nll": 0.00020326727826613933, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00021901112631894648, + "knowledge_nll": 0.00020560802659019828, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.696251207343 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000209247853490524, + "knowledge_nll": 0.00020092652994208038, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.70316727467 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 22.24895668029785, + "knowledge_nll": 22.248947143554688, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 23.906715393066406, + "knowledge_nll": 23.90670394897461, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.02287581699346405, + "answer_nll": 21.973052978515625, + "knowledge_nll": 21.973041534423828, + "identifier_accuracy": 0.02287581699346405, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.02287581699346405 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 23.666913986206055, + "knowledge_nll": 23.66690444946289, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.00021737217321060598, + "knowledge_nll": 0.00020802926155738533, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.399418482013, + "learned_bits_per_parameter": 0.15909920193522775 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "8f0c1a5d4fe04927b3de0deeb86816d143938de107143f9e89f2c1ff9d5fc785", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:20.325474+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/complete.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..3c1bfdbb2e630b37acf42c8c9e292d9b2aa9a788 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/complete.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00021412948262877762, + "knowledge_nll": 0.00020326727826613933, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00021901112631894648, + "knowledge_nll": 0.00020560802659019828, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.696251207343 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000209247853490524, + "knowledge_nll": 0.00020092652994208038, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.70316727467 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 22.24895668029785, + "knowledge_nll": 22.248947143554688, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 23.906715393066406, + "knowledge_nll": 23.90670394897461, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.02287581699346405, + "answer_nll": 21.973052978515625, + "knowledge_nll": 21.973041534423828, + "identifier_accuracy": 0.02287581699346405, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.02287581699346405 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 23.666913986206055, + "knowledge_nll": 23.66690444946289, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.00021737217321060598, + "knowledge_nll": 0.00020802926155738533, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.399418482013, + "learned_bits_per_parameter": 0.15909920193522775 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "8f0c1a5d4fe04927b3de0deeb86816d143938de107143f9e89f2c1ff9d5fc785", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:20.325474+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..6e68308a1a78138f1886cc045ff68e1bd2c8bdc7 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-120230e909823c33db81", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-120230e909823c33db81", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-lr0.001" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..34e1b32ca44b0685ccebce63acd18b0653d50f70 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97", + "Created": "2026-10-05T23:12:10.148023447Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-lr0.001" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:10.157736366Z", + "FinishedAt": "2026-10-05T23:12:20.94841307Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97/20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97-json.log", + "Name": "/lm-capctrl-120230e909823c33db81", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/fba1b51a5ad7770789cf59a46ee88c3d6c99a884a5e1896561103053b8259ff0-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/fba1b51a5ad7770789cf59a46ee88c3d6c99a884a5e1896561103053b8259ff0/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/fba1b51a5ad7770789cf59a46ee88c3d6c99a884a5e1896561103053b8259ff0/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/fba1b51a5ad7770789cf59a46ee88c3d6c99a884a5e1896561103053b8259ff0/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "20eb8f00edcc", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PYTHONDONTWRITEBYTECODE=1", + "OMP_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "PHYSICAL_GPU=0", + "MKL_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "TRITON_CACHE_DIR=/tmp/triton", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-lr0.001" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..f29c30e9e465b154b3c23dde066f914c0110e361 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 329253, + "container_id": "20eb8f00edccd9b5fe69a7f4597ca83c61ac544d6ee37ee6d1259d72cb433d97", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/learning.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..b9e95797948abb479d48d3e7f9957173eb3fd0ed --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/learning.json @@ -0,0 +1,238 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00021412948262877762, + "knowledge_nll": 0.00020326727826613933, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00021901112631894648, + "knowledge_nll": 0.00020560802659019828, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.696251207343 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000209247853490524, + "knowledge_nll": 0.00020092652994208038, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.70316727467 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 22.24895668029785, + "knowledge_nll": 22.248947143554688, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 23.906715393066406, + "knowledge_nll": 23.90670394897461, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.02287581699346405, + "answer_nll": 21.973052978515625, + "knowledge_nll": 21.973041534423828, + "identifier_accuracy": 0.02287581699346405, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.02287581699346405 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 23.666913986206055, + "knowledge_nll": 23.66690444946289, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.00021737217321060598, + "knowledge_nll": 0.00020802926155738533, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.399418482013, + "learned_bits_per_parameter": 0.15909920193522775 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 0.6540061458945274, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:14.292098+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/run.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/run.json new file mode 100644 index 0000000000000000000000000000000000000000..29377041fc67a9376a043d4b92418f7f7fbbc966 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/run.json @@ -0,0 +1,181 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 1000, + "batch_size": 512, + "learning_rate": 0.001, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-calibration-lr0.001", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.001", + "evaluation_only": true, + "parent_checkpoint_sha256": "12742f5209e46ec02ad20034b4af7bf73dfc44a3a35da73043c4e2dfe05e1fe3" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "initial_model_sha256": "8f0c1a5d4fe04927b3de0deeb86816d143938de107143f9e89f2c1ff9d5fc785", + "parent_step": 7000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:14.213959+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/status.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/worker.log b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.001/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/audit.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..a51a363ff010900e8a6b1a4a655bf8cef7a77fb2 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/audit.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 7.154226477723569e-05, + "knowledge_nll": 6.86763523845002e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.212474156403914e-05, + "knowledge_nll": 6.885499897180125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898279152069 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.095978071447462e-05, + "knowledge_nll": 6.849771307315677e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898806977574 + }, + "II": { + "n": 880, + "accuracy": 0.011363636363636364, + "answer_nll": 22.943639755249023, + "knowledge_nll": 22.943639755249023, + "identifier_accuracy": 0.011363636363636364, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.011363636363636364 + }, + "IO": { + "n": 891, + "accuracy": 0.002244668911335578, + "answer_nll": 26.75170135498047, + "knowledge_nll": 26.75170135498047, + "identifier_accuracy": 0.002244668911335578, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.002244668911335578 + }, + "OI": { + "n": 612, + "accuracy": 0.00980392156862745, + "answer_nll": 23.1972599029541, + "knowledge_nll": 23.197256088256836, + "identifier_accuracy": 0.00980392156862745, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00980392156862745 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 25.408363342285156, + "knowledge_nll": 25.408361434936523, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.237344834720716e-05, + "knowledge_nll": 6.974453572183847e-05, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.797086140392, + "learned_bits_per_parameter": 0.1591030636861054 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "7968aaa52220f618f04dd146f9fd4ba03a7e88490451be629e84ba6be74e996d", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:20.320398+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/complete.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..a51a363ff010900e8a6b1a4a655bf8cef7a77fb2 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/complete.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 7.154226477723569e-05, + "knowledge_nll": 6.86763523845002e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.212474156403914e-05, + "knowledge_nll": 6.885499897180125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898279152069 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.095978071447462e-05, + "knowledge_nll": 6.849771307315677e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898806977574 + }, + "II": { + "n": 880, + "accuracy": 0.011363636363636364, + "answer_nll": 22.943639755249023, + "knowledge_nll": 22.943639755249023, + "identifier_accuracy": 0.011363636363636364, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.011363636363636364 + }, + "IO": { + "n": 891, + "accuracy": 0.002244668911335578, + "answer_nll": 26.75170135498047, + "knowledge_nll": 26.75170135498047, + "identifier_accuracy": 0.002244668911335578, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.002244668911335578 + }, + "OI": { + "n": 612, + "accuracy": 0.00980392156862745, + "answer_nll": 23.1972599029541, + "knowledge_nll": 23.197256088256836, + "identifier_accuracy": 0.00980392156862745, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00980392156862745 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 25.408363342285156, + "knowledge_nll": 25.408361434936523, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.237344834720716e-05, + "knowledge_nll": 6.974453572183847e-05, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.797086140392, + "learned_bits_per_parameter": 0.1591030636861054 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "7968aaa52220f618f04dd146f9fd4ba03a7e88490451be629e84ba6be74e996d", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:20.320398+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..a1ab234dfa4aebf569dd00d8b045eb809ec44655 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-7bf5d747156264dfa65e", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-7bf5d747156264dfa65e", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-lr0.003" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..7c89b938181c062c073d11640e8bed8fb4c66ab6 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70", + "Created": "2026-10-05T23:12:10.467657754Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-lr0.003" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:10.480171525Z", + "FinishedAt": "2026-10-05T23:12:20.91641305Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70/acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70-json.log", + "Name": "/lm-capctrl-7bf5d747156264dfa65e", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/1de77e8ee3e6024ab22b474cc378e25f7202aea306dfcd3128c2731d57030438-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/1de77e8ee3e6024ab22b474cc378e25f7202aea306dfcd3128c2731d57030438/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/1de77e8ee3e6024ab22b474cc378e25f7202aea306dfcd3128c2731d57030438/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/1de77e8ee3e6024ab22b474cc378e25f7202aea306dfcd3128c2731d57030438/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "acb06b61c618", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PYTHONDONTWRITEBYTECODE=1", + "MKL_NUM_THREADS=4", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PHYSICAL_GPU=1", + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-calibration-lr0.003" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..18f17c3868c6193bd072b4fa1e61b1977bb0981b --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 329520, + "container_id": "acb06b61c618c21f8c6ccf2679620e4b236fb2f4a028bf4f71cc98bf782bad70", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/learning.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..2c734c8fa406f53fde8cee23dcb40f1048831f65 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/learning.json @@ -0,0 +1,238 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 7.154226477723569e-05, + "knowledge_nll": 6.86763523845002e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.212474156403914e-05, + "knowledge_nll": 6.885499897180125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898279152069 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.095978071447462e-05, + "knowledge_nll": 6.849771307315677e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898806977574 + }, + "II": { + "n": 880, + "accuracy": 0.011363636363636364, + "answer_nll": 22.943639755249023, + "knowledge_nll": 22.943639755249023, + "identifier_accuracy": 0.011363636363636364, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.011363636363636364 + }, + "IO": { + "n": 891, + "accuracy": 0.002244668911335578, + "answer_nll": 26.75170135498047, + "knowledge_nll": 26.75170135498047, + "identifier_accuracy": 0.002244668911335578, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.002244668911335578 + }, + "OI": { + "n": 612, + "accuracy": 0.00980392156862745, + "answer_nll": 23.1972599029541, + "knowledge_nll": 23.197256088256836, + "identifier_accuracy": 0.00980392156862745, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00980392156862745 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 25.408363342285156, + "knowledge_nll": 25.408361434936523, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.237344834720716e-05, + "knowledge_nll": 6.974453572183847e-05, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.797086140392, + "learned_bits_per_parameter": 0.1591030636861054 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 0.6398400813341141, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:14.281790+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/run.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/run.json new file mode 100644 index 0000000000000000000000000000000000000000..4275f295f556242ecec63c7712b6dd1baf240504 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/run.json @@ -0,0 +1,181 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 256, + "epochs": 1000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-calibration-lr0.003", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.003", + "evaluation_only": true, + "parent_checkpoint_sha256": "dfec03711c24a5f98dd47b70d6a9215d8a57c5cace4ea66c04d0bf13d0bd6e64" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "951b1572a4c7ba575874bbd9d3f6d6488e4b3386a82cf2473eff450e5ecddd95", + "initial_model_sha256": "7968aaa52220f618f04dd146f9fd4ba03a7e88490451be629e84ba6be74e996d", + "parent_step": 7000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:14.211201+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/status.json b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/worker.log b/results/capacity-recall-controls-v1/runs/recall-calibration-lr0.003/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/audit.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..b524399b8557d0e1d0ef22d20ee3fb3c6849c332 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/audit.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 0.9333984375, + "answer_nll": 0.20021846890449524, + "knowledge_nll": 0.20009231567382812, + "identifier_accuracy": 0.9333984375, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 0.924560546875, + "answer_nll": 0.22697804868221283, + "knowledge_nll": 0.22682344913482666, + "identifier_accuracy": 0.924560546875, + "learned_bits_raw": 31427.636980841904 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.96875, + "answer_nll": 0.09318004548549652, + "knowledge_nll": 0.0931677594780922, + "identifier_accuracy": 0.96875, + "learned_bits_raw": 8054.361431480546 + }, + "II": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 30.409255981445312, + "knowledge_nll": 30.409194946289062, + "identifier_accuracy": 0.00537109375, + "population_n": 4402, + "first_atomic_accuracy": 0.92724609375, + "second_atomic_accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.00596529284164859 + }, + "IO": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 36.97035217285156, + "knowledge_nll": 36.970340728759766, + "identifier_accuracy": 0.00439453125, + "population_n": 2629, + "first_atomic_accuracy": 0.9248046875, + "second_atomic_accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.004340748779164406 + }, + "OI": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 30.223848342895508, + "knowledge_nll": 30.223705291748047, + "identifier_accuracy": 0.00439453125, + "population_n": 3107, + "first_atomic_accuracy": 0.94189453125, + "second_atomic_accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0037393162393162395 + }, + "OO": { + "n": 1573, + "accuracy": 0.0019071837253655435, + "answer_nll": 36.12781524658203, + "knowledge_nll": 36.127811431884766, + "identifier_accuracy": 0.0019071837253655435, + "population_n": 1573, + "first_atomic_accuracy": 0.9294342021614749, + "second_atomic_accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.0021536252692031586 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.94580078125, + "answer_nll": 0.1764768660068512, + "knowledge_nll": 0.17647475004196167, + "identifier_accuracy": 0.94580078125, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 39481.99837930178, + "learned_bits_per_parameter": 0.3834097107996211 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.90087890625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.0032537960954446853, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.89990234375, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.0048833423765599565, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.91455078125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0005341880341880342, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 0.8862047043865225, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.0025429116338207248, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.002871500358937545, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "e1bd42f3dbdeb571c1a7f259c426508b2993abb9b9e496b0834d184802a45fd6", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:32.132590+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/complete.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..b524399b8557d0e1d0ef22d20ee3fb3c6849c332 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/complete.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 0.9333984375, + "answer_nll": 0.20021846890449524, + "knowledge_nll": 0.20009231567382812, + "identifier_accuracy": 0.9333984375, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 0.924560546875, + "answer_nll": 0.22697804868221283, + "knowledge_nll": 0.22682344913482666, + "identifier_accuracy": 0.924560546875, + "learned_bits_raw": 31427.636980841904 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.96875, + "answer_nll": 0.09318004548549652, + "knowledge_nll": 0.0931677594780922, + "identifier_accuracy": 0.96875, + "learned_bits_raw": 8054.361431480546 + }, + "II": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 30.409255981445312, + "knowledge_nll": 30.409194946289062, + "identifier_accuracy": 0.00537109375, + "population_n": 4402, + "first_atomic_accuracy": 0.92724609375, + "second_atomic_accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.00596529284164859 + }, + "IO": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 36.97035217285156, + "knowledge_nll": 36.970340728759766, + "identifier_accuracy": 0.00439453125, + "population_n": 2629, + "first_atomic_accuracy": 0.9248046875, + "second_atomic_accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.004340748779164406 + }, + "OI": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 30.223848342895508, + "knowledge_nll": 30.223705291748047, + "identifier_accuracy": 0.00439453125, + "population_n": 3107, + "first_atomic_accuracy": 0.94189453125, + "second_atomic_accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0037393162393162395 + }, + "OO": { + "n": 1573, + "accuracy": 0.0019071837253655435, + "answer_nll": 36.12781524658203, + "knowledge_nll": 36.127811431884766, + "identifier_accuracy": 0.0019071837253655435, + "population_n": 1573, + "first_atomic_accuracy": 0.9294342021614749, + "second_atomic_accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.0021536252692031586 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.94580078125, + "answer_nll": 0.1764768660068512, + "knowledge_nll": 0.17647475004196167, + "identifier_accuracy": 0.94580078125, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 39481.99837930178, + "learned_bits_per_parameter": 0.3834097107996211 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.90087890625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.0032537960954446853, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.89990234375, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.0048833423765599565, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.91455078125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0005341880341880342, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 0.8862047043865225, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.0025429116338207248, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.002871500358937545, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "e1bd42f3dbdeb571c1a7f259c426508b2993abb9b9e496b0834d184802a45fd6", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:32.132590+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..64499d07925e1b0ab80162c923e52bf316fb2150 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-9c188e9c2416b6bf3968", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-9c188e9c2416b6bf3968", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h1024,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h1024", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h1024" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..fe26d6fe1c3479ab3689be9627ed61cc688c1711 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928", + "Created": "2026-10-05T23:12:23.75727331Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h1024" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:23.767720495Z", + "FinishedAt": "2026-10-05T23:12:32.660154533Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928/a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928-json.log", + "Name": "/lm-capctrl-9c188e9c2416b6bf3968", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h1024", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h1024" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/5c4ea809c5cb73b3e153553a27a4b53d5b365a3d256636f7a4499c37d2b329a1-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/5c4ea809c5cb73b3e153553a27a4b53d5b365a3d256636f7a4499c37d2b329a1/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/5c4ea809c5cb73b3e153553a27a4b53d5b365a3d256636f7a4499c37d2b329a1/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/5c4ea809c5cb73b3e153553a27a4b53d5b365a3d256636f7a4499c37d2b329a1/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h1024", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h1024", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "a07402d4dfb7", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "PYTHONDONTWRITEBYTECODE=1", + "OMP_NUM_THREADS=4", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PHYSICAL_GPU=1", + "MKL_NUM_THREADS=4", + "TORCH_HOME=/tmp/torch", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h1024" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..ea872b0d04b702c17d54d00e2d6f66fbf210f1c7 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 330450, + "container_id": "a07402d4dfb7b5125274dee197c63565deed539e376a62794fa9b4a8b83f3928", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/learning.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..92a2064f4ba61aabbb2953e370e444ff05174620 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/learning.json @@ -0,0 +1,238 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 0.9333984375, + "answer_nll": 0.20021846890449524, + "knowledge_nll": 0.20009231567382812, + "identifier_accuracy": 0.9333984375, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 0.924560546875, + "answer_nll": 0.22697804868221283, + "knowledge_nll": 0.22682344913482666, + "identifier_accuracy": 0.924560546875, + "learned_bits_raw": 31427.636980841904 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.96875, + "answer_nll": 0.09318004548549652, + "knowledge_nll": 0.0931677594780922, + "identifier_accuracy": 0.96875, + "learned_bits_raw": 8054.361431480546 + }, + "II": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 30.409255981445312, + "knowledge_nll": 30.409194946289062, + "identifier_accuracy": 0.00537109375, + "population_n": 4402, + "first_atomic_accuracy": 0.92724609375, + "second_atomic_accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.00596529284164859 + }, + "IO": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 36.97035217285156, + "knowledge_nll": 36.970340728759766, + "identifier_accuracy": 0.00439453125, + "population_n": 2629, + "first_atomic_accuracy": 0.9248046875, + "second_atomic_accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.004340748779164406 + }, + "OI": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 30.223848342895508, + "knowledge_nll": 30.223705291748047, + "identifier_accuracy": 0.00439453125, + "population_n": 3107, + "first_atomic_accuracy": 0.94189453125, + "second_atomic_accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0037393162393162395 + }, + "OO": { + "n": 1573, + "accuracy": 0.0019071837253655435, + "answer_nll": 36.12781524658203, + "knowledge_nll": 36.127811431884766, + "identifier_accuracy": 0.0019071837253655435, + "population_n": 1573, + "first_atomic_accuracy": 0.9294342021614749, + "second_atomic_accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.0021536252692031586 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.94580078125, + "answer_nll": 0.1764768660068512, + "knowledge_nll": 0.17647475004196167, + "identifier_accuracy": 0.94580078125, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 39481.99837930178, + "learned_bits_per_parameter": 0.3834097107996211 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.90087890625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.0032537960954446853, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.89990234375, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.0048833423765599565, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.91455078125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0005341880341880342, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 0.8862047043865225, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.0025429116338207248, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.002871500358937545, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 1.0521410144865513, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:27.904352+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/run.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/run.json new file mode 100644 index 0000000000000000000000000000000000000000..0d2c18ef16aa937a10e0cf35edf55062b91ad02a --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/run.json @@ -0,0 +1,181 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 1024, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-load-h1024", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024", + "evaluation_only": true, + "parent_checkpoint_sha256": "4dcd2a2de244f6148e0a4795c8dbfd8dfd96f5bc52f1130c9bd8d8e3bf96e42b" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "bc532147aec498c6e878d08ab2c16389553eb6e51e02d1e195c580b8605f6d0e", + "initial_model_sha256": "e1bd42f3dbdeb571c1a7f259c426508b2993abb9b9e496b0834d184802a45fd6", + "parent_step": 60000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:27.629481+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/status.json b/results/capacity-recall-controls-v1/runs/recall-load-h1024/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h1024/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h1024/worker.log b/results/capacity-recall-controls-v1/runs/recall-load-h1024/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/audit.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..737972b8006600e6a944574974885397966f74a4 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/audit.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.013942307692307693, + "answer_nll": 5.332866668701172, + "knowledge_nll": 5.332655429840088, + "identifier_accuracy": 0.013942307692307693, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.0124969482421875, + "answer_nll": 5.36183500289917, + "knowledge_nll": 5.361629486083984, + "identifier_accuracy": 0.0124969482421875, + "learned_bits_raw": 17354.17720619624 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.1064453125, + "answer_nll": 3.4788806438446045, + "knowledge_nll": 3.478288173675537, + "identifier_accuracy": 0.1064453125, + "learned_bits_raw": 3053.456282680907 + }, + "II": { + "n": 2048, + "accuracy": 0.01318359375, + "answer_nll": 6.002089500427246, + "knowledge_nll": 6.002084732055664, + "identifier_accuracy": 0.01318359375, + "population_n": 69718, + "first_atomic_accuracy": 0.00927734375, + "second_atomic_accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.00244140625, + "answer_nll": 9.324575424194336, + "knowledge_nll": 9.324567794799805, + "identifier_accuracy": 0.00244140625, + "population_n": 40069, + "first_atomic_accuracy": 0.02001953125, + "second_atomic_accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.015625, + "answer_nll": 6.006150245666504, + "knowledge_nll": 6.006135940551758, + "identifier_accuracy": 0.015625, + "population_n": 53757, + "first_atomic_accuracy": 0.00732421875, + "second_atomic_accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.00146484375, + "answer_nll": 9.133949279785156, + "knowledge_nll": 9.133926391601562, + "identifier_accuracy": 0.00146484375, + "population_n": 24671, + "first_atomic_accuracy": 0.01513671875, + "second_atomic_accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.087890625, + "answer_nll": 3.885626792907715, + "knowledge_nll": 3.8856210708618164, + "identifier_accuracy": 0.087890625, + "population_n": 73929 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 20407.592631302774, + "learned_bits_per_parameter": 0.1981781447259825 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.005859375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0029296875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "b4705e13984e74b3c433ceb56fd64c491262e798b804fc09a2dfb9d0b28220ab", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:43.021382+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/complete.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..737972b8006600e6a944574974885397966f74a4 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/complete.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.013942307692307693, + "answer_nll": 5.332866668701172, + "knowledge_nll": 5.332655429840088, + "identifier_accuracy": 0.013942307692307693, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.0124969482421875, + "answer_nll": 5.36183500289917, + "knowledge_nll": 5.361629486083984, + "identifier_accuracy": 0.0124969482421875, + "learned_bits_raw": 17354.17720619624 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.1064453125, + "answer_nll": 3.4788806438446045, + "knowledge_nll": 3.478288173675537, + "identifier_accuracy": 0.1064453125, + "learned_bits_raw": 3053.456282680907 + }, + "II": { + "n": 2048, + "accuracy": 0.01318359375, + "answer_nll": 6.002089500427246, + "knowledge_nll": 6.002084732055664, + "identifier_accuracy": 0.01318359375, + "population_n": 69718, + "first_atomic_accuracy": 0.00927734375, + "second_atomic_accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.00244140625, + "answer_nll": 9.324575424194336, + "knowledge_nll": 9.324567794799805, + "identifier_accuracy": 0.00244140625, + "population_n": 40069, + "first_atomic_accuracy": 0.02001953125, + "second_atomic_accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.015625, + "answer_nll": 6.006150245666504, + "knowledge_nll": 6.006135940551758, + "identifier_accuracy": 0.015625, + "population_n": 53757, + "first_atomic_accuracy": 0.00732421875, + "second_atomic_accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.00146484375, + "answer_nll": 9.133949279785156, + "knowledge_nll": 9.133926391601562, + "identifier_accuracy": 0.00146484375, + "population_n": 24671, + "first_atomic_accuracy": 0.01513671875, + "second_atomic_accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.087890625, + "answer_nll": 3.885626792907715, + "knowledge_nll": 3.8856210708618164, + "identifier_accuracy": 0.087890625, + "population_n": 73929 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 20407.592631302774, + "learned_bits_per_parameter": 0.1981781447259825 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.005859375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0029296875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "b4705e13984e74b3c433ceb56fd64c491262e798b804fc09a2dfb9d0b28220ab", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:43.021382+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..f4f0bb4e59f032c19de2a0fb423b6d10d3f901ca --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-dbed9797167a62712648", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-dbed9797167a62712648", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=1", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h16384,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h16384", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=1", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h16384" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..5242050855e0b0a3c5af70833ea45ea77a68895c --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc", + "Created": "2026-10-05T23:12:33.567442635Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h16384" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:33.57706671Z", + "FinishedAt": "2026-10-05T23:12:43.580076069Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc/a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc-json.log", + "Name": "/lm-capctrl-dbed9797167a62712648", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "1" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h16384", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h16384" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/5cec504a58f8ea6d4b1b16b74124753f8ec38ee4ed3ebb1835aec87478d31f4f-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/5cec504a58f8ea6d4b1b16b74124753f8ec38ee4ed3ebb1835aec87478d31f4f/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/5cec504a58f8ea6d4b1b16b74124753f8ec38ee4ed3ebb1835aec87478d31f4f/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/5cec504a58f8ea6d4b1b16b74124753f8ec38ee4ed3ebb1835aec87478d31f4f/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h16384", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h16384", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "a91af6805b58", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "OMP_NUM_THREADS=4", + "MKL_NUM_THREADS=4", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "TRITON_CACHE_DIR=/tmp/triton", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "PHYSICAL_GPU=1", + "PYTHONDONTWRITEBYTECODE=1", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h16384" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..3874a762e28b364fc44afd28d4a1e70234c1b745 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 1, + "host_pid": 331413, + "container_id": "a91af6805b58361552be1eff13fe6a41bd493753d0d0df46b5e35b84b7ce43cc", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/learning.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..dbc5e2118b17e24f9db6c7f9d7fc03816bb1e2a6 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/learning.json @@ -0,0 +1,238 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.013942307692307693, + "answer_nll": 5.332866668701172, + "knowledge_nll": 5.332655429840088, + "identifier_accuracy": 0.013942307692307693, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.0124969482421875, + "answer_nll": 5.36183500289917, + "knowledge_nll": 5.361629486083984, + "identifier_accuracy": 0.0124969482421875, + "learned_bits_raw": 17354.17720619624 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.1064453125, + "answer_nll": 3.4788806438446045, + "knowledge_nll": 3.478288173675537, + "identifier_accuracy": 0.1064453125, + "learned_bits_raw": 3053.456282680907 + }, + "II": { + "n": 2048, + "accuracy": 0.01318359375, + "answer_nll": 6.002089500427246, + "knowledge_nll": 6.002084732055664, + "identifier_accuracy": 0.01318359375, + "population_n": 69718, + "first_atomic_accuracy": 0.00927734375, + "second_atomic_accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.00244140625, + "answer_nll": 9.324575424194336, + "knowledge_nll": 9.324567794799805, + "identifier_accuracy": 0.00244140625, + "population_n": 40069, + "first_atomic_accuracy": 0.02001953125, + "second_atomic_accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.015625, + "answer_nll": 6.006150245666504, + "knowledge_nll": 6.006135940551758, + "identifier_accuracy": 0.015625, + "population_n": 53757, + "first_atomic_accuracy": 0.00732421875, + "second_atomic_accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.00146484375, + "answer_nll": 9.133949279785156, + "knowledge_nll": 9.133926391601562, + "identifier_accuracy": 0.00146484375, + "population_n": 24671, + "first_atomic_accuracy": 0.01513671875, + "second_atomic_accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.087890625, + "answer_nll": 3.885626792907715, + "knowledge_nll": 3.8856210708618164, + "identifier_accuracy": 0.087890625, + "population_n": 73929 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 20407.592631302774, + "learned_bits_per_parameter": 0.1981781447259825 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.005859375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0029296875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 2.0981276407837868, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:38.542608+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/run.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/run.json new file mode 100644 index 0000000000000000000000000000000000000000..ff194da3416c4ebe034b9d2ed24e978db14a381b --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/run.json @@ -0,0 +1,181 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 16384, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-load-h16384", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h16384", + "evaluation_only": true, + "parent_checkpoint_sha256": "ffe7719c9c72dc9863ea1b07881e21152bed831d8433ee50c539d03187e0fb5f" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "3c78f6a59152d0f9944419c9f4c1e284172f0f00f0e8e2a7c9001ca2d67afc1d", + "initial_model_sha256": "b4705e13984e74b3c433ceb56fd64c491262e798b804fc09a2dfb9d0b28220ab", + "parent_step": 825000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 1, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:38.116729+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/status.json b/results/capacity-recall-controls-v1/runs/recall-load-h16384/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h16384/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h16384/worker.log b/results/capacity-recall-controls-v1/runs/recall-load-h16384/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/audit.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/audit.json new file mode 100644 index 0000000000000000000000000000000000000000..585ad67501facb65d32000cdf838a2e66beefff0 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/audit.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.21811810661764705, + "answer_nll": 2.975054979324341, + "knowledge_nll": 2.9749858379364014, + "identifier_accuracy": 0.21811810661764705, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.193115234375, + "answer_nll": 3.080827236175537, + "knowledge_nll": 3.0807769298553467, + "identifier_accuracy": 0.193115234375, + "learned_bits_raw": 58251.319725466674 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.6181640625, + "answer_nll": 1.2827003002166748, + "knowledge_nll": 1.2823312282562256, + "identifier_accuracy": 0.6181640625, + "learned_bits_raw": 6297.586786526915 + }, + "II": { + "n": 2048, + "accuracy": 0.00830078125, + "answer_nll": 13.821113586425781, + "knowledge_nll": 13.820261001586914, + "identifier_accuracy": 0.00830078125, + "population_n": 17515, + "first_atomic_accuracy": 0.20556640625, + "second_atomic_accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.003875968992248062 + }, + "IO": { + "n": 2048, + "accuracy": 0.00341796875, + "answer_nll": 20.449134826660156, + "knowledge_nll": 20.449058532714844, + "identifier_accuracy": 0.00341796875, + "population_n": 9988, + "first_atomic_accuracy": 0.1953125, + "second_atomic_accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0038314176245210726 + }, + "OI": { + "n": 2048, + "accuracy": 0.0087890625, + "answer_nll": 14.067947387695312, + "knowledge_nll": 14.065528869628906, + "identifier_accuracy": 0.0087890625, + "population_n": 13308, + "first_atomic_accuracy": 0.1875, + "second_atomic_accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617 + }, + "OO": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 20.17261505126953, + "knowledge_nll": 20.172481536865234, + "identifier_accuracy": 0.00537109375, + "population_n": 6256, + "first_atomic_accuracy": 0.1845703125, + "second_atomic_accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.008264462809917356 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.45751953125, + "answer_nll": 1.8601629734039307, + "knowledge_nll": 1.8601325750350952, + "identifier_accuracy": 0.45751953125, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 64548.91073863921, + "learned_bits_per_parameter": 0.6268345123003342 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.12841796875, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.011627906976744186, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.1318359375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0078125, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.12255859375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "898fa98233e4771a8255362ecc1e0834ef1ee21caa56260bd44db20be5ec8e7d", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:41.216743+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/complete.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/complete.json new file mode 100644 index 0000000000000000000000000000000000000000..585ad67501facb65d32000cdf838a2e66beefff0 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/complete.json @@ -0,0 +1,237 @@ +{ + "passed": true, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.21811810661764705, + "answer_nll": 2.975054979324341, + "knowledge_nll": 2.9749858379364014, + "identifier_accuracy": 0.21811810661764705, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.193115234375, + "answer_nll": 3.080827236175537, + "knowledge_nll": 3.0807769298553467, + "identifier_accuracy": 0.193115234375, + "learned_bits_raw": 58251.319725466674 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.6181640625, + "answer_nll": 1.2827003002166748, + "knowledge_nll": 1.2823312282562256, + "identifier_accuracy": 0.6181640625, + "learned_bits_raw": 6297.586786526915 + }, + "II": { + "n": 2048, + "accuracy": 0.00830078125, + "answer_nll": 13.821113586425781, + "knowledge_nll": 13.820261001586914, + "identifier_accuracy": 0.00830078125, + "population_n": 17515, + "first_atomic_accuracy": 0.20556640625, + "second_atomic_accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.003875968992248062 + }, + "IO": { + "n": 2048, + "accuracy": 0.00341796875, + "answer_nll": 20.449134826660156, + "knowledge_nll": 20.449058532714844, + "identifier_accuracy": 0.00341796875, + "population_n": 9988, + "first_atomic_accuracy": 0.1953125, + "second_atomic_accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0038314176245210726 + }, + "OI": { + "n": 2048, + "accuracy": 0.0087890625, + "answer_nll": 14.067947387695312, + "knowledge_nll": 14.065528869628906, + "identifier_accuracy": 0.0087890625, + "population_n": 13308, + "first_atomic_accuracy": 0.1875, + "second_atomic_accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617 + }, + "OO": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 20.17261505126953, + "knowledge_nll": 20.172481536865234, + "identifier_accuracy": 0.00537109375, + "population_n": 6256, + "first_atomic_accuracy": 0.1845703125, + "second_atomic_accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.008264462809917356 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.45751953125, + "answer_nll": 1.8601629734039307, + "knowledge_nll": 1.8601325750350952, + "identifier_accuracy": 0.45751953125, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 64548.91073863921, + "learned_bits_per_parameter": 0.6268345123003342 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.12841796875, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.011627906976744186, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.1318359375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0078125, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.12255859375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "model_sha256": "898fa98233e4771a8255362ecc1e0834ef1ee21caa56260bd44db20be5ec8e7d", + "unchanged_weights": true, + "historical_native_reproduced": true, + "separate_process": true, + "audit_pid": 49, + "created_utc": "2026-10-05T23:12:41.216743+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-command-1.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-command-1.json new file mode 100644 index 0000000000000000000000000000000000000000..9bf6b2ac0513d9f52e1bdae01306a3808aef1e34 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-command-1.json @@ -0,0 +1,59 @@ +{ + "name": "lm-capctrl-f9feedb005b3ee517fb1", + "command": [ + "docker", + "--context", + "lm-memory", + "run", + "--name", + "lm-capctrl-f9feedb005b3ee517fb1", + "--label", + "project=llm-memory-editability", + "--label", + "batch=capacity-recall-controls-v1", + "--network=none", + "--gpus", + "device=0", + "--cpus", + "2", + "--memory", + "12g", + "--shm-size=2g", + "--read-only", + "--tmpfs", + "/tmp:rw,size=4g", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability,dst=/ossfs/workspace/llm-memory-editability,readonly", + "--mount", + "type=bind,src=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h4096,dst=/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h4096", + "--workdir", + "/ossfs/workspace/llm-memory-editability", + "--env", + "PHYSICAL_GPU=0", + "--env", + "PYTHONDONTWRITEBYTECODE=1", + "--env", + "OMP_NUM_THREADS=4", + "--env", + "MKL_NUM_THREADS=4", + "--env", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "--env", + "XDG_CACHE_HOME=/tmp/cache", + "--env", + "TORCH_HOME=/tmp/torch", + "--env", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "--env", + "TRITON_CACHE_DIR=/tmp/triton", + "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h4096" + ] +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-inspect.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-inspect.json new file mode 100644 index 0000000000000000000000000000000000000000..b2026b5c99e6b2f959174414a19539f0a0eb0f17 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-inspect.json @@ -0,0 +1,460 @@ +[ + { + "Id": "036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f", + "Created": "2026-10-05T23:12:33.256374598Z", + "Path": "/opt/conda/bin/python", + "Args": [ + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h4096" + ], + "State": { + "Status": "exited", + "Running": false, + "Paused": false, + "Restarting": false, + "OOMKilled": false, + "Dead": false, + "Pid": 0, + "ExitCode": 0, + "Error": "", + "StartedAt": "2026-10-05T23:12:33.266063787Z", + "FinishedAt": "2026-10-05T23:12:41.720305332Z" + }, + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "ResolvConfPath": "/workspaces/docker-lm-memory/containers/036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f/resolv.conf", + "HostnamePath": "/workspaces/docker-lm-memory/containers/036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f/hostname", + "HostsPath": "/workspaces/docker-lm-memory/containers/036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f/hosts", + "LogPath": "/workspaces/docker-lm-memory/containers/036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f/036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f-json.log", + "Name": "/lm-capctrl-f9feedb005b3ee517fb1", + "RestartCount": 0, + "Driver": "overlay2", + "Platform": "linux", + "MountLabel": "", + "ProcessLabel": "", + "AppArmorProfile": "", + "ExecIDs": null, + "HostConfig": { + "Binds": null, + "ContainerIDFile": "", + "LogConfig": { + "Type": "json-file", + "Config": { + "max-file": "3", + "max-size": "20m" + } + }, + "NetworkMode": "none", + "PortBindings": {}, + "RestartPolicy": { + "Name": "no", + "MaximumRetryCount": 0 + }, + "AutoRemove": false, + "VolumeDriver": "", + "VolumesFrom": null, + "ConsoleSize": [ + 0, + 0 + ], + "CapAdd": null, + "CapDrop": null, + "CgroupnsMode": "host", + "Dns": null, + "DnsOptions": [], + "DnsSearch": [], + "ExtraHosts": null, + "GroupAdd": null, + "IpcMode": "private", + "Cgroup": "", + "Links": null, + "OomScoreAdj": 0, + "PidMode": "", + "Privileged": false, + "PublishAllPorts": false, + "ReadonlyRootfs": true, + "SecurityOpt": null, + "Tmpfs": { + "/tmp": "rw,size=4g" + }, + "UTSMode": "", + "UsernsMode": "", + "ShmSize": 2147483648, + "Runtime": "runc", + "Isolation": "", + "CpuShares": 0, + "Memory": 12884901888, + "NanoCpus": 2000000000, + "CgroupParent": "", + "BlkioWeight": 0, + "BlkioWeightDevice": [], + "BlkioDeviceReadBps": [], + "BlkioDeviceWriteBps": [], + "BlkioDeviceReadIOps": [], + "BlkioDeviceWriteIOps": [], + "CpuPeriod": 0, + "CpuQuota": 0, + "CpuRealtimePeriod": 0, + "CpuRealtimeRuntime": 0, + "CpusetCpus": "", + "CpusetMems": "", + "Devices": [], + "DeviceCgroupRules": null, + "DeviceRequests": [ + { + "Driver": "", + "Count": 0, + "DeviceIDs": [ + "0" + ], + "Capabilities": [ + [ + "gpu" + ] + ], + "Options": {} + } + ], + "MemoryReservation": 0, + "MemorySwap": 25769803776, + "MemorySwappiness": null, + "OomKillDisable": false, + "PidsLimit": null, + "Ulimits": null, + "CpuCount": 0, + "CpuPercent": 0, + "IOMaximumIOps": 0, + "IOMaximumBandwidth": 0, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Target": "/ossfs/workspace/llm-memory-editability", + "ReadOnly": true + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h4096", + "Target": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h4096" + } + ], + "MaskedPaths": [ + "/proc/acpi", + "/proc/asound", + "/proc/interrupts", + "/proc/kcore", + "/proc/keys", + "/proc/latency_stats", + "/proc/sched_debug", + "/proc/scsi", + "/proc/timer_list", + "/proc/timer_stats", + "/sys/devices/virtual/powercap", + "/sys/firmware", + "/sys/devices/system/cpu/cpu0/thermal_throttle", + "/sys/devices/system/cpu/cpu1/thermal_throttle", + "/sys/devices/system/cpu/cpu2/thermal_throttle", + "/sys/devices/system/cpu/cpu3/thermal_throttle", + "/sys/devices/system/cpu/cpu4/thermal_throttle", + "/sys/devices/system/cpu/cpu5/thermal_throttle", + "/sys/devices/system/cpu/cpu6/thermal_throttle", + "/sys/devices/system/cpu/cpu7/thermal_throttle", + "/sys/devices/system/cpu/cpu8/thermal_throttle", + "/sys/devices/system/cpu/cpu9/thermal_throttle", + "/sys/devices/system/cpu/cpu10/thermal_throttle", + "/sys/devices/system/cpu/cpu11/thermal_throttle", + "/sys/devices/system/cpu/cpu12/thermal_throttle", + "/sys/devices/system/cpu/cpu13/thermal_throttle", + "/sys/devices/system/cpu/cpu14/thermal_throttle", + "/sys/devices/system/cpu/cpu15/thermal_throttle", + "/sys/devices/system/cpu/cpu16/thermal_throttle", + "/sys/devices/system/cpu/cpu17/thermal_throttle", + "/sys/devices/system/cpu/cpu18/thermal_throttle", + "/sys/devices/system/cpu/cpu19/thermal_throttle", + "/sys/devices/system/cpu/cpu20/thermal_throttle", + "/sys/devices/system/cpu/cpu21/thermal_throttle", + "/sys/devices/system/cpu/cpu22/thermal_throttle", + "/sys/devices/system/cpu/cpu23/thermal_throttle", + "/sys/devices/system/cpu/cpu24/thermal_throttle", + "/sys/devices/system/cpu/cpu25/thermal_throttle", + "/sys/devices/system/cpu/cpu26/thermal_throttle", + "/sys/devices/system/cpu/cpu27/thermal_throttle", + "/sys/devices/system/cpu/cpu28/thermal_throttle", + "/sys/devices/system/cpu/cpu29/thermal_throttle", + "/sys/devices/system/cpu/cpu30/thermal_throttle", + "/sys/devices/system/cpu/cpu31/thermal_throttle", + "/sys/devices/system/cpu/cpu32/thermal_throttle", + "/sys/devices/system/cpu/cpu33/thermal_throttle", + "/sys/devices/system/cpu/cpu34/thermal_throttle", + "/sys/devices/system/cpu/cpu35/thermal_throttle", + "/sys/devices/system/cpu/cpu36/thermal_throttle", + "/sys/devices/system/cpu/cpu37/thermal_throttle", + "/sys/devices/system/cpu/cpu38/thermal_throttle", + "/sys/devices/system/cpu/cpu39/thermal_throttle", + "/sys/devices/system/cpu/cpu40/thermal_throttle", + "/sys/devices/system/cpu/cpu41/thermal_throttle", + "/sys/devices/system/cpu/cpu42/thermal_throttle", + "/sys/devices/system/cpu/cpu43/thermal_throttle", + "/sys/devices/system/cpu/cpu44/thermal_throttle", + "/sys/devices/system/cpu/cpu45/thermal_throttle", + "/sys/devices/system/cpu/cpu46/thermal_throttle", + "/sys/devices/system/cpu/cpu47/thermal_throttle", + "/sys/devices/system/cpu/cpu48/thermal_throttle", + "/sys/devices/system/cpu/cpu49/thermal_throttle", + "/sys/devices/system/cpu/cpu50/thermal_throttle", + "/sys/devices/system/cpu/cpu51/thermal_throttle", + "/sys/devices/system/cpu/cpu52/thermal_throttle", + "/sys/devices/system/cpu/cpu53/thermal_throttle", + "/sys/devices/system/cpu/cpu54/thermal_throttle", + "/sys/devices/system/cpu/cpu55/thermal_throttle", + "/sys/devices/system/cpu/cpu56/thermal_throttle", + "/sys/devices/system/cpu/cpu57/thermal_throttle", + "/sys/devices/system/cpu/cpu58/thermal_throttle", + "/sys/devices/system/cpu/cpu59/thermal_throttle", + "/sys/devices/system/cpu/cpu60/thermal_throttle", + "/sys/devices/system/cpu/cpu61/thermal_throttle", + "/sys/devices/system/cpu/cpu62/thermal_throttle", + "/sys/devices/system/cpu/cpu63/thermal_throttle", + "/sys/devices/system/cpu/cpu64/thermal_throttle", + "/sys/devices/system/cpu/cpu65/thermal_throttle", + "/sys/devices/system/cpu/cpu66/thermal_throttle", + "/sys/devices/system/cpu/cpu67/thermal_throttle", + "/sys/devices/system/cpu/cpu68/thermal_throttle", + "/sys/devices/system/cpu/cpu69/thermal_throttle", + "/sys/devices/system/cpu/cpu70/thermal_throttle", + "/sys/devices/system/cpu/cpu71/thermal_throttle", + "/sys/devices/system/cpu/cpu72/thermal_throttle", + "/sys/devices/system/cpu/cpu73/thermal_throttle", + "/sys/devices/system/cpu/cpu74/thermal_throttle", + "/sys/devices/system/cpu/cpu75/thermal_throttle", + "/sys/devices/system/cpu/cpu76/thermal_throttle", + "/sys/devices/system/cpu/cpu77/thermal_throttle", + "/sys/devices/system/cpu/cpu78/thermal_throttle", + "/sys/devices/system/cpu/cpu79/thermal_throttle", + "/sys/devices/system/cpu/cpu80/thermal_throttle", + "/sys/devices/system/cpu/cpu81/thermal_throttle", + "/sys/devices/system/cpu/cpu82/thermal_throttle", + "/sys/devices/system/cpu/cpu83/thermal_throttle", + "/sys/devices/system/cpu/cpu84/thermal_throttle", + "/sys/devices/system/cpu/cpu85/thermal_throttle", + "/sys/devices/system/cpu/cpu86/thermal_throttle", + "/sys/devices/system/cpu/cpu87/thermal_throttle", + "/sys/devices/system/cpu/cpu88/thermal_throttle", + "/sys/devices/system/cpu/cpu89/thermal_throttle", + "/sys/devices/system/cpu/cpu90/thermal_throttle", + "/sys/devices/system/cpu/cpu91/thermal_throttle", + "/sys/devices/system/cpu/cpu92/thermal_throttle", + "/sys/devices/system/cpu/cpu93/thermal_throttle", + "/sys/devices/system/cpu/cpu94/thermal_throttle", + "/sys/devices/system/cpu/cpu95/thermal_throttle", + "/sys/devices/system/cpu/cpu96/thermal_throttle", + "/sys/devices/system/cpu/cpu97/thermal_throttle", + "/sys/devices/system/cpu/cpu98/thermal_throttle", + "/sys/devices/system/cpu/cpu99/thermal_throttle", + "/sys/devices/system/cpu/cpu100/thermal_throttle", + "/sys/devices/system/cpu/cpu101/thermal_throttle", + "/sys/devices/system/cpu/cpu102/thermal_throttle", + "/sys/devices/system/cpu/cpu103/thermal_throttle", + "/sys/devices/system/cpu/cpu104/thermal_throttle", + "/sys/devices/system/cpu/cpu105/thermal_throttle", + "/sys/devices/system/cpu/cpu106/thermal_throttle", + "/sys/devices/system/cpu/cpu107/thermal_throttle", + "/sys/devices/system/cpu/cpu108/thermal_throttle", + "/sys/devices/system/cpu/cpu109/thermal_throttle", + "/sys/devices/system/cpu/cpu110/thermal_throttle", + "/sys/devices/system/cpu/cpu111/thermal_throttle", + "/sys/devices/system/cpu/cpu112/thermal_throttle", + "/sys/devices/system/cpu/cpu113/thermal_throttle", + "/sys/devices/system/cpu/cpu114/thermal_throttle", + "/sys/devices/system/cpu/cpu115/thermal_throttle", + "/sys/devices/system/cpu/cpu116/thermal_throttle", + "/sys/devices/system/cpu/cpu117/thermal_throttle", + "/sys/devices/system/cpu/cpu118/thermal_throttle", + "/sys/devices/system/cpu/cpu119/thermal_throttle", + "/sys/devices/system/cpu/cpu120/thermal_throttle", + "/sys/devices/system/cpu/cpu121/thermal_throttle", + "/sys/devices/system/cpu/cpu122/thermal_throttle", + "/sys/devices/system/cpu/cpu123/thermal_throttle", + "/sys/devices/system/cpu/cpu124/thermal_throttle", + "/sys/devices/system/cpu/cpu125/thermal_throttle", + "/sys/devices/system/cpu/cpu126/thermal_throttle", + "/sys/devices/system/cpu/cpu127/thermal_throttle", + "/sys/devices/system/cpu/cpu128/thermal_throttle", + "/sys/devices/system/cpu/cpu129/thermal_throttle", + "/sys/devices/system/cpu/cpu130/thermal_throttle", + "/sys/devices/system/cpu/cpu131/thermal_throttle", + "/sys/devices/system/cpu/cpu132/thermal_throttle", + "/sys/devices/system/cpu/cpu133/thermal_throttle", + "/sys/devices/system/cpu/cpu134/thermal_throttle", + "/sys/devices/system/cpu/cpu135/thermal_throttle", + "/sys/devices/system/cpu/cpu136/thermal_throttle", + "/sys/devices/system/cpu/cpu137/thermal_throttle", + "/sys/devices/system/cpu/cpu138/thermal_throttle", + "/sys/devices/system/cpu/cpu139/thermal_throttle", + "/sys/devices/system/cpu/cpu140/thermal_throttle", + "/sys/devices/system/cpu/cpu141/thermal_throttle", + "/sys/devices/system/cpu/cpu142/thermal_throttle", + "/sys/devices/system/cpu/cpu143/thermal_throttle", + "/sys/devices/system/cpu/cpu144/thermal_throttle", + "/sys/devices/system/cpu/cpu145/thermal_throttle", + "/sys/devices/system/cpu/cpu146/thermal_throttle", + "/sys/devices/system/cpu/cpu147/thermal_throttle", + "/sys/devices/system/cpu/cpu148/thermal_throttle", + "/sys/devices/system/cpu/cpu149/thermal_throttle", + "/sys/devices/system/cpu/cpu150/thermal_throttle", + "/sys/devices/system/cpu/cpu151/thermal_throttle", + "/sys/devices/system/cpu/cpu152/thermal_throttle", + "/sys/devices/system/cpu/cpu153/thermal_throttle", + "/sys/devices/system/cpu/cpu154/thermal_throttle", + "/sys/devices/system/cpu/cpu155/thermal_throttle", + "/sys/devices/system/cpu/cpu156/thermal_throttle", + "/sys/devices/system/cpu/cpu157/thermal_throttle", + "/sys/devices/system/cpu/cpu158/thermal_throttle", + "/sys/devices/system/cpu/cpu159/thermal_throttle", + "/sys/devices/system/cpu/cpu160/thermal_throttle", + "/sys/devices/system/cpu/cpu161/thermal_throttle", + "/sys/devices/system/cpu/cpu162/thermal_throttle", + "/sys/devices/system/cpu/cpu163/thermal_throttle", + "/sys/devices/system/cpu/cpu164/thermal_throttle", + "/sys/devices/system/cpu/cpu165/thermal_throttle", + "/sys/devices/system/cpu/cpu166/thermal_throttle", + "/sys/devices/system/cpu/cpu167/thermal_throttle", + "/sys/devices/system/cpu/cpu168/thermal_throttle", + "/sys/devices/system/cpu/cpu169/thermal_throttle", + "/sys/devices/system/cpu/cpu170/thermal_throttle", + "/sys/devices/system/cpu/cpu171/thermal_throttle", + "/sys/devices/system/cpu/cpu172/thermal_throttle", + "/sys/devices/system/cpu/cpu173/thermal_throttle", + "/sys/devices/system/cpu/cpu174/thermal_throttle", + "/sys/devices/system/cpu/cpu175/thermal_throttle", + "/sys/devices/system/cpu/cpu176/thermal_throttle", + "/sys/devices/system/cpu/cpu177/thermal_throttle", + "/sys/devices/system/cpu/cpu178/thermal_throttle", + "/sys/devices/system/cpu/cpu179/thermal_throttle", + "/sys/devices/system/cpu/cpu180/thermal_throttle", + "/sys/devices/system/cpu/cpu181/thermal_throttle", + "/sys/devices/system/cpu/cpu182/thermal_throttle", + "/sys/devices/system/cpu/cpu183/thermal_throttle", + "/sys/devices/system/cpu/cpu184/thermal_throttle", + "/sys/devices/system/cpu/cpu185/thermal_throttle", + "/sys/devices/system/cpu/cpu186/thermal_throttle", + "/sys/devices/system/cpu/cpu187/thermal_throttle", + "/sys/devices/system/cpu/cpu188/thermal_throttle", + "/sys/devices/system/cpu/cpu189/thermal_throttle", + "/sys/devices/system/cpu/cpu190/thermal_throttle", + "/sys/devices/system/cpu/cpu191/thermal_throttle" + ], + "ReadonlyPaths": [ + "/proc/bus", + "/proc/fs", + "/proc/irq", + "/proc/sys", + "/proc/sysrq-trigger" + ] + }, + "GraphDriver": { + "Data": { + "ID": "036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f", + "LowerDir": "/workspaces/docker-lm-memory/overlay2/18c1a457a24759e77bb96ebe9e3957ced2ab5d5466bed7a13766248ec2175ef1-init/diff:/workspaces/docker-lm-memory/overlay2/55ded685e2b4277d6c3d84622b8f0f337d3266fc28c2f3bfc6a086ebfe8d1624/diff:/workspaces/docker-lm-memory/overlay2/a181b78688f1bfbda2f1a6130ab5f8ca09832fa8e747af2f68d68e81a1f19d4e/diff:/workspaces/docker-lm-memory/overlay2/a4114720702204728e9ecc63322801e5041f097eaaa8068a2af005999b910454/diff:/workspaces/docker-lm-memory/overlay2/0d28ce241b571e6508c315e7bde54dc65f99caea26f26187f057fa3093f99b91/diff:/workspaces/docker-lm-memory/overlay2/e9f8871d684ff912c3c8fbdc4dee82533ac76ca92c8e7477c0a4aa898fa136d2/diff:/workspaces/docker-lm-memory/overlay2/b7889b33c65336b5a8b9801c36533ebebc05dea65535b7aecbd829e6ff4fb8b2/diff:/workspaces/docker-lm-memory/overlay2/e1119616dcb7ac8cdd1c1c969ef7daaa07f8e6f863a49a161a18268dd0eccb71/diff:/workspaces/docker-lm-memory/overlay2/5c8869c1800705555f44b666a83b4435d2ade61d2218293fa845f95fcab833e9/diff:/workspaces/docker-lm-memory/overlay2/503136c51f7a12c3c52b24c7c33409809c08c61441f6f9b3731a0b39bfd1bc40/diff:/workspaces/docker-lm-memory/overlay2/9842752423a009f16151b43d550d068db10545286086c81607c1bf3a5b9a388f/diff:/workspaces/docker-lm-memory/overlay2/be1eb62184b4ee707e4bcfb71ed658ccde9f2ecf801d4d1e79bd99292b8af97e/diff", + "MergedDir": "/workspaces/docker-lm-memory/overlay2/18c1a457a24759e77bb96ebe9e3957ced2ab5d5466bed7a13766248ec2175ef1/merged", + "UpperDir": "/workspaces/docker-lm-memory/overlay2/18c1a457a24759e77bb96ebe9e3957ced2ab5d5466bed7a13766248ec2175ef1/diff", + "WorkDir": "/workspaces/docker-lm-memory/overlay2/18c1a457a24759e77bb96ebe9e3957ced2ab5d5466bed7a13766248ec2175ef1/work" + }, + "Name": "overlay2" + }, + "Mounts": [ + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability", + "Destination": "/ossfs/workspace/llm-memory-editability", + "Mode": "", + "RW": false, + "Propagation": "rprivate" + }, + { + "Type": "bind", + "Source": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h4096", + "Destination": "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1/runs/recall-load-h4096", + "Mode": "", + "RW": true, + "Propagation": "rprivate" + } + ], + "Config": { + "Hostname": "036358f95d4c", + "Domainname": "", + "User": "", + "AttachStdin": false, + "AttachStdout": true, + "AttachStderr": true, + "Tty": false, + "OpenStdin": false, + "StdinOnce": false, + "Env": [ + "TRITON_CACHE_DIR=/tmp/triton", + "PYTHONDONTWRITEBYTECODE=1", + "OMP_NUM_THREADS=4", + "MKL_NUM_THREADS=4", + "TORCHINDUCTOR_CACHE_DIR=/tmp/torchinductor", + "PHYSICAL_GPU=0", + "PYTHONPATH=/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src", + "XDG_CACHE_HOME=/tmp/cache", + "TORCH_HOME=/tmp/torch", + "PATH=/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin", + "PYTHONUNBUFFERED=1", + "PYTHONNOUSERSITE=1", + "NVIDIA_VISIBLE_DEVICES=all", + "NVIDIA_DRIVER_CAPABILITIES=compute,utility" + ], + "Cmd": [ + "/opt/conda/bin/python", + "-u", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py", + "container-worker", + "--config", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/frozen-config.json", + "--run", + "recall-load-h4096" + ], + "Image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "Volumes": null, + "WorkingDir": "/ossfs/workspace/llm-memory-editability", + "Entrypoint": null, + "Labels": { + "batch": "capacity-recall-controls-v1", + "org.opencontainers.image.description": "Independent dependency snapshot from the LM Memory Editability experiment environment", + "org.opencontainers.image.title": "LM Memory Interface Python 3.10 / PyTorch 2.6.0+cu126", + "org.opencontainers.image.version": "22.04", + "project": "llm-memory-editability" + } + }, + "NetworkSettings": { + "SandboxID": "", + "SandboxKey": "", + "Ports": {}, + "Networks": { + "none": { + "IPAMConfig": null, + "Links": null, + "Aliases": null, + "DriverOpts": null, + "GwPriority": 0, + "NetworkID": "f13f14be11241c5b9f6f8403f2a65314d134b2eeb59d8c184e86627519610681", + "EndpointID": "", + "Gateway": "", + "IPAddress": "", + "MacAddress": "", + "IPPrefixLen": 0, + "IPv6Gateway": "", + "GlobalIPv6Address": "", + "GlobalIPv6PrefixLen": 0, + "DNSNames": null + } + } + } + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-runtime.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-runtime.json new file mode 100644 index 0000000000000000000000000000000000000000..4a696c659bc31be8ee69de471bf7622a8c015a96 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/container-runtime.json @@ -0,0 +1,8 @@ +{ + "physical_gpu": 0, + "host_pid": 331150, + "container_id": "036358f95d4cdbca0153ff0a9586e46a25dd9ae9f3c11ab98f3a89a6ecaa196f", + "image": "sha256:a994f1a1886220693eb26b7ff201147fbd4b49477d335ab2707330cab771063f", + "cpus": 2, + "memory": "12g" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/learning.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/learning.json new file mode 100644 index 0000000000000000000000000000000000000000..f283f254f15cda2b2cb2d2fde245680aeea7ce09 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/learning.json @@ -0,0 +1,238 @@ +[ + { + "step": 1, + "optimizer_updates": 0, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.21811810661764705, + "answer_nll": 2.975054979324341, + "knowledge_nll": 2.9749858379364014, + "identifier_accuracy": 0.21811810661764705, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.193115234375, + "answer_nll": 3.080827236175537, + "knowledge_nll": 3.0807769298553467, + "identifier_accuracy": 0.193115234375, + "learned_bits_raw": 58251.319725466674 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.6181640625, + "answer_nll": 1.2827003002166748, + "knowledge_nll": 1.2823312282562256, + "identifier_accuracy": 0.6181640625, + "learned_bits_raw": 6297.586786526915 + }, + "II": { + "n": 2048, + "accuracy": 0.00830078125, + "answer_nll": 13.821113586425781, + "knowledge_nll": 13.820261001586914, + "identifier_accuracy": 0.00830078125, + "population_n": 17515, + "first_atomic_accuracy": 0.20556640625, + "second_atomic_accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.003875968992248062 + }, + "IO": { + "n": 2048, + "accuracy": 0.00341796875, + "answer_nll": 20.449134826660156, + "knowledge_nll": 20.449058532714844, + "identifier_accuracy": 0.00341796875, + "population_n": 9988, + "first_atomic_accuracy": 0.1953125, + "second_atomic_accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0038314176245210726 + }, + "OI": { + "n": 2048, + "accuracy": 0.0087890625, + "answer_nll": 14.067947387695312, + "knowledge_nll": 14.065528869628906, + "identifier_accuracy": 0.0087890625, + "population_n": 13308, + "first_atomic_accuracy": 0.1875, + "second_atomic_accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617 + }, + "OO": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 20.17261505126953, + "knowledge_nll": 20.172481536865234, + "identifier_accuracy": 0.00537109375, + "population_n": 6256, + "first_atomic_accuracy": 0.1845703125, + "second_atomic_accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.008264462809917356 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.45751953125, + "answer_nll": 1.8601629734039307, + "knowledge_nll": 1.8601325750350952, + "identifier_accuracy": 0.45751953125, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 64548.91073863921, + "learned_bits_per_parameter": 0.6268345123003342 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.12841796875, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.011627906976744186, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.1318359375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0078125, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.12255859375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "training_seconds": 0, + "wall_seconds": 1.2074997015297413, + "peak_gpu_memory_bytes": 85784064, + "created_utc": "2026-10-05T23:12:37.637981+00:00" + } +] diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/run.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/run.json new file mode 100644 index 0000000000000000000000000000000000000000..04e31c8b856cf48952eb07d9818563409c508a02 --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/run.json @@ -0,0 +1,181 @@ +{ + "spec": { + "world_seed": 96100617, + "initialization": 96100623, + "stream_seed": 96100629, + "max_heads": 65536, + "values_n": 256, + "relations": 4, + "width": 64, + "heads_n": 4096, + "epochs": 3000, + "batch_size": 512, + "learning_rate": 0.003, + "weight_decay": 0.01, + "warmup_steps": 100, + "evaluation_per_pool": 2048, + "evaluation_batch_size": 512, + "evaluation_epochs": [ + 0, + 10, + 30, + 100, + 300, + 1000, + 3000 + ], + "checkpoint_epochs": 25, + "log_steps": 1000, + "max_wall_seconds": 600, + "name": "recall-load-h4096", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096", + "evaluation_only": true, + "parent_checkpoint_sha256": "1e42f08da93caadbb75e8745c1f1f73d254845d63dd43c37bd9063fe9093e91d" + }, + "model": { + "vocab_size": 31, + "width": 64, + "layers": 2, + "heads": 4, + "context": 14 + }, + "parameters": 102976, + "world_sha256": "8694a4dec375266f0b68eee9976ded8af1f46a59146a604ffc4e58cd9f731eef", + "initial_model_sha256": "898fa98233e4771a8255362ecc1e0834ef1ee21caa56260bd44db20be5ec8e7d", + "parent_step": 213000, + "phase": "development", + "tracking_group": "capacity-recall-controls-v1", + "pid": 44, + "gpu": 0, + "gpu_name": "NVIDIA L20X", + "source_files": { + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/capacity-recall-controls-v1.json": "26d65f77acc169b989b8e05bbc62706463051810b9c72e1f3f853cbec6fb08e9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json": "41d4b73b9d2f57f71fe51dd8500275f2c9fb3476ec24a9eeee3a8deadb5ecaa2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/docs/development-artifacts/capacity-recall-controls-v1/protocol.md": "ea4d736712716a74b933dd39bdf49a130c95a27ae22a8906a77ff952c7f2cb3a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/capacity_serial_recall.py": "7c8570c1e32f27709f644ddb5a90d96cc96c384f16e0f015ddc5d2739586fc52", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/evaluate_capacity_recall.py": "9362cc66ce6062b8703a6914833a5ab5b809962fefff26a0582339d6711b029e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_controls.py": "3207b5bd0b5d02958d94c11cd00234d7ecd17341b70b8484584b5e01fe3a2d8b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_capacity_scaling.py": "6b00f286945beee08969c0a5808167a2ce15eec7db370939f8819bf3c1979daf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/execute_parametric_architecture.py": "ce767c4ac3a39bea0295fa8c4e9565355c62c543ebf5dc0a4e95e0c7c4e3ea75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/report_capacity_controls.py": "414854d0fbaf7d9fcf0dba803c222127ff56562443d85fb5ff0e9d38477ea3c9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_controls.py": "b0c64589d5b7baaa078eecbb4b02add3c3c5c86f66b66e11f916b3262bf37efd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/scripts/run_capacity_scaling.py": "830646dc8d828bb51fe487116573ea3cecdec058d6ab35f3f642b2948e1b0336", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__init__.py": "84e6bb4a97b68f67f3256135c2b5fc35d9a83ceb04914a6cf3d38d926b015f7f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/__main__.py": "0af76e0612dd46d8097cd06d02bcd6220d89354be49910110a80b9942fdb71b3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/alignment_coverage.py": "152b868b836ff3ae18d8bb572ffe6ce956ea26edde1d283726b82215125736ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge.py": "777fe51d98b09275f487386660106e93c6c8b49e25b94e804510ed968c2df04c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/architecture_bridge_toy.py": "320d859c4d11b68299266d3f9bdb9a7e6867d635eb3d347827be082c60f0ffca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_analysis.py": "41d836fc201b9ae4f1988e0cdda3dc3be4ebc3ca898ab2ff69ca8445212407ff", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_branch.py": "f5b0f0ae79f84d64e33862e40fffbc4bd9a8fd102414995e8a2d41560009c09d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_capacity.py": "a9c306f0e326a8b97eccc4c0b404d45a3e3d8697186092ac562f645b4b370ba4", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_causal_paths.py": "10ea265743293fff64cc2201b7b49f5a22dd3bc3ff6a320f469948c233e65620", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_confirmation_stats.py": "e40f0347bd44e8602c18fc2fbee9647010d509d6f6dc7bc3c5cb8e98036e9c9b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_control.py": "9205a7f8d25e0f1311d78c73638b97466f425886e62165166ba104f53050a40d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_context_gradient.py": "8376dec9883b1d2c3ef06e5e04ad01fec6a1b9eceaa5cd74db02a79629bc536f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross.py": "47b8f55adbe13d9bc6e1c5c9170cc95e382261ffb1f31980706ac95be03623bf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_continue.py": "e6fd3a86157566559ab0e0571fbefcc1a28f22ec7add66da2105ea81d63cdaf8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_scale.py": "a1be3c598403b72661b9b2df642b2b1236ae1df6fdf46d982d4d89d19487f658", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_cross_train.py": "0106cae29be447319be2e7f6f0e1f5b60cc6224282331906f43ebc65ab795f38", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_data.py": "d5568901f2042a6d89d447f47eddae9764eced0a9e71e3ea5adc0038a7e636d6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction.py": "1240f83f5ee558101bbf6f808522fa6c37ffe09dc2296749bd5e685eff8aa41d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_cross.py": "66cf337b3a52508e82da6190ea01916662f1fe6fddef036844f9d1be2c179888", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_formation.py": "e2b19c17c6b7ebb7a884782f2c7750a7c65b935c17694d4424d354c62d0a24ed", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_direction_refresh.py": "4f80060d4232ec3bf4fb5d99b0823d20ee759e088aeedf4bd49ab841357d0127", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_edit.py": "dbbbc01ce57acef79d5cc46bcd39e301b256fa1e8c9eff7b1ce5ece693f86f2f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_followup.py": "06b4ffd3bbb65e2ff4df0f68e3fbf9f368257196bd4ef36eb1ffb0f7b15ee43b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_measure.py": "8c275b658c5c99316a19e2328eb53952f26b8a858b591784509391780ead3267", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal.py": "41aeed0ba09eba1b869e74dc29236aaa2abf142a596916dc06316754c7f21d8a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_causal_v2.py": "bc37408e458014e746c061c65b4672e67e30adee2b5a85b325a0282fbec00dfe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_edit.py": "ca9351ef08189c643a5b0a009af3e52b2578d5ae6265510f603cb78b229667dd", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_mechanism_interventions.py": "190c75e0a2779fe96936bff38d13a03e17e0dfd9faba3d2909ffc4a65265d96f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_model.py": "99efb7feeeb15f33dd3f08174c1190f4aa470e3877d8ac6692b2d43fed4c5f4d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization.py": "42f714473695da4c8543f666fd15a7eab7cef1e571429b25f81818b5505bd9d5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_organization_train.py": "833426232b693495711e38101553e8bff370c837c722d76e7f9f5f2d2ed3cad6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_data.py": "092689c2a05aad564ff8a7c6e1ac669d7e0475908e525766cf70922037cd2488", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_diagnostics.py": "6dd51ead7d16c1960740716fb73cb4409828666ac0332baae4c14730e39dd120", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_model.py": "8a52e58d343320ccce9e2f1b43674cc6765b840bd4feebed4813f78296ab29a9", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_report.py": "3483f72d479a861a4513f0a1a5dc7cbf53bcbace6a652d39f389b46ffb82286e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_original_train.py": "86b2ef1be03223dff26bc7997b91143be81fb46fd29ab8650a9cde8a39eb6891", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_diagnostics.py": "7d95f31f9fa9099d6b05666b9a638f880aa83a88554d934c3ff05e86880d0f7e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_minimal.py": "6fe8f0f6dd0950adfbbc5ad0524c1fe7e96b5c054d04338c046728535257a12e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_path_transfer.py": "2a079c54c2778e9bcb8fb36ebea4f90c43ac7bb7135e6d61e8a91a250ae3a0e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_readout_control.py": "545260dcaeac15766857271cbe8646ed3f096e445215064790b4ad62b6425afe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_relation_response.py": "56a21f6b7cd028aff011f99c9222518d0ef04bb803eda79a176e355cd735e0ca", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation.py": "92306cd8d88e0329916b52d9aadb992db286fae4ad7cf72cd846ab2b9a22553e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_confirmation_sets.py": "063d867951c621f8110c5c2547458aa5039899d64e44c199b86a45b4661e142e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_control.py": "a9369b1a042ef644b231763e2b62ac2b12451c3a526ccf121fd476a72fa27325", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit.py": "68c4980269249cbb1acf787fe5679bfad762460487f4a0cfc8e5e7f728ed8a68", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_edit_v2.py": "55ee452c248a44e0abb50f9806a00772dc6e72b683541db6cc17ffd1ac18e899", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_shortcut_matched_edit.py": "a8bba1a538fe4b3d5739a2ec4d223daf54b3988d74a7aa86854af3971acd4123", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bios_train.py": "c1d84d38aa1853815075041535ae3fa9890f5cf1f9f5d9019136c79521033046", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_reencoding.py": "128c02424642e2a479b8a439bd0342c89f77bf3befe3783a5fef9ebe01375ae5", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/bridge_workspace.py": "fe8f98ff6348d879c0b3c6db6b24f18eaabe03692729f0b0c967fe8d3b5a124a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_controls.py": "dc0b6ea601216b0997c45271a2ce8e02121148f37c88649e68d8960c9a6f1796", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/capacity_scaling.py": "5ee176e8d16e6e2a7becca7b89109712f940e21ead6b73a61a2ae974435e8678", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/cli.py": "01c814b9644988be1bf2ab660b2010ad5e7beab99067116c2afb2b6957f9fd3b", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step.py": "bd69879d5ec6124c05ca28a62c2c2459734e5b4b17d32ae92005308de63b8279", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_edit_calibration.py": "2dd20b15ae1f92eb6f685eca1e914923ff349a6a94277cfd3a5a74ad9155b4b8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/depth_step_mechanism.py": "546ce23095e755959d8114ed2bcf3f3f0d70f4a8e38e5c9b5d98c7a28ea7c5a6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiment_tracking.py": "2afe9e767123bee16cf56f59c6c2953a100338ecf1f971945c4968a064551866", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/experiments.py": "e575aceb2e3804956655d91710809818aec04c0b16a22edb441f5757629371d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth.py": "7d6d5af38a5dc4438b1e7ff44df8e833169d500f0d60d8933932bdb8822aca26", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_bridge.py": "414a0dbf17c369ad6d15714c2c026aafc4fb12bb1813a3c056efe8035fe2773d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_data.py": "c1451a0647ef7c25567398efd63848dbb44fdf066d07718c02f7e556e6c8b94a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_depth_extension.py": "f91923d3a7f154c7432e4763a0a90c0863eb75b7b35c8742838c9949795ab9f6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_data.py": "504de57da94618578cf792a3963f99e2dac587424d74ceae6b4c02c1d9680a8e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_mechanism.py": "aa11f58d3aa378741218eee29106b55da5601e1ff9bc3ac7e39ae55f26e613e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_model.py": "07e84388997a1710e5c821e54cf6d23726e4289aab178347761e060851fea6cc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge.py": "06538ab83312484367f84eefdf4944bddc8f3f45507dfcb96e005cb3017a3349", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_same_bridge_eval.py": "dea9ebb3130a0d7816b11cd01ac6d105f09e3aa4a051857b71693da261632410", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_supervision.py": "a24661453cb82764f81d631b9a1fb4642df0fc7181c5adf7cd6ac46960c9f9b7", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_loop_train.py": "4931606ee614aaadebbc3460c9ad9a86fbb12b5b6a1bbda9f3714f81424ff142", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop.py": "67ed1f37b04fbef7031f208e5ca140aea1b6158adb64ec8b0fe12217eb53cdbc", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_multihop_data.py": "d417b4d39e70cfa4010a8cd737a362d8159d73c2377330b04bf471a5079da851", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_data.py": "cfce0e5835665933ee1a1561ee681ffa6520c564be7e2292d9206399f86e7ced", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grok_usage_train.py": "5509ab6b2ad0c93e185cdfc211a7ee5afef45a5021a74aa8ce8bce520f694f70", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_dynamics_mechanism.py": "713470c8432ea27c602208cf0625452859924b83f8c62927c81894070815432c", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/grokking_reproduction.py": "7e3a89d96f6fef7bd4665ac46dd1acb6e7cb461c6878647ecc7c6f425ac31117", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_data.py": "f2f5458d624fc4a49781a557641de7388937e90fda846ab03f7e17a3f455dd0e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_followup.py": "752244bd78c5b02ba1d37a276e0547a5ff5bcf7a47986d64642f0db36cc4f4aa", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_future.py": "9fa7d88102e5b79e91735f530fe98fdd2bba20fad146238cde4f6eb591cf7105", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_interface.py": "a1ead4b413aef8f3082dcd569318fd132b64ed1a1ddb0c0c3a3aae4686589198", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_learning.py": "3dd0317b90943a22aabb80dcdc24eb38199623c5fb84a67641c3acd5de6a650e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_model.py": "e0413d8288a679800f3f7bafc8ef072a0d6d5b29fc49de417077569eec49cc3e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_statistics.py": "8c3a37806bed9661666c55bcb7c727ab78d9f4b2a1b384323f6a33c51d0a11f8", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/hebbian_train.py": "71ca785eafbe3438da45c4f5fa543a62424f1fd5176b04b317b0c78e7c96ecbf", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_editing.py": "f5a9aba43a4c03373bfb59510322a9be800de53af4c3f87e967c7e03f648e0a0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/interface_tracking.py": "7b7c252998c3eb764c8eaeb389cf9aab8a1da45d97200911d9e7455e59ec3c55", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_scaling.py": "231050e859da58c52b9ea47d09fb5de91271df0d24cbab42dead3f911adc6119", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/latent_support.py": "71e2483f8b5eb7e447594bf04def731add89f4cf140954fe87f793a69cb440a3", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/low_rank.py": "e1ddb5714d492311a43af2d5fd3dd5f578d8144db0b3d860ca71e3b603d018e1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/memory_reuse.py": "e95814cd98de22adc54e458f0b5933f2c3f13a0640c0c71a841780a9b1b52e57", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/multihop_scaling.py": "cbb60954b2738d17a1fce125087f87ee203fe98c5d462d14ad22ccff5790c7c6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation.py": "e13986431617be78b05db8c1f84f522f5cf4b6af7cd1b2e9d89345423be977e2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/natural_composition_confirmation_v2.py": "9bfa6540da812d4e6e2a21d2a8942dd73908269ce46aff15915b1782382dee75", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural.py": "f0df4d9bbb47b1febf0baf76d53b58319e598b6bbb29d31abca575e2dd13e025", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_data.py": "8812cb49f223dff57ac2fbbeb8055aa3017302e0450c194ecc984eaefcc3596e", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/neural_models.py": "c5ecb2fd69aa205a22688c95049750a7b8a0fd58b7c888a026252273b3af9091", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture.py": "b19ebaa377705f582fef367163312f74c2b3d2cc0451d8df03f47eff16e37a19", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/parametric_architecture_train.py": "232d2a9e1c3db2023cafd15cf107e57a6f37fc8139d8c81a45e5a3121ef31c5d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_constraints.py": "1b371c02d59becde87d61f3e8db20c9064588ff1908be66c06570ed2c5b1ab6f", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_learning.py": "d62080bf19605df02e9a140332c8981094a6e65b4c84a14b35734248e278a231", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/qwen_path_train.py": "09f03b01179a2cef8d98f803f61cea7e48ce636259222e394b0248d6744aec9d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition.py": "323f1cdb0f3c25a085e95b6f85fe352b1a91274aa5b3bbaca4e0686fdb4510c0", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_composition_data.py": "7208e0d0789f0287963b6e36d2646171e334f40ee365af13af79944f81e221be", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation.py": "e160fa1ab79580281753752b3e8f39584e5f2ba6a3b5d27abece6c99a291efe2", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/realworld_confirmation_analysis.py": "c8a89a57f913e034d7fd2c805fc4567900cd1c4881d5b66e8ac0f44deee75802", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/recurrence_use.py": "144fb9561ead5dbce0589ee986b6452af31405b1ff4fd30aae36a72076b62469", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/representation_alignment.py": "9794218f052a19019a5cb6427b84877a5174de3c0485bad441cdaed0ec7bd6b6", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_composition.py": "93796eee05e305ad538a498f013463d6bcde4a03de720eff6f4bfedf903f21d1", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/small_lm_followup.py": "90fdbbc5c1509d30e0e369c201b5caccac0c063636ad99101f9e3ea603ce7780", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_composition.py": "fa4d8b073ecb3ac69a3204ee446a4bc1ecf0c36f9d8dd1dcd0b6835c245e4c5a", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/storage_frontier.py": "2a1adcbbb0439ed771e17090878b9f7c9861d2fef4544172a88c35bd037d4a22", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_loss_source.py": "579471a04def8a11e9cc072fcb909d6e84c3b61c8d901d0d029e126f14a6d3fe", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_pretrain.py": "cd777a56ba270d3c71ed3260f68501ee0685d4cc58a4f7b952719236adf874cb", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/text_structure.py": "9c8e3f00b263a62d53868a6224830e702dcb4348c05d52cc438c1e37e365287d", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/src/llm_memory_editability/twohop_depth.py": "870ad9f1f3a3736b77b1b0781d25961803d9d2e1df9aed1c709a669691b76def", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_controls.py": "6cf88b51704bc56a67eb892cf707938ed8fe5b196eb76479e7595bdde08b8499", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/tests/test_capacity_scaling.py": "a7cbf13e174178c0074515e93165bd132d1af18fe71f14771bdc012c962e23a4" + }, + "created_utc": "2026-10-05T23:12:37.382100+00:00" +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/status.json b/results/capacity-recall-controls-v1/runs/recall-load-h4096/status.json new file mode 100644 index 0000000000000000000000000000000000000000..78625a0cf7e455caf8c180218f191dcec2d0e68f --- /dev/null +++ b/results/capacity-recall-controls-v1/runs/recall-load-h4096/status.json @@ -0,0 +1,4 @@ +{ + "state": "complete", + "step": 1 +} diff --git a/results/capacity-recall-controls-v1/runs/recall-load-h4096/worker.log b/results/capacity-recall-controls-v1/runs/recall-load-h4096/worker.log new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/results/capacity-recall-controls-v1/summary.csv b/results/capacity-recall-controls-v1/summary.csv new file mode 100644 index 0000000000000000000000000000000000000000..6c9b5f5a588903eb011b394a9d5905f5e1e4f7b0 --- /dev/null +++ b/results/capacity-recall-controls-v1/summary.csv @@ -0,0 +1,18 @@ +name,heads_n,arm,parent,density,learned_density,atomic,train_composition,II,serial_II,wrong_bridge_II,oracle_bridge_II,II_both_coverage,IO,serial_IO,wrong_bridge_IO,oracle_bridge_IO,IO_both_coverage,OI,serial_OI,wrong_bridge_OI,oracle_bridge_OI,OI_both_coverage,OO,serial_OO,wrong_bridge_OO,oracle_bridge_OO,OO_both_coverage +recall-calibration-lr0.001,256,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.001,0.15910503418272218,0.15909920193522775,1.0,1.0,0.006818181818181818,1.0,0.0,1.0,1.0,0.004489337822671156,1.0,0.0,1.0,1.0,0.02287581699346405,1.0,0.006535947712418301,1.0,1.0,0.007352941176470588,1.0,0.0,1.0,1.0 +recall-calibration-lr0.003,256,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.003,0.15910503418272218,0.1591030636861054,1.0,1.0,0.011363636363636364,1.0,0.0,1.0,1.0,0.002244668911335578,1.0,0.0,1.0,1.0,0.00980392156862745,1.0,0.006535947712418301,1.0,1.0,0.007352941176470588,1.0,0.0,1.0,1.0 +recall-calibration-long,256,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long,0.15910503418272218,0.15910503210007843,1.0,1.0,0.006818181818181818,1.0,0.0,1.0,1.0,0.001122334455667789,1.0,0.0,1.0,1.0,0.006535947712418301,1.0,0.006535947712418301,1.0,1.0,0.003676470588235294,1.0,0.0,1.0,1.0 +recall-load-h1024,1024,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024,0.3977625854568055,0.3834097107996211,0.9333984375,0.94580078125,0.00537109375,0.90087890625,0.00390625,0.96923828125,0.900390625,0.00439453125,0.89990234375,0.00634765625,0.97265625,0.89990234375,0.00439453125,0.91455078125,0.001953125,0.96875,0.9140625,0.0019071837253655435,0.8862047043865225,0.0025429116338207248,0.951048951048951,0.8855689764780674 +recall-load-h4096,4096,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096,1.3523927905531385,0.6268345123003342,0.21811810661764705,0.45751953125,0.00830078125,0.12841796875,0.00634765625,0.6259765625,0.1259765625,0.00341796875,0.1318359375,0.0078125,0.646484375,0.12744140625,0.0087890625,0.119140625,0.0068359375,0.59765625,0.11474609375,0.00537109375,0.12255859375,0.00732421875,0.63427734375,0.1181640625 +recall-load-h16384,16384,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h16384,5.170913610938471,0.1981781447259825,0.013942307692307693,0.087890625,0.01318359375,0.005859375,0.00830078125,0.12060546875,0.00048828125,0.00244140625,0.00341796875,0.00390625,0.06201171875,0.0,0.015625,0.00830078125,0.00732421875,0.119140625,0.00048828125,0.00146484375,0.00341796875,0.0029296875,0.07177734375,0.00048828125 +recall-background-h1024,1024,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h1024,0.3977625854568055,0.3977500840866651,1.0,1.0,0.010227272727272727,1.0,0.0,1.0,1.0,0.004489337822671156,1.0,0.0,1.0,1.0,0.006535947712418301,1.0,0.006535947712418301,1.0,1.0,0.001838235294117647,1.0,0.0,1.0,1.0 +recall-background-h4096,4096,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h4096,1.3523927905531385,1.1506901831376122,0.7446001838235294,0.9101796407185628,0.006818181818181818,0.7090909090909091,0.004545454545454545,0.8386363636363636,0.7090909090909091,0.003367003367003367,0.7351290684624018,0.008978675645342313,0.8911335578002245,0.7328843995510662,0.0032679738562091504,0.684640522875817,0.006535947712418301,0.8496732026143791,0.684640522875817,0.003676470588235294,0.7555147058823529,0.0,0.8915441176470589,0.7555147058823529 +recall-background-h16384,16384,old_weights,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h16384,5.170913610938471,0.9714620810377882,0.07536057692307692,0.5765611633875107,0.004545454545454545,0.02159090909090909,0.006818181818181818,0.4943181818181818,0.017045454545454544,0.003367003367003367,0.016835016835016835,0.006734006734006734,0.5241301907968574,0.013468013468013467,0.008169934640522876,0.021241830065359478,0.011437908496732025,0.565359477124183,0.0196078431372549,0.001838235294117647,0.027573529411764705,0.012867647058823529,0.5533088235294118,0.02022058823529412 +atomic-h256,256,atomic,,0.15910503418272218,0.15910498797209105,1.0,0.0,0.0,1.0,0.0,1.0,1.0,0.0,1.0,0.0,1.0,1.0,0.0,1.0,0.006535947712418301,1.0,1.0,0.0,1.0,0.0,1.0,1.0 +atomic_replay-h256,256,atomic_replay,,0.15910503418272218,0.08563859488367709,0.291015625,0.0,0.0,0.10795454545454546,0.004545454545454545,0.3886363636363636,0.10340909090909091,0.0,0.07295173961840629,0.004489337822671156,0.37373737373737376,0.06734006734006734,0.0,0.09640522875816994,0.004901960784313725,0.32516339869281047,0.09313725490196079,0.0,0.06985294117647059,0.007352941176470588,0.34191176470588236,0.06066176470588235 +atomic-h1024,1024,atomic,,0.3977625854568055,0.3977580508404657,1.0,0.0,0.0,1.0,0.00390625,1.0,1.0,0.0,1.0,0.00439453125,1.0,1.0,0.0,1.0,0.001953125,1.0,1.0,0.0,1.0,0.003814367450731087,1.0,1.0 +atomic_replay-h1024,1024,atomic_replay,,0.3977625854568055,0.39774002772115163,1.0,0.0,0.0,1.0,0.00390625,1.0,1.0,0.0,1.0,0.00439453125,1.0,1.0,0.0,1.0,0.001953125,1.0,1.0,0.0,1.0,0.003814367450731087,1.0,1.0 +atomic-h4096,4096,atomic,,1.3523927905531385,1.1243231969257026,0.7165096507352942,0.0,0.0,0.64306640625,0.0048828125,0.89013671875,0.64111328125,0.0,0.61572265625,0.0048828125,0.8798828125,0.6142578125,0.0,0.6123046875,0.00537109375,0.86279296875,0.61181640625,0.0,0.64111328125,0.0087890625,0.89501953125,0.63916015625 +atomic_replay-h4096,4096,atomic_replay,,1.3523927905531385,1.1689504129814499,0.7679227941176471,0.0,0.0,0.65283203125,0.0107421875,0.86328125,0.65087890625,0.0,0.69140625,0.0087890625,0.8896484375,0.68994140625,0.0,0.6416015625,0.00927734375,0.8466796875,0.64111328125,0.0,0.6953125,0.0068359375,0.8994140625,0.69287109375 +continuation-wd0.01,256,mixed,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long,0.15910503418272218,0.1590919900629028,1.0,1.0,0.005681818181818182,1.0,0.0,1.0,1.0,0.004489337822671156,1.0,0.0,1.0,1.0,0.014705882352941176,1.0,0.006535947712418301,1.0,1.0,0.007352941176470588,1.0,0.0,1.0,1.0 +continuation-wd0.1,256,mixed,/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long,0.15910503418272218,0.1590984711525922,1.0,1.0,0.010227272727272727,1.0,0.0,1.0,1.0,0.004489337822671156,1.0,0.0,1.0,1.0,0.008169934640522876,1.0,0.006535947712418301,1.0,1.0,0.0055147058823529415,1.0,0.0,1.0,1.0 diff --git a/results/capacity-recall-controls-v1/summary.json b/results/capacity-recall-controls-v1/summary.json new file mode 100644 index 0000000000000000000000000000000000000000..c40dafa1ed2b98b2cc6551c4e740080b36405048 --- /dev/null +++ b/results/capacity-recall-controls-v1/summary.json @@ -0,0 +1,4495 @@ +{ + "batch": "capacity-recall-controls-v1", + "expected": 17, + "audited": 17, + "missing_or_failed": [], + "independent_worlds": 1, + "initializations": 1, + "runs": [ + { + "name": "recall-calibration-lr0.001", + "heads_n": 256, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.001", + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00021412948262877762, + "knowledge_nll": 0.00020326727826613933, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00021901112631894648, + "knowledge_nll": 0.00020560802659019828, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.696251207343 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000209247853490524, + "knowledge_nll": 0.00020092652994208038, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.70316727467 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 22.24895668029785, + "knowledge_nll": 22.248947143554688, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 23.906715393066406, + "knowledge_nll": 23.90670394897461, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.02287581699346405, + "answer_nll": 21.973052978515625, + "knowledge_nll": 21.973041534423828, + "identifier_accuracy": 0.02287581699346405, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.02287581699346405 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 23.666913986206055, + "knowledge_nll": 23.66690444946289, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.00021737217321060598, + "knowledge_nll": 0.00020802926155738533, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.399418482013, + "learned_bits_per_parameter": 0.15909920193522775 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.15910503418272218, + "learned_density": 0.15909920193522775, + "atomic": 1.0, + "train_composition": 1.0, + "II": 0.006818181818181818, + "serial_II": 1.0, + "wrong_bridge_II": 0.0, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.004489337822671156, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.0, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.02287581699346405, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.007352941176470588, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "recall-calibration-lr0.003", + "heads_n": 256, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration/runs/calibration-lr0.003", + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 7.154226477723569e-05, + "knowledge_nll": 6.86763523845002e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.212474156403914e-05, + "knowledge_nll": 6.885499897180125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898279152069 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 7.095978071447462e-05, + "knowledge_nll": 6.849771307315677e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.898806977574 + }, + "II": { + "n": 880, + "accuracy": 0.011363636363636364, + "answer_nll": 22.943639755249023, + "knowledge_nll": 22.943639755249023, + "identifier_accuracy": 0.011363636363636364, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.011363636363636364 + }, + "IO": { + "n": 891, + "accuracy": 0.002244668911335578, + "answer_nll": 26.75170135498047, + "knowledge_nll": 26.75170135498047, + "identifier_accuracy": 0.002244668911335578, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.002244668911335578 + }, + "OI": { + "n": 612, + "accuracy": 0.00980392156862745, + "answer_nll": 23.1972599029541, + "knowledge_nll": 23.197256088256836, + "identifier_accuracy": 0.00980392156862745, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00980392156862745 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 25.408363342285156, + "knowledge_nll": 25.408361434936523, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.237344834720716e-05, + "knowledge_nll": 6.974453572183847e-05, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.797086140392, + "learned_bits_per_parameter": 0.1591030636861054 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.15910503418272218, + "learned_density": 0.1591030636861054, + "atomic": 1.0, + "train_composition": 1.0, + "II": 0.011363636363636364, + "serial_II": 1.0, + "wrong_bridge_II": 0.0, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.002244668911335578, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.0, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.00980392156862745, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.007352941176470588, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "recall-calibration-long", + "heads_n": 256, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 8.8009969090308e-08, + "knowledge_nll": 7.258493894823914e-08, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 9.348148921617394e-08, + "knowledge_nll": 7.69505135167492e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999886319489 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 8.253844896444207e-08, + "knowledge_nll": 6.821937148515644e-08, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.999899218177 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 30.207937240600586, + "knowledge_nll": 30.207937240600586, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006818181818181818 + }, + "IO": { + "n": 891, + "accuracy": 0.001122334455667789, + "answer_nll": 34.36986541748047, + "knowledge_nll": 34.36986541748047, + "identifier_accuracy": 0.001122334455667789, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001122334455667789 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 30.35199737548828, + "knowledge_nll": 30.35199737548828, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 33.45905685424805, + "knowledge_nll": 33.45905685424805, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003676470588235294 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 7.617563824169338e-08, + "knowledge_nll": 6.924130957486341e-08, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.999785537677, + "learned_bits_per_parameter": 0.15910503210007843 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.15910503418272218, + "learned_density": 0.15910503210007843, + "atomic": 1.0, + "train_composition": 1.0, + "II": 0.006818181818181818, + "serial_II": 1.0, + "wrong_bridge_II": 0.0, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.001122334455667789, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.0, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.006535947712418301, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.003676470588235294, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "recall-load-h1024", + "heads_n": 1024, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h1024", + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 0.9333984375, + "answer_nll": 0.20021846890449524, + "knowledge_nll": 0.20009231567382812, + "identifier_accuracy": 0.9333984375, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 0.924560546875, + "answer_nll": 0.22697804868221283, + "knowledge_nll": 0.22682344913482666, + "identifier_accuracy": 0.924560546875, + "learned_bits_raw": 31427.636980841904 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.96875, + "answer_nll": 0.09318004548549652, + "knowledge_nll": 0.0931677594780922, + "identifier_accuracy": 0.96875, + "learned_bits_raw": 8054.361431480546 + }, + "II": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 30.409255981445312, + "knowledge_nll": 30.409194946289062, + "identifier_accuracy": 0.00537109375, + "population_n": 4402, + "first_atomic_accuracy": 0.92724609375, + "second_atomic_accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.00596529284164859 + }, + "IO": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 36.97035217285156, + "knowledge_nll": 36.970340728759766, + "identifier_accuracy": 0.00439453125, + "population_n": 2629, + "first_atomic_accuracy": 0.9248046875, + "second_atomic_accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.004340748779164406 + }, + "OI": { + "n": 2048, + "accuracy": 0.00439453125, + "answer_nll": 30.223848342895508, + "knowledge_nll": 30.223705291748047, + "identifier_accuracy": 0.00439453125, + "population_n": 3107, + "first_atomic_accuracy": 0.94189453125, + "second_atomic_accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0037393162393162395 + }, + "OO": { + "n": 1573, + "accuracy": 0.0019071837253655435, + "answer_nll": 36.12781524658203, + "knowledge_nll": 36.127811431884766, + "identifier_accuracy": 0.0019071837253655435, + "population_n": 1573, + "first_atomic_accuracy": 0.9294342021614749, + "second_atomic_accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.0021536252692031586 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.94580078125, + "answer_nll": 0.1764768660068512, + "knowledge_nll": 0.17647475004196167, + "identifier_accuracy": 0.94580078125, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 39481.99837930178, + "learned_bits_per_parameter": 0.3834097107996211 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.90087890625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 0.0032537960954446853, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.96923828125, + "both_atomic_n": 1844, + "both_atomic_coverage": 0.900390625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.89990234375, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 0.0048833423765599565, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.97265625, + "both_atomic_n": 1843, + "both_atomic_coverage": 0.89990234375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.91455078125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 0.0005341880341880342, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.96875, + "both_atomic_n": 1872, + "both_atomic_coverage": 0.9140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9990234375, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 0.8862047043865225, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.0025429116338207248, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 0.002871500358937545, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 0.951048951048951, + "both_atomic_n": 1393, + "both_atomic_coverage": 0.8855689764780674, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.3977625854568055, + "learned_density": 0.3834097107996211, + "atomic": 0.9333984375, + "train_composition": 0.94580078125, + "II": 0.00537109375, + "serial_II": 0.90087890625, + "wrong_bridge_II": 0.00390625, + "oracle_bridge_II": 0.96923828125, + "II_both_coverage": 0.900390625, + "IO": 0.00439453125, + "serial_IO": 0.89990234375, + "wrong_bridge_IO": 0.00634765625, + "oracle_bridge_IO": 0.97265625, + "IO_both_coverage": 0.89990234375, + "OI": 0.00439453125, + "serial_OI": 0.91455078125, + "wrong_bridge_OI": 0.001953125, + "oracle_bridge_OI": 0.96875, + "OI_both_coverage": 0.9140625, + "OO": 0.0019071837253655435, + "serial_OO": 0.8862047043865225, + "wrong_bridge_OO": 0.0025429116338207248, + "oracle_bridge_OO": 0.951048951048951, + "OO_both_coverage": 0.8855689764780674 + }, + { + "name": "recall-load-h4096", + "heads_n": 4096, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h4096", + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.21811810661764705, + "answer_nll": 2.975054979324341, + "knowledge_nll": 2.9749858379364014, + "identifier_accuracy": 0.21811810661764705, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.193115234375, + "answer_nll": 3.080827236175537, + "knowledge_nll": 3.0807769298553467, + "identifier_accuracy": 0.193115234375, + "learned_bits_raw": 58251.319725466674 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.6181640625, + "answer_nll": 1.2827003002166748, + "knowledge_nll": 1.2823312282562256, + "identifier_accuracy": 0.6181640625, + "learned_bits_raw": 6297.586786526915 + }, + "II": { + "n": 2048, + "accuracy": 0.00830078125, + "answer_nll": 13.821113586425781, + "knowledge_nll": 13.820261001586914, + "identifier_accuracy": 0.00830078125, + "population_n": 17515, + "first_atomic_accuracy": 0.20556640625, + "second_atomic_accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.003875968992248062 + }, + "IO": { + "n": 2048, + "accuracy": 0.00341796875, + "answer_nll": 20.449134826660156, + "knowledge_nll": 20.449058532714844, + "identifier_accuracy": 0.00341796875, + "population_n": 9988, + "first_atomic_accuracy": 0.1953125, + "second_atomic_accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0038314176245210726 + }, + "OI": { + "n": 2048, + "accuracy": 0.0087890625, + "answer_nll": 14.067947387695312, + "knowledge_nll": 14.065528869628906, + "identifier_accuracy": 0.0087890625, + "population_n": 13308, + "first_atomic_accuracy": 0.1875, + "second_atomic_accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617 + }, + "OO": { + "n": 2048, + "accuracy": 0.00537109375, + "answer_nll": 20.17261505126953, + "knowledge_nll": 20.172481536865234, + "identifier_accuracy": 0.00537109375, + "population_n": 6256, + "first_atomic_accuracy": 0.1845703125, + "second_atomic_accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.008264462809917356 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.45751953125, + "answer_nll": 1.8601629734039307, + "knowledge_nll": 1.8601325750350952, + "identifier_accuracy": 0.45751953125, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 64548.91073863921, + "learned_bits_per_parameter": 0.6268345123003342 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.12841796875, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00634765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 0.011627906976744186, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.6259765625, + "both_atomic_n": 258, + "both_atomic_coverage": 0.1259765625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99853515625, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.1318359375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0078125, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.646484375, + "both_atomic_n": 261, + "both_atomic_coverage": 0.12744140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 0.00425531914893617, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.59765625, + "both_atomic_n": 235, + "both_atomic_coverage": 0.11474609375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.12255859375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.63427734375, + "both_atomic_n": 242, + "both_atomic_coverage": 0.1181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 1.3523927905531385, + "learned_density": 0.6268345123003342, + "atomic": 0.21811810661764705, + "train_composition": 0.45751953125, + "II": 0.00830078125, + "serial_II": 0.12841796875, + "wrong_bridge_II": 0.00634765625, + "oracle_bridge_II": 0.6259765625, + "II_both_coverage": 0.1259765625, + "IO": 0.00341796875, + "serial_IO": 0.1318359375, + "wrong_bridge_IO": 0.0078125, + "oracle_bridge_IO": 0.646484375, + "IO_both_coverage": 0.12744140625, + "OI": 0.0087890625, + "serial_OI": 0.119140625, + "wrong_bridge_OI": 0.0068359375, + "oracle_bridge_OI": 0.59765625, + "OI_both_coverage": 0.11474609375, + "OO": 0.00537109375, + "serial_OO": 0.12255859375, + "wrong_bridge_OO": 0.00732421875, + "oracle_bridge_OO": 0.63427734375, + "OO_both_coverage": 0.1181640625 + }, + { + "name": "recall-load-h16384", + "heads_n": 16384, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/load-scan/runs/load-h16384", + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.013942307692307693, + "answer_nll": 5.332866668701172, + "knowledge_nll": 5.332655429840088, + "identifier_accuracy": 0.013942307692307693, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.0124969482421875, + "answer_nll": 5.36183500289917, + "knowledge_nll": 5.361629486083984, + "identifier_accuracy": 0.0124969482421875, + "learned_bits_raw": 17354.17720619624 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.1064453125, + "answer_nll": 3.4788806438446045, + "knowledge_nll": 3.478288173675537, + "identifier_accuracy": 0.1064453125, + "learned_bits_raw": 3053.456282680907 + }, + "II": { + "n": 2048, + "accuracy": 0.01318359375, + "answer_nll": 6.002089500427246, + "knowledge_nll": 6.002084732055664, + "identifier_accuracy": 0.01318359375, + "population_n": 69718, + "first_atomic_accuracy": 0.00927734375, + "second_atomic_accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.00244140625, + "answer_nll": 9.324575424194336, + "knowledge_nll": 9.324567794799805, + "identifier_accuracy": 0.00244140625, + "population_n": 40069, + "first_atomic_accuracy": 0.02001953125, + "second_atomic_accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null + }, + "OI": { + "n": 2048, + "accuracy": 0.015625, + "answer_nll": 6.006150245666504, + "knowledge_nll": 6.006135940551758, + "identifier_accuracy": 0.015625, + "population_n": 53757, + "first_atomic_accuracy": 0.00732421875, + "second_atomic_accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.00146484375, + "answer_nll": 9.133949279785156, + "knowledge_nll": 9.133926391601562, + "identifier_accuracy": 0.00146484375, + "population_n": 24671, + "first_atomic_accuracy": 0.01513671875, + "second_atomic_accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.087890625, + "answer_nll": 3.885626792907715, + "knowledge_nll": 3.8856210708618164, + "identifier_accuracy": 0.087890625, + "population_n": 73929 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 20407.592631302774, + "learned_bits_per_parameter": 0.1981781447259825 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.005859375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.12060546875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.06201171875, + "both_atomic_n": 0, + "both_atomic_coverage": 0.0, + "both_atomic_composition_accuracy": null, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.00830078125, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00732421875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.119140625, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.00341796875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0029296875, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.07177734375, + "both_atomic_n": 1, + "both_atomic_coverage": 0.00048828125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 5.170913610938471, + "learned_density": 0.1981781447259825, + "atomic": 0.013942307692307693, + "train_composition": 0.087890625, + "II": 0.01318359375, + "serial_II": 0.005859375, + "wrong_bridge_II": 0.00830078125, + "oracle_bridge_II": 0.12060546875, + "II_both_coverage": 0.00048828125, + "IO": 0.00244140625, + "serial_IO": 0.00341796875, + "wrong_bridge_IO": 0.00390625, + "oracle_bridge_IO": 0.06201171875, + "IO_both_coverage": 0.0, + "OI": 0.015625, + "serial_OI": 0.00830078125, + "wrong_bridge_OI": 0.00732421875, + "oracle_bridge_OI": 0.119140625, + "OI_both_coverage": 0.00048828125, + "OO": 0.00146484375, + "serial_OO": 0.00341796875, + "wrong_bridge_OO": 0.0029296875, + "oracle_bridge_OO": 0.07177734375, + "OO_both_coverage": 0.00048828125 + }, + { + "name": "recall-background-h1024", + "heads_n": 1024, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h1024", + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00017469974409323186, + "knowledge_nll": 0.00017428063438273966, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00018967264622915536, + "knowledge_nll": 0.00018929645011667162, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32766.88139448385 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00011480812099762261, + "knowledge_nll": 0.00011421731323935091, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.8312645105725 + }, + "atomic_background": { + "n": 3072, + "accuracy": 1.0, + "answer_nll": 0.0002004616690101102, + "knowledge_nll": 0.00020001969824079424, + "identifier_accuracy": 1.0, + "learned_bits_raw": 24575.11352086508 + }, + "atomic_target": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00013605682761408389, + "knowledge_nll": 0.00013567201676778495, + "identifier_accuracy": 1.0, + "learned_bits_raw": 16383.599138107846 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 35.12508010864258, + "knowledge_nll": 35.12507629394531, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 40.16291809082031, + "knowledge_nll": 40.16291427612305, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "answer_nll": 34.633235931396484, + "knowledge_nll": 34.63323211669922, + "identifier_accuracy": 0.006535947712418301, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 40.470703125, + "knowledge_nll": 40.470703125, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001838235294117647 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.000104951934190467, + "knowledge_nll": 0.00010415949509479105, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40958.71265890843, + "learned_bits_per_parameter": 0.3977500840866651 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.3977625854568055, + "learned_density": 0.3977500840866651, + "atomic": 1.0, + "train_composition": 1.0, + "II": 0.010227272727272727, + "serial_II": 1.0, + "wrong_bridge_II": 0.0, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.004489337822671156, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.0, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.006535947712418301, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.001838235294117647, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "recall-background-h4096", + "heads_n": 4096, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h4096", + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7446001838235294, + "answer_nll": 0.827059268951416, + "knowledge_nll": 0.8270354270935059, + "identifier_accuracy": 0.7446001838235294, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.73736572265625, + "answer_nll": 0.8522984385490417, + "knowledge_nll": 0.852286696434021, + "identifier_accuracy": 0.73736572265625, + "learned_bits_raw": 110926.40087472538 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8603515625, + "answer_nll": 0.4232327342033386, + "knowledge_nll": 0.4230150878429413, + "identifier_accuracy": 0.8603515625, + "learned_bits_raw": 7567.071468080926 + }, + "atomic_background": { + "n": 15360, + "accuracy": 0.7309895833333333, + "answer_nll": 0.874413251876831, + "knowledge_nll": 0.874402642250061, + "identifier_accuracy": 0.7309895833333333, + "learned_bits_raw": 103503.41597622729 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.8466796875, + "answer_nll": 0.47190460562705994, + "knowledge_nll": 0.47178179025650024, + "identifier_accuracy": 0.8466796875, + "learned_bits_raw": 14990.054913669592 + }, + "II": { + "n": 880, + "accuracy": 0.006818181818181818, + "answer_nll": 27.632980346679688, + "knowledge_nll": 27.632936477661133, + "identifier_accuracy": 0.006818181818181818, + "population_n": 880, + "first_atomic_accuracy": 0.8454545454545455, + "second_atomic_accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.004807692307692308 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 30.619428634643555, + "knowledge_nll": 30.619401931762695, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.8338945005611672, + "second_atomic_accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.004594180704441042 + }, + "OI": { + "n": 612, + "accuracy": 0.0032679738562091504, + "answer_nll": 28.253385543823242, + "knowledge_nll": 28.253379821777344, + "identifier_accuracy": 0.0032679738562091504, + "population_n": 612, + "first_atomic_accuracy": 0.7990196078431373, + "second_atomic_accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.003676470588235294, + "answer_nll": 29.52218246459961, + "knowledge_nll": 29.522167205810547, + "identifier_accuracy": 0.003676470588235294, + "population_n": 544, + "first_atomic_accuracy": 0.84375, + "second_atomic_accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0024330900243309003 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.9101796407185628, + "answer_nll": 0.28134071826934814, + "knowledge_nll": 0.28127506375312805, + "identifier_accuracy": 0.9101796407185628, + "population_n": 1169 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 118493.47229877875, + "learned_bits_per_parameter": 1.1506901831376122 + }, + "serial_II": { + "n": 880, + "accuracy": 0.7090909090909091, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.8386363636363636, + "both_atomic_n": 624, + "both_atomic_coverage": 0.7090909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.7351290684624018, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.008978675645342313, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.8911335578002245, + "both_atomic_n": 653, + "both_atomic_coverage": 0.7328843995510662, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.684640522875817, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 0.00477326968973747, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.8496732026143791, + "both_atomic_n": 419, + "both_atomic_coverage": 0.684640522875817, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.7555147058823529, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.8915441176470589, + "both_atomic_n": 411, + "both_atomic_coverage": 0.7555147058823529, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 1.3523927905531385, + "learned_density": 1.1506901831376122, + "atomic": 0.7446001838235294, + "train_composition": 0.9101796407185628, + "II": 0.006818181818181818, + "serial_II": 0.7090909090909091, + "wrong_bridge_II": 0.004545454545454545, + "oracle_bridge_II": 0.8386363636363636, + "II_both_coverage": 0.7090909090909091, + "IO": 0.003367003367003367, + "serial_IO": 0.7351290684624018, + "wrong_bridge_IO": 0.008978675645342313, + "oracle_bridge_IO": 0.8911335578002245, + "IO_both_coverage": 0.7328843995510662, + "OI": 0.0032679738562091504, + "serial_OI": 0.684640522875817, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 0.8496732026143791, + "OI_both_coverage": 0.684640522875817, + "OO": 0.003676470588235294, + "serial_OO": 0.7555147058823529, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 0.8915441176470589, + "OO_both_coverage": 0.7555147058823529 + }, + { + "name": "recall-background-h16384", + "heads_n": 16384, + "arm": "old_weights", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/fixed-target/runs/background-h16384", + "metrics": { + "atomic": { + "n": 66560, + "accuracy": 0.07536057692307692, + "answer_nll": 4.5034284591674805, + "knowledge_nll": 4.503402233123779, + "identifier_accuracy": 0.07536057692307692, + "full_population": true + }, + "atomic_first": { + "n": 65536, + "accuracy": 0.068389892578125, + "answer_nll": 4.545054912567139, + "knowledge_nll": 4.545030117034912, + "identifier_accuracy": 0.068389892578125, + "learned_bits_raw": 94562.39178303059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.521484375, + "answer_nll": 1.8393397331237793, + "knowledge_nll": 1.8392066955566406, + "identifier_accuracy": 0.521484375, + "learned_bits_raw": 5474.903676058273 + }, + "atomic_background": { + "n": 64512, + "accuracy": 0.0689329117063492, + "answer_nll": 4.539407253265381, + "knowledge_nll": 4.539381980895996, + "identifier_accuracy": 0.0689329117063492, + "learned_bits_raw": 93610.53289473998 + }, + "atomic_target": { + "n": 2048, + "accuracy": 0.27783203125, + "answer_nll": 3.3700973987579346, + "knowledge_nll": 3.370026111602783, + "identifier_accuracy": 0.27783203125, + "learned_bits_raw": 6426.7879242226645 + }, + "II": { + "n": 880, + "accuracy": 0.004545454545454545, + "answer_nll": 11.732002258300781, + "knowledge_nll": 11.731553077697754, + "identifier_accuracy": 0.004545454545454545, + "population_n": 880, + "first_atomic_accuracy": 0.028409090909090908, + "second_atomic_accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.003367003367003367, + "answer_nll": 12.642873764038086, + "knowledge_nll": 12.642569541931152, + "identifier_accuracy": 0.003367003367003367, + "population_n": 891, + "first_atomic_accuracy": 0.031425364758698095, + "second_atomic_accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 12.019797325134277, + "knowledge_nll": 12.019563674926758, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 0.042483660130718956, + "second_atomic_accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.001838235294117647, + "answer_nll": 12.872064590454102, + "knowledge_nll": 12.871174812316895, + "identifier_accuracy": 0.001838235294117647, + "population_n": 544, + "first_atomic_accuracy": 0.03308823529411765, + "second_atomic_accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.5765611633875107, + "answer_nll": 1.4960180521011353, + "knowledge_nll": 1.4957056045532227, + "identifier_accuracy": 0.5765611633875107, + "population_n": 1169 + }, + "information": { + "independent_facts": 66560, + "world_bits": 532480.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 5.170913610938471, + "composition_independent_bits": 0, + "learned_bits_raw": 100037.27925694728, + "learned_bits_per_parameter": 0.9714620810377882 + }, + "serial_II": { + "n": 880, + "accuracy": 0.02159090909090909, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.006818181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.4943181818181818, + "both_atomic_n": 15, + "both_atomic_coverage": 0.017045454545454544, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.016835016835016835, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.006734006734006734, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.5241301907968574, + "both_atomic_n": 12, + "both_atomic_coverage": 0.013468013468013467, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.021241830065359478, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.011437908496732025, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.565359477124183, + "both_atomic_n": 12, + "both_atomic_coverage": 0.0196078431372549, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.027573529411764705, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.012867647058823529, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.5533088235294118, + "both_atomic_n": 11, + "both_atomic_coverage": 0.02022058823529412, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 5.170913610938471, + "learned_density": 0.9714620810377882, + "atomic": 0.07536057692307692, + "train_composition": 0.5765611633875107, + "II": 0.004545454545454545, + "serial_II": 0.02159090909090909, + "wrong_bridge_II": 0.006818181818181818, + "oracle_bridge_II": 0.4943181818181818, + "II_both_coverage": 0.017045454545454544, + "IO": 0.003367003367003367, + "serial_IO": 0.016835016835016835, + "wrong_bridge_IO": 0.006734006734006734, + "oracle_bridge_IO": 0.5241301907968574, + "IO_both_coverage": 0.013468013468013467, + "OI": 0.008169934640522876, + "serial_OI": 0.021241830065359478, + "wrong_bridge_OI": 0.011437908496732025, + "oracle_bridge_OI": 0.565359477124183, + "OI_both_coverage": 0.0196078431372549, + "OO": 0.001838235294117647, + "serial_OO": 0.027573529411764705, + "wrong_bridge_OO": 0.012867647058823529, + "oracle_bridge_OO": 0.5533088235294118, + "OO_both_coverage": 0.02022058823529412 + }, + { + "name": "atomic-h256", + "heads_n": 256, + "arm": "atomic", + "parent": null, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 1.852807258728717e-06, + "knowledge_nll": 1.6105470876937034e-06, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.9262070054537617e-06, + "knowledge_nll": 1.6569385934417369e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997552171938 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 1.7794075120036723e-06, + "knowledge_nll": 1.5641555819456698e-06, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.997689242111 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 75.06710815429688, + "knowledge_nll": 46.6080436706543, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 74.91608428955078, + "knowledge_nll": 46.640281677246094, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 75.52379608154297, + "knowledge_nll": 47.41034698486328, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 74.99325561523438, + "knowledge_nll": 46.99372863769531, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 75.2520980834961, + "knowledge_nll": 47.073333740234375, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.995241414048, + "learned_bits_per_parameter": 0.15910498797209105 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.15910503418272218, + "learned_density": 0.15910498797209105, + "atomic": 1.0, + "train_composition": 0.0, + "II": 0.0, + "serial_II": 1.0, + "wrong_bridge_II": 0.0, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.0, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.0, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.0, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.0, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "atomic_replay-h256", + "heads_n": 256, + "arm": "atomic_replay", + "parent": null, + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 0.291015625, + "answer_nll": 2.560638427734375, + "knowledge_nll": 2.5604748725891113, + "identifier_accuracy": 0.291015625, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 0.2236328125, + "answer_nll": 2.7695472240448, + "knowledge_nll": 2.76949405670166, + "identifier_accuracy": 0.2236328125, + "learned_bits_raw": 4100.571810432059 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.3583984375, + "answer_nll": 2.35172963142395, + "knowledge_nll": 2.3514554500579834, + "identifier_accuracy": 0.3583984375, + "learned_bits_raw": 4718.148488529942 + }, + "II": { + "n": 880, + "accuracy": 0.0, + "answer_nll": 63.565555572509766, + "knowledge_nll": 29.89066505432129, + "identifier_accuracy": 0.0, + "population_n": 880, + "first_atomic_accuracy": 0.23863636363636365, + "second_atomic_accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 891, + "accuracy": 0.0, + "answer_nll": 64.41242218017578, + "knowledge_nll": 30.54340362548828, + "identifier_accuracy": 0.0, + "population_n": 891, + "first_atomic_accuracy": 0.20987654320987653, + "second_atomic_accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 612, + "accuracy": 0.0, + "answer_nll": 64.0531005859375, + "knowledge_nll": 30.21320915222168, + "identifier_accuracy": 0.0, + "population_n": 612, + "first_atomic_accuracy": 0.24673202614379086, + "second_atomic_accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 544, + "accuracy": 0.0, + "answer_nll": 63.25845718383789, + "knowledge_nll": 29.904817581176758, + "identifier_accuracy": 0.0, + "population_n": 544, + "first_atomic_accuracy": 0.19301470588235295, + "second_atomic_accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 1169, + "accuracy": 0.0, + "answer_nll": 63.29830551147461, + "knowledge_nll": 29.5711612701416, + "identifier_accuracy": 0.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 8818.719946741532, + "learned_bits_per_parameter": 0.08563859488367709 + }, + "serial_II": { + "n": 880, + "accuracy": 0.10795454545454546, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.004545454545454545, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 0.3886363636363636, + "both_atomic_n": 91, + "both_atomic_coverage": 0.10340909090909091, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9988636363636364, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 0.07295173961840629, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 0.37373737373737376, + "both_atomic_n": 60, + "both_atomic_coverage": 0.06734006734006734, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9955106621773289, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 0.09640522875816994, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.004901960784313725, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 0.32516339869281047, + "both_atomic_n": 57, + "both_atomic_coverage": 0.09313725490196079, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9983660130718954, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 0.06985294117647059, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 0.34191176470588236, + "both_atomic_n": 33, + "both_atomic_coverage": 0.06066176470588235, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.9944852941176471, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.15910503418272218, + "learned_density": 0.08563859488367709, + "atomic": 0.291015625, + "train_composition": 0.0, + "II": 0.0, + "serial_II": 0.10795454545454546, + "wrong_bridge_II": 0.004545454545454545, + "oracle_bridge_II": 0.3886363636363636, + "II_both_coverage": 0.10340909090909091, + "IO": 0.0, + "serial_IO": 0.07295173961840629, + "wrong_bridge_IO": 0.004489337822671156, + "oracle_bridge_IO": 0.37373737373737376, + "IO_both_coverage": 0.06734006734006734, + "OI": 0.0, + "serial_OI": 0.09640522875816994, + "wrong_bridge_OI": 0.004901960784313725, + "oracle_bridge_OI": 0.32516339869281047, + "OI_both_coverage": 0.09313725490196079, + "OO": 0.0, + "serial_OO": 0.06985294117647059, + "wrong_bridge_OO": 0.007352941176470588, + "oracle_bridge_OO": 0.34191176470588236, + "OO_both_coverage": 0.06066176470588235 + }, + { + "name": "atomic-h1024", + "heads_n": 1024, + "arm": "atomic", + "parent": null, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 6.343187124002725e-05, + "knowledge_nll": 6.321673572529107e-05, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 6.535269494634122e-05, + "knowledge_nll": 6.520927126985043e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32767.614660230018 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 5.574858369072899e-05, + "knowledge_nll": 5.524660082301125e-05, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.918383107038 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.4780502319336, + "knowledge_nll": 60.92633056640625, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 90.73646545410156, + "knowledge_nll": 60.789772033691406, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.14728546142578, + "knowledge_nll": 60.069427490234375, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 89.3138198852539, + "knowledge_nll": 59.68183898925781, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 89.79078674316406, + "knowledge_nll": 60.41696548461914, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40959.5330433478, + "learned_bits_per_parameter": 0.3977580508404657 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.3977625854568055, + "learned_density": 0.3977580508404657, + "atomic": 1.0, + "train_composition": 0.0, + "II": 0.0, + "serial_II": 1.0, + "wrong_bridge_II": 0.00390625, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.0, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.00439453125, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.0, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.001953125, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.0, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.003814367450731087, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "atomic_replay-h1024", + "heads_n": 1024, + "arm": "atomic_replay", + "parent": null, + "metrics": { + "atomic": { + "n": 5120, + "accuracy": 1.0, + "answer_nll": 0.00031458126613870263, + "knowledge_nll": 0.00031447564833797514, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 4096, + "accuracy": 1.0, + "answer_nll": 0.00034317426616325974, + "knowledge_nll": 0.00034307054011151195, + "identifier_accuracy": 1.0, + "learned_bits_raw": 32765.972700500402 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00020020920783281326, + "knowledge_nll": 0.0002000961685553193, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.704393983922 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 152.88522338867188, + "knowledge_nll": 81.95446014404297, + "identifier_accuracy": 0.0, + "population_n": 4402, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.7292022705078, + "knowledge_nll": 83.51936340332031, + "identifier_accuracy": 0.0, + "population_n": 2629, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 154.1458740234375, + "knowledge_nll": 82.13455963134766, + "identifier_accuracy": 0.0, + "population_n": 3107, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 1573, + "accuracy": 0.0, + "answer_nll": 155.16091918945312, + "knowledge_nll": 83.30101776123047, + "identifier_accuracy": 0.0, + "population_n": 1573, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 153.95921325683594, + "knowledge_nll": 82.60690307617188, + "identifier_accuracy": 0.0, + "population_n": 4673 + }, + "information": { + "independent_facts": 5120, + "world_bits": 40960.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.3977625854568055, + "composition_independent_bits": 0, + "learned_bits_raw": 40957.67709461331, + "learned_bits_per_parameter": 0.39774002772115163 + }, + "serial_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.00390625, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00390625, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.00439453125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.00439453125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.001953125, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.001953125, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 1.0, + "both_atomic_n": 2048, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 1573, + "accuracy": 0.003814367450731087, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.003814367450731087, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 1573, + "accuracy": 1.0, + "both_atomic_n": 1573, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.3977625854568055, + "learned_density": 0.39774002772115163, + "atomic": 1.0, + "train_composition": 0.0, + "II": 0.0, + "serial_II": 1.0, + "wrong_bridge_II": 0.00390625, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.0, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.00439453125, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.0, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.001953125, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.0, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.003814367450731087, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "atomic-h4096", + "heads_n": 4096, + "arm": "atomic", + "parent": null, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7165096507352942, + "answer_nll": 0.9351626634597778, + "knowledge_nll": 0.935147225856781, + "identifier_accuracy": 0.7165096507352942, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.70599365234375, + "answer_nll": 0.9714698195457458, + "knowledge_nll": 0.971454918384552, + "identifier_accuracy": 0.70599365234375, + "learned_bits_raw": 108109.6078426016 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.884765625, + "answer_nll": 0.35424816608428955, + "knowledge_nll": 0.3542240560054779, + "identifier_accuracy": 0.884765625, + "learned_bits_raw": 7668.697816102218 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.22854614257812, + "knowledge_nll": 49.78916931152344, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.7109375, + "second_atomic_accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.97843170166016, + "knowledge_nll": 50.494781494140625, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.7001953125, + "second_atomic_accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.48211669921875, + "knowledge_nll": 49.74689483642578, + "identifier_accuracy": 0.00048828125, + "population_n": 13308, + "first_atomic_accuracy": 0.70458984375, + "second_atomic_accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.88727569580078, + "knowledge_nll": 50.95634460449219, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.7177734375, + "second_atomic_accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 123.36808013916016, + "knowledge_nll": 49.981666564941406, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 115778.30552662114, + "learned_bits_per_parameter": 1.1243231969257026 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.64306640625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0015232292460015233, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.89013671875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.61572265625, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0048828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 0.001589825119236884, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8798828125, + "both_atomic_n": 1258, + "both_atomic_coverage": 0.6142578125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6123046875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00537109375, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 0.004788507581803671, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.86279296875, + "both_atomic_n": 1253, + "both_atomic_coverage": 0.61181640625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.64111328125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 0.0053475935828877, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.89501953125, + "both_atomic_n": 1309, + "both_atomic_coverage": 0.63916015625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 1.3523927905531385, + "learned_density": 1.1243231969257026, + "atomic": 0.7165096507352942, + "train_composition": 0.0, + "II": 0.0, + "serial_II": 0.64306640625, + "wrong_bridge_II": 0.0048828125, + "oracle_bridge_II": 0.89013671875, + "II_both_coverage": 0.64111328125, + "IO": 0.0, + "serial_IO": 0.61572265625, + "wrong_bridge_IO": 0.0048828125, + "oracle_bridge_IO": 0.8798828125, + "IO_both_coverage": 0.6142578125, + "OI": 0.0, + "serial_OI": 0.6123046875, + "wrong_bridge_OI": 0.00537109375, + "oracle_bridge_OI": 0.86279296875, + "OI_both_coverage": 0.61181640625, + "OO": 0.0, + "serial_OO": 0.64111328125, + "wrong_bridge_OO": 0.0087890625, + "oracle_bridge_OO": 0.89501953125, + "OO_both_coverage": 0.63916015625 + }, + { + "name": "atomic_replay-h4096", + "heads_n": 4096, + "arm": "atomic_replay", + "parent": null, + "metrics": { + "atomic": { + "n": 17408, + "accuracy": 0.7679227941176471, + "answer_nll": 0.7522584199905396, + "knowledge_nll": 0.7521635293960571, + "identifier_accuracy": 0.7679227941176471, + "full_population": true + }, + "atomic_first": { + "n": 16384, + "accuracy": 0.76165771484375, + "answer_nll": 0.7713814973831177, + "knowledge_nll": 0.7713284492492676, + "identifier_accuracy": 0.76165771484375, + "learned_bits_raw": 112840.02031815077 + }, + "atomic_second": { + "n": 1024, + "accuracy": 0.8681640625, + "answer_nll": 0.4462886154651642, + "knowledge_nll": 0.4455249607563019, + "identifier_accuracy": 0.8681640625, + "learned_bits_raw": 7533.817188889225 + }, + "II": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 134.19708251953125, + "knowledge_nll": 68.98158264160156, + "identifier_accuracy": 0.0, + "population_n": 17515, + "first_atomic_accuracy": 0.75537109375, + "second_atomic_accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.0 + }, + "IO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 132.91983032226562, + "knowledge_nll": 67.88194274902344, + "identifier_accuracy": 0.0, + "population_n": 9988, + "first_atomic_accuracy": 0.78173828125, + "second_atomic_accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.0 + }, + "OI": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.59744262695312, + "knowledge_nll": 68.44195556640625, + "identifier_accuracy": 0.0, + "population_n": 13308, + "first_atomic_accuracy": 0.75927734375, + "second_atomic_accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.0 + }, + "OO": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.86203002929688, + "knowledge_nll": 67.7496566772461, + "identifier_accuracy": 0.0, + "population_n": 6256, + "first_atomic_accuracy": 0.77197265625, + "second_atomic_accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.0 + }, + "train_composition": { + "n": 2048, + "accuracy": 0.0, + "answer_nll": 133.4477081298828, + "knowledge_nll": 68.21073913574219, + "identifier_accuracy": 0.0, + "population_n": 18469 + }, + "information": { + "independent_facts": 17408, + "world_bits": 139264.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 1.3523927905531385, + "composition_independent_bits": 0, + "learned_bits_raw": 120373.83772717779, + "learned_bits_per_parameter": 1.1689504129814499 + }, + "serial_II": { + "n": 2048, + "accuracy": 0.65283203125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 2048, + "accuracy": 0.0107421875, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 0.005251312828207052, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 2048, + "accuracy": 0.86328125, + "both_atomic_n": 1333, + "both_atomic_coverage": 0.65087890625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 2048, + "accuracy": 0.69140625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 2048, + "accuracy": 0.0087890625, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 0.004953998584571833, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 2048, + "accuracy": 0.8896484375, + "both_atomic_n": 1413, + "both_atomic_coverage": 0.68994140625, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 2048, + "accuracy": 0.6416015625, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 2048, + "accuracy": 0.00927734375, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 0.006854531607006854, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 2048, + "accuracy": 0.8466796875, + "both_atomic_n": 1313, + "both_atomic_coverage": 0.64111328125, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 2048, + "accuracy": 0.6953125, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 2048, + "accuracy": 0.0068359375, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 0.005637773079633545, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 2048, + "accuracy": 0.8994140625, + "both_atomic_n": 1419, + "both_atomic_coverage": 0.69287109375, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 0.99951171875, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 1.3523927905531385, + "learned_density": 1.1689504129814499, + "atomic": 0.7679227941176471, + "train_composition": 0.0, + "II": 0.0, + "serial_II": 0.65283203125, + "wrong_bridge_II": 0.0107421875, + "oracle_bridge_II": 0.86328125, + "II_both_coverage": 0.65087890625, + "IO": 0.0, + "serial_IO": 0.69140625, + "wrong_bridge_IO": 0.0087890625, + "oracle_bridge_IO": 0.8896484375, + "IO_both_coverage": 0.68994140625, + "OI": 0.0, + "serial_OI": 0.6416015625, + "wrong_bridge_OI": 0.00927734375, + "oracle_bridge_OI": 0.8466796875, + "OI_both_coverage": 0.64111328125, + "OO": 0.0, + "serial_OO": 0.6953125, + "wrong_bridge_OO": 0.0068359375, + "oracle_bridge_OO": 0.8994140625, + "OO_both_coverage": 0.69287109375 + }, + { + "name": "continuation-wd0.01", + "heads_n": 256, + "arm": "mixed", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.0004575219645630568, + "knowledge_nll": 0.0004546176642179489, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004955988842993975, + "knowledge_nll": 0.0004946840927004814, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.269193433758 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.0004194450448267162, + "knowledge_nll": 0.00041455120663158596, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.387575326718 + }, + "II": { + "n": 880, + "accuracy": 0.005681818181818182, + "answer_nll": 32.82706832885742, + "knowledge_nll": 32.827064514160156, + "identifier_accuracy": 0.005681818181818182, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.005681818181818182 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 38.12151336669922, + "knowledge_nll": 38.12150192260742, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.014705882352941176, + "answer_nll": 33.14290237426758, + "knowledge_nll": 33.14289855957031, + "identifier_accuracy": 0.014705882352941176, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.014705882352941176 + }, + "OO": { + "n": 544, + "accuracy": 0.007352941176470588, + "answer_nll": 39.64762878417969, + "knowledge_nll": 39.64761734008789, + "identifier_accuracy": 0.007352941176470588, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.007352941176470588 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0005104398587718606, + "knowledge_nll": 0.0005056438967585564, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16382.656768717481, + "learned_bits_per_parameter": 0.1590919900629028 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.15910503418272218, + "learned_density": 0.1590919900629028, + "atomic": 1.0, + "train_composition": 1.0, + "II": 0.005681818181818182, + "serial_II": 1.0, + "wrong_bridge_II": 0.0, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.004489337822671156, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.0, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.014705882352941176, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.007352941176470588, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + }, + { + "name": "continuation-wd0.1", + "heads_n": 256, + "arm": "mixed", + "parent": "/ossfs/workspace/llm-memory-editability/results/capacity-scaling-development-v1/calibration-long/runs/calibration-long", + "metrics": { + "atomic": { + "n": 2048, + "accuracy": 1.0, + "answer_nll": 0.00023144441365730017, + "knowledge_nll": 0.00022873673879075795, + "identifier_accuracy": 1.0, + "full_population": true + }, + "atomic_first": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.000221588445128873, + "knowledge_nll": 0.00021811686747241765, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.67777165001 + }, + "atomic_second": { + "n": 1024, + "accuracy": 1.0, + "answer_nll": 0.00024130038218572736, + "knowledge_nll": 0.00023935661010909826, + "identifier_accuracy": 1.0, + "learned_bits_raw": 8191.646393759326 + }, + "II": { + "n": 880, + "accuracy": 0.010227272727272727, + "answer_nll": 28.51885223388672, + "knowledge_nll": 28.51885223388672, + "identifier_accuracy": 0.010227272727272727, + "population_n": 880, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.010227272727272727 + }, + "IO": { + "n": 891, + "accuracy": 0.004489337822671156, + "answer_nll": 32.9504508972168, + "knowledge_nll": 32.9504508972168, + "identifier_accuracy": 0.004489337822671156, + "population_n": 891, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.004489337822671156 + }, + "OI": { + "n": 612, + "accuracy": 0.008169934640522876, + "answer_nll": 29.162445068359375, + "knowledge_nll": 29.162445068359375, + "identifier_accuracy": 0.008169934640522876, + "population_n": 612, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.008169934640522876 + }, + "OO": { + "n": 544, + "accuracy": 0.0055147058823529415, + "answer_nll": 34.03778076171875, + "knowledge_nll": 34.03778076171875, + "identifier_accuracy": 0.0055147058823529415, + "population_n": 544, + "first_atomic_accuracy": 1.0, + "second_atomic_accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0055147058823529415 + }, + "train_composition": { + "n": 1169, + "accuracy": 1.0, + "answer_nll": 0.0002445103309582919, + "knowledge_nll": 0.00024392938939854503, + "identifier_accuracy": 1.0, + "population_n": 1169 + }, + "information": { + "independent_facts": 2048, + "world_bits": 16384.0, + "parameters": 102976, + "adjusted_parameters": 102976, + "data_bits_per_parameter": 0.15910503418272218, + "composition_independent_bits": 0, + "learned_bits_raw": 16383.324165409336, + "learned_bits_per_parameter": 0.1590984711525922 + }, + "serial_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_II": { + "n": 880, + "accuracy": 0.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_II": { + "n": 880, + "accuracy": 1.0, + "both_atomic_n": 880, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_IO": { + "n": 891, + "accuracy": 0.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_IO": { + "n": 891, + "accuracy": 1.0, + "both_atomic_n": 891, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OI": { + "n": 612, + "accuracy": 0.006535947712418301, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.006535947712418301, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OI": { + "n": 612, + "accuracy": 1.0, + "both_atomic_n": 612, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + }, + "serial_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "wrong_bridge_OO": { + "n": 544, + "accuracy": 0.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 0.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": false, + "generation_forward_calls_per_query": 12 + }, + "oracle_bridge_OO": { + "n": 544, + "accuracy": 1.0, + "both_atomic_n": 544, + "both_atomic_coverage": 1.0, + "both_atomic_composition_accuracy": 1.0, + "valid_bridge_fraction": 1.0, + "external_decomposition": true, + "oracle_information": true, + "generation_forward_calls_per_query": 6 + } + }, + "density": 0.15910503418272218, + "learned_density": 0.1590984711525922, + "atomic": 1.0, + "train_composition": 1.0, + "II": 0.010227272727272727, + "serial_II": 1.0, + "wrong_bridge_II": 0.0, + "oracle_bridge_II": 1.0, + "II_both_coverage": 1.0, + "IO": 0.004489337822671156, + "serial_IO": 1.0, + "wrong_bridge_IO": 0.0, + "oracle_bridge_IO": 1.0, + "IO_both_coverage": 1.0, + "OI": 0.008169934640522876, + "serial_OI": 1.0, + "wrong_bridge_OI": 0.006535947712418301, + "oracle_bridge_OI": 1.0, + "OI_both_coverage": 1.0, + "OO": 0.0055147058823529415, + "serial_OO": 1.0, + "wrong_bridge_OO": 0.0, + "oracle_bridge_OO": 1.0, + "OO_both_coverage": 1.0 + } + ], + "interpretation_limits": [ + "External two-call recall is not implicit composition or an internal repair.", + "Atomic replay matches examples/updates/nominal matmul FLOPs, not atomic exposure.", + "Atomic-only matches base factual exposure, not total compute.", + "Continuation changes duration; the paired arm changes late weight decay only.", + "No parameter capacity bound, scaling exponent, or independent-world confirmation." + ], + "paired_training_comparisons": [ + { + "heads_n": 256, + "arm": "atomic", + "atomic_delta": 0.0, + "learned_density_delta": -4.412798737529755e-08, + "serial_II_delta": 0.0 + }, + { + "heads_n": 256, + "arm": "atomic_replay", + "atomic_delta": -0.708984375, + "learned_density_delta": -0.07346643721640134, + "serial_II_delta": -0.8920454545454546 + }, + { + "heads_n": 1024, + "arm": "atomic", + "atomic_delta": 0.06660156250000004, + "learned_density_delta": 0.01434834004084462, + "serial_II_delta": 0.09912109375 + }, + { + "heads_n": 1024, + "arm": "atomic_replay", + "atomic_delta": 0.06660156250000004, + "learned_density_delta": 0.014330316921530528, + "serial_II_delta": 0.09912109375 + }, + { + "heads_n": 4096, + "arm": "atomic", + "atomic_delta": 0.4983915441176471, + "learned_density_delta": 0.49748868462536844, + "serial_II_delta": 0.5146484375 + }, + { + "heads_n": 4096, + "arm": "atomic_replay", + "atomic_delta": 0.5498046875, + "learned_density_delta": 0.5421159006811157, + "serial_II_delta": 0.5244140625 + } + ] +} diff --git a/results/capacity-recall-controls-v1/tracking-completion.json b/results/capacity-recall-controls-v1/tracking-completion.json new file mode 100644 index 0000000000000000000000000000000000000000..d86779e06eec3e3206e211c6cdc422512d39892d --- /dev/null +++ b/results/capacity-recall-controls-v1/tracking-completion.json @@ -0,0 +1,74 @@ +{ + "passed": true, + "registered_runs": 17, + "runs": { + "atomic-h1024": { + "last_logged_step": 30000, + "final_step": 30000 + }, + "atomic-h256": { + "last_logged_step": 12000, + "final_step": 12000 + }, + "atomic-h4096": { + "last_logged_step": 102000, + "final_step": 102000 + }, + "atomic_replay-h1024": { + "last_logged_step": 60000, + "final_step": 60000 + }, + "atomic_replay-h256": { + "last_logged_step": 21000, + "final_step": 21000 + }, + "atomic_replay-h4096": { + "last_logged_step": 213000, + "final_step": 213000 + }, + "continuation-wd0.01": { + "last_logged_step": 280000, + "final_step": 280000 + }, + "continuation-wd0.1": { + "last_logged_step": 280000, + "final_step": 280000 + }, + "recall-background-h1024": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-background-h16384": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-background-h4096": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-calibration-long": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-calibration-lr0.001": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-calibration-lr0.003": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-load-h1024": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-load-h16384": { + "last_logged_step": 1, + "final_step": 1 + }, + "recall-load-h4096": { + "last_logged_step": 1, + "final_step": 1 + } + } +} diff --git a/results/capacity-recall-controls-v1/tracking-process.json b/results/capacity-recall-controls-v1/tracking-process.json new file mode 100644 index 0000000000000000000000000000000000000000..2c841b295a8e057354c3f17c7c28f28600f5c77c --- /dev/null +++ b/results/capacity-recall-controls-v1/tracking-process.json @@ -0,0 +1,13 @@ +{ + "pid": 329037, + "command": [ + "/ossfs/workspace/llm-memory-editability/.venv-wandb/bin/python", + "-u", + "-m", + "llm_memory_editability.interface_tracking", + "--root", + "/ossfs/workspace/llm-memory-editability/results/capacity-recall-controls-v1", + "--defaults", + "/ossfs/workspace/llm-memory-editability/docs/development-artifacts/capacity-recall-controls-v1/source/configs/experiment-tracking-defaults.json" + ] +} diff --git a/results/capacity-recall-controls-v1/tracking-ready.json b/results/capacity-recall-controls-v1/tracking-ready.json new file mode 100644 index 0000000000000000000000000000000000000000..d392056d14e35def1e344d596ae54514ab7a6129 --- /dev/null +++ b/results/capacity-recall-controls-v1/tracking-ready.json @@ -0,0 +1,3 @@ +{ + "sdk_version": "0.30.0" +} diff --git a/results/capacity-recall-controls-v1/tracking-wandb/atomic-h1024/state.json b/results/capacity-recall-controls-v1/tracking-wandb/atomic-h1024/state.json new file mode 100644 index 0000000000000000000000000000000000000000..165f7e055c4890d6d58ea53ab8a97b7693032bba --- /dev/null +++ b/results/capacity-recall-controls-v1/tracking-wandb/atomic-h1024/state.json @@ -0,0 +1,10 @@ +{ + "run_id": "e224630bbcd7a99c", + "fingerprint": "e224630bbcd7a99c6cc1588c25cea8f282cf6b9b11ae2813f53dd6dd3b114e02", + "entity": "zhusq20", + "project": "llm-memory-editability", + "last_logged_step": 30000, + "url": "https://wandb.ai/zhusq20/llm-memory-editability/runs/e224630bbcd7a99c", + "mode": "online", + "wandb_run_id": "e224630bbcd7a99c" +}