@datagrok/eda 1.4.10 → 1.4.12

package/src/pareto-optimization/pareto-optimizer.ts

@@ -0,0 +1,272 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import '../../css/pareto.css';
+import {NumericFeature, OPT_TYPE, DIFFERENCE, RATIO, COL_NAME, PC_MAX_COLS, ColorOpt} from './defs';
+import {getColorScaleDiv, getOutputPalette} from './utils';
+
+/** Pareto front optimization app */
+export class ParetoOptimizer {
+  private df: DG.DataFrame;
+  private numCols: DG.Column[];
+  private numColNames: string[] = [];
+  private numColsCount: number;
+  private rowCount: number;
+  private features = new Map<string, NumericFeature>();
+  private view: DG.TableView;
+  private pcPlot: DG.Viewer<DG.IPcPlotSettings>;
+  private toUpdatePcCols = false;
+  private paretoFrontViewer: DG.Viewer;
+  private resultColName: string;
+  private intervalId: NodeJS.Timeout | null = null;
+  private inputsMap = new Map<string, DG.InputBase>();
+  private pcPlotNode: DG.DockNode | null = null;
+  private inputFormNode: DG.DockNode | null = null;
+  private toChangeParetoViewerOptions = true;
+
+  constructor(df: DG.DataFrame) {
+    this.df = df;
+    const cols = df.columns;
+    const colList = cols.toList();
+    this.numCols = colList.filter((col) => col.isNumerical);
+    this.numColNames = this.numCols.map((col) => col.name);
+    this.numColsCount = this.numCols.length;
+    this.rowCount = df.rowCount;
+    this.view = grok.shell.getTableView(df.name);
+
+    this.paretoFrontViewer = DG.Viewer.fromType('Pareto front', df);
+
+    const paretoFrontViewerNode = this.view.dockManager.dock(
+      this.paretoFrontViewer,
+      DG.DOCK_TYPE.RIGHT,
+      null,
+      undefined,
+      RATIO.VIEWER,
+    );
+
+    this.pcPlot = DG.Viewer.pcPlot(df, {legendPosition: 'Top'});
+    const gridNode = this.view.dockManager.findNode(this.view.grid.root) ?? paretoFrontViewerNode;
+    this.pcPlotNode = this.view.dockManager.dock(this.pcPlot, DG.DOCK_TYPE.DOWN, gridNode, undefined, RATIO.VIEWER);
+    this.toUpdatePcCols = this.numColNames.length > PC_MAX_COLS;
+
+    this.resultColName = this.df.columns.getUnusedName(COL_NAME.OPT);
+    this.showResultOptCol();
+
+    this.view.subs.push(...this.getSubscriptions());
+  } // constructor
+
+  private isApplicable(): boolean {
+    if (this.rowCount < 1) {
+      grok.shell.warning('Cannot compute Pareto front: the table is empty.');
+      return false;
+    }
+
+    if (this.numColsCount < 2) {
+      grok.shell.warning('Cannot compute Pareto front: at least two numeric columns are required.');
+      return false;
+    }
+
+    return true;
+  } // isApplicable
+
+  public run(): void {
+    if (!this.isApplicable())
+      return;
+
+    this.buildInputsForm();
+    this.computeParetoFront();
+    this.updateVisualization();
+  } // run
+
+  private getSubscriptions() {
+    return [
+      this.paretoFrontViewer.onDetached.subscribe(() => {
+        if (this.pcPlotNode !== null) {
+          this.view.dockManager.close(this.pcPlotNode);
+          this.pcPlotNode = null;
+        }
+
+        if (this.inputFormNode !== null) {
+          this.view.dockManager.close(this.inputFormNode);
+          this.inputFormNode = null;
+        }
+
+        this.numCols.forEach((col) => col.colors.setDisabled());
+        this.features.clear();
+      }),
+    ];
+  } // getSubscriptions
+
+  private buildInputsForm(): void {
+    const form = ui.form([]);
+    form.classList.add('pareto-input-form');
+    form.append(ui.h1('Optimize'));
+
+    this.numCols.forEach((col, idx) => {
+      const feature: NumericFeature = {
+        toOptimize: this.numColsCount - idx - 1 < DIFFERENCE,
+        optType: OPT_TYPE.MIN,
+      };
+
+      const name = col.name;
+
+      const optimizationTypeInput = ui.input.choice(name, {
+        value: feature.toOptimize ? feature.optType : null,
+        nullable: true,
+        items: [null, OPT_TYPE.MIN, OPT_TYPE.MAX],
+        onValueChanged: (val) => {
+          if (val == null)
+            feature.toOptimize = false;
+          else {
+            feature.toOptimize = true;
+            feature.optType = val;
+          }
+
+          this.computeParetoFront();
+          this.updateVisualization();
+        },
+      });
+      ui.tooltip.bind(optimizationTypeInput.input, () => {
+        if (feature.toOptimize)
+          return ui.markdown(`M${feature.optType.slice(1)} **${name}** during Pareto optimization`);
+
+        return ui.markdown(`Ignore **${name}** during Pareto optimization`);
+      });
+
+      this.inputsMap.set(name, optimizationTypeInput);
+
+      form.append(optimizationTypeInput.root);
+      this.features.set(name, feature);
+    });
+
+    this.inputFormNode = this.view.dockManager.dock(form, DG.DOCK_TYPE.LEFT, null, undefined, RATIO.FORM);
+  } // buildInputsForm
+
+  private computeParetoFront(): void {
+    if (!this.toChangeParetoViewerOptions)
+      return;
+
+    const featureNames = this.getMinMaxFeatureNames();
+
+    this.paretoFrontViewer.setOptions({
+      minimizeColumnNames: featureNames.toMin,
+      maximizeColumnNames: featureNames.toMax,
+    });
+  } // computeParetoFront
+
+  private updatePcPlot(colNames: string[], colorOpt: ColorOpt): void {
+    this.pcPlot.setOptions(colorOpt);
+
+    // update value columns: check that optimized cols are included
+    if (this.toUpdatePcCols) {
+      const prevColNames = this.pcPlot.getOptions().look['columnNames'];
+
+      let toUpdatePcPlotColNames = false;
+
+      colNames.forEach((name) => {
+        if (!prevColNames.includes(name))
+          toUpdatePcPlotColNames = true;
+      });
+
+      if (toUpdatePcPlotColNames) {
+        const valColNames = [...colNames];
+        const notIncluded = this.numColNames.filter((name) => !valColNames.includes(name));
+        valColNames.push(...notIncluded.slice(0, PC_MAX_COLS - colNames.length));
+        this.pcPlot.setOptions({columnNames: valColNames});
+      }
+    }
+  } // updatePcPlot
+
+  private updateVisualization(): void {
+    const colNames: string[] = [];
+
+    this.features.forEach((fea, name) => {
+      if (fea.toOptimize)
+        colNames.push(name);
+    });
+
+    const colorOpt: ColorOpt = {'colorColumnName': (colNames.length > 0) ? this.resultColName: undefined};
+    this.updatePcPlot(colNames, colorOpt);
+    this.markOptColsWithColor();
+    this.updateTooltips();
+  } // updateVisualization
+
+  private showResultOptCol(): void {
+    // show a column with the results, once it is added
+    this.intervalId = setInterval(() => {
+      const gridCol = this.view.grid.columns.byName(this.resultColName);
+
+      if (gridCol !== null) {
+        gridCol.visible = true;
+        this.stopChecking();
+      }
+    }, 1000);
+  } // showResultOptCol
+
+  private stopChecking(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+  }
+
+  private markOptColsWithColor(): void {
+    this.numCols.forEach((col) => col.colors.setDisabled());
+
+    this.features.forEach((fea, name) => {
+      if (!fea.toOptimize)
+        return;
+
+      const col = this.df.col(name);
+
+      if (col != null)
+        col.colors.setLinear(getOutputPalette(fea.optType), {min: col.stats.min, max: col.stats.max});
+    });
+  } // markOptColsWithColor
+
+  private updateTooltips(): void {
+    const features = this.features;
+
+    this.view.grid.onCellTooltip(function(cell, x, y) {
+      if (cell.isColHeader) {
+        const cellCol = cell.tableColumn;
+        if (cellCol) {
+          const name = cell.tableColumn.name;
+          const feature = features.get(name);
+
+          if (feature !== undefined) {
+            const elems = [ui.markdown(`**${name}**`)];
+
+            if (feature.toOptimize) {
+              elems.push(ui.markdown(`This feature is **${feature.optType}d** during Pareto optimization.`));
+              elems.push(getColorScaleDiv(feature.optType));
+            }
+
+            ui.tooltip.show(ui.divV(elems), x, y);
+
+            return true;
+          }
+
+          return false;
+        }
+      }
+    });
+  } // updateTooltips
+
+  private getMinMaxFeatureNames() {
+    const minimizeColumnNames: string[] = [];
+    const maximizeColumnNames: string[] = [];
+
+    this.features.forEach((fea, name) => {
+      if (fea.toOptimize) {
+        if (fea.optType === OPT_TYPE.MIN)
+          minimizeColumnNames.push(name);
+        else
+          maximizeColumnNames.push(name);
+      }
+    });
+
+    return {toMin: minimizeColumnNames, toMax: maximizeColumnNames};
+  }
+} // ParetoOptimizer

package/src/pareto-optimization/utils.ts

@@ -0,0 +1,41 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import {OPT_TYPE} from './defs';
+
+export const PALETTE = [DG.Color.darkGreen, DG.Color.yellow, DG.Color.darkRed];
+
+/** Return output color palette w.r.t. the specified type of optimization */
+export function getOutputPalette(type: OPT_TYPE): number[] {
+  if (type === OPT_TYPE.MIN)
+    return [...PALETTE];
+
+  return [...PALETTE].reverse();
+}
+
+/** Return div with color scale description */
+export function getColorScaleDiv(type: OPT_TYPE, useMinMax: boolean = true): HTMLElement {
+  const scale = ui.label('Color scale:');
+  scale.style.paddingRight = '7px';
+  const elems = [scale];
+  const minLbl = ui.label(useMinMax ? 'min' : 'worst');
+  const midLbl = ui.label('. . .');
+  const maxLbl = ui.label(useMinMax ? 'max' : 'best');
+  const palette = getOutputPalette(type);
+
+  const colorElems = [minLbl, midLbl, maxLbl].map((el, idx) => {
+    if (idx !== 1) {
+      el.style.fontWeight = 'bold';
+      el.style.color = DG.Color.toRgb(palette[idx]);
+    }
+
+    el.style.marginRight = '5px';
+
+    return el;
+  });
+
+  elems.push(...colorElems);
+
+  return ui.divH(elems);
+} // getColorScaleDiv

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

@@ -0,0 +1,108 @@
+// Constants and type definitions for probabilistic scoring (pMPO)
+// Link: https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
+
+/** Minimum number of samples required to compute pMPO */
+export const MIN_SAMPLES_COUNT = 10;
+
+export const PMPO_NON_APPLICABLE = 'pMPO is not applicable';
+export const PMPO_COMPUTE_FAILED = 'Failed to compute pMPO parameters';
+
+/** Basic statistics for desired and non-desired compounds */
+export type BasicStats = {
+  desAvg: number,
+  desStd: number,
+  nonDesAvg: number,
+  nonDesStd: number,
+};
+
+/** Descriptor statistics including basic stats, t-statistics and p-value */
+export type DescriptorStatistics = BasicStats & {
+  desLen: number,
+  nonSesLen: number,
+  tstat: number,
+  pValue: number,
+};
+
+/** Cutoff parameters for the basic functions of the pMPO model */
+export type Cutoff = {
+  cutoff: number,
+  cutoffDesired: number,
+  cutoffNotDesired: number,
+};
+
+/** Generalized Sigmoid parameters for the desirability functions of the pMPO model */
+export type SigmoidParams = {
+  pX0: number,
+  b: number,
+  c: number,
+};
+
+/** pMPO parameters including basic stats, cutoffs, sigmoid params, z-score, weight, intersections */
+export type PmpoParams = BasicStats & Cutoff & SigmoidParams & {
+  zScore: number,
+  weight: number,
+  intersections: number[],
+  x0: number,
+  xBound: number,
+};
+
+export type CorrelationTriple = [string, string, number];
+
+const DESIRED = 'desired';
+const NON_DESIRED = 'non-desired';
+const MEAN = 'Mean';
+const STD = 'Std';
+const T_STAT = 't-statistics';
+export const P_VAL = 'p-value';
+const MEAN_DES = `${MEAN}(${DESIRED})`;
+const MEAN_NON_DES = `${MEAN}(${NON_DESIRED})`;
+const STD_DES = `${STD}(${DESIRED})`;
+const STD_NON_DES = `${STD}(${NON_DESIRED})`;
+
+/** Map of statistic field names to their display titles  */
+export const STAT_TO_TITLE_MAP = new Map([
+  ['desAvg', MEAN_DES],
+  ['desStd', STD_DES],
+  ['nonDesAvg', MEAN_NON_DES],
+  ['nonDesStd', STD_NON_DES],
+  ['tstat', T_STAT],
+  ['pValue', P_VAL],
+]);
+
+export const DESCR_TITLE = 'Descriptor';
+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';
+
+/** Minimum p-value threshold for filtering descriptors */
+export const P_VAL_TRES_MIN = 0.01;
+
+/** Minimum R-squared threshold for filtering correlated descriptors */
+export const R2_MIN = 0.01;
+
+/** Minimum q-cutoff for descriptors in the pMPO model */
+export const Q_CUTOFF_MIN = 0.01;
+
+/** Colors used for selected and skipped descriptors */
+export enum COLORS {
+  SELECTED = 'rgb(26, 146, 26)',
+  SKIPPED = 'rgb(208, 57, 67)',
+};
+
+export const TINY = 1e-8;
+
+/** Folder path for storing pMPO models */
+export const FOLDER = 'System:AppData/Chem/mpo';
+
+/** Desirability profile properties type */
+export type DesirabilityProfileProperties = Record<string, {
+  line: [number, number][],
+  weight: number,
+  min?: number,
+  max?: number,
+}>;
+
+export const STAT_GRID_HEIGHT = 75;
+export const DESIRABILITY_COLUMN_WIDTH = 305;