@datagrok/eda 1.4.12 → 1.4.13

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

@@ -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,253 @@
+// 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});
+});

package/src/tests/pmpo-tests.ts

@@ -0,0 +1,157 @@
+// Tests for Probabilistic MPO (pMPO)
+// Reference scores are pre-computed and stored in the 'drugs-props-train-scores.csv' file.
+// This scores are computed using the library: https://github.com/Merck/pmpo
+
+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 {Pmpo} from '../probabilistic-scoring/prob-scoring';
+import {P_VAL_TRES_DEFAULT, Q_CUTOFF_DEFAULT, R2_DEFAULT, SCORES_PATH,
+  SOURCE_PATH} from '../probabilistic-scoring/pmpo-defs';
+import {getSynteticPmpoData} from '../probabilistic-scoring/data-generator';
+
+const TIMEOUT = 10000;
+const MAD_THRESH = 1E-6;
+
+const DESIRABILITY_COL_NAME = 'CNS';
+const DESCRIPTOR_NAMES = ['TPSA', 'TPSA_S', 'HBA', 'HBD', 'MW', 'nAtoms',
+  'cLogD_ACD_v15', 'mapKa', 'cLogP_Biobyte', 'mbpKa', 'cLogP_ACD_v15', 'ALogP98'];
+const SCORES_NAME = 'Score';
+const DRUG = 'Drug';
+
+const SIGMOIDAL = 'Sigmoidal';
+const GAUSSIAN = 'Gaussian';
+const PMPO_MODES = [SIGMOIDAL, GAUSSIAN];
+
+const SAMPLES_K = 100;
+const SAMPLES_COUNT = 1000 * SAMPLES_K;
+
+/** Computes the maximum absolute deviation between pMPO scores in two data frames */
+function getScoreMaxDeviation(sourceDrugCol: DG.Column, sourceScores: DG.Column,
+  referenceDrugCol: DG.Column, referenceScores: DG.Column): number {
+  let mad = 0;
+
+  const sourceDrugList = sourceDrugCol.toList();
+  const referenceDrugList = referenceDrugCol.toList();
+
+  const sourceScoresRaw = sourceScores.getRawData();
+  const referenceScoresRaw = referenceScores.getRawData();
+
+  sourceDrugList.forEach((name, idx) => {
+    const refIdx = referenceDrugList.indexOf(name);
+
+    if (refIdx < 0)
+      throw new Error(`Failed to compare pMPO scores: the "${name}" drug is missing in the reference data.`);
+
+    mad = Math.max(mad, Math.abs(sourceScoresRaw[idx] - referenceScoresRaw[refIdx]));
+  });
+
+  return mad;
+} // getScoreMaxDeviation
+
+category('Probabilistic MPO', () => {
+  // Correctness tests: compare pMPO scores with reference scores
+  PMPO_MODES.forEach((refScoreName) => {
+    const useSigmoid = (refScoreName == SIGMOIDAL);
+
+    test('Correctness: ' + refScoreName, async () => {
+      let sourceDf: DG.DataFrame | null = null;
+      let referenceDf: DG.DataFrame | null = null;
+      let desirability: DG.Column | null = null;
+      let descriptors: DG.Column[] = [];
+      let sourceDrugCol: DG.Column | null = null;
+      let referenceDrugCol: DG.Column | null = null;
+      let referencePrediction: DG.Column | null = null;
+      let mad: number | null = null;
+
+      try {
+        // Load data
+        sourceDf = await grok.dapi.files.readCsv(SOURCE_PATH);
+        referenceDf = await grok.dapi.files.readCsv(SCORES_PATH);
+
+        // Extract training items
+        desirability = sourceDf.col(DESIRABILITY_COL_NAME);
+        descriptors = sourceDf.columns.byNames(DESCRIPTOR_NAMES);
+
+        if (desirability == null)
+          throw new Error();
+
+        // Train pMPO model
+        const trainRes = Pmpo.fit(
+          sourceDf,
+          DG.DataFrame.fromColumns(descriptors).columns,
+          desirability,
+          P_VAL_TRES_DEFAULT,
+          R2_DEFAULT,
+          Q_CUTOFF_DEFAULT,
+        );
+
+        // Apply pMPO
+        const prediction = Pmpo.predict(sourceDf, trainRes.params, useSigmoid, SCORES_NAME);
+
+        // Compare with reference scores
+        sourceDrugCol = sourceDf.col(DRUG);
+        referenceDrugCol = referenceDf.col(DRUG);
+        referencePrediction = referenceDf.col(refScoreName);
+
+        mad = getScoreMaxDeviation(sourceDrugCol!, prediction, referenceDrugCol!, referencePrediction!);
+
+        //console.log(refScoreName, ': max absolute deviation of pMPO scores:', mad);
+      } catch (error) {
+        grok.shell.error((error as Error).message);
+      }
+
+      expect(sourceDf !== null, true, 'Failed to load the source data: ' + SOURCE_PATH);
+      expect(referenceDf !== null, true, 'Failed to load the scores data: ' + SCORES_PATH);
+      expect(desirability !== null, true, 'Inconsistent source data: no column ' + DESIRABILITY_COL_NAME);
+      expect(descriptors.length, DESCRIPTOR_NAMES.length, 'Inconsistent source data: no enough of columns');
+      expect(sourceDrugCol !== null, true, 'Inconsistent source data: no column ' + DRUG);
+      expect(referenceDrugCol !== null, true, 'Inconsistent reference data: no column ' + DRUG);
+      expect(referencePrediction !== null, true, 'Inconsistent reference data: no column ' + SCORES_NAME);
+      expect(mad !== null, true, 'Failed to compare pMPO scores with the reference data');
+      expect(mad! < MAD_THRESH, true, `Max absolute deviation of pMPO scores exceeds the threshold (${MAD_THRESH})`);
+    }, {timeout: TIMEOUT});
+  });
+
+  // Performance tests: measure time of pMPO training
+  test('Performance: ' + SAMPLES_K + 'K drugs, ' + DESCRIPTOR_NAMES.length + ' descriptors', async () => {
+    let sourceDf: DG.DataFrame | null = null;
+    let desirability: DG.Column | null = null;
+    let descriptors: DG.Column[] = [];
+
+    try {
+      // Generate synthetic data
+      sourceDf = await getSynteticPmpoData(SAMPLES_COUNT);
+
+      // Extract training items
+      desirability = sourceDf.col(DESIRABILITY_COL_NAME);
+      descriptors = sourceDf.columns.byNames(DESCRIPTOR_NAMES);
+
+      if (desirability == null)
+        throw new Error();
+
+      // Train pMPO model
+      const trainRes = Pmpo.fit(
+        sourceDf,
+        DG.DataFrame.fromColumns(descriptors).columns,
+        desirability,
+        P_VAL_TRES_DEFAULT,
+        R2_DEFAULT,
+        Q_CUTOFF_DEFAULT,
+      );
+
+      // Apply pMPO
+      Pmpo.predict(sourceDf, trainRes.params, true, SCORES_NAME);
+    } catch (error) {
+      grok.shell.error((error as Error).message);
+    }
+
+    expect(sourceDf !== null, true, 'Failed to load the source data: ' + SOURCE_PATH);
+    expect(desirability !== null, true, 'Inconsistent source data: no column ' + DESIRABILITY_COL_NAME);
+    expect(descriptors.length, DESCRIPTOR_NAMES.length, 'Inconsistent source data: no enough of columns');
+  }, {timeout: TIMEOUT});
+});