mini-jstorch 1.2.2 → 1.3.2

package/tests/unit/newver.js

@@ -0,0 +1,103 @@
+// tests/engine.test.js
+import { 
+    MatrixOps,
+    Tensor,
+    Linear,
+    CrossEntropyLoss,  // Ganti pake classnya
+    Adam,
+    Sequential,
+    ReLU,
+    MathOps            // Import MathOps yang ada softmax di dalamnya
+} from '../../src/Dummy/exp.js';
+
+// Alias untuk softmax dari MathOps
+const softmax = MathOps.softmax;
+
+// Test 1: MatrixOps.matmul vs old Tensor.matmul (dot)
+console.log("=== TEST 1: Matrix Multiplication ===");
+const A = [[1, 2], [3, 4]];
+const B = [[5, 6], [7, 8]];
+
+// Correct matrix multiplication
+const correctResult = MatrixOps.matmul(A, B);
+console.log("Correct matmul result:", correctResult);
+
+// Test new Tensor matmul
+const tensorA = new Tensor(A);
+const tensorB = new Tensor(B);
+const tensorResult = tensorA.matmul(tensorB);
+console.log("New Tensor matmul result:", tensorResult.data);
+
+// Test 2: Tensor operations consistency
+console.log("\n=== TEST 2: Tensor Operations ===");
+const testTensor = new Tensor([[1, 2], [3, 4]]);
+console.log("Original shape:", testTensor.shape());
+console.log("Transpose shape:", testTensor.transpose().shape());
+console.log("Flatten shape:", testTensor.flatten().shape());
+
+// Test 3: CrossEntropyLoss backward pass
+console.log("\n=== TEST 3: CrossEntropyLoss Backward ===");
+const pred = [[0.8, 0.1, 0.1], [0.2, 0.7, 0.1]];
+const target = [[1, 0, 0], [0, 1, 0]];
+
+const lossFn = new CrossEntropyLoss();
+const loss = lossFn.forward(pred, target);
+console.log("Loss value:", loss);
+
+const grad = lossFn.backward();
+console.log("Gradient shape per sample:", grad.map(g => g.length));
+console.log("Sample gradient:", grad[0]);
+
+// Test 4: Adam optimizer with 1D and 2D parameters
+console.log("\n=== TEST 4: Adam Optimizer ===");
+
+// Mock parameters (like from a Linear layer)
+const mockParams = [
+    {
+        param: [[0.5, 0.3], [0.1, 0.9]], // 2D weights
+        grad: [[0.1, 0.2], [0.3, 0.4]]
+    },
+    {
+        param: [0.1, 0.2], // 1D bias
+        grad: [0.01, 0.02]
+    }
+];
+
+console.log("Before optimization - Weights:", mockParams[0].param);
+console.log("Before optimization - Bias:", mockParams[1].param);
+
+const optimizer = new Adam(mockParams, 0.01);
+optimizer.step();
+
+console.log("After optimization - Weights:", mockParams[0].param);
+console.log("After optimization - Bias:", mockParams[1].param);
+
+// Test 5: Integration test - Simple forward pass
+console.log("\n=== TEST 5: Integration Test ===");
+try {
+    const linearLayer = new Linear(2, 3);
+    const input = new Tensor([[1, 2]]);
+    
+    console.log("Input shape:", input.shape());
+    
+    const output = linearLayer.forward(input.data);
+    console.log("Linear layer output shape:", [output.length, output[0].length]);
+    
+    // Test with ReLU
+    const relu = new ReLU();
+    const activated = relu.forward(output);
+    console.log("ReLU output shape:", [activated.length, activated[0].length]);
+    
+    console.log("✅ All integration tests passed!");
+} catch (error) {
+    console.log("❌ Integration test failed:", error.message);
+}
+
+// Test 6: Softmax consistency
+console.log("\n=== TEST 6: Softmax ===");
+const logits = [2.0, 1.0, 0.1];
+const sm = softmax(logits);
+console.log("Softmax result:", sm);
+console.log("Sum:", sm.reduce((a, b) => a + b, 0));
+
+console.log("\n=== ALL TESTS COMPLETED ===");

package/tests/unit/ogver.js

@@ -0,0 +1,87 @@
+// TEST JSTORCH WHOLE SYSTEMS AT ONCE
+// THIS FILES TESTINGS AT PREVIOUS UPDATE 1.3.0
+// DEPRECATED FILES NOT NEW
+import { Tensor, Linear, Sequential, ReLU, Sigmoid, Tanh, LeakyReLU, GELU, Dropout, Conv2D, MSELoss, CrossEntropyLoss, Adam, SGD, saveModel, loadModel, flattenBatch, reshape, stack, concat, eye } from '../../src/MainEngine.js';
+
+// ---------------------- Linear Test ----------------------
+console.log("=== Linear Test ===");
+const lin = new Linear(3,2);
+const linInput = [[1,2,3],[4,5,6]];
+const linOut = lin.forward(linInput);
+console.log("Linear forward:", linOut);
+const linGrad = [[0.1,0.2],[0.3,0.4]];
+const linBack = lin.backward(linGrad);
+console.log("Linear backward gradInput:", linBack);
+
+// ---------------------- Sequential + Activations Test ----------------------
+console.log("\n=== Sequential + Activations Test ===");
+const model = new Sequential([new Linear(2,2), new ReLU(), new Linear(2,1), new Sigmoid()]);
+const seqInput = [[0.5,1.0],[1.5,2.0]];
+const seqOut = model.forward(seqInput);
+console.log("Sequential forward:", seqOut);
+const seqGrad = [[0.1],[0.2]];
+const seqBack = model.backward(seqGrad);
+console.log("Sequential backward gradInput:", seqBack);
+
+// ---------------------- Conv2D Test ----------------------
+console.log("\n=== Conv2D Test ===");
+const conv = new Conv2D(1,1,3);
+const convInput = [[[ [1,2,3],[4,5,6],[7,8,9] ]]]; // batch=1, inC=1, HxW=3x3
+const convOut = conv.forward(convInput);
+console.log("Conv2D forward:", convOut);
+
+// Conv2D backward test
+const convGrad = [[[ [0.1,0.2,0.1],[0.2,0.3,0.2],[0.1,0.2,0.1] ]]];
+const convBack = conv.backward(convGrad);
+console.log("Conv2D backward gradInput:", convBack);
+
+// ---------------------- Tensor & Broadcast Test ----------------------
+console.log("\n=== Tensor & Broadcast Test ===");
+const a = Tensor.random(2,3);
+const b = Tensor.ones(2,3);
+const sum = a.add(b);
+console.log("Tensor add broadcast:", sum);
+
+// ---------------------- Loss + Optimizer Test ----------------------
+console.log("\n=== Loss + Optimizer Test ===");
+const lossModel = new Sequential([new Linear(2,2)]);
+const pred = lossModel.forward([[1,2]]);
+const target = [[0,1]];
+const ceLoss = new CrossEntropyLoss();
+const lval = ceLoss.forward(pred,target);
+console.log("CrossEntropyLoss value:", lval);
+
+const gradLoss = ceLoss.backward();
+lossModel.backward(gradLoss);
+
+const opt = new Adam(lossModel.parameters());
+opt.step();
+console.log("Updated parameters after Adam:", lossModel.parameters());
+
+// ---------------------- Dropout Test ----------------------
+console.log("\n=== Dropout Test ===");
+const drop = new Dropout(0.5);
+const dropInput = [[1,2],[3,4]];
+const dropOut = drop.forward(dropInput);
+console.log("Dropout forward:", dropOut);
+const dropBack = drop.backward([[0.1,0.2],[0.3,0.4]]);
+console.log("Dropout backward:", dropBack);
+
+// ---------------------- Save / Load Model Test ----------------------
+console.log("\n=== Save / Load Model Test ===");
+const modelSave = new Sequential([new Linear(2,2)]);
+const json = saveModel(modelSave);
+console.log("Saved model JSON:", json);
+const modelLoad = new Sequential([new Linear(2,2)]);
+loadModel(modelLoad,json);
+console.log("Loaded model parameters:", modelLoad.parameters());
+
+// ---------------------- Advanced Utils Test ----------------------
+console.log("\n=== Advanced Utils Test ===");
+const batch = [[[1,2],[3,4]],[[5,6],[7,8]]];
+console.log("Flatten batch:", flattenBatch(batch));
+console.log("Eye 3:", eye(3));
+console.log("Reshape:", reshape({data:[[1,2,3,4]]},2,2));
+console.log("Stack:", stack([Tensor.ones(2,2), Tensor.zeros(2,2)]));
+console.log("Concat axis0:", concat([[1,2],[3,4]], [[5,6],[7,8]], 0));
+console.log("Concat axis1:", concat([[1,2],[3,4]], [[5,6],[7,8]], 1));