[{"_1":2,"_176":-5,"_177":-5},"loaderData",{"_3":4,"_93":94},"root",{"_5":6,"_36":37,"_66":67},"ctx",{"_7":8,"_23":-5,"_24":25,"_26":27,"_28":20,"_29":20,"_30":20,"_31":-5,"_32":33,"_34":20,"_35":20},"auth",{"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20,"_21":22},"sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","isAuthenticated",false,"tokenType","session_token","user","preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesChatPanelState","notificationCount",0,"flagDenols","isTeamOrgMember","ENV",{"_38":39,"_40":41,"_42":43,"_44":45,"_46":47,"_48":49,"_50":51,"_52":53,"_54":55,"_56":57,"_58":59,"_60":61,"_62":63,"_64":65},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","VAL_RUNTIME_NAME","prod","RENDER_GIT_COMMIT","6050acf0705e6826bb1b68e27572c5b8979c5bd9","RENDER_GIT_BRANCH","main","CLERK_PUBLISHABLE_KEY","pk_live_Y2xlcmsudmFsLnRvd24k","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","API_URL","https://api.val.town","clerkState",{"_68":69},"__internal_clerk_state",{"_70":71,"_72":47,"_73":74,"_75":74,"_76":20,"_77":74,"_78":74,"_79":74,"_80":74,"_81":82,"_91":20,"_92":20},"__clerk_ssr_state",{"_21":22,"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20},"__publishableKey","__proxyUrl","","__domain","__isSatellite","__signInUrl","__signUpUrl","__afterSignInUrl","__afterSignUpUrl","__clerk_debug",{"_83":20,"_19":20,"_84":74,"_85":86,"_87":74,"_88":47,"_89":20,"_90":74},"isSignedIn","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","__telemetryDisabled","__telemetryDebug","routes/embed.x.$handle.$name.$",{"_95":96,"_97":98,"_99":100,"_101":102,"_153":154,"_173":174,"_175":-5},"handle","stevekrouse","name","microgpt","path","main.ts","project",{"_103":104,"_97":98,"_105":106,"_107":-5,"_108":20,"_109":110,"_111":74,"_112":74,"_12":113,"_114":-5,"_115":20,"_116":-5,"_117":-5,"_118":33,"_14":119,"_120":-5,"_121":-5,"_122":123,"_124":123,"_125":126,"_127":126,"_128":126,"_129":123,"_130":123,"_23":131,"_134":135,"_139":140,"_152":20},"id","9c1dc470-0f41-11f1-b466-42dde27851f2","createdAt",["D",1771690989159],"deletedAt","legacyEnvVars","privacy","public","description","imageUrl","a0bf3b31-15a5-4d5c-880e-4b1e22c9bc18","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount","e81e7335-6d4c-4764-a902-d0962bbfa9f7","tursoName","tursoHostname","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_95":96,"_132":133},"profileImageUrl","https://images.clerk.dev/uploaded/img_2PqHa2Gsy93xQrjh2w78Xu0cChW.jpeg","org",{"_95":96,"_136":133,"_12":113,"_137":138},"avatar","tier","pro","branch",{"_141":142,"_97":45,"_103":143,"_144":104,"_145":-5,"_146":-5,"_147":-5,"_148":-5,"_149":-5,"_150":98,"_151":96},"version",17,"9c1e152e-0f41-11f1-b466-42dde27851f2","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","isOwned","file",{"_103":155,"_97":100,"_156":157,"_158":-5,"_159":143,"_160":161,"_162":163,"_105":164,"_141":165,"_166":167,"_168":169,"_170":20,"_171":-5,"_99":172},"6396ef34-0f44-11f1-b572-42dde27851f2","fileId","9c206342-0f41-11f1-b466-42dde27851f2","parentId","branchId","branchVersion",15,"latest",true,["D",1771692182733],14,"fileType","script","content","// ---- Tensor (micrograd-style autograd on flat arrays) ----\ntype Shape = number[];\nclass Tensor {\n data: Float32Array;\n grad: Float32Array;\n shape: Shape;\n _backward: () => void = () => {};\n _parents: Tensor[] = [];\n constructor(data: Float32Array, shape: Shape) {\n this.data = data;\n this.grad = new Float32Array(data.length);\n this.shape = shape;\n }\n backward() {\n const order: Tensor[] = [], visited = new Set();\n const topo = (t: Tensor) => {\n if (visited.has(t)) return;\n visited.add(t);\n t._parents.forEach(topo);\n order.push(t);\n };\n topo(this);\n this.grad.fill(1);\n for (let i = order.length - 1; i >= 0; i--) order[i]._backward();\n }\n}\nfunction zeros(shape: Shape) {\n return new Tensor(new Float32Array(shape.reduce((a, b) => a * b, 1)), shape);\n}\n\nfunction matmul(a: Tensor, b: Tensor): Tensor {\n const [M, K] = a.shape, N = b.shape[1], out = zeros([M, N]);\n for (let i = 0; i < M; i++) {\n for (let j = 0; j < N; j++) {\n let s = 0;\n for (let k = 0; k < K; k++) s += a.data[i * K + k] * b.data[k * N + j];\n out.data[i * N + j] = s;\n }\n }\n out._parents = [a, b];\n out._backward = () => {\n for (let i = 0; i < M; i++) {\n for (let j = 0; j < N; j++) {\n const g = out.grad[i * N + j];\n for (let k = 0; k < K; k++) {\n a.grad[i * K + k] += g * b.data[k * N + j];\n b.grad[k * N + j] += g * a.data[i * K + k];\n }\n }\n }\n };\n return out;\n}\n\nfunction addBias(a: Tensor, b: Tensor): Tensor {\n const [M, N] = a.shape, out = zeros([M, N]);\n for (let i = 0; i < M; i++) {\n for (let j = 0; j < N; j++) {\n out.data[i * N + j] = a.data[i * N + j] + b.data[j];\n }\n }\n out._parents = [a, b];\n out._backward = () => {\n for (let i = 0; i < M * N; i++) a.grad[i] += out.grad[i];\n for (let i = 0; i < M; i++) {\n for (let j = 0; j < N; j++) b.grad[j] += out.grad[i * N + j];\n }\n };\n return out;\n}\n\nfunction relu(a: Tensor): Tensor {\n const n = a.data.length, out = zeros(a.shape);\n for (let i = 0; i < n; i++) out.data[i] = Math.max(0, a.data[i]);\n out._parents = [a];\n out._backward = () => {\n for (let i = 0; i < n; i++) {\n a.grad[i] += out.grad[i] * (a.data[i] > 0 ? 1 : 0);\n }\n };\n return out;\n}\n\nfunction residualAdd(a: Tensor, b: Tensor): Tensor {\n const out = zeros(a.shape);\n for (let i = 0; i < a.data.length; i++) out.data[i] = a.data[i] + b.data[i];\n out._parents = [a, b];\n out._backward = () => {\n for (let i = 0; i < a.data.length; i++) {\n a.grad[i] += out.grad[i];\n b.grad[i] += out.grad[i];\n }\n };\n return out;\n}\n\nfunction embedding(table: Tensor, indices: Int32Array): Tensor {\n const D = table.shape[1], T = indices.length, out = zeros([T, D]);\n for (let t = 0; t < T; t++) {\n for (let d = 0; d < D; d++) {\n out.data[t * D + d] = table.data[indices[t] * D + d];\n }\n }\n out._parents = [table];\n out._backward = () => {\n for (let t = 0; t < T; t++) {\n for (let d = 0; d < D; d++) {\n table.grad[indices[t] * D + d] += out.grad[t * D + d];\n }\n }\n };\n return out;\n}\n\nfunction rmsnorm(a: Tensor): Tensor {\n // RMSNorm: x * rsqrt(mean(x^2) + eps), applied per-row for [T, D]\n const [T, D] = a.shape, out = zeros([T, D]);\n const scales = new Float32Array(T);\n for (let t = 0; t < T; t++) {\n let ms = 0;\n for (let d = 0; d < D; d++) ms += a.data[t * D + d] * a.data[t * D + d];\n ms /= D;\n scales[t] = 1 / Math.sqrt(ms + 1e-5);\n for (let d = 0; d < D; d++) {\n out.data[t * D + d] = a.data[t * D + d] * scales[t];\n }\n }\n out._parents = [a];\n out._backward = () => {\n for (let t = 0; t < T; t++) {\n const s = scales[t];\n let dot = 0;\n for (let d = 0; d < D; d++) {\n dot += a.data[t * D + d] * out.grad[t * D + d];\n }\n for (let d = 0; d < D; d++) {\n a.grad[t * D + d] += s *\n (out.grad[t * D + d] - a.data[t * D + d] * dot * s * s / D);\n }\n }\n };\n return out;\n}\n\nfunction crossEntropyLoss(logits: Tensor, targets: Int32Array): Tensor {\n const [T, V] = logits.shape,\n out = zeros([1]),\n probs = new Float32Array(T * V);\n for (let t = 0; t < T; t++) {\n let mx = -Infinity;\n for (let v = 0; v < V; v++) mx = Math.max(mx, logits.data[t * V + v]);\n let s = 0;\n for (let v = 0; v < V; v++) {\n probs[t * V + v] = Math.exp(logits.data[t * V + v] - mx);\n s += probs[t * V + v];\n }\n for (let v = 0; v < V; v++) probs[t * V + v] /= s;\n out.data[0] -= Math.log(probs[t * V + targets[t]] + 1e-10);\n }\n out.data[0] /= T;\n out._parents = [logits];\n out._backward = () => {\n for (let t = 0; t < T; t++) {\n for (let v = 0; v < V; v++) {\n logits.grad[t * V + v] += out.grad[0] *\n (probs[t * V + v] - (v === targets[t] ? 1 : 0)) / T;\n }\n }\n };\n return out;\n}\n\n// ---- Seeded RNG (xorshift32) ----\nfunction makeRng(seed: number) {\n let s = seed | 0 || 1;\n return () => {\n s ^= s << 13;\n s ^= s >> 17;\n s ^= s << 5;\n return (s >>> 0) / 4294967296;\n };\n}\n\n// ---- Dataset (fetch from Karpathy's repo) ----\nasync function loadDocs(): Promise {\n const resp = await fetch(\n \"https://raw.githubusercontent.com/karpathy/makemore/refs/heads/master/names.txt\",\n );\n const text = await resp.text();\n return text.trim().split(\"\\n\").map((s) => s.trim().toLowerCase()).filter(\n (s) => s.length > 0\n );\n}\n\n// ---- Tokenizer ----\nfunction buildCharTokenizerFromDocs(docs: string[]) {\n const chars = [...new Set(docs.join(\"\"))].sort();\n const BOS = chars.length, vocabSize = chars.length + 1;\n const c2i = new Map(chars.map((c, i) => [c, i]));\n return {\n vocabSize,\n BOS,\n chars,\n encode(text: string): Int32Array {\n const ids = [BOS];\n for (const c of text) ids.push(c2i.get(c)!);\n ids.push(BOS);\n return new Int32Array(ids);\n },\n decode(tokens: Int32Array): string {\n let s = \"\";\n for (const t of tokens) if (t !== BOS && t < chars.length) s += chars[t];\n return s;\n },\n };\n}\n\n// ---- Model ----\ntype Params = Tensor[];\ninterface ModelSpec {\n vocabSize: number;\n maxLen: number;\n dModel: number;\n nHeads: number;\n nLayers: number;\n dFF: number;\n}\ninterface Model {\n spec: ModelSpec;\n initParams: (seed: number) => Params;\n forward: (params: Params, tokens: Int32Array) => Tensor;\n countParams: (p: Params) => number;\n}\n\nfunction makeTransformerLanguageModel(spec: ModelSpec): Model {\n const { vocabSize, maxLen, dModel, nHeads, nLayers, dFF } = spec;\n const headDim = dModel / nHeads;\n\n function initParams(seed: number): Params {\n const rng = makeRng(seed), params: Params = [];\n const randn = (shape: Shape, scale = 0.02) => {\n const t = zeros(shape);\n for (let i = 0; i < t.data.length; i++) {\n const u1 = rng() || 1e-10, u2 = rng();\n t.data[i] = Math.sqrt(-2 * Math.log(u1)) * Math.cos(6.2831853 * u2) *\n scale;\n }\n params.push(t);\n return t;\n };\n randn([vocabSize, dModel]);\n randn([maxLen, dModel]); // token embeddings, position embeddings\n for (let _l = 0; _l < nLayers; _l++) {\n randn([dModel, 3 * dModel]);\n randn([3 * dModel]); // attention QKV weight + bias\n randn([dModel, dModel], 0);\n randn([dModel]); // attention output projection (init to 0 like Karpathy)\n randn([dModel, dFF]);\n randn([dFF]); // feedforward layer 1 weight + bias\n randn([dFF, dModel], 0);\n randn([dModel]); // feedforward layer 2 (init to 0 like Karpathy)\n }\n // No separate lm_head — we'll use weight tying with wte (like Karpathy)\n return params;\n }\n\n function forward(params: Params, tokens: Int32Array): Tensor {\n let pi = 0;\n const tokEmb = params[pi++], posEmb = params[pi++], T = tokens.length;\n const posIds = new Int32Array(T);\n for (let i = 0; i < T; i++) posIds[i] = i % maxLen;\n let x = residualAdd(embedding(tokEmb, tokens), embedding(posEmb, posIds));\n x = rmsnorm(x);\n\n for (let _l = 0; _l < nLayers; _l++) {\n const wQKV = params[pi++],\n bQKV = params[pi++],\n wO = params[pi++],\n bO = params[pi++];\n\n // RMSNorm before attention\n const xNorm = rmsnorm(x);\n const qkv = addBias(matmul(xNorm, wQKV), bQKV); // [T, 3*dModel]\n\n // Attention (all heads, manual forward + backward)\n const attnOut = zeros([T, dModel]);\n const headData: {\n Q: Float32Array;\n K: Float32Array;\n V: Float32Array;\n attnW: Float32Array;\n off: number;\n }[] = [];\n for (let h = 0; h < nHeads; h++) {\n const off = h * headDim, scale = 1 / Math.sqrt(headDim);\n const Q = new Float32Array(T * headDim),\n K = new Float32Array(T * headDim),\n V = new Float32Array(T * headDim);\n for (let t = 0; t < T; t++) {\n for (let d = 0; d < headDim; d++) {\n Q[t * headDim + d] = qkv.data[t * 3 * dModel + off + d];\n K[t * headDim + d] = qkv.data[t * 3 * dModel + dModel + off + d];\n V[t * headDim + d] =\n qkv.data[t * 3 * dModel + 2 * dModel + off + d];\n }\n }\n // Causal attention scores + softmax\n const attnW = new Float32Array(T * T);\n for (let i = 0; i < T; i++) {\n const scores = new Float32Array(T);\n let mx = -Infinity;\n for (let j = 0; j <= i; j++) {\n let s = 0;\n for (let d = 0; d < headDim; d++) {\n s += Q[i * headDim + d] * K[j * headDim + d];\n }\n scores[j] = s * scale;\n mx = Math.max(mx, scores[j]);\n }\n let s = 0;\n for (let j = 0; j <= i; j++) {\n attnW[i * T + j] = Math.exp(scores[j] - mx);\n s += attnW[i * T + j];\n }\n for (let j = 0; j <= i; j++) attnW[i * T + j] /= s;\n }\n // Weighted sum of values\n for (let i = 0; i < T; i++) {\n for (let d = 0; d < headDim; d++) {\n let s = 0;\n for (let j = 0; j <= i; j++) {\n s += attnW[i * T + j] * V[j * headDim + d];\n }\n attnOut.data[i * dModel + off + d] = s;\n }\n }\n headData.push({ Q, K, V, attnW, off });\n }\n attnOut._parents = [qkv];\n attnOut._backward = () => {\n for (const { Q, K, V, attnW, off } of headData) {\n const scale = 1 / Math.sqrt(headDim);\n const dAttnW = new Float32Array(T * T),\n dV = new Float32Array(T * headDim);\n for (let i = 0; i < T; i++) {\n for (let d = 0; d < headDim; d++) {\n const g = attnOut.grad[i * dModel + off + d];\n for (let j = 0; j <= i; j++) {\n dAttnW[i * T + j] += g * V[j * headDim + d];\n dV[j * headDim + d] += g * attnW[i * T + j];\n }\n }\n }\n const dQ = new Float32Array(T * headDim),\n dK = new Float32Array(T * headDim);\n for (let i = 0; i < T; i++) {\n let dot = 0;\n for (let j = 0; j <= i; j++) {\n dot += dAttnW[i * T + j] * attnW[i * T + j];\n }\n for (let j = 0; j <= i; j++) {\n const ds = attnW[i * T + j] * (dAttnW[i * T + j] - dot) * scale;\n for (let d = 0; d < headDim; d++) {\n dQ[i * headDim + d] += ds * K[j * headDim + d];\n dK[j * headDim + d] += ds * Q[i * headDim + d];\n }\n }\n }\n for (let t = 0; t < T; t++) {\n for (let d = 0; d < headDim; d++) {\n qkv.grad[t * 3 * dModel + off + d] += dQ[t * headDim + d];\n qkv.grad[t * 3 * dModel + dModel + off + d] +=\n dK[t * headDim + d];\n qkv.grad[t * 3 * dModel + 2 * dModel + off + d] +=\n dV[t * headDim + d];\n }\n }\n }\n };\n\n x = residualAdd(x, addBias(matmul(attnOut, wO), bO));\n\n // MLP with RMSNorm, ReLU (like Karpathy), no bias needed but keeping for simplicity\n const xNorm2 = rmsnorm(x);\n const wFF1 = params[pi++],\n bFF1 = params[pi++],\n wFF2 = params[pi++],\n bFF2 = params[pi++];\n x = residualAdd(\n x,\n addBias(matmul(relu(addBias(matmul(xNorm2, wFF1), bFF1)), wFF2), bFF2),\n );\n }\n\n // Weight-tied output head: logits = x @ tokEmb^T (reuse token embeddings)\n // tokEmb is [vocabSize, dModel], we need [T, dModel] @ [dModel, vocabSize] = [T, vocabSize]\n // So we need to transpose tokEmb. We'll do this manually.\n const Tout = tokens.length, V = vocabSize;\n const logits = zeros([Tout, V]);\n logits._parents = [x, tokEmb];\n for (let t = 0; t < Tout; t++) {\n for (let v = 0; v < V; v++) {\n let s = 0;\n for (let d = 0; d < dModel; d++) {\n s += x.data[t * dModel + d] * tokEmb.data[v * dModel + d];\n }\n logits.data[t * V + v] = s;\n }\n }\n logits._backward = () => {\n for (let t = 0; t < Tout; t++) {\n for (let v = 0; v < V; v++) {\n const g = logits.grad[t * V + v];\n for (let d = 0; d < dModel; d++) {\n x.grad[t * dModel + d] += g * tokEmb.data[v * dModel + d];\n tokEmb.grad[v * dModel + d] += g * x.data[t * dModel + d];\n }\n }\n }\n };\n return logits;\n }\n\n return {\n spec,\n initParams,\n forward,\n countParams: (p: Params) => p.reduce((s, t) => s + t.data.length, 0),\n };\n}\n\n// ---- Training (Karpathy-style: 1 doc per step, Adam optimizer) ----\ntype Trained = {\n tokenizer: ReturnType;\n model: Model;\n params: Params;\n};\n\nfunction trainNameModel(opts: {\n docs: string[];\n tokenizer: ReturnType;\n model: Model;\n steps: number;\n maxLen: number;\n seed: number;\n learningRate: number;\n}): Trained {\n const { docs, tokenizer, model, steps, maxLen, seed, learningRate } = opts;\n const params = model.initParams(seed);\n const numParams = model.countParams(params);\n console.log(`num params: ${numParams}`);\n\n // Adam optimizer state\n const beta1 = 0.9, beta2 = 0.95, epsAdam = 1e-8;\n const mBuf: Float32Array[] = params.map((p) =>\n new Float32Array(p.data.length)\n );\n const vBuf: Float32Array[] = params.map((p) =>\n new Float32Array(p.data.length)\n );\n\n // Shuffle docs with our seeded RNG\n const rng = makeRng(seed);\n const shuffled = [...docs];\n for (let i = shuffled.length - 1; i > 0; i--) {\n const j = Math.floor(rng() * (i + 1));\n [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];\n }\n\n const t0 = Date.now();\n for (let step = 0; step < steps; step++) {\n // Zero gradients\n for (const p of params) p.grad.fill(0);\n\n // Pick one doc, encode it: [BOS, ...chars, BOS]\n const doc = shuffled[step % shuffled.length];\n const allTokens = tokenizer.encode(doc); // already has BOS on both sides\n // Crop to maxLen\n const n = Math.min(maxLen, allTokens.length - 1);\n const input = allTokens.slice(0, n);\n const target = allTokens.slice(1, n + 1);\n\n // Forward + loss + backward\n const logits = model.forward(params, input);\n const loss = crossEntropyLoss(logits, target);\n loss.backward();\n\n // Adam update with linear LR decay\n const lrT = learningRate * (1 - step / steps);\n for (let pi = 0; pi < params.length; pi++) {\n const p = params[pi], m = mBuf[pi], v = vBuf[pi];\n for (let i = 0; i < p.data.length; i++) {\n m[i] = beta1 * m[i] + (1 - beta1) * p.grad[i];\n v[i] = beta2 * v[i] + (1 - beta2) * p.grad[i] * p.grad[i];\n const mHat = m[i] / (1 - Math.pow(beta1, step + 1));\n const vHat = v[i] / (1 - Math.pow(beta2, step + 1));\n p.data[i] -= lrT * mHat / (Math.sqrt(vHat) + epsAdam);\n }\n }\n\n if (step % 100 === 0 || step === steps - 1) {\n const elapsed = ((Date.now() - t0) / 1000).toFixed(1);\n console.log(\n `step ${String(step + 1).padStart(4)} / ${steps} | loss ${\n loss.data[0].toFixed(4)\n } | ${elapsed}s`,\n );\n }\n }\n\n return { tokenizer, model, params };\n}\n\n// ---- Sampling ----\nfunction generateName(\n opts: {\n trained: Trained;\n maxNewTokens: number;\n temperature: number;\n seed: number;\n },\n): string {\n const {\n trained: { tokenizer, model, params },\n maxNewTokens,\n temperature,\n seed,\n } = opts;\n const rng = makeRng(seed);\n let tokens = new Int32Array([tokenizer.BOS]);\n\n for (let i = 0; i < maxNewTokens; i++) {\n const logits = model.forward(params, tokens);\n const T = tokens.length, V = tokenizer.vocabSize;\n // Take logits from the last position, apply temperature\n const lp = new Float32Array(V);\n for (let v = 0; v < V; v++) {\n lp[v] = logits.data[(T - 1) * V + v] / temperature;\n }\n // Softmax\n let mx = -Infinity;\n for (let v = 0; v < V; v++) mx = Math.max(mx, lp[v]);\n let s = 0;\n for (let v = 0; v < V; v++) {\n lp[v] = Math.exp(lp[v] - mx);\n s += lp[v];\n }\n for (let v = 0; v < V; v++) lp[v] /= s;\n // Sample from distribution\n const r = rng();\n let cum = 0, next = 0;\n for (let v = 0; v < V; v++) {\n cum += lp[v];\n if (r < cum) {\n next = v;\n break;\n }\n }\n if (next === tokenizer.BOS) break; // BOS doubles as end-of-name\n const newTokens = new Int32Array(tokens.length + 1);\n newTokens.set(tokens);\n newTokens[tokens.length] = next;\n tokens = newTokens;\n }\n\n return tokenizer.decode(tokens);\n}\n\n// ============================================================================\n// main script\n// ============================================================================\n\nconst docs = await loadDocs();\nconsole.log(`num docs: ${docs.length}`);\n\nconst tok = buildCharTokenizerFromDocs(docs);\nconsole.log(`vocab size: ${tok.vocabSize}`);\n\nconst model = makeTransformerLanguageModel({\n vocabSize: tok.vocabSize, // 27 (a-z + BOS)\n maxLen: 8, // max sequence length (matches Karpathy's block_size)\n dModel: 16, // embedding dimension (matches Karpathy's n_embd)\n nHeads: 4, // attention heads (matches Karpathy's n_head)\n nLayers: 1, // transformer blocks (matches Karpathy's n_layer)\n dFF: 64, // feedforward hidden dim (4 * dModel, matches Karpathy)\n});\n\nconst trained = trainNameModel({\n docs,\n tokenizer: tok,\n model,\n steps: 1000, // same as Karpathy\n maxLen: 8, // crop sequences to block_size\n seed: 42, // same seed as Karpathy\n learningRate: 0.01, // same as Karpathy\n});\n\nconsole.log(\"\\n--- generation ---\");\nArray.from({ length: 20 }, (_, i) => i + 1)\n .map((i) =>\n generateName({\n trained,\n maxNewTokens: 8, // max name length = block_size\n temperature: 0.7, // balance between variety and quality\n seed: i * 7919, // spread seeds far apart for diversity (7919 is prime)\n })\n )\n .forEach((name, i) =>\n console.log(`sample ${String(i + 1).padStart(2, \" \")}: ${name}`)\n );","deleted","label",[100],"permalink","https://www.val.town/x/stevekrouse/microgpt/code/main.ts","extension","actionData","errors"]