@simulatte/doppler 0.1.0

package/src/browser/quantization.js

@@ -0,0 +1,328 @@
+
+
+import { classifyTensorRole } from '../formats/rdrr/index.js';
+import { shouldQuantize } from '../converter/core.js';
+import {
+  float16ToFloat32,
+  float32ToFloat16,
+  quantizeQ4KBlock,
+  quantizeToQ4KMColumnWise,
+  getQ4KSize,
+  QK_K,
+  QK4_K_BLOCK_SIZE,
+} from '../converter/quantizer.js';
+import {
+  buildQuantizationInfo,
+  normalizeQuantTag,
+  resolveEffectiveQuantizationInfo,
+  resolveManifestQuantization,
+  resolveModelId,
+  toWebGPUDtype,
+} from '../converter/quantization-info.js';
+
+export {
+  buildQuantizationInfo,
+  normalizeQuantTag,
+  resolveEffectiveQuantizationInfo,
+  resolveManifestQuantization,
+  resolveModelId,
+  toWebGPUDtype,
+};
+
+const BF16_VIEW = new DataView(new ArrayBuffer(4));
+
+function bf16ToFloat32(value) {
+  BF16_VIEW.setUint32(0, value << 16, true);
+  return BF16_VIEW.getFloat32(0, true);
+}
+
+function concatBytes(a, b) {
+  if (!a || a.length === 0) return b;
+  if (!b || b.length === 0) return a;
+  const combined = new Uint8Array(a.length + b.length);
+  combined.set(a, 0);
+  combined.set(b, a.length);
+  return combined;
+}
+
+async function* decodeFloat32Chunks(chunks, dtype) {
+  const upper = String(dtype || '').toUpperCase();
+  const bytesPerElement = upper === 'F32' ? 4 : 2;
+  let carry = new Uint8Array(0);
+
+  for await (const chunk of chunks) {
+    const merged = concatBytes(carry, chunk);
+    const count = Math.floor(merged.length / bytesPerElement);
+    const used = count * bytesPerElement;
+    if (count > 0) {
+      const view = new DataView(merged.buffer, merged.byteOffset, used);
+      const out = new Float32Array(count);
+      if (upper === 'F32') {
+        for (let i = 0; i < count; i++) {
+          out[i] = view.getFloat32(i * 4, true);
+        }
+      } else if (upper === 'BF16') {
+        for (let i = 0; i < count; i++) {
+          const bits = view.getUint16(i * 2, true);
+          out[i] = bf16ToFloat32(bits);
+        }
+      } else {
+        for (let i = 0; i < count; i++) {
+          const bits = view.getUint16(i * 2, true);
+          out[i] = float16ToFloat32(bits);
+        }
+      }
+      yield out;
+    }
+    carry = merged.slice(used);
+  }
+
+  if (carry.length > 0) {
+    throw new Error('Unaligned tensor chunk for float decoding');
+  }
+}
+
+function isGptOssPackedExpertTensor(name) {
+  const lower = name.toLowerCase();
+  if (!lower.includes('mlp.experts.')) return false;
+  return lower.includes('gate_up_proj_blocks') ||
+    lower.includes('gate_up_proj_scales') ||
+    lower.includes('down_proj_blocks') ||
+    lower.includes('down_proj_scales');
+}
+
+export function isMatmulWeight(name, shape) {
+  if (!Array.isArray(shape) || shape.length !== 2) return false;
+
+  const matmulPatterns = [
+    /\.weight$/,
+    /q_proj|k_proj|v_proj|o_proj/,
+    /gate_proj|up_proj|down_proj/,
+    /gate\.weight|up\.weight|down\.weight/,
+    /w1\.weight|w2\.weight|w3\.weight/,
+    /lm_head/,
+    /embed_tokens/,
+  ];
+
+  const excludePatterns = [
+    /norm|layernorm|rmsnorm/i,
+    /bias$/,
+    /rotary|rope/i,
+  ];
+
+  for (const pattern of excludePatterns) {
+    if (pattern.test(name)) return false;
+  }
+
+  for (const pattern of matmulPatterns) {
+    if (pattern.test(name)) return true;
+  }
+
+  return false;
+}
+
+export function resolveTensorDtype(name, shape, origDtype, quantizationInfo) {
+  const sourceDtype = origDtype === 'BF16' ? 'F16' : origDtype;
+  if (!quantizationInfo) {
+    return sourceDtype;
+  }
+
+  if (isGptOssPackedExpertTensor(name)) {
+    return origDtype;
+  }
+
+  const role = classifyTensorRole(name);
+  if (role === 'embedding') {
+    return toWebGPUDtype(quantizationInfo.embeddings);
+  }
+  if (role === 'lm_head') {
+    const headQuant = quantizationInfo.lmHead ?? quantizationInfo.embeddings;
+    return toWebGPUDtype(headQuant);
+  }
+  if (shouldQuantize(name, shape)) {
+    return toWebGPUDtype(quantizationInfo.weights);
+  }
+
+  return sourceDtype;
+}
+
+export function resolveQ4KLayout(name, shape, quantizationInfo) {
+  if (!quantizationInfo?.layout) return null;
+  if (!isMatmulWeight(name, shape)) return null;
+  return quantizationInfo.layout;
+}
+
+export function getQ4KOutputSize(shape, layout) {
+  return getQ4KSize(shape, layout ?? 'flat');
+}
+
+export function decodeTensorToFloat32(buffer, sourceDtype) {
+  const upper = String(sourceDtype || '').toUpperCase();
+  if (upper === 'F32') {
+    return new Float32Array(buffer);
+  }
+
+  const bytes = new Uint8Array(buffer);
+  if (upper === 'BF16') {
+    const values = new Float32Array(bytes.length / 2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    for (let i = 0; i < values.length; i++) {
+      values[i] = bf16ToFloat32(view.getUint16(i * 2, true));
+    }
+    return values;
+  }
+
+  const values = new Float32Array(bytes.length / 2);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (let i = 0; i < values.length; i++) {
+    values[i] = float16ToFloat32(view.getUint16(i * 2, true));
+  }
+  return values;
+}
+
+export async function* createQ4KChunkStream(chunks, sourceDtype, shape, layout, chunkSizeBytes) {
+  if (layout === 'col') {
+    const totalElements = shape.reduce((a, b) => a * b, 1);
+    const data = new Float32Array(totalElements);
+    let offset = 0;
+
+    for await (const values of decodeFloat32Chunks(chunks, sourceDtype)) {
+      const remaining = totalElements - offset;
+      const count = Math.min(values.length, remaining);
+      data.set(values.subarray(0, count), offset);
+      offset += count;
+      if (offset >= totalElements) {
+        if (values.length > count) {
+          throw new Error('Quantization stream exceeded expected tensor length');
+        }
+        break;
+      }
+    }
+
+    if (offset < totalElements) {
+      throw new Error('Quantization stream ended early');
+    }
+
+    const result = quantizeToQ4KMColumnWise(data, shape);
+    const targetChunkSize = Math.max(chunkSizeBytes || QK4_K_BLOCK_SIZE, QK4_K_BLOCK_SIZE);
+    for (let i = 0; i < result.quantized.length; i += targetChunkSize) {
+      yield result.quantized.subarray(i, i + targetChunkSize);
+    }
+    return;
+  }
+  const totalElements = shape.reduce((a, b) => a * b, 1);
+  const rowLayout = layout === 'row' && shape.length === 2;
+  const cols = rowLayout ? shape[1] : 0;
+
+  const block = new Float32Array(QK_K);
+  let blockPos = 0;
+  let rowRemaining = cols;
+  let processed = 0;
+
+  const targetChunkSize = Math.max(chunkSizeBytes || QK4_K_BLOCK_SIZE, QK4_K_BLOCK_SIZE);
+  let outBuffer = new Uint8Array(targetChunkSize);
+  let outOffset = 0;
+
+  for await (const values of decodeFloat32Chunks(chunks, sourceDtype)) {
+    for (let i = 0; i < values.length && processed < totalElements; i++) {
+      block[blockPos++] = values[i];
+      processed++;
+      if (rowLayout) {
+        rowRemaining -= 1;
+      }
+
+      const rowBoundary = rowLayout && rowRemaining === 0;
+      if (blockPos === QK_K || rowBoundary) {
+        if (blockPos < QK_K) {
+          block.fill(0, blockPos);
+        }
+
+        const q4Block = quantizeQ4KBlock(block, 0);
+        if (q4Block.byteLength > outBuffer.byteLength) {
+          if (outOffset > 0) {
+            yield outBuffer.subarray(0, outOffset);
+            outOffset = 0;
+          }
+          yield q4Block;
+        } else {
+          if (outOffset + q4Block.byteLength > outBuffer.byteLength) {
+            yield outBuffer.subarray(0, outOffset);
+            outOffset = 0;
+          }
+          outBuffer.set(q4Block, outOffset);
+          outOffset += q4Block.byteLength;
+        }
+
+        blockPos = 0;
+        if (rowBoundary) {
+          rowRemaining = cols;
+        }
+      }
+    }
+  }
+
+  if (processed < totalElements) {
+    throw new Error('Quantization stream ended early');
+  }
+
+  if (!rowLayout && blockPos > 0) {
+    block.fill(0, blockPos);
+    const q4Block = quantizeQ4KBlock(block, 0);
+    if (outOffset + q4Block.byteLength > outBuffer.byteLength) {
+      yield outBuffer.subarray(0, outOffset);
+      outOffset = 0;
+    }
+    outBuffer.set(q4Block, outOffset);
+    outOffset += q4Block.byteLength;
+  }
+
+  if (outOffset > 0) {
+    yield outBuffer.subarray(0, outOffset);
+  }
+}
+
+export async function* createF16ChunkStream(chunks, sourceDtype) {
+  const upper = String(sourceDtype || '').toUpperCase();
+  if (upper === 'F16') {
+    for await (const chunk of chunks) {
+      yield chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
+    }
+    return;
+  }
+
+  const bytesPerElement = upper === 'F32' ? 4 : 2;
+  let carry = new Uint8Array(0);
+
+  for await (const chunk of chunks) {
+    const merged = concatBytes(carry, chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk));
+    const count = Math.floor(merged.length / bytesPerElement);
+    const used = count * bytesPerElement;
+    if (count > 0) {
+      const view = new DataView(merged.buffer, merged.byteOffset, used);
+      const out = new Uint16Array(count);
+      if (upper === 'F32') {
+        for (let i = 0; i < count; i++) {
+          out[i] = float32ToFloat16(view.getFloat32(i * 4, true));
+        }
+      } else if (upper === 'BF16') {
+        for (let i = 0; i < count; i++) {
+          out[i] = float32ToFloat16(bf16ToFloat32(view.getUint16(i * 2, true)));
+        }
+      } else {
+        for (let i = 0; i < count; i++) {
+          out[i] = float32ToFloat16(float16ToFloat32(view.getUint16(i * 2, true)));
+        }
+      }
+      yield new Uint8Array(out.buffer);
+    }
+    carry = merged.slice(used);
+  }
+
+  if (carry.length > 0) {
+    throw new Error('Unaligned tensor chunk for F16 conversion');
+  }
+}
+
+export async function quantizeToQ4KColumnWise(data, shape) {
+  return quantizeToQ4KMColumnWise(data, shape);
+}

package/src/browser/safetensors-parser-browser.d.ts

@@ -0,0 +1,193 @@
+/**
+ * safetensors-parser-browser.ts - Browser Safetensors Parser
+ *
+ * Parses Hugging Face safetensors files in the browser using File API.
+ * Supports both single files and sharded models (multiple files + index).
+ *
+ * @module browser/safetensors-parser-browser
+ */
+
+import type { SafetensorsTensor as CoreSafetensorsTensor, SafetensorsIndexJson } from '../formats/safetensors/types.js';
+import type { TensorSource } from './tensor-source-file.js';
+
+export { DTYPE_SIZE, DTYPE_MAP } from '../formats/safetensors/types.js';
+
+export type { SafetensorsDtype, SafetensorsIndexJson } from '../formats/safetensors/types.js';
+
+/**
+ * Tensor information from safetensors file
+ */
+export type SafetensorsTensor = CoreSafetensorsTensor & {
+  file?: File;
+  source?: TensorSource;
+  elemSize: number;
+  dtypeOriginal: string;
+};
+
+/**
+ * Parsed safetensors file result
+ */
+export interface ParsedSafetensorsFile {
+  headerSize: number;
+  dataOffset: number;
+  metadata: Record<string, unknown>;
+  tensors: SafetensorsTensor[];
+  file?: File;
+  source: TensorSource;
+  fileSize: number;
+  fileName: string;
+  config?: ModelConfig;
+}
+
+/**
+ * Shard information
+ */
+export interface ShardInfo {
+  file: string;
+  size: number;
+  tensorCount: number;
+}
+
+/**
+ * Parsed sharded safetensors model
+ */
+export interface ParsedSafetensorsSharded {
+  metadata: Record<string, unknown>;
+  shards: ShardInfo[];
+  tensors: SafetensorsTensor[];
+  fileMap: Map<string, TensorSource>;
+  config?: ModelConfig;
+}
+
+/**
+ * Model format detection result
+ */
+export interface ModelFormatInfo {
+  type: 'single' | 'sharded' | 'sharded-no-index' | 'gguf' | 'unknown';
+  indexFile?: File | TensorSource;
+  safetensorsFile?: File | TensorSource;
+  safetensorsFiles?: Array<File | TensorSource>;
+  ggufFile?: File | TensorSource;
+  files?: Array<File | TensorSource>;
+}
+
+/**
+ * Auxiliary files from model directory
+ */
+export interface AuxiliaryFiles {
+  config?: File | TensorSource;
+  tokenizerConfig?: File | TensorSource;
+  tokenizer?: File | TensorSource;
+  tokenizerModel?: File | TensorSource;
+  specialTokensMap?: File | TensorSource;
+  generationConfig?: File | TensorSource;
+}
+
+/**
+ * Parse safetensors header from File object
+ */
+export declare function parseSafetensorsFile(file: File | TensorSource): Promise<ParsedSafetensorsFile>;
+
+/**
+ * Parse sharded safetensors model from multiple files
+ */
+export declare function parseSafetensorsSharded(
+  files: Array<File | TensorSource>,
+  indexJson?: SafetensorsIndexJson | null
+): Promise<ParsedSafetensorsSharded>;
+
+/**
+ * Read tensor data from File
+ */
+export declare function readTensorData(tensor: SafetensorsTensor): Promise<ArrayBuffer>;
+
+/**
+ * Stream tensor data for large files
+ */
+export declare function streamTensorData(
+  tensor: SafetensorsTensor,
+  chunkSize?: number
+): AsyncGenerator<Uint8Array>;
+
+/**
+ * Parse config.json from File
+ */
+export declare function parseConfigJson(configFile: File | TensorSource): Promise<Record<string, unknown>>;
+
+export declare function parseTokenizerConfigJson(tokenizerConfigFile: File | TensorSource): Promise<Record<string, unknown>>;
+
+/**
+ * Parse tokenizer.json from File
+ */
+export declare function parseTokenizerJson(tokenizerFile: File | TensorSource): Promise<Record<string, unknown>>;
+
+/**
+ * Parse model.safetensors.index.json from File
+ */
+export declare function parseIndexJson(indexFile: File | TensorSource): Promise<SafetensorsIndexJson>;
+
+/**
+ * Detect model format from selected files
+ */
+export declare function detectModelFormat(files: Array<File | TensorSource>): ModelFormatInfo;
+
+/**
+ * Get auxiliary files from selection
+ */
+export declare function getAuxiliaryFiles(files: Array<File | TensorSource>): AuxiliaryFiles;
+
+/**
+ * Calculate total model size
+ */
+export declare function calculateTotalSize(parsed: { tensors: SafetensorsTensor[] }): number;
+
+/**
+ * Group tensors by layer
+ */
+export declare function groupTensorsByLayer(
+  parsed: { tensors: SafetensorsTensor[] }
+): Map<number, SafetensorsTensor[]>;
+
+/**
+ * @deprecated Use ParsedSafetensorsFile instead
+ */
+export type SafetensorsParseResult = ParsedSafetensorsFile;
+
+/**
+ * @deprecated Use ModelFormatInfo instead
+ */
+export type ModelFormat = ModelFormatInfo;
+
+/**
+ * @deprecated Use SafetensorsTensor instead
+ */
+export type TensorInfo = SafetensorsTensor;
+
+/**
+ * Model configuration type (extracted from config.json)
+ */
+export interface ModelConfig {
+  architectures?: string[];
+  model_type?: string;
+  hidden_size?: number;
+  intermediate_size?: number;
+  num_hidden_layers?: number;
+  num_attention_heads?: number;
+  num_key_value_heads?: number;
+  vocab_size?: number;
+  max_position_embeddings?: number;
+  rms_norm_eps?: number;
+  rope_theta?: number;
+  rope_scaling?: {
+    type?: string;
+    factor?: number;
+  };
+  _name_or_path?: string;
+  n_layer?: number;
+  n_embd?: number;
+  n_inner?: number;
+  n_head?: number;
+  n_positions?: number;
+  head_dim?: number;
+  [key: string]: unknown;
+}