mini-jstorch 1.1.0 → 1.1.6

package/engine/Dummy/msg

@@ -0,0 +1,6 @@
+**File Unavailable**
+This file 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.
+
+For upcoming updates, this file may contain critical system components. Current usage may result in errors or malfunction, and it is not supported at this time.

package/engine/MainEngine.js

@@ -0,0 +1,148 @@
+// ================================
+// 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

@@ -0,0 +1,8 @@
+--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]--

package/index.js

@@ -1,17 +1,6 @@
-// index.js
-// Main entry point for mini-jstorch
-
-// Core model
+// Entry point of the library, export main classes and functions
 export { Seq } from './models/seq.js';
-
-// Layers
 export { Dense } from './layers/dense.js';
-
-// Activations
 export * as act from './act/linear.js';
-
-// Optimizers
 export { SGD } from './optim/sgd.js';
-
-// Training loop
 export { train } from './train/loop.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mini-jstorch",
-  "version": "1.1.0",
+  "version": "1.1.6",
   "type": "module", 
   "description": "A lightweight JavaScript neural network framework for browser & Node.js, inspired by PyTorch.",
   "main": "index.js",

package/README.md

@@ -1,73 +0,0 @@
-# mini-jstorch README
-
-## Overview
-*mini-jstorch* module is a lightweight, **PyTorch-inspired** neural network library in JavaScript. It provides basic components to build, train, and optimize neural networks
-and are not heavy.
-
-## Features
-- Sequential model container (`Seq`) for easy stacking of layers.
-- Common layers: `Dense`, `Dropout`, `Flatten`.
-- Activations: `relu`, `sigmoid`, `leakyRelu`, `tanh`, `linear`.
-- Tensor utilities (`zeros`, `rand`, `shape`) and math helpers (`dot`, `add`).
-- Custom SGD optimizer.
-- Training loop with batch and epoch support.
-- Save/load models with JSON.
-
-## Directory Structure
-```
-module-root/            # Only placeholder not an real module root name
-│
-├── index.js            # Main exports
-├── models/             # Model containers
-│   └── Seq.js          # Sequential model
-├── layers/             # Neural network layers
-│   ├── dense.js        # Fully connected layer
-│   ├── dropout.js      # Dropout layer
-│   └── flatten.js      # Flatten input layer
-├── act/                # Activation functions
-│   ├── linear.js       # Additional activations (leakyRelu, tanh)
-│   └── relu.js         # ReLU, Sigmoid
-├── utils/              # Utilities
-│   ├── io.js           # Save/load models
-│   ├── math.js         # Math helpers (dot, add, etc.)
-│   └── tensor.js       # Tensor helpers
-├── train/              # Training loop
-│   └── loop.js
-└── optim/              # Optimizers
-    └── sgd.js          # Custom SGD optimizer
-```
-
-## Patch Notes - Version 1.1.0
-- Refactored activation system into `act/` folder for better separation.
-- Added `linear.js` activations (leakyRelu, tanh).
-- Updated `Dense` layer with `forwardBatch` and `forwardLeaky` support.
-- Added `Flatten` and `Dropout` layers.
-- Implemented batch prediction support in `Seq` model.
-- Added basic SGD optimizer in `optim/`.
-- Introduced training loop in `train/loop.js`.
-- Expanded utils: tensor creation (`zeros`, `rand`), math operations (`dotBatch`, `addScalar`).
-- Enhanced model IO with activations mapping and optional pretty-print.
-- Added comments throughout files for better clarity and professional documentation.
-
-## Example Usage
-```javascript
-import { Seq } from './models/Seq.js';
-import { Dense } from './layers/dense.js';
-import * as act from './act/linear.js';
-import { SGD } from './optim/sgd.js';
-import { train } from './train/loop.js';
-
-const model = new Seq();
-model.add(new Dense(3, 5, act.leakyRelu));
-model.add(new Dense(5, 1));
-
-const optimizer = new SGD(0.01);
-
-train(model, [[1,2,3]], [[1]], (pred, y) => pred[0]-y[0], optimizer, 10);
-model.summary();
-```
-
-## Notes
-- Layer and function names are kept short and professional for clarity.
-- Batch methods available in layers and model for better training performance.
-- Designed to be an educational and extensible PyTorch-like system in pure JavaScript.

package/act/linear.js

@@ -1,8 +0,0 @@
-// Additional activations
-export function leakyRelu(x, alpha = 0.01) {
-  return x.map(v => (v > 0 ? v : alpha * v));
-}
-
-export function tanh(x) {
-  return x.map(v => Math.tanh(v));
-}

package/act/relu.js

@@ -1,10 +0,0 @@
-// Activation functions
-export function relu(x) {
-  // Rectified Linear Unit
-  return x.map(v => Math.max(0, v));
-}
-
-export function sigmoid(x) {
-  // Sigmoid activation
-  return x.map(v => 1 / (1 + Math.exp(-v)));
-}

package/example.js

@@ -1,23 +0,0 @@
-// example.js
-import { Seq, Dense, act, SGD, train } from './index.js';
-
-// Buat model
-const model = new Seq();
-model.add(new Dense(3, 5, act.leakyRelu));
-model.add(new Dense(5, 1));
-
-// Buat optimizer
-const optimizer = new SGD(0.01);
-
-// Contoh data training
-const x = [[1, 2, 3]];
-const y = [[1]];
-
-// Loss function sederhana
-const lossFn = (pred, target) => pred[0] - target[0];
-
-// Train model
-train(model, x, y, lossFn, optimizer, 10);
-
-// Tampilkan summary
-model.summary();

package/layers/dense.js

@@ -1,28 +0,0 @@
-import { dot, add } from '../utils/math.js';
-import { leakyRelu } from '../act/linear.js';
-
-// Fully connected layer
-export class Dense {
-  constructor(inputSize, outputSize, activation = x => x) {
-    this.weights = Array.from({ length: outputSize }, () =>
-      Array.from({ length: inputSize }, () => Math.random() * 0.1)
-    );
-    this.bias = Array(outputSize).fill(0);
-    this.activation = activation;
-    this.name = "Dense";
-  }
-
-  forward(input) {
-    const z = add(dot(this.weights, input), this.bias);
-    return z.map(this.activation);
-  }
-
-  forwardBatch(inputs) {
-    return inputs.map(input => this.forward(input));
-  }
-
-  forwardLeaky(input) {
-    const z = add(dot(this.weights, input), this.bias);
-    return leakyRelu(z);
-  }
-}

package/layers/dropout.js

@@ -1,15 +0,0 @@
-// Dropout layer for regularization
-export class Dropout {
-  constructor(p = 0.5) {
-    this.p = p;
-    this.name = "Dropout";
-  }
-
-  forward(input) {
-    return input.map(v => (Math.random() < this.p ? 0 : v / (1 - this.p)));
-  }
-
-  forwardBatch(inputs) {
-    return inputs.map(inp => this.forward(inp));
-  }
-}

package/layers/flatten.js

@@ -1,14 +0,0 @@
-// Flatten input for Dense layers
-export class Flatten {
-  constructor() {
-    this.name = "Flatten";
-  }
-
-  forward(input) {
-    return input.flat();
-  }
-
-  forwardBatch(inputs) {
-    return inputs.map(inp => inp.flat());
-  }
-}

package/models/Seq.js

@@ -1,25 +0,0 @@
-// Sequential model container
-export class Seq {
-  constructor() {
-    this.layers = [];
-  }
-
-  add(layer) {
-    this.layers.push(layer);
-  }
-
-  predict(input) {
-    return this.layers.reduce((out, layer) => layer.forward(out), input);
-  }
-
-  predictBatch(inputs) {
-    return inputs.map(input => this.predict(input));
-  }
-
-  summary() {
-    console.log("Model summary:");
-    this.layers.forEach((l, i) => {
-      console.log(` Layer ${i+1}: ${l.name}, outputSize: ${l.weights ? l.weights.length : 'N/A'}`);
-    });
-  }
-}

package/optim/sgd.js

@@ -1,12 +0,0 @@
-// Custom SGD optimizer
-export class SGD {
-  constructor(lr = 0.01) {
-    this.lr = lr;
-  }
-
-  step(params, grads) {
-    for (let i = 0; i < params.length; i++) {
-      params[i] = params[i].map((v,j) => v - this.lr * grads[i][j]);
-    }
-  }
-}

package/train/loop.js

@@ -1,28 +0,0 @@
-// Training loop
-export function train(model, X, Y, lossFn, optimizer, epochs=None) {
-  for(let e=0; e<epochs; e++) {
-    let totalLoss = 0;
-
-    for(let i=0; i<X.length; i++) {
-      const x = X[i];
-      const y = Y[i];
-
-      // Forward pass
-      const pred = model.predict(x);
-
-      // Compute loss
-      const loss = lossFn(pred, y);
-      totalLoss += loss;
-
-      // Naive gradient (placeholder)
-      const grads = pred.map((p,j) => [p - y[j]]);
-
-      // Update first Dense layer as example
-      if(model.layers[0].weights) {
-        optimizer.step([model.layers[0].weights], grads);
-      }
-    }
-
-    console.log(`Epoch ${e+1}/${epochs}, Loss: ${totalLoss/X.length}`);
-  }
-}

package/utils/io.js

@@ -1,28 +0,0 @@
-// Save and load model
-export function saveModel(model, pretty=false) {
-  const data = {
-    layers: model.layers.map(l => ({
-      name: l.name,
-      weights: l.weights,
-      bias: l.bias,
-      activation: l.activation?.name || null
-    }))
-  };
-  return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
-}
-
-export function loadModel(json, ModelClass, LayerClass, actMap={}) {
-  const data = typeof json === 'string' ? JSON.parse(json) : json;
-  const model = new ModelClass();
-
-  data.layers.forEach(ld => {
-    const l = new LayerClass(0,0);
-    l.weights = ld.weights;
-    l.bias = ld.bias;
-    l.name = ld.name;
-    if(ld.activation && actMap[ld.activation]) l.activation = actMap[ld.activation];
-    model.add(l);
-  });
-
-  return model;
-}

package/utils/math.js

@@ -1,18 +0,0 @@
-// Basic math utils
-export function dot(weights, input) {
-  return weights.map(row =>
-    row.reduce((sum, val, i) => sum + val * input[i], 0)
-  );
-}
-
-export function add(a, b) {
-  return a.map((v, i) => v + b[i]);
-}
-
-export function dotBatch(weights, inputs) {
-  return inputs.map(input => dot(weights, input));
-}
-
-export function addScalar(arr, scalar) {
-  return arr.map(v => v + scalar);
-}

package/utils/tensor.js

@@ -1,13 +0,0 @@
-// Tensor helpers
-export function zeros(size) {
-  return Array(size).fill(0);
-}
-
-export function rand(size, scale=0.1) {
-  return Array(size).fill(0).map(()=>Math.random()*scale);
-}
-
-export function shape(tensor) {
-  if(Array.isArray(tensor[0])) return [tensor.length, tensor[0].length];
-  return [tensor.length];
-}