Clean up debug diagnostics now that WebGPU works end-to-end

mega-asr.js

@@ -309,19 +309,11 @@ async function transcribe({ mel, dims, T_mel }) {
   if (!state.loaded) throw new Error("models not loaded");
   // 1. encode
   setStatus("audio encoder ...");
-  let melTensor;
-  try { melTensor = new ort.Tensor("float32", mel, dims); }
-  catch (e) { log(`[step] Tensor ctor failed: ${e.message || e}`); throw e; }
-  log(`[step] running encoder ...`);
-  let encOut;
-  try { encOut = await state.encoder.run({ mel: melTensor }); }
-  catch (e) { log(`[step] encoder.run failed: ${e.message || e}`); throw e; }
-  log(`[step] encoder ok; reading audio_embeds ...`);
-  let audioEmbedsAll;
-  try { audioEmbedsAll = await encOut.audio_embeds.getData(true); }
-  catch (e) { log(`[step] getData failed: ${e.message || e}`); throw e; }
-  log(`[step] audio_embeds len=${audioEmbedsAll.length} dtype=${audioEmbedsAll.constructor.name}`);
-  const audioEmbedsDims = encOut.audio_embeds.dims; // [1, 390, 2048]
+  const melTensor = new ort.Tensor("float32", mel, dims);
+  const encOut = await state.encoder.run({ mel: melTensor });
+  // WebGPU outputs live in GPU memory — getData(true) downloads to CPU.
+  const audioEmbedsAll = await encOut.audio_embeds.getData(true);
+  const audioEmbedsDims = encOut.audio_embeds.dims;
   const realChunks = Math.floor((T_mel + 99) / 100);
   const lastChunkMel = T_mel - (realChunks - 1) * 100;
   const realAudioFrames = (realChunks - 1) * 13 + Math.floor((lastChunkMel + 7) / 8);
@@ -364,15 +356,11 @@ async function transcribe({ mel, dims, T_mel }) {
   // 4. prefill
   setStatus("prefill ...");
   const t0 = performance.now();
-  log(`[step] running prefill (L=${L}) ...`);
-  let prefillOut;
-  try {
-    prefillOut = await state.prefill.run({
-      inputs_embeds: new ort.Tensor("float16", inputsEmbedsF16, [1, L, HIDDEN]),
-      attention_mask: new ort.Tensor("int64", attnMask, [1, L]),
-      position_ids: new ort.Tensor("int64", posIds, [1, L]),
-    });
-  } catch (e) { log(`[step] prefill.run failed: ${e.message || e}`); throw e; }
+  const prefillOut = await state.prefill.run({
+    inputs_embeds: new ort.Tensor("float16", inputsEmbedsF16, [1, L, HIDDEN]),
+    attention_mask: new ort.Tensor("int64", attnMask, [1, L]),
+    position_ids: new ort.Tensor("int64", posIds, [1, L]),
+  });
   log(`prefill: ${(performance.now() - t0).toFixed(0)} ms (L=${L})`);
 
   // 5. greedy decode
@@ -381,33 +369,6 @@ async function transcribe({ mel, dims, T_mel }) {
   // them back to CPU. CPU/WASM tensors return their data array synchronously.
   let logits = await prefillOut.logits.getData(true); // (1, L, VOCAB)
   const logitsDims = prefillOut.logits.dims;
-  // Diagnostic
-  {
-    const off = (logitsDims[1] - 1) * VOCAB;
-    log(`logits type=${logits.constructor.name} len=${logits.length} dims=[${logitsDims.join(",")}] expect=${1 * logitsDims[1] * VOCAB}`);
-    const sample = [];
-    for (let i = 0; i < 8; i++) sample.push(String(logits[off + i]));
-    log(`first 8 logits at last pos: ${sample.join(", ")}`);
-    let nNaN = 0, nInf = 0, nNorm = 0, lo = Infinity, hi = -Infinity;
-    for (let i = 0; i < VOCAB; i++) {
-      const v = Number(logits[off + i]);
-      if (Number.isNaN(v)) nNaN++;
-      else if (!Number.isFinite(v)) nInf++;
-      else { nNorm++; if (v < lo) lo = v; if (v > hi) hi = v; }
-    }
-    log(`logit health: NaN=${nNaN} Inf=${nInf} finite=${nNorm}  range=[${lo.toFixed(2)}, ${hi.toFixed(2)}]`);
-    const idxs = [], vals = [];
-    for (let k = 0; k < 5; k++) {
-      let best = -Infinity, bi = -1;
-      for (let i = 0; i < VOCAB; i++) {
-        if (idxs.includes(i)) continue;
-        const v = Number(logits[off + i]);
-        if (Number.isFinite(v) && v > best) { best = v; bi = i; }
-      }
-      idxs.push(bi); vals.push(best);
-    }
-    log(`prefill top-5: ${idxs.map((i, k) => `${i}(${vals[k].toFixed(2)})`).join(" ")}`);
-  }
   // get argmax of last token
   let nid = argmax(logits, (logitsDims[1] - 1) * VOCAB, VOCAB);
   const gen = [nid];
@@ -482,28 +443,16 @@ function f32ToF16Bits(v) {
   return (sign << 15) | (newExp << 10) | (frac >> 13);
 }
 
-// Build fp16 storage: if browser has Float16Array, use it directly (ORT 1.20
-// validates the constructor). Otherwise build a Uint16Array of bit patterns
-// and view it as a Float16Array if available. Diagnostics: also dump the
-// first few converted values once so we can spot conversion errors.
+// Build fp16 storage: explicit Uint16 bit-pattern conversion (canonical
+// round-to-nearest-even). ORT 1.20+ validates that the data is a Float16Array
+// instance, so when available we return a Float16Array view over the same
+// buffer (no copy).
 const HAS_F16 = typeof Float16Array !== "undefined";
-let _f16_diag_count = 0;
 
 function floatArrayToFp16(arr) {
-  // Build the u16 bit-pattern explicitly (canonical round-to-nearest-even)
   const u16 = new Uint16Array(arr.length);
   for (let i = 0; i < arr.length; i++) u16[i] = f32ToF16Bits(arr[i]);
-  if (HAS_F16) {
-    // View the same buffer as Float16Array so ORT's type validation passes.
-    const f16 = new Float16Array(u16.buffer, u16.byteOffset, u16.length);
-    if (_f16_diag_count === 0) {
-      _f16_diag_count = 1;
-      const sample = [];
-      for (let i = 0; i < Math.min(5, arr.length); i++) sample.push(arr[i].toFixed(4) + "->" + f16[i].toFixed(4));
-      log(`fp16 sanity: ${sample.join("  ")}`);
-    }
-    return f16;
-  }
+  if (HAS_F16) return new Float16Array(u16.buffer, u16.byteOffset, u16.length);
   return u16;
 }
 
@@ -589,7 +538,7 @@ document.getElementById("transcribe-btn").addEventListener("click", async () =>
     }
     const text = await transcribe({ mel, dims, T_mel });
     const elapsed = (performance.now() - t0) / 1000;
-    renderResult(text, refText, `INT4 ONNX · ${state.device} · ${elapsed.toFixed(1)}s`);
+    renderResult(text, refText, `INT4 enc + GPTQ-INT4 dec · ${state.device} · ${elapsed.toFixed(1)}s`);
   } catch (e) {
     const msg = (e && (e.message || e.toString())) || JSON.stringify(e) || "(no error info)";
     const stk = (e && e.stack) ? e.stack.split("\n").slice(0, 3).join(" | ") : "(no stack)";