xy-scale 1.4.32 → 1.4.34

package/dist/xy-scale.min.js

@@ -1 +1 @@
-var XY_Scale;(()=>{"use strict";var e={d:(t,r)=>{for(var n in r)e.o(r,n)&&!e.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:r[n]})},o:(e,t)=>Object.prototype.hasOwnProperty.call(e,t),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},t={};e.r(t),e.d(t,{arrayToTimesteps:()=>i,parseProductionX:()=>s,parseTrainingXY:()=>a});const r=e=>null==e||!Number.isFinite(e),n=e=>{const t=[...e];for(let e=t.length-1;e>0;e--){const r=Math.floor(Math.random()*(e+1));[t[e],t[r]]=[t[r],t[e]]}return t},o=(e,{min:t=-1/0,max:r=1/0},n)=>{if(!Array.isArray(e))throw new Error(`Invalid property. "${n}" expected an array.`);if(e.length<t)throw new Error(`Invalid property value. Array "${n}" expected at least ${r} items.`);if(e.length>r)throw new Error(`Invalid property value. Array "${n}" expected at max ${r} items.`);return!0},l=e=>{for(const[t,r]of Object.entries(e)){if("number"==typeof r&&Number.isNaN(r))throw new Error(`Invalid value at index 0 property "${t}": value is "${r}". Expected a numeric value.`);if(null===r)throw new Error(`Invalid value at index 0 property "${t}": value is "${r}".`)}return!0},a=({arrObj:e=[],trainingSplit:t=.8,yCallbackFunc:a=e=>e,xCallbackFunc:s=e=>e,validateRows:i=()=>!0,shuffle:c=!1,balancing:u="",state:h={}})=>{let f=[],p=[];const y=[];o(e,{min:5},"parseTrainingXY"),l(e[0]);for(let t=0;t<e.length;t++){if(!i({objRow:e,index:t,state:h}))continue;const r=s({objRow:e,index:t,state:h}),n=a({objRow:e,index:t,state:h});null!=r&&null!=n&&(f.push(r),p.push(n),y.push(t))}if(c){const e=new Array(f.length);for(let t=0;t<f.length;t++)e[t]={x:f[t],y:p[t],sourceIndex:y[t]};const t=n(e);f=new Array(t.length),p=new Array(t.length);for(let e=0;e<t.length;e++)f[e]=t[e].x,p[e]=t[e].y,y[e]=t[e].sourceIndex}const d=f.length,g=p.length,w=d?Object.keys(f[0]).filter((e=>"tempIdx"!==e)):[],b=g?Object.keys(p[0]).filter((e=>"tempIdx"!==e)):[],m=new Array(d),x=new Array(g),v={keyNames:w},j={keyNames:b};for(let e=0;e<d;e++){const t=f[e],n=y[e],o=new Array(w.length);for(let e=0;e<w.length;e++){const l=w[e],a=t[l];if(r(a))throw new Error(`Invalid property value (${a}) returned from "xCallbackFunc" on index "${n}" property "${l}".`);o[e]=a}m[e]=o}for(let e=0;e<g;e++){const t=p[e],r=new Array(b.length);for(let e=0;e<b.length;e++)r[e]=t[b[e]];x[e]=r}const A=Math.floor(m.length*t);let O=m.slice(0,A),X=x.slice(0,A),$=m.slice(A),E=x.slice(A);if(u){let e;if("oversample"===u)e=((e,t)=>{const r={},n={};t.forEach(((o,l)=>{r[o]||(r[o]=0,n[o]=[]),r[o]++,n[o].push([e[l],t[l]])}));const o=Math.max(...Object.values(r)),l=[],a=[];return Object.keys(n).forEach((e=>{const t=n[e],r=t.length;for(let e=0;e<o;e++){const n=t[e%r];l.push(n[0]),a.push(n[1])}})),{X:l,Y:a}})(O,X),O=e.X,X=e.Y;else{if("undersample"!==u)throw Error('balancing argument only accepts "", "oversample" and "undersample". Defaults to "".');e=((e,t)=>{const r={},n={};t.forEach(((o,l)=>{r[o]||(r[o]=0,n[o]=[]),r[o]++,n[o].push([e[l],t[l]])}));const o=Math.min(...Object.values(r)),l=[],a=[];return Object.keys(n).forEach((e=>{const t=n[e];for(let e=0;e<o;e++){const r=t[e];l.push(r[0]),a.push(r[1])}})),{X:l,Y:a}})(O,X),O=e.X,X=e.Y}}return{trainX:O,trainY:X,testX:$,testY:E,configX:v,configY:j}},s=({arrObj:e=[],xCallbackFunc:t=e=>e,validateRows:a=()=>!0,shuffle:s=!1,state:i={}})=>{let c=[],u=[];o(e,{min:5},"parseProductionX"),l(e[0]);for(let r=0;r<e.length;r++){if(!a({objRow:e,index:r,state:i}))continue;const n=t({objRow:e,index:r,state:i});null!=n&&!1!==n&&(c.push(n),u.push(r))}if(s){const e=new Array(c.length);for(let t=0;t<c.length;t++)e[t]={x:c[t],sourceIndex:u[t]};const t=n(e);c=new Array(t.length),u=new Array(t.length);for(let e=0;e<t.length;e++)c[e]=t[e].x,u[e]=t[e].sourceIndex}const h=c.length,f=h?Object.keys(c[0]).filter((e=>"tempIdx"!==e)):[],p=new Array(h),y={keyNames:f};for(let e=0;e<h;e++){const t=c[e],n=u[e],o=new Array(f.length);for(let e=0;e<f.length;e++){const l=f[e],a=t[l];if(r(a))throw new Error(`Invalid property value (${a}) returned from "xCallbackFunc" on index "${n}" property "${l}".`);o[e]=a}p[e]=o}return{X:p,configX:y}},i=(e,t)=>{if(0===t)return e;if(t<0)throw new Error("timeSteps must be greater than 0");const r=[];for(let n=0;n<=e.length-t;n++)r.push(e.slice(n,n+t));return r};XY_Scale=t})();
+var XY_Scale;(()=>{"use strict";var e={d:(r,t)=>{for(var n in t)e.o(t,n)&&!e.o(r,n)&&Object.defineProperty(r,n,{enumerable:!0,get:t[n]})},o:(e,r)=>Object.prototype.hasOwnProperty.call(e,r),r:e=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(e,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(e,"__esModule",{value:!0})}},r={};e.r(r),e.d(r,{arrayToTimesteps:()=>A,parseProductionX:()=>v,parseTrainingXY:()=>$});const t=e=>null==e||!Number.isFinite(e),n=e=>{const r=[...e];for(let e=r.length-1;e>0;e--){const t=Math.floor(Math.random()*(e+1));[r[e],r[t]]=[r[t],r[e]]}return r},a=e=>"string"==typeof e||"boolean"==typeof e||("number"==typeof e?Number.isFinite(e):!!Array.isArray(e)&&e.every(a)),o=({random:e,seed:r}={})=>"function"==typeof e?e:Number.isInteger(r)?(e=>{let r=e>>>0;return()=>{r+=1831565813;let e=Math.imul(r^r>>>15,1|r);return e^=e+Math.imul(e^e>>>7,61|e),((e^e>>>14)>>>0)/4294967296}})(r):Math.random,s=(e,r=Math.random)=>{for(let t=e.length-1;t>0;t--){const n=Math.floor(r()*(t+1));[e[t],e[n]]=[e[n],e[t]]}return e},l=(e,r,t=Math.random)=>{if(r>e.length)throw new Error("Cannot sample more items than available without replacement.");const n=[...e];return s(n,t),n.slice(0,r)},i=(e,r,t=Math.random)=>{if(0===e.length)throw new Error("Cannot sample from an empty array.");const n=[];for(let a=0;a<r;a++){const r=Math.floor(t()*e.length);n.push(e[r])}return n},c=(e,r)=>r?structuredClone(e):e,h=(e,r,{cloneX:t=!1}={})=>{((e,r)=>{if(!Array.isArray(e)||!Array.isArray(r))throw new Error("X and Y must be arrays.");if(e.length!==r.length)throw new Error("X and Y must have the same length.");if(0===e.length)throw new Error("X and Y cannot be empty.")})(e,r);const n=new Map;return r.forEach(((r,o)=>{const s=(e=>{if(!a(e))throw new Error("Invalid Y label. Allowed types: finite numbers, strings, booleans, or nested arrays of those.");return JSON.stringify(e)})(r);n.has(s)||n.set(s,[]),n.get(s).push({x:c(e[o],t),y:r})})),n},u=(e,{min:r=-1/0,max:t=1/0},n)=>{if(!Array.isArray(e))throw new Error(`Invalid property. "${n}" expected an array.`);if(e.length<r)throw new Error(`Invalid property value. Array "${n}" expected at least ${t} items.`);if(e.length>t)throw new Error(`Invalid property value. Array "${n}" expected at max ${t} items.`);return!0},d=e=>{for(const[r,t]of Object.entries(e)){if("number"==typeof t&&Number.isNaN(t))throw new Error(`Invalid value at index 0 property "${r}": value is "${t}". Expected a numeric value.`);if(null===t)throw new Error(`Invalid value at index 0 property "${r}": value is "${t}".`)}return!0},f=e=>{return Array.isArray(e)?"array":(r=e,"[object Object]"===Object.prototype.toString.call(r)?"object":typeof e);var r},p=e=>Object.keys(e).filter((e=>"tempIdx"!==e)),y=({parentPath:e="",key:r,isArrayParent:t=!1})=>`${e}${t?`[${r}]`:e?`.${r}`:`${r}`}`,g=({rowLabel:e,sourceIndex:r,path:t="",detail:n,strictFlagName:a})=>new Error(`${e} schema error at index "${r}"${t?` path "${t}"`:""}. ${n} Set "${a}" to false to disable this validation.`),m=({referenceRow:e,currentRow:r,rowLabel:t,currentIndex:n,strictFlagName:a})=>{const o=f(e),s=f(r);if(o!==s)throw g({rowLabel:t,sourceIndex:n,detail:`Expected row type "${o}" based on the first parsed ${t} row, but got "${s}".`,strictFlagName:a});if("array"!==o&&"object"!==o)throw g({rowLabel:t,sourceIndex:n,detail:`Parsed ${t} rows must be arrays or plain objects.`,strictFlagName:a});const l=p(e),i=p(r),c=new Set(l),h=new Set(i),u=Array.isArray(e);for(let e=0;e<l.length;e++){const r=l[e];if(!h.has(r))throw g({rowLabel:t,sourceIndex:n,path:y({key:r,isArrayParent:u}),detail:`Missing required ${u?"index":"property"} "${r}" found in the first parsed ${t} row.`,strictFlagName:a})}for(let e=0;e<i.length;e++){const r=i[e];if(!c.has(r))throw g({rowLabel:t,sourceIndex:n,path:y({key:r,isArrayParent:u}),detail:`Unexpected ${u?"index":"property"} "${r}" not present in the first parsed ${t} row.`,strictFlagName:a})}return l},w=e=>Array.isArray(e)?"array":typeof e,b=({referenceValue:e,currentValue:r,sourceIndex:t,path:n,strictFlagName:a})=>{const o=w(e),s=w(r);if(o!==s)throw g({rowLabel:"Y",sourceIndex:t,path:n,detail:`Expected type "${o}" based on the first parsed Y row, but got "${s}".`,strictFlagName:a});if("array"!==o){if("number"!==o&&"boolean"!==o&&"string"!==o)throw g({rowLabel:"Y",sourceIndex:t,path:n,detail:`Unsupported Y value type "${o}". Y values must be numbers, booleans, strings, or nested arrays of those types.`,strictFlagName:a})}else{if(e.length!==r.length)throw g({rowLabel:"Y",sourceIndex:t,path:n,detail:`Expected array length "${e.length}" based on the first parsed Y row, but got "${r.length}".`,strictFlagName:a});for(let o=0;o<e.length;o++)b({referenceValue:e[o],currentValue:r[o],sourceIndex:t,path:y({parentPath:n,key:o,isArrayParent:!0}),strictFlagName:a})}},x=({rows:e,sourceIndexes:r,strictFlagName:t})=>{if(!e.length)return;const n=e[0],a=(e,r)=>{m({referenceRow:n,currentRow:e,rowLabel:"X",currentIndex:r,strictFlagName:t})};e.length>1&&a(e[e.length-1],r[e.length-1]);for(let t=0;t<e.length;t++)a(e[t],r[t])},$=({arrObj:e=[],trainingSplit:r=.8,yCallbackFunc:a=e=>e,xCallbackFunc:f=e=>e,validateRows:g=()=>!0,shuffle:w=!1,balancing:$="",strictXSchema:v=!0,strictYSchema:A=!0,state:I={}})=>{let N=[],X=[];const F=[];u(e,{min:5},"parseTrainingXY"),d(e[0]);for(let r=0;r<e.length;r++){if(!g({objRow:e,index:r,state:I}))continue;const t=f({objRow:e,index:r,state:I}),n=a({objRow:e,index:r,state:I});null!=t&&null!=n&&(N.push(t),X.push(n),F.push(r))}if(v&&x({rows:N,sourceIndexes:F,strictFlagName:"strictXSchema"}),A&&(({rows:e,sourceIndexes:r,strictFlagName:t})=>{if(!e.length)return;const n=e[0],a=(e,r)=>{const a=m({referenceRow:n,currentRow:e,rowLabel:"Y",currentIndex:r,strictFlagName:t}),o=Array.isArray(n);for(let s=0;s<a.length;s++){const l=a[s],i=y({key:l,isArrayParent:o});b({referenceValue:n[l],currentValue:e[l],sourceIndex:r,path:i,strictFlagName:t})}};e.length>1&&a(e[e.length-1],r[e.length-1]);for(let t=0;t<e.length;t++)a(e[t],r[t])})({rows:X,sourceIndexes:F,strictFlagName:"strictYSchema"}),w){const e=new Array(N.length);for(let r=0;r<N.length;r++)e[r]={x:N[r],y:X[r],sourceIndex:F[r]};const r=n(e);N=new Array(r.length),X=new Array(r.length);for(let e=0;e<r.length;e++)N[e]=r[e].x,X[e]=r[e].y,F[e]=r[e].sourceIndex}const Y=N.length,E=X.length,S=Y?p(N[0]):[],j=E?p(X[0]):[],M=new Array(Y),R=new Array(E),k={keyNames:S},P={keyNames:j};for(let e=0;e<Y;e++){const r=N[e],n=F[e],a=new Array(S.length);for(let e=0;e<S.length;e++){const o=S[e],s=r[o];if(t(s))throw new Error(`Invalid property value (${s}) returned from "xCallbackFunc" on index "${n}" property "${o}".`);a[e]=s}M[e]=a}for(let e=0;e<E;e++){const r=X[e],t=new Array(j.length);for(let e=0;e<j.length;e++)t[e]=r[j[e]];R[e]=t}const O=Math.floor(M.length*r);let L=M.slice(0,O),C=R.slice(0,O),T=M.slice(O),V=R.slice(O);if($){let e;if("oversample"===$)e=((e,r,t={})=>{const{random:n,seed:a,shuffleResult:l=!0,cloneX:u=!1}=t,d=o({random:n,seed:a}),f=h(e,r,{cloneX:u}),p=[...f.values()].map((e=>e.length)),y=Math.max(...p),g=[];for(const e of f.values()){const r=[...e],t=y-r.length,n=t>0?i(e,t,d).map((e=>({x:c(e.x,u),y:e.y}))):[];g.push(...r,...n)}return l&&s(g,d),{X:g.map((({x:e})=>e)),Y:g.map((({y:e})=>e))}})(L,C),L=e.X,C=e.Y;else{if("undersample"!==$)throw Error('balancing argument only accepts "", "oversample" and "undersample". Defaults to "".');e=((e,r,t={})=>{const{random:n,seed:a,shuffleResult:i=!0,cloneX:u=!1}=t,d=o({random:n,seed:a}),f=h(e,r,{cloneX:u}),p=[...f.values()].map((e=>e.length)),y=Math.min(...p),g=[];for(const e of f.values()){const r=l(e,y,d).map((e=>({x:c(e.x,u),y:e.y})));g.push(...r)}return i&&s(g,d),{X:g.map((({x:e})=>e)),Y:g.map((({y:e})=>e))}})(L,C),L=e.X,C=e.Y}}return{trainX:L,trainY:C,testX:T,testY:V,configX:k,configY:P}},v=({arrObj:e=[],xCallbackFunc:r=e=>e,validateRows:a=()=>!0,shuffle:o=!1,strictXSchema:s=!0,state:l={}})=>{let i=[],c=[];u(e,{min:5},"parseProductionX"),d(e[0]);for(let t=0;t<e.length;t++){if(!a({objRow:e,index:t,state:l}))continue;const n=r({objRow:e,index:t,state:l});null!=n&&!1!==n&&(i.push(n),c.push(t))}if(s&&x({rows:i,sourceIndexes:c,strictFlagName:"strictXSchema"}),o){const e=new Array(i.length);for(let r=0;r<i.length;r++)e[r]={x:i[r],sourceIndex:c[r]};const r=n(e);i=new Array(r.length),c=new Array(r.length);for(let e=0;e<r.length;e++)i[e]=r[e].x,c[e]=r[e].sourceIndex}const h=i.length,f=h?p(i[0]):[],y=new Array(h),g={keyNames:f};for(let e=0;e<h;e++){const r=i[e],n=c[e],a=new Array(f.length);for(let e=0;e<f.length;e++){const o=f[e],s=r[o];if(t(s))throw new Error(`Invalid property value (${s}) returned from "xCallbackFunc" on index "${n}" property "${o}".`);a[e]=s}y[e]=a}return{X:y,configX:g}},A=(e,r)=>{if(0===r)return e;if(r<0)throw new Error("timeSteps must be greater than 0");const t=[];for(let n=0;n<=e.length-r;n++)t.push(e.slice(n,n+r));return t};XY_Scale=r})();

package/package.json

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

package/src/balancing.js

@@ -1,71 +1,187 @@
-export const oversampleXY = (X, Y) => {
-
-    const labelCounts = {};
-    const data = {};
-  
-    // Count occurrences of each label and group by label
-    Y.forEach((label, i) => {
-      if (!labelCounts[label]) {
-        labelCounts[label] = 0;
-        data[label] = [];
-      }
-      labelCounts[label]++;
-      data[label].push([X[i], Y[i]]);
-    });
-  
-    // Find the max label count
-    const maxCount = Math.max(...Object.values(labelCounts));
-  
-    const oversampledX = [];
-    const oversampledY = [];
-  
-    // Oversample each label to match the max count
-    Object.keys(data).forEach(label => {
-      const samples = data[label];
-      const numSamples = samples.length;
-  
-      for (let i = 0; i < maxCount; i++) {
-        const sample = samples[i % numSamples]; // Cycle through samples
-        oversampledX.push(sample[0]);
-        oversampledY.push(sample[1]);
-      }
-    });
-  
-    return { X: oversampledX, Y: oversampledY };
+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);
   }
-  
-
-export const undersampleXY = (X, Y) => {
-
-    const labelCounts = {};
-    const data = {};
-  
-    // Count occurrences of each label and group by label
-    Y.forEach((label, i) => {
-      if (!labelCounts[label]) {
-        labelCounts[label] = 0;
-        data[label] = [];
-      }
-      labelCounts[label]++;
-      data[label].push([X[i], Y[i]]);
-    });
-  
-    // Find the minimum label count
-    const minCount = Math.min(...Object.values(labelCounts));
-  
-    const undersampledX = [];
-    const undersampledY = [];
-  
-    // Undersample each label to match the minimum count
-    Object.keys(data).forEach(label => {
-      const samples = data[label];
-      for (let i = 0; i < minCount; i++) {
-        const sample = samples[i]; // Use first minCount samples
-        undersampledX.push(sample[0]);
-        undersampledY.push(sample[1]);
-      }
+
+  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 { X: undersampledX, Y: undersampledY };
+  });
+
+  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),
+  };
+};

package/src/datasets.js

@@ -4,6 +4,229 @@ import { validateFirstRow, validateArray } from "./validators.js";
 
 // ADD A PARAM max correlation that will measure the correlation between variables if defined
 
+const isPlainObject = value =>
+    Object.prototype.toString.call(value) === '[object Object]';
+
+const getRowKind = row => {
+    if (Array.isArray(row)) return 'array';
+    if (isPlainObject(row)) return 'object';
+    return typeof row;
+};
+
+const getComparableKeys = row =>
+    Object.keys(row).filter(key => key !== 'tempIdx');
+
+const buildPath = ({ parentPath = '', key, isArrayParent = false }) => {
+    const nextPart = isArrayParent ? `[${key}]` : (parentPath ? `.${key}` : `${key}`);
+    return `${parentPath}${nextPart}`;
+};
+
+const createStrictSchemaError = ({
+    rowLabel,
+    sourceIndex,
+    path = '',
+    detail,
+    strictFlagName,
+}) => {
+    const pathText = path ? ` path "${path}"` : '';
+    return new Error(
+        `${rowLabel} schema error at index "${sourceIndex}"${pathText}. ${detail} Set "${strictFlagName}" to false to disable this validation.`
+    );
+};
+
+const assertSameTopLevelSchema = ({
+    referenceRow,
+    currentRow,
+    rowLabel,
+    currentIndex,
+    strictFlagName,
+}) => {
+    const referenceKind = getRowKind(referenceRow);
+    const currentKind = getRowKind(currentRow);
+
+    if (referenceKind !== currentKind) {
+        throw createStrictSchemaError({
+            rowLabel,
+            sourceIndex: currentIndex,
+            detail: `Expected row type "${referenceKind}" based on the first parsed ${rowLabel} row, but got "${currentKind}".`,
+            strictFlagName,
+        });
+    }
+
+    if (referenceKind !== 'array' && referenceKind !== 'object') {
+        throw createStrictSchemaError({
+            rowLabel,
+            sourceIndex: currentIndex,
+            detail: `Parsed ${rowLabel} rows must be arrays or plain objects.`,
+            strictFlagName,
+        });
+    }
+
+    const referenceKeys = getComparableKeys(referenceRow);
+    const currentKeys = getComparableKeys(currentRow);
+
+    const referenceKeySet = new Set(referenceKeys);
+    const currentKeySet = new Set(currentKeys);
+    const isArrayRow = Array.isArray(referenceRow);
+
+    for (let i = 0; i < referenceKeys.length; i++) {
+        const key = referenceKeys[i];
+
+        if (!currentKeySet.has(key)) {
+            throw createStrictSchemaError({
+                rowLabel,
+                sourceIndex: currentIndex,
+                path: buildPath({ key, isArrayParent: isArrayRow }),
+                detail: `Missing required ${isArrayRow ? 'index' : 'property'} "${key}" found in the first parsed ${rowLabel} row.`,
+                strictFlagName,
+            });
+        }
+    }
+
+    for (let i = 0; i < currentKeys.length; i++) {
+        const key = currentKeys[i];
+
+        if (!referenceKeySet.has(key)) {
+            throw createStrictSchemaError({
+                rowLabel,
+                sourceIndex: currentIndex,
+                path: buildPath({ key, isArrayParent: isArrayRow }),
+                detail: `Unexpected ${isArrayRow ? 'index' : 'property'} "${key}" not present in the first parsed ${rowLabel} row.`,
+                strictFlagName,
+            });
+        }
+    }
+
+    return referenceKeys;
+};
+
+const getYValueKind = value => {
+    if (Array.isArray(value)) return 'array';
+    return typeof value;
+};
+
+const assertSameYValueSchema = ({
+    referenceValue,
+    currentValue,
+    sourceIndex,
+    path,
+    strictFlagName,
+}) => {
+    const referenceKind = getYValueKind(referenceValue);
+    const currentKind = getYValueKind(currentValue);
+
+    if (referenceKind !== currentKind) {
+        throw createStrictSchemaError({
+            rowLabel: 'Y',
+            sourceIndex,
+            path,
+            detail: `Expected type "${referenceKind}" based on the first parsed Y row, but got "${currentKind}".`,
+            strictFlagName,
+        });
+    }
+
+    if (referenceKind === 'array') {
+        if (referenceValue.length !== currentValue.length) {
+            throw createStrictSchemaError({
+                rowLabel: 'Y',
+                sourceIndex,
+                path,
+                detail: `Expected array length "${referenceValue.length}" based on the first parsed Y row, but got "${currentValue.length}".`,
+                strictFlagName,
+            });
+        }
+
+        for (let i = 0; i < referenceValue.length; i++) {
+            assertSameYValueSchema({
+                referenceValue: referenceValue[i],
+                currentValue: currentValue[i],
+                sourceIndex,
+                path: buildPath({ parentPath: path, key: i, isArrayParent: true }),
+                strictFlagName,
+            });
+        }
+
+        return;
+    }
+
+    if (
+        referenceKind !== 'number' &&
+        referenceKind !== 'boolean' &&
+        referenceKind !== 'string'
+    ) {
+        throw createStrictSchemaError({
+            rowLabel: 'Y',
+            sourceIndex,
+            path,
+            detail: `Unsupported Y value type "${referenceKind}". Y values must be numbers, booleans, strings, or nested arrays of those types.`,
+            strictFlagName,
+        });
+    }
+};
+
+const validateStrictXRows = ({ rows, sourceIndexes, strictFlagName }) => {
+    if (!rows.length) return;
+
+    const referenceRow = rows[0];
+
+    const compareRow = (currentRow, currentIndex) => {
+        assertSameTopLevelSchema({
+            referenceRow,
+            currentRow,
+            rowLabel: 'X',
+            currentIndex,
+            strictFlagName,
+        });
+    };
+
+    if (rows.length > 1) {
+        compareRow(rows[rows.length - 1], sourceIndexes[rows.length - 1]);
+    }
+
+    for (let i = 0; i < rows.length; i++) {
+        compareRow(rows[i], sourceIndexes[i]);
+    }
+};
+
+const validateStrictYRows = ({ rows, sourceIndexes, strictFlagName }) => {
+    if (!rows.length) return;
+
+    const referenceRow = rows[0];
+
+    const compareRow = (currentRow, currentIndex) => {
+        const referenceKeys = assertSameTopLevelSchema({
+            referenceRow,
+            currentRow,
+            rowLabel: 'Y',
+            currentIndex,
+            strictFlagName,
+        });
+
+        const isArrayRow = Array.isArray(referenceRow);
+
+        for (let i = 0; i < referenceKeys.length; i++) {
+            const key = referenceKeys[i];
+            const path = buildPath({ key, isArrayParent: isArrayRow });
+
+            assertSameYValueSchema({
+                referenceValue: referenceRow[key],
+                currentValue: currentRow[key],
+                sourceIndex: currentIndex,
+                path,
+                strictFlagName,
+            });
+        }
+    };
+
+    if (rows.length > 1) {
+        compareRow(rows[rows.length - 1], sourceIndexes[rows.length - 1]);
+    }
+
+    for (let i = 0; i < rows.length; i++) {
+        compareRow(rows[i], sourceIndexes[i]);
+    }
+};
+
 export const parseTrainingXY = ({
     arrObj = [], // array of objects
     trainingSplit = 0.8, // numeric float between 0.01 and 0.99
@@ -12,6 +235,8 @@ export const parseTrainingXY = ({
     validateRows = () => true, // accepted callback functions
     shuffle = false, // only booleans
     balancing = '', // accepted '', 'oversample' or 'undersample'
+    strictXSchema = true,
+    strictYSchema = true,
     state = {}, // accepted object or classes
 }) => {
     let X = [];
@@ -21,7 +246,6 @@ export const parseTrainingXY = ({
     validateArray(arrObj, { min: 5 }, 'parseTrainingXY');
     validateFirstRow(arrObj[0]);
 
-    // if parsedX or parsedY is undefined/null the current row will be excluded from training
     for (let x = 0; x < arrObj.length; x++) {
         if (!validateRows({ objRow: arrObj, index: x, state })) continue;
 
@@ -40,6 +264,22 @@ export const parseTrainingXY = ({
         }
     }
 
+    if (strictXSchema) {
+        validateStrictXRows({
+            rows: X,
+            sourceIndexes,
+            strictFlagName: 'strictXSchema',
+        });
+    }
+
+    if (strictYSchema) {
+        validateStrictYRows({
+            rows: Y,
+            sourceIndexes,
+            strictFlagName: 'strictYSchema',
+        });
+    }
+
     if (shuffle) {
         const merged = new Array(X.length);
 
@@ -66,8 +306,8 @@ export const parseTrainingXY = ({
     const xLen = X.length;
     const yLen = Y.length;
 
-    const xKeys = xLen ? Object.keys(X[0]).filter(key => key !== 'tempIdx') : [];
-    const yKeys = yLen ? Object.keys(Y[0]).filter(key => key !== 'tempIdx') : [];
+    const xKeys = xLen ? getComparableKeys(X[0]) : [];
+    const yKeys = yLen ? getComparableKeys(Y[0]) : [];
 
     const flatX = new Array(xLen);
     const flatY = new Array(yLen);
@@ -150,6 +390,7 @@ export const parseProductionX = ({
     xCallbackFunc = row => row,
     validateRows = () => true,
     shuffle = false,
+    strictXSchema = true,
     state = {},
 }) => {
     let X = [];
@@ -169,6 +410,14 @@ export const parseProductionX = ({
         }
     }
 
+    if (strictXSchema) {
+        validateStrictXRows({
+            rows: X,
+            sourceIndexes,
+            strictFlagName: 'strictXSchema',
+        });
+    }
+
     if (shuffle) {
         const merged = new Array(X.length);
 
@@ -191,7 +440,7 @@ export const parseProductionX = ({
     }
 
     const xLen = X.length;
-    const xKeys = xLen ? Object.keys(X[0]).filter(key => key !== 'tempIdx') : [];
+    const xKeys = xLen ? getComparableKeys(X[0]) : [];
     const flatX = new Array(xLen);
 
     const configX = {