* avoid passing around dataRaw where possible.

* don't return values which are not used.
* renamed some `get` methods to `set`.

Author: lindapaiste

src/NeuralNetwork/NeuralNetworkData.js

@@ -25,11 +25,11 @@ class NeuralNetworkData {
     // methods
     // summarize data
     this.createMetadata = this.createMetadata.bind(this);
-    this.getDataStats = this.getDataStats.bind(this);
+    this.setDataStats = this.setDataStats.bind(this);
     this.getInputMetaStats = this.getInputMetaStats.bind(this);
-    this.getDataUnits = this.getDataUnits.bind(this);
-    this.getInputMetaUnits = this.getInputMetaUnits.bind(this);
-    this.getDTypesFromData = this.getDTypesFromData.bind(this);
+    this.setDataUnits = this.setDataUnits.bind(this);
+    this.setInputMetaUnits = this.setInputMetaUnits.bind(this);
+    this.setDTypesFromData = this.setDTypesFromData.bind(this);
     // add data
     this.addData = this.addData.bind(this);
     // data conversion
@@ -41,7 +41,7 @@ class NeuralNetworkData {
     this.unnormalizeArray = this.unnormalizeArray.bind(this);
     // one hot
     this.applyOneHotEncodingsToDataRaw = this.applyOneHotEncodingsToDataRaw.bind(this);
-    this.getDataOneHot = this.getDataOneHot.bind(this);
+    this.setDataOneHot = this.setDataOneHot.bind(this);
     this.getInputMetaOneHot = this.getInputMetaOneHot.bind(this);
     this.createOneHotEncodings = this.createOneHotEncodings.bind(this);
     // Saving / loading data
@@ -66,25 +66,22 @@ class NeuralNetworkData {
    *  2. getting the min and max from the data
    *  3. getting the oneHot encoded values
    *  4. getting the inputShape and outputUnits from the data
-   * @param {*} dataRaw
-   * @param {*} inputShape
-   * TODO: don't need to pass around dataRaw as an argument
+   * @param {number[]} [inputShape]
    */
-  createMetadata(dataRaw, inputShape = null) {
-    if (!dataRaw.length) {
+  createMetadata(inputShape = null) {
+    if (!this.data.raw.length) {
       throw new Error('Cannot create metadata because no data has been added.');
     }
     // get the data type for each property
-    this.getDTypesFromData(dataRaw);
+    this.setDTypesFromData();
     // get the stats - min, max
-    this.getDataStats(dataRaw);
+    this.setDataStats();
     // onehot encode
-    this.getDataOneHot(dataRaw);
+    this.setDataOneHot();
     // calculate the input units from the data
-    this.getDataUnits(dataRaw, inputShape);
+    this.setDataUnits(inputShape);
 
     this.isMetadataReady = true;
-    return { ...this.meta };
   }
 
   /*
@@ -94,47 +91,35 @@ class NeuralNetworkData {
    */
 
   /**
+   * @private
    * get stats about the data
-   * @param {*} dataRaw
    */
-  getDataStats(dataRaw) {
-    const meta = Object.assign({}, this.meta);
-
-    const inputMeta = this.getInputMetaStats(dataRaw, meta.inputs, 'xs');
-    const outputMeta = this.getInputMetaStats(dataRaw, meta.outputs, 'ys');
-
-    meta.inputs = inputMeta;
-    meta.outputs = outputMeta;
-
-    this.meta = {
-      ...this.meta,
-      ...meta,
-    };
-
-    return meta;
+  setDataStats() {
+    // TODO: I don't like that this overwrites the existing value -Linda
+    this.meta.inputs = this.getInputMetaStats(this.meta.inputs, 'xs');
+    this.meta.outputs = this.getInputMetaStats(this.meta.outputs, 'ys');
   }
 
   /**
+   * @private
    * getRawStats
    * get back the min and max of each label
-   * @param {*} dataRaw
    * @param {*} inputOrOutputMeta
    * @param {*} xsOrYs
    */
-  // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  getInputMetaStats(dataRaw, inputOrOutputMeta, xsOrYs) {
+  getInputMetaStats(inputOrOutputMeta, xsOrYs) {
     const inputMeta = Object.assign({}, inputOrOutputMeta);
 
     Object.keys(inputMeta).forEach(k => {
       if (inputMeta[k].dtype === 'string') {
         inputMeta[k].min = 0;
         inputMeta[k].max = 1;
       } else if (inputMeta[k].dtype === 'number') {
-        const dataAsArray = dataRaw.map(item => item[xsOrYs][k]);
+        const dataAsArray = this.data.raw.map(item => item[xsOrYs][k]);
         inputMeta[k].min = nnUtils.getMin(dataAsArray);
         inputMeta[k].max = nnUtils.getMax(dataAsArray);
       } else if (inputMeta[k].dtype === 'array') {
-        const dataAsArray = dataRaw.map(item => item[xsOrYs][k]).flat();
+        const dataAsArray = this.data.raw.map(item => item[xsOrYs][k]).flat();
         inputMeta[k].min = nnUtils.getMin(dataAsArray);
         inputMeta[k].max = nnUtils.getMax(dataAsArray);
       }
@@ -144,41 +129,23 @@ class NeuralNetworkData {
   }
 
   /**
+   * @private
    * get the data units, inputshape and output units
-   * @param {*} dataRaw
+   * @param {*} arrayShape
    */
-  getDataUnits(dataRaw, _arrayShape = null) {
-    const arrayShape = _arrayShape !== null ? _arrayShape : undefined;
-    const meta = Object.assign({}, this.meta);
-
+  setDataUnits(arrayShape) {
     // if the data has a shape pass it in
-    let inputShape;
-    if (arrayShape) {
-      inputShape = arrayShape;
-    } else {
-      inputShape = [this.getInputMetaUnits(dataRaw, meta.inputs)].flat();
-    }
-
-    const outputShape = this.getInputMetaUnits(dataRaw, meta.outputs);
-
-    meta.inputUnits = inputShape;
-    meta.outputUnits = outputShape;
-
-    this.meta = {
-      ...this.meta,
-      ...meta,
-    };
-
-    return meta;
+    this.meta.inputUnits = arrayShape ?? [this.setInputMetaUnits(this.meta.inputs)].flat();
+    this.meta.outputUnits = this.setInputMetaUnits(this.meta.outputs);
   }
 
   /**
+   * @private
    * get input
    * @param {*} _inputsMeta
-   * @param {*} _dataRaw
    */
-  // eslint-disable-next-line class-methods-use-this, no-unused-vars
-  getInputMetaUnits(_dataRaw, _inputsMeta) {
+  // eslint-disable-next-line class-methods-use-this
+  setInputMetaUnits(_inputsMeta) {
     let units = 0;
     const inputsMeta = Object.assign({}, _inputsMeta);
 
@@ -202,18 +169,19 @@ class NeuralNetworkData {
   }
 
   /**
-   * getDTypesFromData
+   * @private
+   * setDTypesFromData
    * gets the data types of the data we're using
    * important for handling oneHot
    */
-  getDTypesFromData(_dataRaw) {
+  setDTypesFromData() {
     const meta = {
       ...this.meta,
       inputs: {},
       outputs: {},
     };
 
-    const sample = _dataRaw[0];
+    const sample = this.data.raw[0];
     const xs = Object.keys(sample.xs);
     const ys = Object.keys(sample.ys);
 
@@ -233,8 +201,6 @@ class NeuralNetworkData {
     // otherwise throw an error
 
     this.meta = meta;
-
-    return meta;
   }
 
   /**
@@ -244,6 +210,7 @@ class NeuralNetworkData {
    */
 
   /**
+   * @public - used by nn
    * Add Data
    * @param {object} xInputObj, {key: value}, key must be the name of the property value must be a String, Number, or Array
    * @param {*} yInputObj, {key: value}, key must be the name of the property value must be a String, Number, or Array
@@ -262,12 +229,13 @@ class NeuralNetworkData {
    */
 
   /**
+   * @public - used by nn
    * convertRawToTensors
    * converts array of {xs, ys} to tensors
    * @param {*} _dataRaw
    * @param {*} meta
+   * TODO: requires the nn to pass in the training data as an argument -- why?
    */
-  // eslint-disable-next-line class-methods-use-this, no-unused-vars
   convertRawToTensors(dataRaw) {
     const meta = Object.assign({}, this.meta);
     const dataLength = dataRaw.length;
@@ -313,30 +281,24 @@ class NeuralNetworkData {
    */
 
   /**
+   * @public - used by nn
    * normalize the dataRaw input
-   * @param {*} dataRaw
    */
-  normalizeDataRaw(dataRaw) {
-    const meta = Object.assign({}, this.meta);
-
-    const normXs = this.normalizeInputData(dataRaw, meta.inputs, 'xs');
-    const normYs = this.normalizeInputData(dataRaw, meta.outputs, 'ys');
-
-    const normalizedData = nnUtils.zipArrays(normXs, normYs);
+  normalizeDataRaw() {
+    const normXs = this.normalizeInputData(this.meta.inputs, 'xs');
+    const normYs = this.normalizeInputData(this.meta.outputs, 'ys');
 
-    return normalizedData;
+    return nnUtils.zipArrays(normXs, normYs);
   }
 
   /**
-   * normalizeRaws
-   * @param {*} dataRaw
+   * @private
    * @param {*} inputOrOutputMeta
    * @param {*} xsOrYs
    */
-  // eslint-disable-next-line no-unused-vars, class-methods-use-this
-  normalizeInputData(dataRaw, inputOrOutputMeta, xsOrYs) {
+  normalizeInputData(inputOrOutputMeta, xsOrYs) {
     // the data length
-    const dataLength = dataRaw.length;
+    const dataLength = this.data.raw.length;
     // the copy of the inputs.meta[inputOrOutput]
     const inputMeta = Object.assign({}, inputOrOutputMeta);
 
@@ -349,7 +311,7 @@ class NeuralNetworkData {
         max: inputMeta[k].max,
       };
 
-      const dataAsArray = dataRaw.map(item => item[xsOrYs][k]);
+      const dataAsArray = this.data.raw.map(item => item[xsOrYs][k]);
       // depending on the input type, normalize accordingly
       if (inputMeta[k].dtype === 'string') {
         options.legend = inputMeta[k].legend;
@@ -378,7 +340,7 @@ class NeuralNetworkData {
   }
 
   /**
-   * normalizeArray
+   * @public - used by nn
    * @param {*} _input
    * @param {*} _options
    */
@@ -408,7 +370,7 @@ class NeuralNetworkData {
   }
 
   /**
-   * unNormalizeArray
+   * @public but not used anywhere
    * @param {*} _input
    * @param {*} _options
    */
@@ -451,16 +413,17 @@ class NeuralNetworkData {
    */
 
   /**
+   * @public - used by nn
    * applyOneHotEncodingsToDataRaw
    * does not set this.data.raws
    * but rather returns them
    * @param {*} _dataRaw
    * @param {*} _meta
    */
-  applyOneHotEncodingsToDataRaw(dataRaw) {
+  applyOneHotEncodingsToDataRaw() {
     const meta = Object.assign({}, this.meta);
 
-    const output = dataRaw.map(row => {
+    const output = this.data.raw.map(row => {
       const xs = {
         ...row.xs,
       };
@@ -490,35 +453,21 @@ class NeuralNetworkData {
   }
 
   /**
-   * getDataOneHot
+   * @private
    * creates onehot encodings for the input and outputs
    * and adds them to the meta info
-   * @param {*} dataRaw
    */
-  getDataOneHot(dataRaw) {
-    const meta = Object.assign({}, this.meta);
-
-    const inputMeta = this.getInputMetaOneHot(dataRaw, meta.inputs, 'xs');
-    const outputMeta = this.getInputMetaOneHot(dataRaw, meta.outputs, 'ys');
-
-    meta.inputs = inputMeta;
-    meta.outputs = outputMeta;
-
-    this.meta = {
-      ...this.meta,
-      ...meta,
-    };
-
-    return meta;
+  setDataOneHot() {
+    this.meta.inputs = this.getInputMetaOneHot(this.meta.inputs, 'xs');
+    this.meta.outputs = this.getInputMetaOneHot(this.meta.outputs, 'ys');
   }
 
   /**
-   * getOneHotMeta
+   * @private
    * @param {*} _inputsMeta
-   * @param {*} _dataRaw
    * @param {*} xsOrYs
    */
-  getInputMetaOneHot(_dataRaw, _inputsMeta, xsOrYs) {
+  getInputMetaOneHot(_inputsMeta, xsOrYs) {
     const inputsMeta = Object.assign({}, _inputsMeta);
 
     Object.entries(inputsMeta).forEach(arr => {
@@ -528,7 +477,7 @@ class NeuralNetworkData {
       const { dtype } = arr[1];
 
       if (dtype === 'string') {
-        const uniqueVals = [...new Set(_dataRaw.map(obj => obj[xsOrYs][key]))];
+        const uniqueVals = [...new Set(this.data.raw.map(obj => obj[xsOrYs][key]))];
         const oneHotMeta = this.createOneHotEncodings(uniqueVals);
         inputsMeta[key] = {
           ...inputsMeta[key],
@@ -587,7 +536,7 @@ class NeuralNetworkData {
    */
   async loadData(filesOrPath, inputLabels, outputLabels) {
     const dataArray = await loadData(filesOrPath);
-    this.data.raw = this.formatRawData(dataArray, inputLabels, outputLabels);
+    this.formatRawData(dataArray, inputLabels, outputLabels);
   }
 
   /**
@@ -704,7 +653,8 @@ class NeuralNetworkData {
     }
 
     // create an array of json objects [{xs,ys}]
-    const result = dataArray.map((item, idx) => {
+    // set this.data.raw
+    this.data.raw = dataArray.map((item, idx) => {
       const output = {
         xs: {},
         ys: {},
@@ -728,11 +678,6 @@ class NeuralNetworkData {
 
       return output;
     });
-
-    // set this.data.raw
-    this.data.raw = result;
-
-    return result;
   }
 
   /**