@simulatte/doppler 0.1.8 → 0.2.0

package/src/gpu/kernels/backward/matmul_backward.js

@@ -1,124 +0,0 @@
-import { runMatmulTransposeA, recordMatmulTransposeA, runMatmulBackwardDx, recordMatmulBackwardDx } from './utils.js';
-
-export async function runMatmulBackward(input, weight, gradOutput, options = {}) {
-  const {
-    M,
-    N,
-    K,
-    transposeB = false,
-    computeGradInput = true,
-    computeGradWeight = true,
-  } = options;
-  if (!M || !N || !K) {
-    throw new Error('matmul backward requires M, N, and K');
-  }
-  if (!computeGradInput && !computeGradWeight) {
-    throw new Error('matmul backward requires computeGradInput or computeGradWeight');
-  }
-
-  let gradInput = null;
-  let gradWeight = null;
-
-  if (computeGradInput) {
-    // dX = dY @ W^T (or dY @ W depending on transposeB)
-    // Fused WGSL kernel handles transpose via uniform flag.
-    gradInput = await runMatmulBackwardDx(
-      gradOutput,
-      weight,
-      M,
-      K,
-      N,
-      { transposeB }
-    );
-  }
-
-  if (computeGradWeight) {
-    // dW = X^T @ dY (if Y = X @ W)
-    // dW = dY^T @ X (if Y = X @ W^T and we want dW [N, K])
-    if (transposeB) {
-      // Y = X @ W^T, W is [N, K]
-      // dW = dY^T @ X: dY is [M, N], X is [M, K] => dW is [N, K]
-      gradWeight = await runMatmulTransposeA(
-        gradOutput,
-        input,
-        N,
-        K,
-        M
-      );
-    } else {
-      // Y = X @ W, W is [K, N]
-      // dW = X^T @ dY: X is [M, K], dY is [M, N] => dW is [K, N]
-      gradWeight = await runMatmulTransposeA(
-        input,
-        gradOutput,
-        K,
-        N,
-        M
-      );
-    }
-  }
-
-  return { gradInput, gradWeight };
-}
-
-export async function recordMatmulBackward(
-  recorder,
-  input,
-  weight,
-  gradOutput,
-  options = {}
-) {
-  const {
-    M,
-    N,
-    K,
-    transposeB = false,
-    computeGradInput = true,
-    computeGradWeight = true,
-  } = options;
-  if (!M || !N || !K) {
-    throw new Error('matmul backward requires M, N, and K');
-  }
-  if (!computeGradInput && !computeGradWeight) {
-    throw new Error('matmul backward requires computeGradInput or computeGradWeight');
-  }
-
-  let gradInput = null;
-  let gradWeight = null;
-
-  if (computeGradInput) {
-    gradInput = await recordMatmulBackwardDx(
-      recorder,
-      gradOutput,
-      weight,
-      M,
-      K,
-      N,
-      { transposeB }
-    );
-  }
-
-  if (computeGradWeight) {
-    if (transposeB) {
-      gradWeight = await recordMatmulTransposeA(
-        recorder,
-        gradOutput,
-        input,
-        N,
-        K,
-        M
-      );
-    } else {
-      gradWeight = await recordMatmulTransposeA(
-        recorder,
-        input,
-        gradOutput,
-        K,
-        N,
-        M
-      );
-    }
-  }
-
-  return { gradInput, gradWeight };
-}

package/src/gpu/kernels/backward/matmul_backward.wgsl

@@ -1,90 +0,0 @@
-// Matrix Multiplication Backward Kernel - dX = dY @ W^T
-//
-// Fused tiled matmul for computing input gradients during backpropagation.
-//
-// When transpose_b = 1 (standard case: forward was Y = X @ W, W stored [K,N]):
-//   dX[M,K] = dY[M,N] @ W^T[N,K]   (reads W as [K,N], transposes on the fly)
-//
-// When transpose_b = 0 (forward was Y = X @ W^T, W stored [N,K]):
-//   dX[M,K] = dY[M,N] @ W[N,K]     (reads W directly as [N,K])
-//
-// Uses 16x16 shared memory tiles, matching matmul_transpose_a.wgsl style.
-
-const MAX_TILE_SIZE: u32 = 16u;
-const TILE_AREA: u32 = MAX_TILE_SIZE * MAX_TILE_SIZE;
-
-override TILE_SIZE: u32 = 16u;
-
-struct Uniforms {
-    M: u32,            // Rows of dY and dX (batch dim)
-    N: u32,            // Cols of dY (output dim of forward)
-    K: u32,            // Cols of dX (input dim of forward)
-    alpha: f32,
-    transpose_b: u32,  // 0 = W stored [N,K], 1 = W stored [K,N]
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> dY: array<f32>;  // [M, N]
-@group(0) @binding(2) var<storage, read> W: array<f32>;   // [K, N] or [N, K]
-@group(0) @binding(3) var<storage, read_write> dX: array<f32>; // [M, K]
-
-var<workgroup> tileDY: array<f32, TILE_AREA>;
-var<workgroup> tileW: array<f32, TILE_AREA>;
-
-@compute @workgroup_size(TILE_SIZE, TILE_SIZE, 1)
-fn main(
-    @builtin(global_invocation_id) global_id: vec3<u32>,
-    @builtin(local_invocation_id) local_id: vec3<u32>
-) {
-    let row = global_id.x;  // M dim
-    let col = global_id.y;  // K dim
-    let local_row = local_id.x;
-    let local_col = local_id.y;
-
-    var sum: f32 = 0.0;
-    let num_tiles = (u.N + TILE_SIZE - 1u) / TILE_SIZE;
-
-    for (var t: u32 = 0u; t < num_tiles; t = t + 1u) {
-        let tile_n = t * TILE_SIZE;
-        let tile_idx = local_row * TILE_SIZE + local_col;
-
-        // Load tile from dY [M, N].
-        // Element dY[row, tile_n + local_col]
-        let dy_col = tile_n + local_col;
-        if (row < u.M && dy_col < u.N) {
-            tileDY[tile_idx] = dY[row * u.N + dy_col];
-        } else {
-            tileDY[tile_idx] = 0.0;
-        }
-
-        // Load tile from W^T [N, K].
-        // We need W^T[tile_n + local_row, col].
-        let wt_row = tile_n + local_row;
-        if (wt_row < u.N && col < u.K) {
-            if (u.transpose_b == 0u) {
-                // W stored as [N, K]: W^T[wt_row, col] = W[wt_row, col]
-                tileW[tile_idx] = W[wt_row * u.K + col];
-            } else {
-                // W stored as [K, N]: W^T[wt_row, col] = W[col, wt_row]
-                tileW[tile_idx] = W[col * u.N + wt_row];
-            }
-        } else {
-            tileW[tile_idx] = 0.0;
-        }
-
-        workgroupBarrier();
-
-        for (var k: u32 = 0u; k < TILE_SIZE; k = k + 1u) {
-            sum += tileDY[local_row * TILE_SIZE + k] * tileW[k * TILE_SIZE + local_col];
-        }
-
-        workgroupBarrier();
-    }
-
-    if (row < u.M && col < u.K) {
-        dX[row * u.K + col] = sum * u.alpha;
-    }
-}

package/src/gpu/kernels/backward/matmul_transpose_a.wgsl

@@ -1,84 +0,0 @@
-// Matrix Multiplication Kernel - Transpose A
-//
-// C[M,N] = A^T[M,K] * B[K,N]
-// Where A is stored as [K,M], so A^T is [M,K]
-//
-// This is used for matmul backward: dW = X^T * dY
-// if X is [Batch, K] and dY is [Batch, N], then dW is [K, N]
-// Here M = K_dim, K = Batch_dim, N = N_dim
-
-const MAX_TILE_SIZE: u32 = 16u;
-const TILE_AREA: u32 = MAX_TILE_SIZE * MAX_TILE_SIZE;
-
-override TILE_SIZE: u32 = 16u;
-
-struct Uniforms {
-    M: u32,           // Rows of A^T and C
-    N: u32,           // Cols of B and C
-    K: u32,           // Cols of A^T, Rows of B
-    alpha: f32,
-    _pad0: u32,
-    _pad1: u32,
-    _pad2: u32,
-    _pad3: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> A: array<f32>; // Stored as [K, M]
-@group(0) @binding(2) var<storage, read> B: array<f32>; // Stored as [K, N]
-@group(0) @binding(3) var<storage, read_write> C: array<f32>; // Result [M, N]
-
-var<workgroup> tileA: array<f32, TILE_AREA>;
-var<workgroup> tileB: array<f32, TILE_AREA>;
-
-@compute @workgroup_size(TILE_SIZE, TILE_SIZE, 1)
-fn main(
-    @builtin(global_invocation_id) global_id: vec3<u32>,
-    @builtin(local_invocation_id) local_id: vec3<u32>
-) {
-    let row = global_id.x;
-    let col = global_id.y;
-    let local_row = local_id.x;
-    let local_col = local_id.y;
-
-    var sum: f32 = 0.0;
-    let num_tiles = (u.K + TILE_SIZE - 1u) / TILE_SIZE;
-
-    for (var t: u32 = 0u; t < num_tiles; t = t + 1u) {
-        let tile_k = t * TILE_SIZE;
-        
-        // Load tile A. A is [K, M]. We want A^T [M, K].
-        // Element A^T[row, tile_k + local_col] is A[tile_k + local_col, row]
-        let a_row_to_load = tile_k + local_col;
-        let a_col_to_load = row;
-        
-        let tile_idx = local_row * TILE_SIZE + local_col;
-        if (a_col_to_load < u.M && a_row_to_load < u.K) {
-            tileA[tile_idx] = A[a_row_to_load * u.M + a_col_to_load];
-        } else {
-            tileA[tile_idx] = 0.0;
-        }
-
-        // Load tile B. B is [K, N].
-        // Element B[tile_k + local_row, col]
-        let b_row_to_load = tile_k + local_row;
-        let b_col_to_load = col;
-        if (b_row_to_load < u.K && b_col_to_load < u.N) {
-            tileB[tile_idx] = B[b_row_to_load * u.N + b_col_to_load];
-        } else {
-            tileB[tile_idx] = 0.0;
-        }
-
-        workgroupBarrier();
-
-        for (var k: u32 = 0u; k < TILE_SIZE; k = k + 1u) {
-            sum += tileA[local_row * TILE_SIZE + k] * tileB[k * TILE_SIZE + local_col];
-        }
-
-        workgroupBarrier();
-    }
-
-    if (row < u.M && col < u.N) {
-        C[row * u.N + col] = sum * u.alpha;
-    }
-}

package/src/gpu/kernels/backward/pixel_shuffle_backward.d.ts

@@ -1,22 +0,0 @@
-import type { BackwardKernelOptions } from './utils.js';
-
-export interface PixelShuffleBackwardOptions extends BackwardKernelOptions {
-  outChannels: number;
-  outHeight: number;
-  outWidth: number;
-  gridWidth: number;
-  gridHeight: number;
-  patchSize: number;
-  patchChannels: number;
-}
-
-export declare function runPixelShuffleBackward(
-  gradOutput: any,
-  options: PixelShuffleBackwardOptions
-): Promise<any>;
-
-export declare function recordPixelShuffleBackward(
-  recorder: any,
-  gradOutput: any,
-  options: PixelShuffleBackwardOptions
-): Promise<any>;

package/src/gpu/kernels/backward/pixel_shuffle_backward.js

@@ -1,30 +0,0 @@
-import { createBackwardKernel } from './utils.js';
-
-const { run, record } = createBackwardKernel('pixel_shuffle_backward', {
-  uniformSize: 32,
-  writeUniforms: (view, opts) => {
-    view.setUint32(0, opts.outChannels, true);
-    view.setUint32(4, opts.outHeight, true);
-    view.setUint32(8, opts.outWidth, true);
-    view.setUint32(12, opts.gridWidth, true);
-    view.setUint32(16, opts.gridHeight, true);
-    view.setUint32(20, opts.patchSize, true);
-    view.setUint32(24, opts.patchChannels, true);
-  },
-  calcWorkgroups: (opts) => Math.ceil((opts.gridWidth * opts.gridHeight * opts.patchChannels) / 256),
-  outputBytes: (opts) => opts.gridWidth * opts.gridHeight * opts.patchChannels * 4,
-  outputShape: (opts) => [opts.gridHeight * opts.gridWidth, opts.patchChannels],
-  validate: (opts) => {
-    if (!opts.outChannels || !opts.outHeight || !opts.outWidth || !opts.gridWidth || !opts.gridHeight || !opts.patchSize || !opts.patchChannels) {
-      throw new Error('pixel_shuffle backward requires all dimensions');
-    }
-  },
-});
-
-export async function runPixelShuffleBackward(gradOutput, options = {}) {
-  return run(gradOutput, options);
-}
-
-export async function recordPixelShuffleBackward(recorder, gradOutput, options = {}) {
-  return record(recorder, gradOutput, options);
-}

package/src/gpu/kernels/backward/pixel_shuffle_backward.wgsl

@@ -1,54 +0,0 @@
-// pixel_shuffle_backward.wgsl
-//
-// Inverse of Pixel Shuffle: Rearranges [C, H, W] -> [H/P, W/P, C*P*P]
-// 
-// Forward: tokens [grid_height * grid_width, patch_channels] -> output [out_channels, out_height, out_width]
-// Backward: grad_output [out_channels, out_height, out_width] -> grad_input [grid_height * grid_width, patch_channels]
-
-struct Uniforms {
-    out_channels: u32,
-    out_height: u32,
-    out_width: u32,
-    grid_width: u32,
-    grid_height: u32,
-    patch_size: u32,
-    patch_channels: u32,
-    _pad0: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> grad_output: array<f32>;
-@group(0) @binding(2) var<storage, read_write> grad_input: array<f32>;
-
-override WORKGROUP_SIZE: u32 = 256u;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
-    let input_idx = gid.x;
-    let total_input_elements = u.grid_width * u.grid_height * u.patch_channels;
-    
-    if (input_idx >= total_input_elements) {
-        return;
-    }
-
-    // Resolve input coordinates (inverse of forward mapping)
-    let token_idx = input_idx / u.patch_channels;
-    let patch_idx = input_idx % u.patch_channels;
-    
-    let grid_y = token_idx / u.grid_width;
-    let grid_x = token_idx % u.grid_width;
-    
-    // patch_idx = (subY * patchSize + subX) * outChannels + c
-    let c = patch_idx % u.out_channels;
-    let sub_rem = patch_idx / u.out_channels;
-    let sub_y = sub_rem / u.patch_size;
-    let sub_x = sub_rem % u.patch_size;
-    
-    let y = grid_y * u.patch_size + sub_y;
-    let x = grid_x * u.patch_size + sub_x;
-    
-    let spatial = u.out_height * u.out_width;
-    let output_idx = (c * u.out_height + y) * u.out_width + x;
-    
-    grad_input[input_idx] = grad_output[output_idx];
-}

package/src/gpu/kernels/backward/rmsnorm_backward.d.ts

@@ -1,24 +0,0 @@
-import type { CommandRecorder } from '../../command-recorder.js';
-import type { Tensor } from '../../tensor.js';
-import type { BackwardKernelOptions } from './utils.js';
-
-export interface RmsNormBackwardOptions extends BackwardKernelOptions {
-  numTokens: number;
-  hiddenSize: number;
-  eps?: number;
-}
-
-export declare function runRmsNormBackward(
-  input: Tensor,
-  weight: Tensor,
-  gradOutput: Tensor,
-  options: RmsNormBackwardOptions
-): Promise<Tensor>;
-
-export declare function recordRmsNormBackward(
-  recorder: CommandRecorder,
-  input: Tensor,
-  weight: Tensor,
-  gradOutput: Tensor,
-  options: RmsNormBackwardOptions
-): Promise<Tensor>;

package/src/gpu/kernels/backward/rmsnorm_backward.js

@@ -1,101 +0,0 @@
-import { getDevice } from '../../device.js';
-import { acquireBuffer } from '../../../memory/buffer-pool.js';
-import { createTensor } from '../../tensor.js';
-import { WORKGROUP_SIZES } from '../constants.js';
-import { dispatch, recordDispatch } from '../dispatch.js';
-import { createPipeline, createUniformBufferWithView } from '../utils.js';
-import { castF16ToF32, recordCastF16ToF32 } from '../cast.js';
-import { DEFAULT_HIGH_PRECISION_EPS } from '../../../config/schema/index.js';
-
-export async function runRmsNormBackward(input, weight, gradOutput, options = {}) {
-  const device = getDevice();
-  const { numTokens, hiddenSize, eps = DEFAULT_HIGH_PRECISION_EPS, outputBuffer = null } = options;
-
-  if (!numTokens || !hiddenSize) {
-    throw new Error('rmsnorm backward requires numTokens and hiddenSize');
-  }
-
-  const inputTensor = input.dtype === 'f16' ? await castF16ToF32(input) : input;
-  const weightTensor = weight.dtype === 'f16' ? await castF16ToF32(weight) : weight;
-  const gradTensor = gradOutput.dtype === 'f16' ? await castF16ToF32(gradOutput) : gradOutput;
-
-  const outputSize = numTokens * hiddenSize * 4;
-  const outputBuf = outputBuffer || acquireBuffer(outputSize, undefined, 'rmsnorm_backward_output');
-
-  const pipeline = await createPipeline('rmsnorm_backward', 'default');
-  const uniformBuffer = createUniformBufferWithView(
-    'rmsnorm_backward_uniforms',
-    16,
-    (view) => {
-      view.setUint32(0, numTokens, true);
-      view.setUint32(4, hiddenSize, true);
-      view.setFloat32(8, eps, true);
-    },
-    null,
-    device
-  );
-
-  const bindGroup = device.createBindGroup({
-    label: 'rmsnorm_backward_bind_group',
-    layout: pipeline.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniformBuffer } },
-      { binding: 1, resource: { buffer: inputTensor.buffer } },
-      { binding: 2, resource: { buffer: weightTensor.buffer } },
-      { binding: 3, resource: { buffer: gradTensor.buffer } },
-      { binding: 4, resource: { buffer: outputBuf } },
-    ],
-  });
-
-  const workgroups = numTokens;
-  dispatch(device, pipeline, bindGroup, workgroups, 'rmsnorm_backward');
-
-  uniformBuffer.destroy();
-
-  return createTensor(outputBuf, 'f32', [numTokens, hiddenSize], 'rmsnorm_backward_output');
-}
-
-export async function recordRmsNormBackward(recorder, input, weight, gradOutput, options = {}) {
-  const device = recorder.device;
-  const { numTokens, hiddenSize, eps = DEFAULT_HIGH_PRECISION_EPS, outputBuffer = null } = options;
-
-  if (!numTokens || !hiddenSize) {
-    throw new Error('rmsnorm backward requires numTokens and hiddenSize');
-  }
-
-  const inputTensor = input.dtype === 'f16' ? await recordCastF16ToF32(recorder, input) : input;
-  const weightTensor = weight.dtype === 'f16' ? await recordCastF16ToF32(recorder, weight) : weight;
-  const gradTensor = gradOutput.dtype === 'f16' ? await recordCastF16ToF32(recorder, gradOutput) : gradOutput;
-
-  const outputSize = numTokens * hiddenSize * 4;
-  const outputBuf = outputBuffer || acquireBuffer(outputSize, undefined, 'rmsnorm_backward_output');
-
-  const pipeline = await createPipeline('rmsnorm_backward', 'default');
-  const uniformBuffer = createUniformBufferWithView(
-    'rmsnorm_backward_uniforms',
-    16,
-    (view) => {
-      view.setUint32(0, numTokens, true);
-      view.setUint32(4, hiddenSize, true);
-      view.setFloat32(8, eps, true);
-    },
-    recorder
-  );
-
-  const bindGroup = device.createBindGroup({
-    label: 'rmsnorm_backward_bind_group',
-    layout: pipeline.getBindGroupLayout(0),
-    entries: [
-      { binding: 0, resource: { buffer: uniformBuffer } },
-      { binding: 1, resource: { buffer: inputTensor.buffer } },
-      { binding: 2, resource: { buffer: weightTensor.buffer } },
-      { binding: 3, resource: { buffer: gradTensor.buffer } },
-      { binding: 4, resource: { buffer: outputBuf } },
-    ],
-  });
-
-  const workgroups = numTokens;
-  recordDispatch(recorder, pipeline, bindGroup, workgroups, 'rmsnorm_backward');
-
-  return createTensor(outputBuf, 'f32', [numTokens, hiddenSize], 'rmsnorm_backward_output');
-}

package/src/gpu/kernels/backward/rmsnorm_backward.wgsl

@@ -1,78 +0,0 @@
-// rmsnorm_backward.wgsl
-
-/**
- * RMSNorm Backward Kernel (GPU)
- *
- * Computes gradients for RMSNorm input/weights.
- * Uses shared-memory reduction for per-token stats.
- */
-override WORKGROUP_SIZE: u32 = 256u;
-const MAX_WORKGROUP_SIZE: u32 = 256u;
-
-struct Uniforms {
-    num_tokens: u32,
-    hidden_size: u32,
-    eps: f32,
-    _pad0: u32,
-}
-
-@group(0) @binding(0) var<uniform> u: Uniforms;
-@group(0) @binding(1) var<storage, read> input: array<f32>;
-@group(0) @binding(2) var<storage, read> weight: array<f32>;
-@group(0) @binding(3) var<storage, read> grad_output: array<f32>;
-@group(0) @binding(4) var<storage, read_write> output: array<f32>;
-
-var<workgroup> shared_sum_sq: array<f32, MAX_WORKGROUP_SIZE>;
-var<workgroup> shared_sum_gx: array<f32, MAX_WORKGROUP_SIZE>;
-
-@compute @workgroup_size(WORKGROUP_SIZE, 1, 1)
-fn main(
-    @builtin(workgroup_id) wid: vec3<u32>,
-    @builtin(local_invocation_id) lid: vec3<u32>
-) {
-    let token_idx = wid.x;
-    if (token_idx >= u.num_tokens) {
-        return;
-    }
-
-    let hidden_size = u.hidden_size;
-    let base = token_idx * hidden_size;
-    let local_id = lid.x;
-
-    var sum_sq: f32 = 0.0;
-    var sum_gx: f32 = 0.0;
-
-    for (var i: u32 = local_id; i < hidden_size; i = i + WORKGROUP_SIZE) {
-        let x = input[base + i];
-        let g = grad_output[base + i] * weight[i];
-        sum_sq = sum_sq + x * x;
-        sum_gx = sum_gx + g * x;
-    }
-
-    shared_sum_sq[local_id] = sum_sq;
-    shared_sum_gx[local_id] = sum_gx;
-    workgroupBarrier();
-
-    var stride = WORKGROUP_SIZE / 2u;
-    loop {
-        if (stride == 0u) { break; }
-        if (local_id < stride) {
-            shared_sum_sq[local_id] = shared_sum_sq[local_id] + shared_sum_sq[local_id + stride];
-            shared_sum_gx[local_id] = shared_sum_gx[local_id] + shared_sum_gx[local_id + stride];
-        }
-        workgroupBarrier();
-        stride = stride / 2u;
-    }
-
-    let sum_sq_total = shared_sum_sq[0];
-    let sum_gx_total = shared_sum_gx[0];
-    let inv_rms = 1.0 / sqrt(sum_sq_total / f32(hidden_size) + u.eps);
-    let inv_rms3 = inv_rms * inv_rms * inv_rms;
-    let coeff = (sum_gx_total / f32(hidden_size)) * inv_rms3;
-
-    for (var i: u32 = local_id; i < hidden_size; i = i + WORKGROUP_SIZE) {
-        let x = input[base + i];
-        let g = grad_output[base + i] * weight[i];
-        output[base + i] = g * inv_rms - x * coeff;
-    }
-}

package/src/gpu/kernels/backward/rope_backward.d.ts

@@ -1,25 +0,0 @@
-import type { CommandRecorder } from '../../command-recorder.js';
-import type { Tensor } from '../../tensor.js';
-import type { BackwardKernelOptions } from './utils.js';
-
-export interface RoPEBackwardOptions extends BackwardKernelOptions {
-  seqLen: number;
-  numHeads: number;
-  headDim: number;
-  startPos?: number;
-}
-
-export declare function runRoPEBackward(
-  gradOutput: Tensor,
-  freqsCos: Tensor,
-  freqsSin: Tensor,
-  options: RoPEBackwardOptions
-): Promise<Tensor>;
-
-export declare function recordRoPEBackward(
-  recorder: CommandRecorder,
-  gradOutput: Tensor,
-  freqsCos: Tensor,
-  freqsSin: Tensor,
-  options: RoPEBackwardOptions
-): Promise<Tensor>;