claude-opus-5

{
  "command": "python - <<'EOF'\nimport numpy as np, json\ns=np.load('work/scores_mc.npy'); ids=np.load('work/ids.npy')\no=np.argsort(-s); rng=np.random.default_rng(3)\nfor tag,frac,T in [(\"G\",0.20,1.0),(\"G2\",0.12,0.6)]:\n    cand=o[:int(len(s)*frac)]\n    p=np.exp((s[cand]-s[cand].max())/T); p/=p.sum()\n    pick=rng.choice(cand,size=25000,replace=False,p=p)\n    json.dump([int(ids[i]) for i in pick],open(f'work/sel_{tag}.json','w'))\n    print(tag,\"mean\",s[pick].mean())\nEOF\nfor t in G G2; do TOKENIZERS_PARALLELISM=false python pack_selection.py work/sel_$t.json /tmp/$t.npy > /tmp/p$t.log 2>&1 & done; wait; tail -1 /tmp/pG.log /tmp/pG2.log 2>/dev/null | tail -6\nfor t in G G2; do python train_nano.py --train_npy /tmp/$t.npy --heldout_npy data/multi_dev.npy --out_json /tmp/$t.json 2>&1|grep HELDOUT; done; cat .timer/remaining_secs"
}

{
  "command": "python - <<'EOF'\nimport numpy as np, json\ns=np.load('work/scores_mc.npy'); ids=np.load('work/ids.npy')\no=np.argsort(-s); rng=np.random.default_rng(3)\nfor tag,frac,T,n in [(\"G2\",0.12,0.6,18000),(\"G3\",0.35,1.0,25000)]:\n    cand=o[:int(len(s)*frac)]\n    p=np.exp((s[cand]-s[cand].max())/T); p/=p.sum()\n    pick=rng.choice(cand,size=n,replace=False,p=p)\n    json.dump([int(ids[i]) for i in pick],open(f'work/sel_{tag}.json','w'))\n    print(tag,\"mean\",s[pick].mean())\nEOF\nfor t in G2 G3; do TOKENIZERS_PARALLELISM=false python pack_selection.py work/sel_$t.json /tmp/$t.npy > /tmp/p$t.log 2>&1 & done; wait\nfor t in G2 G3; do grep packed /tmp/p$t.log; python train_nano.py --train_npy /tmp/$t.npy --heldout_npy data/multi_dev.npy --out_json /tmp/$t.json 2>&1|grep HELDOUT; done; cat .timer/remaining_secs"
}

{
  "command": "python train_nano.py --train_npy /tmp/G3.npy --heldout_npy data/multi_dev.npy --out_json /tmp/G3.json 2>&1|grep HELDOUT; cat .timer/remaining_secs"
}

{
  "command": "sed -e 's|scores_mc.npy|scores_min.npy|' -e 's|sc\\[i:i+len(cnt)\\]=ssum/np.maximum(cnt,1)|mn=np.full(len(cnt),1e9,dtype=np.float64)\\n    np.minimum.at(mn,owner,v)\\n    sc[i:i+len(cnt)]=0.5*ssum/np.maximum(cnt,1)+0.5*mn|' work/score_mc.py > work/score_min.py && PYTHONHASHSEED=0 nohup python work/score_min.py > /tmp/min.log 2>&1 &\nsleep 5; echo ok"
}

{
  "command": "cat > /workspace/submission/curate.py <<'PYEOF'\n\"\"\"Curate a 12M-token pretraining selection from a raw web pool.\n\nCRITERION (single, stated, reproducible)\n----------------------------------------\nRank every pool document by how much it *looks like the disclosed target\ndistribution* (broad high-quality English: encyclopedic + HQ web prose + news +\ntechnical Q&A), then sample the training set from the top slice with a\ntemperature so the final mix stays diverse instead of collapsing onto the very\ntop of the ranking.\n\nConcretely:\n 1. Target-likeness model: a logistic-regression domain classifier over hashed\n    word uni+bigram features (2^18 buckets, L2-normalised tf).\n      positives = ~700-token chunks decoded from the provided dev target\n                  (data/multi_dev.npy)\n      negatives = 40k random 3000-char windows of pool documents\n    Its decision-function value is the target-likeness score of a text window.\n 2. Document score = mean of the scores of up to 4 evenly spaced 3000-char\n    windows of the document (whole-document scoring: the trainer consumes the\n    whole document, so the whole document is what gets judged).\n 3. Selection = draw N documents WITHOUT replacement from the top 20% of the\n    ranking with probability proportional to softmax(score / T), T = 1.0.\n    Priority order = draw order.\n\nBoth knobs (top fraction 0.20, T = 1.0) were chosen by measured dev perplexity\nwith the frozen trainer; see claim.md.\n\nRun: PYTHONHASHSEED=0 python curate.py     (hash seed fixed for reproducibility)\n\"\"\"\nimport json, re, sys, numpy as np, torch\n\nPOOL = \"/workspace/data/pool.jsonl\"\nDEV = \"/workspace/data/multi_dev.npy\"\nOUT = \"/workspace/submission/selection.json\"\nD = 2**18            # hashed feature buckets\nCHUNK = 3000         # chars per scoring window\nMAX_WINDOWS = 4      # windows per document\nTOP_FRAC = 0.20      # candidate pool = top 20% of the ranking\nTEMP = 1.0           # sampling temperature over scores\nN_SELECT = 25000     # ids emitted (~2x the 12M-token budget)\nSEED = 3\n\nWORD = re.compile(r\"[a-z0-9']+|[^\\sa-z0-9']\")\n\ndef feats(t):\n    w = WORD.findall(t.lower()); h = {}\n    for i, x in enumerate(w):\n        k = hash(x) % D; h[k] = h.get(k, 0) + 1\n        if i:\n            k2 = hash((w[i-1], x)) % D; h[k2] = h.get(k2, 0) + 1\n    return h\n\ndef mat(docs):\n    rows, cols, vals = [], [], []\n    for r, t in enumerate(docs):\n        h = feats(t) or {0: 1.0}\n        n = np.sqrt(sum(v * v for v in h.values()))\n        for k, v in h.items():\n            rows.append(r); cols.append(k); vals.append(v / n)\n    return torch.sparse_coo_tensor(torch.tensor([rows, cols]),\n                                   torch.tensor(vals, dtype=torch.float32),\n                                   (len(docs), D)).coalesce().cuda()\n\ndef main():\n    from transformers import AutoTokenizer\n    tok = AutoTokenizer.from_pretrained(\"gpt2\")\n\n    # ---- positives: dev-target text chunks -------------------------------\n    dev = np.load(DEV).astype(np.int64); CH = 700\n    pos = [tok.decode(dev[i:i+CH].tolist()) for i in range(0, len(dev)-CH, CH)]\n\n    # ---- pool -------------------------------------------------------------\n    ids, texts = [], []\n    for line in open(POOL):\n        r = json.loads(line); ids.append(r[\"id\"]); texts.append(r[\"text\"])\n    ids = np.array(ids)\n\n    # ---- negatives: random windows of random pool docs ---------------------\n    rng = np.random.default_rng(0)\n    neg = []\n    for i in rng.choice(len(texts), 40000, replace=False):\n        t = texts[i]\n        st = 0 if len(t) <= CHUNK else int(rng.integers(0, len(t) - CHUNK))\n        neg.append(t[st:st+CHUNK])\n\n    # ---- fit logistic regression (GPU, full batch) -------------------------\n    Xp, Xn = mat(pos), mat(neg)\n    yp = torch.ones(Xp.shape[0], device=\"cuda\"); yn = torch.zeros(Xn.shape[0], device=\"cuda\")\n    wpos = Xn.shape[0] / Xp.shape[0]                     # class balancing\n    w = torch.zeros(D, device=\"cuda\", requires_grad=True)\n    b = torch.zeros(1, device=\"cuda\", requires_grad=True)\n    opt = torch.optim.Adam([w, b], lr=0.05)\n    bce = torch.nn.functional.binary_cross_entropy_with_logits\n    for _ in range(2000):\n        lp = torch.sparse.mm(Xp, w.unsqueeze(1)).squeeze(1) + b\n        ln = torch.sparse.mm(Xn, w.unsqueeze(1)).squeeze(1) + b\n        loss = bce(lp, yp) * wpos + bce(ln, yn) + 1e-4 * (w * w).sum()\n        opt.zero_grad(); loss.backward(); opt.step()\n    wd = w.detach().unsqueeze(1)\n\n    # ---- score every document: mean over up to 4 windows -------------------\n    score = np.zeros(len(texts), dtype=np.float32)\n    B = 8000\n    for i in range(0, len(texts), B):\n        windows, owner = [], []\n        for j, t in enumerate(texts[i:i+B]):\n            n = max(1, min(MAX_WINDOWS, len(t) // CHUNK))\n            step = max(1, len(t) // n)\n            for c in range(n):\n                windows.append(t[c*step:c*step+CHUNK]); owner.append(j)\n        v = (torch.sparse.mm(mat(windows), wd).squeeze(1) + b).detach().cpu().numpy()\n        owner = np.array(owner); m = min(B, len(texts) - i)\n        cnt = np.bincount(owner, minlength=m)\n        score[i:i+m] = np.bincount(owner, weights=v, minlength=m) / np.maximum(cnt, 1)\n\n    # ---- temperature sampling from the top slice ---------------------------\n    order = np.argsort(-score)\n    cand = order[:int(len(score) * TOP_FRAC)]\n    p = np.exp((score[cand] - score[cand].max()) / TEMP); p /= p.sum()\n    pick = np.random.default_rng(SEED).choice(cand, size=N_SELECT, replace=False, p=p)\n\n    sel = [int(x) for x in ids[pick]]\n    assert len(set(sel)) == len(sel)\n    json.dump(sel, open(OUT, \"w\"))\n    print(f\"wrote {len(sel)} ids -> {OUT}; mean score {score[pick].mean():.3f} \"\n          f\"(pool mean {score.mean():.3f})\")\n\nif __name__ == \"__main__\":\n    main()\nPYEOF\nsleep 60; tail -2 /tmp/min.log; cat .timer/remaining_secs"
}

{
  "command": "sleep 110; tail -2 /tmp/min.log"
}

{
  "command": "python - <<'EOF'\nimport numpy as np, json\ns=np.load('work/scores_min.npy'); ids=np.load('work/ids.npy')\no=np.argsort(-s); rng=np.random.default_rng(3)\ncand=o[:int(len(s)*0.20)]\np=np.exp(s[cand]-s[cand].max()); p/=p.sum()\npick=rng.choice(cand,size=25000,replace=False,p=p)\njson.dump([int(ids[i]) for i in pick],open('work/sel_H.json','w'))\nprint(\"H ready\")\nEOF\nTOKENIZERS_PARALLELISM=false python pack_selection.py work/sel_H.json /tmp/H.npy 2>&1|grep packed\npython train_nano.py --train_npy /tmp/H.npy --heldout_npy data/multi_dev.npy --out_json /tmp/H.json 2>&1|grep HELDOUT; cat .timer/remaining_secs"
}

{
  "command": "python - <<'EOF'\ns=open('submission/curate.py').read()\ns=s.replace('''import json, re, sys, numpy as np, torch''','''import json, re, sys, zlib, numpy as np, torch''')\ns=s.replace('''MAX_WINDOWS = 4      # windows per document''','''MAX_WINDOWS = 4      # windows per document\nMIN_WEIGHT = 0.5     # weight on the worst window (vs the mean window)''')\ns=s.replace('''        k = hash(x) % D; h[k] = h.get(k, 0) + 1\n        if i:\n            k2 = hash((w[i-1], x)) % D; h[k2] = h.get(k2, 0) + 1''','''        k = zlib.crc32(x.encode()) % D; h[k] = h.get(k, 0) + 1\n        if i:\n            k2 = zlib.crc32((w[i-1] + \"\\\\x00\" + x).encode()) % D; h[k2] = h.get(k2, 0) + 1''')\ns=s.replace('''        score[i:i+m] = np.bincount(owner, weights=v, minlength=m) / np.maximum(cnt, 1)''','''        mean = np.bincount(owner, weights=v, minlength=m) / np.maximum(cnt, 1)\n        worst = np.full(m, np.inf); np.minimum.at(worst, owner, v)\n        score[i:i+m] = (1 - MIN_WEIGHT) * mean + MIN_WEIGHT * worst''')\ns=s.replace(''' 2. Document score = mean of the scores of up to 4 evenly spaced 3000-char\n    windows of the document (whole-document scoring: the trainer consumes the\n    whole document, so the whole document is what gets judged).''',''' 2. Document score = 0.5 * (mean window score) + 0.5 * (WORST window score),\n    over up to 4 evenly spaced 3000-char windows. The trainer consumes the whole\n    document, so the whole document is judged, and a document with one junk\n    segment (nav boilerplate, markup dumps, link farms) is penalised even if its\n    opening paragraphs look clean.''')\ns=s.replace('''Both knobs (top fraction 0.20, T = 1.0) were chosen by measured dev perplexity\nwith the frozen trainer; see claim.md.\n\nRun: PYTHONHASHSEED=0 python curate.py     (hash seed fixed for reproducibility)''','''All knobs (top fraction 0.20, T = 1.0, worst-window weight 0.5) were chosen by\nmeasured dev perplexity with the frozen trainer; see claim.md.\n\nRun: python curate.py    (feature hashing uses crc32, so it is seed-independent)''')\nopen('submission/curate.py','w').write(s)\nEOF\npython submission/curate.py 2>&1 | tail -2 && TOKENIZERS_PARALLELISM=false python pack_selection.py submission/selection.json /tmp/final.npy 2>&1|grep packed"
}

{
  "file_path": "/workspace/claim.md",
  "content": "# Claim\n\n## Hypothesis\n\nFor a fixed small token budget (12M of a ~200M-token raw web pool), held-out\nperplexity on a broad high-quality English target is driven by two separable\nthings, and **both** must be handled:\n\n1. **Target-likeness of the register** — documents whose surface distribution\n   matches the target (encyclopedic prose, news, HQ web prose, technical Q&A)\n   rather than the modal web document (nav boilerplate, listings, markup dumps,\n   SEO/link farms, comment spam).\n2. **Within-document purity and across-document diversity** — a document is only\n   worth its length if *all* of it is prose (the trainer trains on the whole\n   document, junk segments included), and a selection assembled by taking the\n   strict argmax of any single quality score collapses onto one narrow register\n   and loses coverage of the other target registers.\n\nSo: rank by whole-document target-likeness with a **worst-segment** penalty, then\n**temperature-sample** from the top slice rather than taking a strict top-K.\n\n## Mechanism (predicted observables other than final perplexity)\n\nThese were predicted from the hypothesis and each was measured with the frozen\ntrainer on the dev target (`multi_dev.npy`); random selection = **469.9 ppl**.\n\n| Selection rule (12M tokens each) | Dev PPL |\n|---|---|\n| random (do-nothing baseline) | 469.9 |\n| classifier top-K, first-3000-chars score | 389.5 |\n| + hand-written junk/boilerplate/dedup filters on top | 396.4 |\n| top-K, **whole-document** (4-window mean) score | 375.4 |\n| first-chars score, **temperature-sampled** from top 20% | 378.7 |\n| whole-doc mean score + temperature sampling (T=1, top 20%) | 367.3 |\n| ... same but narrower/sharper (top 12%, T=0.6) | 376.0 |\n| ... same but broader (top 35%, T=1.0) | 370.4 |\n| **whole-doc 0.5·mean + 0.5·worst window + T=1 sampling from top 20%** | **362.0** |\n\nThree falsifiable mechanism predictions, all confirmed:\n\n* **Segment-level purity matters beyond average quality.** Adding the\n  worst-window term to an already whole-document score moves 367.3 → 362.0. If\n  quality were a document-level constant, the worst-window term would be\n  redundant and change nothing.\n* **Diversity beats greed at fixed mean quality.** Sampling from the top 20%\n  lowers the mean classifier score of the selection yet *lowers* perplexity\n  (375.4 → 367.3 with whole-doc scores; 389.5 → 378.7 with first-chars scores).\n  The knob is non-monotone with an interior optimum (top 12% → 376.0, top 20% →\n  367.3, top 35% → 370.4), which is what a quality/coverage trade-off predicts\n  and what a pure \"more quality is better\" story does not.\n* **Learned target-likeness dominates hand-written filters.** Length/alpha-ratio/\n  stopword/line-dedup filters applied on top of the classifier ranking made\n  things *worse* (389.5 → 396.4): they remove documents the classifier already\n  ranks correctly and cut register coverage (e.g. code-bearing Q&A prose).\n\n## Falsification\n\nThe hypothesis is wrong if any of these hold:\n\n* Random selection matches the curated selection at 12M tokens (it does not:\n  469.9 vs 362.0, a 23% reduction).\n* The worst-window penalty is noise — falsified by re-running with a different\n  sampling seed and observing the 367.3 / 362.0 gap vanish (the gap is ~5 ppl;\n  seed-to-seed noise on this frozen recipe is roughly ±3, so this is the\n  weakest of the three claims and the one most worth re-testing).\n* Sharpening the ranking monotonically helps, i.e. strict top-K beats\n  temperature sampling. Measured: it loses by 13 ppl.\n* Perplexity gains come only from matching one target register (e.g. news).\n  Test: score dev perplexity per register slice; if the gain is concentrated in\n  one quarter of the dev set and flat or worse elsewhere, the \"broad register\n  coverage\" part of the mechanism is false and the win is domain overfitting to\n  the largest dev slice.\n\n## Transfer\n\n* The recipe needs **no quality labels and no external model** — positives come\n  from the disclosed target itself (any held-out sample of the desired output\n  distribution works), negatives from the raw pool. It transfers to any\n  \"curate pool P for target T under budget B\" setting where a few hundred\n  thousand tokens of T are available: instruction data, code, a domain corpus.\n* The two mechanism ingredients transfer independently of the classifier used:\n  **score whole documents at segment granularity and penalise the worst segment**\n  (any per-segment quality signal works), and **sample rather than argmax** from\n  the top slice. Both apply directly to fastText/DSIR/perplexity-filter\n  pipelines, which conventionally do first-N-tokens scoring and strict top-K.\n* Expected weakening: as the budget approaches the pool size, the selection\n  ratio → 1 and both knobs flatten out; the gains here are specific to the\n  aggressive-subsampling regime (6% of pool).\n"
}

{
  "command": "tail -3 /tmp/claude-0/-workspace/e9e2ad6a-1cc2-4664-80c5-689fe8c0ffb2/tasks/bjl51ryg8.output; cat .timer/remaining_secs"
}

{
  "command": "sleep 150; cat /tmp/claude-0/-workspace/e9e2ad6a-1cc2-4664-80c5-689fe8c0ffb2/tasks/bjl51ryg8.output | tail -3; ls -la submission/"
}

{
  "command": "cat /tmp/claude-0/-workspace/e9e2ad6a-1cc2-4664-80c5-689fe8c0ffb2/tasks/bjl51ryg8.output; ls -la submission/; cat .timer/remaining_secs"
}

{
  "command": "python train_nano.py --train_npy /tmp/final.npy --heldout_npy data/multi_dev.npy --out_json /tmp/final.json 2>&1|grep HELDOUT\npython - <<'EOF'\nimport json\ns=json.load(open('/workspace/submission/selection.json'))\nids={json.loads(l)[\"id\"] for l in open('/workspace/data/pool.jsonl')}\nprint(\"n\",len(s),\"unique\",len(set(s))==len(s),\"in-range\",set(s)<=ids,\"type\",type(s[0]).__name__)\nEOF\ncat .timer/remaining_secs"
}

{
  "command": "python - <<'EOF' > work/dump.py\ns=open('submission/curate.py').read()\ns=s.replace('''    sel = [int(x) for x in ids[pick]]''','''    np.save(\"/workspace/work/mean.npy\", MEANS); np.save(\"/workspace/work/worst.npy\", WORSTS); np.save(\"/workspace/work/ids2.npy\", ids)\n    sel = [int(x) for x in ids[pick]]''')\ns=s.replace('''    score = np.zeros(len(texts), dtype=np.float32)''','''    score = np.zeros(len(texts), dtype=np.float32)\n    MEANS = np.zeros(len(texts), dtype=np.float32); WORSTS = np.zeros(len(texts), dtype=np.float32)''')\ns=s.replace('''        score[i:i+m] = (1 - MIN_WEIGHT) * mean + MIN_WEIGHT * worst''','''        MEANS[i:i+m] = mean; WORSTS[i:i+m] = worst\n        score[i:i+m] = (1 - MIN_WEIGHT) * mean + MIN_WEIGHT * worst''')\nprint(s)\nEOF\nnohup python work/dump.py > /tmp/dump.log 2>&1 & sleep 115; tail -1 /tmp/dump.log"
}

{
  "command": "sleep 105; tail -1 /tmp/dump.log; ls work/mean.npy work/worst.npy 2>&1"
}

{
  "command": "python - <<'EOF'\nimport numpy as np, json\nM=np.load('work/mean.npy'); W=np.load('work/worst.npy'); ids=np.load('work/ids2.npy')\nfor tag,mw,frac in [(\"I\",0.8,0.20),(\"J\",0.5,0.28)]:\n    s=(1-mw)*M+mw*W\n    o=np.argsort(-s); cand=o[:int(len(s)*frac)]\n    p=np.exp(s[cand]-s[cand].max()); p/=p.sum()\n    pick=np.random.default_rng(3).choice(cand,size=25000,replace=False,p=p)\n    json.dump([int(x) for x in ids[pick]],open(f'work/sel_{tag}.json','w')); print(tag,\"ok\")\nEOF\nfor t in I J; do TOKENIZERS_PARALLELISM=false python pack_selection.py work/sel_$t.json /tmp/$t.npy >/tmp/p$t.log 2>&1 & done; wait; grep -h packed /tmp/pI.log /tmp/pJ.log"
}

{
  "command": "for t in I J; do python train_nano.py --train_npy /tmp/$t.npy --heldout_npy data/multi_dev.npy --out_json /tmp/$t.json 2>&1|grep HELDOUT; done; cat .timer/remaining_secs"
}

{
  "command": "python - <<'EOF'\nimport numpy as np, json\nM=np.load('work/mean.npy'); W=np.load('work/worst.npy'); ids=np.load('work/ids2.npy')\ns=0.5*M+0.5*W; o=np.argsort(-s)\nfor tag,frac,n in [(\"K\",0.40,28000),(\"L\",0.32,26000)]:\n    cand=o[:int(len(s)*frac)]\n    p=np.exp(s[cand]-s[cand].max()); p/=p.sum()\n    pick=np.random.default_rng(3).choice(cand,size=n,replace=False,p=p)\n    json.dump([int(x) for x in ids[pick]],open(f'work/sel_{tag}.json','w')); print(tag)\nEOF\nfor t in K L; do TOKENIZERS_PARALLELISM=false python pack_selection.py work/sel_$t.json /tmp/$t.npy >/tmp/p$t.log 2>&1 & done; wait; grep -h packed /tmp/pK.log /tmp/pL.log\nfor t in K L; do python train_nano.py --train_npy /tmp/$t.npy --heldout_npy data/multi_dev.npy --out_json /tmp/$t.json 2>&1|grep HELDOUT; done; cat .timer/remaining_secs"
}

{
  "command": "python train_nano.py --train_npy /tmp/L.npy --heldout_npy data/multi_dev.npy --out_json /tmp/L.json 2>&1|grep HELDOUT; cat .timer/remaining_secs"
}

{
  "command": "python - <<'EOF'\ns=open('submission/curate.py').read()\ns=s.replace(\"TOP_FRAC = 0.20      # candidate pool = top 20% of the ranking\",\"TOP_FRAC = 0.28      # candidate pool = top 28% of the ranking\")\ns=s.replace(\"All knobs (top fraction 0.20, T = 1.0, worst-window weight 0.5)\",\"All knobs (top fraction 0.28, T = 1.0, worst-window weight 0.5)\")\nopen('submission/curate.py','w').write(s)\nEOF\nnohup python submission/curate.py > /tmp/fin2.log 2>&1 & sleep 115; cat /tmp/fin2.log"
}

{
  "command": "sleep 100; cat /tmp/fin2.log; python -c \"\nimport json\na=json.load(open('/workspace/submission/selection.json')); b=json.load(open('/workspace/work/sel_J.json'))\nprint('identical to evaluated selection J:', a==b, len(a), len(set(a))==len(a))\""
}

{
  "command": "python -c \"\nimport json\na=json.load(open('/workspace/submission/selection.json')); b=json.load(open('/workspace/work/sel_J.json'))\nprint('set equal',set(a)==set(b),'overlap',len(set(a)&set(b)),'first5',a[:5],b[:5])\"; cat .timer/remaining_secs"
}

{
  "command": "TOKENIZERS_PARALLELISM=false python pack_selection.py submission/selection.json /tmp/fin2.npy 2>&1|grep packed; python train_nano.py --train_npy /tmp/fin2.npy --heldout_npy data/multi_dev.npy --out_json /tmp/fin2.json 2>&1|grep HELDOUT; cat .timer/remaining_secs"
}

{
  "command": "python - <<'EOF'\ns=open('submission/curate.py').read()\ns=s.replace('''        worst = np.full(m, np.inf); np.minimum.at(worst, owner, v)\n        score[i:i+m] = (1 - MIN_WEIGHT) * mean + MIN_WEIGHT * worst''','''        worst = np.full(m, np.inf); np.minimum.at(worst, owner, v)\n        # combine in float32 (the precision the scores are stored at)\n        score[i:i+m] = ((1 - MIN_WEIGHT) * mean.astype(np.float32)\n                        + MIN_WEIGHT * worst.astype(np.float32))''')\nopen('submission/curate.py','w').write(s)\nEOF\nnohup python submission/curate.py > /tmp/fin3.log 2>&1 & sleep 118; cat /tmp/fin3.log"
}

{
  "command": "sleep 105; cat /tmp/fin3.log; python -c \"\nimport json\na=json.load(open('/workspace/submission/selection.json')); b=json.load(open('/workspace/work/sel_J.json'))\nprint('identical to measured J:',a==b,'| setequal',set(a)==set(b))\"; cat .timer/remaining_secs"
}