mini-jstorch 1.3.0 → 1.3.2

package/MODULE.md

@@ -9,20 +9,15 @@ btw. This files is actually would be modified and note all changes system state
 ---
 
 **OFFICIAL RELEASE:** 2025-Monday-August-23 time: 2:22 AM (estimated time release)
-**VERSION:** 1.3.0
+**VERSION:** 1.3.1
 **LICENSE:** MIT © 2025
 **AUTHOR:** Rizal
 **MODULE NAME:** mini-jstorch
 **MODULE DESC:** A lightweight JavaScript neural network library for rapid frontend AI experimentation on low-resource devices Inspired by PyTorch.
 **MODULE TYPE:** module
-**ENGINE VERSIONS:** 1.2.0
-**UPDATE TITLE:** `MAJOR` update.
+**ENGINE VERSIONS:** 1.2.1
+**UPDATE TITLE:** `PATCH` update.
 **ADDED FILES/FOLDER:** {
-    "tests" //folder
-    "tests/proj1.js" //files
-    "tests/tests.js" //files [npmignore detected]
-    "tests/proj2.js" //files
-    "tests/proj3.js" //files
     "N/A" //N/A [N/A]
 }
 

package/README.md

@@ -1,27 +1,16 @@
-# Mini-JSTorch Major Update
+# Mini-JSTorch
 
-# MAJOR UPDATE IS RELEASED NOW!! [got little late] 
-
----
-
-## 🙏 Big Thanks 🙏
-I genuinely appreciate everyone who has taken the time to install and try out this module. Every download isn’t just a number it’s a real person spending their time to explore, learn, or build something with this module!
-
-Reaching 400+ weekly downloads might sound small compared to giant frameworks, but for me it’s huge. It means this project is actually helping people out there, and that alone makes every late-night coding session worth it.
-
-Thank you for giving this module a chance. Your support and trust are what keep this project moving forward! 🚀
-
----
+A lightweight JavaScript neural network library for rapid frontend AI experimentation on low-resource devices Inspired by PyTorch.
 
 ## Overview
 
 Mini-JSTorch is a lightweight, high-performance JavaScript library for building neural networks that runs efficiently in both frontend and backend environments, including low-end devices. The library enables experimentation and learning in AI without compromising stability, accuracy, or training reliability.
 
-This release, **version 1.2.3**, is a **major update** that introduces full feature coverage, including convolutional layers, advanced activations, dropout, tensor broadcasting, and enhanced utilities. The engine remains pure JavaScript, lightweight, and compatible with both Node.js and browser environments.
+This release, **version 1.2.3**, is a just some fix a typo and delete not used files.
 
 ---
 
-## Major Updates in 1.2.3
+## Features Overview
 
 - Full **Conv2D support** with forward and backward operations.
 - **Tensor operations** now support broadcasting and reshaping.
@@ -133,4 +122,5 @@ loadModel(model2, json);
 - **This module is implemented entirely in pure JavaScript.**
 - **The `Dummy` folder contains modules used for development, testing, and debugging before integration into the main engine.**
 - **files startup.cpu is actually an some random files lol.**
-- **This module was created by a `single` developer.**
+- **This module was created by a `single` developer.**
+- **You can join to the `mjs-group` Organization on my profile!**

package/hh.js

@@ -0,0 +1,38 @@
+import { Sequential, Linear, ReLU, Sigmoid, CrossEntropyLoss, Adam } from './src/MainEngine.js';
+
+// Build model
+const model = new Sequential([
+  new Linear(2,4),
+  new ReLU(),
+  new Linear(4,2),
+  new Sigmoid()
+]);
+
+// Sample XOR dataset
+const X = [
+  [0,0], [0,1], [1,0], [1,1]
+];
+const Y = [
+  [1,0], [0,1], [0,1], [1,0]
+];
+
+// Loss & optimizer
+const lossFn = new CrossEntropyLoss();
+const optimizer = new Adam(model.parameters(), 0.1);
+
+// Training loop
+for (let epoch = 1; epoch <= 500; epoch++) {
+  const pred = model.forward(X);
+  const loss = lossFn.forward(pred, Y);
+  const gradLoss = lossFn.backward();
+  model.backward(gradLoss);
+  optimizer.step();
+  if (epoch % 20 === 0) console.log(`Epoch ${epoch}, Loss: ${loss.toFixed(4)}`);
+}
+
+// Prediction
+const predTest = model.forward(X);
+predTest.forEach((p,i) => {
+  const predictedClass = p.indexOf(Math.max(...p));
+  console.log(`Input: ${X[i]}, Predicted class: ${predictedClass}, Raw output: ${p.map(v => v.toFixed(3))}`);
+});

package/index.js

@@ -1,6 +1,90 @@
-// Entry point of the library, export main classes and functions [DEPRECATED]
-export { Seq } from './models/seq.js';
-export { Dense } from './layers/dense.js';
-export * as act from './act/linear.js';
-export { SGD } from './optim/sgd.js';
-export { train } from './train/loop.js';
+// =====================================================
+// FILE: index.js - Main entry point
+// =====================================================
+
+// Import all modules
+import { Tensor } from './src/tensor.js';
+import { 
+    Linear, Dense, Conv2d, MaxPool2d, AvgPool2d, Flatten, Dropout, 
+    BatchNorm2d, ReLU, Sigmoid, Tanh, LeakyReLU, ELU, Softmax, Sequential 
+} from './src/layers.js';
+import { MSELoss, CrossEntropyLoss, BCELoss } from './src/loss.js';
+import { SGD, Adam, RMSprop } from './src/optimizers.js';
+import { Model, Trainer, models, optimizers, losses, layers, tensors, utils } from './src/model.js';
+
+// Export everything
+export {
+    // Core classes
+    Tensor,
+    Model,
+    Trainer,
+    
+    // Layer classes
+    Linear,
+    Dense,
+    Conv2d,
+    MaxPool2d,
+    AvgPool2d,
+    Flatten,
+    Dropout,
+    BatchNorm2d,
+    ReLU,
+    Sigmoid,
+    Tanh,
+    LeakyReLU,
+    ELU,
+    Softmax,
+    Sequential,
+    
+    // Loss classes
+    MSELoss,
+    CrossEntropyLoss,
+    BCELoss,
+    
+    // Optimizer classes
+    SGD,
+    Adam,
+    RMSprop,
+    
+    // Factory functions
+    models,
+    optimizers,
+    losses,
+    layers,
+    tensors,
+    utils
+};
+
+// Default export
+export default {
+    Tensor,
+    Model,
+    Trainer,
+    Linear,
+    Dense,
+    Conv2d,
+    MaxPool2d,
+    AvgPool2d,
+    Flatten,
+    Dropout,
+    BatchNorm2d,
+    ReLU,
+    Sigmoid,
+    Tanh,
+    LeakyReLU,
+    ELU,
+    Softmax,
+    Sequential,
+    MSELoss,
+    CrossEntropyLoss,
+    BCELoss,
+    SGD,
+    Adam,
+    RMSprop,
+    models,
+    optimizers,
+    losses,
+    layers,
+    tensors,
+    utils
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-jstorch",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "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

@@ -1,5 +1,8 @@
-// MINI JSTORCH ENGINE - MAJOR ULTRA OPTIMIZED 1.2.3
+
+// MINI JSTORCH ENGINE
 // LICENSE: MIT (C) Rizal 2025
+// 1.2.3 ENGINE VERSIONS
+// IMPORTANT: CORE ENGINE DO NOT EDIT THIS FILES VERY SENSITIVE IT WILL CRASHING YOUR ENGINE SYSTEMS!
 
 // ---------------------- Utilities ----------------------
 function zeros(rows, cols) { return Array.from({length:rows},()=>Array(cols).fill(0)); }
@@ -222,8 +225,310 @@ export class Adam{
     }
 }
 
+// ---------------------- 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");
@@ -252,4 +557,4 @@ export function reshape(tensor, rows, cols) {
         flat.slice(i*cols, i*cols + cols)
     );
     return out;
-}
+}

package/src/startup.cpu

@@ -1,12 +1,15 @@
 // you can delete this files this files are not important for the engine runtime.
 
 e=run=[cpu[runtime]]
-e.set.runtime('beta')
-e.rnt()
-e.set()
-e.register('vanilla',expe='Experiments.js',main='MainEngine.js')
-l=e.prog('asm')
+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=e.load(register,r,'vanilla')
-eng.boot(e,r,'dp')
-eng.load()
+eng=env.load(register,r,'vanilla')
+eng.boot(env,r,'dp')
+eng.load(resources,runtime,devices)

package/tests/DebugModel.js

@@ -0,0 +1,127 @@
+// src/Dummy/debug_train.js
+import { 
+    Tensor,
+    Linear,
+    Sequential,
+    ReLU,
+    Sigmoid,
+    CrossEntropyLoss,
+    Adam,
+    MathOps
+} from '../src/Dummy/exp.js';
+
+// ---------------------- Simple Debug Data ----------------------
+function generateSimpleData() {
+    // VERY simple data: 4 points in 2D
+    const X = [
+        [0, 0],
+        [0, 1], 
+        [1, 0],
+        [1, 1]
+    ];
+    
+    const y = [
+        [0], // AND operation
+        [0],
+        [0], 
+        [1]
+    ];
+    
+    return { X, y };
+}
+
+// ---------------------- Debug Model ----------------------
+function createDebugModel() {
+    return new Sequential([
+        new Linear(2, 2),  // Small layer
+        new ReLU(),
+        new Linear(2, 1),  // Output layer
+        new Sigmoid()
+    ]);
+}
+
+// ---------------------- Debug Training ----------------------
+function debugTraining() {
+    console.log("🔍 DEBUG TRAINING STARTED");
+    console.log("=========================");
+    
+    const data = generateSimpleData();
+    const model = createDebugModel();
+    const lossFunction = new CrossEntropyLoss();
+    const parameters = model.parameters();
+    
+    console.log("Model parameters:", parameters.length);
+    console.log("Data samples:", data.X.length);
+    
+    // Single step debug
+    for (let step = 0; step < 10; step++) {
+        console.log(`\n--- Step ${step} ---`);
+        
+        // Forward pass
+        const predictions = model.forward(data.X);
+        console.log("Predictions:", predictions.map(p => p[0].toFixed(3)));
+        
+        const loss = lossFunction.forward(predictions, data.y);
+        console.log("Loss:", loss);
+        
+        if (isNaN(loss)) {
+            console.log("❌ NaN LOSS DETECTED!");
+            console.log("Predictions:", predictions);
+            console.log("Targets:", data.y);
+            break;
+        }
+        
+        // Backward pass
+        const grad = lossFunction.backward();
+        console.log("Gradient:", grad.map(g => g[0].toFixed(3)));
+        
+        model.backward(grad);
+        
+        // Check gradients
+        console.log("Parameter gradients:");
+        parameters.forEach((param, idx) => {
+            if (Array.isArray(param.grad[0])) {
+                console.log(`  Param ${idx} grad:`, param.grad.map(row => 
+                    row.map(v => v.toFixed(3))
+                ));
+            } else {
+                console.log(`  Param ${idx} grad:`, param.grad.map(v => v.toFixed(3)));
+            }
+        });
+        
+        // Update weights
+        const optimizer = new Adam(parameters, 0.1);
+        optimizer.step();
+        
+        // Reset gradients manually
+        parameters.forEach(param => {
+            if (Array.isArray(param.grad[0])) {
+                for (let i = 0; i < param.grad.length; i++) {
+                    for (let j = 0; j < param.grad[0].length; j++) {
+                        param.grad[i][j] = 0;
+                    }
+                }
+            } else {
+                for (let i = 0; i < param.grad.length; i++) {
+                    param.grad[i] = 0;
+                }
+            }
+        });
+        
+        // Calculate accuracy
+        const accuracy = calculateAccuracy(predictions, data.y);
+        console.log("Accuracy:", (accuracy * 100).toFixed(1) + "%");
+    }
+}
+
+function calculateAccuracy(predictions, targets) {
+    let correct = 0;
+    for (let i = 0; i < predictions.length; i++) {
+        const predLabel = predictions[i][0] > 0.5 ? 1 : 0;
+        if (predLabel === targets[i][0]) correct++;
+    }
+    return correct / predictions.length;
+}
+
+// Run debug
+debugTraining();