mini-jstorch 1.2.0 → 1.2.2

package/README.md

@@ -1,133 +1,17 @@
-## Mini-JSTorch ##
-
-## SORRY GUYS FOR THE DISTURB BECAUSE VERSION 1.1.9 I FORGOT PLACE THE FULL SYSTEM FOR THE UPDATE NOT PLACED ON MAINENGINE BUT AT EXPERIMENTS FILES 
-
-# IMPORTANT!
-
-This Module will not gonna Run *Well* In at GPU or a Backend.
-We're will gonna *Optimize* So all User can still use this Module.
-
----
-
-**Mini JSTorch** is a lightweight, high-performance JavaScript library designed for rapid prototyping of neural networks directly in the frontend environment and for low-end devices. Its core purpose is to enable experimentation and learning on devices with limited computing resources, without compromising stability or training reliability.
-
----
-
-## Vision
-
-Our vision is to democratize AI experimentation by providing a tool that is:
-
-- **Accessible**: Runs efficiently on *low-end* laptops or mobile devices.
-- **Stable**: Handles gradient calculations and NaN values robustly.
-- **Educational**: Clear abstractions for neural network layers, activations, and optimizers.
-- **Fast**: Immediate output without lengthy training delays.
-
-*Mini JSTorch* aims to bridge the gap between conceptual AI learning and hands-on experimentation, making it possible to explore neural network behavior interactively, even on minimal hardware.
+# MINI JSTORCH #
 
 ---
 
-## Features
 
-- **Core Layers**
-  - `Linear`: Fully connected layer with weight and bias support.
-- **Activations**
-  - `ReLU`: Rectified Linear Unit activation.
-  - `Sigmoid`: Sigmoid activation function.
-- **Loss Functions**
-  - `CrossEntropyLoss`: Combines softmax and cross-entropy for classification tasks.
-- **Optimizers**
-  - `Adam`: Adaptive optimizer for stable and efficient training.
-- **Utilities**
-  - `zeros(rows, cols)`: Generate a zero matrix.
-  - `randomMatrix(rows, cols, scale)`: Random initialization for weights.
-  - `softmax(x)`: Compute softmax probabilities.
-  - `crossEntropy(pred, target)`: Compute cross-entropy loss.
-  - `dot(a, b)`: Matrix multiplication.
-  - `addMatrices(a, b)`: Element-wise addition of matrices.
-- **Model Container**
-  - `Sequential`: Container to stack layers sequentially with easy forward and backward passes.
+**Just Empty.. this versions only an note do not use it for your projects models.**
+**I ONLY WANNA GIVE A MESSAGES IF THE MAJOR UPDATE WOULD BE COMING AT TIME 2:22 AM JUST BE READY FOR IT GUYS!**
 
----
-
-## Installation
+# HUGE THANKS 🎉 #
 
-```bash
-npm install mini-jstorch
-# Node.js v20+ recommended for a good experience while using module
-```
-
----
+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!
 
-## Example Scripts
-
-```javascript
-import { Sequential, Linear, ReLU, Sigmoid, CrossEntropy, Adam } from './engine/MainEngine.js'; // use import to import the modules
-
-// Construct a model with two hidden layers
-const model = new Sequential([
-    new Linear(2, 4),
-    new ReLU(),
-    new Linear(4, 4),
-    new ReLU(),
-    new Linear(4, 2),
-    new Sigmoid()
-]);
-
-// Training data (XOR)
-const inputs = [
-    [0,0], [0,1], [1,0], [1,1]
-];
-const targets = [
-    [1,0], [0,1], [0,1], [1,0]
-];
-
-// Optimizer and loss
-const optimizer = new Adam(model.parameters(), 0.01);
-const lossFunc = CrossEntropy;
-
-// Training loop
-for(let epoch = 1; epoch <= 5000; epoch++) {
-    let totalLoss = 0;
-    for(let i = 0; i < inputs.length; i++) {
-        const output = model.forward([inputs[i]]);
-        const loss = lossFunc(output, [targets[i]]);
-        totalLoss += loss;
-        model.zeroGrad();
-        model.backward(lossFunc.backward());
-        optimizer.step();
-    }
-    if(epoch % 500 === 0) console.log(`Epoch ${epoch}, Loss: ${totalLoss.toFixed(6)}`);
-}
-
-// Predictions
-inputs.forEach(inp => {
-    const pred = model.forward([inp]);
-    console.log(`${inp} -> ${pred.map(p => p.toFixed(4))}`);
-});
-```
----
-
-## Intended Use Cases
-
-- **Experimentation on low-end devices or mobile browsers.**
-- **Learning and teaching foundational neural network concepts.**
-- **Testing small to medium feedforward models in real-time.**
-- **Quick prototyping without GPU dependency or complex setup.**
-
----
-
-## Roadmap
-
-- **Browser-based interactive playground.**
-- **Additional activation functions and loss options.**
-- **Visualization of training metrics and loss curves in real-time.**
-- **Support for small convolutional networks in frontend environments.**
-
----
+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.
 
-## Facts
+Thank you for giving this module a chance. Your support and trust are what keep this project moving forward! 🚀
 
-- **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.**
-- **This module was created by a `single` developer.**
-- **Date 23 Would be `CRAZY`.**
+# BE READY FOR IT... SET YOUR TIME CLOCK. #

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-jstorch",
-  "version": "1.2.0",
+  "version": "1.2.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/{engine → src}/Dummy/msg

@@ -1,5 +1,5 @@
 **File Unavailable**
-This file has been restricted by the developer.
+file inside this folder has been restricted by the developer.
 
 It is intended solely for experimental purposes in future versions, including optimizations and bug fixes before full integration into the Main Engine.
 

package/src/MainEngine.js

@@ -0,0 +1 @@
+console.log("MAJOR UPDATE IN 2:22 AM BE READY GUYS! this was empty because this versions only for an major note.")

package/src/startup.cpu

@@ -0,0 +1,12 @@
+// 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')
+r=l.gv=[0xCAFEBABE]
+eng=e.load(register,r,'vanilla')
+eng.boot(e,r,'dp')
+eng.load()

package/CHANGELOG.md

@@ -1,32 +0,0 @@
-## Changelog ##
-
-**Official Release:** 2025-Monday-August-18  
-**Version:** 1.1.9
-
-New Files that will All notable changes to *Mini-JSTorch* will be documented in this file.
-
----
-
-## [1.1.9] - 2025-Monday-August-18
-
-### Added
-- Complete overhaul of core engine for stability and full feature support.
-- Adam optimizer fully integrated with batch gradient handling.
-- NaN-safe operations for forward/backward passes and loss calculations.
-- Sequential container with robust parameter tracking.
-- Utility functions enhanced for numeric safety and matrix operations.
-- Ready-to-use example scripts with multiple hidden layers for frontend experimentation.
-- Full handling for lightweight devices, optimized for speed and low memory usage.
-
-### Fixed
-- bugs in ReLU and gradient propagation causing NaN loss values.
-- Backward propagation errors for batch matrices corrected.
-- Critical Error while startup Engine.
-
-### Changed
-- Layer and activation API standardized for consistency.
-- CrossEntropyLoss now safely handles edge cases in probability computations.
-- Improvements systems for make experiences more stable and not heavy.
-- Minor numeric stability improvements.
-
----

package/engine/MainEngine.js

@@ -1,209 +0,0 @@
-
-// MAINENGINE FILES [PACK IN AT ONE FILES]
-// CURRENT VERSIONS: 0.0.4
-// AUTHOR: Rizal
-// LICENSE: MIT(R)
-
-// Utils
-export function zeros(rows, cols) {
-    return Array.from({length: rows}, () => Array(cols).fill(0));
-}
-
-export function randomMatrix(rows, cols, scale=0.1) {
-    return Array.from({length: rows}, () =>
-        Array.from({length: cols}, () => (Math.random()*2-1)*scale)
-    );
-}
-
-export function softmax(x) {
-    const maxVal = Math.max(...x);
-    const exps = x.map(v => Math.exp(v - maxVal));
-    const sumExps = exps.reduce((a,b)=>a+b, 0);
-    return exps.map(v => v / sumExps);
-}
-
-export function crossEntropy(pred, target) {
-    const eps = 1e-12;
-    return -target.reduce((sum, t, i) => sum + t * Math.log(pred[i] + eps), 0);
-}
-
-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 result = zeros(a.length, b[0].length);
-    for (let i=0;i<a.length;i++) {
-        for (let j=0;j<b[0].length;j++) {
-            let sum=0;
-            for (let k=0;k<a[0].length;k++) sum += a[i][k]*b[k][j];
-            result[i][j]=sum;
-        }
-    }
-    return result;
-}
-
-// 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) {
-        // grad shape: batch x outputDim
-        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);
-
-        // propagate to input
-        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]} // wrap b in array for consistency
-        ];
-    }
-}
-
-// Activations
-export class ReLU {
-    constructor() { this.out=null; }
-    forward(x) {
-        this.out = Array.isArray(x[0]) ? x.map(r=>r.map(v=>Math.max(0,v))) : x.map(v=>Math.max(0,v));
-        return this.out;
-    }
-    backward(grad) {
-        return Array.isArray(grad[0])
-            ? grad.map((r,i)=>r.map((v,j)=>v*(this.out[i][j]>0?1:0)))
-            : grad.map((v,i)=>v*(this.out[i]>0?1:0));
-    }
-}
-
-export class Sigmoid {
-    constructor() { this.out=null; }
-    forward(x) {
-        const sigmoidFn = v=>1/(1+Math.exp(-v));
-        this.out = Array.isArray(x[0]) ? x.map(r=>r.map(sigmoidFn)) : x.map(sigmoidFn);
-        return this.out;
-    }
-    backward(grad) {
-        return Array.isArray(grad[0])
-            ? grad.map((r,i)=>r.map((v,j)=>v*this.out[i][j]*(1-this.out[i][j])))
-            : grad.map((v,i)=>v*this.out[i]*(1-this.out[i]));
-    }
-}
-
-// Loss wrapper
-export class CrossEntropyLoss {
-    forward(pred, target) {
-        // pred: batch x classes, target: batch x classes
-        const losses = pred.map((p,i)=>crossEntropy(softmax(p), target[i]));
-        this.pred = pred;
-        this.target = target;
-        return losses.reduce((a,b)=>a+b,0)/pred.length;
-    }
-
-    backward() {
-        // gradient of softmax + CE
-        const grad = [];
-        for (let i=0;i<this.pred.length;i++) {
-            const s = softmax(this.pred[i]);
-            grad.push(s.map((v,j)=>v-this.target[i][j]));
-        }
-        return grad.map(r=>r.map(v=>v/this.pred.length));
-    }
-}
-
-// Optimizer: Adam
-export class Adam {
-    constructor(params, lr=0.001, beta1=0.9, beta2=0.999, eps=1e-8) {
-        this.params = params;
-        this.lr = lr;
-        this.beta1 = beta1;
-        this.beta2 = beta2;
-        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);
-                }
-            }
-        });
-    }
-}
-
-// Sequential container
-export class Sequential {
-    constructor(layers=[]) { this.layers=layers; }
-    forward(x) {
-        return this.layers.reduce((input, layer)=>layer.forward(input), x);
-    }
-    backward(grad) {
-        return this.layers.reduceRight((g,layer)=>layer.backward(g), grad);
-    }
-    parameters() {
-        return this.layers.flatMap(l=>l.parameters ? l.parameters() : []);
-    }
-}
-
-// Tambahin ke akhir file utama mini-jstorch
-     export function saveModel(model) {
-       if (!(model instanceof Sequential)) {
-         throw new Error("saveModel only supports Sequential models");
-       }
-       const weights = model.layers.map(layer => ({
-         weights: layer.W ? layer.W : null,
-         biases: layer.b ? layer.b : null
-       }));
-       return JSON.stringify(weights);
-     }
-
-     export function loadModel(model, json) {
-       if (!(model instanceof Sequential)) {
-         throw new Error("loadModel only supports Sequential models");
-       }
-       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;
-         }
-       });
-     }
-

package/engine/startup.cpu

@@ -1,8 +0,0 @@
---start[line]--
-e=run=[cpu[core]]
-e.cg()
-e.register('vanilla')
-l=e.load('asm')
-r=l.gv=[0xCAFEBABE]
-e.load(register,r,'vanilla')
---end[line]--