finish feature normalization and multivariate linear regression

Author: rwieruch

package.json

@@ -17,7 +17,6 @@
   },
   "dependencies": {
     "csv-to-array-matrix": "^0.1.1",
-    "fast-csv": "^2.4.1",
     "mathjs": "^3.16.5"
   }
 }

src/index.js

@@ -2,11 +2,9 @@ import math from 'mathjs';
 import csvToMatrix  from 'csv-to-array-matrix';
 
 import {
-  getDimension,
-  getSubset,
-  getMeanByVector,
-  getStdByVector,
-  setVector,
+  getDimensionSize,
+  getMeanAsRowVector,
+  getStdAsRowVector,
   pushVector,
 } from './util';
 
@@ -17,10 +15,15 @@ function init(matrix) {
   // Part 0: Preparation
   console.log('Part 0: Preparation ...\n');
 
-  let X = getSubset(matrix, ':, 1:2');
-  let y = getSubset(matrix, ':, 3');
-  let m = getDimension(y, 1);
-  let n = getDimension(y, 2);
+  let X = math.eval('matrix[:, 1:2]', {
+    matrix,
+  });
+  let y = math.eval('matrix[:, 3]', {
+    matrix,
+  });
+
+  let m = getDimensionSize(y, 1);
+  let n = getDimensionSize(y, 2);
 
   // Part 1: Feature Normalization
   console.log('Part 1: Feature Normalization ...\n');
@@ -43,60 +46,56 @@ function init(matrix) {
   const ALPHA = 0.01;
   const ITERATIONS = 400;
 
-  let theta = math.zeros(3, 1).valueOf();
+  let theta = [[0], [0], [0]];
   theta = gradientDescentMulti(XNorm, y, theta, ALPHA, ITERATIONS);
 
   console.log('theta: ', theta);
   console.log('\n');
 }
 
 function featureNormalize(X) {
-  const mu = getMeanByVector(X);
-  const sigma = getStdByVector(X); // alternative: range
+  const mu = getMeanAsRowVector(X);
+  const sigma = getStdAsRowVector(X); // alternative: range
 
   // n = features
-  const n = getDimension(X, 2);
+  const n = getDimensionSize(X, 2);
   for (let i = 0; i < n; i++) {
 
-    // take feature column by index i and subtract with mean with index i from mean vector
-    let xMinusMean = math.subtract(getSubset(X, `:, ${i + 1}`), mu[i]);
-    // put normalized feature column by dividing the meaned vector with the standard deviation
-    let normalizedVector = math.divide(xMinusMean, sigma[i]);
+    let featureVector = math.eval(`X[:, ${i + 1}]`, {
+      X,
+    });
+
+    let featureMeanVector = math.eval('featureVector - mu', {
+      featureVector,
+      mu: mu[i]
+    });
+
+    let normalizedVector = math.eval('featureMeanVector / sigma', {
+      featureMeanVector,
+      sigma: sigma[i],
+    });
 
-    X = setVector(X, i, normalizedVector);
+    math.eval(`X[:, ${i + 1}] = normalizedVector`, {
+      X,
+      normalizedVector,
+    });
   }
 
   return { XNorm: X, mu, sigma };
 }
 
 function gradientDescentMulti(X, y, theta, ALPHA, ITERATIONS) {
-  const m = getDimension(y, 1);
+  const m = getDimensionSize(y, 1);
 
   for (let i = 0; i < ITERATIONS; i++) {
-    // Octave:
-    // theta = theta - ALPHA / m * ((X * theta - y)' * X)';
-
-    theta = math.subtract(
+    theta = math.eval(`theta - ALPHA / m * ((X * theta - y)' * X)'`, {
       theta,
-      math.multiply(
-        (ALPHA / m),
-        math.transpose(
-          math.multiply(
-            math.transpose(
-              math.subtract(
-                math.multiply(
-                  X,
-                  theta
-                ),
-                y
-              )
-            ),
-            X
-          )
-        )
-      )
-    );
+      ALPHA,
+      m,
+      X,
+      y,
+    });
   }
 
   return theta;
-}
+}

src/util.js

@@ -1,13 +1,10 @@
 import math from 'mathjs';
 
-export const getSubset = (matrix, selector) =>
-  math.eval(`matrix[${selector}]`, { matrix });
-
 export const pushVector = (matrix, index, vector) => {
   const extendedMatrix = math
     .ones([
-      getDimension(matrix, 1),
-      getDimension(matrix, 2) + 1
+      getDimensionSize(matrix, 1),
+      getDimensionSize(matrix, 2) + 1
     ])
     .valueOf();
 
@@ -24,22 +21,19 @@ export const pushVector = (matrix, index, vector) => {
   }));
 };
 
-export const setVector = (matrix, index, vector) =>
-  matrix.map((row, rowKey) => row.map((column, columnKey) => index === columnKey ? vector[rowKey][0] : column));
-
-export const getMeanByVector = (matrix) => {
-  const n = getDimension(matrix, 2);
-  const vectors = Array(n).fill().map((_, i) => getSubset(matrix, `:, ${i + 1}`));
+export const getMeanAsRowVector = (matrix) => {
+  const n = getDimensionSize(matrix, 2);
+  const vectors = Array(n).fill().map((_, i) => math.eval(`matrix[:, ${i + 1}]`, { matrix }));
   return vectors.reduce((result, vector) => result.concat(math.mean(vector)), []);
 };
 
-export const getStdByVector = (matrix) => {
-  const n = getDimension(matrix, 2);
-  const vectors = Array(n).fill().map((_, i) => getSubset(matrix, `:, ${i + 1}`));
+export const getStdAsRowVector = (matrix) => {
+  const n = getDimensionSize(matrix, 2);
+  const vectors = Array(n).fill().map((_, i) => math.eval(`matrix[:, ${i + 1}]`, { matrix }));
   return vectors.reduce((result, vector) => result.concat(math.std(vector)), []);
 };
 
-export const getDimension = (matrix, dimension) =>
+export const getDimensionSize = (matrix, dimension) =>
   dimension === 1
     ? matrix.length
     : matrix[0].length;