gpt-5.6-sol

{
  "cell_id": "112",
  "yield_time_ms": 30000,
  "max_tokens": 5000
}

{
  "input": "const r = await tools.write_stdin({session_id:62713,chars:\"\",yield_time_ms:30000,max_output_tokens:5000}); text(r);\n"
}

{
  "input": "const r = await tools.exec_command({cmd:\"python work/pack_fast.py data/pool.jsonl work/neural_equal.json work/contrast50.npy && PYTHONPATH=. python work/train_diag.py --train_npy work/contrast50.npy --out_json work/contrast50_result.json\",workdir:\"/workspace\",yield_time_ms:1000,max_output_tokens:10000}); text(r);\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:71599,chars:\"\",yield_time_ms:30000,max_output_tokens:10000}); text(r);\n"
}

{
  "cell_id": "115",
  "yield_time_ms": 30000,
  "max_tokens": 10000
}

{
  "input": "const r = await tools.write_stdin({session_id:71599,chars:\"\",yield_time_ms:30000,max_output_tokens:10000}); text(r);\n"
}

{
  "cell_id": "116",
  "yield_time_ms": 30000,
  "max_tokens": 10000
}

{
  "input": "const r = await tools.write_stdin({session_id:71599,chars:\"\",yield_time_ms:30000,max_output_tokens:10000}); text(r);\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Update File: /workspace/work/make_candidates.py\\n@@\\n-    q=loss[i] - .50*(generic[i]-6.0)\\n+    q=loss[i] - .75*(generic[i]-6.0)\\n*** End Patch\";\nconst a = await tools.apply_patch(patch);\nconst r = await tools.exec_command({cmd:\"python work/make_candidates.py\",workdir:\"/workspace\",yield_time_ms:1000,max_output_tokens:5000});\ntext(a); text(r);\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Add File: /workspace/submission/curate.py\\n+#!/usr/bin/env python3\\n+\\\"\\\"\\\"Contrastive target-affinity curation for the 12M-token nano-GPT run.\\n+\\n+Criterion:\\n+  1. Train a small reference LM on the disclosed, equally weighted dev target.\\n+  2. Train an identical-capacity reference on a deterministic random web sample.\\n+  3. Rank documents by target CE minus 0.75 * generic-web CE, plus transparent\\n+     language/boilerplate/repetition penalties.\\n+  4. Infer the four target registers from their dev quarters and interleave the\\n+     four ranked queues by estimated token mass, so every prefix is balanced.\\n+\\n+This is intentionally self-contained.  It requires the same CUDA/PyTorch and\\n+cached GPT-2 tokenizer available to the supplied training pipeline.\\n+\\\"\\\"\\\"\\n+import collections\\n+import hashlib\\n+import json\\n+import math\\n+import random\\n+import re\\n+from pathlib import Path\\n+\\n+import numpy as np\\n+import torch\\n+import torch.nn.functional as F\\n+from transformers import GPT2TokenizerFast\\n+\\n+import sys\\n+sys.path.insert(0, \\\"/workspace\\\")\\n+from model import GPT, GPTConfig\\n+\\n+ROOT = Path(\\\"/workspace\\\")\\n+POOL = ROOT / \\\"data/pool.jsonl\\\"\\n+DEV = ROOT / \\\"data/multi_dev.npy\\\"\\n+OUT = ROOT / \\\"submission/selection.json\\\"\\n+EOS = 50256\\n+\\n+\\n+def load_pool():\\n+    texts = []\\n+    with POOL.open() as f:\\n+        for line in f:\\n+            row = json.loads(line)\\n+            assert row[\\\"id\\\"] == len(texts)\\n+            texts.append(row[\\\"text\\\"])\\n+    return texts\\n+\\n+\\n+def pack_random_reference(texts, tok):\\n+    order = list(range(len(texts)))\\n+    random.Random(42).shuffle(order)\\n+    parts, total = [], 0\\n+    for j in range(0, len(order), 256):\\n+        batch = tok([texts[i] for i in order[j:j + 256]],\\n+                    add_special_tokens=False,\\n+                    return_attention_mask=False)[\\\"input_ids\\\"]\\n+        for ids in batch:\\n+            ids.append(EOS)\\n+            take = min(len(ids), 12_000_000 - total)\\n+            parts.extend(ids[:take])\\n+            total += take\\n+            if total == 12_000_000:\\n+                return torch.tensor(parts, dtype=torch.long)\\n+    raise RuntimeError(\\\"pool did not fill generic reference budget\\\")\\n+\\n+\\n+def train_reference(src, block, batch, iterations, seed):\\n+    torch.manual_seed(seed)\\n+    np.random.seed(seed)\\n+    rng = np.random.default_rng(seed)\\n+    model = GPT(GPTConfig(block_size=block, vocab_size=50257, n_layer=4,\\n+                          n_head=4, n_embd=256, dropout=0.0,\\n+                          bias=False)).cuda().train()\\n+    opt = model.configure_optimizers(.1, 7e-4, (.9, .95), \\\"cuda\\\")\\n+    warmup = 100\\n+    for it in range(iterations):\\n+        starts = rng.integers(0, len(src) - block - 1, size=batch)\\n+        x = torch.stack([src[i:i + block] for i in starts]).cuda()\\n+        y = torch.stack([src[i + 1:i + block + 1] for i in starts]).cuda()\\n+        if it < warmup:\\n+            lr = 7e-4 * (it + 1) / (warmup + 1)\\n+        else:\\n+            r = (it - warmup) / (iterations - warmup)\\n+            lr = 7e-5 + .5 * (1 + math.cos(math.pi * r)) * 6.3e-4\\n+        for group in opt.param_groups:\\n+            group[\\\"lr\\\"] = lr\\n+        with torch.autocast(\\\"cuda\\\", dtype=torch.bfloat16):\\n+            _, loss = model(x, y)\\n+        opt.zero_grad(set_to_none=True)\\n+        loss.backward()\\n+        opt.step()\\n+    return model.eval()\\n+\\n+\\n+@torch.no_grad()\\n+def score_documents(model, texts, tok, block, batch_size):\\n+    tok.pad_token = tok.eos_token\\n+    scores = np.empty(len(texts), np.float32)\\n+    for begin in range(0, len(texts), batch_size):\\n+        batch = texts[begin:begin + batch_size]\\n+        z = tok(batch, add_special_tokens=False, truncation=True,\\n+                max_length=block + 1, padding=\\\"max_length\\\",\\n+                return_attention_mask=True, return_tensors=\\\"pt\\\")\\n+        x = z.input_ids[:, :block].cuda()\\n+        y = z.input_ids[:, 1:block + 1].cuda()\\n+        mask = z.attention_mask[:, 1:block + 1].cuda()\\n+        mask[:, :7] = 0\\n+        with torch.autocast(\\\"cuda\\\", dtype=torch.bfloat16):\\n+            logits, _ = model(x)\\n+        ce = F.cross_entropy(logits.float().reshape(-1, 50257),\\n+                             y.reshape(-1), reduction=\\\"none\\\")\\n+        ce = ce.view(len(batch), block)\\n+        value = (ce * mask).sum(1) / mask.sum(1).clamp_min(1)\\n+        scores[begin:begin + len(batch)] = value.cpu().numpy()\\n+    return scores\\n+\\n+\\n+WORD = re.compile(r\\\"[A-Za-z][A-Za-z0-9_+#.-]*|</?(?:p|pre|code)>\\\", re.I)\\n+\\n+\\n+def infer_registers(texts, dev, tok):\\n+    \\\"\\\"\\\"Regularized multinomial log-odds against the four dev quarters.\\\"\\\"\\\"\\n+    counts = []\\n+    for domain in range(4):\\n+        decoded = tok.decode(dev[domain * 250_000:(domain + 1) * 250_000])\\n+        counts.append(collections.Counter(WORD.findall(decoded.lower())))\\n+    all_counts = sum(counts, collections.Counter())\\n+    vocab = {word for word, count in all_counts.items() if count >= 12}\\n+    total = sum(all_counts[w] for w in vocab)\\n+    coef = []\\n+    prior_strength = 3000\\n+    for c in counts:\\n+        domain_total = sum(c[w] for w in vocab)\\n+        coef.append({\\n+            w: math.log((c[w] + prior_strength * all_counts[w] / total) /\\n+                        (domain_total + prior_strength))\\n+               - math.log(all_counts[w] / total)\\n+            for w in vocab\\n+        })\\n+    labels = np.empty(len(texts), np.uint8)\\n+    confidence = np.empty(len(texts), np.float32)\\n+    for i, text in enumerate(texts):\\n+        value = np.zeros(4)\\n+        n = 0\\n+        for word in WORD.findall(text[:16_000].lower()):\\n+            if word in vocab:\\n+                n += 1\\n+                for domain in range(4):\\n+                    value[domain] += coef[domain][word]\\n+        if n:\\n+            value /= math.sqrt(n)\\n+        label = int(value.argmax())\\n+        labels[i] = label\\n+        confidence[i] = value[label] - max(value[j] for j in range(4)\\n+                                             if j != label)\\n+    return labels, confidence\\n+\\n+\\n+def rank_and_balance(texts, target_ce, generic_ce, labels, confidence):\\n+    bad_terms = (\\n+        \\\"cookie policy\\\", \\\"privacy policy\\\", \\\"all rights reserved\\\", \\\"sign in\\\",\\n+        \\\"log in\\\", \\\"click here\\\", \\\"shopping cart\\\", \\\"skip to content\\\",\\n+        \\\"terms of use\\\", \\\"contact us\\\", \\\"javascript\\\", \\\"free shipping\\\",\\n+        \\\"search results\\\", \\\"home page\\\", \\\"subscribe\\\",\\n+    )\\n+    queues = [[] for _ in range(4)]\\n+    seen = set()\\n+    word_re = re.compile(r\\\"[a-z]{2,}\\\")\\n+    for i, text in enumerate(texts):\\n+        size = len(text)\\n+        if not 700 <= size <= 40_000:\\n+            continue\\n+        head = text[:12_000]\\n+        lower = head.lower()\\n+        alpha = sum(c.isalpha() for c in head) / len(head)\\n+        if alpha < .55:\\n+            continue\\n+        words = word_re.findall(lower)\\n+        if len(words) < 90:\\n+            continue\\n+        digest = hashlib.blake2b(\\n+            re.sub(r\\\"\\\\W+\\\", \\\" \\\", lower[:4_000]).encode(), digest_size=8\\n+        ).digest()\\n+        if digest in seen:\\n+            continue\\n+        seen.add(digest)\\n+\\n+        # Moore-Lewis style contrast plus conservative web-quality penalties.\\n+        q = float(target_ce[i] - .75 * (generic_ce[i] - 6.0))\\n+        q += max(0, .66 - alpha) * 2.0\\n+        q += max(0, head.count(\\\"\\\\n\\\") * 45 / len(head) - 1) * .18\\n+        q += min(.8, sum(lower.count(term) for term in bad_terms) * .10)\\n+        q += max(0, sum(c.isdigit() for c in head) / len(head) - .06) * 4\\n+        q += max(0, .28 - len(set(words)) / len(words)) * 2\\n+        if i >= 114_000:\\n+            q += .08\\n+        if size < 1_000:\\n+            q += .10\\n+        q -= min(.35, max(0, float(confidence[i])) * .04)\\n+        queues[int(labels[i])].append((q, i))\\n+    for queue in queues:\\n+        queue.sort()\\n+\\n+    # Estimated GPT-2 token mass, with a correction for code-heavy Q&A.\\n+    pos = [0] * 4\\n+    load = [0.0] * 4\\n+    output = []\\n+    while True:\\n+        available = [d for d in range(4) if pos[d] < len(queues[d])]\\n+        if not available:\\n+            break\\n+        domain = min(available, key=lambda d: load[d])\\n+        _, doc_id = queues[domain][pos[domain]]\\n+        pos[domain] += 1\\n+        output.append(doc_id)\\n+        load[domain] += len(texts[doc_id]) / (3.25 if domain == 3 else 4.05)\\n+    return output\\n+\\n+\\n+def main():\\n+    texts = load_pool()\\n+    tok = GPT2TokenizerFast.from_pretrained(\\\"gpt2\\\", local_files_only=True)\\n+    dev_np = np.load(DEV)\\n+    dev = torch.from_numpy(dev_np.astype(np.int64))\\n+\\n+    target_model = train_reference(dev, 256, 48, 1800, 2026)\\n+    target_ce = score_documents(target_model, texts, tok, 256, 128)\\n+    del target_model\\n+    torch.cuda.empty_cache()\\n+\\n+    generic = pack_random_reference(texts, tok)\\n+    generic_model = train_reference(generic, 128, 64, 1400, 2027)\\n+    generic_ce = score_documents(generic_model, texts, tok, 128, 256)\\n+    del generic_model, generic\\n+    torch.cuda.empty_cache()\\n+\\n+    labels, confidence = infer_registers(texts, dev_np, tok)\\n+    selection = rank_and_balance(texts, target_ce, generic_ce,\\n+                                 labels, confidence)\\n+    OUT.parent.mkdir(parents=True, exist_ok=True)\\n+    OUT.write_text(json.dumps(selection))\\n+    print(f\\\"wrote {len(selection)} unique ranked ids to {OUT}\\\")\\n+\\n+\\n+if __name__ == \\\"__main__\\\":\\n+    main()\\n*** End Patch\";\nconst a = await tools.apply_patch(patch); text(a);\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:94263,chars:\"\",yield_time_ms:1000,max_output_tokens:5000}); text(r);\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:94263,chars:\"\",yield_time_ms:30000,max_output_tokens:5000}); text(r);\n"
}

{
  "cell_id": "121",
  "yield_time_ms": 30000,
  "max_tokens": 5000
}

{
  "input": "const r = await tools.exec_command({cmd:\"python work/pack_fast.py data/pool.jsonl work/neural_equal.json work/contrast75.npy && PYTHONPATH=. python work/train_diag.py --train_npy work/contrast75.npy --out_json work/contrast75_result.json\",workdir:\"/workspace\",yield_time_ms:1000,max_output_tokens:10000}); text(r);\n"
}

{
  "input": "const patch = \"*** Begin Patch\\n*** Add File: /workspace/claim.md\\n+# Hypothesis\\n+\\n+For a 12M-token budget, documents that are substantially more predictable under a reference LM fitted to the disclosed four-register target than under a reference LM fitted to random raw web will train a better small LM than either random web or quality filtering alone. The selected prefix should also carry roughly equal estimated token mass from encyclopedic, polished-web, news, and technical-Q&A registers.\\n+\\n+# Mechanism\\n+\\n+The contrastive cross-entropy score rewards target-like syntax, vocabulary, and formatting while discounting text that is merely easy because it is repetitive or generic. Explicit register interleaving prevents the high-volume general-web class from crowding out news and technical text. Boilerplate, repetition, non-English, and near-duplicate filters spend the limited updates on transferable language rather than page furniture.\\n+\\n+An observable prediction independent of final perplexity is that the selected 12M-token prefix has lower target-reference cross-entropy minus generic-reference cross-entropy than a random prefix, lower navigation/boilerplate incidence, and approximately balanced inferred register token mass. Its training loss on news and technical-Q&A minibatches should fall faster than random web during the first third of training.\\n+\\n+# Falsification\\n+\\n+Hold the four register quotas and document-length distribution fixed, then randomly permute documents between the selected and rejected sets within each register. If those matched random sets do not have worse target-reference contrast, boilerplate rate, and early register-specific learning curves, the affinity/quality ranking mechanism is false. If removing the explicit interleaving does not measurably reduce the least-represented register's token share or degrade its learning curve, the coverage mechanism is false.\\n+\\n+# Transfer\\n+\\n+The method transfers to another disclosed broad target by fitting its reference LM and register model, without source labels or hand-picked IDs. The particular ranking should transfer to disjoint high-quality English samples with a similar four-way mixture, but not necessarily to code-only, conversational, multilingual, or differently weighted targets; those require refitting the references and quotas.\\n*** End Patch\";\nconst a = await tools.apply_patch(patch); text(a);\n"
}

{
  "input": "const r = await tools.exec_command({cmd:\"python -m py_compile submission/curate.py && chmod +x submission/curate.py && git diff --no-index /dev/null submission/curate.py | head -40 || true && cat .timer/remaining_secs\",workdir:\"/workspace\",yield_time_ms:10000,max_output_tokens:5000}); text(r);\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:14373,chars:\"\",yield_time_ms:30000,max_output_tokens:10000}); text(r);\n"
}

{
  "cell_id": "125",
  "yield_time_ms": 30000,
  "max_tokens": 10000
}

{
  "input": "const r = await tools.write_stdin({session_id:14373,chars:\"\",yield_time_ms:30000,max_output_tokens:10000}); text(r);\n"
}

{
  "cell_id": "126",
  "yield_time_ms": 30000,
  "max_tokens": 10000
}

{
  "input": "const r = await tools.exec_command({cmd:\"cp work/neural_equal.json submission/selection.json\\npython - <<'PY'\\nimport json\\np='submission/selection.json'; x=json.load(open(p))\\nassert isinstance(x,list) and len(x)==len(set(x))\\nassert all(type(i) is int and 0<=i<182016 for i in x)\\nprint('ids',len(x),'unique',len(set(x)),'range',min(x),max(x),'first10',x[:10])\\nPY\\npython pack_selection.py submission/selection.json work/final_official_pack.npy\\ncmp work/final_official_pack.npy work/contrast75.npy && echo PACKS_IDENTICAL\\nsha256sum submission/selection.json submission/curate.py claim.md work/final_official_pack.npy\",workdir:\"/workspace\",yield_time_ms:1000,max_output_tokens:5000}); text(r);\n"
}

{
  "input": "const r = await tools.write_stdin({session_id:63346,chars:\"\",yield_time_ms:30000,max_output_tokens:5000}); text(r);\n"
}

{
  "cell_id": "128",
  "yield_time_ms": 30000,
  "max_tokens": 5000
}