mini-jstorch 1.0.2 → 1.1.0

package/README.md

@@ -1,24 +1,73 @@
-# mini-jstorch
-*NOTICE!*:
-This versions is still on a **BETA** Versions of **mini-jstorch**!
-So maybe the features is not many and completely *SO* BE PATIENCE!!
+# 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.
 
-**Version: 1.0.2**  
-A lightweight and browser-compatible deep learning framework inspired by **PyTorch** — written in pure JavaScript.  
-Perfect for CodePen, web demos, and fast prototyping.
+## 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
+```
 
-## Features
+## 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);
 
-- # `Sequential` model API
-- # Fully modular layers (e.g., `Dense`)
-- # Activation functions: `ReLU`, `Sigmoid`
-- # Model serialization (`saveModel`, `loadModel`)
-- # Works on both **Node.js** and **browser**
-- # No native bindings, 100% JavaScript
-- # Inspired by PyTorch, but mini-sized
+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

@@ -0,0 +1,8 @@
+// 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/{activations → act}/relu.js

@@ -1,7 +1,10 @@
+// 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

@@ -0,0 +1,23 @@
+// 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/index.js

@@ -1,5 +1,17 @@
 // index.js
-export { Sequential } from './models/Sequential.js';
-export { Dense } from './layers/Dense.js';
-export * as activations from './activations/relu.js';
-export * as io from './utils/io.js';
+// Main entry point for mini-jstorch
+
+// Core model
+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/layers/{Dense.js → dense.js}

@@ -1,5 +1,7 @@
 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 }, () =>
@@ -14,4 +16,13 @@ export class Dense {
     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

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

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

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

@@ -0,0 +1,12 @@
+// 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/package.json

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

package/train/loop.js

@@ -0,0 +1,28 @@
+// 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,24 +1,27 @@
-export function saveModel(model) {
-  const modelData = {
-    layers: model.layers.map(layer => ({
-      name: layer.name,
-      weights: layer.weights,
-      bias: layer.bias
+// 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 JSON.stringify(modelData);
+  return pretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
 }
 
-export function loadModel(json, ModelClass, LayerClass) {
+export function loadModel(json, ModelClass, LayerClass, actMap={}) {
   const data = typeof json === 'string' ? JSON.parse(json) : json;
   const model = new ModelClass();
 
-  data.layers.forEach(layer => {
-    const dense = new LayerClass(0, 0); // dummy init
-    dense.weights = layer.weights;
-    dense.bias = layer.bias;
-    dense.name = layer.name;
-    model.add(dense);
+  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,3 +1,4 @@
+// Basic math utils
 export function dot(weights, input) {
   return weights.map(row =>
     row.reduce((sum, val, i) => sum + val * input[i], 0)
@@ -5,5 +6,13 @@ export function dot(weights, input) {
 }
 
 export function add(a, b) {
-  return a.map((val, i) => val + b[i]);
+  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

@@ -0,0 +1,13 @@
+// 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];
+}

package/models/Sequential.js

@@ -1,20 +0,0 @@
-export class Sequential {
-  constructor() {
-    this.layers = [];
-  }
-
-  add(layer) {
-    this.layers.push(layer);
-  }
-
-  predict(input) {
-    return this.layers.reduce((out, layer) => layer.forward(out), input);
-  }
-
-  summary() {
-    console.log("Sequential model:");
-    this.layers.forEach((layer, i) => {
-      console.log(` Layer ${i + 1}: ${layer.name || "unnamed"}`);
-    });
-  }
-}