volvoxai 0.1.0

package/js/ops/matMul.js

@@ -0,0 +1,35 @@
+export function _cpuMatMul(node) {
+
+    const input = node.inputs.input;
+    const weight = node.inputs.weight;
+    const output = node.outputs.out;
+    const M = input.shape.slice(0, -1).reduce((a, b) => a * b, 1);
+    const K = input.shape[input.shape.length - 1];
+    const N = output.shape[output.shape.length - 1];
+    const inBuf = input.buffer;
+    const wBuf = weight.buffer;
+    const outBuf = output.buffer;
+    const scale = node.inputs.scale ? node.inputs.scale.buffer : null;
+    const bias = node.inputs.bias ? node.inputs.bias.buffer : null;
+    // Two weight layouts coexist: PyTorch Linear stores [d_out, d_in] (out = x·Wᵀ),
+    // while GPT-Neo/Conv1D stores [d_in, d_out] (out = x·W). Detect by shape so both
+    // model families work. INT8-quantized weights are always [d_out, d_in] + per-out scale.
+    const w0 = weight.shape.length >= 2 ? weight.shape[0] : N;
+    const w1 = weight.shape.length >= 2 ? weight.shape[1] : K;
+    // Prefer the per-node layout resolved at load (handles square weights); fall back to
+    // shape detection. 'dout' = [d_out, d_in] (x·Wᵀ), 'din' = [d_in, d_out] (x·W).
+    const doutFirst = scale ? true : (node.wLayout ? node.wLayout === "dout" : (w0 === N && w1 === K));
+    for (let i = 0; i < M; i++) {
+      for (let j = 0; j < N; j++) {
+        let sum = 0;
+        if (doutFirst) {
+          for (let k = 0; k < K; k++) sum += inBuf[i * K + k] * wBuf[j * K + k];
+        } else {
+          for (let k = 0; k < K; k++) sum += inBuf[i * K + k] * wBuf[k * N + j];
+        }
+        if (scale) sum *= scale[j];
+        if (bias) sum += bias[j];
+        outBuf[i * N + j] = sum;
+      }
+    }
+  }

package/js/ops/maxPool2D.js

@@ -0,0 +1,36 @@
+export function _cpuMaxPool2D(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const [n, h, w, c] = input.shape;
+    const ky = node.params.kernel[0];
+    const kx = node.params.kernel[1];
+    const sy = node.params.stride[0];
+    const sx = node.params.stride[1];
+    const pad_y = node.params.padding ? node.params.padding[0] : 0;
+    const pad_x = node.params.padding ? node.params.padding[1] : 0;
+    const out_h = output.shape[1];
+    const out_w = output.shape[2];
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    for (let b = 0; b < n; b++) {
+      for (let oy = 0; oy < out_h; oy++) {
+        for (let ox = 0; ox < out_w; ox++) {
+          for (let ch = 0; ch < c; ch++) {
+            let best = -Infinity;
+            for (let dy = 0; dy < ky; dy++) {
+              for (let dx = 0; dx < kx; dx++) {
+                const ih = oy * sy + dy - pad_y;
+                const iw = ox * sx + dx - pad_x;
+                if (ih >= 0 && ih < h && iw >= 0 && iw < w) {
+                  const v = inBuf[((b * h + ih) * w + iw) * c + ch];
+                  if (v > best) best = v;
+                }
+              }
+            }
+            outBuf[((b * out_h + oy) * out_w + ox) * c + ch] = best;
+          }
+        }
+      }
+    }
+  }

package/js/ops/meanHeight.js

@@ -0,0 +1,17 @@
+export function _cpuMeanHeight(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const [, h, w, c] = input.shape;
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    for (let ch = 0; ch < c; ch++) {
+      for (let x = 0; x < w; x++) {
+        let sum = 0;
+        for (let y = 0; y < h; y++) {
+          sum += inBuf[(y * w + x) * c + ch];
+        }
+        outBuf[ch * w + x] = sum / h;
+      }
+    }
+  }

package/js/ops/mul.js

@@ -0,0 +1,31 @@
+export function _cpuMul(node) {
+
+    const a = node.inputs.a;
+    const b = node.inputs.b;
+    const outBuf = node.outputs.out.buffer;
+    let aBuf = a.buffer;
+    let bBuf = b.buffer;
+    let aShape = a.shape;
+    let bShape = b.shape;
+    
+    // Swap to ensure a is the larger tensor
+    if (aBuf.length < bBuf.length) {
+        let temp = aBuf; aBuf = bBuf; bBuf = temp;
+        let tempS = aShape; aShape = bShape; bShape = tempS;
+    }
+    
+    const elements = aBuf.length;
+    if (bBuf.length === 1) {
+      for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[0];
+    } else if (bBuf.length === elements) {
+      for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[i];
+    } else if (aShape.length === 4 && bBuf.length === aShape[3]) {
+      const c = aShape[3];
+      for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[i % c];
+    } else if (aShape.length === 4 && bShape.length === 4 && bShape[0] === 1 && bShape[1] === 1 && bShape[2] === 1 && bShape[3] === aShape[3]) {
+      const c = aShape[3];
+      for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] * bBuf[i % c];
+    } else {
+      console.warn("[VolvoxAI CPU] Executing Mul is not fully implemented yet for shapes", a.shape, b.shape);
+    }
+  }

package/js/ops/nonMaxSuppression.js

@@ -0,0 +1,72 @@
+export function _cpuNonMaxSuppression(node) {
+
+    const boxes = node.inputs.boxes;
+    const scores = node.inputs.scores;
+    const out = node.outputs.out;
+    
+    let max_output_boxes_per_class = 0;
+    if (node.inputs.max_output_boxes_per_class) max_output_boxes_per_class = node.inputs.max_output_boxes_per_class.buffer[0];
+    let iou_threshold = 0.5;
+    if (node.inputs.iou_threshold) iou_threshold = node.inputs.iou_threshold.buffer[0];
+    let score_threshold = 0.0;
+    if (node.inputs.score_threshold) score_threshold = node.inputs.score_threshold.buffer[0];
+
+    const num_batches = boxes.shape[0];
+    const spatial_dimension = boxes.shape[1];
+    const num_classes = scores.shape[1];
+    
+    let outIdx = 0;
+    for (let b = 0; b < num_batches; b++) {
+        for (let c = 0; c < num_classes; c++) {
+            let candidates = [];
+            for (let s = 0; s < spatial_dimension; s++) {
+                const score = scores.buffer[b * (num_classes * spatial_dimension) + c * spatial_dimension + s];
+                if (score >= score_threshold) {
+                    const y1 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 0];
+                    const x1 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 1];
+                    const y2 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 2];
+                    const x2 = boxes.buffer[b * (spatial_dimension * 4) + s * 4 + 3];
+                    candidates.push({s, score, y1, x1, y2, x2});
+                }
+            }
+            candidates.sort((a, b_) => b_.score - a.score);
+            let selected = [];
+            for (let i = 0; i < candidates.length && selected.length < max_output_boxes_per_class; i++) {
+                const cand = candidates[i];
+                let keep = true;
+                for (let j = 0; j < selected.length; j++) {
+                    const sel = selected[j];
+                    const xx1 = Math.max(cand.x1, sel.x1);
+                    const yy1 = Math.max(cand.y1, sel.y1);
+                    const xx2 = Math.min(cand.x2, sel.x2);
+                    const yy2 = Math.min(cand.y2, sel.y2);
+                    const w = Math.max(0, xx2 - xx1);
+                    const h = Math.max(0, yy2 - yy1);
+                    const inter = w * h;
+                    const areaCand = (cand.x2 - cand.x1) * (cand.y2 - cand.y1);
+                    const areaSel = (sel.x2 - sel.x1) * (sel.y2 - sel.y1);
+                    const iou = inter / (areaCand + areaSel - inter);
+                    if (iou > iou_threshold) {
+                        keep = false;
+                        break;
+                    }
+                }
+                if (keep) {
+                    selected.push(cand);
+                    if (outIdx < out.buffer.length / 3) {
+                        out.buffer[outIdx * 3 + 0] = b;
+                        out.buffer[outIdx * 3 + 1] = c;
+                        out.buffer[outIdx * 3 + 2] = cand.s;
+                        outIdx++;
+                    }
+                }
+            }
+        }
+    }
+    while (outIdx < out.buffer.length / 3) {
+        out.buffer[outIdx * 3 + 0] = -1;
+        out.buffer[outIdx * 3 + 1] = -1;
+        out.buffer[outIdx * 3 + 2] = -1;
+        outIdx++;
+    }
+  }

package/js/ops/pReLU.js

@@ -0,0 +1,11 @@
+export function _cpuPReLU(node) {
+    const inBuf = (node.inputs.input || node.inputs.x).buffer;
+    const slope = (node.inputs.slope || node.inputs.weight).buffer;
+    const outBuf = node.outputs.out.buffer;
+    const shape = (node.inputs.input || node.inputs.x).shape || [];
+    const channels = shape.length === 4 ? shape[3] : slope.length;
+    for (let i = 0; i < outBuf.length; i++) {
+        const alpha = slope.length === channels ? slope[i % channels] : slope[i % slope.length];
+        outBuf[i] = inBuf[i] < 0.0 ? inBuf[i] * alpha : inBuf[i];
+    }
+}

package/js/ops/pad.js

@@ -0,0 +1,35 @@
+export function _cpuPad(node) {
+    const input = node.inputs.input || node.inputs.data;
+    const outBuf = node.outputs.out.buffer;
+    const pads = node.params.pads || [];
+    const val = node.params.value || 0.0;
+
+    let pt = 0, pb = 0, pl = 0, pr = 0;
+    if (pads.length === 8) {
+        pt = pads[1];
+        pl = pads[2];
+        pb = pads[5];
+        pr = pads[6];
+    } else if (pads.length === 4) {
+        pt = pads[0]; pl = pads[1]; pb = pads[2]; pr = pads[3];
+    }
+    
+    const inShape = input.shape.length === 4 ? input.shape : [1, input.shape[0] || 1, input.shape[1] || 1, 1];
+    const [b, in_h, in_w, c] = inShape;
+    const out_h = in_h + pt + pb;
+    const out_w = in_w + pl + pr;
+    
+    for (let i = 0; i < outBuf.length; i++) outBuf[i] = val;
+
+    for (let batch = 0; batch < b; batch++) {
+        for (let y = 0; y < in_h; y++) {
+            for (let x = 0; x < in_w; x++) {
+                for (let chan = 0; chan < c; chan++) {
+                    const inIdx = ((batch * in_h + y) * in_w + x) * c + chan;
+                    const outIdx = ((batch * out_h + (y + pt)) * out_w + (x + pl)) * c + chan;
+                    outBuf[outIdx] = input.buffer[inIdx];
+                }
+            }
+        }
+    }
+}

package/js/ops/profileX.js

@@ -0,0 +1,22 @@
+export function _cpuProfileX(node) {
+
+    // Column (W) profile: collapse H, keep W -> [1, 2c, w]. Mirrors C profile_x_f32.
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const [, h, w, c] = input.shape;
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    for (let ch = 0; ch < c; ch++) {
+      for (let x = 0; x < w; x++) {
+        let max_v = -Infinity;
+        let sum_v = 0;
+        for (let y = 0; y < h; y++) {
+          const v = inBuf[(y * w + x) * c + ch];
+          if (v > max_v) max_v = v;
+          sum_v += v;
+        }
+        outBuf[ch * w + x] = max_v;
+        outBuf[(c + ch) * w + x] = sum_v / h;
+      }
+    }
+  }

package/js/ops/profileY.js

@@ -0,0 +1,22 @@
+export function _cpuProfileY(node) {
+
+    // Row (H) profile: collapse W, keep H -> [1, 2c, h]. Mirrors C profile_y_f32.
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const [, h, w, c] = input.shape;
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    for (let ch = 0; ch < c; ch++) {
+      for (let y = 0; y < h; y++) {
+        let max_v = -Infinity;
+        let sum_v = 0;
+        for (let x = 0; x < w; x++) {
+          const v = inBuf[(y * w + x) * c + ch];
+          if (v > max_v) max_v = v;
+          sum_v += v;
+        }
+        outBuf[ch * h + y] = max_v;
+        outBuf[(c + ch) * h + y] = sum_v / w;
+      }
+    }
+  }

package/js/ops/rMSNorm.js

@@ -0,0 +1,14 @@
+export function _cpuRMSNorm(node) {
+    const input = node.inputs.input || node.inputs.x;
+    const weight = node.inputs.weight;
+    const outBuf = node.outputs.out.buffer;
+    const in_shape = input.shape.length === 2 ? input.shape : [1, input.buffer.length];
+    const b = in_shape[0], d = in_shape[1];
+    const eps = node.params.eps || 1e-5;
+    for (let i = 0; i < b; i++) {
+        let sq_sum = 0.0;
+        for (let j = 0; j < d; j++) sq_sum += input.buffer[i * d + j] * input.buffer[i * d + j];
+        const rms = Math.sqrt(sq_sum / d + eps);
+        for (let j = 0; j < d; j++) outBuf[i * d + j] = (input.buffer[i * d + j] / rms) * weight.buffer[j];
+    }
+}

package/js/ops/reLU.js

@@ -0,0 +1,8 @@
+export function _cpuReLU(node) {
+
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < inBuf.length; i++) {
+        outBuf[i] = inBuf[i] > 0 ? inBuf[i] : 0;
+    }
+  }

package/js/ops/reduceMean.js

@@ -0,0 +1,17 @@
+export function _cpuReduceMean(node) {
+    const input = node.inputs.input || node.inputs.data;
+    const inBuf = input.buffer;
+    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 sum = 0.0;
+        for (let j = 0; j < d; j++) {
+            sum += inBuf[i * d + j];
+        }
+        outBuf[i] = sum / d;
+    }
+}

package/js/ops/reduceSum.js

@@ -0,0 +1,19 @@
+export function _cpuReduceSum(node) {
+    const input = node.inputs.input || node.inputs.data;
+    const inBuf = input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    
+    // Simplistic reduce: flatten outer dimensions as batch, and reduce inner dimension
+    // Typically used for [B, D] -> [B, 1] or similar
+    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 sum = 0.0;
+        for (let j = 0; j < d; j++) {
+            sum += inBuf[i * d + j];
+        }
+        outBuf[i] = sum;
+    }
+}

package/js/ops/reshape.js

@@ -0,0 +1,6 @@
+export function _cpuReshape(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    output.buffer.set(input.buffer);
+  }

package/js/ops/resize.js

@@ -0,0 +1,44 @@
+export function _cpuResize(node) {
+
+    const inp = node.inputs.input, out = node.outputs.out;
+    const [b, inH, inW, c] = inp.shape;
+    const [, outH, outW] = out.shape;
+    const src = inp.buffer, dst = out.buffer;
+    if (node.opType === "ResizeNearest2D" || node.params.mode === "nearest") {
+      for (let n = 0; n < b; n++) {
+        for (let y = 0; y < outH; y++) {
+          let iy = Math.floor(y * inH / outH);
+          if (iy >= inH) iy = inH - 1;
+          for (let x = 0; x < outW; x++) {
+            let ix = Math.floor(x * inW / outW);
+            if (ix >= inW) ix = inW - 1;
+            for (let ch = 0; ch < c; ch++) {
+              dst[((n * outH + y) * outW + x) * c + ch] = src[((n * inH + iy) * inW + ix) * c + ch];
+            }
+          }
+        }
+      }
+      return;
+    }
+
+    // Bilinear, half-pixel (align_corners=False) to match PyTorch F.interpolate.
+    const sy = inH / outH, sx = inW / outW;
+    for (let n = 0; n < b; n++) {
+      for (let y = 0; y < outH; y++) {
+        let iy = (y + 0.5) * sy - 0.5; if (iy < 0) iy = 0;
+        const y0 = Math.min(inH - 1, Math.floor(iy)), y1 = Math.min(inH - 1, y0 + 1), dy = iy - y0;
+        for (let x = 0; x < outW; x++) {
+          let ix = (x + 0.5) * sx - 0.5; if (ix < 0) ix = 0;
+          const x0 = Math.min(inW - 1, Math.floor(ix)), x1 = Math.min(inW - 1, x0 + 1), dx = ix - x0;
+          for (let ch = 0; ch < c; ch++) {
+            const v00 = src[((n * inH + y0) * inW + x0) * c + ch];
+            const v01 = src[((n * inH + y0) * inW + x1) * c + ch];
+            const v10 = src[((n * inH + y1) * inW + x0) * c + ch];
+            const v11 = src[((n * inH + y1) * inW + x1) * c + ch];
+            dst[((n * outH + y) * outW + x) * c + ch] =
+              v00 * (1 - dy) * (1 - dx) + v01 * (1 - dy) * dx + v10 * dy * (1 - dx) + v11 * dy * dx;
+          }
+        }
+      }
+    }
+  }

package/js/ops/sDPA.js

@@ -0,0 +1,44 @@
+export function _cpuSDPA(node) {
+
+    const qkv = node.inputs.qkv.buffer;
+    const outBuf = node.outputs.out.buffer;
+    const seq_len = node.inputs.qkv.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 = node.params.scale !== undefined ? node.params.scale : 1 / Math.sqrt(head_dim);
+    // Causal self-attention: query q attends only to keys k <= q (matches the native
+    // sdpa_f32 kernel; required for autoregressive decoders).
+    for (let h = 0; h < num_heads; h++) {
+      for (let q = 0; q < seq_len; q++) {
+        const logits = new Float32Array(seq_len);
+        let max_logit = -Infinity;
+        for (let k = 0; k <= q; k++) {
+          let score = 0;
+          for (let d = 0; d < head_dim; d++) {
+            const q_val = qkv[q * (d_model * 3) + h * head_dim + d];
+            const k_val = qkv[k * (d_model * 3) + d_model + h * head_dim + d];
+            score += q_val * k_val;
+          }
+          score *= scale;
+          logits[k] = score;
+          if (score > max_logit) max_logit = score;
+        }
+        let sum_exp = 0;
+        for (let k = 0; k <= q; 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 <= q; k++) {
+            const w = logits[k] / sum_exp;
+            const v_val = qkv[k * (d_model * 3) + d_model * 2 + h * head_dim + d];
+            out_val += w * v_val;
+          }
+          outBuf[q * d_model + h * head_dim + d] = out_val;
+        }
+      }
+    }
+  }

package/js/ops/siLU.js

@@ -0,0 +1,8 @@
+export function _cpuSiLU(node) {
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < outBuf.length; i++) {
+        const x = inBuf[i];
+        outBuf[i] = x / (1.0 + Math.exp(-x));
+    }
+}

package/js/ops/sigmoid.js

@@ -0,0 +1,6 @@
+export function _cpuSigmoid(node) {
+
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < inBuf.length; i++) outBuf[i] = 1.0 / (1.0 + Math.exp(-inBuf[i]));
+  }

package/js/ops/slice.js

@@ -0,0 +1,36 @@
+export function _cpuSlice(node) {
+    const input = node.inputs.input || node.inputs.data;
+    const outBuf = node.outputs.out.buffer;
+    const starts = node.params.starts || [0, 0, 0, 0];
+    const steps = node.params.steps || [1, 1, 1, 1];
+    const axes = node.params.axes || [0, 1, 2, 3];
+
+    const in_s = [1, 1, 1, 1].slice(0, 4 - input.shape.length).concat(input.shape);
+    const out_s = [1, 1, 1, 1].slice(0, 4 - node.outputs.out.shape.length).concat(node.outputs.out.shape);
+
+    const st = [0, 0, 0, 0];
+    const sp = [1, 1, 1, 1];
+    for (let i = 0; i < axes.length; i++) {
+        let ax = axes[i];
+        if (ax < 0) ax += input.shape.length;
+        ax += (4 - input.shape.length);
+        st[ax] = starts[i] < 0 ? starts[i] + in_s[ax] : starts[i];
+        sp[ax] = steps[i];
+    }
+
+    let outIdx = 0;
+    for (let i0 = 0; i0 < out_s[0]; i0++) {
+        for (let i1 = 0; i1 < out_s[1]; i1++) {
+            for (let i2 = 0; i2 < out_s[2]; i2++) {
+                for (let i3 = 0; i3 < out_s[3]; i3++) {
+                    const src0 = st[0] + i0 * sp[0];
+                    const src1 = st[1] + i1 * sp[1];
+                    const src2 = st[2] + i2 * sp[2];
+                    const src3 = st[3] + i3 * sp[3];
+                    const inIdx = src0 * (in_s[1] * in_s[2] * in_s[3]) + src1 * (in_s[2] * in_s[3]) + src2 * in_s[3] + src3;
+                    outBuf[outIdx++] = input.buffer[inIdx];
+                }
+            }
+        }
+    }
+}

package/js/ops/softmax.js

@@ -0,0 +1,18 @@
+export function _cpuSoftmax(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++) {
+            const val = Math.exp(input.buffer[i * d + j] - max);
+            outBuf[i * d + j] = val;
+            sum += val;
+        }
+        for (let j = 0; j < d; j++) outBuf[i * d + j] /= sum;
+    }
+}

package/js/ops/spatialSoftargmaxY.js

@@ -0,0 +1,28 @@
+export function _cpuSpatialSoftargmaxY(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    const h = input.shape[1];
+    const w = input.shape[2];
+    const c = input.shape[3];
+    for (let ch = 0; ch < c; ch++) {
+      const outBase = ch * w;
+      for (let x = 0; x < w; x++) {
+        let maxLogit = -Infinity;
+        for (let y = 0; y < h; y++) {
+          const v = inBuf[(y * w + x) * c + ch];
+          if (v > maxLogit) maxLogit = v;
+        }
+        let denom = 0;
+        let weighted = 0;
+        for (let y = 0; y < h; y++) {
+          const ev = Math.exp(inBuf[(y * w + x) * c + ch] - maxLogit);
+          denom += ev;
+          weighted += ev * ((y + 0.5) / h);
+        }
+        outBuf[outBase + x] = denom > 0 ? weighted / denom : 0;
+      }
+    }
+  }

package/js/ops/split.js

@@ -0,0 +1,24 @@
+export function _cpuSplit(node) {
+
+    const input = node.inputs.input;
+    const inBuf = input.buffer;
+    const inShape = input.shape;
+    let axis = node.params.axis || 0;
+    if (axis < 0) axis += inShape.length;
+    const outKeys = Object.keys(node.outputs).sort();
+    const numOutputs = outKeys.length;
+    const splitSize = inShape[axis] / numOutputs;
+    let outerSize = 1;
+    for (let i = 0; i < axis; i++) outerSize *= inShape[i];
+    let innerSize = 1;
+    for (let i = axis + 1; i < inShape.length; i++) innerSize *= inShape[i];
+    const chunkSize = splitSize * innerSize;
+    for (let o = 0; o < numOutputs; o++) {
+        const outBuf = node.outputs[outKeys[o]].buffer;
+        for (let i = 0; i < outerSize; i++) {
+            const inOffset = (i * inShape[axis] + o * splitSize) * innerSize;
+            const outOffset = i * chunkSize;
+            outBuf.set(inBuf.subarray(inOffset, inOffset + chunkSize), outOffset);
+        }
+    }
+  }

package/js/ops/sub.js

@@ -0,0 +1,11 @@
+export function _cpuSub(node) {
+    const aBuf = node.inputs.a.buffer;
+    const bBuf = node.inputs.b.buffer;
+    const outBuf = node.outputs.out.buffer;
+    const elements = outBuf.length;
+    if (bBuf.length === 1) {
+        for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] - bBuf[0];
+    } else {
+        for (let i = 0; i < elements; i++) outBuf[i] = aBuf[i] - bBuf[i];
+    }
+}

package/js/ops/tanh.js

@@ -0,0 +1,7 @@
+export function _cpuTanh(node) {
+    const inBuf = node.inputs.input.buffer;
+    const outBuf = node.outputs.out.buffer;
+    for (let i = 0; i < outBuf.length; i++) {
+        outBuf[i] = Math.tanh(inBuf[i]);
+    }
+}

package/js/ops/transpose.js

@@ -0,0 +1,34 @@
+export function _cpuTranspose(node) {
+
+    const input = node.inputs.input;
+    const inBuf = input.buffer;
+    const inShape = input.shape;
+    const outBuf = node.outputs.out.buffer;
+    const perm = node.params.perm || [...Array(inShape.length).keys()].reverse();
+    
+    const inStrides = new Array(inShape.length);
+    let s = 1;
+    for (let i = inShape.length - 1; i >= 0; i--) {
+        inStrides[i] = s;
+        s *= inShape[i];
+    }
+    const outShape = perm.map(p => inShape[p]);
+    const outStrides = new Array(outShape.length);
+    s = 1;
+    for (let i = outShape.length - 1; i >= 0; i--) {
+        outStrides[i] = s;
+        s *= outShape[i];
+    }
+    
+    const elements = inBuf.length;
+    for (let i = 0; i < elements; i++) {
+        let inIdx = 0;
+        let temp = i;
+        for (let j = 0; j < outShape.length; j++) {
+            const outCoord = Math.floor(temp / outStrides[j]);
+            temp %= outStrides[j];
+            inIdx += outCoord * inStrides[perm[j]];
+        }
+        outBuf[i] = inBuf[inIdx];
+    }
+  }

package/js/ops/upsample2x.js

@@ -0,0 +1,23 @@
+export function _cpuUpsample2x(node) {
+
+    const input = node.inputs.input;
+    const output = node.outputs.out;
+    const [n, h, w, c] = input.shape;
+    const inBuf = input.buffer;
+    const outBuf = output.buffer;
+    for (let b = 0; b < n; b++) {
+      for (let y = 0; y < h; y++) {
+        for (let x = 0; x < w; x++) {
+          for (let ch = 0; ch < c; ch++) {
+            const v = inBuf[((b * h + y) * w + x) * c + ch];
+            const oy = y * 2;
+            const ox = x * 2;
+            outBuf[((b * h * 2 + oy) * w * 2 + ox) * c + ch] = v;
+            outBuf[((b * h * 2 + oy) * w * 2 + ox + 1) * c + ch] = v;
+            outBuf[((b * h * 2 + oy + 1) * w * 2 + ox) * c + ch] = v;
+            outBuf[((b * h * 2 + oy + 1) * w * 2 + ox + 1) * c + ch] = v;
+          }
+        }
+      }
+    }
+  }