mini-jstorch 1.4.4 → 1.5.0

package/README.md

@@ -6,30 +6,21 @@ A lightweight JavaScript neural network library for rapid frontend AI experiment
 
 Mini-JSTorch is a high-performance, minimalist JavaScript library for building neural networks. It runs efficiently in both frontend and backend environments, including low-end devices. The library enables quick experimentation and learning in AI without compromising stability, accuracy, or training reliability.
 
-This release, **version 1.4.4**, We make `Matrix Utils` now can be used in others Files.
+This release, **version 1.5.0:** Adds user-friendly tensor functions, Flatten layer, and improved Conv2D operations and Modify Some Class
+For Architecture Compability.
 
 ---
 
-## Feature Highlights
-
-- **Learning Rate Schedulers:** New `StepLR` and `LambdaLR` for dynamic optimizer learning rate adjustment.
-- **Full Conv2D support:** Forward and backward operations for convolutional layers.
-- **Tensor operations:** Broadcasting, reshaping, and reduction utilities.
-- **Advanced Activations:** Includes `LeakyReLU`, `GELU`, `Mish`, `SiLU`, `ELU`, and more.
-- **Optimizers:** `Adam` and `SGD` with gradient updates.
-- **Dropout Layer:** For regularization during training.
-- **BatchNorm2D:** For stable training in convolutional models.
-- **Tensor Manipulation:** Utilities like `flatten`, `stack`, `concat`, `eye`, `reshape`.
-- **Model Save & Load:** Easy persistence and restore of models.
-- **Test/Demo Templates:** The `tests/` folder provides ready-to-run examples for model building and feature usage.
-- **Performance Optimized:** Suitable for both frontend and backend usage.
-- **Backward Compatibility:** Maintained for core layers and activations.
+## New Features Highlights
+
+- **User-Friendly Tensor API:** New `fu_` functions (`fu_tensor`, `fu_add`, `fu_matmul`, etc.) with automatic validation and shape checking
+- **Flatten Layer:** Essential for connecting CNN architectures to dense layers.
 
 ---
 
 ## Core Features
 
-- **Layers:** Linear, Conv2D  
+- **Layers:** Linear, Flatten, Conv2D  
 - **Activations:** ReLU, Sigmoid, Tanh, LeakyReLU, GELU, Mish, SiLU, ELU  
 - **Loss Functions:** MSELoss, CrossEntropyLoss
 - **Optimizers:** Adam, SGD  
@@ -52,7 +43,7 @@ npm install mini-jstorch
 ## Quick Start Example
 
 ```javascript
-import { Sequential, Linear, ReLU, Sigmoid, CrossEntropyLoss, Adam, StepLR } from 'mini-jstorch';
+import { Sequential, Linear, ReLU, Sigmoid, CrossEntropyLoss, Adam, StepLR } from './jstorch.js';
 
 // Build model
 const model = new Sequential([
@@ -99,7 +90,7 @@ predTest.forEach((p,i) => {
 ## Save & Load Models
 
 ```javascript
-import { saveModel, loadModel, Sequential } from './src/MainEngine.js';
+import { saveModel, loadModel, Sequential } from '.jstorch.js';
 
 const json = saveModel(model);
 const model2 = new Sequential([...]); // same architecture

package/index.js

@@ -1,2 +1,2 @@
 // package root
-export * from "./src/MainEngine.js";
+export * from "./src/jstorch.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-jstorch",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "type": "module", 
   "description": "A lightweight JavaScript neural network library for rapid frontend AI experimentation on low-resource devices Inspired by PyTorch.",
   "main": "index.js",

package/src/{MainEngine.js → jstorch.js}

@@ -70,8 +70,160 @@ export function crossEntropy(pred,target){
     const eps=1e-12; 
     return -target.reduce((sum,t,i)=>sum+t*Math.log(pred[i]+eps),0); 
 }
-/* Not Added more Utils yet. (this patch not MINOR)
-   Just make it Public to other files. */ 
+
+// ---------------------- USERS FRIENDLY UTILS ----------------
+export function fu_tensor(data, requiresGrad = false) {
+    if (!Array.isArray(data) || !Array.isArray(data[0])) {
+        throw new Error("fu_tensor: Data must be 2D array");
+    }
+    const tensor = new Tensor(data);
+    tensor.requiresGrad = requiresGrad;
+    return tensor;
+}
+
+// fu_add
+export function fu_add(a, b) {
+    if (!(a instanceof Tensor) && !(b instanceof Tensor)) {
+        throw new Error("fu_add: At least one operand must be Tensor");
+    }
+    
+    if (!(a instanceof Tensor)) {
+        a = fu_tensor(Array(b.shape()[0]).fill().map(() => 
+            Array(b.shape()[1]).fill(a)
+        ));
+    }
+    
+    if (!(b instanceof Tensor)) {
+        b = fu_tensor(Array(a.shape()[0]).fill().map(() => 
+            Array(a.shape()[1]).fill(b)
+        ));
+    }
+    
+    if (a.shape()[0] !== b.shape()[0] || a.shape()[1] !== b.shape()[1]) {
+        throw new Error(`fu_add: Shape mismatch ${a.shape()} vs ${b.shape()}`);
+    }
+    
+    return new Tensor(a.data.map((r, i) => r.map((v, j) => v + b.data[i][j])));
+}
+
+// fu_mul
+export function fu_mul(a, b) {
+    if (!(a instanceof Tensor) && !(b instanceof Tensor)) {
+        throw new Error("fu_mul: At least one operand must be Tensor");
+    }
+    
+    if (!(a instanceof Tensor)) {
+        a = fu_tensor(Array(b.shape()[0]).fill().map(() => 
+            Array(b.shape()[1]).fill(a)
+        ));
+    }
+    
+    if (!(b instanceof Tensor)) {
+        b = fu_tensor(Array(a.shape()[0]).fill().map(() => 
+            Array(a.shape()[1]).fill(b)
+        ));
+    }
+    
+    if (a.shape()[0] !== b.shape()[0] || a.shape()[1] !== b.shape()[1]) {
+        throw new Error(`fu_mul: Shape mismatch ${a.shape()} vs ${b.shape()}`);
+    }
+    
+    return new Tensor(a.data.map((r, i) => r.map((v, j) => v * b.data[i][j])));
+}
+
+// fu_matmul
+export function fu_matmul(a, b) {
+    if (!(a instanceof Tensor)) a = fu_tensor(a);
+    if (!(b instanceof Tensor)) b = fu_tensor(b);
+    
+    if (a.shape()[1] !== b.shape()[0]) {
+        throw new Error(`fu_matmul: Inner dimension mismatch ${a.shape()[1]} vs ${b.shape()[0]}`);
+    }
+    
+    return new Tensor(dot(a.data, b.data));
+}
+
+// fu_sum
+export function fu_sum(tensor) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    const total = tensor.data.flat().reduce((a, b) => a + b, 0);
+    return new Tensor([[total]]);
+}
+
+// fu_mean
+export function fu_mean(tensor) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    const totalElements = tensor.shape()[0] * tensor.shape()[1];
+    const sum = fu_sum(tensor).data[0][0];
+    return new Tensor([[sum / totalElements]]);
+}
+
+// fu_relu
+export function fu_relu(tensor) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    return new Tensor(tensor.data.map(r => r.map(v => Math.max(0, v))));
+}
+
+// fu_sigmoid
+export function fu_sigmoid(tensor) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    const fn = v => 1 / (1 + Math.exp(-v));
+    return new Tensor(tensor.data.map(r => r.map(fn)));
+}
+
+// fu_tanh
+export function fu_tanh(tensor) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    return new Tensor(tensor.data.map(r => r.map(v => Math.tanh(v))));
+}
+
+// fu_softmax
+export function fu_softmax(tensor) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    const result = tensor.data.map(row => {
+        const maxVal = Math.max(...row);
+        const exps = row.map(v => Math.exp(v - maxVal));
+        const sumExps = exps.reduce((a, b) => a + b, 0);
+        return exps.map(v => v / sumExps);
+    });
+    return new Tensor(result);
+}
+
+// fu_flatten - Flatten tensor to 1D
+export function fu_flatten(tensor) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    return new Tensor([tensor.data.flat()]);
+}
+
+// fu_reshape
+export function fu_reshape(tensor, rows, cols) {
+    if (!(tensor instanceof Tensor)) tensor = fu_tensor(tensor);
+    const flat = tensor.data.flat();
+    if (flat.length !== rows * cols) {
+        throw new Error(`fu_reshape: Size mismatch ${flat.length} vs ${rows * cols}`);
+    }
+    
+    const result = [];
+    for (let i = 0; i < rows; i++) {
+        result.push(flat.slice(i * cols, i * cols + cols));
+    }
+    return new Tensor(result);
+}
+
+// fu_stack
+export function fu_stack(tensors) {
+    if (!tensors.every(t => t instanceof Tensor)) {
+        throw new Error("fu_stack: All inputs must be Tensors");
+    }
+    
+    const firstShape = tensors[0].shape();
+    if (!tensors.every(t => t.shape()[0] === firstShape[0] && t.shape()[1] === firstShape[1])) {
+        throw new Error("fu_stack: All tensors must have same shape");
+    }
+    
+    const stacked = tensors.map(t => t.data);
+    return new Tensor(stacked);
+}
 
 // ---------------------- Tensor ----------------------
 export class Tensor {
@@ -121,47 +273,163 @@ export class Linear {
     parameters(){ return [ {param:this.W,grad:this.gradW}, {param:[this.b],grad:[this.gradb]} ]; }
 }
 
+export class Flatten {
+    constructor() {
+        this.originalShape = null;
+    }
+    
+    forward(x) {
+        // Always convert to [batch, features] format
+        this.originalShape = x.map(sample => this._getShape(sample));
+        
+        return x.map(sample => {
+            const flat = this._flatten(sample);
+            return flat; // Return as 1D array for [batch, features] compatibility
+        });
+    }
+    
+    backward(grad) {
+        // grad is [batch, features], reshape back to original shape
+        return grad.map((flatGrad, batchIdx) => {
+            const shape = this.originalShape[batchIdx];
+            return this._unflatten(flatGrad, shape);
+        });
+    }
+    
+    _getShape(sample) {
+        if (Array.isArray(sample[0]) && Array.isArray(sample[0][0])) {
+            return {
+                type: '3d',
+                dims: [sample.length, sample[0].length, sample[0][0].length]
+            };
+        } else if (Array.isArray(sample[0])) {
+            return {
+                type: '2d', 
+                dims: [sample.length, sample[0].length]
+            };
+        } else {
+            return {
+                type: '1d',
+                dims: [sample.length]
+            };
+        }
+    }
+    
+    _flatten(sample) {
+        if (Array.isArray(sample[0]) && Array.isArray(sample[0][0])) {
+            return sample.flat(2); // [channels, height, width] -> flat
+        } else if (Array.isArray(sample[0])) {
+            return sample.flat(); // [height, width] -> flat
+        } else {
+            return sample; // already flat
+        }
+    }
+    
+    _unflatten(flat, shape) {
+        if (shape.type === '3d') {
+            const [channels, height, width] = shape.dims;
+            const result = [];
+            let index = 0;
+            for (let c = 0; c < channels; c++) {
+                const channel = [];
+                for (let h = 0; h < height; h++) {
+                    const row = [];
+                    for (let w = 0; w < width; w++) {
+                        row.push(flat[index++]);
+                    }
+                    channel.push(row);
+                }
+                result.push(channel);
+            }
+            return result;
+        } else if (shape.type === '2d') {
+            const [height, width] = shape.dims;
+            const result = [];
+            for (let h = 0; h < height; h++) {
+                result.push(flat.slice(h * width, h * width + width));
+            }
+            return result;
+        } else {
+            return flat; // 1d
+        }
+    }
+    
+    parameters() { return []; }
+}
+
 // ---------------------- Conv2D ----------------------
 export class Conv2D {
-    constructor(inC,outC,kernel,stride=1,padding=0){
-        this.inC=inC; this.outC=outC; this.kernel=kernel;
-        this.stride=stride; this.padding=padding;
-        this.W=Array(outC).fill(0).map(()=>Array(inC).fill(0).map(()=>randomMatrix(kernel,kernel)));
-        this.gradW=Array(outC).fill(0).map(()=>Array(inC).fill(0).map(()=>zeros(kernel,kernel)));
-        this.x=null;
+    constructor(inC, outC, kernel, stride=1, padding=0){
+        this.inC = inC; 
+        this.outC = outC; 
+        this.kernel = kernel;
+        this.stride = stride; 
+        this.padding = padding;
+        this.W = Array(outC).fill().map(() => 
+            Array(inC).fill().map(() => randomMatrix(kernel, kernel))
+        );
+        this.gradW = Array(outC).fill().map(() => 
+            Array(inC).fill().map(() => zeros(kernel, kernel))
+        );
+        this.x = null;
     }
 
-    pad2D(input,pad){
-        return input.map(channel=>{
-            const rows=channel.length+2*pad;
-            const cols=channel[0].length+2*pad;
-            const out=Array.from({length:rows},()=>Array(cols).fill(0));
-            for(let i=0;i<channel.length;i++) for(let j=0;j<channel[0].length;j++) out[i+pad][j+pad]=channel[i][j];
-            return out;
-        });
+    pad2D(input, pad){
+        // Input is single channel [height, width]
+        if (!input || !input.length) return input;
+        
+        const rows = input.length + 2 * pad;
+        const cols = input[0].length + 2 * pad;
+        const out = Array.from({length: rows}, () => Array(cols).fill(0));
+        
+        for(let i = 0; i < input.length; i++) {
+            for(let j = 0; j < input[0].length; j++) {
+                out[i + pad][j + pad] = input[i][j];
+            }
+        }
+        return out;
     }
 
-    conv2DSingle(input,kernel){
-        const rows=input.length-kernel.length+1;
-        const cols=input[0].length-kernel[0].length+1;
-        const out=zeros(rows,cols);
-        for(let i=0;i<rows;i++) for(let j=0;j<cols;j++)
-            for(let ki=0;ki<kernel.length;ki++) for(let kj=0;kj<kernel[0].length;kj++)
-                out[i][j]+=input[i+ki][j+kj]*kernel[ki][kj];
+    conv2DSingle(input, kernel) {
+        const rows = Math.floor((input.length - kernel.length) / this.stride) + 1;
+        const cols = Math.floor((input[0].length - kernel[0].length) / this.stride) + 1;
+        const out = zeros(rows, cols);
+        
+        for(let i = 0; i < rows; i++) {
+            for(let j = 0; j < cols; j++) {
+                let sum = 0;
+                for(let ki = 0; ki < kernel.length; ki++) {
+                    for(let kj = 0; kj < kernel[0].length; kj++) {
+                        const inputRow = i * this.stride + ki;
+                        const inputCol = j * this.stride + kj;
+                        sum += input[inputRow][inputCol] * kernel[ki][kj];
+                    }
+                }
+                out[i][j] = sum;
+            }
+        }
         return out;
     }
 
-    forward(batch){
-        this.x=batch;
-        return batch.map(sample=>{
-            const channelsOut=[];
-            for(let oc=0;oc<this.outC;oc++){
-                let outChan=zeros(sample[0].length,sample[0][0].length);
-                for(let ic=0;ic<this.inC;ic++){
-                    let inputChan=sample[ic];
-                    if(this.padding>0) inputChan=this.pad2D([inputChan],this.padding)[0];
-                    const conv=this.conv2DSingle(inputChan,this.W[oc][ic]);
-                    outChan=addMatrices(outChan,conv);
+    forward(batch) {
+        this.x = batch;
+        return batch.map(sample => {
+            const channelsOut = [];
+            for(let oc = 0; oc < this.outC; oc++) {
+                let outChan = null;
+                for(let ic = 0; ic < this.inC; ic++) {
+                    let inputChan = sample[ic];
+                    if(this.padding > 0) {
+                        inputChan = this.pad2D(inputChan, this.padding);
+                    }
+                    
+                    const conv = this.conv2DSingle(inputChan, this.W[oc][ic]);
+                    
+                    if(outChan === null) {
+                        outChan = conv;
+                    } else {
+                        outChan = addMatrices(outChan, conv);
+                    }
                 }
                 channelsOut.push(outChan);
             }
@@ -170,46 +438,45 @@ export class Conv2D {
     }
 
     backward(grad) {
-    const batchSize = this.x.length;
-    const gradInput = this.x.map(sample => sample.map(chan => zeros(chan.length, chan[0].length)));
-    const gradW = this.W.map(oc => oc.map(ic => zeros(this.kernel,this.kernel)));
-
-    for (let b = 0; b < batchSize; b++) {
-        const xPadded = this.pad2D(this.x[b], this.padding);
-        const gradInputPadded = xPadded.map(chan => zeros(chan.length, chan[0].length));
-
-        for (let oc = 0; oc < this.outC; oc++) {
-            for (let ic = 0; ic < this.inC; ic++) {
-                const outGrad = grad[b][oc];
-                const inChan = xPadded[ic];
-
-                // Compute gradW
-                for (let i = 0; i < this.kernel; i++) {
-                    for (let j = 0; j < this.kernel; j++) {
-                        let sum = 0;
-                        for (let y = 0; y < outGrad.length; y++) {
-                            for (let x = 0; x < outGrad[0].length; x++) {
-                                const inY = y * this.stride + i;
-                                const inX = x * this.stride + j;
-                                if (inY < inChan.length && inX < inChan[0].length) {
-                                    sum += inChan[inY][inX] * outGrad[y][x];
+        const batchSize = this.x.length;
+        const gradW = this.W.map(oc => oc.map(ic => zeros(this.kernel, this.kernel)));
+        const gradInput = this.x.map(sample => 
+            sample.map(chan => zeros(chan.length, chan[0].length))
+        );
+
+        for (let b = 0; b < batchSize; b++) {
+            for (let oc = 0; oc < this.outC; oc++) {
+                for (let ic = 0; ic < this.inC; ic++) {
+                    const outGrad = grad[b][oc];
+                    
+                    // Compute gradW
+                    for (let i = 0; i < this.kernel; i++) {
+                        for (let j = 0; j < this.kernel; j++) {
+                            let sum = 0;
+                            for (let y = 0; y < outGrad.length; y++) {
+                                for (let x = 0; x < outGrad[0].length; x++) {
+                                    const inY = y * this.stride + i;
+                                    const inX = x * this.stride + j;
+                                    if (inY < this.x[b][ic].length && inX < this.x[b][ic][0].length) {
+                                        sum += this.x[b][ic][inY][inX] * outGrad[y][x];
+                                    }
                                 }
                             }
+                            gradW[oc][ic][i][j] += sum;
                         }
-                        gradW[oc][ic][i][j] += sum;
                     }
-                }
 
-                // Compute gradInput
-                const flippedKernel = this.W[oc][ic].map(row => [...row].reverse()).reverse();
-                for (let y = 0; y < outGrad.length; y++) {
-                    for (let x = 0; x < outGrad[0].length; x++) {
-                        for (let i = 0; i < this.kernel; i++) {
-                            for (let j = 0; j < this.kernel; j++) {
-                                const inY = y * this.stride + i;
-                                const inX = x * this.stride + j;
-                                if (inY < gradInputPadded[ic].length && inX < gradInputPadded[ic][0].length) {
-                                    gradInputPadded[ic][inY][inX] += flippedKernel[i][j] * outGrad[y][x];
+                    // Compute gradInput
+                    for (let y = 0; y < outGrad.length; y++) {
+                        for (let x = 0; x < outGrad[0].length; x++) {
+                            for (let ki = 0; ki < this.kernel; ki++) {
+                                for (let kj = 0; kj < this.kernel; kj++) {
+                                    const inY = y * this.stride + ki;
+                                    const inX = x * this.stride + kj;
+                                    if (inY < gradInput[b][ic].length && inX < gradInput[b][ic][0].length) {
+                                        gradInput[b][ic][inY][inX] += 
+                                            this.W[oc][ic][ki][kj] * outGrad[y][x];
+                                    }
                                 }
                             }
                         }
@@ -218,24 +485,18 @@ export class Conv2D {
             }
         }
 
-        // Remove padding from gradInput
-        if (this.padding > 0) {
-            for (let ic = 0; ic < this.inC; ic++) {
-                const padded = gradInputPadded[ic];
-                const cropped = padded.slice(this.padding, padded.length - this.padding)
-                    .map(row => row.slice(this.padding, row.length - this.padding));
-                gradInput[b][ic] = cropped;
-            }
-        } else {
-            for (let ic = 0; ic < this.inC; ic++) gradInput[b][ic] = gradInputPadded[ic];
-        }
+        this.gradW = gradW;
+        return gradInput;
     }
 
-    this.gradW = gradW;
-    return gradInput;
-}
-
-    parameters(){ return this.W.flatMap((w,oc)=>w.map((wc,ic)=>({param:wc,grad:this.gradW[oc][ic]}))); }
+    parameters() { 
+        return this.W.flatMap((w, oc) => 
+            w.map((wc, ic) => ({
+                param: wc, 
+                grad: this.gradW[oc][ic]
+            }))
+        ); 
+    }
 }
 
 // ---------------------- Sequential ----------------------
@@ -247,7 +508,39 @@ export class Sequential {
 }
 
 // ---------------------- Activations ----------------------
-export class ReLU{ constructor(){ this.out=null; } forward(x){ this.out=x.map(r=>r.map(v=>Math.max(0,v))); return this.out; } backward(grad){ return grad.map((r,i)=>r.map((v,j)=>v*(this.out[i][j]>0?1:0))); } }
+export class ReLU{ 
+    constructor(){ this.out=null; } 
+    
+    forward(x){ 
+        // Handle both [batch, features] and [batch, channels, height, width]
+        if (Array.isArray(x[0]) && Array.isArray(x[0][0]) && Array.isArray(x[0][0][0])) {
+            // [batch, channels, height, width]
+            this.out = x.map(batch => 
+                batch.flatMap(channel => 
+                    channel.flatMap(row => 
+                        row.map(v => Math.max(0, v))
+                    )
+                )
+            );
+        } else {
+            // [batch, features] - existing behavior
+            this.out = x.map(r => r.map(v => Math.max(0, v)));
+        }
+        return this.out; 
+    } 
+    
+    backward(grad){ 
+        // Gradient shape must match forward output shape
+        if (Array.isArray(grad[0]) && Array.isArray(grad[0][0])) {
+            // Standard [batch, features]
+            return grad.map((r, i) => r.map((v, j) => v * (this.out[i][j] > 0 ? 1 : 0)));
+        } else {
+            // return as is
+            return grad;
+        }
+    } 
+}
+
 export class Sigmoid{ constructor(){ this.out=null; } forward(x){ const fn=v=>1/(1+Math.exp(-v)); this.out=x.map(r=>r.map(fn)); return this.out; } backward(grad){ return grad.map((r,i)=>r.map((v,j)=>v*this.out[i][j]*(1-this.out[i][j]))); } }
 export class Tanh{ constructor(){ this.out=null; } forward(x){ this.out=x.map(r=>r.map(v=>Math.tanh(v))); return this.out; } backward(grad){ return grad.map((r,i)=>r.map((v,j)=>v*(1-this.out[i][j]**2))); } }
 export class LeakyReLU{ constructor(alpha=0.01){ this.alpha=alpha; this.out=null; } forward(x){ this.out=x.map(r=>r.map(v=>v>0?v:v*this.alpha)); return this.out; } backward(grad){ return grad.map((r,i)=>r.map((v,j)=>v*(this.out[i][j]>0?1:this.alpha))); } }
@@ -635,7 +928,7 @@ export function saveModel(model){
     if(!(model instanceof Sequential)) throw new Error("saveModel supports only Sequential");
     const weights=model.layers.map(layer=>({weights:layer.W||null,biases:layer.b||null}));
     return JSON.stringify(weights);
-	/* Didn't expect this to work */
+	/* Didn't expect this to work /: */
 }
 
 export function loadModel(model,json){
@@ -645,7 +938,7 @@ export function loadModel(model,json){
         if(layer.W && weights[i].weights) layer.W=weights[i].weights;
         if(layer.b && weights[i].biases) layer.b=weights[i].biases;
     });
-	/* Didn't expect this to work */
+	/* Didn't expect this to work /: */
 }
 
 // ---------------------- Advanced Utils ----------------------

package/tests/MakeModel.js

@@ -1,38 +1,36 @@
-// Example: Build and run a simple neural network model using mini-jstorch
+import { Sequential, Linear, ReLU, MSELoss, Adam, StepLR, Tanh } from '../src/jstorch.js';
 
-import { Sequential, Linear, ReLU, MSELoss, SGD, Tensor } from "../src/MainEngine.js";
-
-// Create dummy input and target data
-const input = new Tensor([[0.5, -1.0], [1.5, 2.0]]); // shape: [2,2]
-const target = new Tensor([[1.0, 0.0], [0.0, 1.0]]); // shape: [2,2]
-
-// Build a simple model: Linear -> ReLU -> Linear
 const model = new Sequential([
-    new Linear(2, 4),
+    new Linear(2, 16),
+    new Tanh(),
+    new Linear(16, 8), 
     new ReLU(),
-    new Linear(4, 2)
+    new Linear(8, 1)
 ]);
 
-const criterion = new MSELoss();
-const optimizer = new SGD(model.parameters(), 0.01);
-
-// Forward pass
-const output = model.forward(input.data);
-console.log("Model output:", output);
+const X = [[0,0], [0,1], [1,0], [1,1]];
+const y = [[0], [1], [1], [0]];
 
-// Compute loss
-const loss = criterion.forward(output, target.data);
-console.log("Loss:", loss);
-
-// Backward pass
-const grad = criterion.backward();
-model.backward(grad);
-
-// Optimizer step
-optimizer.step();
-console.log("Parameters updated!");
-
-// Run again to show change
-const output2 = model.forward(input.data);
-const loss2 = criterion.forward(output2, target.data);
-console.log("New Loss:", loss2);
+const criterion = new MSELoss();
+const optimizer = new Adam(model.parameters(), 0.1);
+const scheduler = new StepLR(optimizer, 25, 0.5); // LR * 0.5 every 25 epochs
+
+console.log("Training Progress:");
+for (let epoch = 0; epoch < 1000; epoch++) {
+    const pred = model.forward(X);
+    const loss = criterion.forward(pred, y);
+    const grad = criterion.backward();
+    model.backward(grad);
+    optimizer.step();
+    scheduler.step();
+    
+    if (epoch % 100 === 0) {
+        console.log(`Epoch ${epoch}: Loss = ${loss.toFixed(6)}, LR = ${optimizer.lr.toFixed(6)}`);
+    }
+}
+
+console.log("\nFinal Predictions:");
+const predictions = model.forward(X);
+predictions.forEach((pred, i) => {
+    console.log(`Input: ${X[i]} -> ${pred[0].toFixed(4)} (target: ${y[i][0]})`);
+});

package/tests/fu_fun.js

@@ -0,0 +1,72 @@
+
+import { 
+    fu_tensor, fu_add, fu_mul, fu_matmul, fu_sum, fu_mean, 
+    fu_relu, fu_sigmoid, fu_tanh, fu_softmax, fu_flatten, fu_reshape 
+} from '../src/jstorch.js';
+
+function testAllFuFunctions() {
+    console.log("🧪 TESTING ALL FU_FUNCTIONS\n");
+    
+    // Test 1: fu_tensor
+    console.log("1. fu_tensor");
+    const t1 = fu_tensor([[1, 2], [3, 4]]);
+    console.log("✅", t1.data);
+    
+    // Test 2: fu_add
+    console.log("\n2. fu_add");
+    const a = fu_tensor([[1, 2]]);
+    const b = fu_tensor([[3, 4]]);
+    const c = fu_add(a, b);
+    console.log("✅", a.data, "+", b.data, "=", c.data);
+    
+    // Test 3: fu_mul
+    console.log("\n3. fu_mul");
+    const d = fu_mul(a, b);
+    console.log("✅", a.data, "*", b.data, "=", d.data);
+    
+    // Test 4: fu_matmul
+    console.log("\n4. fu_matmul");
+    const e = fu_tensor([[1, 2]]);
+    const f = fu_tensor([[3], [4]]);
+    const g = fu_matmul(e, f);
+    console.log("✅ matmul =", g.data);
+    
+    // Test 5: fu_sum & fu_mean
+    console.log("\n5. fu_sum & fu_mean");
+    const h = fu_tensor([[1, 2], [3, 4]]);
+    const sum = fu_sum(h);
+    const mean = fu_mean(h);
+    console.log("✅ sum =", sum.data, "mean =", mean.data);
+    
+    // Test 6: fu_relu
+    console.log("\n6. fu_relu");
+    const i = fu_tensor([[-1, 0], [1, 2]]);
+    const relu = fu_relu(i);
+    console.log("✅ relu =", relu.data);
+    
+    // Test 7: fu_sigmoid
+    console.log("\n7. fu_sigmoid");
+    const sigmoid = fu_sigmoid(i);
+    console.log("✅ sigmoid =", sigmoid.data);
+    
+    // Test 8: fu_tanh
+    console.log("\n8. fu_tanh");
+    const tanh = fu_tanh(i);
+    console.log("✅ tanh =", tanh.data);
+    
+    // Test 9: fu_softmax
+    console.log("\n9. fu_softmax");
+    const j = fu_tensor([[1, 2, 3]]);
+    const softmax = fu_softmax(j);
+    console.log("✅ softmax =", softmax.data);
+    
+    // Test 10: fu_flatten & fu_reshape
+    console.log("\n10. fu_flatten & fu_reshape");
+    const k = fu_tensor([[1, 2], [3, 4]]);
+    const flat = fu_flatten(k);
+    const reshaped = fu_reshape(flat, 1, 4);
+    console.log("✅ flatten =", flat.data);
+    console.log("✅ reshape =", reshaped.data);
+}
+
+testAllFuFunctions();

package/tests/scheduler.js

@@ -1,6 +1,6 @@
 // Example: Test learning rate schedulers (StepLR and LambdaLR) with mini-jstorch optimizers
 
-import { SGD, StepLR, LambdaLR, Tensor } from "../src/MainEngine.js";
+import { SGD, StepLR, LambdaLR, Tensor } from "../src/jstorch.js";
 
 const param = { param: [[1, 2], [3, 4]], grad: [[0, 0], [0, 0]] };
 const optimizer = new SGD([param], 0.1);

package/src/startup.cpu

@@ -1,15 +0,0 @@
-// you can delete this files this files are not important for the engine runtime.
-
-e=run=[cpu[runtime]]
-devices=e.getdata[devices[5]]
-env.set.runtime('beta')
-env.rnt()
-env.set()
-env.register('vanilla',expe='Experiments.js',main='MainEngine.js',tgver=latest)
-resources=e.find(tag='resources')
-resources.ld(env)
-l=env.prog('asm')
-r=l.gv=[0xCAFEBABE]
-eng=env.load(register,r,'vanilla')
-eng.boot(env,r,'dp')
-eng.load(resources,runtime,devices)