volvoxai 0.1.0

package/js/ops/batchNorm2D.js

@@ -0,0 +1,28 @@
+export function _cpuBatchNorm2D(node) {
+    const input = node.inputs.input || node.inputs.x;
+    const weight = node.inputs.weight || node.inputs.scale;
+    const bias = node.inputs.bias || node.inputs.b;
+    const running_mean = node.inputs.running_mean || node.inputs.mean;
+    const running_var = node.inputs.running_var || node.inputs.var;
+    const outBuf = node.outputs.out.buffer;
+    
+    const [b, h, w, c] = input.shape;
+    const eps = node.params.eps || 1e-5;
+    
+    for (let batch = 0; batch < b; batch++) {
+        for (let chan = 0; chan < c; chan++) {
+            const w_val = weight.buffer[chan];
+            const b_val = bias ? bias.buffer[chan] : 0.0;
+            const rm_val = running_mean.buffer[chan];
+            const rv_val = running_var.buffer[chan];
+            
+            for (let y = 0; y < h; y++) {
+                for (let x = 0; x < w; x++) {
+                    const idx = ((batch * h + y) * w + x) * c + chan;
+                    const val = input.buffer[idx];
+                    outBuf[idx] = ((val - rm_val) / Math.sqrt(rv_val + eps)) * w_val + b_val;
+                }
+            }
+        }
+    }
+}

package/js/ops/cast.js

@@ -0,0 +1,19 @@
+export function _cpuCast(node) {
+
+    // Activations are Float32 throughout this engine, so a Cast is a plain copy.
+    // If the target is an integer ONNX dtype we truncate toward zero to match
+    // the numeric result of a real cast (e.g. float indices -> int32).
+    const input = node.inputs.input || node.inputs.data;
+    const output = node.outputs.out;
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    const to = node.params.to;
+    const intCast = to === "int32" || to === "int64" || to === "int8"
+                 || to === 3 || to === 5 || to === 6 || to === 7;
+    const n = Math.min(inBuf.length, outBuf.length);
+    if (intCast) {
+      for (let i = 0; i < n; i++) outBuf[i] = Math.trunc(inBuf[i]);
+    } else {
+      outBuf.set(inBuf.subarray(0, n));
+    }
+  }

package/js/ops/clip.js

@@ -0,0 +1,15 @@
+export function _cpuClip(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    let min = node.params.min !== undefined ? node.params.min : -Infinity;
+    let max = node.params.max !== undefined ? node.params.max : Infinity;
+    if (node.inputs.min) min = node.inputs.min.buffer[0];
+    if (node.inputs.max) max = node.inputs.max.buffer[0];
+    for (let i = 0; i < input.buffer.length; i++) {
+      let v = input.buffer[i];
+      if (v < min) v = min;
+      if (v > max) v = max;
+      output.buffer[i] = v;
+    }
+  }

package/js/ops/concat2.js

@@ -0,0 +1,18 @@
+export function _cpuConcat2(node) {
+
+    // N-way concat for the blueprint keys emitted by exporters: input0, input1, ...
+    // Current model packages concatenate flattened detection heads, so flat append is
+    // enough for the supported axis layouts.
+    const outBuf = node.outputs.out.buffer;
+    let off = 0;
+    const entries = Object.entries(node.inputs).sort(([a], [b]) => {
+      const ai = /^input(\d+)$/.exec(a);
+      const bi = /^input(\d+)$/.exec(b);
+      if (ai && bi) return Number(ai[1]) - Number(bi[1]);
+      return a.localeCompare(b);
+    });
+    for (const [, t] of entries) {
+      outBuf.set(t.buffer, off);
+      off += t.buffer.length;
+    }
+  }

package/js/ops/conv1D.js

@@ -0,0 +1,35 @@
+import { _pair } from '../Tensor.js';
+
+export function _cpuConv1D(node) {
+
+    const input = node.inputs.input;
+    const weight = node.inputs.weight;
+    const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+    const output = node.outputs.out;
+    const [in_c, in_l] = input.shape.slice(1);
+    const [out_c, k_c, k] = weight.shape;
+    const out_l = output.shape[2];
+    const stride = _pair(node.params.stride, 1)[0];
+    const padding = _pair(node.params.padding, 0)[0];
+    const relu = node.params.relu;
+    const inBuf = input.buffer;
+    const wBuf = weight.buffer;
+    const outBuf = output.buffer;
+    for (let oc = 0; oc < out_c; oc++) {
+      for (let x = 0; x < out_l; x++) {
+        let sum = bias ? bias[oc] : 0;
+        for (let ic = 0; ic < in_c; ic++) {
+          for (let k_idx = 0; k_idx < k; k_idx++) {
+            const ix = x * stride + k_idx - padding;
+            if (ix >= 0 && ix < in_l) {
+              const in_idx = ic * in_l + ix;
+              const w_idx = (oc * in_c + ic) * k + k_idx;
+              sum += inBuf[in_idx] * wBuf[w_idx];
+            }
+          }
+        }
+        if (relu && sum < 0) sum = 0;
+        outBuf[oc * out_l + x] = sum;
+      }
+    }
+  }

package/js/ops/conv2D.js

@@ -0,0 +1,70 @@
+import { _pair } from '../Tensor.js';
+
+export function _cpuConv2D(node) {
+
+    const input = node.inputs.input;
+    const weight = node.inputs.weight;
+    const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+    const output = node.outputs.out;
+    const [batch, in_h, in_w, in_c] = input.shape;
+    const [k_h, k_w] = weight.shape;
+    const out_c = output.shape[3];
+    const out_h = output.shape[1];
+    const out_w = output.shape[2];
+    const [stride_y, stride_x] = _pair(node.params.stride, 1);
+    const [pad_y, pad_x] = _pair(node.params.padding, 0);
+    const pads = node.params.pads || [pad_y, pad_x, pad_y, pad_x];
+    const [dil_y, dil_x] = _pair(node.params.dilation, 1);
+    const inBuf = input.buffer;
+    const wBuf = weight.buffer;
+    const outBuf = output.buffer;
+    const groups = node.params.groups || 1;
+    const group_out = out_c / groups;
+    const group_in = weight.shape[2];
+    for (let b = 0; b < batch; b++) {
+      for (let oh = 0; oh < out_h; oh++) {
+        for (let ow = 0; ow < out_w; ow++) {
+          for (let oc = 0; oc < out_c; oc++) {
+            let sum = 0;
+            if (groups === in_c) {
+              const mult = out_c / in_c;
+              const ic = Math.floor(oc / mult);
+              const m = oc - ic * mult;
+              for (let kh = 0; kh < k_h; kh++) {
+                for (let kw = 0; kw < k_w; kw++) {
+                  const ih = oh * stride_y + kh * dil_y - pads[0];
+                  const iw = ow * stride_x + kw * dil_x - pads[1];
+                  if (ih >= 0 && ih < in_h && iw >= 0 && iw < in_w) {
+                    const in_idx = ((b * in_h + ih) * in_w + iw) * in_c + ic;
+                    const w_idx = (((kh * k_w + kw) * in_c + ic) * mult) + m;
+                    sum += inBuf[in_idx] * wBuf[w_idx];
+                  }
+                }
+              }
+            } else {
+              const g = Math.floor(oc / group_out);
+              const in_start = g * group_in;
+              for (let icl = 0; icl < group_in; icl++) {
+                const ic = in_start + icl;
+                for (let kh = 0; kh < k_h; kh++) {
+                  for (let kw = 0; kw < k_w; kw++) {
+                    const ih = oh * stride_y + kh * dil_y - pads[0];
+                    const iw = ow * stride_x + kw * dil_x - pads[1];
+                    if (ih >= 0 && ih < in_h && iw >= 0 && iw < in_w) {
+                      const in_idx = ((b * in_h + ih) * in_w + iw) * in_c + ic;
+                      const w_idx = (((kh * k_w + kw) * group_in + icl) * out_c) + oc;
+                      sum += inBuf[in_idx] * wBuf[w_idx];
+                    }
+                  }
+                }
+              }
+            }
+            if (bias) sum += bias[oc];
+            if (node.params.relu === 1 && sum < 0) sum = 0;
+            else if (node.params.relu >= 2) sum = Math.min(Math.max(sum, 0), 6);
+            outBuf[((b * out_h + oh) * out_w + ow) * out_c + oc] = sum;
+          }
+        }
+      }
+    }
+  }

package/js/ops/convTranspose2D.js

@@ -0,0 +1,45 @@
+export function _cpuConvTranspose2D(node) {
+    const input = node.inputs.input || node.inputs.x;
+    const weight = node.inputs.weight;
+    const bias = node.inputs.bias;
+    
+    const inBuf = input.buffer;
+    const wBuf = weight.buffer;
+    const bBuf = bias ? bias.buffer : null;
+    const outBuf = node.outputs.out.buffer;
+    
+    const [b, in_h, in_w, in_c] = input.shape;
+    const [out_b, out_h, out_w, out_c] = node.outputs.out.shape;
+    const kh = node.params.kernel[0], kw = node.params.kernel[1];
+    const sh = node.params.stride ? node.params.stride[0] : 1;
+    const sw = node.params.stride ? node.params.stride[1] : 1;
+    const ph = node.params.padding ? node.params.padding[0] : 0;
+    const pw = node.params.padding ? node.params.padding[1] : 0;
+    
+    // Zero initialize output
+    for (let i = 0; i < outBuf.length; i++) {
+        outBuf[i] = bBuf ? bBuf[i % out_c] : 0.0;
+    }
+    
+    for (let i_b = 0; i_b < b; i_b++) {
+        for (let i_ic = 0; i_ic < in_c; i_ic++) {
+            for (let iy = 0; iy < in_h; iy++) {
+                for (let ix = 0; ix < in_w; ix++) {
+                    const in_val = inBuf[((i_b * in_h + iy) * in_w + ix) * in_c + i_ic];
+                    for (let oc = 0; oc < out_c; oc++) {
+                        for (let ky = 0; ky < kh; ky++) {
+                            for (let kx = 0; kx < kw; kx++) {
+                                const oy = iy * sh - ph + ky;
+                                const ox = ix * sw - pw + kx;
+                                if (oy >= 0 && oy < out_h && ox >= 0 && ox < out_w) {
+                                    const w_val = wBuf[i_ic * (out_c * kh * kw) + oc * (kh * kw) + ky * kw + kx];
+                                    outBuf[((i_b * out_h + oy) * out_w + ox) * out_c + oc] += in_val * w_val;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}

package/js/ops/crossAttention.js

@@ -0,0 +1,69 @@
+export function _cpuCrossAttention(node) {
+
+    const q_in = node.inputs.q.buffer;
+    const kv_in = node.inputs.kv.buffer;
+    const wBuf = node.inputs.weight.buffer;
+    const scale = node.inputs.scale ? node.inputs.scale.buffer : null;
+    const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+    const outBuf = node.outputs.out.buffer;
+    const seq_len_q = node.inputs.q.shape[1];
+    const seq_len_kv = node.inputs.kv.shape[1];
+    const d_model = node.outputs.out.shape[2];
+    const num_heads = node.params.heads || 8;
+    const head_dim = d_model / num_heads;
+    const scale_factor = 1 / Math.sqrt(head_dim);
+    for (let h = 0; h < num_heads; h++) {
+      for (let q = 0; q < seq_len_q; q++) {
+        const q_proj = new Float32Array(head_dim);
+        for (let d = 0; d < head_dim; d++) {
+          let sum = 0;
+          const out_col = h * head_dim + d;
+          for (let i = 0; i < d_model; i++) {
+            sum += q_in[q * d_model + i] * wBuf[out_col * d_model + i];
+          }
+          if (scale) sum *= scale[out_col];
+          if (bias) sum += bias[out_col];
+          q_proj[d] = sum;
+        }
+        const logits = new Float32Array(seq_len_kv);
+        let max_logit = -Infinity;
+        for (let k = 0; k < seq_len_kv; k++) {
+          let score = 0;
+          for (let d = 0; d < head_dim; d++) {
+            let k_val = 0;
+            const out_col = d_model + h * head_dim + d;
+            for (let i = 0; i < d_model; i++) {
+              k_val += kv_in[k * d_model + i] * wBuf[out_col * d_model + i];
+            }
+            if (scale) k_val *= scale[out_col];
+            if (bias) k_val += bias[out_col];
+            score += q_proj[d] * k_val;
+          }
+          score *= scale_factor;
+          logits[k] = score;
+          if (score > max_logit) max_logit = score;
+        }
+        let sum_exp = 0;
+        for (let k = 0; k < seq_len_kv; k++) {
+          const exp_val = Math.exp(logits[k] - max_logit);
+          logits[k] = exp_val;
+          sum_exp += exp_val;
+        }
+        for (let d = 0; d < head_dim; d++) {
+          let out_val = 0;
+          for (let k = 0; k < seq_len_kv; k++) {
+            const w = logits[k] / sum_exp;
+            let v_val = 0;
+            const out_col = d_model * 2 + h * head_dim + d;
+            for (let i = 0; i < d_model; i++) {
+              v_val += kv_in[k * d_model + i] * wBuf[out_col * d_model + i];
+            }
+            if (scale) v_val *= scale[out_col];
+            if (bias) v_val += bias[out_col];
+            out_val += w * v_val;
+          }
+          outBuf[q * d_model + h * head_dim + d] = out_val;
+        }
+      }
+    }
+  }

package/js/ops/crossSDPA.js

@@ -0,0 +1,41 @@
+export function _cpuCrossSDPA(node) {
+
+    const q = node.inputs.q.buffer;
+    const k = node.inputs.k.buffer;
+    const v = node.inputs.v.buffer;
+    const outBuf = node.outputs.out.buffer;
+    const seqQ = node.inputs.q.shape[1];
+    const seqKV = node.inputs.k.shape[1];
+    const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+    const heads = node.params.heads || 8;
+    const head_dim = d_model / heads;
+    const scale = 1 / Math.sqrt(head_dim);
+    for (let h = 0; h < heads; h++) {
+      for (let qi = 0; qi < seqQ; qi++) {
+        const logits = new Float32Array(seqKV);
+        let mx = -Infinity;
+        for (let ki = 0; ki < seqKV; ki++) {
+          let s = 0;
+          for (let d = 0; d < head_dim; d++) {
+            s += q[qi * d_model + h * head_dim + d] * k[ki * d_model + h * head_dim + d];
+          }
+          s *= scale;
+          logits[ki] = s;
+          if (s > mx) mx = s;
+        }
+        let sum = 0;
+        for (let ki = 0; ki < seqKV; ki++) {
+          const e = Math.exp(logits[ki] - mx);
+          logits[ki] = e;
+          sum += e;
+        }
+        for (let d = 0; d < head_dim; d++) {
+          let o = 0;
+          for (let ki = 0; ki < seqKV; ki++) {
+            o += (logits[ki] / sum) * v[ki * d_model + h * head_dim + d];
+          }
+          outBuf[qi * d_model + h * head_dim + d] = o;
+        }
+      }
+    }
+  }

package/js/ops/dequantizeLinear.js

@@ -0,0 +1,9 @@
+export function _cpuDequantizeLinear(node) {
+    const inBuf = node.inputs.input.buffer;
+    const scale = node.inputs.scale.buffer[0];
+    const zp = node.inputs.zero_point ? node.inputs.zero_point.buffer[0] : 0.0;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < outBuf.length; i++) {
+        outBuf[i] = (inBuf[i] - zp) * scale;
+    }
+}

package/js/ops/div.js

@@ -0,0 +1,15 @@
+export function _cpuDiv(node) {
+
+    const a = node.inputs.a;
+    const b = node.inputs.b;
+    const out = node.outputs.out;
+    const aBuf = a.buffer;
+    const bBuf = b.buffer;
+    const outBuf = out.buffer;
+    if (bBuf.length === 1) {
+        for (let i = 0; i < aBuf.length; i++) outBuf[i] = aBuf[i] / bBuf[0];
+    } else {
+        // Broadcast fallback assuming b is same size or inner dimension broadcasting
+        for (let i = 0; i < aBuf.length; i++) outBuf[i] = aBuf[i] / bBuf[i % bBuf.length];
+    }
+  }

package/js/ops/embedding.js

@@ -0,0 +1,14 @@
+export function _cpuEmbedding(node) {
+
+    const tokens = node.inputs.input.buffer;
+    const wBuf = node.inputs.weight.buffer;
+    const outBuf = node.outputs.out.buffer;
+    const d_model = node.outputs.out.shape[node.outputs.out.shape.length - 1];
+    const seq_len = tokens.length;
+    for (let i = 0; i < seq_len; i++) {
+      const token_id = tokens[i];
+      for (let j = 0; j < d_model; j++) {
+        outBuf[i * d_model + j] = wBuf[token_id * d_model + j];
+      }
+    }
+  }

package/js/ops/expand.js

@@ -0,0 +1,24 @@
+export function _cpuExpand(node) {
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    if (inBuf.length === 1) {
+        for (let i = 0; i < outBuf.length; i++) outBuf[i] = inBuf[0];
+    } else if (inBuf.length === outBuf.length) {
+        outBuf.set(inBuf);
+    } else {
+        const pad4 = (sh) => [1, 1, 1, 1].slice(0, 4 - sh.length).concat(sh);
+        const [ib, ih, iw, ic] = pad4(node.inputs.input.shape);
+        const [ob, oh, ow, oc] = pad4(node.outputs.out.shape);
+        for (let b = 0; b < ob; b++) {
+            for (let y = 0; y < oh; y++) {
+                for (let x = 0; x < ow; x++) {
+                    for (let c = 0; c < oc; c++) {
+                        const src = (((b % ib) * ih + (y % ih)) * iw + (x % iw)) * ic + (c % ic);
+                        const dst = ((b * oh + y) * ow + x) * oc + c;
+                        outBuf[dst] = inBuf[src];
+                    }
+                }
+            }
+        }
+    }
+}

package/js/ops/gELU.js

@@ -0,0 +1,9 @@
+export function _cpuGELU(node) {
+
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < inBuf.length; i++) {
+      const x = inBuf[i];
+      outBuf[i] = 0.5 * x * (1 + Math.tanh(0.7978845608 * (x + 0.044715 * x * x * x)));
+    }
+  }

package/js/ops/gather.js

@@ -0,0 +1,51 @@
+export function _cpuGather(node) {
+
+    const input = node.inputs.input;
+    const indices = node.inputs.indices;
+    const out = node.outputs.out;
+    let axis = node.params.axis || 0;
+    if (axis < 0) axis += input.shape.length;
+    
+    const inShape = input.shape;
+    const outShape = out.shape;
+    const idxShape = indices.shape;
+    
+    let inStrides = new Array(inShape.length);
+    let s = 1; for (let i = inShape.length - 1; i >= 0; i--) { inStrides[i] = s; s *= inShape[i]; }
+    
+    let outStrides = new Array(outShape.length);
+    s = 1; for (let i = outShape.length - 1; i >= 0; i--) { outStrides[i] = s; s *= outShape[i]; }
+    
+    let idxStrides = new Array(idxShape.length);
+    s = 1; for (let i = idxShape.length - 1; i >= 0; i--) { idxStrides[i] = s; s *= idxShape[i]; }
+    
+    for (let i = 0; i < out.buffer.length; i++) {
+        let temp = i;
+        let outCoords = new Array(outShape.length);
+        for (let d = 0; d < outShape.length; d++) {
+            outCoords[d] = Math.floor(temp / outStrides[d]);
+            temp %= outStrides[d];
+        }
+        
+        let idxOffset = 0;
+        for (let d = 0; d < idxShape.length; d++) {
+            idxOffset += outCoords[axis + d] * idxStrides[d];
+        }
+        
+        let gatherIdx = indices.buffer[idxOffset];
+        if (gatherIdx < 0) {
+            out.buffer[i] = -1;
+            continue;
+        }
+        let inOffset = 0;
+        for (let d = 0; d < axis; d++) {
+            inOffset += outCoords[d] * inStrides[d];
+        }
+        inOffset += gatherIdx * inStrides[axis];
+        for (let d = axis + 1; d < inShape.length; d++) {
+            inOffset += outCoords[d - 1 + idxShape.length] * inStrides[d];
+        }
+        
+        out.buffer[i] = input.buffer[inOffset];
+    }
+  }

package/js/ops/gatherElements.js

@@ -0,0 +1,33 @@
+export function _cpuGatherElements(node) {
+
+    // ONNX GatherElements: output has the same shape as `indices`; each element
+    // pulls from `data` at the same coordinates but with the `axis` coordinate
+    // replaced by the corresponding index value.
+    const data = node.inputs.input || node.inputs.data;
+    const indices = node.inputs.indices;
+    const out = node.outputs.out;
+    const dBuf = data.buffer;
+    const iBuf = indices.buffer;
+    const oBuf = out.buffer;
+    const dShape = data.shape;
+    const iShape = indices.shape;
+    let axis = node.params.axis !== undefined ? node.params.axis : 0;
+    if (axis < 0) axis += dShape.length;
+
+    const dStrides = new Array(dShape.length);
+    { let s = 1; for (let k = dShape.length - 1; k >= 0; k--) { dStrides[k] = s; s *= dShape[k]; } }
+    const iStrides = new Array(iShape.length);
+    { let s = 1; for (let k = iShape.length - 1; k >= 0; k--) { iStrides[k] = s; s *= iShape[k]; } }
+
+    const rank = iShape.length;
+    const coord = new Array(rank);
+    for (let lin = 0; lin < oBuf.length; lin++) {
+      let rem = lin;
+      for (let k = 0; k < rank; k++) { coord[k] = Math.floor(rem / iStrides[k]); rem %= iStrides[k]; }
+      let idx = iBuf[lin] | 0;
+      if (idx < 0) idx += dShape[axis];
+      let off = 0;
+      for (let k = 0; k < rank; k++) off += (k === axis ? idx : coord[k]) * dStrides[k];
+      oBuf[lin] = dBuf[off];
+    }
+  }

package/js/ops/globalAveragePool.js

@@ -0,0 +1,21 @@
+export function _cpuGlobalAveragePool(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const B = input.shape[0];
+    const H = input.shape[1];
+    const W = input.shape[2];
+    const C = input.shape[3];
+    const spatial = H * W;
+    for (let b = 0; b < B; b++) {
+      for (let c = 0; c < C; c++) {
+        let sum = 0;
+        for (let i = 0; i < spatial; i++) {
+          const y = Math.floor(i / W);
+          const x = i - y * W;
+          sum += input.buffer[((b * H + y) * W + x) * C + c];
+        }
+        output.buffer[b * C + c] = sum / spatial;
+      }
+    }
+  }

package/js/ops/hardSigmoid.js

@@ -0,0 +1,12 @@
+export function _cpuHardSigmoid(node) {
+
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < inBuf.length; i++) {
+        const x = inBuf[i];
+        let v = x + 3.0;
+        if (v < 0.0) v = 0.0;
+        else if (v > 6.0) v = 6.0;
+        outBuf[i] = v / 6.0;
+    }
+  }

package/js/ops/hardSwish.js

@@ -0,0 +1,12 @@
+export function _cpuHardSwish(node) {
+
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < inBuf.length; i++) {
+        const x = inBuf[i];
+        let v = x + 3.0;
+        if (v < 0.0) v = 0.0;
+        else if (v > 6.0) v = 6.0;
+        outBuf[i] = x * v / 6.0;
+    }
+  }

package/js/ops/interp1D.js

@@ -0,0 +1,25 @@
+export function _cpuInterp1D(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const [c, in_l] = input.shape.slice(1);
+    const out_l = node.params.size;
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    // Half-pixel (align_corners=false) mapping, matching interp1d_f32 and the
+    // WebGPU shader (PyTorch F.interpolate default).
+    const scale = in_l / out_l;
+    for (let ch = 0; ch < c; ch++) {
+      for (let x = 0; x < out_l; x++) {
+        let pos = (x + 0.5) * scale - 0.5;
+        if (pos < 0) pos = 0;
+        if (pos > in_l - 1) pos = in_l - 1;
+        const x0 = Math.floor(pos);
+        const x1 = x0 + 1 < in_l ? x0 + 1 : x0;
+        const dx = pos - x0;
+        const v0 = inBuf[ch * in_l + x0];
+        const v1 = inBuf[ch * in_l + x1];
+        outBuf[ch * out_l + x] = v0 + dx * (v1 - v0);
+      }
+    }
+  }

package/js/ops/layerNorm.js

@@ -0,0 +1,25 @@
+export function _cpuLayerNorm(node) {
+
+    const inBuf = node.inputs.input.buffer;
+    const wBuf = node.inputs.weight.buffer;
+    const bBuf = node.inputs.bias.buffer;
+    const outBuf = node.outputs.out.buffer;
+    const d_model = node.params.d_model;
+    const seq_len = node.inputs.input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+    for (let i = 0; i < seq_len; i++) {
+      const offset = i * d_model;
+      let sum = 0, sq_sum = 0;
+      for (let j = 0; j < d_model; j++) {
+        const val = inBuf[offset + j];
+        sum += val;
+        sq_sum += val * val;
+      }
+      const mean = sum / d_model;
+      const variance = sq_sum / d_model - mean * mean;
+      const inv_std = 1 / Math.sqrt(variance + 1e-5);
+      for (let j = 0; j < d_model; j++) {
+        const norm_val = (inBuf[offset + j] - mean) * inv_std;
+        outBuf[offset + j] = norm_val * wBuf[j] + bBuf[j];
+      }
+    }
+  }

package/js/ops/leakyReLU.js

@@ -0,0 +1,10 @@
+export function _cpuLeakyReLU(node) {
+
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    const alpha = node.params.alpha !== undefined ? node.params.alpha : 0.01;
+    for (let i = 0; i < inBuf.length; i++) {
+        const v = inBuf[i];
+        outBuf[i] = v > 0 ? v : alpha * v;
+    }
+  }

package/js/ops/logSoftmax.js

@@ -0,0 +1,15 @@
+export function _cpuLogSoftmax(node) {
+    const input = node.inputs.input || node.inputs.x;
+    const outBuf = node.outputs.out.buffer;
+    const in_shape = input.shape.length === 2 ? input.shape : [1, input.buffer.length];
+    const b = in_shape[0];
+    const d = in_shape[1];
+    for (let i = 0; i < b; i++) {
+        let max = -Infinity;
+        for (let j = 0; j < d; j++) max = Math.max(max, input.buffer[i * d + j]);
+        let sum = 0.0;
+        for (let j = 0; j < d; j++) sum += Math.exp(input.buffer[i * d + j] - max);
+        const logSum = Math.log(sum);
+        for (let j = 0; j < d; j++) outBuf[i * d + j] = (input.buffer[i * d + j] - max) - logSum;
+    }
+}