@simulatte/doppler 0.1.8 → 0.2.0

package/src/inference/pipelines/text/moe-impl.d.ts

@@ -1,117 +0,0 @@
-/**
- * Mixture of Experts (MoE) feed-forward implementation.
- *
- * This module handles:
- * - Token routing to experts via softmax + top-k
- * - Expert weight loading (on-demand)
- * - Parallel expert execution on GPU
- * - Scatter-add combination of expert outputs
- *
- * Supports multiple MoE architectures:
- * - Mixtral-style (gate/up/down per expert)
- * - GPT-OSS style (MXFP4 quantized fused gate_up + bias)
- *
- * @module inference/pipelines/text/moe-impl
- */
-
-import type { Tensor, TensorDtype } from '../../../gpu/tensor.js';
-import type { MoERouter } from '../../moe-router.js';
-import type { ExpertWeights } from './types.js';
-import type { KernelPathSchema } from '../../../config/schema/index.js';
-
-/**
- * Clear the dequantization cache (call on model unload).
- */
-export function clearDequantCache(): void;
-
-/**
- * Get cache stats for debugging.
- */
-export function getDequantCacheStats(): {
-  hits: number;
-  misses: number;
-  size: number;
-  maxEntries: number;
-};
-
-/**
- * Configure dequant cache max entries at runtime.
- */
-export function setDequantCacheMaxEntries(maxEntries: number): void;
-
-/**
- * Configuration for MoE feed-forward.
- */
-export interface MoEConfig {
-  modelType?: string | null;
-  hiddenSize: number;
-  intermediateSize: number;
-  numExperts: number;
-  moeTopK: number;
-  expertFormat: 'mixtral' | 'gpt-oss';
-  hiddenActivation: string;
-  swigluLimit: number | null;
-  activationDtype?: TensorDtype;
-  kernelPath?: KernelPathSchema | null;
-}
-
-/**
- * Expert weights with optional GPT-OSS quantized format.
- */
-export interface MoEExpertWeights extends ExpertWeights {
-  expertFormat: 'mixtral' | 'gpt-oss';
-  numExperts?: number;
-  gateUpBlocks?: GPUBuffer;
-  gateUpScales?: GPUBuffer;
-  gateUpBias?: GPUBuffer;
-  downBlocks?: GPUBuffer;
-  downScales?: GPUBuffer;
-  downBias?: GPUBuffer;
-}
-
-/**
- * Layer router weights (for models with per-layer routers like GPT-OSS).
- */
-export interface LayerRouterWeights {
-  weight: Float32Array | GPUBuffer;
-  bias: Float32Array | GPUBuffer | null;
-}
-
-/**
- * Expert weight loader interface.
- */
-export interface ExpertLoader {
-  loadExpert(layerIdx: number, expertIdx: number): Promise<MoEExpertWeights | null>;
-}
-
-/**
- * MoE feed-forward with CPU routing.
- */
-export function moeFeedForwardCPU(
-  hiddenStates: Float32Array,
-  numTokens: number,
-  config: MoEConfig,
-  moeRouter: MoERouter,
-  expertWeights: Map<string, MoEExpertWeights>,
-  expertLoader: ExpertLoader,
-  layerIdx: number
-): Promise<Float32Array>;
-
-/**
- * MoE feed-forward fully on GPU.
- */
-export function moeFeedForwardGPU(
-  inputBuffer: GPUBuffer,
-  numTokens: number,
-  config: MoEConfig,
-  moeRouter: MoERouter,
-  expertWeights: Map<string, MoEExpertWeights>,
-  expertLoader: ExpertLoader,
-  layerIdx: number,
-  layerRouterWeights?: Map<number, LayerRouterWeights>
-): Promise<GPUBuffer>;
-
-/**
- * Check if layer is MoE layer (some models have dense layers too).
- */
-export function isMoELayer(layerIdx: number): boolean;

package/src/inference/pipelines/text/moe-impl.js

@@ -1,9 +0,0 @@
-import { clearDequantCache, getDequantCacheStats, setDequantCacheMaxEntries } from './moe-cache.js';
-import { moeFeedForwardCPU } from './moe-cpu.js';
-import { moeFeedForwardGPU } from './moe-gpu.js';
-
-export { clearDequantCache, getDequantCacheStats, setDequantCacheMaxEntries, moeFeedForwardCPU, moeFeedForwardGPU };
-
-export function isMoELayer(_layerIdx) {
-  return true;
-}

package/src/inference/pipelines/text/moe-shape-validator.d.ts

@@ -1,31 +0,0 @@
-export interface MoEVendorProfile {
-  preferVec4Dequant: boolean;
-  dequantTileShape: 'vec4' | 'scalar';
-  routerWorkgroupSize: number;
-  maxTokensPerExpertScale: number;
-}
-
-export interface MoEShapeConfig {
-  hiddenSize: number;
-  intermediateSize: number;
-  moeTopK: number;
-  numExperts: number;
-  expertFormat?: string | null;
-}
-
-export interface ValidateMoeShapeOptions {
-  modelType?: string;
-}
-
-export declare function resolveMoeVendorProfile(modelType: string): MoEVendorProfile;
-
-export declare function validateMoeShape(config: MoEShapeConfig, options?: ValidateMoeShapeOptions): void;
-
-export interface GptOssKernelPathProfile {
-  routerTopK: string;
-  dequantExpert: string;
-}
-
-export declare function resolveGptOssKernelPathProfile(
-  context: Record<string, unknown>
-): Promise<GptOssKernelPathProfile>;

package/src/inference/pipelines/text/moe-shape-validator.js

@@ -1,78 +0,0 @@
-import { getKernelCapabilities } from '../../../gpu/device.js';
-import { selectRuleValue } from '../../../rules/rule-registry.js';
-
-function asVendorString(caps) {
-  const raw = caps?.adapterInfo?.vendor;
-  return typeof raw === 'string' && raw.trim() !== '' ? raw.toLowerCase() : 'unknown';
-}
-
-export function resolveMoeVendorProfile(modelType) {
-  if (modelType !== 'gpt-oss') {
-    return {
-      preferVec4Dequant: false,
-      dequantTileShape: 'scalar',
-      routerWorkgroupSize: 128,
-      maxTokensPerExpertScale: 1.0,
-    };
-  }
-  const caps = getKernelCapabilities();
-  const vendor = asVendorString(caps);
-  return selectRuleValue('kernels', 'moeGptoss', 'vendorQuirkProfile', { vendor });
-}
-
-function resolveGptOssRuleContext(context) {
-  return {
-    modelType: 'gpt-oss',
-    hasF16: context?.hasF16,
-    hasSubgroups: context?.hasSubgroups,
-    inputDtype: context?.routerDtype ?? context?.inputDtype,
-    weightsDtype: context?.weightsDtype,
-    outputDtype: context?.outputDtype ?? context?.weightsDtype,
-    groupSize: context?.groupSize,
-    dequantTileShape: context?.tileShape ?? context?.dequantTileShape,
-  };
-}
-
-export async function resolveGptOssKernelPathProfile(context) {
-  const ruleContext = resolveGptOssRuleContext(context);
-  return {
-    routerTopK: selectRuleValue('kernels', 'moeGptoss', 'routerTopKVariant', ruleContext),
-    dequantExpert: selectRuleValue('kernels', 'moeGptoss', 'dequantVariant', ruleContext),
-  };
-}
-
-export function validateMoeShape(config, options = {}) {
-  const {
-    hiddenSize,
-    intermediateSize,
-    moeTopK,
-    numExperts,
-    expertFormat,
-  } = config;
-  const modelType = options.modelType ?? (expertFormat === 'gpt-oss' ? 'gpt-oss' : 'mixtral');
-
-  if (!Number.isFinite(hiddenSize) || hiddenSize <= 0) {
-    throw new Error(`[MoE] hiddenSize must be > 0, got ${hiddenSize}.`);
-  }
-  if (!Number.isFinite(intermediateSize) || intermediateSize <= 0) {
-    throw new Error(`[MoE] intermediateSize must be > 0, got ${intermediateSize}.`);
-  }
-  if (!Number.isFinite(numExperts) || numExperts <= 0) {
-    throw new Error(`[MoE] numExperts must be > 0, got ${numExperts}.`);
-  }
-  if (!Number.isFinite(moeTopK) || moeTopK <= 0 || moeTopK > numExperts) {
-    throw new Error(`[MoE] topK must be in range [1, ${numExperts}], got ${moeTopK}.`);
-  }
-
-  if (modelType === 'gpt-oss') {
-    const policy = selectRuleValue('kernels', 'moeGptoss', 'shapePolicy', { modelType });
-    const hiddenDivisor = policy.hiddenSizeDivisor ?? 32;
-    const intermediateDivisor = policy.intermediateSizeDivisor ?? 32;
-    if (hiddenSize % hiddenDivisor !== 0 || intermediateSize % intermediateDivisor !== 0) {
-      throw new Error(
-        `[MoE] GPT-OSS shape policy violation: hiddenSize (${hiddenSize}) % ${hiddenDivisor} = ${hiddenSize % hiddenDivisor}, ` +
-        `intermediateSize (${intermediateSize}) % ${intermediateDivisor} = ${intermediateSize % intermediateDivisor}.`
-      );
-    }
-  }
-}

package/src/inference/pipelines/text/ops.d.ts

@@ -1,167 +0,0 @@
-/**
- * Kernel Operation Wrappers (Ops)
- *
- * This module provides high-level wrappers around GPU kernels (run/record variants)
- * and handles tensor creation, tracing, and buffer management.
- *
- * @module inference/pipelines/text/ops
- */
-
-import type { SiLURowSplitOptions, CommandRecorder } from '../../../gpu/kernel-selector.js';
-import type { Tensor } from '../../../gpu/tensor.js';
-import type { WeightBuffer, CpuWeightBuffer } from '../../../gpu/weight-buffer.js';
-import type { DecodeBufferManager } from '../../decode-buffers.js';
-import type {
-  AttentionConfig,
-  AttentionState,
-  AttentionDebugFlags,
-  AttentionResult
-} from './attention/index.js';
-import type { LayerWeights } from './types.js';
-import type { LoRAAdapter } from './lora.js';
-
-export function isDecodeBuffer(decodeBuffers: DecodeBufferManager | null | undefined, buffer: GPUBuffer): boolean;
-
-export function releaseOrTrack(
-  recorder: CommandRecorder | undefined,
-  buffer: GPUBuffer,
-  decodeBuffers?: DecodeBufferManager | null
-): void;
-
-/**
- * RMSNorm that uses record variant when recorder is provided.
- * Input and residual are Tensor, returns Tensor.
- */
-export function doRMSNorm(
-  input: Tensor,
-  weight: GPUBuffer,
-  eps: number,
-  options: { batchSize: number; hiddenSize: number; residual?: Tensor | null; outputBuffer?: GPUBuffer | null; label?: string; layerIdx?: number; rmsNormWeightOffset?: boolean },
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * ResidualAdd that uses record variant when recorder is provided.
- * Accepts Tensor for inputs, returns Tensor.
- */
-export function doResidualAdd(
-  a: Tensor,
-  b: Tensor,
-  size: number,
-  recorder?: CommandRecorder,
-  traceOptions?: { label?: string; layerIdx?: number; outputBuffer?: GPUBuffer | null }
-): Promise<Tensor>;
-
-/**
- * Matmul that uses record variant when recorder is provided.
- * A is activation Tensor, B is weight (GPUBuffer or WeightBuffer), returns Tensor.
- */
-export function doMatmul(
-  A: Tensor,
-  B: GPUBuffer | WeightBuffer,
-  M: number,
-  N: number,
-  K: number,
-  options?: { transposeB?: boolean | 'auto'; label?: string; layerIdx?: number; outputDtype?: 'f16' | 'f32'; role?: string },
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * SiLU that uses record variant when recorder is provided.
- * Supports gated variant (SiLU with gate multiplication).
- */
-export function doSiLU(
-  input: Tensor,
-  options?: { size?: number; gate?: Tensor | null; label?: string; layerIdx?: number },
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * GeLU that uses record variant when recorder is provided.
- * Supports gated variant (GeGLU).
- */
-export function doGeLU(
-  input: Tensor,
-  options?: { size?: number; gate?: Tensor | null; label?: string; layerIdx?: number },
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * SiLURowSplit that uses record variant when recorder is provided.
- * Used for fused gate+up FFN path: splits combined output and applies activation.
- */
-export function doSiLURowSplit(
-  input: Tensor,
-  options: Omit<SiLURowSplitOptions, 'activationDtype'> & { label?: string; layerIdx?: number },
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * Fused Matmul + RMSNorm that uses record variant when recorder is provided.
- * Used for down projection + post-FFN norm fusion during decode (M=1).
- */
-export function doMatmulRMSNormFused(
-  input: Tensor,
-  weight: GPUBuffer | WeightBuffer,
-  normWeight: GPUBuffer,
-  options: { N: number; K: number; eps: number; residual?: Tensor | null; outputBuffer?: GPUBuffer | null; transposeB?: boolean; label?: string; layerIdx?: number; rmsNormWeightOffset?: boolean },
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * Hybrid conv block helper for per-layer conv schedules.
- * Uses linear projections and optional conv2d dispatch when shape metadata is provided.
- */
-export function doConv(
-  inputTensor: Tensor,
-  convInProj: GPUBuffer | WeightBuffer,
-  convKernel: GPUBuffer | WeightBuffer | Float32Array | null,
-  convOutProj: GPUBuffer | WeightBuffer,
-  options: {
-    numTokens: number;
-    hiddenSize: number;
-    swigluLimit?: number | null;
-    layerIdx?: number;
-    label?: string;
-    kernelPath?: unknown;
-    conv2d?: {
-      enabled: boolean;
-      inChannels: number;
-      outChannels: number;
-      height: number;
-      width: number;
-      kernelH: number;
-      kernelW: number;
-      stride?: number;
-      pad?: number;
-    } | null;
-  },
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * Dtype cast helper that uses record variants when recorder is provided.
- */
-export function doCast(
-  input: Tensor,
-  toDtype: 'f16' | 'f32',
-  recorder?: CommandRecorder
-): Promise<Tensor>;
-
-/**
- * Attention that uses record variant when recorder is provided.
- * Input is Tensor for dtype-aware processing.
- */
-export function doAttention(
-  inputTensor: Tensor,
-  layerWeights: LayerWeights | null,
-  config: AttentionConfig,
-  state: AttentionState,
-  debug: boolean,
-  debugFlags: AttentionDebugFlags,
-  getWeightBufferFn: (weight: GPUBuffer | WeightBuffer | Float32Array | ArrayBuffer | CpuWeightBuffer, label: string) => GPUBuffer | WeightBuffer,
-  getNormWeightBufferFn: (weight: GPUBuffer | Float32Array | ArrayBuffer | CpuWeightBuffer, label: string) => GPUBuffer,
-  debugCheckBuffer?: (buffer: GPUBuffer, label: string, numTokens: number, expectedDim?: number) => Promise<void>,
-  recorder?: CommandRecorder,
-  lora?: LoRAAdapter | null
-): Promise<AttentionResult>;