mini-jstorch 1.1.9 → 1.2.1

package/README.md

@@ -1,130 +1,17 @@
-## Mini-JSTorch ##
-
-# 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.
-
----
-
-## 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.
+# MINI JSTORCH #
 
 ---
 
-## Installation
 
-```bash
-npm install mini-jstorch
-# Node.js v20+ recommended for a good experience while using module
-```
+**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!**
 
----
-
-## 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()
-]);
+# HUGE THANKS 🎉 #
 
-// 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))}`);
-});
-```
----
+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!
 
-## 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.**
+# BE READY FOR IT... SET YOUR TIME CLOCK. #

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-jstorch",
-  "version": "1.1.9",
+  "version": "1.2.1",
   "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/Dummy/Experiments.js

@@ -0,0 +1,256 @@
+// MINI JSTORCH ENGINE
+// ENGINE VER: 1.2.0
+// LICENSE: MIT (C) Rizal 2025
+
+// ---------------------- Utilities ----------------------
+function zeros(rows, cols) { return Array.from({length:rows},()=>Array(cols).fill(0)); }
+function ones(rows, cols) { return Array.from({length:rows},()=>Array(cols).fill(1)); }
+function randomMatrix(rows, cols, scale=0.1){ return Array.from({length:rows},()=>Array.from({length:cols},()=> (Math.random()*2-1)*scale)); }
+function transpose(matrix){ return matrix[0].map((_,i)=>matrix.map(row=>row[i])); }
+function addMatrices(a,b){ return a.map((row,i)=>row.map((v,j)=>v+(b[i] && b[i][j]!==undefined?b[i][j]:0))); }
+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; }
+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); }
+function crossEntropy(pred,target){ const eps=1e-12; return -target.reduce((sum,t,i)=>sum+t*Math.log(pred[i]+eps),0); }
+
+// ---------------------- 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);
+                }
+        });
+    }
+}
+
+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]; }); } }
+
+// ---------------------- 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);
+}
+
+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;
+    });
+}
+
+// ---------------------- 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 dulu
+    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/{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,148 +0,0 @@
-// ================================
-// MINI JS AI ENGINE v1
-// ================================
-
-// Basic tensor ops
-const zeros = n => Array(n).fill(0);
-const randn = () => (Math.random() * 2 - 1) * 0.1;
-
-const dot = (a,b) => a.map(row=>b[0].map((_,j)=>row.reduce((sum,v,k)=>sum+v*b[k][j],0)));
-const add = (a,b) => a.map((row,i)=>row.map((v,j)=>v+b[i][j]));
-const sub = (a,b) => a.map((row,i)=>row.map((v,j)=>v-b[i][j]));
-const mulScalar = (a,s) => a.map(row=>row.map(v=>v*s));
-const transpose = m => m[0].map((_,i)=>m.map(row=>row[i]));
-
-// Activations
-const Activations = {
-    relu: x => x.map(v=>Math.max(0,v)),
-    linear: x => x,
-    leakyRelu: (x, alpha=0.01) => x.map(v=>v>0?v:alpha*v)
-};
-const dActivations = {
-    relu: x => x.map(v=>v>0?1:0),
-    linear: x => x.map(_=>1),
-    leakyRelu: (x, alpha=0.01) => x.map(v=>v>0?1:alpha)
-};
-
-// Dense layer with manual grad & auto-grad
-class Dense {
-    constructor(inputSize, outputSize, activation='linear'){
-        this.inputSize = inputSize;
-        this.outputSize = outputSize;
-        this.activation = activation;
-        this.W = Array.from({length:inputSize},()=>Array.from({length:outputSize},()=>randn()*Math.sqrt(2/inputSize)));
-        this.b = Array(outputSize).fill(0);
-
-        // Adam variables
-        this.mW = mulScalar(this.W,0);
-        this.vW = mulScalar(this.W,0);
-        this.mb = Array(outputSize).fill(0);
-        this.vb = Array(outputSize).fill(0);
-        this.lastInput = null;
-        this.lastOutput = null;
-    }
-
-    forward(X){
-        this.lastInput = X;
-        let output = dot(X,this.W);
-        output = output.map((row,i)=>row.map((v,j)=>v+this.b[j]));
-        this.lastOutput = output.map(row => Activations[this.activation](row));
-        return this.lastOutput;
-    }
-
-    backward(dLoss, lr=0.001, beta1=0.9, beta2=0.999, t=1){
-        const flatOut = this.lastOutput.flat();
-        const actGrad = dActivations[this.activation](flatOut);
-        const dOut = dLoss.flat().map((v,i)=>v*actGrad[i]);
-
-        const gradW = Array.from({length:this.inputSize},()=>Array(this.outputSize).fill(0));
-        const gradB = Array(this.outputSize).fill(0);
-
-        for(let k=0;k<this.lastInput.length;k++){
-            for(let i=0;i<this.inputSize;i++){
-                for(let j=0;j<this.outputSize;j++){
-                    gradW[i][j] += this.lastInput[k][i]*dOut[j]/this.lastInput.length;
-                }
-            }
-        }
-        for(let j=0;j<this.outputSize;j++) gradB[j] = dOut[j]/this.lastInput.length;
-
-        // Adam update with bias correction
-        for(let i=0;i<this.inputSize;i++){
-            for(let j=0;j<this.outputSize;j++){
-                this.mW[i][j] = beta1*this.mW[i][j]+(1-beta1)*gradW[i][j];
-                this.vW[i][j] = beta2*this.vW[i][j]+(1-beta2)*gradW[i][j]*gradW[i][j];
-                const mHat = this.mW[i][j]/(1-Math.pow(beta1,t));
-                const vHat = this.vW[i][j]/(1-Math.pow(beta2,t));
-                this.W[i][j] -= lr*mHat/(Math.sqrt(vHat)+1e-8);
-            }
-        }
-
-        for(let j=0;j<this.outputSize;j++){
-            this.mb[j] = beta1*this.mb[j]+(1-beta1)*gradB[j];
-            this.vb[j] = beta2*this.vb[j]+(1-beta2)*gradB[j]*gradB[j];
-            const mHat = this.mb[j]/(1-Math.pow(beta1,t));
-            const vHat = this.vb[j]/(1-Math.pow(beta2,t));
-            this.b[j] -= lr*mHat/(Math.sqrt(vHat)+1e-8);
-        }
-
-        // Return dLoss for next layer (manual grad)
-        const dNext = Array(this.lastInput.length).fill(0).map(_=>Array(this.inputSize).fill(0));
-        for(let i=0;i<this.inputSize;i++){
-            for(let j=0;j<this.outputSize;j++){
-                for(let k=0;k<this.lastInput.length;k++){
-                    dNext[k][i] += dOut[j]*this.W[i][j];
-                }
-            }
-        }
-        return dNext;
-    }
-}
-
-// Sequential model
-class Seq {
-    constructor(layers){
-        this.layers = layers;
-        this.logs = [];
-    }
-
-    forward(X){
-        return this.layers.reduce((inp,layer)=>layer.forward(inp), X);
-    }
-
-    train(X,y,epochs=200, lr=0.001){
-        for(let epoch=1;epoch<=epochs;epoch++){
-            const yPred = this.forward(X);
-            const dLoss = yPred.map((row,i)=>row.map((v,j)=>2*(v - y[i][j])/y.length));
-
-            let grad = dLoss;
-            for(let l=this.layers.length-1;l>=0;l--){
-                grad = this.layers[l].backward(grad, lr, 0.9, 0.999, epoch);
-            }
-
-            const loss = yPred.map((row,i)=>row.map((v,j)=>Math.pow(v - y[i][j],2))).flat().reduce((a,b)=>a+b,0)/y.length;
-            if(epoch%50===0) console.log(`Epoch ${epoch}, Loss ${loss.toFixed(4)}, Pred sample ${yPred[0][0].toFixed(2)}`);
-        }
-    }
-
-    predict(X){
-        return this.forward(X);
-    }
-}
-
-// ================================
-// EXAMPLE USAGE
-// ================================
-
-const model = new Seq([
-    new Dense(2,16,'relu'),
-    new Dense(16,12,'relu'),
-    new Dense(12,1,'linear')
-]);
-
-const X = [[1,2],[2,3],[3,4]];
-const y = [[3],[5],[7]];
-
-model.train(X,y,200,0.01);
-
-console.log('Prediction [7,8]:', model.predict([[7,8]]));

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]--