@datagrok/eda 1.4.12 → 1.5.0

package/src/probabilistic-scoring/data-generator.ts

@@ -0,0 +1,202 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {DescriptorStatistics, SOURCE_PATH, SYNTHETIC_DRUG_NAME} from './pmpo-defs';
+import {getDescriptorStatistics, getDesiredTables} from './stat-tools';
+
+//@ts-ignore: no types
+import * as jStat from 'jstat';
+
+/** Generates synthetic data for pMPO model training and testing
+ * @param samplesCount Number of samples to generate
+ * @returns DataFrame with generated data */
+export async function getSynteticPmpoData(samplesCount: number, isTest: boolean = true): Promise<DG.DataFrame> {
+  const df = await grok.dapi.files.readCsv(SOURCE_PATH);
+  const generator = new PmpoDataGenerator(df, 'Drug', 'CNS', 'Smiles');
+  const genTable = generator.getGenerated(samplesCount);
+
+  if (!isTest) {
+    genTable.columns.add(DG.Column.fromList(DG.COLUMN_TYPE.BOOL, 'Const bool', new Array(samplesCount).fill(true)));
+    genTable.columns.add(DG.Column.fromInt32Array('Const int', new Int32Array(samplesCount).fill(1)));
+
+    // Add a copy of the first numeric column with 5 missing values
+    const firstNumCol = genTable.columns.toList().find((col) => col.isNumerical);
+    if (firstNumCol) {
+      const colWithMissing = firstNumCol.clone();
+      colWithMissing.name = `${firstNumCol.name} (missing)`;
+      for (let i = 0; i < Math.min(5, colWithMissing.length); ++i)
+        colWithMissing.set(i, DG.FLOAT_NULL);
+      genTable.columns.add(colWithMissing);
+    }
+
+    // Add a column with all null values
+    genTable.columns.add(DG.Column.fromFloat32Array('Nulls', new Float32Array(samplesCount).fill(DG.FLOAT_NULL)));
+
+    // Add categorical columns
+    const categoricalCols = getCategoricalColumns(genTable.col('CNS')!, samplesCount);
+    for (const col of categoricalCols)
+      genTable.columns.add(col);
+  }
+
+  return genTable;
+} // getSynteticPmpoData
+
+/** Generates categorical columns based on a boolean source column
+ * @param sourceBoolCol Source boolean column to base the categorical columns on
+ * @param samplesCount Number of samples to generate
+ * @returns Array of generated categorical columns */
+function getCategoricalColumns(sourceBoolCol: DG.Column, samplesCount: number): DG.Column[] {
+  const source = sourceBoolCol.toList();
+  const stringLabels = new Array<string>(samplesCount);
+  const threeCats = new Array<string>(samplesCount);
+
+  for (let i = 0; i < samplesCount; ++i) {
+    stringLabels[i] = source[i] ? 'active' : 'non-active';
+    threeCats[i] = source[i] ? (Math.random() < 0.5 ? 'perfect' : 'good') : (Math.random() < 0.5 ? 'bad' : 'worst');
+  }
+
+  return [
+    DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'CNS (strings)', stringLabels),
+    DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'CNS (4 categories)', threeCats),
+    DG.Column.fromList(DG.COLUMN_TYPE.STRING, 'Single category', new Array<string>(samplesCount).fill('Unknown')),
+  ];
+} // getCategoricalColumns
+
+/** Class for generating synthetic data for pMPO model training and testing */
+export class PmpoDataGenerator {
+  private sourceDf: DG.DataFrame;
+  private drugName: string;
+  private desirabilityColName: string;
+  private smilesColName: string;
+  private desiredProbability: number;
+  private descriptorStats: Map<string, DescriptorStatistics>;
+
+  constructor(df: DG.DataFrame, drugName: string, desirabilityColName: string, smilesColName: string) {
+    this.sourceDf = df;
+    this.drugName = drugName;
+    this.desirabilityColName = desirabilityColName;
+    this.smilesColName = smilesColName;
+
+    const descriptorNames = df.columns.toList().filter((col) => col.isNumerical).map((col) => col.name);
+    const {desired, nonDesired} = getDesiredTables(df, df.col(desirabilityColName)!);
+
+    // Compute descriptors' statistics
+    this.descriptorStats = new Map<string, DescriptorStatistics>();
+    descriptorNames.forEach((name) => {
+      this.descriptorStats.set(name, getDescriptorStatistics(desired.col(name)!, nonDesired.col(name)!));
+    });
+
+    // Probability of desired class
+    this.desiredProbability = desired.rowCount / df.rowCount;
+  } // constructor
+
+  /** Generates synthetic data for pMPO model training and testing
+   * @param samplesCount Number of samples to generate
+   * @returns DataFrame with generated data */
+  public getGenerated(samplesCount: number): DG.DataFrame {
+    if (samplesCount <= 1)
+      throw new Error('Failed to generate pMPO data: sample count must be greater than 1.');
+
+    let result: DG.DataFrame;
+
+    /* Use rows from the source dataframe if the requested sample count
+       is less than or equal to the source dataframe row count */
+    if (samplesCount <= this.sourceDf.rowCount) {
+      const rowMask = DG.BitSet.create(this.sourceDf.rowCount);
+
+      for (let i = 0; i < samplesCount; ++i)
+        rowMask.set(i, true);
+
+      result = this.sourceDf.clone(rowMask);
+    } else {
+      const cloneDf = this.getClonedSourceDfWithFloatNumericCols();
+      result = cloneDf.append(this.getSyntheticTable(samplesCount - this.sourceDf.rowCount));
+    }
+
+    // Check boolean columns and ensure non-zero stdev
+    for (const col of result.columns) {
+      if (col.type === DG.COLUMN_TYPE.BOOL && col.stats.stdev === 0) {
+        // All values are the same, flip the first value
+        let value = col.get(0);
+        col.set(0, !value);
+
+        value = col.get(1);
+        col.set(1, !value);
+      }
+    }
+
+    return result;
+  } // getGenerated
+
+  /** Generates a synthetic data table
+   * @param samplesCount Number of samples to generate
+   * @returns DataFrame with synthetic data */
+  private getSyntheticTable(samplesCount: number): DG.DataFrame {
+    const desirabilityRaw = new Array<boolean>(samplesCount);
+
+    for (let i = 0; i < samplesCount; ++i)
+      desirabilityRaw[i] = (Math.random() < this.desiredProbability);
+
+
+    const cols = [
+      this.getDrugColumn(samplesCount),
+      this.getSmilesColumn(samplesCount),
+      DG.Column.fromList(DG.COLUMN_TYPE.BOOL, this.desirabilityColName, desirabilityRaw),
+    ];
+
+    this.descriptorStats.forEach((stat, name) => {
+      const arr = new Float32Array(samplesCount);
+
+      for (let i = 0; i < samplesCount; ++i) {
+        if (desirabilityRaw[i])
+          arr[i] = jStat.normal.sample(stat.desAvg, stat.desStd);
+        else
+          arr[i] = jStat.normal.sample(stat.nonDesAvg, stat.nonDesStd);
+      }
+
+      // @ts-ignore
+      cols.push(DG.Column.fromFloat32Array(name, arr));
+    });
+
+    return DG.DataFrame.fromColumns(cols);
+  } // getSyntheticTable
+
+  /** Generates a column with synthetic drug names
+   * @param samplesCount Number of samples to generate
+   * @returns Column with synthetic drug names */
+  private getDrugColumn(samplesCount: number): DG.Column<string> {
+    return DG.Column.fromList(
+      DG.COLUMN_TYPE.STRING,
+      this.drugName,
+      Array.from({length: samplesCount}, (_, i) => `${SYNTHETIC_DRUG_NAME} ${i + 1}`));
+  }
+
+  /** Generates a column with synthetic SMILES strings
+   * @param samplesCount Number of samples to generate
+   * @returns Column with synthetic SMILES strings */
+  private getSmilesColumn(samplesCount: number): DG.Column<string> {
+    return DG.Column.fromList(
+      DG.COLUMN_TYPE.STRING,
+      this.smilesColName,
+      Array.from({length: samplesCount}, () => 'C'));
+  }
+
+  /** Clones the source dataframe converting numerical columns to Float type
+   * @returns Cloned dataframe */
+  private getClonedSourceDfWithFloatNumericCols(): DG.DataFrame {
+    const cols: DG.Column[] = [];
+
+    this.sourceDf.columns.toList().forEach((col) => {
+      if (col.isNumerical)
+        cols.push(col.clone().convertTo(DG.COLUMN_TYPE.FLOAT));
+      else
+        cols.push(col.clone());
+    });
+
+    const clone = DG.DataFrame.fromColumns(cols);
+    clone.name = this.sourceDf.name;
+
+    return clone;
+  }
+} // PmpoDataGenerator

package/src/probabilistic-scoring/nelder-mead.ts

@@ -0,0 +1,204 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+function getInitialParams(
+  objectiveFunc: (x: Float32Array) => number,
+  settings: Map<string, number>,
+  paramsInitial: Float32Array,
+  restrictionsBottom: Float32Array,
+  restrictionsTop: Float32Array): [Float32Array[], number[]] {
+  const dim = paramsInitial.length + 1;
+  const dimParams = paramsInitial.length;
+  const nonZeroParam = settings.get('nonZeroParam')!;
+  const initScale = settings.get('initialScale')!;
+
+  const optParams = new Array<Float32Array>(dim);
+  const pointObjectives = new Array<number>(dim);
+
+  for (let i = 0; i < dim; i++) {
+    optParams[i] = new Float32Array(dimParams);
+    for (let j = 0; j < dimParams; j++) {
+      optParams[i][j] = paramsInitial[j];
+      if (i != 0 && i - 1 === j) {
+        if (paramsInitial[j] == 0)
+          optParams[i][j] = nonZeroParam;
+        else
+          optParams[i][j] += initScale * paramsInitial[i - 1];
+
+        if (optParams[i][j] < restrictionsBottom[j])
+          optParams[i][j] = restrictionsBottom[j];
+        else if (optParams[i][j] > restrictionsTop[j])
+          optParams[i][j] = restrictionsTop[j];
+      }
+    }
+
+    pointObjectives[i] = objectiveFunc(optParams[i]);
+  }
+
+  return [optParams, pointObjectives];
+} // getInitialParams
+
+function fillCentroid(centroid: Float32Array, dimParams: number, lastIndex: number, optParams: Float32Array[]) {
+  for (let i = 0; i < dimParams; i++) {
+    let val = 0;
+    for (let j = 0; j < dimParams + 1; j++) {
+      if (j != lastIndex)
+        val += optParams[j][i];
+    }
+
+    centroid[i] = val / dimParams;
+  }
+} // fillCentroid
+
+function fillPoint(
+  centroid: Float32Array, point: Float32Array,
+  lastIndex: number, optParams: Float32Array[],
+  scale: number, dimParams: number,
+  restrictionsBottom: Float32Array,
+  restrictionsTop: Float32Array) {
+  for (let i = 0; i < dimParams; i++) {
+    point[i] = centroid[i];
+    point[i] += scale * (centroid[i] - optParams[lastIndex][i]);
+
+    if (point[i] < restrictionsBottom[i])
+      point[i] = restrictionsBottom[i];
+    else if (point[i] > restrictionsTop[i])
+      point[i] = restrictionsTop[i];
+  }
+} // fillPoint
+
+export async function optimizeNM(pi: DG.ProgressIndicator,
+  objectiveFunc: (x: Float32Array) => number, paramsInitial: Float32Array,
+  settings: Map<string, number>, restrictionsBottom: Float32Array, restrictionsTop: Float32Array) {
+  // Settings initialization
+  const tolerance = settings.get('tolerance')!;
+  const maxIter = settings.get('maxIter')!;
+  const scaleReflection = settings.get('scaleReflaction')!;
+  const scaleExpansion = settings.get('scaleExpansion')!;
+  const scaleContraction = settings.get('scaleContraction')!;
+
+  const dim = paramsInitial.length + 1;
+  const dimParams = paramsInitial.length;
+
+  const [optParams, pointObjectives] = getInitialParams(
+    objectiveFunc,
+    settings,
+    paramsInitial,
+    restrictionsBottom,
+    restrictionsTop,
+  );
+
+  const indexes = new Array<number>(dim);
+  for (let i = 0; i < dim; i++)
+    indexes[i] = i;
+
+  const lastIndex = indexes.length - 1;
+
+  let iteration = 0;
+  let best = 0;
+  let previousBest = 0;
+  let noImprovement = 0;
+
+  const centroid = new Float32Array(dimParams);
+  const reflectionPoint = new Float32Array(dimParams);
+  const expansionPoint = new Float32Array(dimParams);
+  const contractionPoint = new Float32Array(dimParams);
+  const costs = new Array<number>(maxIter);
+
+  if (dim > 1) {
+    let percentage = 0;
+
+    while (true) {
+      indexes.sort((a:number, b:number) => {
+        return pointObjectives[a] - pointObjectives[b];
+      });
+
+      percentage = Math.min(100, Math.floor(100 * (iteration) / maxIter));
+      pi.update(percentage, `Optimizing pMPO... (${percentage}%)`);
+      await new Promise((r) => setTimeout(r, 1));
+
+      if (pi.canceled)
+        break;
+
+      if (iteration > maxIter)
+        break;
+
+      if (iteration == 0) {
+        best = pointObjectives[0];
+        previousBest = 2*pointObjectives[indexes[0]];
+      }
+      costs[iteration] = best;
+
+      ++iteration;
+
+      best = pointObjectives[indexes[0]];
+      if (previousBest - best > tolerance)
+        noImprovement = 0;
+      else {
+        ++noImprovement;
+        if (noImprovement > 2 * dim)
+          break;
+      }
+
+      previousBest = best;
+
+      //centroid
+      fillCentroid(centroid, dimParams, indexes[lastIndex], optParams);
+
+      // reflection
+      fillPoint(centroid, reflectionPoint, indexes[lastIndex],
+        optParams, scaleReflection, dimParams, restrictionsBottom, restrictionsTop);
+      const reflectionScore = objectiveFunc(reflectionPoint);
+
+      // expansion
+      if (reflectionScore < pointObjectives[indexes[lastIndex]]) {
+        fillPoint(centroid, expansionPoint, indexes[lastIndex],
+          optParams, scaleExpansion, dimParams, restrictionsBottom, restrictionsTop);
+
+        const expansionScore = objectiveFunc(expansionPoint);
+
+        if (expansionScore < reflectionScore) {
+          pointObjectives[indexes[lastIndex]] = expansionScore;
+
+          for (let i = 0; i < dimParams; i++)
+            optParams[indexes[lastIndex]][i] = expansionPoint[i];
+
+          continue;
+        } else {
+          pointObjectives[indexes[lastIndex]] = reflectionScore;
+
+          for (let i = 0; i < dimParams; i++)
+            optParams[indexes[lastIndex]][i] = reflectionPoint[i];
+
+          continue;
+        }
+      }
+
+      // Contraction
+      fillPoint(centroid, contractionPoint, indexes[lastIndex],
+        optParams, scaleContraction, dimParams, restrictionsBottom, restrictionsTop);
+
+      const contractionScore = objectiveFunc(contractionPoint);
+
+      if (contractionScore < pointObjectives[indexes[lastIndex]]) {
+        pointObjectives[indexes[lastIndex]] = contractionScore;
+
+        for (let i = 0; i < dimParams; i++)
+          optParams[indexes[lastIndex]][i] = contractionPoint[i];
+
+        continue;
+      }
+
+      break;
+    } // while
+
+    for (let i = iteration; i < maxIter; i++)
+      costs[i] = pointObjectives[indexes[0]];
+  } // if
+
+  return {
+    optimalPoint: optParams[indexes[0]],
+    iterations: iteration,
+  };
+}; // optimizeNM

package/src/probabilistic-scoring/pmpo-defs.ts

@@ -1,5 +1,5 @@
 // Constants and type definitions for probabilistic scoring (pMPO)
-// Link: https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
+// Source paper https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
 
 /** Minimum number of samples required to compute pMPO */
 export const MIN_SAMPLES_COUNT = 10;
@@ -13,6 +13,8 @@ export type BasicStats = {
   desStd: number,
   nonDesAvg: number,
   nonDesStd: number,
+  min: number,
+  max: number,
 };
 
 /** Descriptor statistics including basic stats, t-statistics and p-value */
@@ -44,6 +46,7 @@ export type PmpoParams = BasicStats & Cutoff & SigmoidParams & {
   intersections: number[],
   x0: number,
   xBound: number,
+  inflection: number,
 };
 
 export type CorrelationTriple = [string, string, number];
@@ -74,17 +77,40 @@ export const DESCR_TABLE_TITLE = DESCR_TITLE + ' Statistics';
 export const SELECTED_TITLE = 'Selected';
 export const WEIGHT_TITLE = 'Weight';
 export const SCORES_TITLE = 'pMPO score';
-export const DESIRABILITY_COL_NAME = 'Desirability';
+export const DESIRABILITY_COL_NAME = 'Desirability Curve';
+
+/** Default p-value threshold for filtering descriptors */
+export const P_VAL_TRES_DEFAULT = 0.001;
 
 /** Minimum p-value threshold for filtering descriptors */
-export const P_VAL_TRES_MIN = 0.01;
+export const P_VAL_TRES_MIN = 0.001;
+
+/** Maximum p-value threshold for filtering descriptors */
+export const P_VAL_TRES_MAX = 1;
+
+/** Default R-squared threshold for filtering correlated descriptors */
+export const R2_DEFAULT = 0.53;
 
 /** Minimum R-squared threshold for filtering correlated descriptors */
 export const R2_MIN = 0.01;
 
+/** Maximum R-squared threshold for filtering correlated descriptors */
+export const R2_MAX = 1.0;
+
+/** Default q-cutoff for descriptors in the pMPO model */
+export const Q_CUTOFF_DEFAULT = 0.05;
+
 /** Minimum q-cutoff for descriptors in the pMPO model */
 export const Q_CUTOFF_MIN = 0.01;
 
+/** Maximum q-cutoff for descriptors in the pMPO model */
+export const Q_CUTOFF_MAX = 1;
+
+/** Default setting for using sigmoid correction in pMPO */
+export const USE_SIGMOID_DEFAULT = true;
+
+export const FORMAT = '0.000';
+
 /** Colors used for selected and skipped descriptors */
 export enum COLORS {
   SELECTED = 'rgb(26, 146, 26)',
@@ -106,3 +132,115 @@ export type DesirabilityProfileProperties = Record<string, {
 
 export const STAT_GRID_HEIGHT = 75;
 export const DESIRABILITY_COLUMN_WIDTH = 305;
+
+const POSITIVE_BASIC_RANGE_SIGMA_COEFFS = [0, 0.25, 0.5, 1, 1.5, 2, 2.5, 3, 4, 5];
+
+/** Basic range sigma coefficients for desirability profile points */
+export const BASIC_RANGE_SIGMA_COEFFS = POSITIVE_BASIC_RANGE_SIGMA_COEFFS
+  .slice(1)
+  .map((v) => -v)
+  .reverse()
+  .concat(POSITIVE_BASIC_RANGE_SIGMA_COEFFS);
+
+const EXTRA_RANGE_SIGMA_COEFFS = [0.12, 0.37, 0.63, 0.75, 0.88, 1.25, 1.75, 2.25, 2.75];
+const EXTENDED_POSITIVE_RANGE_SIGMA_COEFFS = POSITIVE_BASIC_RANGE_SIGMA_COEFFS.concat(EXTRA_RANGE_SIGMA_COEFFS).sort();
+
+/** Extended range sigma coefficients for desirability profile points */
+export const EXTENDED_RANGE_SIGMA_COEFFS = EXTENDED_POSITIVE_RANGE_SIGMA_COEFFS
+  .slice(1)
+  .map((v) => -v)
+  .reverse()
+  .concat(EXTENDED_POSITIVE_RANGE_SIGMA_COEFFS);
+
+/** Confusion matrix type */
+export type ConfusionMatrix = {
+  TP: number,
+  TN: number,
+  FP: number,
+  FN: number,
+};
+
+// Titles for ROC curve columns
+export const TPR_TITLE = 'TPR (Sensitivity)';
+export const FPR_TITLE = 'FPR (1 - Specificity)';
+export const THRESHOLD = 'Threshold';
+
+// Number of points in ROC curve
+const ROC_POINTS = 100;
+export const ROC_TRESHOLDS_COUNT = ROC_POINTS + 1;
+
+/** ROC curve thresholds from 0.0 to 1.0 */
+export const ROC_TRESHOLDS = new Float32Array(Array.from({length: ROC_TRESHOLDS_COUNT}, (_, i) => i / ROC_POINTS));
+
+/** Sample dataframe for pMPO training: https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/ */
+export const SOURCE_PATH = 'System:AppData/Eda/drugs-props-train.csv';
+
+/** Scores of the sample dataframe computed using https://github.com/Merck/pmpo */
+export const SCORES_PATH = 'System:AppData/Eda/drugs-props-train-scores.csv';
+
+/** Name of the synthetic drug used in the sample dataframe */
+export const SYNTHETIC_DRUG_NAME = 'Synthetic drug';
+
+/** pMPO model evaluation result type */
+export type ModelEvaluationResult = {
+  auc: number,
+  threshold: number,
+  tpr: Float32Array,
+  fpr: Float32Array,
+};
+
+/** Maximum number of rows for which auto-tuning is applicable */
+export const AUTO_TUNE_MAX_APPLICABLE_ROWS = 10000;
+
+/** Default settings for optimization in pMPO parameter tuning */
+export const DEFAULT_OPTIMIZATION_SETTINGS = new Map<string, number>([
+  ['tolerance', 0.001],
+  ['maxIter', 25],
+  ['nonZeroParam', 0.0001],
+  ['initialScale', 0.02],
+  ['scaleReflaction', 1],
+  ['scaleExpansion', 2],
+  ['scaleContraction', -0.5],
+]);
+
+/** Optimal point type for pMPO parameter tuning */
+export type OptimalPoint = {
+  pValTresh: number,
+  r2Tresh: number,
+  qCutoff: number,
+  state: 'success' | 'canceled' | 'failed',
+  msg: string,
+};
+
+/** Minimum bounds for pMPO parameters during optimization */
+export const LOW_PARAMS_BOUNDS = new Float32Array([0.5, Q_CUTOFF_MIN]);
+
+/** Maximum bounds for pMPO parameters during optimization */
+export const HIGH_PARAMS_BOUNDS = new Float32Array([R2_MAX, Q_CUTOFF_MAX]);
+
+export enum EQUALITY_SIGN {
+  GREATER = '>',
+  LESS = '<',
+  GREATER_OR_EQUAL = '≥',
+  LESS_OR_EQUAL = '≤',
+  DEFAULT = LESS_OR_EQUAL,
+};
+
+export const SIGN_OPTIONS = [
+  EQUALITY_SIGN.GREATER,
+  EQUALITY_SIGN.LESS,
+  EQUALITY_SIGN.GREATER_OR_EQUAL,
+  EQUALITY_SIGN.LESS_OR_EQUAL,
+];
+
+export const THRESHOLDED_DESIRABILITY_COL_NAME = 'Desirability';
+
+export const PREFERABLE_CATEGORIES = ['perfect', 'good', 'true', 't', 'g', 'active', 'a', 'yes', 'y'];
+
+export type PmpoInputId = 'descriptors' | 'desirability' | 'threshold' | 'categories';
+export type TooltipContent = string | (() => HTMLElement);
+
+export interface PmpoValidationResult {
+  valid: boolean;
+  errors: Map<PmpoInputId, TooltipContent>;
+}