ohlcv-indicators 3.5.55 → 3.5.59

package/src/machine-learning/ml-config.js

@@ -1,219 +0,0 @@
-export const defaultYCallback = (index, verticalOhlcv, horizon) => {
-
-    //this function will be executed inside a secondary loop after most of the indicates are calculated
-    //use the "verticalOhlcv" object to access desired indicators
-
-    if(horizon !== 2) throw new Error(`The default "yCallback" function in this classifier requires that "options.horizon" and "options.predictions" are set to "2".`)
-
-    const currClose =  verticalOhlcv.close[index]
-    const nextCloseArr = Array.from({length: horizon}, (_, i) => verticalOhlcv.close[i + 1 + index])
-
-    if(nextCloseArr.some(v => typeof v === 'undefined')) return null
-
-    const [nextClose, nextNextClose] = nextCloseArr
-
-  
-    //the total length of item is this output must be equal to "options.yColumns" property
-    return [Number(nextClose > currClose), Number(nextNextClose > nextClose)]
-}
-
-export const exportTrainedModels = main => {
-
-  const {ML, inputParams} = main
-  const allModels = ML.models
-  const output = {}
-
-  for (const { key, params } of inputParams) {
-
-    if(key !== 'classifier' && key !== 'regressor') continue
-
-    const [_, {type, predictions, precompute}] = params
-    const {flatY, prefix} = precompute
-    const expectedLoops = (flatY) ? predictions : 1
-
-    let exportModel
-
-    if(key === 'regressor')
-    {
-      exportModel = validRegressors[type].exportModel
-    }
-    else if (key === 'classifier')
-    {
-      exportModel = validClassifiers[type].exportModel
-    }
-
-    for(let loopIdx = 0; loopIdx < expectedLoops; loopIdx++)
-    {
-      const modelKey = `${prefix}_${(loopIdx+1)}`
-      output[modelKey] = exportModel(allModels[modelKey])
-    }
-
-  }
-
-  return output
-}
-
-
-export const validClassifiers = {
-    'KNN': {
-      shortName: 'knn',
-      flatY: true,
-      exportModel: m => m.toJSON(),
-      train: ({modelClass, xRows, yRows, modelArgs}) => new modelClass(xRows, yRows, modelArgs),
-      unsupervised: false
-    },
-    'FeedForwardNeuralNetworks': {
-      shortName: 'feed_forward',
-      flatY: false,
-      exportModel: m => m.toJSON(),
-      train: ({modelClass, xRows, yRows, modelArgs, uniqueLabels}) => {
-
-        if(!modelArgs) modelArgs = {}
-
-        modelArgs = {
-          ...modelArgs, 
-          activation: (uniqueLabels === 2) ? 'logistic' : 'identity'
-        }
-        
-        const m = new modelClass(modelArgs)
-        m.train(xRows, yRows)
-        return m
-      },
-      unsupervised: false
-    },
-    'GaussianNB': {
-      shortName: 'naive_bayes',
-      flatY: true,
-      exportModel: m => m.toJSON(),
-      train: ({modelClass, xRows, yRows, modelArgs}) => {
-        const m = new modelClass(modelArgs)
-        m.train(xRows, yRows)
-        return m
-      },
-      unsupervised: false
-    },
-    'MultinomialNB': {
-      shortName: 'naive_bayes',
-      flatY: true,
-      exportModel: m => m.toJSON(),
-      train: ({modelClass, xRows, yRows, modelArgs}) => {
-        const m = new modelClass(modelArgs)
-        m.train(xRows, yRows)
-        return m
-      },
-      unsupervised: false
-    },
-    'DecisionTreeClassifier': {
-      shortName: 'decision_tree',
-      flatY: true,
-      exportModel: m => m.toJSON(),
-      train: ({modelClass, xRows, yRows, modelArgs}) => {
-        const m = new modelClass(modelArgs)
-        m.train(xRows, yRows)
-        return m
-      },
-      unsupervised: false
-    },
-    'RandomForestClassifier': {
-      shortName: 'random_forest',
-      flatY: true,
-      exportModel: m => m.toJSON(),
-      train: ({modelClass, xRows, yRows, modelArgs}) => {
-        const m = new modelClass(modelArgs)
-        m.train(xRows, yRows)
-        return m
-      }
-    },
-    unsupervised: false
-}
-
-export const validRegressors = {
-    'ARIMA': {
-        shortName: 'arima',
-        flatX: true,
-        flatY: false,
-        exportModel: m => m,
-        train: ({modelClass, xRows, modelArgs}) => {
-
-          if(!modelArgs) modelArgs = {}
-
-          modelArgs = { ...modelArgs, p: 2, d: 1, q: 2, P: 0, D: 0, Q: 0, S: 0, verbose: false }
-
-          const m = new modelClass(modelArgs)
-          m.train(xRows)
-          return m
-        },
-        unsupervised: true
-    }, 
-    'SimpleLinearRegression': {
-        shortName: 'linear',
-        flatX: true,
-        flatY: true,
-  
-        exportModel: m => m.toJSON(),
-        train: ({modelClass, xRows, yRows, modelArgs}) => new modelClass(xRows, yRows, modelArgs),
-        unsupervised: false
-    }, 
-    'PolynomialRegression': {
-        shortName: 'polynomial',
-        flatX: true,
-        flatY: true,
-  
-        exportModel: m => m.toJSON(),
-        train: ({modelClass, xRows, yRows, modelArgs}) => new modelClass(xRows, yRows, modelArgs),
-        unsupervised: false
-    },
-    'MultivariateLinearRegression': {
-        shortName: 'multivariable',
-        flatX: false,
-        flatY: false,
-  
-        exportModel: m => m.toJSON(),
-        train: ({modelClass, xRows, yRows, modelArgs}) => new modelClass(xRows, yRows, modelArgs),
-        unsupervised: false
-    }, 
-    'DecisionTreeRegression': {
-        shortName: 'decision_tree',
-        flatX: false,
-        flatY: true,
-        exportModel: m => m.toJSON(),
-        train: ({modelClass, xRows, yRows, modelArgs}) => {
-          const m = new modelClass(modelArgs)
-          m.train(xRows, yRows)
-          return m
-        },
-        unsupervised: false
-    },
-    'RandomForestRegression': {
-        shortName: 'random_forest',
-        flatX: false,
-        flatY: true,
-        exportModel: m => m.toJSON(),
-        train: ({modelClass, xRows, yRows, modelArgs}) => {
-          const m = new modelClass(modelArgs)
-          m.train(xRows, yRows)
-          return m
-        },
-        unsupervised: false
-    },
-    'FeedForwardNeuralNetworks': {
-        shortName: 'feed_forward',
-        flatX: false,
-        flatY: false,
-        exportModel: m => m.toJSON(),
-        train: ({modelClass, xRows, yRows, modelArgs}) => {
-
-          if(!modelArgs) modelArgs = {}
-
-          modelArgs = {
-            ...modelArgs, 
-            activation: 'identity'
-          }
-          
-          const m = new modelClass(modelArgs)
-          m.train(xRows, yRows)
-          return m
-        },
-        unsupervised: false
-    }
-}

package/src/machine-learning/pca.js

@@ -1,95 +0,0 @@
-import { getFeaturedKeys, computeFlatFeaturesLen, findGroupsFunc } from "./ml-utilities.js";
-import { buildTrainX } from "./trainX.js";
-import { areKeyValuesValid } from "../core-functions/pushToMain.js";
-
-const algo = 'pca'
-
-export const pca = (main, index, {prefix, trainingSize, findGroups, trainingCols, lookbackAbs, modelArgs, filterCallback}) => {
-
-    const {verticalOhlcv, scaledGroups, len, instances, ML, invalidValueIndex} = main
-
-    const startIndex = (invalidValueIndex + 2)
-    const allModels = ML.models
-
-    if(index === startIndex)
-    {
-        if(!instances.hasOwnProperty(algo)) instances[algo] = {}
-
-        instances[algo][prefix] = {
-            flatFeaturesColLen: 0,
-            featureCols: [],
-            X: []
-        }
-        
-        verticalOhlcv[prefix] = new Array(len).fill(null)
-    }
-    else if(index < startIndex || index < lookbackAbs)
-    {
-        return
-    }
-    else if(filterCallback(verticalOhlcv, index) === false)
-    {
-        return
-    }
-    else if(index + 1 === len) 
-    {
-
-        if(instances[algo][prefix].featureCols.length === 0)
-        {
-            const inputFeatures = [...trainingCols, ...(findGroupsFunc(findGroups, scaledGroups))]
-
-            throw new Error(`Some of the provided features in ${prefix} features where not found in "verticalOhlcv": ${JSON.stringify(inputFeatures)}`)
-        }
-
-        //last execution
-        for(const featureKey of instances[algo][prefix].featureCols)
-        {
-            if(!verticalOhlcv.hasOwnProperty(featureKey)) throw new Error(`Feature "${featureKey}" not found in verticalOhlcv for pca.`)
-        }
-
-        if(instances[algo][prefix].X.length < trainingSize)
-        {
-            const requiredDatapoints = instances[algo][prefix].X.length - trainingSize
-            throw new Error(`The current "trainingSize" at "${prefix}" requires at least ${requiredDatapoints} more datapoints. Try adding more input ohlcv rows or reducing the "trainingSize" by ${requiredDatapoints}.`)
-        }
-    } 
-
-    const dataSetInstance = instances[algo][prefix]
-
-    if(dataSetInstance.flatFeaturesColLen === 0)
-    {
-        dataSetInstance.featureCols = getFeaturedKeys({trainingCols, findGroups, verticalOhlcv, scaledGroups})
-
-        if(areKeyValuesValid(main, index, dataSetInstance.featureCols))
-        {
-            dataSetInstance.flatFeaturesColLen = computeFlatFeaturesLen(dataSetInstance.featureCols, verticalOhlcv, index)
-        } else {
-            return
-        }
-    }
-
-    if(dataSetInstance.flatFeaturesColLen === 0) return
-    
-    const {X: xRows, featureCols, flatFeaturesColLen} = dataSetInstance
-
-    const trainX = buildTrainX({featureCols, flatFeaturesColLen, type: algo, index, lookbackAbs, main})
-
-    if (trainX == null) return
-
-    if(allModels.hasOwnProperty(prefix))
-    {
-
-        const futureRow = allModels[prefix].predict([trainX]).to2DArray()
-
-        verticalOhlcv[prefix][index] = futureRow[0]
-    }
-
-    xRows.push(trainX)
-
-    if (xRows.length > trainingSize) xRows.shift()
-
-    if(xRows.length === trainingSize)
-    {
-        allModels[prefix] = new ML.classes.PCA(xRows, modelArgs) 
-    }
-}

package/src/machine-learning/regressor.js

@@ -1,227 +0,0 @@
-import { getFeaturedKeys, computeFlatFeaturesLen, logMlTraining, findGroupsFunc } from './ml-utilities.js'
-import { buildTrainX } from './trainX.js'
-import { areKeyValuesValid } from '../core-functions/pushToMain.js'
-
-const algo = 'regressor'
-
-export const regressor = (main, index, trainingSize, {target, predictions, retrain, trainingCols, findGroups, type, modelArgs, precompute, filterCallback, modelConfig, modelClass}) => {
-
-    const {lookbackAbs, prefix, flatX, flatY} = precompute
-    const {verticalOhlcv, len, instances, scaledGroups, invalidValueIndex, ML} = main
-    const allModels = ML.models
-    const startIndex = (invalidValueIndex + 1)
-
-    if(index === startIndex)
-    {
-        if (!instances.hasOwnProperty(algo)) instances.regressor = {}
-        if(!instances.regressor.hasOwnProperty(prefix)) instances.regressor[prefix] = {}
-
-        const expectedLoops = (flatY) ? predictions : 1 //
-
-        instances.regressor[prefix] = {
-            expectedLoops,
-            trainingSize,
-            isTrained: new Array(expectedLoops).fill(false),
-            shouldRetrain: retrain,
-            featureCols: [],
-            flatFeaturesColLen: 0,
-            X: [],
-            Y: Array.from({ length: expectedLoops }, () => []),
-        }
-
-        for(let x = 0; x < predictions; x++)
-        {
-            const predictionKey = `${prefix}_${(x+1)}`
-            verticalOhlcv[predictionKey] = new Float64Array(len).fill(NaN)
-
-            if(!allModels.hasOwnProperty(predictionKey))
-            {
-                allModels[predictionKey] = []
-            }
-        }
-    } 
-    else if(index < startIndex || index < lookbackAbs)
-    {
-        return
-    }
-    else if(filterCallback(verticalOhlcv, index) === false)
-    {
-        return
-    }
-    else if(index + 1 === len) 
-    {
-        if(instances.regressor[prefix].featureCols.length === 0)
-        {
-            const inputFeatures = [...trainingCols, ...(findGroupsFunc(findGroups, scaledGroups))]
-
-            throw new Error(`Some of the provided  features in ${prefix} features where not found in "verticalOhlcv": ${JSON.stringify(inputFeatures)}`)
-        }
-
-        //last execution
-        for(const featureKey of instances.regressor[prefix].featureCols)
-        {
-            if(!verticalOhlcv.hasOwnProperty(featureKey)) throw new Error(`Feature "${featureKey}" not found in verticalOhlcv for ${prefix}.`)
-        }
-
-        if(instances.regressor[prefix].X.length < trainingSize)
-        {
-            const requiredDatapoints = instances.regressor[prefix].X.length - trainingSize
-            throw new Error(`The current "trainingSize" at "${prefix}" requires at least ${requiredDatapoints} more datapoints. Try adding more input ohlcv rows or reducing the "trainingSize" by ${requiredDatapoints}.`)
-        }
-    }
-
-    const dataSetInstance = instances.regressor[prefix]
-
-    if(dataSetInstance.flatFeaturesColLen === 0)
-    {
-        dataSetInstance.featureCols = getFeaturedKeys({trainingCols, findGroups, verticalOhlcv, scaledGroups})
-
-        if(areKeyValuesValid(main, index, dataSetInstance.featureCols))
-        {
-            dataSetInstance.flatFeaturesColLen = computeFlatFeaturesLen(dataSetInstance.featureCols, verticalOhlcv, index)
-
-            logMlTraining({
-                featureCols: dataSetInstance.featureCols, 
-                flatFeaturesColLen: dataSetInstance.flatFeaturesColLen, 
-                type, 
-                trainingSize
-            })
-
-        } else {
-            return
-        }
-    }
-    
-    if(dataSetInstance.flatFeaturesColLen === 0) return
-
-    if(!verticalOhlcv.hasOwnProperty(target))
-    {
-        throw new Error(`Target property "${target}" not found in verticalOhlcv for regressor.`)
-    }
-
-    const {
-        expectedLoops,
-        X: xRows, 
-        Y, 
-        flatFeaturesColLen, 
-        featureCols, 
-        shouldRetrain
-    } = dataSetInstance
-
-    if(!featureCols.includes(target))
-    {
-        throw new Error(`Target property "${target}" not found in ${type} features: ${JSON.stringify(featureCols)}`)
-    }
-    
-    const trainX = (flatX) ? verticalOhlcv[target][index] : buildTrainX({featureCols, flatFeaturesColLen, type, index, lookbackAbs, main})
-
-    if (flatX) {
-        if (!Number.isFinite(trainX)) return;   // or `trainX == null`
-    } else {
-        if (trainX == null) return;
-    }
-
-    let trainY = []
-
-    for (let i = 0; i < predictions; i++) {
-        const v = verticalOhlcv[target][index + i + 1]
-
-        if (!Number.isFinite(v)) {
-            break
-        }
-
-        trainY.push(v)
-    }
-
-    const {train, unsupervised} = modelConfig
-
-    //if univariable Y (flatY) a model is created for each prediction
-    for(let loopIdx = 0; loopIdx < expectedLoops; loopIdx++)
-    {
-        const predictionKey = `${prefix}_${(loopIdx+1)}`
-        const yRows = Y[loopIdx]
-        const currTrainY =  (flatY) ? (typeof trainY[loopIdx] === 'undefined') ? null : trainY[loopIdx] : trainY
-        const isTrained = dataSetInstance.isTrained[loopIdx]
-
-        const shouldPredict = allModels.hasOwnProperty(predictionKey) && isTrained && allModels[predictionKey].length === expectedLoops
-
-        //predicts using previously saved models even if current currTrainY is not available
-        if(shouldPredict)
-        {
-            const currModel = allModels[predictionKey][0]
-            const futureRow = (unsupervised) ? currModel.predict(predictions)[0] : currModel.predict([trainX])[0]
-            
-            if(flatY)
-            {
-                if(Number.isNaN(futureRow)) throw new Error(`Prediction of ${type} at index ${index} was expecting a number.`)
-
-                main.pushToMain({index, key: predictionKey, value: futureRow})
-            }
-            else {
-
-                if (!Array.isArray(futureRow) || futureRow.length !== predictions) {
-                    throw new Error(
-                        `Prediction output of "${type}" at index ${index} was expecting an array of values.`
-                    )
-                }
-
-                for(let preIdx = 0; preIdx < predictions; preIdx++) {
-                    main.pushToMain({index, key: `${prefix}_${(preIdx+1)}`, value: futureRow[preIdx]})
-                }
-            }
-        }
-
-        if((index + predictions + 1) > len) continue
-        if(trainY.length < predictions) continue
-        if(currTrainY === null) continue
-
-        if(flatY)
-        {
-            if (typeof currTrainY !== 'number' || Number.isNaN(currTrainY))
-            {
-                throw new Error(`currTrainY must return number, got ${typeof currTrainY} at index ${index}`)
-            }
-        } else {
-            if (!Array.isArray(currTrainY)) {
-                throw new Error(`currTrainY must return an array, got ${typeof currTrainY} at index ${index}`)
-            }
-
-            if ((currTrainY.length !== predictions)) {
-
-                throw new Error(`currTrainY length (${currTrainY.length}) ≠ "options.predictions" (${predictions}) for regressor "${type}"`)
-            }           
-        }
-
-        // enqueue
-        yRows.push(currTrainY)
-        if (yRows.length > trainingSize) yRows.shift()
-
-        if(loopIdx === 0)
-        {
-            xRows.push(trainX)
-            if (xRows.length > trainingSize) xRows.shift()
-        }
-
-        const shouldTrainModel = shouldRetrain || !isTrained
-
-        if (shouldTrainModel && xRows.length === trainingSize && yRows.length === trainingSize) {
-
-            const trainedModel = train({modelClass, xRows, yRows, modelArgs, uniqueLabels: 0})
-
-            if(unsupervised)
-            {
-                allModels[predictionKey] = [trainedModel]
-            } else {
-                allModels[predictionKey].push(trainedModel)
-
-                if(allModels[predictionKey].length > predictions)
-                {
-                    allModels[predictionKey].shift()
-                }
-            }
-
-            dataSetInstance.isTrained[loopIdx] = true
-        }
-
-    }
-}

package/src/machine-learning/trainX.js

@@ -1,73 +0,0 @@
-/**
- * Builds a flattened lookback feature vector or returns null if any value is non‐finite.
- *
- * @param {string[]} featureCols                – list of feature column keys
- * @param {Object}   instances                  – your instances object (with crossPairs)
- * @param {number}   flatFeaturesColLen         – total number of flattened feature slots
- * @param {string}   type                       – a string used only for error reporting
- * @param {number}   index                      – current time index
- * @param {number}   lookbackAbs                – number of lags to include
- * @param {Object}   verticalOhlcv              – an object mapping each key to its time series array
- * @returns {number[]\|null}                    – the feature vector or null if exiting early
- */
-export const buildTrainX = ({
-  featureCols,
-  flatFeaturesColLen,
-  type,
-  index,
-  lookbackAbs,
-  main
-}) => {
-
-  const {verticalOhlcv} = main
-
-  let shouldExit = false
-
-  // --- BUILD A FLATTENED LIST OF “COLUMN SLOTS” ---
-  const slots = [];
-  for (const key of featureCols) {
-    if (key.startsWith('one_hot_') || key.startsWith('pca_')) {
-
-      const colSize = verticalOhlcv[key][index].length
-
-      for (let bit = 0; bit < colSize; bit++) {
-        slots.push({ key, bit });
-      }
-    } else {
-      slots.push({ key });
-    }
-  }
-
-  if (slots.length !== flatFeaturesColLen) {
-    throw new Error(
-      `slots (${slots.length}) ≠ flatFeaturesColLen (${flatFeaturesColLen}) in ${type} index ${index}`
-    );
-  }
-
-  // --- ALLOCATE AND FILL trainX ---
-  const trainX = new Array(flatFeaturesColLen * lookbackAbs).fill(NaN);
-
-  for (let lag = 0; lag < lookbackAbs; lag++) {
-    const tIdx = index - lag;
-
-    for (let s = 0; s < slots.length; s++) {
-      const { key, bit } = slots[s];
-      const cell = verticalOhlcv[key][tIdx];
-      const value = (bit != null) ? cell[bit] : cell;
-
-      if (!Number.isFinite(value)) {
-        shouldExit = true;
-        break;
-      }
-      trainX[lag * flatFeaturesColLen + s] = value;
-    }
-
-    if (shouldExit) break;
-  }
-
-  if (shouldExit) {
-    return null;
-  }
-
-  return trainX;
-};

package/src/utilities/order.js

@@ -1,51 +0,0 @@
-
-import { validateArray, validateString } from "./validators.js"
-
-export const getOrderFromArray = (arr, methodName) => {
-
-    validateArray(arr, 'arr', 'getOrderFromArray')
-    validateString(methodName, 'methodName', 'getOrderFromArray')
-
-    const level2Methods = ['regressor', 'classifier', 'pca']
-    const baseKeys = ['open', 'high', 'low', 'close', 'volume', 'date']
-
-    // 1. Level-2: does this method live in your level-2 list?
-    const isSecondary = level2Methods.includes(methodName);
-
-    // 2. Level-0: is every field one of the primitives *and* not level-2?
-    const isPrimary = arr.every(v => baseKeys.includes(v)) && !isSecondary;
-
-    if(isPrimary)
-    {
-        return 0
-    }
-
-    let order = 1
-    const level1Prefixes = ['_x_', 'zscore_', 'minmax_', 'lag_']
-
-    for(const k of level1Prefixes)
-    {
-        if(arr.some(v => v.includes(k)))
-        {
-            order++
-        }
-    }
-
-    if(!isSecondary)
-    {
-        return order
-    }
-
-    const level2Prefixes = ['prediction_', 'reg_', 'cla_', 'pca_']
-    order = 10
-
-    for(const k of level2Prefixes)
-    {
-        if(arr.some(v => v.includes(k)))
-        {
-            order++
-        }
-    }
-
-    return order
-}