xy-scale 1.3.2 → 1.3.4

package/dist/xy-scale.min.js

@@ -1 +1 @@
-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:()=>p,parseProductionX:()=>u,parseTrainingXY:()=>i});const t=({arrObj:e,repeat:r={},minmaxRange:t=[0,1],groups:i={},prevConfig:u=null,customMinMaxRanges:p=null})=>{const m=[...e],f=m.length,l=m[0],c="object"==typeof p&&null!==p;if(0===f)return{scaledOutput:[],scaledConfig:{}};let g={};const h=u&&o(u);if(h)s(u,{minmaxRange:t,repeat:r,groups:i,firstRow:l}),g={...u};else{const e=Object.keys(l),n=e.map((e=>r.hasOwnProperty(e)?Math.max(r[e],1):1)),a=n.reduce(((e,r)=>e+r),0);g={arrObjLen:f,rangeMin:t[0],rangeMax:t[1],inputTypes:{},min:{},max:{},groupMinMax:{},repeat:r,groups:i,inputKeyNames:e,outputKeyNames:new Array(a),repeatedKeyNames:n};let s=0;for(let e=0;e<g.inputKeyNames.length;e++)for(let r=0;r<g.repeatedKeyNames[e];r++)g.outputKeyNames[s++]=g.inputKeyNames[e];o(g)}n(g.groups);const y=["number","boolean"];for(const e of g.inputKeyNames){const r=typeof l[e],t=a(e,g.groups);if(!y.includes(r))throw new Error(`Invalid input type "${r}" provided for key "${e}". Only accepting `);if(h){if(!g.inputTypes.hasOwnProperty(e))throw new Error(`Error: A new unknown inputType property "${e}" found.`);if(g.inputTypes[e]!==r)throw new Error(`Error: Current inputType of property "${e}" is not the same as in the prevConfig inputType.`)}else g.inputTypes[e]=r,c&&p.hasOwnProperty(e)?t?g.groupMinMax[t]=p[e]:(g.min[e]=p[e].min,g.max[e]=p[e].max):t?g.groupMinMax[t]={min:1/0,max:-1/0}:(g.min[e]=1/0,g.max[e]=-1/0)}for(const e of m)for(const r of g.inputKeyNames){let t=e[r];"boolean"===g.inputTypes[r]&&(e[r]=Number(t));const n=a(r,g.groups);(!1===c||c&&!p.hasOwnProperty(r))&&(n?(g.groupMinMax[n].min=Math.min(g.groupMinMax[n].min,t),g.groupMinMax[n].max=Math.max(g.groupMinMax[n].max,t)):(g.min[r]=Math.min(g.min[r],t),g.max[r]=Math.max(g.max[r],t)))}const w=new Array(f);for(let e=0;e<f;e++){const r=m[e],t=new Array(g.outputKeyNames.length);let n=0;for(let e=0;e<g.inputKeyNames.length;e++){const o=g.inputKeyNames[e],s=r[o],i=a(o,g.groups);let u,p;i?(u=g.groupMinMax[i].min,p=g.groupMinMax[i].max):(u=g.min[o],p=g.max[o]);const m=p!==u?g.rangeMin+(s-u)/(p-u)*(g.rangeMax-g.rangeMin):g.rangeMin,f=g.repeatedKeyNames[e];for(let e=0;e<f;e++)t[n++]=m}w[e]=t}return{scaledOutput:w,scaledConfig:g}},n=e=>{const r=new Set,t=[];for(const[n,a]of Object.entries(e))r.add(n),t.push(n),a.forEach((e=>{r.add(e),t.push(e)}));if(r.size!==t.length)throw new Error("Duplicate value found between properties in validateUniqueProperties function.")},a=(e,r)=>{for(const[t,n]of Object.entries(r))if(n.includes(e))return t;return null},o=e=>{if(!e)return!1;const r=["rangeMin","rangeMax","inputTypes","min","max","groupMinMax","repeat","groups","inputKeyNames","outputKeyNames","repeatedKeyNames"];for(const t of r)if(!e.hasOwnProperty(t))throw new Error(`Missing key "${t}" in config.`);const{rangeMin:t,rangeMax:n,inputTypes:a,min:o,max:s,groupMinMax:i,repeat:u,groups:p,inputKeyNames:m,outputKeyNames:f,repeatedKeyNames:l}=e;if("number"!=typeof t||"number"!=typeof n)throw new Error("rangeMin and rangeMax must be numbers.");if(t>=n)throw new Error("rangeMin must be less than rangeMax.");const c=e=>"object"==typeof e&&null!==e&&!Array.isArray(e);if(!c(a))throw new Error("inputTypes must be an object.");if(!c(o))throw new Error("min must be an object.");if(!c(s))throw new Error("max must be an object.");if(!c(i))throw new Error("groupMinMax must be an object.");if(!c(u))throw new Error("repeat must be an object.");if(!c(p))throw new Error("groups must be an object.");if(!Array.isArray(m))throw new Error("inputKeyNames must be an array.");if(!Array.isArray(f))throw new Error("outputKeyNames must be an array.");if(!Array.isArray(l))throw new Error("repeatedKeyNames must be an array.");return!0},s=(e,{minmaxRange:r,repeat:t,groups:n,firstRow:a})=>{if(e.rangeMin!==r[0]||e.rangeMax!==r[1])throw new Error('"prevConfig.minmaxRange" is not equal "minmaxRange".');if(JSON.stringify(e.inputKeyNames)!==JSON.stringify(Object.keys(a)))throw new Error('"prevConfig.inputKeyNames" structure does not match "Object.keys(firstRow)" structure. The order of keys is important.');if(JSON.stringify(e.repeat)!==JSON.stringify(t))throw new Error('"prevConfig.repeat" structure does not match "repeat" structure. The order of keys is important.');if(JSON.stringify(e.groups)!==JSON.stringify(n))throw new Error('"prevConfig.groups" structure does not match "groups" structure. The order of keys is important.');return!0},i=({arrObj:e,trainingSplit:r=.8,repeat:n,yCallbackFunc:a=e=>e,xCallbackFunc:o=e=>e,validateRows:s=()=>!0,groups:i,shuffle:u=!1,minmaxRange:p,balancing:m="",state:f={},customMinMaxRanges:l})=>{let c=[],g=[];for(let r=0;r<e.length;r++){if(!s({objRow:e,index:r,state:f}))continue;const t=o({objRow:e,index:r,state:f}),n=a({objRow:e,index:r,state:f});null!=t&&null!=n&&(c.push(t),g.push(n))}if(u){const{shuffledX:e,shuffledY:r}=((e,r)=>{if(e.length!==r.length)throw new Error("X and Y arrays must have the same length");const t=Array.from({length:e.length},((e,r)=>r));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{shuffledX:t.map((r=>e[r])),shuffledY:t.map((e=>r[e]))}})(c,g);c=e,g=r}let{scaledOutput:h,scaledConfig:y}=t({arrObj:c,repeat:n,groups:i,minmaxRange:p,customMinMaxRanges:l}),{scaledOutput:w,scaledConfig:M}=t({arrObj:g,repeat:n,groups:i,minmaxRange:p,customMinMaxRanges:l});const d=Math.floor(h.length*r);let b=h.slice(0,d),x=w.slice(0,d),O=h.slice(d),j=w.slice(d);if(m){let e;if("oversample"===m)e=((e,r)=>{const t={},n={};r.forEach(((a,o)=>{t[a]||(t[a]=0,n[a]=[]),t[a]++,n[a].push([e[o],r[o]])}));const a=Math.max(...Object.values(t)),o=[],s=[];return Object.keys(n).forEach((e=>{const r=n[e],t=r.length;for(let e=0;e<a;e++){const n=r[e%t];o.push(n[0]),s.push(n[1])}})),{X:o,Y:s}})(b,x),b=e.X,x=e.Y;else{if("undersample"!==m)throw Error('balancing argument only accepts "false", "oversample" and "undersample". Defaults to "false".');e=((e,r)=>{const t={},n={};r.forEach(((a,o)=>{t[a]||(t[a]=0,n[a]=[]),t[a]++,n[a].push([e[o],r[o]])}));const a=Math.min(...Object.values(t)),o=[],s=[];return Object.keys(n).forEach((e=>{const r=n[e];for(let e=0;e<a;e++){const t=r[e];o.push(t[0]),s.push(t[1])}})),{X:o,Y:s}})(b,x),b=e.X,x=e.Y}}return{trainX:b,trainY:x,testX:O,testY:j,configX:y,configY:M}},u=({arrObj:e,repeat:r,xCallbackFunc:n=e=>e,validateRows:a=()=>!0,groups:o,shuffle:s=!1,minmaxRange:i,state:u={},prevConfig:p,customMinMaxRanges:m})=>{let f=[];for(let r=0;r<e.length;r++){if(!a(e[r]))continue;const t=n({objRow:e,index:r,state:u});null!=t&&!1!==t&&f.push(t)}s&&(f=(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})(f));const{scaledOutput:l,scaledConfig:c}=t({arrObj:f,repeat:r,groups:o,minmaxRange:i,prevConfig:p,customMinMaxRanges:m});return{X:l,configX:c}},p=(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})();
+var XY_Scale;(()=>{"use strict";var e={d:(t,n)=>{for(var a in n)e.o(n,a)&&!e.o(t,a)&&Object.defineProperty(t,a,{enumerable:!0,get:n[a]})},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:()=>u,parseProductionX:()=>s,parseTrainingXY:()=>o});const n=({arrObj:e,repeat:t={},minmaxRange:n=[0,1],groups:o={},customMinMaxRanges:s=null,excludes:u=new Set})=>{const i=[...e],l=i.length,c=i[0],p="object"==typeof s&&null!==s;if(0===l)return{scaledOutput:[],scaledConfig:{}};const m=Object.keys(c),f=m.map((e=>t.hasOwnProperty(e)?Math.max(t[e],1):1)),g=f.reduce(((e,t)=>e+t),0),h={arrObjLen:l,rangeMin:n[0],rangeMax:n[1],inputTypes:{},min:{},max:{},groupMinMax:{},repeat:t,groups:o,inputKeyNames:m,outputKeyNames:new Array(g),repeatedKeyNames:f};let d=0;for(let e=0;e<h.inputKeyNames.length;e++)for(let t=0;t<h.repeatedKeyNames[e];t++)h.outputKeyNames[d++]=h.inputKeyNames[e];a(h.groups);const x=["number","boolean"];for(const e of h.inputKeyNames){if(u.has(e)){h.inputTypes[e]="excluded";continue}const t=typeof c[e],n=r(e,h.groups);if(!x.includes(t))throw new Error(`Invalid input type "${t}" provided for key "${e}". Only accepting `);h.inputTypes[e]=t,p&&s.hasOwnProperty(e)?n?h.groupMinMax[n]=s[e]:(h.min[e]=s[e].min,h.max[e]=s[e].max):n?h.groupMinMax[n]={min:1/0,max:-1/0}:(h.min[e]=1/0,h.max[e]=-1/0)}for(const e of i)for(const t of h.inputKeyNames){if("excluded"===h.inputTypes[t])continue;let n=e[t];"boolean"===h.inputTypes[t]&&(e[t]=Number(n));const a=r(t,h.groups);(!1===p||p&&!s.hasOwnProperty(t))&&(a?(h.groupMinMax[a].min=Math.min(h.groupMinMax[a].min,n),h.groupMinMax[a].max=Math.max(h.groupMinMax[a].max,n)):(h.min[t]=Math.min(h.min[t],n),h.max[t]=Math.max(h.max[t],n)))}const M=new Array(l);for(let e=0;e<l;e++){const t=i[e],n=new Array(h.outputKeyNames.length);let a=0;for(let e=0;e<h.inputKeyNames.length;e++){const o=h.inputKeyNames[e],s=t[o];if("excluded"===h.inputTypes[o]){n[a++]=s;continue}const u=r(o,h.groups);let i,l;u?(i=h.groupMinMax[u].min,l=h.groupMinMax[u].max):(i=h.min[o],l=h.max[o]);const c=l!==i?h.rangeMin+(s-i)/(l-i)*(h.rangeMax-h.rangeMin):h.rangeMin,p=h.repeatedKeyNames[e];for(let e=0;e<p;e++)n[a++]=c}M[e]=n}return{scaledOutput:M,scaledConfig:h}},a=e=>{const t=new Set,n=[];for(const[a,r]of Object.entries(e))t.add(a),n.push(a),r.forEach((e=>{t.add(e),n.push(e)}));if(t.size!==n.length)throw new Error("Duplicate value found between properties in validateUniqueProperties function.")},r=(e,t)=>{for(const[n,a]of Object.entries(t))if(a.includes(e))return n;return null},o=({arrObj:e=[],trainingSplit:t=.8,repeat:a={},yCallbackFunc:r=e=>e,xCallbackFunc:o=e=>e,validateRows:s=()=>!0,groups:u={},shuffle:i=!1,minmaxRange:l=[],balancing:c="",state:p={},customMinMaxRanges:m={},excludes:f=[]})=>{let g=[],h=[];for(let t=0;t<e.length;t++){if(!s({objRow:e,index:t,state:p}))continue;const n=o({objRow:e,index:t,state:p}),a=r({objRow:e,index:t,state:p});null!=n&&null!=a&&(g.push(n),h.push(a))}if(i){const{shuffledX:e,shuffledY:t}=((e,t)=>{if(e.length!==t.length)throw new Error("X and Y arrays must have the same length");const n=Array.from({length:e.length},((e,t)=>t));for(let e=n.length-1;e>0;e--){const t=Math.floor(Math.random()*(e+1));[n[e],n[t]]=[n[t],n[e]]}return{shuffledX:n.map((t=>e[t])),shuffledY:n.map((e=>t[e]))}})(g,h);g=e,h=t}const d=new Set(f);let{scaledOutput:x,scaledConfig:M}=n({arrObj:g,repeat:a,groups:u,minmaxRange:l,customMinMaxRanges:m,excludes:d}),{scaledOutput:y,scaledConfig:b}=n({arrObj:h,repeat:a,groups:u,minmaxRange:l,customMinMaxRanges:m,excludes:d});const O=Math.floor(x.length*t);let w=x.slice(0,O),j=y.slice(0,O),R=x.slice(O),v=y.slice(O);if(c){let e;if("oversample"===c)e=((e,t)=>{const n={},a={};t.forEach(((r,o)=>{n[r]||(n[r]=0,a[r]=[]),n[r]++,a[r].push([e[o],t[o]])}));const r=Math.max(...Object.values(n)),o=[],s=[];return Object.keys(a).forEach((e=>{const t=a[e],n=t.length;for(let e=0;e<r;e++){const a=t[e%n];o.push(a[0]),s.push(a[1])}})),{X:o,Y:s}})(w,j),w=e.X,j=e.Y;else{if("undersample"!==c)throw Error('balancing argument only accepts "false", "oversample" and "undersample". Defaults to "false".');e=((e,t)=>{const n={},a={};t.forEach(((r,o)=>{n[r]||(n[r]=0,a[r]=[]),n[r]++,a[r].push([e[o],t[o]])}));const r=Math.min(...Object.values(n)),o=[],s=[];return Object.keys(a).forEach((e=>{const t=a[e];for(let e=0;e<r;e++){const n=t[e];o.push(n[0]),s.push(n[1])}})),{X:o,Y:s}})(w,j),w=e.X,j=e.Y}}return{trainX:w,trainY:j,testX:R,testY:v,configX:M,configY:b}},s=({arrObj:e=[],repeat:t={},xCallbackFunc:a=e=>e,validateRows:r=()=>!0,groups:o={},shuffle:s=!1,minmaxRange:u=[],state:i={},customMinMaxRanges:l,excludes:c=[]})=>{let p=[];for(let t=0;t<e.length;t++){if(!r(e[t]))continue;const n=a({objRow:e,index:t,state:i});null!=n&&!1!==n&&p.push(n)}s&&(p=(e=>{const t=[...e];for(let e=t.length-1;e>0;e--){const n=Math.floor(Math.random()*(e+1));[t[e],t[n]]=[t[n],t[e]]}return t})(p));const{scaledOutput:m,scaledConfig:f}=n({arrObj:p,repeat:t,groups:o,minmaxRange:u,customMinMaxRanges:l,excludes:new Set(c)});return{X:m,configX:f}},u=(e,t)=>{if(0===t)return e;if(t<0)throw new Error("timeSteps must be greater than 0");const n=[];for(let a=0;a<=e.length-t;a++)n.push(e.slice(a,a+t));return n};XY_Scale=t})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xy-scale",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "main": "./index.js",
   "type": "module",
   "scripts": {
@@ -12,6 +12,9 @@
   "description": "This repository contains a JavaScript module designed to facilitate the preprocessing of datasets for machine learning applications. The primary functionality of the module is to scale feature data using normalization or standardization methods, and to parse training and production datasets into appropriate formats for training models.",
   "devDependencies": {
     "@tensorflow/tfjs-node": "^4.22.0",
+    "ml-confusion-matrix": "^2.0.0",
+    "ml-knn": "^3.0.0",
+    "ohlcv-indicators": "^3.4.1",
     "webpack": "^5.96.1",
     "webpack-cli": "^5.1.4"
   },

package/src/datasets.js

@@ -3,18 +3,19 @@ import { arrayShuffle, xyArrayShuffle } from "./utilities.js";
 import { oversampleXY, undersampleXY } from "./balancing.js";
 
 export const parseTrainingXY = ({ 
-    arrObj, 
+    arrObj = [], 
     trainingSplit = 0.8, 
-    repeat, 
+    repeat = {}, 
     yCallbackFunc = row => row, 
     xCallbackFunc = row => row,
     validateRows = () => true,
-    groups,
+    groups = {},
     shuffle = false,
-    minmaxRange,
+    minmaxRange = [],
     balancing = '',
     state = {},
-    customMinMaxRanges
+    customMinMaxRanges = {},
+    excludes = []
 }) => {
     let X = [];
     let Y = [];
@@ -40,15 +41,17 @@ export const parseTrainingXY = ({
         Y = shuffledY
     }
 
+    const excludesSet = new Set(excludes)
+
     let {
         scaledOutput: scaledX, 
         scaledConfig: configX
-    } = scaleArrayObj({arrObj: X, repeat, groups, minmaxRange, customMinMaxRanges})
+    } = scaleArrayObj({arrObj: X, repeat, groups, minmaxRange, customMinMaxRanges, excludes: excludesSet})
 
     let {
         scaledOutput: scaledY,
         scaledConfig: configY,
-    } = scaleArrayObj({arrObj: Y, repeat, groups, minmaxRange, customMinMaxRanges})
+    } = scaleArrayObj({arrObj: Y, repeat, groups, minmaxRange, customMinMaxRanges, excludes: excludesSet})
 
 
 
@@ -98,16 +101,16 @@ export const parseTrainingXY = ({
 
 
 export const parseProductionX = ({ 
-    arrObj, 
-    repeat, 
+    arrObj = [], 
+    repeat = {}, 
     xCallbackFunc = row => row,
     validateRows = () => true,
-    groups,
+    groups = {},
     shuffle = false,
-    minmaxRange,
+    minmaxRange = [],
     state = {},
-    prevConfig,
-    customMinMaxRanges
+    customMinMaxRanges,
+    excludes = []
 }) => {
     let X = [];
 
@@ -127,11 +130,12 @@ export const parseProductionX = ({
         X = arrayShuffle(X)
     }
 
+
     // Scale X
     const {
         scaledOutput: scaledX, 
         scaledConfig: configX
-    } = scaleArrayObj({arrObj: X, repeat, groups, minmaxRange, prevConfig, customMinMaxRanges})
+    } = scaleArrayObj({arrObj: X, repeat, groups, minmaxRange, customMinMaxRanges, excludes: new Set(excludes)})
 
 
     // Split into training and testing sets

package/src/scale.js

@@ -1,4 +1,4 @@
-export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], groups = {}, prevConfig = null, customMinMaxRanges = null }) => {
+export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], groups = {}, customMinMaxRanges = null, excludes = new Set() }) => {
     
     const arrObjClone = [...arrObj]
     const arrObjLen = arrObjClone.length;
@@ -11,51 +11,36 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
             scaledConfig: {}
         };
     }
-
-    let config = {}
-
-    const isValidPrevConfig = prevConfig && validateConfig(prevConfig)
-
-    if(isValidPrevConfig)
-    {
-        validateCurrPrevConfig(prevConfig, {minmaxRange, repeat, groups, firstRow})
-        config = {...prevConfig}
-    }
-    else
-    {
-        const inputKeyNames = Object.keys(firstRow);
-
-        const repeatedKeyNames = inputKeyNames.map(key => {
-            return repeat.hasOwnProperty(key) ? Math.max(repeat[key], 1) : 1;
-        });
     
-        const countRepeatedKeyNames = repeatedKeyNames.reduce((sum, rep) => sum + rep, 0);
-
-        config = {
-            arrObjLen,
-            rangeMin: minmaxRange[0], 
-            rangeMax: minmaxRange[1],
-            inputTypes: {},
-            min: {},
-            max: {},
-            groupMinMax: {},
-            repeat,
-            groups,
-            inputKeyNames,
-            outputKeyNames: new Array(countRepeatedKeyNames),
-            repeatedKeyNames,
-        }
-            
-        let keyNamesIdx = 0;
+    const inputKeyNames = Object.keys(firstRow);
+
+    const repeatedKeyNames = inputKeyNames.map(key => {
+        return repeat.hasOwnProperty(key) ? Math.max(repeat[key], 1) : 1;
+    });
+
+    const countRepeatedKeyNames = repeatedKeyNames.reduce((sum, rep) => sum + rep, 0);
+
+    const config = {
+        arrObjLen,
+        rangeMin: minmaxRange[0], 
+        rangeMax: minmaxRange[1],
+        inputTypes: {},
+        min: {},
+        max: {},
+        groupMinMax: {},
+        repeat,
+        groups,
+        inputKeyNames,
+        outputKeyNames: new Array(countRepeatedKeyNames),
+        repeatedKeyNames
+    }
+        
+    let keyNamesIdx = 0;
 
-        for (let i = 0; i < config.inputKeyNames.length; i++) {
-            for (let w = 0; w < config.repeatedKeyNames[i]; w++) {
-                config.outputKeyNames[keyNamesIdx++] = config.inputKeyNames[i];
-            }
+    for (let i = 0; i < config.inputKeyNames.length; i++) {
+        for (let w = 0; w < config.repeatedKeyNames[i]; w++) {
+            config.outputKeyNames[keyNamesIdx++] = config.inputKeyNames[i];
         }
-
-        validateConfig(config)
-
     }
 
     validateUniqueProperties(config.groups);
@@ -64,6 +49,12 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
 
     for (const key of config.inputKeyNames) {
 
+        if(excludes.has(key))
+        {
+            config.inputTypes[key] = 'excluded'
+            continue
+        }
+
         const firstType = typeof firstRow[key]
         const thisGroup = findGroup(key, config.groups);
 
@@ -73,22 +64,6 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
             throw new Error(`Invalid input type "${firstType}" provided for key "${key}". Only accepting `)
         }
 
-        if(isValidPrevConfig)
-        {
-            if(!config.inputTypes.hasOwnProperty(key))
-            {
-                // If prevConfig is set, no new inputTypes can be introduced
-                throw new Error(`Error: A new unknown inputType property "${key}" found.`)
-            }
-            if(config.inputTypes[key] !== firstType)
-            {
-                 //is prevConfig is set the types of "typeof firstRow[key]" and config.inputTypes[key] must be the same
-                throw new Error(`Error: Current inputType of property "${key}" is not the same as in the prevConfig inputType.`)
-            }
-
-            continue;
-        }
-
         config.inputTypes[key] = firstType;
         
         if(validCustomMinMaxRanges && customMinMaxRanges.hasOwnProperty(key))
@@ -116,6 +91,12 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
 
     for (const obj of arrObjClone) {
         for (const key of config.inputKeyNames) {
+
+            if (config.inputTypes[key] === 'excluded')
+            {
+                continue;
+            }
+
             let value = obj[key];
 
             if (config.inputTypes[key] === 'boolean') {
@@ -139,24 +120,32 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
     }
 
     const scaledOutput = new Array(arrObjLen);
+
+    
     for (let i = 0; i < arrObjLen; i++) {
         const obj = arrObjClone[i];
         const scaledRow = new Array(config.outputKeyNames.length);
         let idx = 0;
 
         for (let j = 0; j < config.inputKeyNames.length; j++) {
-            const key = config.inputKeyNames[j];
-            const value = obj[key];
+            const key = config.inputKeyNames[j]
+            const value = obj[key]
+
+            if (config.inputTypes[key] === 'excluded')
+            {
+                scaledRow[idx++] = value
+                continue
+            }
 
             const thisGroup = findGroup(key, config.groups);
-            let minValue, maxValue;
+            let minValue, maxValue
 
             if (thisGroup) {
-                minValue = config.groupMinMax[thisGroup].min;
-                maxValue = config.groupMinMax[thisGroup].max;
+                minValue = config.groupMinMax[thisGroup].min
+                maxValue = config.groupMinMax[thisGroup].max
             } else {
-                minValue = config.min[key];
-                maxValue = config.max[key];
+                minValue = config.min[key]
+                maxValue = config.max[key]
             }
 
             const scaledValue =
@@ -164,14 +153,14 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
                     ? config.rangeMin + ((value - minValue) / (maxValue - minValue)) * (config.rangeMax - config.rangeMin)
                     : config.rangeMin;
 
-            const rep = config.repeatedKeyNames[j];
+            const rep = config.repeatedKeyNames[j]
 
             for (let w = 0; w < rep; w++) {
-                scaledRow[idx++] = scaledValue;
+                scaledRow[idx++] = scaledValue
             }
             
         }
-        scaledOutput[i] = scaledRow;
+        scaledOutput[i] = scaledRow
     }
 
     
@@ -179,8 +168,8 @@ export const scaleArrayObj = ({ arrObj, repeat = {}, minmaxRange = [0, 1], group
     return {
         scaledOutput,
         scaledConfig: config
-    };
-};
+    }
+}
 
 
 const validateUniqueProperties = obj => {
@@ -294,27 +283,4 @@ const validateConfig = config => {
     }
 
     return true;
-}
-
-const validateCurrPrevConfig = (prevConfig, {minmaxRange, repeat, groups, firstRow}) => {
-
-    if(prevConfig.rangeMin !== minmaxRange[0] || prevConfig.rangeMax !== minmaxRange[1])
-    {
-        throw new Error(`"prevConfig.minmaxRange" is not equal "minmaxRange".`);
-    }
-
-    //it is important o keep the same key order
-    if (JSON.stringify(prevConfig.inputKeyNames) !== JSON.stringify(Object.keys(firstRow))) {
-        throw new Error(`"prevConfig.inputKeyNames" structure does not match "Object.keys(firstRow)" structure. The order of keys is important.`);
-    }
-
-    if (JSON.stringify(prevConfig.repeat) !== JSON.stringify(repeat)) {
-        throw new Error(`"prevConfig.repeat" structure does not match "repeat" structure. The order of keys is important.`);
-    }
-
-    if (JSON.stringify(prevConfig.groups) !== JSON.stringify(groups)) {
-        throw new Error(`"prevConfig.groups" structure does not match "groups" structure. The order of keys is important.`);
-    }
-
-    return true
 }

package/test/test.js

@@ -1,3 +1,7 @@
+import OHLCV_INDICATORS from 'ohlcv-indicators'
+import KNN from 'ml-knn'
+import { ConfusionMatrix } from 'ml-confusion-matrix';
+
 import { parseTrainingXY } from "../src/datasets.js"
 import {arrayToTimesteps} from '../src/timeSteps.js'
 import { loadFile } from "./fs.js"
@@ -5,45 +9,30 @@ import * as tf from '@tensorflow/tfjs-node'
 
 const test = async () => {
 
-    const myArray = (await loadFile({fileName: '1d-spy.json', pathName: 'datasets'}))
-    .map(({open, high, low, close}) => ({open, high, low, close})) //file in /datasets/1d-spy.json
-    
-    //callback function used to prepare X before scaling
-    const xCallbackFunc = ({ objRow, index }) => {
-        const curr = objRow[index]
-        const prev = objRow[index - 1]
-
-        //returning null or undefined will exclude current row X and Y from training
-        if(typeof prev === 'undefined') return null
-
-        const { open, high, low, close } = curr
-
-        return {
-            open,
-            high,
-            low,
-            close,
-            change: open - prev.close,
-            top: high - Math.max(open, close),
-            bottom: low - Math.min(open, close),
-            body: open-close,
-        }
-    }
+    const ohlcv = (await loadFile({fileName: 'btc-1d.json', pathName: 'datasets'}))
 
-    //callback function used to prepare Y before scaling
-    const yCallbackFunc = ({ objRow, index }) => {
-        const curr = objRow[index];
-        const next = objRow[index + 1];
+    const indicators = new OHLCV_INDICATORS({input: ohlcv, ticker: 'BTC', precision: false})
 
-        //returning null or undefined will exclude current row X and Y from training
-        if (typeof next === 'undefined') return null;
+    indicators
+        .rsi(40)
+        .bollingerBands(20, 2)
+        .ema(50)
+        .sma(200)
+        .sma(300)
+        .scaler(200, ['open', 'high', 'low', 'close'], {group: true})
+        .crossPairs([
+            {fast: 'rsi_40', slow: 30},
+            {fast: 'price', slow: 'sma_200'},
+            {fast: 'price', slow: 'sma_300'},
+            {fast: 'price', slow: 'bollinger_bands_upper'}
+        ])
+
+    const parsedOhlcv = indicators.getData()
+
+    const {scaledGroups} = indicators
+
+    console.log(scaledGroups)
 
-        return {
-            label_1: next.open > curr.close,
-            label_2: next.close > curr.close,
-        };
-    };
-    
     const {
         trainX,
         trainY,
@@ -52,27 +41,77 @@ const test = async () => {
         configX,
         keyNamesX,
     } = parseTrainingXY({
-        arrObj: myArray,
-        trainingSplit: 0.90,
+        arrObj: parsedOhlcv,
+        trainingSplit: 0.50,
         yCallbackFunc,
         xCallbackFunc,
-        groups: {
-            ohlc: ['open', 'high', 'low', 'close']
-        },
-        shuffle: true,
-        repeat: {
-            close: 20
+        validateRows: ({objRow, index}) => {
+            const curr = objRow[index]
+            const prev = objRow[index - 1]
+
+            if(typeof prev === 'undefined') return false
+
+            return curr.ema_50 > curr.sma_300 && curr.sma_200 > curr.sma_300 && (curr.price_x_sma_300 === -1 || curr.price_x_sma_300 === 1)
         },
-        minmaxRange: [-1, 1],
-        balancing: 'oversample',
-        customMinMaxRanges: {
-            close: {min: 0, max: 10000}
-        }
+        shuffle: false,
+        minmaxRange: [0, 1],
+        balancing: null,
+        groups: scaledGroups,
+        excludes: ['high']
     });
 
+    //console.log(configX.outputKeyNames)
+    //console.log(configX)
+
+    console.log('trainX', trainX[0])
+
+    tensorflowExample({
+        trainX,
+        trainY,
+        testX,
+        testY,
+        configX,
+        keyNamesX,
+    })
+
+    classifiersExample({
+        trainX,
+        trainY,
+        testX,
+        testY,
+        configX,
+        keyNamesX,
+    })
+
+ 
+}
+
+const classifiersExample = ({
+    trainX,
+    trainY,
+    testX,
+    testY,
+    configX,
+    keyNamesX,
+}) => {
+    const model = new KNN(trainX, trainY)
 
-    //console.log('testX', testX.slice(-2))
+    const predictions = model.predict(testX)
+    const compare = ConfusionMatrix.fromLabels(testY.flat(), predictions.flat())
 
+    //console.log(testY.flat(), predictions.flat())
+
+    console.log(compare.getAccuracy())
+}
+
+const tensorflowExample = ({
+    trainX,
+    trainY,
+    testX,
+    testY,
+    configX,
+    keyNamesX,
+}) => {
 
     const timeSteps = 10
     const colsX = trainX[0].length
@@ -80,16 +119,71 @@ const test = async () => {
     const timeSteppedTrainX = arrayToTimesteps(trainX, timeSteps)
     const trimedTrainY = trainY.slice(timeSteps-1)
 
-
-    //console.log([trainX.length, timeSteps, timeSteppedTrainX[0][0].length])
-
     const inputX = tf.tensor3d(timeSteppedTrainX, [timeSteppedTrainX.length, timeSteps, colsX])
     const targetY = tf.tensor2d(trimedTrainY,  [trimedTrainY.length, colsY])
 
-    console.log('trainX', trainX[trainX.length - 1])
+    //console.log('trainX', trainX)
     //console.log('configX', configX)
     //console.log('inputX', inputX)
-    //console.log('inputX', targetY)
+    //console.log('inputX', targetY)   
+
+}
+
+//callback function used to prepare X before scaling
+const xCallbackFunc = ({ objRow, index }) => {
+    const curr = objRow[index]
+    const prev = objRow[index - 1]
+
+    //returning null or undefined will exclude current row X and Y from training
+    if(typeof prev === 'undefined') return null
+
+    //console.log(((curr.sma_300 - curr.low) / curr.low) * 100)
+
+    const output = {
+        high: curr.high,
+        ema50IsUp: curr.ema_50 > prev.ema_50,
+        ema50GtSma200: curr.ema_50 > curr.sma_200,
+        ema50GtSma300: curr.ema_50 > curr.sma_300,
+        sma200IsUp: curr.sma_200 > prev.sma_200,
+        sma200GtSma300: curr.sma_200 > prev.sma_300,
+        sma_300IsUp: curr.sma_300 > prev.sma_300
+    }
+
+    for(const [key, value]  of Object.entries(curr))
+    {
+        if(key.includes('minmax'))
+        {
+            output[key] = value
+        }
+    }
+
+    return output
+}
+
+//callback function used to prepare Y before scaling
+const yCallbackFunc = ({ objRow, index }) => {
+    const curr = objRow[index]
+    const next = new Array(60).fill(0).map((_, i) => objRow[index + 1 + i])
+
+    //returning null or undefined will exclude current row X and Y from training
+    if (next.some(o => typeof o === 'undefined')) return null;
+
+    const priceTp = curr.sma_300 * 1.3
+    const entryPrice = curr.sma_300 * 0.96
+    const tp = next.some(o => o.close > entryPrice && (o.high > priceTp))
+    const sl = next.some(o => (o.low - entryPrice)/entryPrice < -0.10 && o.low < entryPrice)
+
+    const highestHigh = Math.max(...next.map(o => o.high))
+    const lowestLow = Math.min(...next.slice(0, 5).map(o => o.low))
+
+
+    if(lowestLow > entryPrice) return null
+
+    //console.log([curr.date, (lowestLow - entryPrice)/entryPrice])
+    
+    return {
+        result: Number(tp === true && sl === false)
+    }
 }
 
 test()