mini-jstorch 1.4.5 → 1.6.0

package/src/MainEngine.js

@@ -1,663 +0,0 @@
-/*!
- * Project: mini-jstorch
- * File: MainEngine.js
- * Author: M. Rizal H. (Actual Author Name)
- * License: MIT
- * Copyright (C) 2025 M. Rizal H.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-
-// ---------------------- Utilities ----------------------
-export function zeros(rows, cols) { 
-    return Array.from({length:rows},()=>Array(cols).fill(0)); 
-}
-
-export function ones(rows, cols) { 
-    return Array.from({length:rows},()=>Array(cols).fill(1)); 
-}
-
-export function randomMatrix(rows, cols, scale=0.1){ 
-    return Array.from({length:rows},()=>
-        Array.from({length:cols},()=> (Math.random()*2-1)*scale)
-    ); 
-}
-
-export function transpose(matrix){ 
-    return matrix[0].map((_,i)=>matrix.map(row=>row[i])); 
-}
-
-export function addMatrices(a,b){ 
-    return a.map((row,i)=>
-        row.map((v,j)=>v+(b[i] && b[i][j]!==undefined?b[i][j]:0))
-    ); 
-}
-
-export function dot(a,b){ 
-    const res=zeros(a.length,b[0].length); 
-    for(let i=0;i<a.length;i++) 
-        for(let j=0;j<b[0].length;j++) 
-            for(let k=0;k<a[0].length;k++) 
-                res[i][j]+=a[i][k]*b[k][j]; 
-    return res; 
-}
-
-export function softmax(x){ 
-    const m=Math.max(...x); 
-    const exps=x.map(v=>Math.exp(v-m)); 
-    const s=exps.reduce((a,b)=>a+b,0); 
-    return exps.map(v=>v/s); 
-}
-
-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. */ 
-
-// ---------------------- Tensor ----------------------
-export class Tensor {
-    constructor(data){ this.data=data; this.grad=zeros(data.length,data[0].length); }
-    shape(){ return [this.data.length,this.data[0].length]; }
-    add(t){ return t instanceof Tensor?this.data.map((r,i)=>r.map((v,j)=>v+t.data[i][j])):this.data.map(r=>r.map(v=>v+t)); }
-    sub(t){ return t instanceof Tensor?this.data.map((r,i)=>r.map((v,j)=>v-t.data[i][j])):this.data.map(r=>r.map(v=>v-t)); }
-    mul(t){ return t instanceof Tensor?this.data.map((r,i)=>r.map((v,j)=>v*t.data[i][j])):this.data.map(r=>r.map(v=>v*t)); }
-    matmul(t){ if(t instanceof Tensor) return dot(this.data,t.data); else throw new Error("matmul requires Tensor"); }
-    transpose(){ return transpose(this.data); }
-    flatten(){ return this.data.flat(); }
-    static zeros(r,c){ return new Tensor(zeros(r,c)); }
-    static ones(r,c){ return new Tensor(ones(r,c)); }
-    static random(r,c,scale=0.1){ return new Tensor(randomMatrix(r,c,scale)); }
-}
-
-// ---------------------- Layers ----------------------
-export class Linear {
-    constructor(inputDim,outputDim){
-        this.W=randomMatrix(inputDim,outputDim);
-        this.b=Array(outputDim).fill(0);
-        this.gradW=zeros(inputDim,outputDim);
-        this.gradb=Array(outputDim).fill(0);
-        this.x=null;
-    }
-
-    forward(x){
-        this.x=x;
-        const out=dot(x,this.W);
-        return out.map((row,i)=>row.map((v,j)=>v+this.b[j]));
-    }
-
-    backward(grad){
-        for(let i=0;i<this.W.length;i++) for(let j=0;j<this.W[0].length;j++)
-            this.gradW[i][j]=this.x.reduce((sum,row,k)=>sum+row[i]*grad[k][j],0);
-        for(let j=0;j<this.b.length;j++)
-            this.gradb[j]=grad.reduce((sum,row)=>sum+row[j],0);
-
-        const gradInput=zeros(this.x.length,this.W.length);
-        for(let i=0;i<this.x.length;i++)
-            for(let j=0;j<this.W.length;j++)
-                for(let k=0;k<this.W[0].length;k++)
-                    gradInput[i][j]+=grad[i][k]*this.W[j][k];
-        return gradInput;
-    }
-
-    parameters(){ return [ {param:this.W,grad:this.gradW}, {param:[this.b],grad:[this.gradb]} ]; }
-}
-
-// ---------------------- 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;
-    }
-
-    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;
-        });
-    }
-
-    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];
-        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);
-                }
-                channelsOut.push(outChan);
-            }
-            return channelsOut;
-        });
-    }
-
-    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];
-                                }
-                            }
-                        }
-                        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];
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // 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;
-}
-
-    parameters(){ return this.W.flatMap((w,oc)=>w.map((wc,ic)=>({param:wc,grad:this.gradW[oc][ic]}))); }
-}
-
-// ---------------------- Sequential ----------------------
-export class Sequential {
-    constructor(layers=[]){ this.layers=layers; }
-    forward(x){ return this.layers.reduce((acc,l)=>l.forward(acc), x); }
-    backward(grad){ return this.layers.reduceRight((g,l)=>l.backward(g), grad); }
-    parameters(){ return this.layers.flatMap(l=>l.parameters?l.parameters():[]); }
-}
-
-// ---------------------- 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 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))); } }
-export class GELU{ constructor(){ this.out=null; } forward(x){ const fn=v=>0.5*v*(1+Math.tanh(Math.sqrt(2/Math.PI)*(v+0.044715*v**3))); this.out=x.map(r=>r.map(fn)); return this.out; } backward(grad){ return grad.map((r,i)=>r.map(v=>v*1)); } }
-
-// ---------------------- Dropout ----------------------
-export class Dropout{ constructor(p=0.5){ this.p=p; } forward(x){ return x.map(r=>r.map(v=>v*Math.random()>=this.p?v:0)); } backward(grad){ return grad.map(r=>r.map(v=>v*(1-this.p))); } }
-
-// ---------------------- Losses ----------------------
-export class MSELoss{ forward(pred,target){ this.pred=pred; this.target=target; const losses=pred.map((row,i)=>row.reduce((sum,v,j)=>sum+(v-target[i][j])**2,0)/row.length); return losses.reduce((a,b)=>a+b,0)/pred.length; } backward(){ return this.pred.map((row,i)=>row.map((v,j)=>2*(v-this.target[i][j])/row.length)); } }
-export class CrossEntropyLoss{ forward(pred,target){ this.pred=pred; this.target=target; const losses=pred.map((p,i)=>crossEntropy(softmax(p),target[i])); return losses.reduce((a,b)=>a+b,0)/pred.length; } backward(){ return this.pred.map((p,i)=>{ const s=softmax(p); return s.map((v,j)=>(v-this.target[i][j])/this.pred.length); }); } }
-
-// ---------------------- Optimizers ----------------------
-export class Adam{
-    constructor(params,lr=0.001,b1=0.9,b2=0.999,eps=1e-8){
-        this.params=params; this.lr=lr; this.beta1=b1; this.beta2=b2; this.eps=eps;
-        this.m=params.map(p=>zeros(p.param.length,p.param[0].length||1));
-        this.v=params.map(p=>zeros(p.param.length,p.param[0].length||1));
-        this.t=0;
-    }
-    step(){
-        this.t++;
-        this.params.forEach((p,idx)=>{
-            for(let i=0;i<p.param.length;i++)
-                for(let j=0;j<(p.param[0].length||1);j++){
-                    const g=p.grad[i][j];
-                    this.m[idx][i][j]=this.beta1*this.m[idx][i][j]+(1-this.beta1)*g;
-                    this.v[idx][i][j]=this.beta2*this.v[idx][i][j]+(1-this.beta2)*g*g;
-                    const mHat=this.m[idx][i][j]/(1-Math.pow(this.beta1,this.t));
-                    const vHat=this.v[idx][i][j]/(1-Math.pow(this.beta2,this.t));
-                    p.param[i][j]-=this.lr*mHat/(Math.sqrt(vHat)+this.eps);
-                }
-        });
-    }
-}
-
-// ---------------------- Learning Rate Schedulers ----------------------
-export class StepLR {
-    constructor(optimizer, step_size, gamma=1.0) {
-        this.optimizer = optimizer;
-        this.step_size = step_size;
-        this.gamma = gamma;
-        this.last_epoch = 0;
-        this.base_lr = optimizer.lr;
-    }
-
-    step() {
-        this.last_epoch += 1;
-        if (this.last_epoch % this.step_size === 0) {
-            this.optimizer.lr *= this.gamma;
-        }
-    }
-
-    get_lr() {
-        return this.optimizer.lr;
-		/* Do nothing else */
-    }
-}
-
-export class LambdaLR {
-    constructor(optimizer, lr_lambda) {
-        this.optimizer = optimizer;
-        this.lr_lambda = lr_lambda;
-        this.last_epoch = 0;
-        this.base_lr = optimizer.lr;
-    }
-
-    step() {
-        this.last_epoch += 1;
-        this.optimizer.lr = this.base_lr * this.lr_lambda(this.last_epoch);
-    }
-
-    get_lr() {
-        return this.optimizer.lr;
-		/* Do nothing else */
-    }
-}
-
-// ---------------------- ELU Activation ----------------------
-export class ELU {
-    constructor(alpha=1.0) {
-        this.alpha = alpha;
-        this.out = null;
-    }
-
-    forward(x) {
-        this.out = x.map(row => 
-            row.map(v => v > 0 ? v : this.alpha * (Math.exp(v) - 1))
-        );
-        return this.out;
-    }
-
-    backward(grad) {
-        return grad.map((row, i) => 
-            row.map((v, j) => 
-                v * (this.out[i][j] > 0 ? 1 : this.alpha * Math.exp(this.out[i][j]))
-            )
-        );
-    }
-}
-
-// ---------------------- Mish Activation ----------------------
-export class Mish {
-    constructor() {
-        this.x = null;
-    }
-
-    forward(x) {
-        this.x = x;
-        return x.map(row => 
-            row.map(v => {
-                // Mish(x) = x * tanh(softplus(x)) = x * tanh(ln(1 + e^x))
-                const softplus = Math.log(1 + Math.exp(v));
-                return v * Math.tanh(softplus);
-            })
-        );
-    }
-
-    backward(grad) {
-        return grad.map((row, i) => 
-            row.map((v, j) => {
-                const x_val = this.x[i][j];
-                
-                // Gradient of Mish: 
-                // δ = ω * (4(x+1) + 4e^2x + e^3x + e^x(4x+6)) / (2e^x + e^2x + 2)^2
-                // where ω = sech^2(softplus(x))
-                
-                const exp_x = Math.exp(x_val);
-                const exp_2x = Math.exp(2 * x_val);
-                const exp_3x = Math.exp(3 * x_val);
-                const softplus = Math.log(1 + exp_x);
-                
-                const sech_softplus = 1 / Math.cosh(softplus);
-                const numerator = 4 * (x_val + 1) + 4 * exp_2x + exp_3x + exp_x * (4 * x_val + 6);
-                const denominator = Math.pow(2 * exp_x + exp_2x + 2, 2);
-                
-                const mish_grad = (sech_softplus * sech_softplus) * (numerator / denominator);
-                return v * mish_grad;
-            })
-        );
-    }
-}
-
-// ---------------------- SiLU Activation ----------------------
-export class SiLU {
-    constructor() {
-        this.x = null;
-    }
-
-    forward(x) {
-        this.x = x;
-        return x.map(row => 
-            row.map(v => v / (1 + Math.exp(-v)))  // x * sigmoid(x)
-        );
-    }
-
-    backward(grad) {
-        return grad.map((row, i) => 
-            row.map((v, j) => {
-                const x_val = this.x[i][j];
-                const sigmoid = 1 / (1 + Math.exp(-x_val));
-                return v * (sigmoid * (1 + x_val * (1 - sigmoid)));
-            })
-        );
-    }
-}
-
-export class SGD{ constructor(params,lr=0.01){ this.params=params; this.lr=lr; } step(){ this.params.forEach(p=>{ for(let i=0;i<p.param.length;i++) for(let j=0;j<(p.param[0].length||1);j++) p.param[i][j]-=this.lr*p.grad[i][j]; }); } }
-
-// ---------------------- BatchNorm2D ----------------------
-export class BatchNorm2d {
-    constructor(numFeatures, eps=1e-5, momentum=0.1, affine=true) {
-        this.numFeatures = numFeatures;
-        this.eps = eps;
-        this.momentum = momentum;
-        this.affine = affine;
-        
-        // Parameters
-        if (affine) {
-            this.weight = Array(numFeatures).fill(1);
-            this.bias = Array(numFeatures).fill(0);
-            this.gradWeight = Array(numFeatures).fill(0);
-            this.gradBias = Array(numFeatures).fill(0);
-        }
-        
-        // Running statistics
-        this.runningMean = Array(numFeatures).fill(0);
-        this.runningVar = Array(numFeatures).fill(1);
-        
-        // Training state
-        this.training = true;
-        this.x = null;
-        this.xCentered = null;
-        this.std = null;
-    }
-
-    forward(x) {
-        // x shape: [batch, channels, height, width]
-        this.x = x;
-        const batchSize = x.length;
-        const channels = x[0].length;
-        
-        if (this.training) {
-            // Calculate mean per channel
-            const means = Array(channels).fill(0);
-            for (let b = 0; b < batchSize; b++) {
-                for (let c = 0; c < channels; c++) {
-                    const channelData = x[b][c];
-                    let sum = 0;
-                    for (let i = 0; i < channelData.length; i++) {
-                        for (let j = 0; j < channelData[0].length; j++) {
-                            sum += channelData[i][j];
-                        }
-                    }
-                    means[c] += sum / (channelData.length * channelData[0].length);
-                }
-            }
-            means.forEach((_, c) => means[c] /= batchSize);
-            
-            // Calculate variance per channel
-            const variances = Array(channels).fill(0);
-            for (let b = 0; b < batchSize; b++) {
-                for (let c = 0; c < channels; c++) {
-                    const channelData = x[b][c];
-                    let sum = 0;
-                    for (let i = 0; i < channelData.length; i++) {
-                        for (let j = 0; j < channelData[0].length; j++) {
-                            sum += Math.pow(channelData[i][j] - means[c], 2);
-                        }
-                    }
-                    variances[c] += sum / (channelData.length * channelData[0].length);
-                }
-            }
-            variances.forEach((_, c) => variances[c] /= batchSize);
-            
-            // Update running statistics
-            for (let c = 0; c < channels; c++) {
-                this.runningMean[c] = this.momentum * means[c] + (1 - this.momentum) * this.runningMean[c];
-                this.runningVar[c] = this.momentum * variances[c] + (1 - this.momentum) * this.runningVar[c];
-            }
-            
-            // Normalize
-            this.xCentered = [];
-            this.std = Array(channels).fill(0).map(() => []);
-            
-            const output = [];
-            for (let b = 0; b < batchSize; b++) {
-                const batchOut = [];
-                for (let c = 0; c < channels; c++) {
-                    const channelData = x[b][c];
-                    const channelOut = zeros(channelData.length, channelData[0].length);
-                    const channelCentered = zeros(channelData.length, channelData[0].length);
-                    const channelStd = Math.sqrt(variances[c] + this.eps);
-                    this.std[c].push(channelStd);
-                    
-                    for (let i = 0; i < channelData.length; i++) {
-                        for (let j = 0; j < channelData[0].length; j++) {
-                            channelCentered[i][j] = channelData[i][j] - means[c];
-                            channelOut[i][j] = channelCentered[i][j] / channelStd;
-                            
-                            // Apply affine transformation if enabled
-                            if (this.affine) {
-                                channelOut[i][j] = channelOut[i][j] * this.weight[c] + this.bias[c];
-                            }
-                        }
-                    }
-                    
-                    batchOut.push(channelOut);
-                    if (b === 0) this.xCentered.push(channelCentered);
-                    else this.xCentered[c] = addMatrices(this.xCentered[c], channelCentered);
-                }
-                output.push(batchOut);
-            }
-            
-            return output;
-        } else {
-            // Inference mode - use running statistics
-            const output = [];
-            for (let b = 0; b < batchSize; b++) {
-                const batchOut = [];
-                for (let c = 0; c < channels; c++) {
-                    const channelData = x[b][c];
-                    const channelOut = zeros(channelData.length, channelData[0].length);
-                    const channelStd = Math.sqrt(this.runningVar[c] + this.eps);
-                    
-                    for (let i = 0; i < channelData.length; i++) {
-                        for (let j = 0; j < channelData[0].length; j++) {
-                            channelOut[i][j] = (channelData[i][j] - this.runningMean[c]) / channelStd;
-                            
-                            // Apply affine transformation if enabled
-                            if (this.affine) {
-                                channelOut[i][j] = channelOut[i][j] * this.weight[c] + this.bias[c];
-                            }
-                        }
-                    }
-                    
-                    batchOut.push(channelOut);
-                }
-                output.push(batchOut);
-            }
-            
-            return output;
-        }
-    }
-
-    backward(gradOutput) {
-        if (!this.training) {
-            throw new Error("Backward should only be called in training mode");
-        }
-        
-        const batchSize = gradOutput.length;
-        const channels = gradOutput[0].length;
-        
-        // Initialize gradients
-        const gradInput = this.x.map(batch => 
-            batch.map(channel => 
-                zeros(channel.length, channel[0].length)
-            )
-        );
-        
-        if (this.affine) {
-            this.gradWeight.fill(0);
-            this.gradBias.fill(0);
-        }
-        
-        for (let c = 0; c < channels; c++) {
-            let sumGradWeight = 0;
-            let sumGradBias = 0;
-            
-            for (let b = 0; b < batchSize; b++) {
-                const channelGrad = gradOutput[b][c];
-                const channelData = this.x[b][c];
-                
-                // Calculate gradients for bias and weight
-                if (this.affine) {
-                    for (let i = 0; i < channelGrad.length; i++) {
-                        for (let j = 0; j < channelGrad[0].length; j++) {
-                            sumGradBias += channelGrad[i][j];
-                            sumGradWeight += channelGrad[i][j] * (this.xCentered[c][i][j] / this.std[c][b]);
-                        }
-                    }
-                }
-                
-                // Calculate gradient for input
-                const n = channelData.length * channelData[0].length;
-                const stdInv = 1 / this.std[c][b];
-                
-                for (let i = 0; i < channelGrad.length; i++) {
-                    for (let j = 0; j < channelGrad[0].length; j++) {
-                        let grad = channelGrad[i][j];
-                        
-                        if (this.affine) {
-                            grad *= this.weight[c];
-                        }
-                        
-                        grad *= stdInv;
-                        gradInput[b][c][i][j] = grad;
-                    }
-                }
-            }
-            
-            if (this.affine) {
-                this.gradWeight[c] = sumGradWeight / batchSize;
-                this.gradBias[c] = sumGradBias / batchSize;
-            }
-        }
-        
-        return gradInput;
-    }
-
-    parameters() {
-        if (!this.affine) return [];
-        return [
-            { param: [this.weight], grad: [this.gradWeight] },
-            { param: [this.bias], grad: [this.gradBias] }
-        ];
-    }
-
-    train() { this.training = true; }
-    eval() { this.training = false; }
-}
-
-// ---------------------- Model Save/Load ----------------------
-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 */
-}
-
-export function loadModel(model,json){
-    if(!(model instanceof Sequential)) throw new Error("loadModel supports only Sequential");
-    const weights=JSON.parse(json);
-    model.layers.forEach((layer,i)=>{
-        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 */
-}
-
-// ---------------------- Advanced Utils ----------------------
-export function flattenBatch(batch){ return batch.flat(2); }
-export function stack(tensors){ return tensors.map(t=>t.data); }
-export function eye(n){ return Array.from({length:n},(_,i)=>Array.from({length:n},(_,j)=>i===j?1:0)); }
-export function concat(a,b,axis=0){ /* concat along axis */ if(axis===0) return [...a,...b]; if(axis===1) return a.map((row,i)=>[...row,...b[i]]); }
-export function reshape(tensor, rows, cols) {
-    let flat = tensor.data.flat(); // flatten first
-    if(flat.length < rows*cols) throw new Error("reshape size mismatch");
-    const out = Array.from({length: rows}, (_, i) =>
-        flat.slice(i*cols, i*cols + cols)
-    );
-    return out;
-}

package/tests/MakeModel.js

@@ -1,38 +0,0 @@
-// Example: Build and run a simple neural network model using mini-jstorch
-
-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 ReLU(),
-    new Linear(4, 2)
-]);
-
-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);
-
-// 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);