mini-jstorch 1.0.0 → 1.1.0

package/README.md

@@ -0,0 +1,73 @@
+# 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

@@ -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/act/relu.js

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

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

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

@@ -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,12 +1,22 @@
 {
   "name": "mini-jstorch",
-  "version": "1.0.0",
+  "version": "1.1.0",
+  "type": "module", 
+  "description": "A lightweight JavaScript neural network framework for browser & Node.js, inspired by PyTorch.",
   "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "description": ""
+  "keywords": [
+    "neural-network",
+    "javascript",
+    "lightweight",
+    "ai",
+    "machine-learning",
+    "browser",
+    "mini"
+  ],
+  "author": "Rizal",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rizal-editors/mini-jstorch.git"
+  }
 }

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

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

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

@@ -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];
+}