@openfluke/welvet 0.1.6 → 0.1.8

package/README.md

@@ -201,54 +201,56 @@ for (let step = 0; step < 100000; step++) {
 
 See `example/step_train_v3.ts` for a complete example achieving 100% accuracy.
 
+### 🧠 Neural Tweening API - Gradient-Free Learning
 
-{
-type: "parallel",
-combine_mode: "add",
-branches: [
-{
-type: "dense",
-input_size: 16,
-output_size: 8,
-activation: "relu",
-},
-{
-type: "dense",
-input_size: 16,
-output_size: 8,
-activation: "gelu",
-},
-],
-},
-{ type: "lstm", input_size: 16, hidden_size: 8, seq_length: 1 },
-{ type: "rnn", input_size: 16, hidden_size: 8, seq_length: 1 },
-],
-},
-{
-type: "dense",
-input_size: 24,
-output_size: 2,
-activation: "sigmoid",
-},
-],
-});
-
-// Train multi-agent network
-const batches: TrainingBatch[] = [
-{ Input: [0.2, 0.2, 0.2, 0.2, 0.8, 0.8, 0.8, 0.8], Target: [1.0, 0.0] },
-{ Input: [0.9, 0.9, 0.9, 0.9, 0.1, 0.1, 0.1, 0.1], Target: [0.0, 1.0] },
-];
+**NEW:** Direct weight adjustment without backpropagation:
 
-const config: TrainingConfig = {
-Epochs: 800,
-LearningRate: 0.15,
-LossType: "mse",
-Verbose: false,
-};
+```typescript
+import { init, createNetwork, TweenState } from "@openfluke/welvet";
 
-const result = agentNetwork.Train(JSON.stringify([batches, config]));
+await init();
 
-````
+const network = createNetwork(config);
+
+// Create tween state (with optional chain rule)
+const tweenState: TweenState = network.createTweenState(true); // useChainRule=true
+
+// Training loop - direct weight updates
+for (let step = 0; step < 10000; step++) {
+  const input = new Float32Array([0.1, 0.2, 0.3, 0.4]);
+  const targetClass = 1; // Target output class
+  
+  // Single-step tween learning
+  const loss = tweenState.TweenStep(input, targetClass, 4, 0.02);
+}
+```
+
+**Tweening API:**
+- `network.createTweenState(useChainRule)` - Initialize tween state
+- `tweenState.TweenStep(input, targetClass, outputSize, lr)` - Train step
+- `tweenState.setChainRule(enabled)` - Toggle chain rule
+- `tweenState.getChainRule()` - Get chain rule status
+- `tweenState.getTweenSteps()` - Get total steps performed
+
+### 📊 Adaptation Benchmark - Multi-Architecture Testing
+
+**NEW:** Run the full Test 18 Multi-Architecture Adaptation Benchmark:
+
+```bash
+cd example
+bun run test18_adaptation.ts
+```
+
+Tests 5 architectures × 3 depths × 5 training modes (75 tests total):
+- **Architectures:** Dense, Conv2D, RNN, LSTM, Attention
+- **Depths:** 3, 5, 9 layers
+- **Modes:** NormalBP, StepBP, Tween, TweenChain, StepTweenChain
+
+Measures adaptation speed when tasks change mid-stream (chase→avoid→chase).
+
+See `example/test18_adaptation.ts` for the full implementation.
+
+```
 
 ## API Reference
 
@@ -374,9 +376,9 @@ interface TrainingConfig {
 }
 ```
 
-## Example
+## Examples
 
-See `example/grid-scatter.ts` for a complete multi-agent training demo:
+### Grid Scatter Multi-Agent
 
 ```bash
 cd example
@@ -384,20 +386,20 @@ bun install
 bun run grid-scatter.ts
 ```
 
-Expected output:
+### Stepping Training (LSTM)
 
+```bash
+bun run step_train_v3.ts
 ```
-🤖 Running Grid Scatter Multi-Agent Training...
-✅ Agent network created!
-Training for 800 epochs with learning rate 0.150
-✅ Training complete!
-Training time: 0.47 seconds
-Initial Loss: 0.252249
-Final Loss: 0.001374
-Improvement: 99.46%
-Total Epochs: 800
+
+### Adaptation Benchmark (75 tests)
+
+```bash
+bun run test18_adaptation.ts
 ```
 
+> **Note:** Full benchmark takes ~12.5 minutes (10 seconds per test)
+
 ## Layer Types
 
 - `dense` - Fully connected layer
@@ -417,7 +419,7 @@ Total Epochs: 800
 
 ## License
 
-MIT
+APACHE2
 
 ## Links
 

package/dist/types.d.ts

@@ -100,6 +100,7 @@ export interface Network {
     ApplyGradientsRMSprop(paramsJSON: string): string;
     ApplyGradientsSGDMomentum(paramsJSON: string): string;
     createStepState(inputSize: number): StepState;
+    createTweenState(useChainRule?: boolean): TweenState;
 }
 /**
  * StepState interface for stepping execution
@@ -110,10 +111,42 @@ export interface StepState {
     getOutput(): Float32Array;
     stepBackward(gradients: Float32Array | number[]): Float32Array;
 }
+/**
+ * TweenState interface for neural tweening execution
+ */
+export interface TweenState {
+    /**
+     * Perform a tween training step
+     * @param input - Input data
+     * @param targetClass - Target class index
+     * @param outputSize - Size of output layer
+     * @param learningRate - Learning rate for this step
+     * @returns Loss value
+     */
+    TweenStep(input: Float32Array | number[], targetClass: number, outputSize: number, learningRate: number): number;
+    /** Enable/disable chain rule mode */
+    setChainRule(enabled: boolean): void;
+    /** Get current chain rule setting */
+    getChainRule(): boolean;
+    /** Get number of tween steps performed */
+    getTweenSteps(): number;
+}
 /**
  * Global WASM functions exposed by main.go
  * Only createLoomNetwork is exposed - use network.SaveModelToString() for saving
  */
 declare global {
     function createLoomNetwork(jsonConfig: string): Network;
+    function createAdaptationTracker(windowMs: number, totalMs: number): AdaptationTracker;
+}
+/**
+ * AdaptationTracker interface for tracking accuracy during task changes
+ */
+export interface AdaptationTracker {
+    setModelInfo(modelName: string, modeName: string): void;
+    scheduleTaskChange(atOffsetMs: number, taskID: number, taskName: string): void;
+    start(initialTask: string, initialTaskID: number): void;
+    recordOutput(isCorrect: boolean): void;
+    getCurrentTask(): number;
+    finalize(): string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfluke/welvet",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "TypeScript/JavaScript bindings for LOOM neural network framework with WebAssembly support - GPU-accelerated machine learning in the browser",
   "type": "module",
   "main": "./dist/index.js",