ohlcv-indicators 3.5.56 → 3.5.60

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
-}