@datagrok/eda 1.4.12 → 1.5.0

package/src/probabilistic-scoring/stat-tools.ts

@@ -1,5 +1,5 @@
 // Probabilistic scoring (pMPO) statistical tools
-// Link: https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
+// Link https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
 
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
@@ -8,9 +8,8 @@ import * as DG from 'datagrok-api/dg';
 //@ts-ignore: no types
 import * as jStat from 'jstat';
 
-import {Cutoff, DescriptorStatistics, SigmoidParams} from './pmpo-defs';
-
-const SQRT_2_PI = Math.sqrt(2 * Math.PI);
+import {ConfusionMatrix, Cutoff, DescriptorStatistics, ModelEvaluationResult,
+  ROC_TRESHOLDS, ROC_TRESHOLDS_COUNT, SigmoidParams} from './pmpo-defs';
 
 /** Splits the dataframe into desired and non-desired tables based on the desirability column */
 export function getDesiredTables(df: DG.DataFrame, desirability: DG.Column) {
@@ -70,6 +69,8 @@ export function getDescriptorStatistics(des: DG.Column, nonDes: DG.Column): Desc
     nonDesAvg: nonDesAvg,
     nonDesStd: nonDesStd,
     nonSesLen: nonDesLen,
+    min: Math.min(des.stats.min, nonDes.stats.min),
+    max: Math.max(des.stats.max, nonDes.stats.max),
     tstat: t,
     pValue: pValue,
   };
@@ -163,6 +164,140 @@ export function sigmoidS(x: number, x0: number, b: number, c: number): number {
 }
 
 /** Normal probability density function */
-export function normalPdf(x: number, mu: number, sigma: number): number {
-  return Math.exp(-((x - mu)**2) / (2 * sigma**2)) / (sigma * SQRT_2_PI);
+export function gaussDesirabilityFunc(x: number, mu: number, sigma: number): number {
+  return Math.exp(-((x - mu)**2) / (2 * sigma**2));
 }
+
+/** Computes the confusion matrix given desirability (labels) and prediction columns
+ * @param desirability - desirability column (boolean)
+ * @param prediction - prediction column (numeric)
+ * @param threshold - threshold to convert prediction scores to binary labels
+ * @return ConfusionMatrix object with TP, TN, FP, FN counts
+ */
+export function getConfusionMatrix(desirability: DG.Column, prediction: DG.Column, threshold: number): ConfusionMatrix {
+  if (desirability.length !== prediction.length)
+    throw new Error('Failed to compute confusion matrix: columns have different lengths.');
+
+  if (desirability.type !== DG.COLUMN_TYPE.BOOL)
+    throw new Error('Failed to compute confusion matrix: desirability column must be boolean.');
+
+  if (!prediction.isNumerical)
+    throw new Error('Failed to compute confusion matrix: prediction column must be numerical.');
+
+  let TP = 0;
+  let TN = 0;
+  let FP = 0;
+  let FN = 0;
+
+  const desRaw = desirability.getRawData();
+  const predRaw = prediction.getRawData();
+
+  let desIdx = 0;
+  let curPos = 0;
+  let desElem = desRaw[0];
+
+  // Here, we extract bits from the desirability boolean column in chunks of 32 bits
+  for (let predIdx = 0; predIdx < prediction.length; ++predIdx) {
+    // console.log(predIdx + 1, ': ',
+    //   desirability.get(predIdx), '<-->', (desElem >>> curPos) & 1, ' vs ', predRaw[predIdx] >= threshold);
+
+    if (((desElem >>> curPos) & 1) == 1) { // True actual
+      if (predRaw[predIdx] >= threshold) { // True predicted
+        ++TP;
+      } else { // False predicted
+        ++FN;
+      }
+    } else { // False actual
+      if (predRaw[predIdx] >= threshold) { // True predicted
+        ++FP;
+      } else { // False predicted
+        ++TN;
+      }
+    }
+
+    ++curPos;
+
+    // Move to the next desirability element if we have processed 32 bits
+    if (curPos >= 32) {
+      curPos = 0;
+      ++desIdx;
+      desElem = desRaw[desIdx];
+    }
+  } // for predIdx
+
+  return {TP: TP, TN: TN, FP: FP, FN: FN};
+} // getConfusionMatrix
+
+/** Computes Area Under Curve (AUC) given TPR and FPR arrays
+ * @param tpr - True Positive Rate array
+ * @param fpr - False Positive Rate array
+ * @return AUC value
+ */
+export function getAuc(tpr: Float32Array, fpr: Float32Array): number {
+  if (tpr.length !== fpr.length)
+    throw new Error('Failed to compute AUC: TPR and FPR arrays have different lengths.');
+
+  let auc = 0.0;
+
+  for (let i = 1; i < tpr.length; ++i) {
+    const xDiff = Math.abs(fpr[i] - fpr[i - 1]);
+    const yAvg = (tpr[i] + tpr[i - 1]) / 2.0;
+    auc += xDiff * yAvg;
+  }
+
+  return auc;
+} // getAuc
+
+/** Converts numeric prediction column to boolean based on the given threshold
+ * @param numericPrediction - numeric prediction column
+ * @param threshold - threshold to convert prediction scores to binary labels
+ * @param name - name for the resulting boolean column
+ * @return Boolean prediction column
+ */
+export function getBoolPredictionColumn(numericPrediction: DG.Column, threshold: number, name: string): DG.Column {
+  if (!numericPrediction.isNumerical)
+    throw new Error('Failed to compute confusion matrix: prediction column must be numerical.');
+
+  const size = numericPrediction.length;
+  const boolPredData = new Array<boolean>(size);
+  const predRaw = numericPrediction.getRawData();
+
+  for (let i = 0; i < size; ++i)
+    boolPredData[i] = (predRaw[i] >= threshold);
+
+  return DG.Column.fromList(DG.COLUMN_TYPE.BOOL, name, boolPredData);
+} // getBoolPredictionColumn
+
+/** Computes pMPO model evaluation metrics: AUC, optimal threshold, TPR and FPR arrays
+ * @param desirability - desirability column (boolean)
+ * @param prediction - prediction column (numeric)
+ * @return ModelEvaluationResult object with AUC, optimal threshold, TPR and FPR arrays
+ */
+export function getPmpoEvaluation(desirability: DG.Column, prediction: DG.Column): ModelEvaluationResult {
+  const tpr = new Float32Array(ROC_TRESHOLDS_COUNT);
+  const fpr = new Float32Array(ROC_TRESHOLDS_COUNT);
+
+  let bestJ = -1;
+  let currentJ = -1;
+  let bestThreshold = ROC_TRESHOLDS[0];
+
+  // Compute TPR and FPR for each threshold
+  for (let i = 0; i < ROC_TRESHOLDS_COUNT; ++i) {
+    const confusion = getConfusionMatrix(desirability, prediction, ROC_TRESHOLDS[i]);
+    tpr[i] = (confusion.TP + confusion.FN) > 0 ? confusion.TP / (confusion.TP + confusion.FN) : 0;
+    fpr[i] = (confusion.FP + confusion.TN) > 0 ? confusion.FP / (confusion.FP + confusion.TN) : 0;
+    currentJ = tpr[i] - fpr[i];
+
+    if (currentJ > bestJ) {
+      bestJ = currentJ;
+      bestThreshold = ROC_TRESHOLDS[i];
+    }
+  }
+
+  return {
+    auc: getAuc(tpr, fpr),
+    threshold: bestThreshold,
+    tpr: tpr,
+    fpr: fpr,
+  };
+} // getPmpoEvaluation

package/src/tests/anova-tests.ts

@@ -5,7 +5,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {_package} from '../package-test';
 
-import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test} from '@datagrok-libraries/test/src/test';
 
 import {oneWayAnova, FactorizedData} from '../anova/anova-tools';
 

package/src/tests/classifiers-tests.ts

@@ -5,7 +5,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {_package} from '../package-test';
 
-import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test} from '@datagrok-libraries/test/src/test';
 
 import {classificationDataset, accuracy} from './utils';
 import {SoftmaxClassifier} from '../softmax-classifier';

package/src/tests/dim-reduction-tests.ts

@@ -5,7 +5,7 @@ import {_package} from '../package-test';
 
 // tests for dimensionality reduction
 
-import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test} from '@datagrok-libraries/test/src/test';
 import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
 import {KnownMetrics, NumberMetricsNames, StringMetricsNames} from '@datagrok-libraries/ml/src/typed-metrics';
 import {multiColReduceDimensionality}

package/src/tests/linear-methods-tests.ts

@@ -5,7 +5,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {_package} from '../package-test';
 
-import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test} from '@datagrok-libraries/test/src/test';
 import {computePCA} from '../eda-tools';
 import {getPlsAnalysis} from '../pls/pls-tools';
 import {PlsModel} from '../pls/pls-ml';

package/src/tests/mis-vals-imputation-tests.ts

@@ -5,7 +5,7 @@ import * as ui from 'datagrok-api/ui';
 import * as DG from 'datagrok-api/dg';
 import {_package} from '../package-test';
 
-import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+import {category, expect, test} from '@datagrok-libraries/test/src/test';
 
 import {MetricInfo, DISTANCE_TYPE, impute} from '../missing-values-imputation/knn-imputer';
 import {getFeatureInputSettings} from '../missing-values-imputation/ui';

package/src/tests/pareto-tests.ts

@@ -0,0 +1,251 @@
+// Tests for Pareto Front Computations
+// Performance tests for the Pareto optimality algorithm
+
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {_package} from '../package-test';
+
+import {category, expect, test} from '@datagrok-libraries/test/src/test';
+
+import {getParetoMask} from '../pareto-optimization/pareto-computations';
+import {OPT_TYPE, NumericArray} from '../pareto-optimization/defs';
+
+const TIMEOUT = 5000;
+
+// Test dataset sizes
+const ROWS_COUNT = 1000000;
+const M = 1000000;
+const COLS_COUNT = 2;
+const suffix = M < 1e6 ? 'K' : 'M';
+const DATASET_SIZE_LABEL = `${ROWS_COUNT / M}${suffix} points, ${COLS_COUNT}D`;
+
+/** Generates synthetic numeric data for Pareto front testing */
+function generateSyntheticData(nPoints: number, nDims: number, seed: number = 42): NumericArray[] {
+  const data: NumericArray[] = [];
+
+  // Simple deterministic pseudo-random generator for reproducibility
+  let rng = seed;
+  const random = () => {
+    rng = (rng * 1664525 + 1013904223) % 4294967296;
+    return rng / 4294967296;
+  };
+
+  for (let d = 0; d < nDims; d++) {
+    const column = new Float32Array(nPoints);
+    for (let i = 0; i < nPoints; i++) {
+      // Generate values with some correlation to create realistic Pareto fronts
+      column[i] = random() * 100 + (d * 10);
+    }
+    data.push(column);
+  }
+
+  return data;
+}
+
+/** Generates optimization sense array */
+function generateSense(nDims: number, pattern: 'all-min' | 'all-max' | 'mixed'): OPT_TYPE[] {
+  const sense: OPT_TYPE[] = [];
+
+  for (let d = 0; d < nDims; d++) {
+    if (pattern === 'all-min')
+      sense.push(OPT_TYPE.MIN);
+    else if (pattern === 'all-max')
+      sense.push(OPT_TYPE.MAX);
+    else {
+      // Mixed: alternate between MIN and MAX
+      sense.push(d % 2 === 0 ? OPT_TYPE.MIN : OPT_TYPE.MAX);
+    }
+  }
+
+  return sense;
+}
+
+/** Generates null indices set for testing missing value handling */
+function generateNullIndices(nPoints: number, nullRatio: number): Set<number> {
+  const nullCount = Math.floor(nPoints * nullRatio);
+  const nullIndices = new Set<number>();
+
+  // Distribute null indices evenly
+  const step = Math.floor(nPoints / nullCount);
+  for (let i = 0; i < nullCount; i++)
+    nullIndices.add(i * step);
+
+
+  return nullIndices;
+}
+
+/** Validates Pareto mask result */
+function validateParetoMask(mask: boolean[], nPoints: number): void {
+  if (mask.length !== nPoints)
+    throw new Error(`Invalid mask length: expected ${nPoints}, got ${mask.length}`);
+
+
+  const optimalCount = mask.filter((x) => x).length;
+  if (optimalCount === 0)
+    throw new Error('No optimal points found');
+
+
+  if (optimalCount === nPoints)
+    grok.shell.warning('All points are optimal - data may be degenerate');
+}
+
+category('Pareto optimization', () => {
+  test(`Performance: ${DATASET_SIZE_LABEL}`, async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const data = generateSyntheticData(ROWS_COUNT, COLS_COUNT);
+      const sense = generateSense(COLS_COUNT, 'mixed');
+      mask = getParetoMask(data, sense, ROWS_COUNT);
+      validateParetoMask(mask, ROWS_COUNT);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+
+  // Tests for different optimization patterns
+  test(`Performance: ${DATASET_SIZE_LABEL}, all minimize`, async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const data = generateSyntheticData(ROWS_COUNT, COLS_COUNT);
+      const sense = generateSense(COLS_COUNT, 'all-min');
+      mask = getParetoMask(data, sense, ROWS_COUNT);
+      validateParetoMask(mask, ROWS_COUNT);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+
+  test(`Performance: ${DATASET_SIZE_LABEL}, all maximize`, async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const data = generateSyntheticData(ROWS_COUNT, COLS_COUNT);
+      const sense = generateSense(COLS_COUNT, 'all-max');
+      mask = getParetoMask(data, sense, ROWS_COUNT);
+      validateParetoMask(mask, ROWS_COUNT);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+
+  // Tests with missing values
+  test(`Performance: ${DATASET_SIZE_LABEL} with 10% null indices`, async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const data = generateSyntheticData(ROWS_COUNT, COLS_COUNT);
+      const sense = generateSense(COLS_COUNT, 'mixed');
+      const nullIndices = generateNullIndices(ROWS_COUNT, 0.1);
+      mask = getParetoMask(data, sense, ROWS_COUNT, nullIndices);
+      validateParetoMask(mask, ROWS_COUNT);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+
+  test(`Performance: ${DATASET_SIZE_LABEL} with 25% null indices`, async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const data = generateSyntheticData(ROWS_COUNT, COLS_COUNT);
+      const sense = generateSense(COLS_COUNT, 'mixed');
+      const nullIndices = generateNullIndices(ROWS_COUNT, 0.25);
+      mask = getParetoMask(data, sense, ROWS_COUNT, nullIndices);
+      validateParetoMask(mask, ROWS_COUNT);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+
+  // Edge cases
+  test('Edge case: Empty dataset', async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const data: NumericArray[] = [new Float32Array(0), new Float32Array(0)];
+      const sense = generateSense(COLS_COUNT, 'mixed');
+      mask = getParetoMask(data, sense, 0);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(mask!.length, 0, 'Empty dataset should return empty mask');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+
+  test('Edge case: Single point', async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const data: NumericArray[] = [new Float32Array([1.0]), new Float32Array([2.0])];
+      const sense = generateSense(COLS_COUNT, 'mixed');
+
+      mask = getParetoMask(data, sense, 1);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(mask!.length, 1, 'Single point dataset should return mask with one element');
+    expect(mask![0], true, 'Single point should be optimal');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+
+  test('Edge case: All identical points', async () => {
+    let mask: boolean[] | null = null;
+    let error: Error | null = null;
+
+    try {
+      const nPoints = 100;
+      const data: NumericArray[] = [
+        new Float32Array(nPoints).fill(5.0),
+        new Float32Array(nPoints).fill(10.0),
+      ];
+      const sense = generateSense(COLS_COUNT, 'mixed');
+
+      mask = getParetoMask(data, sense, nPoints);
+    } catch (e) {
+      error = e as Error;
+      grok.shell.error(error.message);
+    }
+
+    expect(mask !== null, true, 'Failed to compute Pareto mask');
+    expect(mask!.length, 100, 'Should return mask with correct length');
+    const optimalCount = mask!.filter((x) => x).length;
+    expect(optimalCount > 0, true, 'At least some identical points should be optimal');
+    expect(error === null, true, error?.message ?? '');
+  }, {timeout: TIMEOUT});
+});