xy-scale 1.0.9 → 1.1.1

package/README.md

@@ -64,7 +64,9 @@ Designed for production environments, this function parses and scales feature da
 - `configX`: Scaling configuration for production data.
 - `keyNamesX`: Key names reflecting feature weights.
 
-## Helper Callback Functions for Custom Data Parsing
+---
+
+## Helper Functions for Custom Data Parsing
 
 ### `xCallbackFunc`
 
@@ -75,6 +77,21 @@ The `xCallbackFunc` function is used to extract specific feature values from eac
 The `yCallbackFunc` function defines the target output (or Y) that the machine learning model will learn to predict. This function typically creates Y by comparing each row of data with a future data point, which is especially useful in time-series data for predictive tasks. In our example, `yCallbackFunc` generates Y based on changes between the current and next rows, which can help the model learn to predict directional trends.
 
 
+### 3. `descaleArrayObj`
+
+The `descaleArrayObj` function reverses the scaling applied to a dataset, reconstructing the original values from the scaled data. It supports both normalization and standardization approaches, making it compatible with the scaled outputs of `parseTrainingXY` and `parseProductionX`.
+
+
+#### Parameters:
+- `scaled`: scaled array returned from `parseTrainingXY` (`trainX`, `trainY`, `testX` or `testY`) or `parseProductionX` (`X`).
+- `config`: config object returned from `parseTrainingXY` (`configX`, `configY`) or `parseProductionX` (`configX`).
+- `keyNames`: keyNames array returned from `parseTrainingXY` (`keyNamesX`, `keyNamesY`) or `parseProductionX` (`keyNamesX`).
+- `timeSteps`: input numeric timeSteps param submited to `parseTrainingXY` or `parseProductionX`. Defaults to 0. 
+
+#### Returns:
+
+The output of this function in an array of objects similar or equal to the input array of objects submited to `parseTrainingXY` or `parseProductionX`.
+
 ---
 
 ## Usage Examples

package/index.js

@@ -1,3 +1,4 @@
 import { parseTrainingXY, parseProductionX } from "./src/datasets.js"
+import { descaleArrayObj } from "./src/descale.js"
 
-export { parseTrainingXY, parseProductionX }
+export { parseTrainingXY, parseProductionX, descaleArrayObj }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xy-scale",
-  "version": "1.0.9",
+  "version": "1.1.1",
   "main": "./index.js",
   "type": "module",
   "scripts": {
@@ -13,5 +13,9 @@
   "devDependencies": {
     "webpack": "^5.96.1",
     "webpack-cli": "^5.1.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaimelias/xy-scale.git"
   }
 }

package/src/descale.js

@@ -2,14 +2,8 @@ import { timeStepsToArray } from './timeSteps.js';
 
 export const descaleArrayObj = ({ scaled, config, keyNames, timeSteps = 0 }) => {
 
-
-    
-
     const { min, max, std, mean, approach, inputTypes, uniqueStringIndexes } = config;
 
-
-    console.log('timeStepsToArray', timeStepsToArray(scaled, timeSteps)[0])
-
     // Initialize the descaled output array
     const descaledOutput = timeStepsToArray(scaled, timeSteps).map(scaledRow => {
         const originalObj = {};

package/src/scale.js

@@ -1,16 +1,12 @@
-
-
 export const scaleArrayObj = ({arrObj, weights = {}, forceScaling = null}) => {
 
-    if(forceScaling !== null  && forceScaling !== 'normalization' && forceScaling !==  'standardization')
-    {
-        throw Error('forceScalling should be null, "normalization" or "standardization"')
+    if (forceScaling !== null && forceScaling !== 'normalization' && forceScaling !== 'standardization') {
+        throw Error('forceScaling should be null, "normalization" or "standardization"');
     }
 
     const n = arrObj.length;
 
     if (n === 0) {
-        // If the input array is empty, return empty outputs
         return {
             scaledOutput: [],
             scaledConfig: {},
@@ -18,36 +14,22 @@ export const scaleArrayObj = ({arrObj, weights = {}, forceScaling = null}) => {
         };
     }
 
-    // Get the feature names (keys) from the first object
     const keyNames = Object.keys(arrObj[0]);
 
-    // **Loop 1: Compute weights for each keyName**
     const keyNameWeights = keyNames.map(key => {
-        if (weights.hasOwnProperty(key)) {
-            const weight = weights[key];
-            if (weight <= 0) {
-                throw new Error(`Weight for key "${key}" must be positive.`);
-            }
-            return weight;
-        } else {
-            return 1; // Default weight
-        }
+        return weights.hasOwnProperty(key) ? Math.max(weights[key], 1) : 1;
     });
 
     const totalColumns = keyNameWeights.reduce((sum, weight) => sum + weight, 0);
 
-    // **Loop 2: Build the new keyNames array with weights applied**
     const outputKeyNames = new Array(totalColumns);
     let idx = 0;
     for (let i = 0; i < keyNames.length; i++) {
-        const key = keyNames[i];
-        const weight = keyNameWeights[i];
-        for (let w = 0; w < weight; w++) {
-            outputKeyNames[idx++] = key;
+        for (let w = 0; w < keyNameWeights[i]; w++) {
+            outputKeyNames[idx++] = keyNames[i];
         }
     }
 
-    // Initialize variables for scaling
     const inputTypes = {};
     const min = {};
     const max = {};
@@ -57,7 +39,6 @@ export const scaleArrayObj = ({arrObj, weights = {}, forceScaling = null}) => {
     const uniqueStringIndexes = {};
     const counts = {};
 
-    // **Loop 3: Initialize variables for each key**
     for (const key of keyNames) {
         const firstValue = arrObj[0][key];
         inputTypes[key] = typeof firstValue;
@@ -73,7 +54,6 @@ export const scaleArrayObj = ({arrObj, weights = {}, forceScaling = null}) => {
         counts[key] = 0;
     }
 
-    // **Loop 4: Single pass to process data**
     for (const obj of arrObj) {
         for (const key of keyNames) {
             let value = obj[key];
@@ -84,11 +64,11 @@ export const scaleArrayObj = ({arrObj, weights = {}, forceScaling = null}) => {
                     uniqueIndexes[value] = Object.keys(uniqueIndexes).length;
                 }
                 value = uniqueIndexes[value];
-                obj[key] = value; 
+                obj[key] = value;
             }
 
-            if (value < min[key]) min[key] = value;
-            if (value > max[key]) max[key] = value;
+            min[key] = Math.min(min[key], value);
+            max[key] = Math.max(max[key], value);
 
             counts[key]++;
             const delta = value - mean[key];
@@ -97,20 +77,19 @@ export const scaleArrayObj = ({arrObj, weights = {}, forceScaling = null}) => {
         }
     }
 
-    // **Loop 5: Finalize standard deviation and decide scaling approach**
     const std = {};
     for (const key of keyNames) {
         std[key] = counts[key] > 1 ? Math.sqrt(M2[key] / (counts[key] - 1)) : 0;
 
-        // Apply forceScaling if specified, else use automatic selection
         if (forceScaling === 'normalization' || forceScaling === 'standardization') {
             approach[key] = forceScaling;
+        } else if (min[key] === 0 && max[key] === 1) {
+            approach[key] = 'none';  // No scaling required
         } else {
             approach[key] = std[key] < 1 ? 'normalization' : 'standardization';
         }
     }
 
-    // **Loop 6: Create scaled and reweighted output**
     const scaledOutput = new Array(n);
     for (let i = 0; i < n; i++) {
         const obj = arrObj[i];
@@ -125,7 +104,9 @@ export const scaleArrayObj = ({arrObj, weights = {}, forceScaling = null}) => {
             const stdValue = std[key];
 
             let scaledValue;
-            if (approach[key] === 'normalization') {
+            if (approach[key] === 'none') {
+                scaledValue = value;  // No scaling
+            } else if (approach[key] === 'normalization') {
                 scaledValue = maxValue !== minValue ? (value - minValue) / (maxValue - minValue) : 0;
             } else {
                 scaledValue = stdValue !== 0 ? (value - meanValue) / stdValue : 0;

package/test/test.js

@@ -52,7 +52,7 @@ const test = async () => {
 
     //console.log(JSON.stringify(trainingData))
 
-    console.log('testX', testX[0])
+    console.log('testX', testX.slice(-2))
     const descaled = descaleArrayObj({scaled: testX, config: configX, keyNames: keyNamesX, timeSteps})
 
     //comparing descaled values with the last values of input myArray