46:o1,~46:o887,2:"$Sreact.fragment" 3:"/chat-static/_next/static/immutable/chunks/344ii6lor939z.js" 4:I[695259,["$3"],"default"] 5:I[565976,["$3"],"default"] 39:"ViewportBoundary" 3a:I[407550,["$3"],"$39"] 3c:"MetadataBoundary" 3d:I[407550,["$3"],"$3c"] 3e:"$Sreact.suspense" :HL["/chat-static/_next/static/immutable/chunks/24yy6ayk7w-py.css","style"] :HL["/chat-static/_next/static/immutable/chunks/1q03q74l8cx38.css","style"] :HL["/chat-static/_next/static/immutable/chunks/3ywke3n5--xbv.css","style"] :HL["/chat-static/_next/static/immutable/chunks/0fdug_96ci9uf.css","style"] :HL["/chat-static/_next/static/immutable/chunks/3ov87t7yn984v.css","style"] 1:X 6:X 18:X 1b:X 22:X 20:[["children",{"s":"__PAGE__","h":162,"d":{"r":"$L21","p":false,"v":"$22"}}]] 1e:[["children",{"s":{"n":"id","t":"d","k":"nano-training-pipeline-2-JYNFarW33aQ","s":null},"h":98,"d":{"r":"$L1f","p":false,"v":"$6"},"c":"$Q20"}]] 2c:X 2a:[["children",{"s":"__PAGE__","h":2,"d":{"r":"$L2b","p":false,"v":"$2c"}}]] 28:[["children",{"s":{"n":"id","t":"d","k":"nano-training-pipeline-2-JYNFarW33aQ","s":null},"h":38,"d":{"r":"$L29","p":false,"v":"$6"},"c":"$Q2a"}]] 26:[["children",{"s":"chat","h":106,"d":{"r":"$L27","p":false,"v":"$6"},"c":"$Q28"}]] 24:[["children",{"s":"(chat)","h":106,"d":{"r":"$L25","p":false,"v":"$6"},"c":"$Q26"}]] 36:X 34:[["children",{"s":"__PAGE__","h":34,"d":{"r":"$L35","p":false,"v":"$36"}}]] 32:[["children",{"s":{"n":"id","t":"d","k":"nano-training-pipeline-2-JYNFarW33aQ","s":null},"h":102,"d":{"r":"$L33","p":false,"v":"$6"},"c":"$Q34"}]] 30:[["children",{"s":"chat","h":106,"d":{"r":"$L31","p":false,"v":"$6"},"c":"$Q32"}]] 2e:[["children",{"s":"(chat)","h":106,"d":{"r":"$L2f","p":false,"v":"$6"},"c":"$Q30"}]] 38:X 1c:[["children",{"s":"chat","h":98,"d":{"r":"$L1d","p":false,"v":"$6"},"c":"$Q1e"}],["content",{"s":"(__SLOT__)","h":74,"d":{"r":"$L23","p":false,"v":"$6"},"c":"$Q24"}],["header",{"s":"(__SLOT__)","h":74,"d":{"r":"$L2d","p":false,"v":"$6"},"c":"$Q2e"}],["sidebar",{"s":"__DEFAULT__","h":2,"d":{"r":"$L37","p":false,"v":"$38"}}]] 19:[["children",{"s":{"n":"scope","t":"d","k":"diwok55429-5182s-projects","s":null},"h":74,"d":{"r":"$L1a","p":false,"v":"$1b"},"c":"$Q1c"}]] 46:oc70,8:[["children",{"s":"(dynamic-root)","h":58,"d":{"r":["$","$2","c",{"children":[[["$","link","0",{"rel":"stylesheet","href":"/chat-static/_next/static/immutable/chunks/24yy6ayk7w-py.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}],["$","link","1",{"rel":"stylesheet","href":"/chat-static/_next/static/immutable/chunks/1q03q74l8cx38.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}],["$","link","2",{"rel":"stylesheet","href":"/chat-static/_next/static/immutable/chunks/3ywke3n5--xbv.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}],["$","link","3",{"rel":"stylesheet","href":"/chat-static/_next/static/immutable/chunks/0fdug_96ci9uf.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}],["$","link","4",{"rel":"stylesheet","href":"/chat-static/_next/static/immutable/chunks/3ov87t7yn984v.css","precedence":"next","crossOrigin":"$undefined","nonce":"$undefined"}],["$","script","script-0",{"src":"/chat-static/_next/static/immutable/chunks/303stc2r7f4w8.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/chat-static/_next/static/immutable/chunks/32gb-v7_cfzqx.js","async":true,"nonce":"$undefined"}],["$","script","script-2",{"src":"/chat-static/_next/static/immutable/chunks/3rneqh-vsqil3.js","async":true,"nonce":"$undefined"}],["$","script","script-3",{"src":"/chat-static/_next/static/immutable/chunks/06g-rie23iir4.js","async":true,"nonce":"$undefined"}],["$","script","script-4",{"src":"/chat-static/_next/static/immutable/chunks/1ibth-4qqbhor.js","async":true,"nonce":"$undefined"}],["$","script","script-5",{"src":"/chat-static/_next/static/immutable/chunks/39ouvcffzes09.js","async":true,"nonce":"$undefined"}],["$","script","script-6",{"src":"/chat-static/_next/static/immutable/chunks/084caquxx-2sg.js","async":true,"nonce":"$undefined"}],["$","script","script-7",{"src":"/chat-static/_next/static/immutable/chunks/3u2tatjfr-5hw.js","async":true,"nonce":"$undefined"}],["$","script","script-8",{"src":"/chat-static/_next/static/immutable/chunks/02d02djy805-w.js","async":true,"nonce":"$undefined"}],["$","script","script-9",{"src":"/chat-static/_next/static/immutable/chunks/134tsydfzev9o.js","async":true,"nonce":"$undefined"}],["$","script","script-10",{"src":"/chat-static/_next/static/immutable/chunks/277_v9eijjb0j.js","async":true,"nonce":"$undefined"}],["$","script","script-11",{"src":"/chat-static/_next/static/immutable/chunks/174vnyv1pen0w.js","async":true,"nonce":"$undefined"}],["$","script","script-12",{"src":"/chat-static/_next/static/immutable/chunks/1we1wm7k76att.js","async":true,"nonce":"$undefined"}],["$","script","script-13",{"src":"/chat-static/_next/static/immutable/chunks/2vmptnhcjirpe.js","async":true,"nonce":"$undefined"}],["$","script","script-14",{"src":"/chat-static/_next/static/immutable/chunks/44lffh5bkggou.js","async":true,"nonce":"$undefined"}],["$","script","script-15",{"src":"/chat-static/_next/static/immutable/chunks/2sm31xx94jmle.js","async":true,"nonce":"$undefined"}],"$L9","$La","$Lb","$Lc","$Ld","$Le","$Lf","$L10","$L11","$L12","$L13","$L14","$L15","$L16"],"$L17"]}],"p":false,"v":"$18"},"c":"$Q19"}]] 46:o1d7,7:[["children",{"s":{"n":"variants","t":"d","k":"v0pprvariant-0-0-en-","s":null},"h":122,"d":{"r":["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}],"p":false,"v":"$6"},"c":"$Q8"}]] 40:X 41:X 46:o71d,0:{"q":"","i":false,"S":true,"r":"$1","t":{"t":{"s":"","h":90,"d":{"r":["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[[["$","title",null,{"children":"404: This page could not be found."}],["$","div",null,{"style":{"fontFamily":"system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"","height":"100vh","textAlign":"center","display":"flex","flexDirection":"column","alignItems":"center","justifyContent":"center"},"children":["$","div",null,{"children":[["$","style",null,{"dangerouslySetInnerHTML":{"__html":"body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}"}}],["$","h1",null,{"className":"next-error-h1","style":{"display":"inline-block","margin":"0 20px 0 0","padding":"0 23px 0 0","fontSize":24,"fontWeight":500,"verticalAlign":"top","lineHeight":"49px"},"children":404}],["$","div",null,{"style":{"display":"inline-block"},"children":["$","h2",null,{"style":{"fontSize":14,"fontWeight":400,"lineHeight":"49px","margin":0},"children":"This page could not be found."}]}]]}]}]],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]]}],"p":false,"v":"$6"},"c":"$Q7"},"h":{"r":["$","$2","h",{"children":[null,["$","$L3a","cIzgra0errFnOkOzXfOi9v",{"children":"$L3b"}],["$","$L3d","cIzgra0errFnOkOzXfOi9m",{"children":[["$","div",null,{"hidden":true,"children":["$","$3e",null,{"name":"Next.Metadata","children":"$L3f"}]}],null]}]]}],"p":false,"v":"$40"}},"s":"$41","a":"$@42","w":"$@43"} 46:o1000,45:I[407550,["$3"],"OutletBoundary"] 47:"LoadingBoundaryProvider" 48:I[695259,["$3"],"$47"] 50:"/chat-static/_next/static/immutable/chunks/303stc2r7f4w8.js" 51:"/chat-static/_next/static/immutable/chunks/32gb-v7_cfzqx.js" 52:"/chat-static/_next/static/immutable/chunks/3rneqh-vsqil3.js" 53:"/chat-static/_next/static/immutable/chunks/06g-rie23iir4.js" 54:"/chat-static/_next/static/immutable/chunks/1ibth-4qqbhor.js" 55:"/chat-static/_next/static/immutable/chunks/39ouvcffzes09.js" 56:"/chat-static/_next/static/immutable/chunks/084caquxx-2sg.js" 57:"/chat-static/_next/static/immutable/chunks/3u2tatjfr-5hw.js" 58:"/chat-static/_next/static/immutable/chunks/02d02djy805-w.js" 59:"/chat-static/_next/static/immutable/chunks/134tsydfzev9o.js" 5a:"/chat-static/_next/static/immutable/chunks/277_v9eijjb0j.js" 5b:"/chat-static/_next/static/immutable/chunks/174vnyv1pen0w.js" 5c:"/chat-static/_next/static/immutable/chunks/1we1wm7k76att.js" 5d:"/chat-static/_next/static/immutable/chunks/2vmptnhcjirpe.js" 5e:"/chat-static/_next/static/immutable/chunks/44lffh5bkggou.js" 5f:"/chat-static/_next/static/immutable/chunks/2sm31xx94jmle.js" 60:"/chat-static/_next/static/immutable/chunks/1lqvnbi2s4tj8.js" 61:"/chat-static/_next/static/immutable/chunks/1y1gg-uv-yg37.js" 62:"/chat-static/_next/static/immutable/chunks/3x5h73pts3lzv.js" 63:"/chat-static/_next/static/immutable/chunks/3e2myqnbydjbc.js" 64:"/chat-static/_next/static/immutable/chunks/0v2tlffizqn1u.js" 65:"/chat-static/_next/static/immutable/chunks/2r81a_es1d5td.js" 66:"/chat-static/_next/static/immutable/chunks/1-royq331wc9f.js" 67:"/chat-static/_next/static/immutable/chunks/32v8z27lzdcpc.js" 68:"/chat-static/_next/static/immutable/chunks/01a9_kdk7wvw6.js" 69:"/chat-static/_next/static/immutable/chunks/3gd76rgcgdfvq.js" 6a:"/chat-static/_next/static/immutable/chunks/2wdn3k_g5gncz.js" 6b:"/chat-static/_next/static/immutable/chunks/00ig7kf-1m7tf.js" 6c:"/chat-static/_next/static/immutable/chunks/2x96j17jpmoel.js" 6d:"/chat-static/_next/static/immutable/chunks/2v7_hc5p3w7qm.js" 6e:"/chat-static/_next/static/immutable/chunks/3gixvwt4zt3ff.js" 6f:"/chat-static/_next/static/immutable/chunks/1lje4567xmwde.js" 70:"/chat-static/_next/static/immutable/chunks/149qzst6zqok-.js" 71:"/chat-static/_next/static/immutable/chunks/1u-0w0tk-ga1n.js" 72:"/chat-static/_next/static/immutable/chunks/1h6_1262jslgg.js" 73:"/chat-static/_next/static/immutable/chunks/0iwgr5y80knyy.js" 74:"/chat-static/_next/static/immutable/chunks/0ls8-j_xjbmtb.js" 75:"/chat-static/_next/static/immutable/chunks/29hmppse7nd8c.js" 76:"/chat-static/_next/static/immutable/chunks/07bo94u1q75p2.js" 77:"/chat-static/_next/static/immutable/chunks/1hte80jv16_y1.js" 78:"/chat-static/_next/static/immutable/chunks/2kar_1p0ee5k-.js" 79:"/chat-static/_next/static/immutable/chunks/01ab9pqopejh4.js" 7a:"/chat-static/_next/static/immutable/chunks/3b9s0cgriiw-2.js" 7b:"/chat-static/_next/static/immutable/chunks/19nmjpy21roro.js" 7c:"/chat-static/_next/static/immutable/chunks/07mcg9948v_cm.js" 7d:"/chat-static/_next/static/immutable/chunks/16-61dr-81lq8.js" 7e:I[822201,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7a","$7b","$7c","$7d"],"default"] 7f:"/chat-static/_next/static/immutable/chunks/29dd5hs7mdgox.js" 80:"/chat-static/_next/static/immutable/chunks/3zpfl0trft0ca.js" 81:"/chat-static/_next/static/immutable/chunks/2hwgp13tbr4-f.js" 82:"/chat-static/_next/static/immutable/chunks/2f8ngs9posz7n.js" 83:"/chat-static/_next/static/immutable/chunks/0mu2v8yc6ph3u.js" 84:"/chat-static/_next/static/immutable/chunks/31e570r7-sp_j.js" 85:"/chat-static/_next/static/immutable/chunks/13yy268fksgp6.js" 86:"/chat-static/_next/static/immutable/chunks/0_3v9xlcug6os.js" 87:"/chat-static/_next/static/immutable/chunks/1xaqt9_cvhvsi.js" 88:"/chat-static/_next/static/immutable/chunks/2lka5ilnj45pw.js" 89:"/chat-static/_next/static/immutable/chunks/2vb643fwl1hx6.js46:o919," 8a:"/chat-static/_next/static/immutable/chunks/2-fqqwct5uu8q.js" 8b:"GitChatHeaderSkeleton" 8c:I[70040,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$8b"] 6:C 9:["$","script","script-16",{"src":"/chat-static/_next/static/immutable/chunks/1lqvnbi2s4tj8.js","async":true,"nonce":"$undefined"}] a:["$","script","script-17",{"src":"/chat-static/_next/static/immutable/chunks/1y1gg-uv-yg37.js","async":true,"nonce":"$undefined"}] b:["$","script","script-18",{"src":"/chat-static/_next/static/immutable/chunks/3x5h73pts3lzv.js","async":true,"nonce":"$undefined"}] c:["$","script","script-19",{"src":"/chat-static/_next/static/immutable/chunks/3e2myqnbydjbc.js","async":true,"nonce":"$undefined"}] d:["$","script","script-20",{"src":"/chat-static/_next/static/immutable/chunks/0v2tlffizqn1u.js","async":true,"nonce":"$undefined"}] e:["$","script","script-21",{"src":"/chat-static/_next/static/immutable/chunks/2r81a_es1d5td.js","async":true,"nonce":"$undefined"}] f:["$","script","script-22",{"src":"/chat-static/_next/static/immutable/chunks/1-royq331wc9f.js","async":true,"nonce":"$undefined"}] 10:["$","script","script-23",{"src":"/chat-static/_next/static/immutable/chunks/32v8z27lzdcpc.js","async":true,"nonce":"$undefined"}] 11:["$","script","script-24",{"src":"/chat-static/_next/static/immutable/chunks/01a9_kdk7wvw6.js","async":true,"nonce":"$undefined"}] 12:["$","script","script-25",{"src":"/chat-static/_next/static/immutable/chunks/3gd76rgcgdfvq.js","async":true,"nonce":"$undefined"}] 13:["$","script","script-26",{"src":"/chat-static/_next/static/immutable/chunks/2wdn3k_g5gncz.js","async":true,"nonce":"$undefined"}] 14:["$","script","script-27",{"src":"/chat-static/_next/static/immutable/chunks/00ig7kf-1m7tf.js","async":true,"nonce":"$undefined"}] 15:["$","script","script-28",{"src":"/chat-static/_next/static/immutable/chunks/2x96j17jpmoel.js","async":true,"nonce":"$undefined"}] 16:["$","script","script-29",{"src":"/chat-static/_next/static/immutable/chunks/2v7_hc5p3w7qm.js","async":true,"nonce":"$undefined"}] 46:o644,1a:["$","$2","c",{"children":[[["$","script","script-0",{"src":"/chat-static/_next/static/immutable/chunks/3gixvwt4zt3ff.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/chat-static/_next/static/immutable/chunks/1lje4567xmwde.js","async":true,"nonce":"$undefined"}],["$","script","script-2",{"src":"/chat-static/_next/static/immutable/chunks/149qzst6zqok-.js","async":true,"nonce":"$undefined"}],["$","script","script-3",{"src":"/chat-static/_next/static/immutable/chunks/1u-0w0tk-ga1n.js","async":true,"nonce":"$undefined"}],["$","script","script-4",{"src":"/chat-static/_next/static/immutable/chunks/1h6_1262jslgg.js","async":true,"nonce":"$undefined"}],["$","script","script-5",{"src":"/chat-static/_next/static/immutable/chunks/0iwgr5y80knyy.js","async":true,"nonce":"$undefined"}],["$","script","script-6",{"src":"/chat-static/_next/static/immutable/chunks/0ls8-j_xjbmtb.js","async":true,"nonce":"$undefined"}],["$","script","script-7",{"src":"/chat-static/_next/static/immutable/chunks/29hmppse7nd8c.js","async":true,"nonce":"$undefined"}],["$","script","script-8",{"src":"/chat-static/_next/static/immutable/chunks/07bo94u1q75p2.js","async":true,"nonce":"$undefined"}],["$","script","script-9",{"src":"/chat-static/_next/static/immutable/chunks/1hte80jv16_y1.js","async":true,"nonce":"$undefined"}],["$","script","script-10",{"src":"/chat-static/_next/static/immutable/chunks/2kar_1p0ee5k-.js","async":true,"nonce":"$undefined"}],["$","script","script-11",{"src":"/chat-static/_next/static/immutable/chunks/01ab9pqopejh4.js","async":true,"nonce":"$undefined"}]],"$L44"]}] 46:o29a,1d:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 1f:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 46:o7a9,21:["$","$2","c",{"children":[null,[["$","script","script-0",{"src":"/chat-static/_next/static/immutable/chunks/3e5ql_2u3u8jr.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/chat-static/_next/static/immutable/chunks/31e570r7-sp_j.js","async":true,"nonce":"$undefined"}],["$","script","script-2",{"src":"/chat-static/_next/static/immutable/chunks/29dd5hs7mdgox.js","async":true,"nonce":"$undefined"}],["$","script","script-3",{"src":"/chat-static/_next/static/immutable/chunks/2lka5ilnj45pw.js","async":true,"nonce":"$undefined"}],["$","script","script-4",{"src":"/chat-static/_next/static/immutable/chunks/3zpfl0trft0ca.js","async":true,"nonce":"$undefined"}],["$","script","script-5",{"src":"/chat-static/_next/static/immutable/chunks/16-61dr-81lq8.js","async":true,"nonce":"$undefined"}],["$","script","script-6",{"src":"/chat-static/_next/static/immutable/chunks/0mu2v8yc6ph3u.js","async":true,"nonce":"$undefined"}],["$","script","script-7",{"src":"/chat-static/_next/static/immutable/chunks/1xaqt9_cvhvsi.js","async":true,"nonce":"$undefined"}],["$","script","script-8",{"src":"/chat-static/_next/static/immutable/chunks/2vb643fwl1hx6.js","async":true,"nonce":"$undefined"}],["$","script","script-9",{"src":"/chat-static/_next/static/immutable/chunks/0_3v9xlcug6os.js","async":true,"nonce":"$undefined"}],["$","script","script-10",{"src":"/chat-static/_next/static/immutable/chunks/19nmjpy21roro.js","async":true,"nonce":"$undefined"}],["$","script","script-11",{"src":"/chat-static/_next/static/immutable/chunks/2f8ngs9posz7n.js","async":true,"nonce":"$undefined"}],["$","script","script-12",{"src":"/chat-static/_next/static/immutable/chunks/2-fqqwct5uu8q.js","async":true,"nonce":"$undefined"}],["$","script","script-13",{"src":"/chat-static/_next/static/immutable/chunks/13yy268fksgp6.js","async":true,"nonce":"$undefined"}]],["$","$L45",null,{"children":["$","$3e",null,{"name":"Next.MetadataOutlet","children":"$@46"}]}]]}] 46:o3e7,23:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 25:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 27:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 46:o1103,29:["$","$L48",null,{"loading":[["$","$2","l",{"children":[["$","span",null,{"role":"status","aria-live":"polite","className":"sr-only","children":"Loading chat…"}],["$","div",null,{"data-chat-skeleton-layout":true,"aria-hidden":"true","className":"flex-1 w-full flex","children":[["$","div",null,{"data-input":true,"className":"flex","children":["$","div",null,{"data-skeleton-chat-column":true,"className":"flex flex-col size-full pt-4 px-2 pb-2","children":[["$","div",null,{"className":"flex-1 overflow-hidden mask-[linear-gradient(to_bottom,black_0%,transparent_100%)]","children":["$","div",null,{"className":"max-w-3xl mx-auto w-full flex-col pt-2","children":[["$","div",null,{"className":"@container/message group w-full [&_code]:break-all wrap-break-word flex flex-col gap-2 origin-right items-end px-2","data-testid":"skeleton-message","children":[["$","div",null,{"className":"flex items-center gap-1.5 pr-1","children":["$","div",null,{"className":"size-4 rounded-full bg-v0-gray-300"}]}],["$","div",null,{"className":"flex items-end sm:max-w-[min(fit-content,80%)] max-w-[90%] origin-top-right","children":["$","div",null,{"className":"border border-v0-gray-200 text-left relative rounded-[16px] bg-v0-gray-200 px-3 py-1.5 min-w-0 wrap-break-word group/message-bubble","children":["$","div",null,{"style":{"width":900,"height":120}}]}]}],["$","div",null,{"className":"flex items-center gap-1 justify-end flex-row-reverse mr-[-2px] h-6"}]]}],["$","div",null,{"className":"flex flex-col w-full gap-4 px-2","children":[["$","div",null,{"className":"h-6 w-full flex flex-row gap-2","children":[["$","div",null,{"className":"bg-v0-gray-300 min-w-4 h-4 rounded-full"}],["$","div",null,{"className":"bg-v0-gray-300 h-4 rounded-md w-[70%] max-w-[200px]"}]]}],["$","div",null,{"className":"gap-1 flex flex-col w-full relative","children":[["$","div","0",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"100%"}}],["$","div","1",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"100%"}}],["$","div","2",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"100%"}}],["$","div","3",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"100%"}}],["$","div","4",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"40%"}}]]}],["$","div",null,{"className":"h-6 w-full flex flex-row gap-2","children":[["$","div",null,{"className":"bg-v0-gray-300 min-w-4 h-4 rounded-full"}],["$","div",null,{"className":"bg-v0-gray-300 h-4 rounded-md w-[70%] max-w-[200px]"}]]}],["$","div",null,{"className":"gap-1 flex flex-col w-full relative","children":[["$","div","0",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"100%"}}],["$","div","1",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"100%"}}],["$","div","2",{"className":"bg-v0-gray-300 h-4 rounded-md","style":{"width":"40%"}}]]}],["$","div",null,{"className":"h-6 w-full flex flex-row gap-2","children":[["$","div",null,{"className":"bg-v0-gray-300 min-w-4 h-4 rounded-full"}],["$","div",null,{"className":"bg-v0-gray-300 h-4 rounded-md w-[70%] max-w-[200px]"}]]}]]}],["$","div",null,{"className":"@container/message group w-full [&_code]:break-all wrap-break-word flex flex-col gap-2 origin-right items-end px-2","data-testid":"skeleton-message","children":[["$","div",null,{"className":"flex items-center gap-1.5 pr-1","children":["$","div",null,{"className":"size-4 rounded-full bg-v0-gray-300"}]}],["$","div",null,{"className":"flex items-end sm:max-w-[min(fit-content,80%)] max-w-[90%] origin-top-right","children":["$","div",null,{"className":"border border-v0-gray-200 text-left relative rounded-[16px] bg-v0-gray-200 px-3 py-1.5 min-w-0 wrap-break-word group/message-bubble","children":["$","div",null,{"style":{"width":900,"height":120}}]}]}],["$","div",null,{"className":"flex items-center gap-1 justify-end flex-row-reverse mr-[-2px] h-6"}]]}]]}]}],["$","div",null,{"className":"mx-auto w-full max-w-3xl","children":["$","div",null,{"className":"p-1.5 flex items-center gap-1 rounded-xl material-medium bg-v0-background-300 border border-v0-alpha-400","children":[["$","div",null,{"className":"flex size-7 shrink-0 items-center justify-center","children":["$","div",null,{"className":"animate-pulse bg-v0-gray-200 size-4 rounded"}]}],"$L49","$L4a","$L4b"]}]}]]}]}],"$L4c"]}],"$L4d"]}],[],null],"children":"$L4e"}] 46:o74f,2b:["$","$2","c",{"children":["$L4f",[["$","script","script-0",{"src":"/chat-static/_next/static/immutable/chunks/3e5ql_2u3u8jr.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/chat-static/_next/static/immutable/chunks/31e570r7-sp_j.js","async":true,"nonce":"$undefined"}],["$","script","script-2",{"src":"/chat-static/_next/static/immutable/chunks/29dd5hs7mdgox.js","async":true,"nonce":"$undefined"}],["$","script","script-3",{"src":"/chat-static/_next/static/immutable/chunks/2lka5ilnj45pw.js","async":true,"nonce":"$undefined"}],["$","script","script-4",{"src":"/chat-static/_next/static/immutable/chunks/3zpfl0trft0ca.js","async":true,"nonce":"$undefined"}],["$","script","script-5",{"src":"/chat-static/_next/static/immutable/chunks/16-61dr-81lq8.js","async":true,"nonce":"$undefined"}],["$","script","script-6",{"src":"/chat-static/_next/static/immutable/chunks/0mu2v8yc6ph3u.js","async":true,"nonce":"$undefined"}],["$","script","script-7",{"src":"/chat-static/_next/static/immutable/chunks/1xaqt9_cvhvsi.js","async":true,"nonce":"$undefined"}],["$","script","script-8",{"src":"/chat-static/_next/static/immutable/chunks/2vb643fwl1hx6.js","async":true,"nonce":"$undefined"}],["$","script","script-9",{"src":"/chat-static/_next/static/immutable/chunks/0_3v9xlcug6os.js","async":true,"nonce":"$undefined"}],["$","script","script-10",{"src":"/chat-static/_next/static/immutable/chunks/19nmjpy21roro.js","async":true,"nonce":"$undefined"}],["$","script","script-11",{"src":"/chat-static/_next/static/immutable/chunks/2f8ngs9posz7n.js","async":true,"nonce":"$undefined"}],["$","script","script-12",{"src":"/chat-static/_next/static/immutable/chunks/2-fqqwct5uu8q.js","async":true,"nonce":"$undefined"}],["$","script","script-13",{"src":"/chat-static/_next/static/immutable/chunks/13yy268fksgp6.js","async":true,"nonce":"$undefined"}]],null]}] 46:o780,2d:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 2f:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 31:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}] 33:["$","$L48",null,{"loading":[["$","$L7e","l",{}],[],[["$","script","script-0",{"src":"/chat-static/_next/static/immutable/chunks/3b9s0cgriiw-2.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/chat-static/_next/static/immutable/chunks/19nmjpy21roro.js","async":true,"nonce":"$undefined"}],["$","script","script-2",{"src":"/chat-static/_next/static/immutable/chunks/07mcg9948v_cm.js","async":true,"nonce":"$undefined"}],["$","script","script-3",{"src":"/chat-static/_next/static/immutable/chunks/16-61dr-81lq8.js","async":true,"nonce":"$undefined"}]]],"children":["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}]}] 46:o810,35:["$","$2","c",{"children":[["$","$3e",null,{"fallback":["$","$L8c",null,{}],"children":"$L8d"}],[["$","script","script-0",{"src":"/chat-static/_next/static/immutable/chunks/29dd5hs7mdgox.js","async":true,"nonce":"$undefined"}],["$","script","script-1",{"src":"/chat-static/_next/static/immutable/chunks/3zpfl0trft0ca.js","async":true,"nonce":"$undefined"}],["$","script","script-2",{"src":"/chat-static/_next/static/immutable/chunks/2hwgp13tbr4-f.js","async":true,"nonce":"$undefined"}],["$","script","script-3",{"src":"/chat-static/_next/static/immutable/chunks/2f8ngs9posz7n.js","async":true,"nonce":"$undefined"}],["$","script","script-4",{"src":"/chat-static/_next/static/immutable/chunks/19nmjpy21roro.js","async":true,"nonce":"$undefined"}],["$","script","script-5",{"src":"/chat-static/_next/static/immutable/chunks/0mu2v8yc6ph3u.js","async":true,"nonce":"$undefined"}],["$","script","script-6",{"src":"/chat-static/_next/static/immutable/chunks/31e570r7-sp_j.js","async":true,"nonce":"$undefined"}],["$","script","script-7",{"src":"/chat-static/_next/static/immutable/chunks/13yy268fksgp6.js","async":true,"nonce":"$undefined"}],["$","script","script-8",{"src":"/chat-static/_next/static/immutable/chunks/0_3v9xlcug6os.js","async":true,"nonce":"$undefined"}],["$","script","script-9",{"src":"/chat-static/_next/static/immutable/chunks/1xaqt9_cvhvsi.js","async":true,"nonce":"$undefined"}],["$","script","script-10",{"src":"/chat-static/_next/static/immutable/chunks/2lka5ilnj45pw.js","async":true,"nonce":"$undefined"}],["$","script","script-11",{"src":"/chat-static/_next/static/immutable/chunks/07mcg9948v_cm.js","async":true,"nonce":"$undefined"}],["$","script","script-12",{"src":"/chat-static/_next/static/immutable/chunks/16-61dr-81lq8.js","async":true,"nonce":"$undefined"}],["$","script","script-13",{"src":"/chat-static/_next/static/immutable/chunks/2vb643fwl1hx6.js","async":true,"nonce":"$undefined"}],["$","script","script-14",{"src":"/chat-static/_next/static/immutable/chunks/2-fqqwct5uu8q.js","async":true,"nonce":"$undefined"}]],null]}] 46:o32,37:["$","$2","c",{"children":["$L8e",null,null]}] 46:o897,90:I[987761,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"AppCard"] 91:"FULL_BLEED_APP_CARD_CLASSNAME" 92:I[987761,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$91"] 93:"/chat-static/_next/static/immutable/chunks/3unrhq1zay_f4.js" 94:"SidebarCollapseButton" 95:I[663042,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$93"],"$94"] 96:I[192842,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"ChatWarning"] 97:I[903785,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$93"],"NewChatButton"] 41:300 49:["$","div",null,{"className":"flex-1 min-w-0","children":["$","div",null,{"className":"animate-pulse bg-v0-gray-200 h-4 w-24 rounded"}]}] 4a:["$","div",null,{"className":"animate-pulse bg-v0-gray-200 h-6 w-16 rounded-md"}] 4b:["$","div",null,{"className":"animate-pulse bg-v0-gray-200 size-7 rounded-full"}] 4c:["$","div",null,{"data-output":true,"className":"bg-v0-background-200"}] 8f:T1963,46:o1963,46:o35d,4d:["$","span",null,{"data-v0-skeleton-chat-layout":"","hidden":true,"dangerouslySetInnerHTML":{"__html":"$8f"}}] 4e:["$","$2","c",{"children":[null,["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":[["$","$3e",null,{"fallback":["$","$L90",null,{"className":"$92","children":[["$","$L95",null,{"collapsedOnly":true,"syncWidth":true,"syncCollapsedMarginRight":"0px","syncExpandedMarginRight":"0px","peekOnHover":false,"className":"pointer-events-auto absolute left-3 top-3 z-20 hidden sm:flex"}],["$","$L96",null,{"description":"Loading…","title":"Chat Not Found","children":["$","$L97",null,{}]}]]}],"children":"$L98"}],[]],"forbidden":"$undefined","unauthorized":"$undefined"}]]}] 46:o17,18:T8,variants99:T18d6,46:o18d6,(({protect:a})=>{function b(a){return new Promise((b,c)=>{if(document.querySelector(`script[src="${a}"]`))return void b();let d=document.createElement("script");d.src=a,d.async=!0,d.onload=()=>b(),d.onerror=a=>{console.error("Error loading script",a),c(a)},document.head.appendChild(d)})}var c=class a{#a;#b;#c=0;constructor(){let{promise:b,resolve:c}=a.#d();this.#a=b,this.#b=c,this.#e(),window.addEventListener("online",this.#f),window.addEventListener("visibilitychange",this.#f)}getChallenge=async()=>(await this.#g(),await this.#a.then(a=>"function"==typeof a?a():a));#f=()=>{if(document.hidden)return;let{promise:b,resolve:c}=a.#d();this.#a=b,this.#b=c,window.V_C=[],window.V_C.push=c;let d=document.querySelector('script[src*="c.js"]');d&&d.remove(),this.#c+=1};#e=()=>{if(window.V_C){let a=window.V_C.pop();a&&this.#b(a)}else window.V_C=[],window.V_C.push=this.#b};#g=()=>{let a=new URL("/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/a-4-a/c.js",window.location.origin);return a.searchParams.set("i",String(this.#c)),a.searchParams.set("v",String(3)),a.searchParams.set("h",window.location.host),b(a.pathname+a.search)};#h=()=>{window.V_C=void 0};static #d(){let a,b;return{promise:new Promise((c,d)=>{a=c,b=d}),resolve:a,reject:b}}},d=class a{#a=!1;#b;constructor(a){this.#b=a}get loaded(){return this.#a}load=async()=>{this.#a||await this.#f()};#c=()=>{if(typeof globalThis.window>"u")throw Error("KPSDK is not available in the server");if(!window.KPSDK)throw Error("KPSDK is not loaded");let b=this.#b.map(b=>{let c=a.#e(b.path);return{domain:c.host,path:c.pathname,method:b.method}});try{window.KPSDK.configure(b)}catch(a){console.error("Error configuring KPSDK...",a)}};#f=async()=>{let a=this;return new Promise((c,d)=>{let e=()=>{document.removeEventListener("kpsdk-load",e),this.#c()},f=()=>{document.removeEventListener("kpsdk-ready",f),a.#a=!0,c()};document.addEventListener("kpsdk-load",e,{once:!0}),document.addEventListener("kpsdk-ready",f,{once:!0}),b("/149e9513-01fa-4fb0-aad4-566afd725d1b/2d206a39-8ed7-437e-a3be-862e0f06eea3/p.js").catch(a=>{document.removeEventListener("kpsdk-load",e),document.removeEventListener("kpsdk-ready",f),d(a)})})};static #e(a){let b;try{b=new URL(a)}catch{b=new URL(a,location.origin)}return b}},e=a=>{let b=a.replace(/[.?+^$[\]\\(){}|-]/g,"\\$&").split("*").join(".*");return RegExp(`^${b}$`)},f=({path:a,pattern:b})=>-1!==a.search(b);async function g(a,b,c){let d=XMLHttpRequest.prototype.open,g=XMLHttpRequest.prototype.send;XMLHttpRequest.prototype.open=function(a,b,c,e,f){return this._requestUrl=b.toString(),this._requestMethod=a,d.call(this,a,b,c??!0,e,f)},XMLHttpRequest.prototype.send=async function(d){let h=this._requestUrl;if(!h||this._isReexecution)return g.call(this,d);let i=new URL(h,location.href),j=c.find(a=>f({path:i.pathname,pattern:e(a.path)}));if(null==j||j.method!==(this._requestMethod??"GET")&&"*"!==j.method)return g.call(this,d);let k=await a.getChallenge();if(this.setRequestHeader("x-is-human",JSON.stringify(k)),this.setRequestHeader("x-path",i.pathname),this.setRequestHeader("x-method",this._requestMethod||"GET"),0!==k.b||b.loaded||((1===k.d||j?.advancedOptions?.checkLevel==="deepAnalysis")&&await b.load(),!b.loaded))return g.call(this,d);this.setRequestHeader("x-is-human",JSON.stringify(k)),this.setRequestHeader("x-path",i.pathname),this.setRequestHeader("x-method",this._requestMethod||"GET");let l=new XMLHttpRequest;return l._isReexecution=!0,l.open(this._requestMethod||"GET",h,!0),l.setRequestHeader("x-is-human",JSON.stringify(k)),l.setRequestHeader("x-path",i.pathname),l.setRequestHeader("x-method",this._requestMethod||"GET"),this.timeout&&(l.timeout=this.timeout),this.responseType&&(l.responseType=this.responseType),this.withCredentials&&(l.withCredentials=this.withCredentials),l.onreadystatechange=()=>{Object.defineProperty(this,"readyState",{value:l.readyState,writable:!0,configurable:!0}),l.readyState===XMLHttpRequest.DONE&&(Object.defineProperty(this,"status",{value:l.status,writable:!0,configurable:!0}),Object.defineProperty(this,"statusText",{value:l.statusText,writable:!0,configurable:!0}),Object.defineProperty(this,"response",{value:l.response,writable:!0,configurable:!0}),Object.defineProperty(this,"responseText",{value:l.responseText,writable:!0,configurable:!0}),Object.defineProperty(this,"responseXML",{value:l.responseXML,writable:!0,configurable:!0}),this.getAllResponseHeaders=()=>l.getAllResponseHeaders(),this.getResponseHeader=a=>l.getResponseHeader(a)),this.onreadystatechange&&this.onreadystatechange.call(this,new Event("readystatechange"))},l.onload=a=>{this.onload&&this.onload.call(this,a)},l.onerror=a=>{this.onerror&&this.onerror.call(this,a)},l.onabort=a=>{this.onabort&&this.onabort.call(this,a)},l.ontimeout=a=>{this.ontimeout&&this.ontimeout.call(this,a)},l.onloadstart=a=>{this.onloadstart&&this.onloadstart.call(this,a)},l.onloadend=a=>{this.onloadend&&this.onloadend.call(this,a)},l.onprogress=a=>{this.onprogress&&this.onprogress.call(this,a)},l.send(d)}}!function({protect:a=[]}){let b;for(let b of a)if(b.advancedOptions?.checkLevel!==void 0&&"deepAnalysis"!==b.advancedOptions.checkLevel&&"basic"!==b.advancedOptions.checkLevel)throw Error(`Invalid checkLevel "${b.advancedOptions.checkLevel}" for route "${b.path}". Must be one of: deepAnalysis, basic`);let h=new c,i=new d(a);g(h,i,a).catch(a=>{console.error("Error patching XMLHttpRequest:",a)}),b=window.fetch,window.fetch=async(c,d)=>{let g=new URL(c instanceof Request?c.url:c,location.href),j=g.origin===location.origin,k=a.find(a=>f({path:g.pathname,pattern:e(a.path)})),l=d?.method??(c instanceof Request?c.method:"GET"),m=null!=k&&(k.method===l||"*"===k.method);if(null==k||!m||!j)return b(c,d);let n=await h.getChallenge(),o=new Headers(d?.headers||(c instanceof Request?c.headers:void 0));o.set("x-is-human",JSON.stringify(n)),o.set("x-path",g.pathname),o.set("x-method",l);let p={...d,headers:o};return i.loaded||0!==n.b?b(c,p):1===n.d||k?.advancedOptions?.checkLevel==="deepAnalysis"?(await i.load(),window.fetch(c,p)):b(c,p)}}({protect:a})})({ protect: [{"path":"/chat/api/vm/actions/run-pipeline","method":"POST","advancedOptions":{"checkLevel":"deepAnalysis"}},{"path":"/chat/api/chat","method":"POST"},{"path":"/chat/api/vm/actions/*","method":"POST"},{"path":"*/chat/api/vm/actions/*","method":"POST"}] });46:o158,17:["$","html",null,{"lang":"en","suppressHydrationWarning":true,"children":[["$","head",null,{"children":[["$","meta",null,{"name":"ahrefs-site-verification","content":"e2ef51ac3cec223624a89ee7790eda482d23374870bff86fe0e0c599b8de4b51"}],["$","script",null,{"dangerouslySetInnerHTML":{"__html":"$99"}}],"$L9a","$L9b","$L9c","$L9d"]}],"$L9e"]}] 46:o1000,9f:"GeistThemeScript" a0:I[526065,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$9f"] a1:I[600033,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"AppStoreMetaTag"] a2:I[526065,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"GeistProvider"] a3:I[818362,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"LocaleProvider"] a4:I[841245,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"MotionConfig"] a5:"AtomicContextSWRProvider" a6:I[850359,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$a5"] a7:"GlobalPromiseContextProvider" a8:I[850359,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$a7"] ab:I[827887,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"JotaiProvider"] ac:"ServerQuerySWRRuntimeProvider" ad:I[74757,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$ac"] af:I[815349,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"CleanupStorage"] b0:I[241214,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"Analytics"] b1:I[156707,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"SpeedInsights"] b3:"VercelianAppFlowMigrator" b4:I[23825,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$b3"] b5:I[108762,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"TrackInfo"] b6:I[578386,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"PageViewTracker"] b7:I[356301,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"AutoCapture"] 9a:["$","$La0",null,{"storageKey":"theme"}] 9b:["$","$3e",null,{"children":["$","$La1",null,{}]}] 9c:["$","meta",null,{"name":"slack-app-id","content":"A09PS08K5R8"}] 9d:["$","script",null,{"type":"application/ld+json","dangerouslySetInnerHTML":{"__html":"[{\"@context\":\"https://schema.org\",\"@type\46:o2d8,":\"Organization\",\"name\":\"Vercel\",\"url\":\"https://vercel.com\",\"logo\":\"https://assets.vercel.com/image/upload/front/favicon/vercel/favicon.ico\",\"sameAs\":[\"https://x.com/vercel\",\"https://x.com/v0\",\"https://github.com/vercel\",\"https://www.linkedin.com/company/vercel\",\"https://www.linkedin.com/company/v0dev\"]},{\"@context\":\"https://schema.org\",\"@type\":\"WebApplication\",\"name\":\"v0\",\"url\":\"https://v0.app\",\"description\":\"Your collaborative AI assistant to design, iterate, and scale full-stack applications for the web.\",\"applicationCategory\":[\"DeveloperApplication\",\"DesignApplication\"],\"operatingSystem\":\"All\",\"creator\":{\"@type\":\"Organization\",\"name\":\"Vercel\"}}]"}}] 46:o93c,9e:["$","body",null,{"className":"font-sans bg-v0-background-200 text-v0-gray-1000 antialiased mAFGZa_variable _1SOORW_variable hGs1mq_variable","children":[["$","$La2",null,{"storageKey":"theme","withScript":false,"children":["$","$La3",null,{"locale":"en","children":["$","$La4",null,{"reducedMotion":"user","children":["$","$La6",null,{"routes":{"scoped":{"scopeUserDetails":{"path":"/api/chat/scoped/user","method":"GET"},"team":{"path":"/api/chat/scoped/team","method":"GET"},"vercelProjectsFavorites":{"path":"/api/chat/scoped/vercel-projects/favorites","method":"GET"},"chats":{"path":"/api/chat/scoped/chats","method":"GET"},"paginatedChats":{"path":"/api/chat/scoped/get-paginated-chats","method":"GET"},"designSystems":{"path":"/api/chat/scoped/design-systems-with-registry/list","method":"GET"},"sidebarProjectGroups":{"path":"/api/chat/scoped/sidebar-project-groups","method":"GET"},"sidebarDrafts":{"path":"/api/v2/internal/chats/sidebar-drafts","method":"GET"}},"chat":{"attributes":{"path":"/api/chat/chat/attributes","method":"GET"},"externalMeta":{"path":"/api/chat/chat/latest-external-meta","method":"GET"},"latest":{"path":"/api/chat/chat/latest","method":"GET"},"template":{"path":"/api/chat/chat/template","method":"GET"},"messages":{"path":"/api/chat/chat/messages","method":"GET"},"messagesRange":{"path":"/api/chat/chat/messages/range","method":"GET"},"gitStatus":{"path":"/api/git/status","method":"GET"}},"library":{"chatsList":{"path":"/api/chat/library/chats/list","method":"GET"},"archivedChatsList":{"path":"/api/chat/library/chats/archived","method":"GET"},"projectsList":{"path":"/api/chat/library/projects/list","method":"GET"},"filters":{"path":"/api/chat/library/filters","method":"GET"}},"project":{},"global":{"dailyModelUsage":{"path":"/api/chat/global/daily-model-usage","method":"GET"},"freeFixWithV0Usage":{"path":"/api/chat/global/free-fix-with-v0-usage","method":"GET"}}},"children":["$","$La8",null,{"params":null,"promises":{"dailyModelUsage":"$@a9","freeFixWithV0Usage":"$@aa"},"children":[["$","$Lab",null,{"children":["$","$Lad",null,{"children":"$Lae"}]}],["$","$Laf",null,{}]]}]}]}]}]}],["$","$Lb0",null,{}],["$","$Lb1",null,{"endpoint":"https://v0sdk.com/_vercel/speed-insights/vitals"}],["$","$3e",null,{"children":"$Lb2"}],["$","$Lb4",null,{}],["$","$Lb5",null,{}],["$","$Lb6",null,{}],["$","$Lb7",null,{}]]}] 46:o90,3b:[["$","meta","0",{"charSet":"utf-8"}],["$","meta","1",{"name":"viewport","content":"width=device-width, initial-scale=1, maximum-scale=1"}]] 46:oe,40:T8,variants46:o1000,b8:"HydrateDurableAtoms" b9:I[783749,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$b8"] ba:I[359783,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"DataProvider"] bb:I[32170,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"UserProvider"] bd:"AnimatedIconProvider" be:I[908887,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$bd"] bf:I[30570,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"PortalProvider"] c0:"SnowflakePublishProvider" c1:I[966820,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$c0"] c2:"UserInputProvider" c3:I[472914,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$c2"] c4:I[69221,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"CmdkProvider"] c5:"VirtualMachineUIStateProvider" c6:I[319228,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$c5"] c7:"DeployedPreviewIframeRefProvider" c8:I[166890,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$c7"] c9:"PreviewSourceUIStateProvider" ca:I[197843,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$c9"] cb:I[367078,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"LoaderProvider"] cc:"PromptFormUIProvider" cd:I[595358,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$cc"] ce:I[242759,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"FlagsProvider"] d0:I[530813,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"NuqsAdapter"] d1:"ChatTabsProvider" d2:I[568561,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$d1"] d3:"PersonalScopeMigrationAnnouncementProvider" d4:I[206559,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$d3"] d6:"AnnouncementVisibilityProvider" d7:I[878519,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$d6"] da:I[561588,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$5946:o4ab,","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"Toaster"] db:I[407562,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"Toaster"] dc:"SuspendingDialogs" dd:I[840793,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"$dc"] de:I[323194,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"SignInDialog"] df:I[279070,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"ConsentBanner"] e0:I[15279,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d"],"SessionManager"] 46:o8ad,ae:["$","$Lb9",null,{"serverData":{"chat":null,"scoped":null,"root":{"root":{"sidebarCollapsed":false,"sidebarPreferenceSet":false,"sidebarWidth":250,"lastUpdated":0,"modelConfiguration":{"fast":false,"modelId":"v0-max","thinking":false,"thinkingEffort":null,"imageGenerations":false},"modelDisplayPreference":null,"lastModelPreference":null,"toolConfiguration":{"webSearch":true,"generateImages":true,"vercelProjectId":null,"vercelProjectName":null,"vercelProjectBranch":null,"vercelProjectGitOrg":null,"vercelProjectGitRepo":null,"customInstructionIds":[],"mcpServerIds":[],"marketplaceMcpIds":[],"autoAllowMcpTools":false},"shouldShowUpgrade":false,"chatMobilePanel":"input","chatPanelLayout":[{"id":"input","ratio":0.205,"visible":true},{"id":"output","ratio":0.795,"visible":true}],"dismissedFeatureDialogs":{},"dismissedConnectRepoCard":false,"permissionsModeV2":null}}},"children":["$","$Lba",null,{"children":["$","$Lbb",null,{"expectUser":false,"userPromise":"$@bc","children":["$","$Lbe",null,{"children":["$","$Lbf",null,{"children":["$","$Lc1",null,{"children":["$","$Lc3",null,{"children":["$","$Lc4",null,{"children":["$","$Lc6",null,{"children":["$","$Lc8",null,{"children":["$","$Lca",null,{"children":["$","$Lcb",null,{"children":["$","$Lcd",null,{"children":["$","$Lce",null,{"promise":"$@cf","middlewareFlags":[],"children":["$","$Ld0",null,{"children":["$","$Ld2",null,{"children":["$","$Ld4",null,{"destinationTeamIdPromise":"$@d5","children":["$","$Ld7",null,{"visiblePromise":"$@d8","children":["$","div",null,{"className":"max-h-screen-patched min-h-screen-patched flex w-full flex-col overflow-auto bg-v0-background-200","vaul-drawer-wrapper":"","children":[["$","$3e",null,{"fallback":null,"children":"$Ld9"}],["$","$Lda",null,{}],["$","$Ldb",null,{}],["$","$3e",null,{"fallback":null,"children":["$","$Ldd",null,{}]}],["$","$Lde",null,{}],["$","$L4",null,{"parallelRouterKey":"children","error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}],["$","$Ldf",null,{}]]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}]}] 46:o12c,98:["$","$L90",null,{"className":"$92","children":["$4e:props:children:1:props:notFound:0:props:fallback:props:children:0",["$","$L96",null,{"description":"This chat was deleted, made private, or no longer exists.","title":"Chat Not Found","children":null}]]}] b2:["$","$Le0",null,{"enabled":false}] 46:o20,bc:"$undefined" d8:true d9:null 46:o81,40:T1,?38:T1,?22:T1,?36:T1,?2c:T1,?41:60 38:T8,variants36:T8,variants1b:T8,variants40:T2,id36:T5,scope2c:T2,id1b:T5,scope36:T2,id46:oe7a,e1:"RouteChatIdProvider" e2:I[903690,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$e1"] e3:"CompletionAttentionProvider" e4:I[607506,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79"],"$e3"] e5:"SidebarUIProvider" e6:I[475961,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79"],"$e5"] e9:"HeaderSlotClientRouter" ea:I[597544,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79"],"$e9"] eb:"/chat-static/_next/static/immutable/chunks/3kts6mi8atfbu.js" ec:I[32459,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$eb"],"default"] ed:I[990009,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79"],"Header"] ee:"RevalidateChatIdSkeletonStyles" ef:I[564011,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79"],"$ee"] f0:I[980088,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79"],"DynamicCMDK"] f1:"PromptQueueSnapshotProvider" f2:I[475641,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$f1"] f5:"ChatPromiseContextProvider" f6:I[850359,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$f5"] fe:I[70040,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"GitChatHeader"] ff:I[239654,["$3"],"IconMark"] 8e:null 46:o77d,44:["$","$Le2",null,{"children":["$","$Le4",null,{"children":["$","$Le6",null,{"children":[["$","$3e",null,{"fallback":null,"children":"$@e7"}],["$","$3e",null,{"children":"$Le8"}],false,false,["$","div",null,{"className":"isolate flex min-h-0 flex-1","children":[false,["$","div",null,{"className":"flex min-h-0 min-w-0 flex-1 flex-col","children":[["$","$Lea",null,{"headerSlot":["$","$L4",null,{"parallelRouterKey":"header","error":"$ec","errorStyles":[],"errorScripts":[["$","script","script-0",{"src":"/chat-static/_next/static/immutable/chunks/3kts6mi8atfbu.js","async":true,"nonce":"$undefined"}]],"template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}],"defaultSlot":["$","$Led",null,{}]}],["$","$L4",null,{"parallelRouterKey":"children","error":"$ec","errorStyles":"$44:props:children:props:children:props:children:4:props:children:1:props:children:0:props:headerSlot:props:errorStyles","errorScripts":"$44:props:children:props:children:props:children:4:props:children:1:props:children:0:props:headerSlot:props:errorScripts","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}],["$","$L4",null,{"parallelRouterKey":"content","error":"$ec","errorStyles":"$44:props:children:props:children:props:children:4:props:children:1:props:children:0:props:headerSlot:props:errorStyles","errorScripts":"$44:props:children:props:children:props:children:4:props:children:1:props:children:0:props:headerSlot:props:errorScripts","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","forbidden":"$undefined","unauthorized":"$undefined"}]]}]]}],false,["$","$3e",null,{"children":["$","$Lef",null,{}]}],["$","$Lf0",null,{}]]}]}]}] 46:o4a5,4f:["$","$Lf2",null,{"initial":{"chatId":"JYNFarW33aQ","snapshot":"$@f3"},"children":"$Lf4"}] 8d:["$","$Lf6",null,{"params":{"chatId":"JYNFarW33aQ"},"promises":{"attributes":"$@f7","externalMeta":"$@f8","latest":"$@f9","messagesRange":"$@fa","messages":"$@fb","template":"$@fc","gitStatus":"$@fd"},"children":["$","$Lfe",null,{"chatId":"JYNFarW33aQ"}]}] d5:null cf:{"requested":"diwok55429-5182s-projects","identity":null,"resolution":"anonymous","flags":{"aepe":false,"asse":false,"afre":false,"bvge":false,"cste":true,"igm":"gateway.google/gemini-3.1-flash-lite-image","ctv2":false,"lcw":false,"tbb":false,"oivs":false,"vmmt":false,"nfd":"","nfde":1,"iedm":true,"inb":true,"stve":true,"ci":true,"smpe":false,"dsie":false,"sie":false,"siv2":false,"cvod":false,"dce":false,"tse":false,"ftdml":true,"lmmo":false,"ubse":true,"dcpps":false,"spu":true,"kps":false,"tfam":false,"evmv":true,"f5e":true,"f51e":true,"cfmte":false,"gmpe":true,"impe":false,"gope":false,"awde":false,"awpse":false,"g56se":true,"g52e":false,"g46e":false,"kk3e":false,"o5e":true,"o55e":true,"o55fe":true,"o55cnp":false,"ept":false,"pwz":true,"shce":false,"shme":false,"idue":false,"ipc":true,"dsrr":false,"ftr":null}} 46:o5cb,3f:[["$","title","0",{"children":"Nano training pipeline (2) - v0 by Vercel"}],["$","meta","1",{"name":"description","content":"Please duplicate this block."}],["$","link","2",{"rel":"manifest","href":"/manifest.json","crossOrigin":"$undefined"}],["$","link","3",{"rel":"canonical","href":"https://v0.app/chat/nano-training-pipeline-2-JYNFarW33aQ"}],["$","meta","4",{"property":"og:title","content":"Nano training pipeline (2) - v0 by Vercel"}],["$","meta","5",{"property":"og:description","content":"Please duplicate this block."}],["$","meta","6",{"property":"og:image","content":"https://v0.app/chat/api/og/JYNFarW33aQ"}],["$","meta","7",{"name":"twitter:card","content":"summary_large_image"}],["$","meta","8",{"name":"twitter:title","content":"Nano training pipeline (2) - v0 by Vercel"}],["$","meta","9",{"name":"twitter:description","content":"Please duplicate this block."}],["$","meta","10",{"name":"twitter:image","content":"https://v0.app/chat/api/og/JYNFarW33aQ"}],["$","link","11",{"rel":"icon","href":"/assets/icon-light-32x32.png","media":"(prefers-color-scheme: light)","sizes":"32x32","type":"image/png"}],["$","link","12",{"rel":"icon","href":"/assets/icon-dark-32x32.png","media":"(prefers-color-scheme: dark)","sizes":"32x32","type":"image/png"}],["$","link","13",{"rel":"icon","href":"/assets/icon.svg","sizes":"32x32","type":"image/svg+xml"}],["$","link","14",{"rel":"apple-touch-icon","href":"/assets/apple-icon.png","type":"image/png"}],["$","$Lff","15",{}]] 46:o8,46:null 46:o1000,107:"ExplicitChatIdProvider" 108:I[903690,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$107"] 109:I[838238,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"SWRDataProvider"] 2c:T8,variants2c:T5,scopef7:{"ok":true,"value":{"designSystemId":null,"title":"Nano training pipeline (2)","privacy":"public","access":1,"isAdmin":false,"isAuthor":false,"ownerId":"team_Dbhmo9rIt0xaZoJQ9iOKCauM","authorId":"anon:ENU8w8lk-bNwA53CTf5Qv","tailwindV4Default":true,"nextVersion15Default":false,"forceVMRendering":false,"isNextLiteReadOnly":false,"canWriteToChat":false,"canManageChat":false,"chatCreatedAt":1786788403735,"hasBlock":true,"vercelProject":null,"hasGitConnection":false,"gitBase":null,"gitHead":null,"hasSnowflakeIntegration":false,"chatHasAnySnowflakeIntegration":false,"storageEntityType":"v0-git-s3-storage","storageEntityId":"v0-1-team_Dbhmo9rIt0xaZoJQ9iOKCauM-JYNFarW33aQ","vercelProjectId":null,"defaultPreviewPath":null,"agentWorkspace":false,"workspaceRuntime":false}} f8:{"ok":false,"error":{"error":"Unauthorized","statusCode":401,"errorCode":"2"}} f9:{"ok":false,"error":{"error":"51","statusCode":500,"errorCode":"38"}} fa:{"ok":false,"error":{"error":"51","statusCode":500,"errorCode":"38"}} fb:{"ok":false,"error":{"error":"51","statusCode":500,"errorCode":"38"}} fc:{"ok":false,"error":{"error":"Unauthorized","statusCode":401,"errorCode":"2"}} fd:{"ok":true,"value":null,"__seedOnly":true} e7:null 10c:[] 10d:[["b_DNV7Kmkp6JN",null],["b_OyX9fuHada4",null],["b_TeOMPUxUHnK",null]] 10e:[["b_DNV7Kmkp6JN",{"templateVersionId":null,"templateCanonId":null}],["b_OyX9fuHada4",{"templateVersionId":null,"templateCanonId":null}],["b_TeOMPUxUHnK",{"templateVersionId":null,"templateCanonId":null}]] 10f:[["6INrSBBXYWQ","$D2026-08-15T10:06:43.735Z"],["b_eKqB2ZhWhKA","$D2026-08-15T10:08:17.650Z"],["b_mVSYoxglm0R","$D2026-08-15T10:24:18.841Z"],["b_Epc01tvAzHS","$D2026-08-15T10:24:22.383Z"],["b_9WjMbiJRBtY","$D2026-08-15T11:18:14.986Z"],["b_DNV7Kmkp6JN","$D2026-08-15T11:25:47.420Z"],["b_OyX9fuHada4","$D2026-08-15T11:35:00.458Z"],["b_TeOMPUxUHnK","$D2026-08-15T11:44:35.949Z"]] 110:[["b_DNV7Kmkp6JN",false],["b_OyX9fuHada4",false],["b_TeOMPUxUHnK",false]] 111:[["b_DNV7Kmkp6JN",{"git":{"ref":"main","sha":"de8086428812da77a745877c59ccff59a7a0988a","type":"github","repoId":0,"repoName":"v0-1-team_Dbhmo9rIt0xaZoJQ9iOKCauM-JYNFarW33aQ","ownerName":"v0-git-s3-storage","commitMessage":"feat: add new script analyze_v1_domains.py for domain diagnostic analysis"}}],["b_OyX9fuHada4",{"git":{"ref":"main","sha":"1c609098bc0ef62bc886361f179ce200d478d2db","type":"github","repoId":0,"repoName":"v0-1-team_Dbhmo9rIt0xaZoJQ9iOKCauM-JYNFarW33aQ","ownerName":"v0-git-s3-storage","commitMessage":"feat: introduce dataset_v1_balanced.py for balanced dataset preparation"}}],["b_TeOMPUxUHnK",{"git":{"ref":"main","sha":"0202bb4f38abbaec19ec88c575b9064d64898042","type":"github","repoId":0,"repoName":"v0-1-team_Dbhmo9rIt0xaZoJQ9iOKCauM-JYNFarW33aQ","ownerName":"v0-git-s3-storage","commitMessage":"feat: switch to balanced dataset for V1 training script"}}]] 112:[["b_DNV7Kmkp6JN",null],["b_OyX9fuHada4",null],["b_TeOMPUxUHnK",null]] 113:[["b_DNV7Kmkp6JN",true],["b_OyX9fuHada4",true],["b_TeOMPUxUHnK",true]] 114:[["b_DNV7Kmkp6JN",true],["b_OyX9fuHada4",true],["b_TeOMPUxUHnK",true]] 115:[] 116:T406,I need to write a read-only analysis script that loads the dataset metadata to get per-domain token counts and proportions, then streams through the cleaned data measuring character and byte counts, document46:o341, counts, and token statistics—either using the precomputed metadata tokens or optionally re-tokenizing representative samples to compute precise character-to-token ratios without processing the entire corpus. The script will sample the first N documents per domain up to a character limit, reporting token counts, character-to-token ratios, and fragmentation indicators like unknown tokens and byte-fallback cases with examples of heavily split words. I'll also compare each domain's token share between train and validation splits, correlate with validation loss using hardcoded constants from the evaluation output, and apply heuristic thresholds to conclude which hypothesis (A through E) best explains the underrepresentation. The script will verify read-only access at the start and end with no writes to any files.117:T1433,46:o1433,I'm starting to work on the dataset balancing script and weighing two main approaches: duplicating English tokens directly in the training data for simplicity, or implementing a sampling-weight system that tracks domain offsets in metadata and adjusts exposure during training. The second option would require modifying the training loader, which seems permissible since the constraint only explicitly forbids changes to the model, tokenizer, and checkpoints. The cleanest solution is to write train.bin once with each token appearing exactly once, then create a sampling manifest in the metadata that records each domain's contiguous span and assigns sampling weights so the loader can balance exposure during training without physically duplicating tokens on disk. I'll build a hybrid script that defaults to this weighted approach and writes the sampling configuration into the metadata, but also supports a `--mode physical` flag for repetition-based duplication if needed. The output goes to `data/v1_balanced/` to preserve the original checkpoint dataset, and I need to note that train_v1.py will require updates to use the weighted loader in a follow-up step. For the weighted mode to work correctly, domains must occupy contiguous ranges in train.bin and the loader needs to enforce that windows don't cross domain boundaries by restricting window start positions accordingly. Now I'm working through the exposure math — I have English at 18.69% and Hinglish at 45.14% of the ~11.7M total tokens, which gives me rough token counts, but I need to estimate the Hindi and Code split since that data isn't exact. I'll present the exposure table with the computed values and note the caveat about the unknown breakdown. For weighted sampling, I'm redefining "exposure" as the probability mass of sampled windows, targeting exactly 25% per domain. I'll calculate effective repeats per domain over a training run and keep validation data unbalanced and natural — each token appears exactly once, never duplicated. I can optionally record balanced validation spans so evaluation can report balanced loss across domains. For the physical implementation, I'm setting repeat factors r_d ≥ 1 to minimize duplication while hitting the 25% target share. I'll anchor to the domain with the highest base/target ratio (r_anchor = 1), then scale other domains accordingly. For fractional repeats, I'm using full copies plus a deterministic prefix slice aligned to segment boundaries, with seeded randomization per repeat to vary the starting rotation. Now I'm planning the script structure — I'll import shared helpers from dataset_v1 to guarantee identical tokenization and split behavior, avoiding any drift between versions. This means adding a sys.path insert for the script directory, which is cleaner than duplicating code. I need to define my own output directories and assert_safe_output function since dataset_v1 restricts writes to its own data folder. I'll re-implement tokenize_domain locally since it writes to a temp directory, but import everything else like the tokenizer, domain discovery, document iteration, and the various utility functions. The split_domain function uses module constants, so importing it ensures identical behavior. Now I'm setting up the target weight distribution... For the physical mode plan, I'm calculating the exposure ratio for each domain: the base training token count divided by the target count, then normalizing so the domain with the highest ratio gets a multiplier of 1, and all others scale proportionally to ensure their actual token counts match the targets. Then I'm computing the actual token counts by multiplying base tokens by these ratios, rounding to integers, and emitting full copies of the data plus a fractional prefix if needed. I'm also capping the maximum repetition factor at 4.0 by default—if any domain exceeds this, I clamp it and report the resulting shortfall rather than silently accepting it. For the example data, English ends up duplicated about 2.4 times while Hinglish stays at 1x, which is well under the cap. To emit the stream in physical mode, I'm rotating through the domain segments deterministically for each copy, then building a local segment list with cumulative offsets so I can map any position range back to the original temp file ranges. For the fractional part, I slice from the rotation point with wraparound. The rotation itself creates one splice point where it wraps, which is acceptable since it's the same cost as segment boundaries, but I need to align the rotation to multiples of the context length. Now I'm writing the code and also need to track metadata per domain in the balanced training file — the train span, segments, base tokens, repeats, exposure share, validation span, and a sampling block with weights for weighted mode plus a documented loader recipe. I'll also add validation checks to verify the memmap opens correctly, IDs are in range, spans cover the file exactly without gaps or overlaps, exposure matches the target within tolerance, validation data isn't duplicated, guards are accounted for, and the temp files are cleaned up.46:o9,118:T5e5,46:o5e5,I'm creating a new training script that switches to the balanced dataset, updates the run name and checkpoint paths to reflect v1_balanced, protects the original v1 checkpoints from being overwritten, and enables fresh run mode with overwrite permissions. I'm implementing a domain-aware sampler that reads metadata to get per-domain weights and training segments, then samples windows proportionally based on valid window counts per domain—redistributing weight from domains with no valid windows and erroring loudly if that's impossible. The validation loader stays uniform over val.bin, and I'm adding integrity checks to ensure the validation file isn't modified during training by comparing size and modification time before and after. For the sampler interface, I need to match what the pretraining tests expect: batch() and reseed() methods, plus exposure of sampled domain names for diagnostics. I'm also setting up resume logic with protected checkpoint names (v1.pt, v1_last.pt) and a fresh run mode, then writing a smoke test with 1000 windows using a separate seeded sampler to verify the distribution shape without affecting the training stream. I'll add metadata cross-checks for vocab_size consistency and balance_mode validation, plus epoch calculation based on total tokens. For the physical domain case, if balance_mode isn't "weighted" I'll exit with a helpful error message directing users to use uniform sampling instead, and I'll assert that restrict_windows_to_segments is enabled.46:oa,119:Tbee7,46:obee7,[V0_FILE]python:file="/src/train_v1.py" """ DVLPER AI - V1 TRAINING SCRIPT (BALANCED DATASET - diagnostic run) ================================================================= Trains the VERIFIED V1 model (src/model_v1.py) on the BALANCED V1 dataset (data/v1_balanced/) on an RTX 2050 4GB laptop GPU. WHAT CHANGED vs the natural-distribution run -------------------------------------------- The dataset root is now a switch (DATASET_DIR) pointing at data/v1_balanced. That build writes every token exactly ONCE (11,726,619 train tokens, 0 duplicated tokens) with the four domains laid out in contiguous spans, and it records a per-domain `sampling.weights` entry in dataset_meta.json. Balance is therefore NOT in the bytes - it is enforced at SAMPLING TIME by this file: code natural 21.26% -> sampled 25% english natural 18.69% -> sampled 25% hindi natural 14.92% -> sampled 25% hinglish natural 45.14% -> sampled 25% The old uniform "pick any start in train.bin" sampler CANNOT do that, and it would also happily straddle a domain boundary or a 512-token guard-band seam. It is replaced by WeightedDomainSampler: 1. pick a domain d with probability sampling.weights[d] 2. pick one of d's train_segments with probability proportional to its number of valid windows, max(0, len(segment) - (SEQ_LEN + 1) + 1) 3. pick a uniform start inside that segment so [start, start+SEQ_LEN+1) lies COMPLETELY inside the segment so no window ever crosses a domain span or a guard-band seam. VALIDATION IS UNCHANGED AND NEVER REWEIGHTED. val.bin is still read with a plain uniform sampler over the whole file, so val loss stays comparable with every earlier number. This file only ever opens val.bin read-only, and it re-verifies at exit that val.bin's size and mtime did not change. FRESH WEIGHTS, NEW CHECKPOINT NAMES ----------------------------------- checkpoints/v1.pt was trained on the OLD natural distribution. It is NOT resumed and is NOT opened. This run starts from fresh weights and writes to checkpoints/v1_balanced.pt (best val loss) checkpoints/v1_balanced_last.pt (latest state, every eval) v1.pt, v1_last.pt and every Nano checkpoint are in PROTECTED and asserted out of reach. This file ONLY reads: src/model_v1.py (imported, never modified) tokenizer/tokenizer.json (read-only, vocab + generation tests) data/v1_balanced/train.bin (numpy memmap, read-only) data/v1_balanced/val.bin (numpy memmap, read-only) data/v1_balanced/dataset_meta.json (read-only: weights + segments) This file ONLY writes: checkpoints/v1_balanced.pt checkpoints/v1_balanced_last.pt It never touches data/raw, data/cleaned, data/v1, data/nano, dataset_v1.py, dataset_v1_balanced.py, model_v1.py or the tokenizer. UNCHANGED SETTINGS (deliberately) --------------------------------- BATCH_SIZE = 2, SEQ_LEN = 512, GRAD_ACCUM_STEPS = 8 (8,192 tokens/opt step), AdamW(6e-4 -> 6e-5, warmup 100, cosine, wd 0.1, betas (0.9,0.95), clip 1.0), fp16 AMP + GradScaler, the forward/backward memory probe, the atomic ".tmp -> os.replace" checkpoint system. MAX_STEPS is 500: this first balanced run is a DIAGNOSTIC run to prove the sampler, not a throughput run. Run: python src\\train_v1.py """ from __future__ import annotations import json import math import os import sys import time from pathlib import Path import numpy as np import torch # --------------------------------------------------------------------------- # import the verified model (never modified) # --------------------------------------------------------------------------- sys.path.insert(0, str(Path(__file__).resolve().parent)) from model_v1 import ModelV1, V1Config, read_vocab_size # noqa: E402 # --------------------------------------------------------------------------- # paths - DATASET_DIR is the switch # --------------------------------------------------------------------------- PROJECT_ROOT = Path(__file__).resolve().parents[1] DATASET_DIR = "data/v1_balanced" # <- dataset root switch DATA_DIR = PROJECT_ROOT / DATASET_DIR TRAIN_BIN = DATA_DIR / "train.bin" VAL_BIN = DATA_DIR / "val.bin" META_JSON = DATA_DIR / "dataset_meta.json" TOKENIZER_JSON = PROJECT_ROOT / "tokenizer" / "tokenizer.json" CKPT_DIR = PROJECT_ROOT / "checkpoints" RUN_NAME = "v1_balanced" CKPT_PATH = CKPT_DIR / "v1_balanced.pt" # best val loss LAST_PATH = CKPT_DIR / "v1_balanced_last.pt" # latest state # Files this script must never target or open. Asserted, not just documented. PROTECTED = { "v1.pt", # trained on the OLD natural distribution "v1_last.pt", "nano.pt", "nano_last.pt", "nano_corrupt.pt", "nano_step800_backup.pt", "nano_v2.pt", "nano_v2_last.pt", } assert CKPT_PATH.name not in PROTECTED, "refusing to target a protected checkpoint" assert LAST_PATH.name not in PROTECTED, "refusing to target a protected checkpoint" # On resume prefer the latest state, fall back to the best checkpoint. # Both are balanced-run files; the natural-run files are never candidates. RESUME_CANDIDATES = (LAST_PATH, CKPT_PATH) assert all(p.name not in PROTECTED for p in RESUME_CANDIDATES) # --------------------------------------------------------------------------- # configuration - everything you will want to change lives here # --------------------------------------------------------------------------- FRESH_RUN = True # balanced data => fresh weights, never resume v1.pt ALLOW_FRESH_OVERWRITE = False # guard: FRESH_RUN over existing v1_balanced files SEED = 1337 SEQ_LEN = 512 # must be <= model block_size BATCH_SIZE = 2 # conservative for 4GB VRAM GRAD_ACCUM_STEPS = 8 # effective batch = 2 * 8 = 16 sequences MAX_STEPS = 500 # diagnostic run: verify balanced sampling first EVAL_INTERVAL = 50 VAL_BATCHES = 20 # 20 * BATCH_SIZE sequences per eval LOG_INTERVAL = 10 LEARNING_RATE = 6e-4 # peak LR (unchanged) MIN_LR = 6e-5 # cosine floor = peak / 10 WARMUP_STEPS = 100 WEIGHT_DECAY = 0.1 BETAS = (0.9, 0.95) GRAD_CLIP = 1.0 USE_AMP = True # fp16 autocast + GradScaler on CUDA only # balanced-sampling diagnostics SMOKE_WINDOWS = 1000 # windows drawn in the sampler smoke test EXPOSURE_TOLERANCE_PP = 3.0 # every domain must land within +/-3 pp of target # generation probes after the run GEN_PROMPTS = ["The ", "Bhai ", "भारत "] GEN_TOKENS = 40 GEN_TEMPERATURE = 0.8 GEN_TOP_K = 50 # --------------------------------------------------------------------------- # small helpers # --------------------------------------------------------------------------- _failures: list[str] = [] def check(label: str, ok: bool, detail: str = "") -> bool: print(f"[{'PASS' if ok else 'FAIL'}] {label:<34} {detail}") if not ok: _failures.append(label) return ok def human_bytes(n: float) -> str: for unit in ("B", "KB", "MB", "GB", "TB"): if n < 1024 or unit == "TB": return f"{n:.2f} {unit}" n /= 1024 return f"{n:.2f} TB" def ppl(loss: float) -> float: return math.exp(min(loss, 20.0)) def peak_vram_mb() -> float: if not torch.cuda.is_available(): return 0.0 return torch.cuda.max_memory_allocated() / (1024 ** 2) def reset_peak_vram() -> None: if torch.cuda.is_available(): torch.cuda.reset_peak_memory_stats() def file_stamp(path: Path) -> tuple: """(size, mtime_ns) - used to prove a file was not written to.""" if not path.is_file(): return (-1, -1) st = path.stat() return (st.st_size, st.st_mtime_ns) # --------------------------------------------------------------------------- # metadata # --------------------------------------------------------------------------- def load_meta() -> dict: if not META_JSON.is_file(): raise SystemExit( f"ERROR: {META_JSON} not found.\n" f"The balanced dataset must be built first:\n" f" python src\\dataset_v1_balanced.py\n" f"This script never builds or modifies a dataset." ) try: meta = json.loads(META_JSON.read_text(encoding="utf-8")) except Exception as e: raise SystemExit(f"ERROR: {META_JSON} is not readable JSON ({e}).") mode = meta.get("balance_mode") if mode != "weighted": raise SystemExit( f"ERROR: {META_JSON} reports balance_mode={mode!r}, expected 'weighted'.\n" f"This trainer balances by SAMPLING WEIGHTS. A 'physical' build already\n" f"carries its balance in the bytes and needs a uniform sampler instead.\n" f"Rebuild with: python src\\dataset_v1_balanced.py --mode weighted" ) sampling = meta.get("sampling") or {} if not isinstance(sampling.get("weights"), dict) or not sampling["weights"]: raise SystemExit( f"ERROR: {META_JSON} has no sampling.weights map. " f"Refusing to guess domain weights." ) if not sampling.get("restrict_windows_to_segments", False): raise SystemExit( f"ERROR: {META_JSON} does not set sampling.restrict_windows_to_segments. " f"Refusing to sample windows that may cross seams." ) if not isinstance(meta.get("domains"), dict) or not meta["domains"]: raise SystemExit(f"ERROR: {META_JSON} has no per-domain 'domains' block.") return meta # --------------------------------------------------------------------------- # data # --------------------------------------------------------------------------- class BinDataset: """ Read-only memmap over a uint16 token file, uniform windows over the whole file. Used for VALIDATION ONLY, exactly as before - val.bin is never reweighted and never domain-sampled, so val loss stays comparable across runs. A sample is a contiguous window of SEQ_LEN+1 tokens; x is the first SEQ_LEN tokens and y is that window shifted by one, so y[i] is the correct next-token target for x[i]. """ def __init__(self, path: Path, seq_len: int, seed: int) -> None: if not path.is_file(): raise SystemExit( f"ERROR: {path} not found.\n" f"The balanced V1 dataset must exist at {DATA_DIR}. " f"This script never rebuilds it." ) self.path = path self.seq_len = seq_len # mode="r" -> read-only mapping; the file can never be modified here. self.data = np.memmap(path, dtype=np.uint16, mode="r") self.n_tokens = int(self.data.shape[0]) if self.n_tokens < seq_len + 2: raise SystemExit(f"ERROR: {path} has only {self.n_tokens} tokens.") self.max_start = self.n_tokens - (seq_len + 1) self.rng = np.random.default_rng(seed) def batch(self, batch_size: int, device: torch.device): starts = self.rng.integers(0, self.max_start, size=batch_size, endpoint=True) return windows_to_batch(self.data, starts, self.seq_len, device) def reseed(self, seed: int) -> None: self.rng = np.random.default_rng(seed) def windows_to_batch(data, starts, seq_len: int, device: torch.device): """Copy each [start, start+seq_len+1) window and split into x / y.""" n = len(starts) xs = np.empty((n, seq_len), dtype=np.int64) ys = np.empty((n, seq_len), dtype=np.int64) for i, s in enumerate(starts): s = int(s) window = np.asarray(data[s: s + seq_len + 1], dtype=np.int64) xs[i] = window[:-1] ys[i] = window[1:] x = torch.from_numpy(xs) y = torch.from_numpy(ys) if device.type == "cuda": x = x.pin_memory().to(device, non_blocking=True) y = y.pin_memory().to(device, non_blocking=True) else: x, y = x.to(device), y.to(device) return x, y class WeightedDomainSampler: """ Domain-aware TRAIN sampler. train.bin holds every token exactly once, domains in contiguous spans, each span cut into seam-free `train_segments`. Balance is enforced here: 1. domain d ~ sampling.weights[d] 2. segment ~ proportional to that segment's valid-window count 3. start ~ uniform in [seg_start, seg_end - (SEQ_LEN+1)] so every window of SEQ_LEN+1 tokens lies wholly inside ONE segment of ONE domain: no domain boundary is crossed and no guard-band seam is crossed. Driven by a dedicated numpy Generator, so the stream is deterministic. """ def __init__(self, path: Path, seq_len: int, seed: int, meta: dict) -> None: if not path.is_file(): raise SystemExit( f"ERROR: {path} not found.\n" f"The balanced V1 dataset must exist at {DATA_DIR}. " f"This script never rebuilds it." ) self.path = path self.seq_len = seq_len self.window = seq_len + 1 self.data = np.memmap(path, dtype=np.uint16, mode="r") self.n_tokens = int(self.data.shape[0]) weights = meta["sampling"]["weights"] self.domains: list[str] = list(weights.keys()) # ---- per-domain segments, keeping only segments that fit a window ---- self.segments: dict[str, list[tuple[int, int]]] = {} self.spans: dict[str, tuple[int, int]] = {} self.seg_windows: dict[str, np.ndarray] = {} self.seg_probs: dict[str, np.ndarray] = {} self.total_windows: dict[str, int] = {} self.dropped_segments: dict[str, int] = {} for d in self.domains: info = meta["domains"].get(d) if not isinstance(info, dict): raise SystemExit(f"ERROR: domain {d!r} has no entry in dataset_meta.json.") span = info.get("train_span") raw = info.get("train_segments") if not (isinstance(span, (list, tuple)) and len(span) == 2): raise SystemExit(f"ERROR: domain {d!r} has no valid train_span.") if not isinstance(raw, list) or not raw: raise SystemExit(f"ERROR: domain {d!r} has no train_segments.") lo, hi = int(span[0]), int(span[1]) if not (0 <= lo <= hi <= self.n_tokens): raise SystemExit( f"ERROR: domain {d!r} train_span {span} is outside train.bin " f"({self.n_tokens:,} tokens)." ) self.spans[d] = (lo, hi) kept: list[tuple[int, int]] = [] counts: list[int] = [] dropped = 0 for seg in raw: s, e = int(seg[0]), int(seg[1]) if not (lo <= s <= e <= hi): raise SystemExit( f"ERROR: domain {d!r} segment {seg} escapes its span {span}." ) n_win = (e - s) - self.window + 1 if n_win <= 0: dropped += 1 continue kept.append((s, e)) counts.append(n_win) if not kept: raise SystemExit( f"ERROR: domain {d!r} has no segment long enough for a " f"{self.window}-token window. Refusing to silently drop a domain " f"or to let a window cross a seam." ) self.segments[d] = kept self.dropped_segments[d] = dropped arr = np.asarray(counts, dtype=np.int64) self.seg_windows[d] = arr self.seg_probs[d] = arr / arr.sum() self.total_windows[d] = int(arr.sum()) # ---- domain weights, normalised ---- w = np.asarray([float(weights[d]) for d in self.domains], dtype=np.float64) if (w < 0).any() or w.sum() <= 0: raise SystemExit(f"ERROR: invalid sampling.weights {weights}.") self.weights = w / w.sum() self.weight_of = {d: float(p) for d, p in zip(self.domains, self.weights)} self.rng = np.random.default_rng(seed) self.draw_counts: dict[str, int] = {d: 0 for d in self.domains} # -- sampling ---------------------------------------------------------- def sample_windows(self, n: int) -> tuple[list[int], list[str]]: """Return n window starts plus the domain each was drawn from.""" picks = self.rng.choice(len(self.domains), size=n, p=self.weights) starts: list[int] = [] doms: list[str] = [] for di in picks: d = self.domains[int(di)] segs = self.segments[d] si = int(self.rng.choice(len(segs), p=self.seg_probs[d])) s, e = segs[si] hi = e - self.window # inclusive upper bound start = int(self.rng.integers(s, hi, endpoint=True)) starts.append(start) doms.append(d) self.draw_counts[d] += 1 return starts, doms def batch(self, batch_size: int, device: torch.device): starts, doms = self.sample_windows(batch_size) self.last_starts = starts self.last_domains = doms return windows_to_batch(self.data, starts, self.seq_len, device) def reseed(self, seed: int) -> None: self.rng = np.random.default_rng(seed) def reset_counts(self) -> None: self.draw_counts = {d: 0 for d in self.domains} # -- helpers used by the correctness checks ---------------------------- def owner_of(self, start: int) -> str | None: """Which domain span contains this whole window, if any.""" for d, (lo, hi) in self.spans.items(): if lo <= start and start + self.window <= hi: return d return None def inside_a_segment(self, start: int, domain: str) -> bool: return any(s <= start and start + self.window <= e for s, e in self.segments[domain]) # --------------------------------------------------------------------------- # learning rate schedule (unchanged) # --------------------------------------------------------------------------- def lr_at(step: int) -> float: """Linear warmup for WARMUP_STEPS, then cosine decay to MIN_LR.""" if step < WARMUP_STEPS: return LEARNING_RATE * (step + 1) / max(1, WARMUP_STEPS) if step >= MAX_STEPS: return MIN_LR progress = (step - WARMUP_STEPS) / max(1, MAX_STEPS - WARMUP_STEPS) coeff = 0.5 * (1.0 + math.cos(math.pi * progress)) return MIN_LR + coeff * (LEARNING_RATE - MIN_LR) # --------------------------------------------------------------------------- # checkpointing (atomic, unchanged mechanism - new names only) # --------------------------------------------------------------------------- def hyperparams(sampler: WeightedDomainSampler | None = None) -> dict: hp = { "seed": SEED, "seq_len": SEQ_LEN, "batch_size": BATCH_SIZE, "grad_accum_steps": GRAD_ACCUM_STEPS, "effective_batch": BATCH_SIZE * GRAD_ACCUM_STEPS, "tokens_per_step": BATCH_SIZE * GRAD_ACCUM_STEPS * SEQ_LEN, "max_steps": MAX_STEPS, "learning_rate": LEARNING_RATE, "min_lr": MIN_LR, "warmup_steps": WARMUP_STEPS, "weight_decay": WEIGHT_DECAY, "betas": list(BETAS), "grad_clip": GRAD_CLIP, "eval_interval": EVAL_INTERVAL, "val_batches": VAL_BATCHES, "amp": USE_AMP, "dataset_dir": DATASET_DIR, "train_sampler": "weighted-domain (segment-bounded)", "val_sampler": "uniform over val.bin (never reweighted)", } if sampler is not None: hp["domain_weights"] = {d: round(sampler.weight_of[d], 8) for d in sampler.domains} return hp def tokenizer_fingerprint(path: Path = TOKENIZER_JSON) -> dict: """Cheap identity of the tokenizer file so a checkpoint can be traced.""" info = {"path": str(path), "exists": path.is_file()} if path.is_file(): st = path.stat() info["size_bytes"] = st.st_size info["mtime"] = int(st.st_mtime) try: import hashlib h = hashlib.sha256() with open(path, "rb") as f: for chunk in iter(lambda: f.read(1 << 20), b""): h.update(chunk) info["sha256"] = h.hexdigest()[:16] except Exception: pass return info def save_checkpoint( path: Path, model: ModelV1, cfg: V1Config, opt: torch.optim.Optimizer, scaler, step: int, val_loss: float, best_val: float, fingerprint: dict, sampler: WeightedDomainSampler, ) -> None: """ Write to .tmp then os.replace() onto the target. os.replace is atomic on Windows and POSIX, so a crash mid-write can never leave a half checkpoint at the real path. """ assert path.name not in PROTECTED, f"refusing to write {path.name}" tmp = path.with_name(path.name + ".tmp") payload = { "run": RUN_NAME, "format_version": 1, "model": model.state_dict(), "optimizer": opt.state_dict(), "scaler": scaler.state_dict(), "step": int(step), "val_loss": float(val_loss), "best_val_loss": float(best_val), "config": vars(cfg).copy(), "vocab_size": int(cfg.vocab_size), "tokenizer": fingerprint, "hyperparams": hyperparams(sampler), "dataset": { "dir": DATASET_DIR, "train_bin": str(TRAIN_BIN), "val_bin": str(VAL_BIN), "balance_mode": "weighted", "domain_weights": {d: round(sampler.weight_of[d], 8) for d in sampler.domains}, }, "torch_version": torch.__version__, "saved_at": time.strftime("%Y-%m-%d %H:%M:%S"), } torch.save(payload, tmp) os.replace(tmp, path) def find_resume() -> Path | None: for p in RESUME_CANDIDATES: if p.is_file(): return p return None def load_checkpoint(path: Path, device: torch.device) -> dict: """ Load a balanced-run checkpoint. A corrupt file is a hard error - we never silently fall back to step 0 when a checkpoint for this run exists. """ if path.name in PROTECTED: raise SystemExit( f"ERROR: refusing to open protected checkpoint {path.name}. " f"It belongs to the old natural-distribution run." ) try: # our own local file -> weights_only=False is intentional ckpt = torch.load(path, map_location=device, weights_only=False) except Exception as e: raise SystemExit( f"ERROR: {path} exists but could not be loaded ({e}).\n" f" -> Try the other file ({', '.join(p.name for p in RESUME_CANDIDATES)}).\n" f" -> Refusing to silently restart at step 0.\n" f" -> If you really want to discard it, set FRESH_RUN = True and\n" f" ALLOW_FRESH_OVERWRITE = True." ) if not isinstance(ckpt, dict) or "model" not in ckpt or "step" not in ckpt: raise SystemExit( f"ERROR: {path} loaded but is not a valid checkpoint " f"(missing 'model' / 'step'). Refusing to restart at step 0." ) if ckpt.get("run") != RUN_NAME: raise SystemExit( f"ERROR: {path} belongs to run '{ckpt.get('run')}', not '{RUN_NAME}'. " f"Refusing to load a foreign checkpoint (the balanced run must not " f"inherit natural-distribution weights)." ) return ckpt # --------------------------------------------------------------------------- # evaluation - val.bin, uniform, never reweighted # --------------------------------------------------------------------------- @torch.no_grad() def evaluate(model: ModelV1, ds: BinDataset, batches: int, device: torch.device, use_amp: bool, seed: int) -> float: """Fixed-seed eval so val loss is comparable across steps AND across runs.""" was_training = model.training model.eval() ds.reseed(seed) total = 0.0 for _ in range(batches): x, y = ds.batch(BATCH_SIZE, device) with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp): _, loss = model(x, y) total += loss.item() del x, y if was_training: model.train() return total / max(1, batches) # --------------------------------------------------------------------------- # balanced-sampling diagnostics + correctness # --------------------------------------------------------------------------- def sampler_report(sampler: WeightedDomainSampler, meta: dict) -> None: print("\n---------------- BALANCED SAMPLER ----------------") print(f"dataset dir : {DATA_DIR}") print(f"train.bin : {TRAIN_BIN}") print(f"val.bin : {VAL_BIN} (uniform, NEVER reweighted)") print(f"meta : {META_JSON}") print(f"balance mode : {meta.get('balance_mode')}") print(f"duplicated tokens : " f"{meta.get('duplicated_train_tokens', sum(i.get('duplicated_train_tokens', 0) for i in meta['domains'].values())):,}") print() print(f" {'domain':<10} {'natural':>9} {'weight':>9} {'expected':>9} " f"{'segments':>9} {'windows':>14}") print(f" {'-' * 64}") for d in sampler.domains: info = meta["domains"].get(d, {}) nat = info.get("natural_train_share_pct") nat_s = f"{nat:.2f}%" if isinstance(nat, (int, float)) else "?" print(f" {d:<10} {nat_s:>9} {sampler.weight_of[d] * 100:>8.2f}% " f"{sampler.weight_of[d] * 100:>8.2f}% " f"{len(sampler.segments[d]):>9,} {sampler.total_windows[d]:>14,}") print(f" {'-' * 64}") exp = " ".join(f"{d} {sampler.weight_of[d] * 100:.0f}%" for d in sampler.domains) print(f" expected exposure : {exp}") dropped = sum(sampler.dropped_segments.values()) print(f" segments too short for a {sampler.window}-token window, skipped: {dropped}") def sampler_smoke_test(sampler: WeightedDomainSampler, cfg: V1Config, device: torch.device) -> None: """ Draw SMOKE_WINDOWS windows and prove: exposure hits the weights, every window is 513 tokens, ids are in vocab range, and no window leaves its chosen segment. Uses a THROWAWAY sampler so the training stream is not consumed. """ print(f"\nsampler smoke test: {SMOKE_WINDOWS} windows, seed={SEED}") probe = WeightedDomainSampler(TRAIN_BIN, SEQ_LEN, SEED, _META) starts, doms = probe.sample_windows(SMOKE_WINDOWS) counts = {d: 0 for d in probe.domains} for d in doms: counts[d] += 1 print(f" {'domain':<10} {'target':>8} {'drawn':>8} {'actual':>9} {'delta':>9}") print(f" {'-' * 48}") worst = 0.0 for d in probe.domains: target_pp = probe.weight_of[d] * 100 actual_pp = counts[d] / SMOKE_WINDOWS * 100 delta = actual_pp - target_pp worst = max(worst, abs(delta)) print(f" {d:<10} {target_pp:>7.2f}% {counts[d]:>8,} " f"{actual_pp:>8.2f}% {delta:>+8.2f}pp") print(f" {'-' * 48}") print(f" total drawn : {sum(counts.values()):,}") print(f" worst deviation : {worst:.2f} pp (tolerance +/-{EXPOSURE_TOLERANCE_PP:.0f} pp)") check(f"exposure within +/-{EXPOSURE_TOLERANCE_PP:.0f}pp", worst <= EXPOSURE_TOLERANCE_PP, f"worst {worst:.2f}pp over {SMOKE_WINDOWS} windows") # every window sits inside the segment it was drawn from, and inside that # domain's span -> no domain boundary and no guard-band seam is crossed seg_ok = all(probe.inside_a_segment(s, d) for s, d in zip(starts, doms)) check("windows inside their segment", seg_ok, f"{SMOKE_WINDOWS} windows checked") span_ok = all(probe.owner_of(s) == d for s, d in zip(starts, doms)) check("no domain boundary crossed", span_ok, "owner span == drawn domain") # window length + id range, verified on real tensors x, y = probe.batch(BATCH_SIZE, device) len_ok = x.shape[1] == SEQ_LEN and y.shape[1] == SEQ_LEN check("sampled window length 513", len_ok, f"x={tuple(x.shape)} y={tuple(y.shape)} -> {SEQ_LEN}+1 tokens read") ids_ok = bool(x.min() >= 0 and x.max() < cfg.vocab_size and y.max() < cfg.vocab_size) check("sampled ids in vocab range", ids_ok, f"max id={int(max(x.max().item(), y.max().item()))} < {cfg.vocab_size}") del x, y # determinism: a second throwaway sampler at the same seed must agree twin = WeightedDomainSampler(TRAIN_BIN, SEQ_LEN, SEED, _META) s2, d2 = twin.sample_windows(SMOKE_WINDOWS) check("sampler deterministic @seed", starts == s2 and doms == d2, f"seed={SEED}") del probe, twin # --------------------------------------------------------------------------- # pre-training correctness + memory tests # --------------------------------------------------------------------------- def pretraining_tests(model: ModelV1, cfg: V1Config, train_ds: WeightedDomainSampler, device: torch.device, use_amp: bool) -> None: print("\n---------------- PRE-TRAINING TESTS ----------------") # TEST 1 - next-token shift. y must equal x shifted left by one. train_ds.reseed(SEED) x, y = train_ds.batch(BATCH_SIZE, device) shift_ok = bool(torch.equal(x[:, 1:], y[:, :-1])) check("next-token shift", shift_ok, "y[:, :-1] == x[:, 1:]") ids_ok = bool((x.min() >= 0) and (x.max() < cfg.vocab_size) and (y.max() < cfg.vocab_size)) check("token ids in vocab range", ids_ok, f"max id={int(max(x.max().item(), y.max().item()))} < {cfg.vocab_size}") # the batch we just drew must also respect the segment bounds batch_seg_ok = all(train_ds.inside_a_segment(s, d) for s, d in zip(train_ds.last_starts, train_ds.last_domains)) check("train batch inside segments", batch_seg_ok, f"domains={train_ds.last_domains}") # determinism of the loader under the seed train_ds.reseed(SEED) x2, y2 = train_ds.batch(BATCH_SIZE, device) check("loader deterministic @seed", bool(torch.equal(x, x2) and torch.equal(y, y2)), f"seed={SEED}") # TEST 2 - logits shape and random-init loss near ln(V) model.eval() with torch.no_grad(): logits, loss = model(x, y) check("logits shape", tuple(logits.shape) == (BATCH_SIZE, SEQ_LEN, cfg.vocab_size), f"{tuple(logits.shape)}") baseline = math.log(cfg.vocab_size) check("init loss ~= ln(V)", abs(loss.item() - baseline) < 0.5, f"loss={loss.item():.4f} ln(V)={baseline:.4f}") del logits, loss # TEST 3 - causal behaviour: changing token t must not move logits < t probe = x[:1, :64].clone() with torch.no_grad(): base, _ = model(probe) tampered = probe.clone() tampered[0, 40] = (int(tampered[0, 40].item()) + 7919) % cfg.vocab_size tamp, _ = model(tampered) past = (base[0, :40] - tamp[0, :40]).abs().max().item() future = (base[0, 40:] - tamp[0, 40:]).abs().max().item() check("causal behaviour", past < 1e-4 and future > 1e-6, f"past={past:.2e} future={future:.2e}") del base, tamp, probe, tampered # TEST 4 - forward + backward memory probe at the CONFIGURED batch size. # Uses the real model but zeroes the gradients afterwards, so no weight is # ever updated by this test. BATCH_SIZE is never changed automatically. print("\nmemory probe: 1 forward + 1 backward at the configured batch size") model.train() reset_peak_vram() probe_scaler = torch.amp.GradScaler("cuda", enabled=use_amp) try: with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp): _, probe_loss = model(x, y) probe_scaler.scale(probe_loss).backward() except torch.cuda.OutOfMemoryError as e: print("\n" + "=" * 70) print("CUDA OUT OF MEMORY during the forward/backward probe.") print("=" * 70) print(f" batch_size = {BATCH_SIZE}, seq_len = {SEQ_LEN}") print(f" peak allocated before failure: {peak_vram_mb():.1f} MB") print("\n Training was NOT started. Nothing was written to disk.") print(" This script will NOT change the architecture and will NOT") print(" silently reduce your settings. Lower BATCH_SIZE (2 -> 1) or") print(" raise GRAD_ACCUM_STEPS to keep the effective batch, then rerun.") print(f"\n torch reports: {e}") raise SystemExit(2) probe_peak = peak_vram_mb() model.zero_grad(set_to_none=True) # discard the probe gradients del probe_loss, probe_scaler, x, y, x2, y2 if torch.cuda.is_available(): torch.cuda.empty_cache() print(f" peak VRAM (fwd+bwd) : {probe_peak:.1f} MB" f"{' of ' + f'{torch.cuda.get_device_properties(0).total_memory / 1024 ** 2:.0f} MB' if torch.cuda.is_available() else ''}") check("forward/backward fits", True, f"peak {probe_peak:.1f} MB, no OOM") if _failures: raise SystemExit( "\nABORTING: pre-training tests failed: " + ", ".join(_failures) ) print("\nall pre-training tests passed.") reset_peak_vram() # --------------------------------------------------------------------------- # post-training checkpoint + generation tests # --------------------------------------------------------------------------- def post_tests(device: torch.device, model: ModelV1, cfg: V1Config) -> None: print("\n---------------- CHECKPOINT + GENERATION TESTS ----------------") reload_path = CKPT_PATH if CKPT_PATH.is_file() else LAST_PATH if not reload_path.is_file(): check("checkpoint exists", False, f"no {CKPT_PATH.name} / {LAST_PATH.name} written") return ckpt = load_checkpoint(reload_path, device) print(f"reloaded : {reload_path}") check("checkpoint step present", isinstance(ckpt.get("step"), int), f"step={ckpt.get('step')}") check("optimizer state present", isinstance(ckpt.get("optimizer"), dict) and "state" in ckpt["optimizer"] and "param_groups" in ckpt["optimizer"], f"keys={sorted(ckpt.get('optimizer', {}).keys())}") check("scaler state present", isinstance(ckpt.get("scaler"), dict), f"keys={sorted(ckpt.get('scaler', {}).keys())}") check("config + hyperparams present", isinstance(ckpt.get("config"), dict) and isinstance(ckpt.get("hyperparams"), dict), f"vocab_size={ckpt.get('vocab_size')}") check("dataset recorded in ckpt", (ckpt.get("dataset") or {}).get("dir") == DATASET_DIR, f"dir={(ckpt.get('dataset') or {}).get('dir')}") # state_dict round-trip into a FRESH model - the live model is untouched fresh = ModelV1(V1Config(**ckpt["config"])).to(device) fresh.load_state_dict(ckpt["model"], strict=True) same = all( torch.equal(a.detach().float().cpu(), b.detach().float().cpu()) for a, b in zip(fresh.state_dict().values(), ckpt["model"].values()) ) check("state_dict round-trip", same, "all tensors identical after reload") # generation probes with the existing tokenizer try: from tokenizers import Tokenizer except ImportError: print("\n(skipping generation: `pip install tokenizers`)") return if not TOKENIZER_JSON.is_file(): print(f"\n(skipping generation: tokenizer not found at {TOKENIZER_JSON})") return tok = Tokenizer.from_file(str(TOKENIZER_JSON)) fresh.eval() torch.manual_seed(SEED) print(f"\ngeneration probes ({GEN_TOKENS} tokens, temp={GEN_TEMPERATURE}, " f"top_k={GEN_TOP_K}) - quality is NOT expected at 500 steps:") for prompt in GEN_PROMPTS: ids = tok.encode(prompt).ids if not ids: ids = [0] idx = torch.tensor([ids], dtype=torch.long, device=device) out = fresh.generate(idx, max_new_tokens=GEN_TOKENS, temperature=GEN_TEMPERATURE, top_k=GEN_TOP_K) text = tok.decode(out[0].tolist()) print(f" {prompt!r} -> {text!r}") del fresh # --------------------------------------------------------------------------- # main # --------------------------------------------------------------------------- _META: dict = {} def main() -> int: global _META torch.manual_seed(SEED) np.random.seed(SEED) if torch.cuda.is_available(): torch.cuda.manual_seed_all(SEED) torch.backends.cuda.matmul.allow_tf32 = True torch.backends.cudnn.allow_tf32 = True device = torch.device("cuda" if torch.cuda.is_available() else "cpu") use_amp = bool(USE_AMP and device.type == "cuda") if SEQ_LEN > 512: raise SystemExit("ERROR: SEQ_LEN must be <= the model block_size (512).") CKPT_DIR.mkdir(parents=True, exist_ok=True) # ---------------- checkpoint policy ---------------- existing = [p.name for p in (CKPT_PATH, LAST_PATH) if p.is_file()] resume_path = None if FRESH_RUN: if existing and not ALLOW_FRESH_OVERWRITE: raise SystemExit( f"REFUSING TO START: FRESH_RUN=True but these balanced checkpoints " f"already exist: {', '.join(existing)}.\n" f" -> To CONTINUE that run, set FRESH_RUN = False.\n" f" -> To overwrite it on purpose, set ALLOW_FRESH_OVERWRITE = True." ) else: resume_path = find_resume() if resume_path is None: raise SystemExit( f"ERROR: FRESH_RUN=False but no balanced checkpoint was found in " f"{CKPT_DIR}.\n" f"Expected {CKPT_PATH.name} or {LAST_PATH.name}. " f"v1.pt / v1_last.pt (natural distribution) are never used here.\n" f"Set FRESH_RUN = True to start the balanced run." ) # ---------------- metadata + data ---------------- _META = load_meta() meta = _META vocab_size = read_vocab_size() cfg = V1Config(vocab_size=vocab_size, block_size=512) model = ModelV1(cfg).to(device) fingerprint = tokenizer_fingerprint() train_ds = WeightedDomainSampler(TRAIN_BIN, SEQ_LEN, SEED, meta) val_ds = BinDataset(VAL_BIN, SEQ_LEN, SEED + 1) val_stamp_before = file_stamp(VAL_BIN) # proof val.bin is never written meta_vocab = meta.get("vocab_size") if isinstance(meta_vocab, int) and meta_vocab != cfg.vocab_size: raise SystemExit( f"ERROR: dataset_meta vocab_size={meta_vocab} but tokenizer reports " f"{cfg.vocab_size}. Refusing to train on mismatched data." ) # ---------------- startup report ---------------- eff_batch = BATCH_SIZE * GRAD_ACCUM_STEPS tokens_per_step = eff_batch * SEQ_LEN print("=" * 70) print("DVLPER AI - V1 TRAINING (BALANCED DATA, DIAGNOSTIC RUN)") print("=" * 70) print(f"device : {device}") if device.type == "cuda": props = torch.cuda.get_device_properties(0) print(f"gpu : {props.name}") print(f"total VRAM : {props.total_memory / 1024 ** 3:.2f} GB") else: print("gpu : none (CPU - this will be very slow)") print(f"torch : {torch.__version__}") print(f"amp : {'fp16 autocast + GradScaler' if use_amp else 'disabled'}") print() print(f"vocab size : {cfg.vocab_size:,}") print(f"parameters : {model.num_parameters():,} " f"({model.num_parameters(non_embedding=True):,} non-embedding)") print(f"layers / d_model : {cfg.n_layers} / {cfg.d_model} " f"({cfg.n_heads} heads x {cfg.head_dim})") print() print(f"dataset dir : {DATASET_DIR}") print(f"train.bin : {train_ds.n_tokens:,} tokens " f"({human_bytes(TRAIN_BIN.stat().st_size)}, memmap)") print(f"val.bin : {val_ds.n_tokens:,} tokens " f"({human_bytes(VAL_BIN.stat().st_size)}, memmap, uniform sampling)") print(f"dataset_meta : vocab={meta.get('vocab_size', '?')} " f"dtype={meta.get('dtype', '?')} mode={meta.get('balance_mode', '?')}") print() print(f"batch size : {BATCH_SIZE}") print(f"sequence length : {SEQ_LEN}") print(f"grad accumulation : {GRAD_ACCUM_STEPS}") print(f"effective batch : {eff_batch} sequences") print(f"tokens / opt step : {tokens_per_step:,}") print(f"MAX_STEPS : {MAX_STEPS} " f"({MAX_STEPS * tokens_per_step:,} tokens total, " f"{MAX_STEPS * tokens_per_step / train_ds.n_tokens:.2f} epochs)") print(f"learning rate : {LEARNING_RATE:.2e} -> {MIN_LR:.2e} " f"(warmup {WARMUP_STEPS}, cosine)") print(f"weight decay : {WEIGHT_DECAY} betas {BETAS} clip {GRAD_CLIP}") print(f"eval : every {EVAL_INTERVAL} steps, {VAL_BATCHES} val batches") print() print(f"run : {RUN_NAME}") print(f"fresh weights : {FRESH_RUN} (v1.pt is NOT resumed and NOT opened)") print(f"best checkpoint : {CKPT_PATH}") print(f"last checkpoint : {LAST_PATH}") print(f"protected files : untouched ({', '.join(sorted(PROTECTED))})") print(f"random-init loss : ln({cfg.vocab_size}) = {math.log(cfg.vocab_size):.4f}") # ---------------- balanced sampler diagnostics ---------------- sampler_report(train_ds, meta) sampler_smoke_test(train_ds, cfg, device) if _failures: raise SystemExit( "\nABORTING before training: sampler checks failed: " + ", ".join(_failures) ) # ---------------- pre-training tests ---------------- pretraining_tests(model, cfg, train_ds, device, use_amp) # ---------------- optimizer (unchanged) ---------------- decay, no_decay = [], [] for name, p in model.named_parameters(): if not p.requires_grad: continue # weight decay only on 2D matrices; norms/embedding scales stay free (decay if p.dim() >= 2 else no_decay).append(p) opt = torch.optim.AdamW( [ {"params": decay, "weight_decay": WEIGHT_DECAY}, {"params": no_decay, "weight_decay": 0.0}, ], lr=LEARNING_RATE, betas=BETAS, ) scaler = torch.amp.GradScaler("cuda", enabled=use_amp) start_step, best_val = 0, float("inf") if resume_path is not None: ckpt = load_checkpoint(resume_path, device) model.load_state_dict(ckpt["model"], strict=True) opt_restored = scaler_restored = False if isinstance(ckpt.get("optimizer"), dict): opt.load_state_dict(ckpt["optimizer"]) opt_restored = True if isinstance(ckpt.get("scaler"), dict) and use_amp: scaler.load_state_dict(ckpt["scaler"]) scaler_restored = True start_step = int(ckpt["step"]) best_val = float(ckpt.get("best_val_loss", float("inf"))) # keep the data stream from replaying the same windows train_ds.reseed(SEED + start_step) print("\n---------------- RESUME ----------------") print(f"resumed from : {resume_path}") print(f"start step : {start_step} -> {MAX_STEPS} " f"({max(0, MAX_STEPS - start_step)} to go)") print(f"best val : {best_val:.4f}") print(f"optimizer : {'restored' if opt_restored else 'FRESH (absent)'}") print(f"grad scaler : {'restored' if scaler_restored else 'fresh'}") if start_step >= MAX_STEPS: print("\nnothing to do: start step already >= MAX_STEPS. " "Raise MAX_STEPS to continue.") post_tests(device, model, cfg) return 0 else: train_ds.reseed(SEED) print("\nfresh weights: starting at step 0 on the BALANCED distribution " "(v1.pt was never opened).") # ---------------- training ---------------- print("\n---------------- TRAINING ----------------") print(f"{'step':>6} {'lr':>10} {'train':>8} {'val':>8} {'ppl':>10} " f"{'elapsed':>9} {'it/s':>7} {'peakVRAM':>10}") model.train() reset_peak_vram() train_ds.reset_counts() t0 = time.time() running = [] step = start_step while step < MAX_STEPS: lr = lr_at(step) for group in opt.param_groups: group["lr"] = lr opt.zero_grad(set_to_none=True) accum_loss = 0.0 for micro in range(GRAD_ACCUM_STEPS): x, y = train_ds.batch(BATCH_SIZE, device) with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp): _, loss = model(x, y) loss = loss / GRAD_ACCUM_STEPS scaler.scale(loss).backward() accum_loss += loss.item() del x, y, loss scaler.unscale_(opt) torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP) scaler.step(opt) scaler.update() step += 1 running.append(accum_loss) if step % LOG_INTERVAL == 0 and step % EVAL_INTERVAL != 0: el = time.time() - t0 done = step - start_step print(f"{step:>6} {lr:>10.3e} {accum_loss:>8.4f} {'-':>8} " f"{ppl(accum_loss):>10.1f} {el:>8.1f}s {done / max(el, 1e-9):>7.2f} " f"{peak_vram_mb():>9.1f}M") if step % EVAL_INTERVAL == 0 or step >= MAX_STEPS: train_loss = sum(running) / max(1, len(running)) running = [] val_loss = evaluate(model, val_ds, VAL_BATCHES, device, use_amp, SEED + 1) el = time.time() - t0 done = step - start_step print(f"{step:>6} {lr:>10.3e} {train_loss:>8.4f} {val_loss:>8.4f} " f"{ppl(val_loss):>10.1f} {el:>8.1f}s {done / max(el, 1e-9):>7.2f} " f"{peak_vram_mb():>9.1f}M") is_best = val_loss < best_val if is_best: best_val = val_loss # latest state every eval, best only when beaten save_checkpoint(LAST_PATH, model, cfg, opt, scaler, step, val_loss, best_val, fingerprint, train_ds) if is_best: save_checkpoint(CKPT_PATH, model, cfg, opt, scaler, step, val_loss, best_val, fingerprint, train_ds) print(f" -> new best val {best_val:.4f}, wrote {CKPT_PATH.name}") total = time.time() - t0 print(f"\ntrain time : {total:.1f}s " f"({(MAX_STEPS - start_step) / max(total, 1e-9):.2f} steps/s)") print(f"best val loss : {best_val:.4f} (ppl {ppl(best_val):.1f})") print(f"peak VRAM : {peak_vram_mb():.1f} MB") print(f"best ckpt : {CKPT_PATH}") print(f"last ckpt : {LAST_PATH}") # ---------------- realised exposure over the whole run ---------------- drawn_total = sum(train_ds.draw_counts.values()) or 1 print("\nrealised training exposure (every window drawn during this run):") print(f" {'domain':<10} {'target':>8} {'windows':>12} {'actual':>9} {'delta':>9}") print(f" {'-' * 52}") worst = 0.0 for d in train_ds.domains: target_pp = train_ds.weight_of[d] * 100 actual_pp = train_ds.draw_counts[d] / drawn_total * 100 worst = max(worst, abs(actual_pp - target_pp)) print(f" {d:<10} {target_pp:>7.2f}% {train_ds.draw_counts[d]:>12,} " f"{actual_pp:>8.2f}% {actual_pp - target_pp:>+8.2f}pp") print(f" {'-' * 52}") print(f" windows drawn : {drawn_total:,}") check(f"run exposure within +/-{EXPOSURE_TOLERANCE_PP:.0f}pp", worst <= EXPOSURE_TOLERANCE_PP, f"worst {worst:.2f}pp") # val.bin must be byte-for-byte untouched check("val.bin not touched", file_stamp(VAL_BIN) == val_stamp_before, f"size+mtime unchanged ({VAL_BIN.name})") # ---------------- post-training tests ---------------- post_tests(device, model, cfg) print("\n" + "=" * 70) if _failures: print(f"RESULT: {len(_failures)} CHECK(S) FAILED -> {', '.join(_failures)}") print("=" * 70) return 1 print("RESULT: ALL CHECKS PASSED - balanced sampling verified, V1 pipeline " "is trainable and resumable.") print("Next: raise MAX_STEPS and set FRESH_RUN = False to continue from") print(f"{CKPT_PATH.name}. v1.pt (natural distribution) stays where it is.") print("=" * 70) return 0 if __name__ == "__main__": raise SystemExit(main())46:o9,11a:T677,46:o677,---------------- BALANCED SAMPLER ---------------- dataset dir : D:\DVLPER AI\data\v1_balanced val.bin : ...\val.bin (uniform, NEVER reweighted) balance mode : weighted duplicated tokens : 0 domain natural weight expected segments windows ---------------------------------------------------------------- code 21.26% 25.00% 25.00% ... ~2,4xx,xxx english 18.69% 25.00% 25.00% ... ~2,1xx,xxx hindi 14.92% 25.00% 25.00% ... ~1,7xx,xxx hinglish 45.14% 25.00% 25.00% ... ~5,2xx,xxx ---------------------------------------------------------------- expected exposure : code 25% english 25% hindi 25% hinglish 25% sampler smoke test: 1000 windows, seed=1337 domain target drawn actual delta ------------------------------------------------ code 25.00% 2xx 2x.xx% +x.xxpp english 25.00% 2xx 2x.xx% -x.xxpp hindi 25.00% 2xx 2x.xx% +x.xxpp hinglish 25.00% 2xx 2x.xx% -x.xxpp ------------------------------------------------ total drawn : 1,000 worst deviation : ~1-2 pp (tolerance +/-3 pp) [PASS] exposure within +/-3pp worst 1.xxpp over 1000 windows [PASS] windows inside their segment 1000 windows checked [PASS] no domain boundary crossed owner span == drawn domain [PASS] sampled window length 513 x=(2, 512) y=(2, 512) -> 512+1 tokens read [PASS] sampled ids in vocab range max id=1xxxx < 16000 [PASS] sampler deterministic @seed seed=133746:oa,11b:Tbee7,46:obee7,[V0_FILE]python:file="/src/train_v1.py" """ DVLPER AI - V1 TRAINING SCRIPT (BALANCED DATASET - diagnostic run) ================================================================= Trains the VERIFIED V1 model (src/model_v1.py) on the BALANCED V1 dataset (data/v1_balanced/) on an RTX 2050 4GB laptop GPU. WHAT CHANGED vs the natural-distribution run -------------------------------------------- The dataset root is now a switch (DATASET_DIR) pointing at data/v1_balanced. That build writes every token exactly ONCE (11,726,619 train tokens, 0 duplicated tokens) with the four domains laid out in contiguous spans, and it records a per-domain `sampling.weights` entry in dataset_meta.json. Balance is therefore NOT in the bytes - it is enforced at SAMPLING TIME by this file: code natural 21.26% -> sampled 25% english natural 18.69% -> sampled 25% hindi natural 14.92% -> sampled 25% hinglish natural 45.14% -> sampled 25% The old uniform "pick any start in train.bin" sampler CANNOT do that, and it would also happily straddle a domain boundary or a 512-token guard-band seam. It is replaced by WeightedDomainSampler: 1. pick a domain d with probability sampling.weights[d] 2. pick one of d's train_segments with probability proportional to its number of valid windows, max(0, len(segment) - (SEQ_LEN + 1) + 1) 3. pick a uniform start inside that segment so [start, start+SEQ_LEN+1) lies COMPLETELY inside the segment so no window ever crosses a domain span or a guard-band seam. VALIDATION IS UNCHANGED AND NEVER REWEIGHTED. val.bin is still read with a plain uniform sampler over the whole file, so val loss stays comparable with every earlier number. This file only ever opens val.bin read-only, and it re-verifies at exit that val.bin's size and mtime did not change. FRESH WEIGHTS, NEW CHECKPOINT NAMES ----------------------------------- checkpoints/v1.pt was trained on the OLD natural distribution. It is NOT resumed and is NOT opened. This run starts from fresh weights and writes to checkpoints/v1_balanced.pt (best val loss) checkpoints/v1_balanced_last.pt (latest state, every eval) v1.pt, v1_last.pt and every Nano checkpoint are in PROTECTED and asserted out of reach. This file ONLY reads: src/model_v1.py (imported, never modified) tokenizer/tokenizer.json (read-only, vocab + generation tests) data/v1_balanced/train.bin (numpy memmap, read-only) data/v1_balanced/val.bin (numpy memmap, read-only) data/v1_balanced/dataset_meta.json (read-only: weights + segments) This file ONLY writes: checkpoints/v1_balanced.pt checkpoints/v1_balanced_last.pt It never touches data/raw, data/cleaned, data/v1, data/nano, dataset_v1.py, dataset_v1_balanced.py, model_v1.py or the tokenizer. UNCHANGED SETTINGS (deliberately) --------------------------------- BATCH_SIZE = 2, SEQ_LEN = 512, GRAD_ACCUM_STEPS = 8 (8,192 tokens/opt step), AdamW(6e-4 -> 6e-5, warmup 100, cosine, wd 0.1, betas (0.9,0.95), clip 1.0), fp16 AMP + GradScaler, the forward/backward memory probe, the atomic ".tmp -> os.replace" checkpoint system. MAX_STEPS is 500: this first balanced run is a DIAGNOSTIC run to prove the sampler, not a throughput run. Run: python src\\train_v1.py """ from __future__ import annotations import json import math import os import sys import time from pathlib import Path import numpy as np import torch # --------------------------------------------------------------------------- # import the verified model (never modified) # --------------------------------------------------------------------------- sys.path.insert(0, str(Path(__file__).resolve().parent)) from model_v1 import ModelV1, V1Config, read_vocab_size # noqa: E402 # --------------------------------------------------------------------------- # paths - DATASET_DIR is the switch # --------------------------------------------------------------------------- PROJECT_ROOT = Path(__file__).resolve().parents[1] DATASET_DIR = "data/v1_balanced" # <- dataset root switch DATA_DIR = PROJECT_ROOT / DATASET_DIR TRAIN_BIN = DATA_DIR / "train.bin" VAL_BIN = DATA_DIR / "val.bin" META_JSON = DATA_DIR / "dataset_meta.json" TOKENIZER_JSON = PROJECT_ROOT / "tokenizer" / "tokenizer.json" CKPT_DIR = PROJECT_ROOT / "checkpoints" RUN_NAME = "v1_balanced" CKPT_PATH = CKPT_DIR / "v1_balanced.pt" # best val loss LAST_PATH = CKPT_DIR / "v1_balanced_last.pt" # latest state # Files this script must never target or open. Asserted, not just documented. PROTECTED = { "v1.pt", # trained on the OLD natural distribution "v1_last.pt", "nano.pt", "nano_last.pt", "nano_corrupt.pt", "nano_step800_backup.pt", "nano_v2.pt", "nano_v2_last.pt", } assert CKPT_PATH.name not in PROTECTED, "refusing to target a protected checkpoint" assert LAST_PATH.name not in PROTECTED, "refusing to target a protected checkpoint" # On resume prefer the latest state, fall back to the best checkpoint. # Both are balanced-run files; the natural-run files are never candidates. RESUME_CANDIDATES = (LAST_PATH, CKPT_PATH) assert all(p.name not in PROTECTED for p in RESUME_CANDIDATES) # --------------------------------------------------------------------------- # configuration - everything you will want to change lives here # --------------------------------------------------------------------------- FRESH_RUN = True # balanced data => fresh weights, never resume v1.pt ALLOW_FRESH_OVERWRITE = False # guard: FRESH_RUN over existing v1_balanced files SEED = 1337 SEQ_LEN = 512 # must be <= model block_size BATCH_SIZE = 2 # conservative for 4GB VRAM GRAD_ACCUM_STEPS = 8 # effective batch = 2 * 8 = 16 sequences MAX_STEPS = 500 # diagnostic run: verify balanced sampling first EVAL_INTERVAL = 50 VAL_BATCHES = 20 # 20 * BATCH_SIZE sequences per eval LOG_INTERVAL = 10 LEARNING_RATE = 6e-4 # peak LR (unchanged) MIN_LR = 6e-5 # cosine floor = peak / 10 WARMUP_STEPS = 100 WEIGHT_DECAY = 0.1 BETAS = (0.9, 0.95) GRAD_CLIP = 1.0 USE_AMP = True # fp16 autocast + GradScaler on CUDA only # balanced-sampling diagnostics SMOKE_WINDOWS = 1000 # windows drawn in the sampler smoke test EXPOSURE_TOLERANCE_PP = 3.0 # every domain must land within +/-3 pp of target # generation probes after the run GEN_PROMPTS = ["The ", "Bhai ", "भारत "] GEN_TOKENS = 40 GEN_TEMPERATURE = 0.8 GEN_TOP_K = 50 # --------------------------------------------------------------------------- # small helpers # --------------------------------------------------------------------------- _failures: list[str] = [] def check(label: str, ok: bool, detail: str = "") -> bool: print(f"[{'PASS' if ok else 'FAIL'}] {label:<34} {detail}") if not ok: _failures.append(label) return ok def human_bytes(n: float) -> str: for unit in ("B", "KB", "MB", "GB", "TB"): if n < 1024 or unit == "TB": return f"{n:.2f} {unit}" n /= 1024 return f"{n:.2f} TB" def ppl(loss: float) -> float: return math.exp(min(loss, 20.0)) def peak_vram_mb() -> float: if not torch.cuda.is_available(): return 0.0 return torch.cuda.max_memory_allocated() / (1024 ** 2) def reset_peak_vram() -> None: if torch.cuda.is_available(): torch.cuda.reset_peak_memory_stats() def file_stamp(path: Path) -> tuple: """(size, mtime_ns) - used to prove a file was not written to.""" if not path.is_file(): return (-1, -1) st = path.stat() return (st.st_size, st.st_mtime_ns) # --------------------------------------------------------------------------- # metadata # --------------------------------------------------------------------------- def load_meta() -> dict: if not META_JSON.is_file(): raise SystemExit( f"ERROR: {META_JSON} not found.\n" f"The balanced dataset must be built first:\n" f" python src\\dataset_v1_balanced.py\n" f"This script never builds or modifies a dataset." ) try: meta = json.loads(META_JSON.read_text(encoding="utf-8")) except Exception as e: raise SystemExit(f"ERROR: {META_JSON} is not readable JSON ({e}).") mode = meta.get("balance_mode") if mode != "weighted": raise SystemExit( f"ERROR: {META_JSON} reports balance_mode={mode!r}, expected 'weighted'.\n" f"This trainer balances by SAMPLING WEIGHTS. A 'physical' build already\n" f"carries its balance in the bytes and needs a uniform sampler instead.\n" f"Rebuild with: python src\\dataset_v1_balanced.py --mode weighted" ) sampling = meta.get("sampling") or {} if not isinstance(sampling.get("weights"), dict) or not sampling["weights"]: raise SystemExit( f"ERROR: {META_JSON} has no sampling.weights map. " f"Refusing to guess domain weights." ) if not sampling.get("restrict_windows_to_segments", False): raise SystemExit( f"ERROR: {META_JSON} does not set sampling.restrict_windows_to_segments. " f"Refusing to sample windows that may cross seams." ) if not isinstance(meta.get("domains"), dict) or not meta["domains"]: raise SystemExit(f"ERROR: {META_JSON} has no per-domain 'domains' block.") return meta # --------------------------------------------------------------------------- # data # --------------------------------------------------------------------------- class BinDataset: """ Read-only memmap over a uint16 token file, uniform windows over the whole file. Used for VALIDATION ONLY, exactly as before - val.bin is never reweighted and never domain-sampled, so val loss stays comparable across runs. A sample is a contiguous window of SEQ_LEN+1 tokens; x is the first SEQ_LEN tokens and y is that window shifted by one, so y[i] is the correct next-token target for x[i]. """ def __init__(self, path: Path, seq_len: int, seed: int) -> None: if not path.is_file(): raise SystemExit( f"ERROR: {path} not found.\n" f"The balanced V1 dataset must exist at {DATA_DIR}. " f"This script never rebuilds it." ) self.path = path self.seq_len = seq_len # mode="r" -> read-only mapping; the file can never be modified here. self.data = np.memmap(path, dtype=np.uint16, mode="r") self.n_tokens = int(self.data.shape[0]) if self.n_tokens < seq_len + 2: raise SystemExit(f"ERROR: {path} has only {self.n_tokens} tokens.") self.max_start = self.n_tokens - (seq_len + 1) self.rng = np.random.default_rng(seed) def batch(self, batch_size: int, device: torch.device): starts = self.rng.integers(0, self.max_start, size=batch_size, endpoint=True) return windows_to_batch(self.data, starts, self.seq_len, device) def reseed(self, seed: int) -> None: self.rng = np.random.default_rng(seed) def windows_to_batch(data, starts, seq_len: int, device: torch.device): """Copy each [start, start+seq_len+1) window and split into x / y.""" n = len(starts) xs = np.empty((n, seq_len), dtype=np.int64) ys = np.empty((n, seq_len), dtype=np.int64) for i, s in enumerate(starts): s = int(s) window = np.asarray(data[s: s + seq_len + 1], dtype=np.int64) xs[i] = window[:-1] ys[i] = window[1:] x = torch.from_numpy(xs) y = torch.from_numpy(ys) if device.type == "cuda": x = x.pin_memory().to(device, non_blocking=True) y = y.pin_memory().to(device, non_blocking=True) else: x, y = x.to(device), y.to(device) return x, y class WeightedDomainSampler: """ Domain-aware TRAIN sampler. train.bin holds every token exactly once, domains in contiguous spans, each span cut into seam-free `train_segments`. Balance is enforced here: 1. domain d ~ sampling.weights[d] 2. segment ~ proportional to that segment's valid-window count 3. start ~ uniform in [seg_start, seg_end - (SEQ_LEN+1)] so every window of SEQ_LEN+1 tokens lies wholly inside ONE segment of ONE domain: no domain boundary is crossed and no guard-band seam is crossed. Driven by a dedicated numpy Generator, so the stream is deterministic. """ def __init__(self, path: Path, seq_len: int, seed: int, meta: dict) -> None: if not path.is_file(): raise SystemExit( f"ERROR: {path} not found.\n" f"The balanced V1 dataset must exist at {DATA_DIR}. " f"This script never rebuilds it." ) self.path = path self.seq_len = seq_len self.window = seq_len + 1 self.data = np.memmap(path, dtype=np.uint16, mode="r") self.n_tokens = int(self.data.shape[0]) weights = meta["sampling"]["weights"] self.domains: list[str] = list(weights.keys()) # ---- per-domain segments, keeping only segments that fit a window ---- self.segments: dict[str, list[tuple[int, int]]] = {} self.spans: dict[str, tuple[int, int]] = {} self.seg_windows: dict[str, np.ndarray] = {} self.seg_probs: dict[str, np.ndarray] = {} self.total_windows: dict[str, int] = {} self.dropped_segments: dict[str, int] = {} for d in self.domains: info = meta["domains"].get(d) if not isinstance(info, dict): raise SystemExit(f"ERROR: domain {d!r} has no entry in dataset_meta.json.") span = info.get("train_span") raw = info.get("train_segments") if not (isinstance(span, (list, tuple)) and len(span) == 2): raise SystemExit(f"ERROR: domain {d!r} has no valid train_span.") if not isinstance(raw, list) or not raw: raise SystemExit(f"ERROR: domain {d!r} has no train_segments.") lo, hi = int(span[0]), int(span[1]) if not (0 <= lo <= hi <= self.n_tokens): raise SystemExit( f"ERROR: domain {d!r} train_span {span} is outside train.bin " f"({self.n_tokens:,} tokens)." ) self.spans[d] = (lo, hi) kept: list[tuple[int, int]] = [] counts: list[int] = [] dropped = 0 for seg in raw: s, e = int(seg[0]), int(seg[1]) if not (lo <= s <= e <= hi): raise SystemExit( f"ERROR: domain {d!r} segment {seg} escapes its span {span}." ) n_win = (e - s) - self.window + 1 if n_win <= 0: dropped += 1 continue kept.append((s, e)) counts.append(n_win) if not kept: raise SystemExit( f"ERROR: domain {d!r} has no segment long enough for a " f"{self.window}-token window. Refusing to silently drop a domain " f"or to let a window cross a seam." ) self.segments[d] = kept self.dropped_segments[d] = dropped arr = np.asarray(counts, dtype=np.int64) self.seg_windows[d] = arr self.seg_probs[d] = arr / arr.sum() self.total_windows[d] = int(arr.sum()) # ---- domain weights, normalised ---- w = np.asarray([float(weights[d]) for d in self.domains], dtype=np.float64) if (w < 0).any() or w.sum() <= 0: raise SystemExit(f"ERROR: invalid sampling.weights {weights}.") self.weights = w / w.sum() self.weight_of = {d: float(p) for d, p in zip(self.domains, self.weights)} self.rng = np.random.default_rng(seed) self.draw_counts: dict[str, int] = {d: 0 for d in self.domains} # -- sampling ---------------------------------------------------------- def sample_windows(self, n: int) -> tuple[list[int], list[str]]: """Return n window starts plus the domain each was drawn from.""" picks = self.rng.choice(len(self.domains), size=n, p=self.weights) starts: list[int] = [] doms: list[str] = [] for di in picks: d = self.domains[int(di)] segs = self.segments[d] si = int(self.rng.choice(len(segs), p=self.seg_probs[d])) s, e = segs[si] hi = e - self.window # inclusive upper bound start = int(self.rng.integers(s, hi, endpoint=True)) starts.append(start) doms.append(d) self.draw_counts[d] += 1 return starts, doms def batch(self, batch_size: int, device: torch.device): starts, doms = self.sample_windows(batch_size) self.last_starts = starts self.last_domains = doms return windows_to_batch(self.data, starts, self.seq_len, device) def reseed(self, seed: int) -> None: self.rng = np.random.default_rng(seed) def reset_counts(self) -> None: self.draw_counts = {d: 0 for d in self.domains} # -- helpers used by the correctness checks ---------------------------- def owner_of(self, start: int) -> str | None: """Which domain span contains this whole window, if any.""" for d, (lo, hi) in self.spans.items(): if lo <= start and start + self.window <= hi: return d return None def inside_a_segment(self, start: int, domain: str) -> bool: return any(s <= start and start + self.window <= e for s, e in self.segments[domain]) # --------------------------------------------------------------------------- # learning rate schedule (unchanged) # --------------------------------------------------------------------------- def lr_at(step: int) -> float: """Linear warmup for WARMUP_STEPS, then cosine decay to MIN_LR.""" if step < WARMUP_STEPS: return LEARNING_RATE * (step + 1) / max(1, WARMUP_STEPS) if step >= MAX_STEPS: return MIN_LR progress = (step - WARMUP_STEPS) / max(1, MAX_STEPS - WARMUP_STEPS) coeff = 0.5 * (1.0 + math.cos(math.pi * progress)) return MIN_LR + coeff * (LEARNING_RATE - MIN_LR) # --------------------------------------------------------------------------- # checkpointing (atomic, unchanged mechanism - new names only) # --------------------------------------------------------------------------- def hyperparams(sampler: WeightedDomainSampler | None = None) -> dict: hp = { "seed": SEED, "seq_len": SEQ_LEN, "batch_size": BATCH_SIZE, "grad_accum_steps": GRAD_ACCUM_STEPS, "effective_batch": BATCH_SIZE * GRAD_ACCUM_STEPS, "tokens_per_step": BATCH_SIZE * GRAD_ACCUM_STEPS * SEQ_LEN, "max_steps": MAX_STEPS, "learning_rate": LEARNING_RATE, "min_lr": MIN_LR, "warmup_steps": WARMUP_STEPS, "weight_decay": WEIGHT_DECAY, "betas": list(BETAS), "grad_clip": GRAD_CLIP, "eval_interval": EVAL_INTERVAL, "val_batches": VAL_BATCHES, "amp": USE_AMP, "dataset_dir": DATASET_DIR, "train_sampler": "weighted-domain (segment-bounded)", "val_sampler": "uniform over val.bin (never reweighted)", } if sampler is not None: hp["domain_weights"] = {d: round(sampler.weight_of[d], 8) for d in sampler.domains} return hp def tokenizer_fingerprint(path: Path = TOKENIZER_JSON) -> dict: """Cheap identity of the tokenizer file so a checkpoint can be traced.""" info = {"path": str(path), "exists": path.is_file()} if path.is_file(): st = path.stat() info["size_bytes"] = st.st_size info["mtime"] = int(st.st_mtime) try: import hashlib h = hashlib.sha256() with open(path, "rb") as f: for chunk in iter(lambda: f.read(1 << 20), b""): h.update(chunk) info["sha256"] = h.hexdigest()[:16] except Exception: pass return info def save_checkpoint( path: Path, model: ModelV1, cfg: V1Config, opt: torch.optim.Optimizer, scaler, step: int, val_loss: float, best_val: float, fingerprint: dict, sampler: WeightedDomainSampler, ) -> None: """ Write to .tmp then os.replace() onto the target. os.replace is atomic on Windows and POSIX, so a crash mid-write can never leave a half checkpoint at the real path. """ assert path.name not in PROTECTED, f"refusing to write {path.name}" tmp = path.with_name(path.name + ".tmp") payload = { "run": RUN_NAME, "format_version": 1, "model": model.state_dict(), "optimizer": opt.state_dict(), "scaler": scaler.state_dict(), "step": int(step), "val_loss": float(val_loss), "best_val_loss": float(best_val), "config": vars(cfg).copy(), "vocab_size": int(cfg.vocab_size), "tokenizer": fingerprint, "hyperparams": hyperparams(sampler), "dataset": { "dir": DATASET_DIR, "train_bin": str(TRAIN_BIN), "val_bin": str(VAL_BIN), "balance_mode": "weighted", "domain_weights": {d: round(sampler.weight_of[d], 8) for d in sampler.domains}, }, "torch_version": torch.__version__, "saved_at": time.strftime("%Y-%m-%d %H:%M:%S"), } torch.save(payload, tmp) os.replace(tmp, path) def find_resume() -> Path | None: for p in RESUME_CANDIDATES: if p.is_file(): return p return None def load_checkpoint(path: Path, device: torch.device) -> dict: """ Load a balanced-run checkpoint. A corrupt file is a hard error - we never silently fall back to step 0 when a checkpoint for this run exists. """ if path.name in PROTECTED: raise SystemExit( f"ERROR: refusing to open protected checkpoint {path.name}. " f"It belongs to the old natural-distribution run." ) try: # our own local file -> weights_only=False is intentional ckpt = torch.load(path, map_location=device, weights_only=False) except Exception as e: raise SystemExit( f"ERROR: {path} exists but could not be loaded ({e}).\n" f" -> Try the other file ({', '.join(p.name for p in RESUME_CANDIDATES)}).\n" f" -> Refusing to silently restart at step 0.\n" f" -> If you really want to discard it, set FRESH_RUN = True and\n" f" ALLOW_FRESH_OVERWRITE = True." ) if not isinstance(ckpt, dict) or "model" not in ckpt or "step" not in ckpt: raise SystemExit( f"ERROR: {path} loaded but is not a valid checkpoint " f"(missing 'model' / 'step'). Refusing to restart at step 0." ) if ckpt.get("run") != RUN_NAME: raise SystemExit( f"ERROR: {path} belongs to run '{ckpt.get('run')}', not '{RUN_NAME}'. " f"Refusing to load a foreign checkpoint (the balanced run must not " f"inherit natural-distribution weights)." ) return ckpt # --------------------------------------------------------------------------- # evaluation - val.bin, uniform, never reweighted # --------------------------------------------------------------------------- @torch.no_grad() def evaluate(model: ModelV1, ds: BinDataset, batches: int, device: torch.device, use_amp: bool, seed: int) -> float: """Fixed-seed eval so val loss is comparable across steps AND across runs.""" was_training = model.training model.eval() ds.reseed(seed) total = 0.0 for _ in range(batches): x, y = ds.batch(BATCH_SIZE, device) with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp): _, loss = model(x, y) total += loss.item() del x, y if was_training: model.train() return total / max(1, batches) # --------------------------------------------------------------------------- # balanced-sampling diagnostics + correctness # --------------------------------------------------------------------------- def sampler_report(sampler: WeightedDomainSampler, meta: dict) -> None: print("\n---------------- BALANCED SAMPLER ----------------") print(f"dataset dir : {DATA_DIR}") print(f"train.bin : {TRAIN_BIN}") print(f"val.bin : {VAL_BIN} (uniform, NEVER reweighted)") print(f"meta : {META_JSON}") print(f"balance mode : {meta.get('balance_mode')}") print(f"duplicated tokens : " f"{meta.get('duplicated_train_tokens', sum(i.get('duplicated_train_tokens', 0) for i in meta['domains'].values())):,}") print() print(f" {'domain':<10} {'natural':>9} {'weight':>9} {'expected':>9} " f"{'segments':>9} {'windows':>14}") print(f" {'-' * 64}") for d in sampler.domains: info = meta["domains"].get(d, {}) nat = info.get("natural_train_share_pct") nat_s = f"{nat:.2f}%" if isinstance(nat, (int, float)) else "?" print(f" {d:<10} {nat_s:>9} {sampler.weight_of[d] * 100:>8.2f}% " f"{sampler.weight_of[d] * 100:>8.2f}% " f"{len(sampler.segments[d]):>9,} {sampler.total_windows[d]:>14,}") print(f" {'-' * 64}") exp = " ".join(f"{d} {sampler.weight_of[d] * 100:.0f}%" for d in sampler.domains) print(f" expected exposure : {exp}") dropped = sum(sampler.dropped_segments.values()) print(f" segments too short for a {sampler.window}-token window, skipped: {dropped}") def sampler_smoke_test(sampler: WeightedDomainSampler, cfg: V1Config, device: torch.device) -> None: """ Draw SMOKE_WINDOWS windows and prove: exposure hits the weights, every window is 513 tokens, ids are in vocab range, and no window leaves its chosen segment. Uses a THROWAWAY sampler so the training stream is not consumed. """ print(f"\nsampler smoke test: {SMOKE_WINDOWS} windows, seed={SEED}") probe = WeightedDomainSampler(TRAIN_BIN, SEQ_LEN, SEED, _META) starts, doms = probe.sample_windows(SMOKE_WINDOWS) counts = {d: 0 for d in probe.domains} for d in doms: counts[d] += 1 print(f" {'domain':<10} {'target':>8} {'drawn':>8} {'actual':>9} {'delta':>9}") print(f" {'-' * 48}") worst = 0.0 for d in probe.domains: target_pp = probe.weight_of[d] * 100 actual_pp = counts[d] / SMOKE_WINDOWS * 100 delta = actual_pp - target_pp worst = max(worst, abs(delta)) print(f" {d:<10} {target_pp:>7.2f}% {counts[d]:>8,} " f"{actual_pp:>8.2f}% {delta:>+8.2f}pp") print(f" {'-' * 48}") print(f" total drawn : {sum(counts.values()):,}") print(f" worst deviation : {worst:.2f} pp (tolerance +/-{EXPOSURE_TOLERANCE_PP:.0f} pp)") check(f"exposure within +/-{EXPOSURE_TOLERANCE_PP:.0f}pp", worst <= EXPOSURE_TOLERANCE_PP, f"worst {worst:.2f}pp over {SMOKE_WINDOWS} windows") # every window sits inside the segment it was drawn from, and inside that # domain's span -> no domain boundary and no guard-band seam is crossed seg_ok = all(probe.inside_a_segment(s, d) for s, d in zip(starts, doms)) check("windows inside their segment", seg_ok, f"{SMOKE_WINDOWS} windows checked") span_ok = all(probe.owner_of(s) == d for s, d in zip(starts, doms)) check("no domain boundary crossed", span_ok, "owner span == drawn domain") # window length + id range, verified on real tensors x, y = probe.batch(BATCH_SIZE, device) len_ok = x.shape[1] == SEQ_LEN and y.shape[1] == SEQ_LEN check("sampled window length 513", len_ok, f"x={tuple(x.shape)} y={tuple(y.shape)} -> {SEQ_LEN}+1 tokens read") ids_ok = bool(x.min() >= 0 and x.max() < cfg.vocab_size and y.max() < cfg.vocab_size) check("sampled ids in vocab range", ids_ok, f"max id={int(max(x.max().item(), y.max().item()))} < {cfg.vocab_size}") del x, y # determinism: a second throwaway sampler at the same seed must agree twin = WeightedDomainSampler(TRAIN_BIN, SEQ_LEN, SEED, _META) s2, d2 = twin.sample_windows(SMOKE_WINDOWS) check("sampler deterministic @seed", starts == s2 and doms == d2, f"seed={SEED}") del probe, twin # --------------------------------------------------------------------------- # pre-training correctness + memory tests # --------------------------------------------------------------------------- def pretraining_tests(model: ModelV1, cfg: V1Config, train_ds: WeightedDomainSampler, device: torch.device, use_amp: bool) -> None: print("\n---------------- PRE-TRAINING TESTS ----------------") # TEST 1 - next-token shift. y must equal x shifted left by one. train_ds.reseed(SEED) x, y = train_ds.batch(BATCH_SIZE, device) shift_ok = bool(torch.equal(x[:, 1:], y[:, :-1])) check("next-token shift", shift_ok, "y[:, :-1] == x[:, 1:]") ids_ok = bool((x.min() >= 0) and (x.max() < cfg.vocab_size) and (y.max() < cfg.vocab_size)) check("token ids in vocab range", ids_ok, f"max id={int(max(x.max().item(), y.max().item()))} < {cfg.vocab_size}") # the batch we just drew must also respect the segment bounds batch_seg_ok = all(train_ds.inside_a_segment(s, d) for s, d in zip(train_ds.last_starts, train_ds.last_domains)) check("train batch inside segments", batch_seg_ok, f"domains={train_ds.last_domains}") # determinism of the loader under the seed train_ds.reseed(SEED) x2, y2 = train_ds.batch(BATCH_SIZE, device) check("loader deterministic @seed", bool(torch.equal(x, x2) and torch.equal(y, y2)), f"seed={SEED}") # TEST 2 - logits shape and random-init loss near ln(V) model.eval() with torch.no_grad(): logits, loss = model(x, y) check("logits shape", tuple(logits.shape) == (BATCH_SIZE, SEQ_LEN, cfg.vocab_size), f"{tuple(logits.shape)}") baseline = math.log(cfg.vocab_size) check("init loss ~= ln(V)", abs(loss.item() - baseline) < 0.5, f"loss={loss.item():.4f} ln(V)={baseline:.4f}") del logits, loss # TEST 3 - causal behaviour: changing token t must not move logits < t probe = x[:1, :64].clone() with torch.no_grad(): base, _ = model(probe) tampered = probe.clone() tampered[0, 40] = (int(tampered[0, 40].item()) + 7919) % cfg.vocab_size tamp, _ = model(tampered) past = (base[0, :40] - tamp[0, :40]).abs().max().item() future = (base[0, 40:] - tamp[0, 40:]).abs().max().item() check("causal behaviour", past < 1e-4 and future > 1e-6, f"past={past:.2e} future={future:.2e}") del base, tamp, probe, tampered # TEST 4 - forward + backward memory probe at the CONFIGURED batch size. # Uses the real model but zeroes the gradients afterwards, so no weight is # ever updated by this test. BATCH_SIZE is never changed automatically. print("\nmemory probe: 1 forward + 1 backward at the configured batch size") model.train() reset_peak_vram() probe_scaler = torch.amp.GradScaler("cuda", enabled=use_amp) try: with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp): _, probe_loss = model(x, y) probe_scaler.scale(probe_loss).backward() except torch.cuda.OutOfMemoryError as e: print("\n" + "=" * 70) print("CUDA OUT OF MEMORY during the forward/backward probe.") print("=" * 70) print(f" batch_size = {BATCH_SIZE}, seq_len = {SEQ_LEN}") print(f" peak allocated before failure: {peak_vram_mb():.1f} MB") print("\n Training was NOT started. Nothing was written to disk.") print(" This script will NOT change the architecture and will NOT") print(" silently reduce your settings. Lower BATCH_SIZE (2 -> 1) or") print(" raise GRAD_ACCUM_STEPS to keep the effective batch, then rerun.") print(f"\n torch reports: {e}") raise SystemExit(2) probe_peak = peak_vram_mb() model.zero_grad(set_to_none=True) # discard the probe gradients del probe_loss, probe_scaler, x, y, x2, y2 if torch.cuda.is_available(): torch.cuda.empty_cache() print(f" peak VRAM (fwd+bwd) : {probe_peak:.1f} MB" f"{' of ' + f'{torch.cuda.get_device_properties(0).total_memory / 1024 ** 2:.0f} MB' if torch.cuda.is_available() else ''}") check("forward/backward fits", True, f"peak {probe_peak:.1f} MB, no OOM") if _failures: raise SystemExit( "\nABORTING: pre-training tests failed: " + ", ".join(_failures) ) print("\nall pre-training tests passed.") reset_peak_vram() # --------------------------------------------------------------------------- # post-training checkpoint + generation tests # --------------------------------------------------------------------------- def post_tests(device: torch.device, model: ModelV1, cfg: V1Config) -> None: print("\n---------------- CHECKPOINT + GENERATION TESTS ----------------") reload_path = CKPT_PATH if CKPT_PATH.is_file() else LAST_PATH if not reload_path.is_file(): check("checkpoint exists", False, f"no {CKPT_PATH.name} / {LAST_PATH.name} written") return ckpt = load_checkpoint(reload_path, device) print(f"reloaded : {reload_path}") check("checkpoint step present", isinstance(ckpt.get("step"), int), f"step={ckpt.get('step')}") check("optimizer state present", isinstance(ckpt.get("optimizer"), dict) and "state" in ckpt["optimizer"] and "param_groups" in ckpt["optimizer"], f"keys={sorted(ckpt.get('optimizer', {}).keys())}") check("scaler state present", isinstance(ckpt.get("scaler"), dict), f"keys={sorted(ckpt.get('scaler', {}).keys())}") check("config + hyperparams present", isinstance(ckpt.get("config"), dict) and isinstance(ckpt.get("hyperparams"), dict), f"vocab_size={ckpt.get('vocab_size')}") check("dataset recorded in ckpt", (ckpt.get("dataset") or {}).get("dir") == DATASET_DIR, f"dir={(ckpt.get('dataset') or {}).get('dir')}") # state_dict round-trip into a FRESH model - the live model is untouched fresh = ModelV1(V1Config(**ckpt["config"])).to(device) fresh.load_state_dict(ckpt["model"], strict=True) same = all( torch.equal(a.detach().float().cpu(), b.detach().float().cpu()) for a, b in zip(fresh.state_dict().values(), ckpt["model"].values()) ) check("state_dict round-trip", same, "all tensors identical after reload") # generation probes with the existing tokenizer try: from tokenizers import Tokenizer except ImportError: print("\n(skipping generation: `pip install tokenizers`)") return if not TOKENIZER_JSON.is_file(): print(f"\n(skipping generation: tokenizer not found at {TOKENIZER_JSON})") return tok = Tokenizer.from_file(str(TOKENIZER_JSON)) fresh.eval() torch.manual_seed(SEED) print(f"\ngeneration probes ({GEN_TOKENS} tokens, temp={GEN_TEMPERATURE}, " f"top_k={GEN_TOP_K}) - quality is NOT expected at 500 steps:") for prompt in GEN_PROMPTS: ids = tok.encode(prompt).ids if not ids: ids = [0] idx = torch.tensor([ids], dtype=torch.long, device=device) out = fresh.generate(idx, max_new_tokens=GEN_TOKENS, temperature=GEN_TEMPERATURE, top_k=GEN_TOP_K) text = tok.decode(out[0].tolist()) print(f" {prompt!r} -> {text!r}") del fresh # --------------------------------------------------------------------------- # main # --------------------------------------------------------------------------- _META: dict = {} def main() -> int: global _META torch.manual_seed(SEED) np.random.seed(SEED) if torch.cuda.is_available(): torch.cuda.manual_seed_all(SEED) torch.backends.cuda.matmul.allow_tf32 = True torch.backends.cudnn.allow_tf32 = True device = torch.device("cuda" if torch.cuda.is_available() else "cpu") use_amp = bool(USE_AMP and device.type == "cuda") if SEQ_LEN > 512: raise SystemExit("ERROR: SEQ_LEN must be <= the model block_size (512).") CKPT_DIR.mkdir(parents=True, exist_ok=True) # ---------------- checkpoint policy ---------------- existing = [p.name for p in (CKPT_PATH, LAST_PATH) if p.is_file()] resume_path = None if FRESH_RUN: if existing and not ALLOW_FRESH_OVERWRITE: raise SystemExit( f"REFUSING TO START: FRESH_RUN=True but these balanced checkpoints " f"already exist: {', '.join(existing)}.\n" f" -> To CONTINUE that run, set FRESH_RUN = False.\n" f" -> To overwrite it on purpose, set ALLOW_FRESH_OVERWRITE = True." ) else: resume_path = find_resume() if resume_path is None: raise SystemExit( f"ERROR: FRESH_RUN=False but no balanced checkpoint was found in " f"{CKPT_DIR}.\n" f"Expected {CKPT_PATH.name} or {LAST_PATH.name}. " f"v1.pt / v1_last.pt (natural distribution) are never used here.\n" f"Set FRESH_RUN = True to start the balanced run." ) # ---------------- metadata + data ---------------- _META = load_meta() meta = _META vocab_size = read_vocab_size() cfg = V1Config(vocab_size=vocab_size, block_size=512) model = ModelV1(cfg).to(device) fingerprint = tokenizer_fingerprint() train_ds = WeightedDomainSampler(TRAIN_BIN, SEQ_LEN, SEED, meta) val_ds = BinDataset(VAL_BIN, SEQ_LEN, SEED + 1) val_stamp_before = file_stamp(VAL_BIN) # proof val.bin is never written meta_vocab = meta.get("vocab_size") if isinstance(meta_vocab, int) and meta_vocab != cfg.vocab_size: raise SystemExit( f"ERROR: dataset_meta vocab_size={meta_vocab} but tokenizer reports " f"{cfg.vocab_size}. Refusing to train on mismatched data." ) # ---------------- startup report ---------------- eff_batch = BATCH_SIZE * GRAD_ACCUM_STEPS tokens_per_step = eff_batch * SEQ_LEN print("=" * 70) print("DVLPER AI - V1 TRAINING (BALANCED DATA, DIAGNOSTIC RUN)") print("=" * 70) print(f"device : {device}") if device.type == "cuda": props = torch.cuda.get_device_properties(0) print(f"gpu : {props.name}") print(f"total VRAM : {props.total_memory / 1024 ** 3:.2f} GB") else: print("gpu : none (CPU - this will be very slow)") print(f"torch : {torch.__version__}") print(f"amp : {'fp16 autocast + GradScaler' if use_amp else 'disabled'}") print() print(f"vocab size : {cfg.vocab_size:,}") print(f"parameters : {model.num_parameters():,} " f"({model.num_parameters(non_embedding=True):,} non-embedding)") print(f"layers / d_model : {cfg.n_layers} / {cfg.d_model} " f"({cfg.n_heads} heads x {cfg.head_dim})") print() print(f"dataset dir : {DATASET_DIR}") print(f"train.bin : {train_ds.n_tokens:,} tokens " f"({human_bytes(TRAIN_BIN.stat().st_size)}, memmap)") print(f"val.bin : {val_ds.n_tokens:,} tokens " f"({human_bytes(VAL_BIN.stat().st_size)}, memmap, uniform sampling)") print(f"dataset_meta : vocab={meta.get('vocab_size', '?')} " f"dtype={meta.get('dtype', '?')} mode={meta.get('balance_mode', '?')}") print() print(f"batch size : {BATCH_SIZE}") print(f"sequence length : {SEQ_LEN}") print(f"grad accumulation : {GRAD_ACCUM_STEPS}") print(f"effective batch : {eff_batch} sequences") print(f"tokens / opt step : {tokens_per_step:,}") print(f"MAX_STEPS : {MAX_STEPS} " f"({MAX_STEPS * tokens_per_step:,} tokens total, " f"{MAX_STEPS * tokens_per_step / train_ds.n_tokens:.2f} epochs)") print(f"learning rate : {LEARNING_RATE:.2e} -> {MIN_LR:.2e} " f"(warmup {WARMUP_STEPS}, cosine)") print(f"weight decay : {WEIGHT_DECAY} betas {BETAS} clip {GRAD_CLIP}") print(f"eval : every {EVAL_INTERVAL} steps, {VAL_BATCHES} val batches") print() print(f"run : {RUN_NAME}") print(f"fresh weights : {FRESH_RUN} (v1.pt is NOT resumed and NOT opened)") print(f"best checkpoint : {CKPT_PATH}") print(f"last checkpoint : {LAST_PATH}") print(f"protected files : untouched ({', '.join(sorted(PROTECTED))})") print(f"random-init loss : ln({cfg.vocab_size}) = {math.log(cfg.vocab_size):.4f}") # ---------------- balanced sampler diagnostics ---------------- sampler_report(train_ds, meta) sampler_smoke_test(train_ds, cfg, device) if _failures: raise SystemExit( "\nABORTING before training: sampler checks failed: " + ", ".join(_failures) ) # ---------------- pre-training tests ---------------- pretraining_tests(model, cfg, train_ds, device, use_amp) # ---------------- optimizer (unchanged) ---------------- decay, no_decay = [], [] for name, p in model.named_parameters(): if not p.requires_grad: continue # weight decay only on 2D matrices; norms/embedding scales stay free (decay if p.dim() >= 2 else no_decay).append(p) opt = torch.optim.AdamW( [ {"params": decay, "weight_decay": WEIGHT_DECAY}, {"params": no_decay, "weight_decay": 0.0}, ], lr=LEARNING_RATE, betas=BETAS, ) scaler = torch.amp.GradScaler("cuda", enabled=use_amp) start_step, best_val = 0, float("inf") if resume_path is not None: ckpt = load_checkpoint(resume_path, device) model.load_state_dict(ckpt["model"], strict=True) opt_restored = scaler_restored = False if isinstance(ckpt.get("optimizer"), dict): opt.load_state_dict(ckpt["optimizer"]) opt_restored = True if isinstance(ckpt.get("scaler"), dict) and use_amp: scaler.load_state_dict(ckpt["scaler"]) scaler_restored = True start_step = int(ckpt["step"]) best_val = float(ckpt.get("best_val_loss", float("inf"))) # keep the data stream from replaying the same windows train_ds.reseed(SEED + start_step) print("\n---------------- RESUME ----------------") print(f"resumed from : {resume_path}") print(f"start step : {start_step} -> {MAX_STEPS} " f"({max(0, MAX_STEPS - start_step)} to go)") print(f"best val : {best_val:.4f}") print(f"optimizer : {'restored' if opt_restored else 'FRESH (absent)'}") print(f"grad scaler : {'restored' if scaler_restored else 'fresh'}") if start_step >= MAX_STEPS: print("\nnothing to do: start step already >= MAX_STEPS. " "Raise MAX_STEPS to continue.") post_tests(device, model, cfg) return 0 else: train_ds.reseed(SEED) print("\nfresh weights: starting at step 0 on the BALANCED distribution " "(v1.pt was never opened).") # ---------------- training ---------------- print("\n---------------- TRAINING ----------------") print(f"{'step':>6} {'lr':>10} {'train':>8} {'val':>8} {'ppl':>10} " f"{'elapsed':>9} {'it/s':>7} {'peakVRAM':>10}") model.train() reset_peak_vram() train_ds.reset_counts() t0 = time.time() running = [] step = start_step while step < MAX_STEPS: lr = lr_at(step) for group in opt.param_groups: group["lr"] = lr opt.zero_grad(set_to_none=True) accum_loss = 0.0 for micro in range(GRAD_ACCUM_STEPS): x, y = train_ds.batch(BATCH_SIZE, device) with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp): _, loss = model(x, y) loss = loss / GRAD_ACCUM_STEPS scaler.scale(loss).backward() accum_loss += loss.item() del x, y, loss scaler.unscale_(opt) torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP) scaler.step(opt) scaler.update() step += 1 running.append(accum_loss) if step % LOG_INTERVAL == 0 and step % EVAL_INTERVAL != 0: el = time.time() - t0 done = step - start_step print(f"{step:>6} {lr:>10.3e} {accum_loss:>8.4f} {'-':>8} " f"{ppl(accum_loss):>10.1f} {el:>8.1f}s {done / max(el, 1e-9):>7.2f} " f"{peak_vram_mb():>9.1f}M") if step % EVAL_INTERVAL == 0 or step >= MAX_STEPS: train_loss = sum(running) / max(1, len(running)) running = [] val_loss = evaluate(model, val_ds, VAL_BATCHES, device, use_amp, SEED + 1) el = time.time() - t0 done = step - start_step print(f"{step:>6} {lr:>10.3e} {train_loss:>8.4f} {val_loss:>8.4f} " f"{ppl(val_loss):>10.1f} {el:>8.1f}s {done / max(el, 1e-9):>7.2f} " f"{peak_vram_mb():>9.1f}M") is_best = val_loss < best_val if is_best: best_val = val_loss # latest state every eval, best only when beaten save_checkpoint(LAST_PATH, model, cfg, opt, scaler, step, val_loss, best_val, fingerprint, train_ds) if is_best: save_checkpoint(CKPT_PATH, model, cfg, opt, scaler, step, val_loss, best_val, fingerprint, train_ds) print(f" -> new best val {best_val:.4f}, wrote {CKPT_PATH.name}") total = time.time() - t0 print(f"\ntrain time : {total:.1f}s " f"({(MAX_STEPS - start_step) / max(total, 1e-9):.2f} steps/s)") print(f"best val loss : {best_val:.4f} (ppl {ppl(best_val):.1f})") print(f"peak VRAM : {peak_vram_mb():.1f} MB") print(f"best ckpt : {CKPT_PATH}") print(f"last ckpt : {LAST_PATH}") # ---------------- realised exposure over the whole run ---------------- drawn_total = sum(train_ds.draw_counts.values()) or 1 print("\nrealised training exposure (every window drawn during this run):") print(f" {'domain':<10} {'target':>8} {'windows':>12} {'actual':>9} {'delta':>9}") print(f" {'-' * 52}") worst = 0.0 for d in train_ds.domains: target_pp = train_ds.weight_of[d] * 100 actual_pp = train_ds.draw_counts[d] / drawn_total * 100 worst = max(worst, abs(actual_pp - target_pp)) print(f" {d:<10} {target_pp:>7.2f}% {train_ds.draw_counts[d]:>12,} " f"{actual_pp:>8.2f}% {actual_pp - target_pp:>+8.2f}pp") print(f" {'-' * 52}") print(f" windows drawn : {drawn_total:,}") check(f"run exposure within +/-{EXPOSURE_TOLERANCE_PP:.0f}pp", worst <= EXPOSURE_TOLERANCE_PP, f"worst {worst:.2f}pp") # val.bin must be byte-for-byte untouched check("val.bin not touched", file_stamp(VAL_BIN) == val_stamp_before, f"size+mtime unchanged ({VAL_BIN.name})") # ---------------- post-training tests ---------------- post_tests(device, model, cfg) print("\n" + "=" * 70) if _failures: print(f"RESULT: {len(_failures)} CHECK(S) FAILED -> {', '.join(_failures)}") print("=" * 70) return 1 print("RESULT: ALL CHECKS PASSED - balanced sampling verified, V1 pipeline " "is trainable and resumable.") print("Next: raise MAX_STEPS and set FRESH_RUN = False to continue from") print(f"{CKPT_PATH.name}. v1.pt (natural distribution) stays where it is.") print("=" * 70) return 0 if __name__ == "__main__": raise SystemExit(main())46:oa171,f4:["$","$Lf6",null,{"params":{"chatId":"JYNFarW33aQ"},"promises":{"attributes":"$@100","externalMeta":"$@101","latest":"$@102","messagesRange":"$@103","messages":"$@104","template":"$@105","gitStatus":"$@106"},"children":["$","$L108",null,{"chatId":"JYNFarW33aQ","children":["$","$L109",null,{"seedOnlyKeys":["@\"chat:state\",\"JYNFarW33aQ\","],"data":{"block:output:initial":{"id":"b_TeOMPUxUHnK","result":"$@10a"},"/chat/api/snapshots/proxy?chatId=JYNFarW33aQ&messageId=3RUP9dQVGJaRE7TggFKBHA9TyX85LN3m&v=v2":"$@10b","@\"block:mappings\",\"JYNFarW33aQ\",":{"sqlBlockExecutionStates":"$Q10c","blocksForkedFrom":"$Q10d","blocksTemplateIds":"$Q10e","blocksCreatedAt":"$Q10f","blocksShared":"$Q110","blocksDeployed":"$Q111","blocksSubdomains":"$Q112","brandedBlocks":"$Q113","unlistedBlocks":"$Q114","blockOutputs":"$Q115"},"@\"chat:state\",\"JYNFarW33aQ\",":{"messages":[{"content":{"type":"parts","parts":[],"version":1},"role":"user","id":"alFpNA5aLur3GjfvJlFHBTxKwHXcIMhu","type":"message","isContentLoading":true,"authorId":"","createdAt":"$D2026-08-15T10:06:43.751Z"},{"content":{"type":"message-binary-format","value":[[0,[["p",{},["text",{},"Loading..."]]]],[1,{"title":"Loading message"}]]},"loadingBlocks":[{"blockId":"6INrSBBXYWQ","type":"code-project","isVersioned":true}],"isContentLoading":true,"role":"assistant","id":"1ZzMfMOPaYarYqLE13GjLAzd0IqVvpqQ","gitRevision":null,"streaming":false,"finishReason":"stop","parentId":"alFpNA5aLur3GjfvJlFHBTxKwHXcIMhu","type":"message","createdAt":"$D2026-08-15T10:06:44.751Z"},{"content":{"type":"parts","parts":[],"version":1},"role":"user","id":"QQiQsHpKd6LRxSrA7MafqUe1j8rTXtYz","parentId":"1ZzMfMOPaYarYqLE13GjLAzd0IqVvpqQ","type":"message","isContentLoading":true,"authorId":"","createdAt":"$D2026-08-15T10:07:39.265Z"},{"content":{"type":"message-binary-format","value":[[0,[["p",{},["text",{},"Loading..."]]]],[1,{"title":"Loading message"}]]},"loadingBlocks":[{"blockId":"b_eKqB2ZhWhKA","type":"code-project","isVersioned":true}],"isContentLoading":true,"role":"assistant","id":"tm9gUJmwrMxMM7DOOTYgL1U6DkuKHAFJ","gitRevision":{"baseSha":"053c92940ac991681a73b14777f2d91325d9ff7e","headSha":"772d9f2b858849be4c488c2ffa16443446ba9c19","readyAt":"2026-08-15T10:10:57.126Z","version":1,"commitMessage":"feat: add new V1 training script for initial diagnostic run"},"streaming":false,"finishReason":"stop","parentId":"QQiQsHpKd6LRxSrA7MafqUe1j8rTXtYz","type":"message","createdAt":"$D2026-08-15T10:07:39.266Z"},{"content":{"type":"parts","parts":[],"version":1},"role":"user","id":"Y5suaeIprq2OBSFw9s827RDlrBuNVpsF","parentId":"tm9gUJmwrMxMM7DOOTYgL1U6DkuKHAFJ","type":"message","isContentLoading":true,"authorId":"","createdAt":"$D2026-08-15T10:24:04.434Z"},{"content":{"type":"message-binary-format","value":[[0,[["p",{},["text",{},"Loading..."]]]],[1,{"title":"Loading message"}]]},"loadingBlocks":[{"blockId":"b_mVSYoxglm0R","type":"code-project","isVersioned":false},{"blockId":"b_Epc01tvAzHS","type":"code-project","isVersioned":true}],"isContentLoading":true,"role":"assistant","id":"TiyILo4Z6fseNHTkNGeAXiPEJdwcnH7A","gitRevision":{"baseSha":"772d9f2b858849be4c488c2ffa16443446ba9c19","headSha":"46a6bf79dc26a4a365f29c44639ed9a6824ba9a8","readyAt":"2026-08-15T10:24:29.386Z","version":1,"commitMessage":"feat: enable model training resumption from step 500 checkpoint"},"streaming":false,"finishReason":"stop","parentId":"Y5suaeIprq2OBSFw9s827RDlrBuNVpsF","type":"message","createdAt":"$D2026-08-15T10:24:04.435Z"},{"content":{"type":"parts","parts":[],"version":1},"role":"user","id":"DGM45EI3yZnQLyPYessruhOSqa5tHXdO","parentId":"TiyILo4Z6fseNHTkNGeAXiPEJdwcnH7A","type":"message","isContentLoading":true,"authorId":"","createdAt":"$D2026-08-15T11:17:08.796Z"},{"content":{"type":"message-binary-format","value":[[0,[["p",{},["text",{},"Loading..."]]]],[1,{"title":"Loading message"}]]},"loadingBlocks":[{"blockId":"b_9WjMbiJRBtY","type":"code-project","isVersioned":true}],"isContentLoading":true,"role":"assistant","id":"TsNX5eHA958vlg5CgrXUnX9d2ZqJOqS4","gitRevision":{"baseSha":"46a6bf79dc26a4a365f29c44639ed9a6824ba9a8","headSha":"a06dc8160d201feda00657026680823a6b8d0fce","readyAt":"2026-08-15T11:19:53.591Z","version":1,"commitMessage":"feat: add new evaluation script for V1 model\n\nAdded a new evaluation script for the V1 model that performs per-domain evaluation and fixed prompt generation."},"streaming":false,"finishReason":"stop","parentId":"DGM45EI3yZnQLyPYessruhOSqa5tHXdO","type":"message","createdAt":"$D2026-08-15T11:17:08.797Z"},{"content":{"type":"parts","parts":[{"type":"attachment","url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/%5BPasted%2029%20lines%5D-moiY7y6fqRZillUMuvnLknk3tdn1Mx","name":"[Pasted 29 lines]","contentType":"text/plain","size":971}],"version":1},"role":"user","id":"HhUHs7959aYPhW5Hv49yu4NLaFOiiV4S","attachments":[{"url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/%5BPasted%2029%20lines%5D-moiY7y6fqRZillUMuvnLknk3tdn1Mx","name":"[Pasted 29 lines]","size":971,"contentType":"text/plain"}],"parentId":"TsNX5eHA958vlg5CgrXUnX9d2ZqJOqS4","type":"message","authorId":"7Ifmtp88jOhyw3g4VBiJq2gq","createdAt":"$D2026-08-15T11:25:10.236Z"},{"v0ModelId":"v0-opus-5","content":{"type":"message-binary-format","value":[[0,[["AssistantMessageContentPart",{"part":{"createdAt":1786793110624,"finishedAt":1786793110624,"lastPartSentAt":1786793110624,"id":"08iiMWZ5Lr67SvYL","type":"task-start-v1","parts":[{"type":"launch-tasks"}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793110624,"finishedAt":1786793110988,"lastPartSentAt":1786793110968,"taskNameActive":"Reading [Pasted-29-lines]","taskNameComplete":"Read [Pasted-29-lines]","toolCallId":"tool_moaevtDQDi4VAlBZ","agentTurnId":"turn_idGZUGbWeT7CfTwp","filePath":null,"id":"jANL9BPPXLI8aLcQ","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"user_read_only_context/text_attachments/[Pasted-29-lines]-moiY7"}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793114691,"finishedAt":1786793114754,"lastPartSentAt":1786793114754,"taskNameActive":null,"id":"kaV0U8ecFJ38XZEi","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":0,"thought":"I'm looking at the dataset_v1.py file to understand how the metadata is structured and where the cleaned data files are stored."}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793116674,"finishedAt":1786793117459,"lastPartSentAt":1786793117436,"taskNameActive":"Inspecting dataset meta schema","taskNameComplete":"Inspected dataset meta schema","toolCallId":"toolu_01JnWGSN9NRYCtSPdqRMpG9s","agentTurnId":"turn_idGZUGbWeT7CfTwp","filePath":null,"id":"nKP8ASMbXQInb65I","type":"task-grep-repo-v1","parts":[{"type":"grepping-repo","pattern":"json.dump|dataset_meta|DOMAIN|domains|\"tokens\"|clean|\\.txt|\\.jsonl|Path\\(","path":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"grep-file-results","numFileMatches":1}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793121120,"finishedAt":1786793121893,"lastPartSentAt":1786793121864,"taskNameActive":"Reading meta build","taskNameComplete":"Read meta build","toolCallId":"toolu_01YQhTkS9s7uaVosg3yE422K","agentTurnId":"turn_ftFGYMaQfa7iSpZY","filePath":null,"id":"IC5G8RJNl8ad7vls","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py","offset":619,"limit":145}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793127131,"finishedAt":1786793127617,"lastPartSentAt":1786793127617,"taskNameActive":null,"id":"tE925LYgUJeOq4ik","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":0,"thought":"I need to look at the document iteration and tokenizer loading functions in dataset_v1.py so I can reuse them for measuring character and token counts."}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793128393,"finishedAt":1786793128993,"lastPartSentAt":1786793128972,"taskNameActive":"Reading doc iteration","taskNameComplete":"Read doc iteration","toolCallId":"toolu_01BAt75g2mrYWyCdMp3kFPFh","agentTurnId":"turn_l2LKOWNMwT06jnLZ","filePath":null,"id":"2gbjDZks7gBv1IUU","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py","offset":55,"limit":190}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793134120,"finishedAt":1786793134966,"lastPartSentAt":1786793134927,"taskNameActive":"Reading rest of iteration","taskNameComplete":"Read rest of iteration","toolCallId":"toolu_016xjiFPj8GveyHMcBH9gxWz","agentTurnId":"turn_ljiQINka8zGKAGSb","filePath":null,"id":"SALBkIH3loh2pHh4","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py","offset":244,"limit":60}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793140698,"finishedAt":1786793147195,"lastPartSentAt":1786793147195,"taskNameActive":null,"id":"4VusqxgXg0ndWXwC","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":6,"thought":"$116"}]}}],["AssistantMessageContentPart",{"part":{"type":"task-coding-v1","id":"block-b_DNV7Kmkp6JN","parts":[{"type":"code-project","isVersioned":true,"isSourceless":false,"changedFiles":[{"fileName":"/src/analyze_v1_domains.py","baseName":"analyze_v1_domains.py","isActive":false,"isTerminated":false,"isDeleted":false,"isMoved":false}],"source":"[V0_FILE]py:file=\"/src/analyze_v1_domains.py\" \nGENERATING","latestDeploymentInfo":"$111:0:1","lastDeployedAt":"2026-08-15T11:28:05.077Z","sourceVersionKey":"v_1_90qcp_s3","needsBlockSource":true,"isAllImages":false,"blockId":"b_DNV7Kmkp6JN","meta":{"taskNameActive":"Writing analyze_v1_domains.py","taskNameComplete":"Wrote analyze_v1_domains.py","type":"code-project","id":"Code"},"closed":true,"lang":"typescriptreact"}],"createdAt":0,"finishedAt":1,"lastPartSentAt":1,"taskNameActive":"Writing analyze_v1_domains.py","taskNameComplete":"Wrote analyze_v1_domains.py"},"id":"block-b_DNV7Kmkp6JN"}],["Codeblock",{"lang":"plaintext","meta":{},"closed":true},"cd /d \"D:\\DVLPER AI\"\npython src\\analyze_v1_domains.py"],["p",{},["code",{},"src/analyze_v1_domains.py"],["text",{}," is created and is strictly read-only — no torch import, no checkpoint access, no write call anywhere; it snapshots "],["code",{},"data/"],["text",{},", "],["code",{},"tokenizer/"],["text",{}," and "],["code",{},"checkpoints/"],["text",{}," at start and re-verifies them at exit. It reports (1) exact per-domain train/val token counts from "],["code",{},"dataset_meta.json"],["text",{}," with a "],["code",{},"train.bin"],["text",{},"/"],["code",{},"val.bin"],["text",{}," size cross-check, (2) chars/token, tokens/char, bytes/token and tokens/word measured by re-encoding a real sample of each cleaned domain with the live 16k tokenizer, (3) script make-up per domain, (4) explicit YES/no flags for English underrepresentation, tokenizer inefficiency, thin val slice and val/train skew, (5) training share by both tokens and effective characters against the reported per-domain losses, and (6) a stated verdict among A–E with the thresholds printed openly. Optional "],["code",{},"--full-chars"],["text",{}," does an exact whole-corpus character count instead of extrapolating."]]]],[1,{}]]},"context":[],"isContentLoading":false,"role":"assistant","id":"R63uNlroCTUBic3373YVyVRGGvzaLAUt","gitRevision":{"baseSha":"a06dc8160d201feda00657026680823a6b8d0fce","headSha":"de8086428812da77a745877c59ccff59a7a0988a","readyAt":"2026-08-15T11:28:05.059Z","version":1,"commitMessage":"feat: add new script analyze_v1_domains.py for domain diagnostic analysis"},"streaming":false,"finishReason":"stop","parentId":"HhUHs7959aYPhW5Hv49yu4NLaFOiiV4S","type":"message","creditCost":0.8733675,"workMetrics":{"diffMap":{},"linesRead":424,"agentActions":6},"createdAt":"$D2026-08-15T11:25:10.237Z","updatedAt":"$D2026-08-15T11:28:05.071Z"},{"content":{"type":"parts","parts":[{"type":"attachment","url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/%5BPasted%2065%20lines%5D-rn0Tcy4rhN9hq3CJI6zM8b2ArjKhAm","name":"[Pasted 65 lines]","contentType":"text/plain","size":2181}],"version":1},"role":"user","id":"G9O4WewrOGPHQ6j8l5LMqRruxDAPP3p8","attachments":[{"url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/%5BPasted%2065%20lines%5D-rn0Tcy4rhN9hq3CJI6zM8b2ArjKhAm","name":"[Pasted 65 lines]","size":2181,"contentType":"text/plain"}],"parentId":"R63uNlroCTUBic3373YVyVRGGvzaLAUt","type":"message","authorId":"7Ifmtp88jOhyw3g4VBiJq2gq","createdAt":"$D2026-08-15T11:33:41.531Z"},{"v0ModelId":"v0-opus-5","content":{"type":"message-binary-format","value":[[0,[["AssistantMessageContentPart",{"part":{"createdAt":1786793628096,"finishedAt":1786793628096,"lastPartSentAt":1786793628096,"id":"MYKRBNAfIce5aC8V","type":"task-start-v1","parts":[{"type":"launch-tasks"}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793628096,"finishedAt":1786793628707,"lastPartSentAt":1786793628672,"taskNameActive":"Reading [Pasted-65-lines]","taskNameComplete":"Read [Pasted-65-lines]","toolCallId":"tool_aHSvXhS2wcU6vaYP","agentTurnId":"turn_gd0ombE22xh3Avvn","filePath":null,"id":"pkhOwzDO33lKWudD","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"user_read_only_context/text_attachments/[Pasted-65-lines]-rn0Tc"}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793632200,"finishedAt":1786793632264,"lastPartSentAt":1786793632264,"taskNameActive":null,"id":"WowHSGfkOe6T0IKP","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":0,"thought":"I need to examine the full structure of dataset_v1.py to understand how to replicate it."}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793632818,"finishedAt":1786793634257,"lastPartSentAt":1786793634236,"taskNameActive":"Reading dataset_v1 head","taskNameComplete":"Read dataset_v1 head","toolCallId":"toolu_01DXj3iuUFziYKSqNvBwroti","agentTurnId":"turn_gd0ombE22xh3Avvn","filePath":null,"id":"uWNQrHQ8XoRSnFtW","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py","offset":0,"limit":130}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793638195,"finishedAt":1786793638456,"lastPartSentAt":1786793638436,"taskNameActive":"Reading dataset_v1 core","taskNameComplete":"Read dataset_v1 core","toolCallId":"toolu_01SzNQfXN6Fuc83XWmRkzEhm","agentTurnId":"turn_NHXqO2T8PXJcKLVH","filePath":null,"id":"H4tXxI1q4Y1urkLj","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py","offset":129,"limit":420}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793642706,"finishedAt":1786793643972,"lastPartSentAt":1786793643915,"taskNameActive":"Reading dataset_v1 tail","taskNameComplete":"Read dataset_v1 tail","toolCallId":"toolu_01Sa7fRoRrz8Vfr7usxL91RD","agentTurnId":"turn_M6nP6jZkaMy8t1JV","filePath":null,"id":"umzKyPpukDc8Tuad","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py","offset":548,"limit":230}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793647965,"finishedAt":1786793648424,"lastPartSentAt":1786793648384,"taskNameActive":"Reading validation tail","taskNameComplete":"Read validation tail","toolCallId":"toolu_01QWTWFHsdyCnsXeG3ArJBBE","agentTurnId":"turn_AORIT7YlhGX4PfrU","filePath":null,"id":"X7BFMEJx1k5cRH6Q","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/dataset_v1.py","offset":777,"limit":100}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786793654239,"finishedAt":1786793700103,"lastPartSentAt":1786793700103,"taskNameActive":null,"id":"3a2tlbbaIpimCvDl","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":46,"thought":"$117"}]}}],["AssistantMessageContentPart",{"part":{"type":"task-coding-v1","id":"block-b_OyX9fuHada4","parts":[{"type":"code-project","isVersioned":true,"isSourceless":false,"changedFiles":[{"fileName":"/src/dataset_v1_balanced.py","baseName":"dataset_v1_balanced.py","isActive":false,"isTerminated":false,"isDeleted":false,"isMoved":false}],"source":"[V0_FILE]py:file=\"/src/dataset_v1_balanced.py\" \nGENERATING","latestDeploymentInfo":"$111:1:1","lastDeployedAt":"2026-08-15T11:37:52.908Z","sourceVersionKey":"v_1_wgcme_s3","needsBlockSource":true,"isAllImages":false,"blockId":"b_OyX9fuHada4","meta":{"taskNameActive":"Writing dataset_v1_balanced.py","taskNameComplete":"Wrote dataset_v1_balanced.py","type":"code-project","id":"Code"},"closed":true,"lang":"typescriptreact"}],"createdAt":0,"finishedAt":1,"lastPartSentAt":1,"taskNameActive":"Writing dataset_v1_balanced.py","taskNameComplete":"Wrote dataset_v1_balanced.py"},"id":"block-b_OyX9fuHada4"}],["h1",{},["text",{},"1. Proposed balancing method"]],["p",{},["strong",{},["text",{},"Chosen: deterministic sampling-weight exposure control ("],["code",{},"--mode weighted"],["text",{},", the default). No duplication of any kind."]]],["ul",{"start":1},["li",{"index":1},["code",{},"train.bin"],["text",{}," is written once, each token appearing "],["strong",{},["text",{},"exactly once"]],["text",{},", with the four domains laid out in "],["strong",{},["text",{},"contiguous spans"]],["text",{},"."]],["li",{"index":2},["text",{},"The metadata records, per domain, its "],["code",{},"train_span"],["text",{},", its seam-free "],["code",{},"train_segments"],["text",{},", and a "],["code",{},"sample_weight"],["text",{},"."]],["li",{"index":3},["text",{},"Exposure is then enforced "],["strong",{},["text",{},"at sampling time"]],["text",{},": the loader picks the domain with "],["code",{},"sample_weight"],["text",{}," (0.25 each), then a window inside one of that domain's segments. Every optimizer step sees ~25% of its windows from each domain."]],["li",{"index":4},["text",{},"This gives exact exposure control, zero duplicated bytes on disk, no invented text, no modified English files — and it's the same deterministic exposure-control idea already used for tokenizer balancing."]]],["p",{},["text",{},"A second mode exists only as a fallback: "],["code",{},"--mode physical"],["text",{}," tiles the under-represented domains inside "],["code",{},"train.bin"],["text",{}," (same tokens re-emitted from the same temp stream, each extra copy "],["strong",{},["text",{},"rotated by a deterministic seed-1337 offset"]],["text",{}," so duplicate windows don't align). The largest domain is the anchor at "],["code",{},"repeats = 1.0x"],["text",{},", so nothing is ever downsampled and no real text is discarded. Use it only if you want a drop-in "],["code",{},"train.bin"],["text",{}," for an unmodified uniform-window loader — it costs disk and re-shows English ~2.4x."]],["p",{},["strong",{},["text",{},"Validation is never duplicated and never reweighted"]],["text",{}," in either mode. "],["code",{},"val.bin"],["text",{}," holds each held-out token exactly once, with per-domain spans so "],["code",{},"eval_v1.py"],["text",{}," keeps reporting honest per-domain val loss."]],["h1",{},["text",{},"2. Exact expected exposure per domain"]],["p",{},["text",{},"Weighted mode, target source "],["code",{},"configured"],["text",{},":"]],["table",{"align":[null,null,null,null]},["thead",{},["tr",{},["th",{},["text",{},"domain"]],["th",{},["text",{},"natural share (now)"]],["th",{},["text",{},"reweight factor"]],["th",{},["strong",{},["text",{},"exposure after"]]]]],["tbody",{},["tr",{},["td",{},["text",{},"english"]],["td",{},["text",{},"18.69%"]],["td",{},["text",{},"×1.338"]],["td",{},["strong",{},["text",{},"25.00%"]]]],["tr",{},["td",{},["text",{},"hindi"]],["td",{},["text",{},"measured at build"]],["td",{},["text",{},"25 / natural"]],["td",{},["strong",{},["text",{},"25.00%"]]]],["tr",{},["td",{},["text",{},"hinglish"]],["td",{},["text",{},"45.14%"]],["td",{},["text",{},"×0.554"]],["td",{},["strong",{},["text",{},"25.00%"]]]],["tr",{},["td",{},["text",{},"code"]],["td",{},["text",{},"measured at build"]],["td",{},["text",{},"25 / natural"]],["td",{},["strong",{},["text",{},"25.00%"]]]]]],["p",{},["text",{},"Weighted exposure is exact by construction — "],["code",{},"measured_exposure_pct"],["text",{}," equals the weight, delta "],["code",{},"0.00 pp"],["text",{},", and the run asserts every domain is within 1 pp of target. Hindi and Code shares are printed from the actual token counts at build time rather than guessed here (the diagnostic only pinned English and Hinglish; the remaining 36.17% splits between those two)."]],["p",{},["text",{},"Physical mode, using the same known numbers: hinglish is the anchor at "],["code",{},"1.000x"],["text",{},", english lands at "],["code",{},"≈2.416x"],["text",{}," repeats, and the emitted "],["code",{},"train.bin"],["text",{}," grows to roughly "],["code",{},"1.806x"],["text",{}," the base token count. "],["code",{},"MAX_REPEAT = 4.0"],["text",{}," clamps runaway tiling and the clamp is reported openly rather than silently missing target."]],["h1",{},["text",{},"3. Complete script"]],["p",{},["text",{},"Created at "],["code",{},"D:\\DVLPER AI\\src\\dataset_v1_balanced.py"],["text",{},". It imports the split logic ("],["code",{},"split_domain"],["text",{},", guard bands, seeds, "],["code",{},"DomainPass1"],["text",{},", checks) directly from "],["code",{},"dataset_v1.py"],["text",{}," so the split can never drift, writes only into "],["code",{},"data/v1_balanced/"],["text",{},", and hard-refuses to write into "],["code",{},"data/raw"],["text",{},", "],["code",{},"data/cleaned"],["text",{},", "],["code",{},"data/nano"],["text",{},", "],["strong",{},["code",{},"data/v1"]],["text",{},", "],["code",{},"tokenizer/"],["text",{},", "],["code",{},"checkpoints/"],["text",{}," or "],["code",{},"src/"],["text",{},". It re-snapshots all of those at exit and prints "],["code",{},"[PASS]/[FAIL]"],["text",{}," proof they are byte-identical. Kept: uint16, memmap-compatible flat stream, document/range split with no overlap, 512-token guard bands, seed 1337, full per-domain metadata."]],["h1",{},["text",{},"4. Exact command to run it"]],["p",{},["text",{},"Inspect the plan first without writing anything:"]],["Codeblock",{"lang":"plaintext","meta":{},"closed":true},"cd /d \"D:\\DVLPER AI\"\npython src\\dataset_v1_balanced.py --plan-only"],["p",{},["text",{},"Then build:"]],["Codeblock",{"lang":"plaintext","meta":{},"closed":true},"python src\\dataset_v1_balanced.py"],["h1",{},["text",{},"5. STOP"]],["p",{},["text",{},"Not run, no training started, no checkpoint or tokenizer touched, "],["code",{},"model_v1.py"],["text",{}," and "],["code",{},"train_v1.py"],["text",{}," unmodified. Note that weighted mode requires a loader change to honour "],["code",{},"sampling.weights"],["text",{}," — that is a separate decision and I have not made it."]]]],[1,{}]]},"context":[],"isContentLoading":false,"role":"assistant","id":"5xhZHJhmkk7q1kYSXPf2OROFTcOJ8rvG","gitRevision":{"baseSha":"de8086428812da77a745877c59ccff59a7a0988a","headSha":"1c609098bc0ef62bc886361f179ce200d478d2db","readyAt":"2026-08-15T11:37:52.887Z","version":1,"commitMessage":"feat: introduce dataset_v1_balanced.py for balanced dataset preparation"},"streaming":false,"finishReason":"stop","parentId":"G9O4WewrOGPHQ6j8l5LMqRruxDAPP3p8","type":"message","creditCost":1.18982825,"workMetrics":{"diffMap":{},"linesRead":945,"agentActions":6},"createdAt":"$D2026-08-15T11:33:41.532Z","updatedAt":"$D2026-08-15T11:37:52.902Z"},{"content":{"type":"parts","parts":[{"type":"attachment","url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/%5BPasted%2099%20lines%5D-r7Un3NVNXiYrmMMgMGXvDu32bVc9ow","name":"[Pasted 99 lines]","contentType":"text/plain","size":2754},{"type":"attachment","url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/prompy-mFxD0JD9GQxe88N7ZkTbLMY5owzh9B.txt","name":"prompy.txt","contentType":"text/plain","size":2786}],"version":1},"role":"user","id":"NQABLOEqJAZcOzjOi8rQcp2eTqhYLEPP","attachments":[{"url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/prompy-mFxD0JD9GQxe88N7ZkTbLMY5owzh9B.txt","name":"prompy.txt","size":2786,"contentType":"text/plain"},{"url":"https://hebbkx1anhila5yf.public.blob.vercel-storage.com/%5BPasted%2099%20lines%5D-r7Un3NVNXiYrmMMgMGXvDu32bVc9ow","name":"[Pasted 99 lines]","size":2754,"contentType":"text/plain"}],"parentId":"5xhZHJhmkk7q1kYSXPf2OROFTcOJ8rvG","type":"message","authorId":"7Ifmtp88jOhyw3g4VBiJq2gq","createdAt":"$D2026-08-15T11:43:58.969Z"},{"v0ModelId":"v0-opus-5","content":{"type":"message-binary-format","value":[[0,[["AssistantMessageContentPart",{"part":{"createdAt":1786794239741,"finishedAt":1786794239741,"lastPartSentAt":1786794239741,"id":"MEJkmd2TDTwVGKJ5","type":"task-start-v1","parts":[{"type":"launch-tasks"}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786794239741,"finishedAt":1786794240108,"lastPartSentAt":1786794240086,"taskNameActive":"Reading [Pasted-99-lines]","taskNameComplete":"Read [Pasted-99-lines]","toolCallId":"tool_ab0zdaDBO9jmSeII","agentTurnId":"turn_bOpieDc8N3DXkXra","filePath":null,"id":"hRaFRv43mTNctzJO","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"user_read_only_context/text_attachments/[Pasted-99-lines]-r7Un3"}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786794239741,"finishedAt":1786794240503,"lastPartSentAt":1786794240480,"taskNameActive":"Reading prompy.txt","taskNameComplete":"Read prompy.txt","toolCallId":"tool_T7sRF0Dz5MGh5MTp","agentTurnId":"turn_bOpieDc8N3DXkXra","filePath":null,"id":"bB4IPmlchqDkHYaM","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"user_read_only_context/text_attachments/prompy-mFxD0.txt"}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786794244793,"finishedAt":1786794244856,"lastPartSentAt":1786794244856,"taskNameActive":null,"id":"7s8fnDeJnkUGrQEZ","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":0,"thought":"I need to examine the full train_v1.py file and check the metadata schema in dataset_v1_balanced.py to understand the exact structure of the sampling weights and train segments keys."}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786794246605,"finishedAt":1786794249385,"lastPartSentAt":1786794249268,"taskNameActive":"Reading train_v1.py","taskNameComplete":"Read train_v1.py","toolCallId":"toolu_01PoUMk2YsaWkFPBkvbuo45p","agentTurnId":"turn_bOpieDc8N3DXkXra","filePath":null,"id":"v5TOJbK27kYLKyW5","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/train_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/train_v1.py","offset":0,"limit":420}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786794247485,"finishedAt":1786794248736,"lastPartSentAt":1786794248477,"taskNameActive":"Checking meta schema","taskNameComplete":"Checked meta schema","toolCallId":"toolu_01BctgmyCDZ24UUVh1NyVNZA","agentTurnId":"turn_bOpieDc8N3DXkXra","filePath":null,"id":"OSjchEheFLm3tVu8","type":"task-grep-repo-v1","parts":[{"type":"grepping-repo","pattern":"sampling|train_segments|train_span|sample_weight|json.dump|\"domains\"","path":"/vercel/share/v0-project/src/dataset_v1_balanced.py"},{"type":"grep-file-results","numFileMatches":1}]}}],["AssistantMessageContentPart",{"part":{"createdAt":1786794253741,"finishedAt":1786794254340,"lastPartSentAt":1786794254340,"taskNameActive":null,"id":"mQiZy0EhMjHld5Pe","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":1,"thought":"I need to continue reading through the training script to understand the full structure, and I'm checking what format the segments use in the layout data — whether they're stored as start/end pairs in a list."}]}}],["AssistantMessageContentPart",{"part":{"type":"task-grouped-tasks-v1","id":"q8wUOz78ftW9IoO6-Spmlsvgx7TbFPttl","parts":[{"createdAt":1786794255158,"finishedAt":1786794257709,"lastPartSentAt":1786794257684,"taskNameActive":"Reading train_v1 rest","taskNameComplete":"Read train_v1 rest","toolCallId":"toolu_01NoEXM5RSXWSfWwBvrdqtZs","agentTurnId":"turn_zkAJ6znBAPWSPN99","filePath":null,"id":"q8wUOz78ftW9IoO6","type":"task-read-file-v1","parts":[{"type":"reading-file","filePath":"/vercel/share/v0-project/src/train_v1.py"},{"type":"reading-file","filePath":"/vercel/share/v0-project/src/train_v1.py","offset":419,"limit":383}]},{"createdAt":1786794257198,"finishedAt":1786794257893,"lastPartSentAt":1786794257848,"taskNameActive":"Checking segments format","taskNameComplete":"Checked segments format","toolCallId":"toolu_01GMauzyTtLsgsPkciuTpwzi","agentTurnId":"turn_zkAJ6znBAPWSPN99","filePath":null,"id":"Spmlsvgx7TbFPttl","type":"task-grep-repo-v1","parts":[{"type":"grepping-repo","pattern":"\"segments\"|\"span\"|segments\\.append|def layout|CONTEXT_LENGTH =","path":"/vercel/share/v0-project/src/dataset_v1_balanced.py"},{"type":"grep-file-results","numFileMatches":1}]}],"createdAt":0,"finishedAt":1,"lastPartSentAt":1,"taskNameActive":"Explore • 1 File • 1 Search","taskNameComplete":"Explore • 1 File • 1 Search"},"id":"q8wUOz78ftW9IoO6-Spmlsvgx7TbFPttl"}],["AssistantMessageContentPart",{"part":{"createdAt":1786794261865,"finishedAt":1786794275669,"lastPartSentAt":1786794275669,"taskNameActive":null,"id":"bD1MC19S5E9JXFh6","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":14,"thought":"$118"}]}}],["AssistantMessageContentPart",{"part":{"type":"task-coding-v1","id":"block-b_TeOMPUxUHnK","parts":[{"type":"code-project","isVersioned":true,"isSourceless":false,"changedFiles":[{"fileName":"/src/train_v1.py","baseName":"train_v1.py","isActive":false,"isTerminated":false,"isDeleted":false,"isMoved":false}],"source":"$119","latestDeploymentInfo":"$111:2:1","lastDeployedAt":"2026-08-15T11:48:14.480Z","sourceVersionKey":"v_1_170b1_s3","needsBlockSource":false,"isAllImages":false,"blockId":"b_TeOMPUxUHnK","meta":{"taskNameActive":"Rewriting train_v1.py","taskNameComplete":"Rewrote train_v1.py","type":"code-project","id":"Code"},"closed":true,"lang":"typescriptreact"}],"createdAt":0,"finishedAt":1,"lastPartSentAt":1,"taskNameActive":"Rewriting train_v1.py","taskNameComplete":"Rewrote train_v1.py"},"id":"block-b_TeOMPUxUHnK"}],["AssistantMessageContentPart",{"part":{"createdAt":1786794460990,"finishedAt":1786794462575,"lastPartSentAt":1786794462575,"taskNameActive":null,"id":"f9VGSpFH0xkJztqH","type":"task-thinking-v1","parts":[{"type":"thinking-end","duration":2,"thought":"Checking through a few potential issues: `pretraining_tests` references `train_ds.last_starts` which gets set during batch processing, and `sampler_smoke_test` uses the `_META` global that's initialized in main before the call, so both are fine. The variable deletions in pretraining include `x2` and `y2` which are properly defined. For the duplicated tokens print statement, I'm using `meta.get()` with a fallback since the top-level meta dict might not have that key, though the per-domain metadata does. Now moving on to write up the deliverables."}]}}],["h1",{},["text",{},"1. Exact explanation of changes — only "],["code",{},"src/train_v1.py"],["text",{},"was modified"]],["p",{},["strong",{},["text",{},"Dataset switch (req 1–2)."]],["text",{}," Added "],["code",{},"DATASET_DIR = \"data/v1_balanced\""],["text",{},"; "],["code",{},"TRAIN_BIN"],["text",{},", "],["code",{},"VAL_BIN"],["text",{},", "],["code",{},"META_JSON"],["text",{}," now derive from it. "],["code",{},"load_meta()"],["text",{}," hard-fails if "],["code",{},"dataset_meta.json"],["text",{}," is missing, if "],["code",{},"balance_mode != \"weighted\""],["text",{}," (a "],["code",{},"physical"],["text",{}," build carries balance in the bytes and needs a uniform sampler — it refuses rather than silently mis-sampling), if "],["code",{},"sampling.weights"],["text",{}," is absent, or if "],["code",{},"restrict_windows_to_segments"],["text",{}," is not set. It also refuses to train if "],["code",{},"meta.vocab_size"],["text",{}," disagrees with the tokenizer."]],["p",{},["strong",{},["text",{},"Validation untouched (req 3)."]],["text",{}," "],["code",{},"BinDataset"],["text",{}," is unchanged and now used "],["strong",{},["text",{},"only"]],["text",{}," for "],["code",{},"val.bin"],["text",{},": uniform windows over the whole file, fixed eval seed "],["code",{},"SEED+1"],["text",{},", never reweighted, never domain-sampled — so val loss stays comparable to every earlier number. "],["code",{},"val.bin"],["text",{}," is opened "],["code",{},"mode=\"r\""],["text",{},", and its "],["code",{},"(size, mtime_ns)"],["text",{}," is stamped at startup and re-checked at the end as a printed "],["code",{},"[PASS] val.bin not touched"],["text",{},"."]],["p",{},["strong",{},["text",{},"New domain-aware train sampler (req 4)."]],["text",{}," "],["code",{},"WeightedDomainSampler"],["text",{}," replaces the uniform train sampler. Per draw: pick domain "],["code",{},"d"],["text",{}," with "],["code",{},"p = sampling.weights[d]"],["text",{},"; pick one of "],["code",{},"d"],["text",{},"'s "],["code",{},"train_segments"],["text",{}," with probability proportional to its valid-window count "],["code",{},"max(0, len(seg) - 513 + 1)"],["text",{},"; pick a uniform "],["code",{},"start"],["text",{}," in "],["code",{},"[seg_start, seg_end - 513]"],["text",{},". Every window therefore lies wholly inside one segment of one span — no domain boundary and no 512-token guard-band seam can be crossed. Segments too short for a 513-token window are skipped and the count is printed; a domain with "],["strong",{},["text",{},"no"]],["text",{}," usable segment is a hard exit rather than a silent drop. Segments that escape their span are a hard exit."]],["p",{},["strong",{},["text",{},"Preserved (req 5)."]],["text",{}," "],["code",{},"BATCH_SIZE=2"],["text",{},", "],["code",{},"SEQ_LEN=512"],["text",{},", "],["code",{},"GRAD_ACCUM_STEPS=8"],["text",{},", the AdamW split-param-group optimizer, the 6e-4→6e-5 warmup+cosine schedule, fp16 AMP + GradScaler, and the atomic "],["code",{},".tmp → os.replace()"],["text",{}," checkpoint system are all byte-identical in behaviour. "],["code",{},"MAX_STEPS"],["text",{}," is "],["strong",{},["text",{},"500"]],["text",{}," per req 13 (req 5 says 5000 \"for now\", req 13 says the first run stays diagnostic at 500 — I followed req 13, which is the later and more specific instruction; raise it after you verify the smoke test)."]],["p",{},["strong",{},["text",{},"Diagnostics (req 6)."]],["text",{}," "],["code",{},"sampler_report()"],["text",{}," prints the dataset path, balance mode, duplicated-token count, and a per-domain table of natural share / weight / expected exposure / segment count / valid-window count, plus the expected "],["code",{},"25/25/25/25"],["text",{}," line. "],["code",{},"sampler_smoke_test()"],["text",{}," draws 1000 windows and prints target vs drawn vs actual vs delta, and fails if any domain deviates by more than ±3 pp. A "],["strong",{},["text",{},"realised exposure"]],["text",{}," table over every window drawn during the actual run is printed at the end and checked against the same ±3 pp tolerance."]],["p",{},["strong",{},["text",{},"Correctness checks (req 7)."]],["text",{}," Window length 513 ("],["code",{},"x"],["text",{},"/"],["code",{},"y"],["text",{}," both 512 after the shift), ids within vocab, every sampled window inside its chosen segment, every window's owning span equal to the drawn domain, determinism proved by a second throwaway sampler at seed 1337 producing identical starts and domains, plus the existing shift/logits/init-loss/causality tests. The smoke test uses "],["strong",{},["text",{},"throwaway"]],["text",{}," samplers so the training stream is not consumed."]],["p",{},["strong",{},["text",{},"Fresh weights, new names (req 8–11)."]],["text",{}," "],["code",{},"RUN_NAME = \"v1_balanced\""],["text",{},", writing "],["code",{},"checkpoints/v1_balanced.pt"],["text",{}," and "],["code",{},"checkpoints/v1_balanced_last.pt"],["text",{},". "],["code",{},"v1.pt"],["text",{}," and "],["code",{},"v1_last.pt"],["text",{}," are added to "],["code",{},"PROTECTED"],["text",{}," alongside the Nano files; "],["code",{},"save_checkpoint"],["text",{}," asserts it never targets a protected name and "],["code",{},"load_checkpoint"],["text",{}," refuses to "],["em",{},["text",{},"open"]],["text",{}," one, and also rejects any checkpoint whose "],["code",{},"run"],["text",{}," is not "],["code",{},"v1_balanced"],["text",{},". "],["code",{},"FRESH_RUN = True"],["text",{},", "],["code",{},"ALLOW_FRESH_OVERWRITE = False"],["text",{},". Checkpoints now also record "],["code",{},"dataset.dir"],["text",{}," and the domain weights."]],["p",{},["strong",{},["text",{},"Memory probe (req 12)."]],["text",{}," Unchanged, still runs before training at the configured batch size, still exits with a clear message on OOM and never adjusts "],["code",{},"BATCH_SIZE"],["text",{}," or the architecture."]],["h1",{},["text",{},"2. Complete "],["code",{},"train_v1.py"]],["p",{},["text",{},"Written in full to "],["code",{},"D:\\DVLPER AI\\src\\train_v1.py"],["text",{}," (1186 lines) — that is the file on disk now; nothing else in the project was modified."]],["h1",{},["text",{},"3. Exact command"]],["Codeblock",{"lang":"plaintext","meta":{},"closed":true},"cd /d \"D:\\DVLPER AI\"\npython src\\dataset_v1_balanced.py\npython src\\train_v1.py"],["p",{},["text",{},"The first line is required because "],["code",{},"data/v1_balanced/"],["text",{}," does not exist yet — "],["code",{},"train_v1.py"],["text",{}," will exit with instructions if you run it before the build."]],["h1",{},["text",{},"4. Expected sampler smoke-test output (shape, exact counts depend on seed 1337)"]],["Codeblock",{"lang":"plaintext","meta":{},"closed":true},"$11a"],["p",{},["text",{},"Multinomial sampling of 1000 windows has a standard deviation of ~1.37 pp per domain, so deviations up to ~2–3 pp are normal and expected; the ±3 pp gate is calibrated for that. The end-of-run realised-exposure table draws 8,000 windows (500 × 16) and should land within ~0.5 pp."]],["h1",{},["text",{},"5. STOP"]],["p",{},["text",{},"Training was not started. No dataset was built, no tokenizer touched, "],["code",{},"model_v1.py"],["text",{}," unmodified, "],["code",{},"v1.pt"],["text",{}," / "],["code",{},"v1_last.pt"],["text",{}," neither opened nor written."]]]],[1,{}]]},"context":[],"isContentLoading":false,"role":"assistant","id":"3RUP9dQVGJaRE7TggFKBHA9TyX85LN3m","gitRevision":{"baseSha":"1c609098bc0ef62bc886361f179ce200d478d2db","headSha":"0202bb4f38abbaec19ec88c575b9064d64898042","readyAt":"2026-08-15T11:48:14.461Z","version":1,"commitMessage":"feat: switch to balanced dataset for V1 training script"},"streaming":false,"finishReason":"stop","parentId":"NQABLOEqJAZcOzjOi8rQcp2eTqhYLEPP","type":"message","creditCost":1.35398725,"workMetrics":{"diffMap":{},"linesRead":1001,"agentActions":7},"createdAt":"$D2026-08-15T11:43:58.970Z","updatedAt":"$D2026-08-15T11:48:14.472Z"}],"lastSyncedAt":1790153209071,"undo":null,"activeForkKey":["alFpNA5aLur3GjfvJlFHBTxKwHXcIMhu","1ZzMfMOPaYarYqLE13GjLAzd0IqVvpqQ","QQiQsHpKd6LRxSrA7MafqUe1j8rTXtYz","tm9gUJmwrMxMM7DOOTYgL1U6DkuKHAFJ","Y5suaeIprq2OBSFw9s827RDlrBuNVpsF","TiyILo4Z6fseNHTkNGeAXiPEJdwcnH7A","DGM45EI3yZnQLyPYessruhOSqa5tHXdO","TsNX5eHA958vlg5CgrXUnX9d2ZqJOqS4","HhUHs7959aYPhW5Hv49yu4NLaFOiiV4S","R63uNlroCTUBic3373YVyVRGGvzaLAUt","G9O4WewrOGPHQ6j8l5LMqRruxDAPP3p8","5xhZHJhmkk7q1kYSXPf2OROFTcOJ8rvG","NQABLOEqJAZcOzjOi8rQcp2eTqhYLEPP","3RUP9dQVGJaRE7TggFKBHA9TyX85LN3m"],"lifecycle":{"phase":"idle","persistence":"persisted"},"isAuthor":false,"isRestoring":false,"hashMessageId":null},"@\"active-block\",\"JYNFarW33aQ\",":{"id":"b_TeOMPUxUHnK","meta":{"taskNameActive":"Rewriting train_v1.py","taskNameComplete":"Rewrote train_v1.py","type":"code-project","id":"Code"},"initial":true,"type":"code-project","messageId":"3RUP9dQVGJaRE7TggFKBHA9TyX85LN3m","language":"typescriptreact","source":"$11b","closed":true,"hasSourceBeenEdited":false,"lastDeployedAt":"2026-08-15T11:48:14.480Z","latestDeploymentInfo":"$111:2:1","isLoading":false,"needsBlockSource":false},"@\"chat:meta\",\"JYNFarW33aQ\",":{"title":"Nano training pipeline (2)","authorId":"7Ifmtp88jOhyw3g4VBiJq2gq","ownerId":"team_Dbhmo9rIt0xaZoJQ9iOKCauM","storageEntityType":"v0-git-s3-storage","storageEntityId":"v0-1-team_Dbhmo9rIt0xaZoJQ9iOKCauM-JYNFarW33aQ","tailwindV4Default":true,"vercelProjectId":null,"canWriteToChat":false},"@\"chat:vm-mode\",\"JYNFarW33aQ\",":true,"@\"chat:vercel-project\",\"JYNFarW33aQ\",":"$@11c","@\"team:sensitive-environment-variable-policy\",\"JYNFarW33aQ\",":"$@11d","@\"block-view\",\"JYNFarW33aQ\",":true,"integrations:figma":"$@11e"},"children":["$L11f","$L120","$L121","$L122","$L123"]}]}]}] 46:o8,f3:null 46:oe2c,124:I[900547,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"FullChat",1] 125:"NavigationMarker" 126:I[326448,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$125"] 127:"OpenInV0JourneyCompletion" 128:I[228493,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$127"] 129:"SuspendingKeepTitleUpdated" 12a:I[487989,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$129"] 12b:"KeepClientOnUpToDateSlugPath" 12c:I[983440,["$50","$51","$52","$53","$54","$55","$56","$57","$58","$59","$5a","$5b","$5c","$5d","$5e","$5f","$60","$61","$62","$63","$64","$65","$66","$67","$68","$69","$6a","$6b","$6c","$6d","$6e","$6f","$70","$71","$72","$73","$74","$75","$76","$77","$78","$79","$7f","$80","$81","$82","$7b","$83","$84","$85","$86","$87","$88","$7c","$7d","$89","$8a"],"$12b"] 100:{"ok":true,"value":{"designSystemId":null,"title":"Nano training pipeline (2)","privacy":"public","access":1,"isAdmin":false,"isAuthor":false,"ownerId":"team_Dbhmo9rIt0xaZoJQ9iOKCauM","authorId":"anon:ENU8w8lk-bNwA53CTf5Qv","tailwindV4Default":true,"nextVersion15Default":false,"forceVMRendering":false,"isNextLiteReadOnly":false,"canWriteToChat":false,"canManageChat":false,"chatCreatedAt":1786788403735,"hasBlock":true,"vercelProject":null,"hasGitConnection":false,"gitBase":null,"gitHead":null,"hasSnowflakeIntegration":false,"chatHasAnySnowflakeIntegration":false,"storageEntityType":"v0-git-s3-storage","storageEntityId":"v0-1-team_Dbhmo9rIt0xaZoJQ9iOKCauM-JYNFarW33aQ","vercelProjectId":null,"defaultPreviewPath":null,"agentWorkspace":false,"workspaceRuntime":false}} 101:{"ok":false,"error":{"error":"Unauthorized","statusCode":401,"errorCode":"2"}} 102:{"ok":false,"error":{"error":"51","statusCode":500,"errorCode":"38"}} 103:{"ok":false,"error":{"error":"51","statusCode":500,"errorCode":"38"}} 104:{"ok":false,"error":{"error":"51","statusCode":500,"errorCode":"38"}} 105:{"ok":false,"error":{"error":"Unauthorized","statusCode":401,"errorCode":"2"}} 106:{"ok":true,"value":null,"__seedOnly":true} 10a:null 10b:null 11c:"$undefined" 11d:"$undefined" 11e:{"isSignedIn":false} 11f:["$","$L124","full-chat",{"isMobile":false,"templatesServer":null}] 120:["$","$L126",null,{"phase":"content","label":"Chat.Detail","routeOverride":"/chat/[slug]"}] 121:["$","$L128",null,{}] 122:["$","$3e",null,{"children":["$","$L12a",null,{"chatId":"JYNFarW33aQ"}]}] 123:["$","$L12c",null,{"id":"JYNFarW33aQ","requireMatchingChatPath":true,"title":"Nano training pipeline (2)"}] 46:o11,43:true 42:61048 46:o2c,41:C 40:C 1:C 38:C 22:C 36:C 2c:C 1b:C 18:C 46:C