@buley/neural 2.0.3 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@buley/neural",
-  "version": "2.0.3",
+  "version": "3.0.0",
   "description": "A Transparent, Local-First, WebGPU-Accelerated Neural Graph Database.",
   "type": "module",
   "main": "./src/index.ts",

package/src/engine/gpu.ts

@@ -112,7 +112,7 @@ export class GPUEngine {
         }
 
         // Upload Input
-        this.device.queue.writeBuffer(this.inputBuffer, 0, inputs as unknown as BufferSource);
+        this.device.queue.writeBuffer(this.inputBuffer, 0, inputs as BufferSource);
 
         // Encode Command
         const commandEncoder = this.device.createCommandEncoder();
@@ -213,7 +213,7 @@ export class GPUEngine {
         // Let's assume prepareTrainingBuffers was called ONCE before loop.
         // We just need to update TARGETS buffer!
         if (this.targetBuffer) {
-             this.device?.queue.writeBuffer(this.targetBuffer, 0, targets as unknown as BufferSource);
+             this.device?.queue.writeBuffer(this.targetBuffer, 0, targets as BufferSource);
         }
         
         // Run Training Shaders
@@ -229,7 +229,7 @@ export class GPUEngine {
         }
 
         if (deltas && deltas.length > 0) {
-           this.device.queue.writeBuffer(this.deltaBuffer, 0, deltas as unknown as BufferSource);
+           this.device.queue.writeBuffer(this.deltaBuffer, 0, deltas as BufferSource);
         }
 
         const commandEncoder = this.device.createCommandEncoder();
@@ -258,7 +258,7 @@ export class GPUEngine {
         
         // We only write what we are given, usually just the first N inputs (Microphone bins)
         // If data is smaller than buffer, we use queue.writeBuffer which handles partial writes
-        this.device.queue.writeBuffer(this.inputBuffer, 0, data as unknown as BufferSource);
+        this.device.queue.writeBuffer(this.inputBuffer, 0, data as BufferSource);
         
         // Trigger a tick? Or let the outer loop do it?
         // Let's just update the buffer. The UI loop calls runTick() or similar.

package/src/engine/webnn.ts

@@ -0,0 +1,118 @@
+
+/// <reference path="../webnn-types.d.ts" />
+
+export class WebNNEngine {
+    context: MLContext | null = null;
+    builder: MLGraphBuilder | null = null;
+    graph: MLGraph | null = null;
+
+    // Buffers/State
+    networkSize: number = 0;
+    batchSize: number = 1;
+    
+    // We keep weights/biases in memory to rebuild graph if needed, 
+    // though for strict WebNN we bakw them into constants.
+    weights: Float32Array | null = null;
+    biases: Float32Array | null = null;
+
+    isReady = false;
+
+    async init() {
+        if (!navigator.ml) {
+            console.warn("WebNN: navigator.ml not supported");
+            return;
+        }
+
+        try {
+            // Prefer NPU, fallback to GPU if NPU not available, though we really want NPU for "cool factor"
+            // Note: browser support for 'npu' deviceType is bleeding edge.
+            this.context = await navigator.ml.createContext({ deviceType: 'npu', powerPreference: 'low-power' });
+            console.log("WebNN: NPU Context created");
+            
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.builder = new (window as any).MLGraphBuilder(this.context);
+            this.isReady = true;
+        } catch (e) {
+            console.error("WebNN Init Error (likely no NPU or flag disabled):", e);
+            // Fallback? or just stay uninitialized
+        }
+    }
+
+    async prepareModel(size: number, weights: Float32Array, biases: Float32Array, batchSize: number = 1) {
+        if (!this.context || !this.builder) return;
+        this.networkSize = size;
+        this.batchSize = batchSize;
+        this.weights = weights;
+        this.biases = biases;
+
+        // Build the Computational Graph
+        // Model: Y = Tanh((X * W) + B)
+        // Shapes:
+        // X: [batchSize, networkSize]
+        // W: [networkSize, networkSize] 
+        // B: [networkSize] (Broadcasted)
+        // Y: [batchSize, networkSize]
+
+        try {
+            const builder = this.builder;
+
+            // 1. Input Operand (Variable)
+            const inputDesc: MLOperandDescriptor = {
+                dataType: 'float32',
+                dimensions: [batchSize, size] 
+            };
+            const input = builder.input('input', inputDesc);
+
+            // 2. Constants (Weights & Biases)
+            // Note: WebNN matmul expects typically [I, J] * [J, K] -> [I, K]
+            // Our weights are N*N flattened. 
+            const weightDesc: MLOperandDescriptor = {
+                dataType: 'float32',
+                dimensions: [size, size]
+            };
+            // WebNN might require specific buffer types, Float32Array is good.
+            const weightConstant = builder.constant(weightDesc, weights);
+
+            const biasDesc: MLOperandDescriptor = {
+                dataType: 'float32',
+                dimensions: [size] // 1D, will broadcast to [batch, size]
+            };
+            const biasConstant = builder.constant(biasDesc, biases);
+
+            // 3. Operations
+            // MatMul: [batch, size] * [size, size] -> [batch, size]
+            const matmul = builder.matmul(input, weightConstant);
+            
+            // Add Bias (Broadcast)
+            const added = builder.add(matmul, biasConstant);
+            
+            // Activation
+            const output = builder.tanh(added);
+
+            // 4. Build
+            this.graph = await builder.build({ 'output': output });
+            console.log("WebNN: Graph compiled successfully");
+
+        } catch (e) {
+            console.error("WebNN Build Error:", e);
+        }
+    }
+
+    async runTick(inputs: Float32Array): Promise<Float32Array> {
+        if (!this.context || !this.graph) {
+            throw new Error("WebNN not ready");
+        }
+        if (inputs.length !== this.networkSize * this.batchSize) {
+           throw new Error(`Input size mismatch. Expected ${this.networkSize * this.batchSize}, got ${inputs.length}`);
+        }
+
+        const outputs = new Float32Array(this.networkSize * this.batchSize);
+
+        const inputsMap = { 'input': inputs };
+        const outputsMap = { 'output': outputs };
+
+        await this.context.compute(this.graph, inputsMap, outputsMap);
+        
+        return outputs;
+    }
+}

package/src/index.ts

@@ -2,24 +2,32 @@ import { dash } from "@buley/dash";
 import { initializeSchema } from "./db/schema";
 import { NeuronRepository, SynapseRepository } from "./db/repository";
 import { GPUEngine } from "./engine/gpu";
+import { WebNNEngine } from "./engine/webnn";
 import { Translator } from "./engine/translator";
+import { Neuron, Synapse } from "./types";
+
+export type { Neuron, Synapse } from "./types";
 
 export class NeuralEngine {
     gpu: GPUEngine;
+    npu: WebNNEngine;
     neuronRepo: NeuronRepository;
     synapseRepo: SynapseRepository;
     private translator: Translator;
 
+    activeBackend: 'gpu' | 'npu' = 'gpu';
+
     constructor() {
         this.gpu = new GPUEngine();
+        this.npu = new WebNNEngine();
         this.neuronRepo = new NeuronRepository();
         this.synapseRepo = new SynapseRepository();
         this.translator = new Translator();
     }
 
     // Cache
-    private neurons: any[] = [];
-    private synapses: any[] = [];
+    private neurons: Neuron[] = [];
+    private synapses: Synapse[] = [];
 
     async init() {
         console.log("Neural 2.0 Engine Initializing...");
@@ -32,6 +40,13 @@ export class NeuralEngine {
         await this.gpu.init();
         this.gpu.batchSize = 2; // Default to mini-batch of 2 for demo
 
+        // Try NPU
+        await this.npu.init();
+        if (this.npu.isReady) {
+            console.log("Neural Engine: NPU Accelerated Backend Available.");
+            this.activeBackend = 'npu'; 
+        }
+
         // 3. Hydration
         this.neurons = await this.neuronRepo.getAll();
         this.synapses = await this.synapseRepo.getAll();
@@ -61,17 +76,27 @@ export class NeuralEngine {
             this.synapses = await this.synapseRepo.getAll();
         }
 
-        // 4. Compile to GPU
+        // 4. Compile to Compute Backends
+        await this.compile();
+
+        console.log(`Engine Ready. Active Backend: ${this.activeBackend.toUpperCase()}`);
+        return this.getGraphData();
+    }
+
+    async compile() {
         console.log(`Compiling graph: ${this.neurons.length} neurons, ${this.synapses.length} synapses`);
         const data = this.translator.flatten(this.neurons, this.synapses);
 
+        // GPU
         this.gpu.prepareBuffers(data.size, data.weights, data.biases, this.gpu.batchSize);
-        // Also prepare training buffers!
-        // Init target buffer with zeros
         this.gpu.prepareTrainingBuffers(new Float32Array(data.size * this.gpu.batchSize), 0.1);
 
-        console.log("Engine Ready.");
-        return data;
+        // NPU
+        if (this.npu.isReady) {
+            await this.npu.prepareModel(data.size, data.weights, data.biases, 2); 
+        }
+        
+        return data; // Return data for init/others if needed
     }
 
     async deployToCloud() {
@@ -128,12 +153,7 @@ export class NeuralEngine {
         this.synapses = this.synapses.filter(s => s.id !== id);
         
         // Recompile (Heavy!)
-        // In a real app we'd just zero the weight in buffer
-        // But for "The Visible Brain" seeing it disappear is cooler.
-        const data = this.translator.flatten(this.neurons, this.synapses);
-        this.gpu.prepareBuffers(data.size, data.weights, data.biases, this.gpu.batchSize);
-        // Reset training buffers too to be safe/simple
-        this.gpu.prepareTrainingBuffers(new Float32Array(data.size * this.gpu.batchSize), 0.1);
+        await this.compile();
 
         return this.getGraphData();
     }
@@ -146,7 +166,7 @@ export class NeuralEngine {
         };
     }
 
-    async importGraph(data: any) {
+    async importGraph(data: { neurons: Neuron[], synapses: Synapse[] }) {
         if (!data.neurons || !data.synapses) throw new Error("Invalid graph data");
         
         console.log("Importing graph...");
@@ -167,18 +187,25 @@ export class NeuralEngine {
         this.synapses = await this.synapseRepo.getAll();
         
         console.log(`Compiling imported graph: ${this.neurons.length} neurons, ${this.synapses.length} synapses`);
-        const graph = this.translator.flatten(this.neurons, this.synapses);
-        this.gpu.prepareBuffers(graph.size, graph.weights, graph.biases, this.gpu.batchSize);
-        this.gpu.prepareTrainingBuffers(new Float32Array(graph.size * this.gpu.batchSize), 0.1);
+        await this.compile();
         
         return this.getGraphData();
     }
 
     async injectInput(data: Float32Array) {
-        // Map data to input neurons
-        // In simulation, we assume first N neurons are inputs.
-        // Or we just overwrite the first N values of the input buffer.
-        await this.gpu.injectInput(data);
+        if (this.activeBackend === 'npu' && this.npu.isReady) {
+             // WebNN takes input at runTick
+        } else {
+            await this.gpu.injectInput(data);
+        }
+    }
+
+    async runTick(inputs: Float32Array): Promise<Float32Array> {
+        if (this.activeBackend === 'npu' && this.npu.isReady) {
+            return this.npu.runTick(inputs);
+        } else {
+            return this.gpu.runTick(inputs);
+        }
     }
 }
 

package/src/types.ts

@@ -1,6 +1,6 @@
 export interface Neuron {
     id: string;
-    type: 'input' | 'hidden' | 'output';
+    type: 'input' | 'hidden' | 'output' | 'cloud';
     bias: number;
     activation: string;
 }

package/src/webnn-types.d.ts

@@ -0,0 +1,43 @@
+
+// Minimal WebNN Type Definitions for TypeScript
+// Based on W3C Web Neural Network API Draft
+
+interface MLContext {
+    compute(graph: MLGraph, inputs: Record<string, ArrayBufferView>, outputs: Record<string, ArrayBufferView>): Promise<MLComputeResult>;
+}
+
+interface MLComputeResult {
+    inputs: Record<string, ArrayBufferView>;
+    outputs: Record<string, ArrayBufferView>;
+}
+
+interface MLGraphBuilder {
+    input(name: string, descriptor: MLOperandDescriptor): MLOperand;
+    constant(descriptor: MLOperandDescriptor, buffer: ArrayBufferView): MLOperand;
+    matmul(a: MLOperand, b: MLOperand): MLOperand;
+    add(a: MLOperand, b: MLOperand): MLOperand;
+    tanh(x: MLOperand): MLOperand;
+    build(outputs: Record<string, MLOperand>): Promise<MLGraph>;
+}
+
+interface MLGraph {}
+
+interface MLOperand {}
+
+interface MLOperandDescriptor {
+    dataType: 'float32' | 'float16' | 'int32' | 'uint32' | 'int8' | 'uint8';
+    dimensions: number[];
+}
+
+interface MLContextOptions {
+    deviceType?: 'cpu' | 'gpu' | 'npu';
+    powerPreference?: 'default' | 'high-performance' | 'low-power';
+}
+
+interface NavigatorML {
+    createContext(options?: MLContextOptions): Promise<MLContext>;
+}
+
+interface Navigator {
+    ml?: NavigatorML;
+}