Ruvector Learning Wasm

@ruvector/learning-wasm

Ultra-fast MicroLoRA (Low-Rank Adaptation) engine compiled to WebAssembly. Performs rank-2 LoRA weight updates in under 100 microseconds, enabling real-time model adaptation in browsers and edge environments without GPU hardware.

Quick Reference

Installation

npx @ruvector/learning-wasm@latest

Node.js Usage

import init, { MicroLoRA, adaptWeights, resetAdapter } from '@ruvector/learning-wasm';

await init();

// Create a MicroLoRA adapter
const adapter = new MicroLoRA({
  inputDim: 768,
  outputDim: 768,
  rank: 2,
  alpha: 1.0,
  learningRate: 0.001,
});

// Adapt to a new example
const input = new Float32Array(768);   // Input activations
const target = new Float32Array(768);  // Target activations
const loss = adapter.adapt(input, target);
console.log(`Adaptation loss: ${loss}`);

// Apply adapter to base model weights
const baseWeights = new Float32Array(768 * 768);
const adaptedWeights = adapter.apply(baseWeights);

// Quick functional API
const result = adaptWeights(baseWeights, {
  inputDim: 768,
  outputDim: 768,
  rank: 2,
  examples: [{ input, target }],
});

// Reset adapter to initial state
adapter.reset();

Browser Usage

<script type="module">
  import init, { MicroLoRA } from '@ruvector/learning-wasm';
  await init();

  const adapter = new MicroLoRA({ inputDim: 256, outputDim: 256, rank: 2 });
  const input = new Float32Array(256).fill(0.1);
  const target = new Float32Array(256).fill(0.5);
  const loss = adapter.adapt(input, target);
  console.log(`Loss: ${loss}`);
</script>

Key API

MicroLoRA

Lightweight LoRA adapter for real-time weight adaptation.

const adapter = new MicroLoRA(config: LoRAConfig);

LoRAConfig:

adapter.adapt(input, target)

Perform one adaptation step. Returns the loss value.

adapter.adapt(input: Float32Array, target: Float32Array): number

adapter.adaptBatch(examples)

Batch adaptation over multiple examples.

adapter.adaptBatch(examples: Array<{ input: Float32Array; target: Float32Array }>): number

Returns average loss across the batch.

adapter.apply(weights)

Apply the LoRA delta to base weights: W' = W + alpha * B * A.

adapter.apply(weights: Float32Array): Float32Array

adapter.delta()

Get the raw LoRA delta matrix without applying to weights.

adapter.delta(): Float32Array  // Shape: inputDim x outputDim

adapter.reset()

Reset adapter weights to initial state.

adapter.reset(): void

adapter.save() / MicroLoRA.load(data)

Serialize and restore adapter state.

const data = adapter.save(): Uint8Array
const restored = MicroLoRA.load(data: Uint8Array): MicroLoRA

adapter.free()

Release WASM memory.

adapter.free(): void

adaptWeights(baseWeights, config)

Functional API: adapt weights in a single call.

const adapted = adaptWeights(
  baseWeights: Float32Array,
  config: { inputDim: number; outputDim: number; rank?: number; examples: Example[] }
): Float32Array

resetAdapter(adapter)

Reset adapter to zero-initialized state.

resetAdapter(adapter: MicroLoRA): void

Common Patterns

Online Learning in Browser

const adapter = new MicroLoRA({ inputDim: 512, outputDim: 512, rank: 2 });

// Continuously adapt from user feedback
function onUserFeedback(input: Float32Array, correctedOutput: Float32Array) {
  const loss = adapter.adapt(input, correctedOutput);
  const updatedWeights = adapter.apply(modelWeights);
  return updatedWeights;
}

Multi-Layer Adaptation

const adapters = layers.map(dim => new MicroLoRA({
  inputDim: dim.in,
  outputDim: dim.out,
  rank: 2,
}));

// Adapt all layers
for (let i = 0; i < adapters.length; i++) {
  adapters[i].adapt(activations[i], targets[i]);
}

References

• API Reference
• npm