xy-scale 1.4.43 → 1.4.44

package/index.js

@@ -1,5 +1,5 @@
 import { parseTrainingXY, parseProductionX } from "./src/datasets.js"
 import {arrayToTimesteps } from "./src/timeSteps.js"
-import { arrayShuffle, arrayShuffleXY } from "./src/utilities.js"
+import { arrayShuffle } from "./src/utilities.js"
 
-export { parseTrainingXY, parseProductionX, arrayToTimesteps, arrayShuffle, arrayShuffleXY }
+export { parseTrainingXY, parseProductionX, arrayToTimesteps, arrayShuffle }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xy-scale",
-  "version": "1.4.43",
+  "version": "1.4.44",
   "main": "./index.js",
   "type": "module",
   "scripts": {

package/src/datasets.js

@@ -1,5 +1,4 @@
 import { arrayShuffle } from "./utilities.js";
-import { oversampleXY, undersampleXY } from "./balancing.js";
 import { validateFirstRow, validateArray, hasInvalidNumbers } from "./validators.js";
 
 export const parseTrainingXY = ({
@@ -9,7 +8,6 @@ export const parseTrainingXY = ({
     xCallbackFunc = row => row,
     validateRows = () => true,
     shuffle = false,
-    balancing = '',
     state = {},
 }) => {
     validateArray(arrObj, { min: 2 }, 'parseTrainingXY');
@@ -17,6 +15,8 @@ export const parseTrainingXY = ({
 
     let flatX = [];
     let flatY = [];
+    let source = [];
+
 
     let keyNamesX = null;
     let keyNamesY = null;
@@ -27,6 +27,7 @@ export const parseTrainingXY = ({
         try {
             if (!validateRows({ objRow: arrObj, index: x, state })) continue;
 
+
             const parsedX = xCallbackFunc({ objRow: arrObj, index: x, state });
             const parsedY = yCallbackFunc({ objRow: arrObj, index: x, state });
 
@@ -74,6 +75,7 @@ export const parseTrainingXY = ({
 
             flatX.push(rowX);
             flatY.push(rowY);
+            source.push(arrObj[x])
 
         } catch(err) {
             throw new Error(`[BUG] - Skipped row index=${x}: ${err.message}`);
@@ -86,7 +88,8 @@ export const parseTrainingXY = ({
         for (let i = 0; i < flatX.length; i++) {
             merged[i] = {
                 x: flatX[i],
-                y: flatY[i]
+                y: flatY[i],
+                source: source[i]
             };
         }
 
@@ -94,10 +97,12 @@ export const parseTrainingXY = ({
 
         flatX = new Array(shuffled.length);
         flatY = new Array(shuffled.length);
+        source = new Array(shuffled.length)
 
         for (let i = 0; i < shuffled.length; i++) {
             flatX[i] = shuffled[i].x;
             flatY[i] = shuffled[i].y;
+            source[i] = shuffled[i].source
         }
     }
 
@@ -116,22 +121,8 @@ export const parseTrainingXY = ({
     let trainY = flatY.slice(0, splitIndex);
     let testX = flatX.slice(splitIndex);
     let testY = flatY.slice(splitIndex);
-
-    if (balancing) {
-        let balance;
-
-        if (balancing === 'oversample') {
-            balance = oversampleXY(trainX, trainY);
-            trainX = balance.X;
-            trainY = balance.Y;
-        } else if (balancing === 'undersample') {
-            balance = undersampleXY(trainX, trainY);
-            trainX = balance.X;
-            trainY = balance.Y;
-        } else {
-            throw Error('balancing argument only accepts "", "oversample" and "undersample". Defaults to "".');
-        }
-    }
+    let trainSource = source.slice(0, splitIndex);
+    let testSource = source.slice(splitIndex);
 
     return {
         trainX,
@@ -140,6 +131,8 @@ export const parseTrainingXY = ({
         testY,
         configX,
         configY,
+        trainSource,
+        testSource
     };
 };
 export const parseProductionX = ({
@@ -151,6 +144,7 @@ export const parseProductionX = ({
     state = {},
 }) => {
     let flatX = [];
+    let source = [];
     let keyNamesX = null;
 
     validateArray(arrObj, { min: 1 }, 'parseProductionX');
@@ -185,13 +179,32 @@ export const parseProductionX = ({
             }
 
             flatX.push(rowX);
+            source.push(arrObj[x])
+
         } catch(err) {
             throw new Error(`[BUG] - Skipped row index=${x}: ${err.message}`);
         }
     }
 
     if (shuffle) {
-         flatX = arrayShuffle(flatX);
+        const merged = new Array(flatX.length);
+
+        for (let i = 0; i < flatX.length; i++) {
+            merged[i] = {
+                x: flatX[i],
+                source: source[i]
+            };
+        }
+
+        const shuffled = arrayShuffle(merged);
+
+        flatX = new Array(shuffled.length);
+        source = new Array(shuffled.length)
+
+        for (let i = 0; i < shuffled.length; i++) {
+            flatX[i] = shuffled[i].x;
+            source[i] = shuffled[i].source
+        }
     }
 
     const configX = {
@@ -200,6 +213,7 @@ export const parseProductionX = ({
 
     return {
         X: flatX,
+        source,
         configX,
     };
 };

package/src/utilities.js

@@ -10,28 +10,4 @@ export const arrayShuffle = X => {
     }
 
     return shuffledX;
-}
-
-export const arrayShuffleXY = (X, Y) => {
-    if (!Array.isArray(X) || !Array.isArray(Y)) {
-        throw new TypeError('Both X and Y must be arrays');
-    }
-
-    if (X.length !== Y.length) {
-        throw new Error('X and Y must have the same length');
-    }
-
-    // Copy to avoid mutating the originals
-    const shuffledX = [...X];
-    const shuffledY = [...Y];
-
-    // Shuffle both arrays using the same swaps
-    for (let i = shuffledX.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-
-        [shuffledX[i], shuffledX[j]] = [shuffledX[j], shuffledX[i]];
-        [shuffledY[i], shuffledY[j]] = [shuffledY[j], shuffledY[i]];
-    }
-
-    return { X: shuffledX, Y: shuffledY };
-};
+}

package/src/balancing.js

@@ -1,187 +0,0 @@
-const isValidLabelValue = (value) => {
-  if (typeof value === "string" || typeof value === "boolean") return true;
-  if (typeof value === "number") return Number.isFinite(value);
-
-  if (Array.isArray(value)) {
-    return value.every(isValidLabelValue);
-  }
-
-  return false;
-};
-
-const makeLabelKey = (label) => {
-  if (!isValidLabelValue(label)) {
-    throw new Error(
-      "Invalid Y label. Allowed types: finite numbers, strings, booleans, or nested arrays of those."
-    );
-  }
-
-  return JSON.stringify(label);
-};
-
-const validateXY = (X, Y) => {
-  if (!Array.isArray(X) || !Array.isArray(Y)) {
-    throw new Error("X and Y must be arrays.");
-  }
-
-  if (X.length !== Y.length) {
-    throw new Error("X and Y must have the same length.");
-  }
-
-  if (X.length === 0) {
-    throw new Error("X and Y cannot be empty.");
-  }
-};
-
-const mulberry32 = (seed) => {
-  let t = seed >>> 0;
-
-  return () => {
-    t += 0x6D2B79F5;
-    let r = Math.imul(t ^ (t >>> 15), t | 1);
-    r ^= r + Math.imul(r ^ (r >>> 7), r | 61);
-    return ((r ^ (r >>> 14)) >>> 0) / 4294967296;
-  };
-};
-
-const resolveRandom = ({ random, seed } = {}) => {
-  if (typeof random === "function") return random;
-  if (Number.isInteger(seed)) return mulberry32(seed);
-  return Math.random;
-};
-
-const shuffleInPlace = (arr, random = Math.random) => {
-  for (let i = arr.length - 1; i > 0; i--) {
-    const j = Math.floor(random() * (i + 1));
-    [arr[i], arr[j]] = [arr[j], arr[i]];
-  }
-
-  return arr;
-};
-
-const sampleWithoutReplacement = (samples, size, random = Math.random) => {
-  if (size > samples.length) {
-    throw new Error("Cannot sample more items than available without replacement.");
-  }
-
-  const copy = [...samples];
-  shuffleInPlace(copy, random);
-  return copy.slice(0, size);
-};
-
-const sampleWithReplacement = (samples, size, random = Math.random) => {
-  if (samples.length === 0) {
-    throw new Error("Cannot sample from an empty array.");
-  }
-
-  const out = [];
-
-  for (let i = 0; i < size; i++) {
-    const idx = Math.floor(random() * samples.length);
-    out.push(samples[idx]);
-  }
-
-  return out;
-};
-
-const maybeClone = (value, clone) => {
-  if (!clone) return value;
-  return structuredClone(value);
-};
-
-const groupXYByLabel = (X, Y, { cloneX = false } = {}) => {
-  validateXY(X, Y);
-
-  const groups = new Map();
-
-  Y.forEach((label, i) => {
-    const key = makeLabelKey(label);
-
-    if (!groups.has(key)) {
-      groups.set(key, []);
-    }
-
-    groups.get(key).push({
-      x: maybeClone(X[i], cloneX),
-      y: label,
-    });
-  });
-
-  return groups;
-};
-
-export const oversampleXY = (X, Y, options = {}) => {
-  const {
-    random,
-    seed,
-    shuffleResult = true,
-    cloneX = false,
-  } = options;
-
-  const rng = resolveRandom({ random, seed });
-  const groups = groupXYByLabel(X, Y, { cloneX });
-
-  const counts = [...groups.values()].map((samples) => samples.length);
-  const maxCount = Math.max(...counts);
-
-  const combined = [];
-
-  for (const samples of groups.values()) {
-    const originals = [...samples];
-    const extrasNeeded = maxCount - originals.length;
-
-    const extras =
-      extrasNeeded > 0
-        ? sampleWithReplacement(samples, extrasNeeded, rng).map((sample) => ({
-            x: maybeClone(sample.x, cloneX),
-            y: sample.y,
-          }))
-        : [];
-
-    combined.push(...originals, ...extras);
-  }
-
-  if (shuffleResult) {
-    shuffleInPlace(combined, rng);
-  }
-
-  return {
-    X: combined.map(({ x }) => x),
-    Y: combined.map(({ y }) => y),
-  };
-};
-
-export const undersampleXY = (X, Y, options = {}) => {
-  const {
-    random,
-    seed,
-    shuffleResult = true,
-    cloneX = false,
-  } = options;
-
-  const rng = resolveRandom({ random, seed });
-  const groups = groupXYByLabel(X, Y, { cloneX });
-
-  const counts = [...groups.values()].map((samples) => samples.length);
-  const minCount = Math.min(...counts);
-
-  const combined = [];
-
-  for (const samples of groups.values()) {
-    const selected = sampleWithoutReplacement(samples, minCount, rng).map((sample) => ({
-      x: maybeClone(sample.x, cloneX),
-      y: sample.y,
-    }));
-
-    combined.push(...selected);
-  }
-
-  if (shuffleResult) {
-    shuffleInPlace(combined, rng);
-  }
-
-  return {
-    X: combined.map(({ x }) => x),
-    Y: combined.map(({ y }) => y),
-  };
-};