@datagrok/eda 1.4.12 → 1.4.13

package/src/probabilistic-scoring/prob-scoring.ts

@@ -10,15 +10,37 @@ import {MpoProfileEditor} from '@datagrok-libraries/statistics/src/mpo/mpo-profi
 
 import '../../css/pmpo.css';
 
-import {getDesiredTables, getDescriptorStatistics, normalPdf, sigmoidS} from './stat-tools';
+import {getDesiredTables, getDescriptorStatistics, getBoolPredictionColumn, getPmpoEvaluation} from './stat-tools';
 import {MIN_SAMPLES_COUNT, PMPO_NON_APPLICABLE, DescriptorStatistics, P_VAL_TRES_MIN, DESCR_TITLE,
   R2_MIN, Q_CUTOFF_MIN, PmpoParams, SCORES_TITLE, DESCR_TABLE_TITLE, PMPO_COMPUTE_FAILED, SELECTED_TITLE,
-  P_VAL, DESIRABILITY_COL_NAME, STAT_GRID_HEIGHT, DESIRABILITY_COLUMN_WIDTH, WEIGHT_TITLE} from './pmpo-defs';
+  P_VAL, DESIRABILITY_COL_NAME, STAT_GRID_HEIGHT, DESIRABILITY_COLUMN_WIDTH, WEIGHT_TITLE,
+  P_VAL_TRES_DEFAULT, R2_DEFAULT, Q_CUTOFF_DEFAULT, USE_SIGMOID_DEFAULT, ROC_TRESHOLDS,
+  FPR_TITLE, TPR_TITLE, COLORS, THRESHOLD, AUTO_TUNE_MAX_APPLICABLE_ROWS, DEFAULT_OPTIMIZATION_SETTINGS,
+  P_VAL_TRES_MAX, R2_MAX, Q_CUTOFF_MAX, OptimalPoint, LOW_PARAMS_BOUNDS, HIGH_PARAMS_BOUNDS, FORMAT} from './pmpo-defs';
 import {addSelectedDescriptorsCol, getDescriptorStatisticsTable, getFilteredByPvalue, getFilteredByCorrelations,
   getModelParams, getDescrTooltip, saveModel, getScoreTooltip, getDesirabilityProfileJson, getCorrelationTriples,
-  addCorrelationColumns, setPvalColumnColorCoding, setCorrColumnColorCoding} from './pmpo-utils';
+  addCorrelationColumns, setPvalColumnColorCoding, setCorrColumnColorCoding, PmpoError} from './pmpo-utils';
 import {getOutputPalette} from '../pareto-optimization/utils';
 import {OPT_TYPE} from '../pareto-optimization/defs';
+import {optimizeNM} from './nelder-mead';
+
+export type PmpoTrainingResult = {
+  params: Map<string, PmpoParams>,
+  descrStatsTable: DG.DataFrame,
+  selectedByPvalue: string[],
+  selectedByCorr: string[],
+};
+
+/** Type for pMPO training controls */
+export type Controls = {form: HTMLElement, saveBtn: HTMLButtonElement};
+
+/** Type for pMPO elements */
+export type PmpoAppItems = {
+  statsGrid: DG.Viewer;
+  rocCurve: DG.Viewer;
+  confusionMatrix: DG.Viewer;
+  controls: Controls;
+};
 
 /** Class implementing probabilistic MPO (pMPO) model training and prediction */
 export class Pmpo {
@@ -131,23 +153,93 @@ export class Pmpo {
     return true;
   } // isTableValid
 
+  /** Fits the pMPO model to the given data and returns training results */
+  static fit(df: DG.DataFrame, descriptors: DG.ColumnList, desirability: DG.Column,
+    pValTresh: number, r2Tresh: number, qCutoff: number, toCheckApplicability: boolean = true): PmpoTrainingResult {
+    if (toCheckApplicability) {
+      if (!Pmpo.isApplicable(descriptors, desirability, pValTresh, r2Tresh, qCutoff))
+        throw new Error('Failed to train pMPO model: the method is not applicable to the inputs');
+    }
+
+    const descriptorNames = descriptors.names();
+    const {desired, nonDesired} = getDesiredTables(df, desirability);
+
+    // Compute descriptors' statistics
+    const descrStats = new Map<string, DescriptorStatistics>();
+    descriptorNames.forEach((name) => {
+      descrStats.set(name, getDescriptorStatistics(desired.col(name)!, nonDesired.col(name)!));
+    });
+    const descrStatsTable = getDescriptorStatisticsTable(descrStats);
+
+    // Set p-value column color coding
+    setPvalColumnColorCoding(descrStatsTable, pValTresh);
+
+    // Filter by p-value
+    const selectedByPvalue = getFilteredByPvalue(descrStatsTable, pValTresh);
+
+    if (selectedByPvalue.length < 1)
+      throw new PmpoError('Cannot train pMPO model: all descriptors have high p-values (not significant).');
+
+    // Compute correlation triples
+    const correlationTriples = getCorrelationTriples(descriptors, selectedByPvalue);
+
+    // Filter by correlations
+    const selectedByCorr = getFilteredByCorrelations(descriptors, selectedByPvalue, descrStats, r2Tresh, correlationTriples);
+
+    // Add the Selected column
+    addSelectedDescriptorsCol(descrStatsTable, selectedByCorr);
+
+    // Add correlation columns
+    addCorrelationColumns(descrStatsTable, descriptorNames, correlationTriples, selectedByCorr);
+
+    // Set correlation columns color coding
+    setCorrColumnColorCoding(descrStatsTable, descriptorNames, r2Tresh);
+
+    // Compute pMPO parameters - training
+    const params = getModelParams(desired, nonDesired, selectedByCorr, qCutoff);
+
+    return {
+      params: params,
+      descrStatsTable: descrStatsTable,
+      selectedByPvalue: selectedByPvalue,
+      selectedByCorr: selectedByCorr,
+    };
+  } // fitModelParams
+
   /** Predicts pMPO scores for the given data frame using provided pMPO parameters */
-  static predict(df: DG.DataFrame, params: Map<string, PmpoParams>, predictionName: string): DG.Column {
+  static predict(df: DG.DataFrame, params: Map<string, PmpoParams>, useSigmoid: boolean, predictionName: string): DG.Column {
     const count = df.rowCount;
     const scores = new Float64Array(count).fill(0);
-    let x = 0;
 
     // Compute pMPO scores (see https://pmc.ncbi.nlm.nih.gov/articles/PMC4716604/
     params.forEach((param, name) => {
       const col = df.col(name);
+      const b = param.b;
+      const c = param.c;
+      const x0 = param.cutoff;
+      let weight = param.weight;
+      const avg = param.desAvg;
+      const std = param.desStd;
+      const frac = 1.0 / (2 * std**2);
 
       if (col == null)
-        throw new Error(`Filed to apply pMPO: inconsistent data, no column "${name}" in the table "${df.name}"`);
+        throw new Error(`Failed to apply pMPO: inconsistent data, no column "${name}" in the table "${df.name}"`);
 
       const vals = col.getRawData();
-      for (let i = 0; i < count; ++i) {
-        x = vals[i];
-        scores[i] += param.weight * normalPdf(x, param.desAvg, param.desStd) * sigmoidS(x, param.x0, param.b, param.c);
+
+      if (useSigmoid) {
+        if (c > 0) {
+          for (let i = 0; i < count; ++i)
+            scores[i] += weight * Math.exp(-((vals[i] - avg)**2) * frac) / (1.0 + b * (c ** (-(vals[i] - x0))));
+        } else {
+          weight = weight / (1.0 + b);
+
+          for (let i = 0; i < count; ++i)
+            scores[i] += weight * Math.exp(-((vals[i] - avg)**2) * frac);
+        }
+      } else {
+        for (let i = 0; i < count; ++i)
+          scores[i] += weight * Math.exp(-((vals[i] - avg)**2) * frac);
       }
     });
 
@@ -161,16 +253,34 @@ export class Pmpo {
   private boolCols: DG.Column[];
   private numericCols: DG.Column[];
 
-  private initTable = grok.data.demo.demog(10);
+  private initTable = DG.DataFrame.create();
 
   private statGrid = DG.Viewer.grid(this.initTable, {showTitle: true, title: DESCR_TABLE_TITLE});
 
   private predictionName = SCORES_TITLE;
+  private boolPredictionName = '';
 
   private desirabilityProfileRoots = new Map<string, HTMLElement>();
-  constructor(df: DG.DataFrame) {
+
+  private rocCurve = DG.Viewer.scatterPlot(this.initTable, {
+    showTitle: true,
+    showSizeSelector: false,
+    showColorSelector: false,
+  });
+
+  private confusionMatrix = DG.Viewer.fromType('Confusion matrix', this.initTable, {
+    xColumnName: 'control',
+    yColumnName: 'control',
+    showTitle: true,
+    title: 'Confusion Matrix',
+    descriptionPosition: 'Bottom',
+    description: 'Confusion matrix for the predicted vs actual desirability labels.',
+    descriptionVisibilityMode: 'Always',
+  });
+
+  constructor(df: DG.DataFrame, view?: DG.TableView) {
     this.table = df;
-    this.view = grok.shell.tableView(df.name) ?? grok.shell.addTableView(df);
+    this.view = view ?? (grok.shell.tableView(df.name) ?? grok.shell.addTableView(df));
     this.boolCols = this.getBoolCols();
     this.numericCols = this.getValidNumericCols();
     this.predictionName = df.columns.getUnusedName(SCORES_TITLE);
@@ -294,14 +404,12 @@ export class Pmpo {
           } else {
             const descriptor = grid.cell(DESCR_TITLE, cell.gridRow).value;
 
-            if ((colName === DESIRABILITY_COL_NAME) || (colName === WEIGHT_TITLE)) {
-              const startText = (colName === WEIGHT_TITLE) ? 'No weight' : 'No chart shown';
-
+            if (colName === WEIGHT_TITLE) {
               if (!this.desirabilityProfileRoots.has(descriptor)) {
                 if (selectedByPvalue.includes(descriptor))
-                  ui.tooltip.show(`${startText}: <b>${descriptor}</b> is excluded due to a high correlation with other descriptors.`, x, y);
+                  ui.tooltip.show(`No weight: <b>${descriptor}</b> is excluded due to a high correlation with other descriptors.`, x, y);
                 else
-                  ui.tooltip.show(`${startText}: <b>${descriptor}</b> is excluded due to a high p-value.`, x, y);
+                  ui.tooltip.show(`No weight: <b>${descriptor}</b> is excluded due to a high p-value.`, x, y);
 
                 return true;
               }
@@ -341,7 +449,23 @@ export class Pmpo {
         return;
 
       const descriptor = grid.cell(DESCR_TITLE, cell.gridRow).value;
-      cell.element = this.desirabilityProfileRoots.get(descriptor) ?? ui.div();
+      const element = this.desirabilityProfileRoots.get(descriptor);
+
+      if (element != null)
+        cell.element = element;
+      else {
+        const selected = selectedByPvalue.includes(descriptor);
+        const text = selected ? 'highly correlated with other descriptors' : 'statistically insignificant';
+        const tooltipMsg = selected ?
+          `No chart shown: <b>${descriptor}</b> is excluded due to a high correlation with other descriptors.` :
+          `No chart shown: <b>${descriptor}</b> is excluded due to a high p-value.`;
+
+        const divWithDescription = ui.divText(text);
+        divWithDescription.style.color = COLORS.SKIPPED;
+        divWithDescription.classList.add('eda-pmpo-centered-text');
+        ui.tooltip.bind(divWithDescription, tooltipMsg);
+        cell.element = divWithDescription;
+      }
     }); // grid.onCellPrepare
   } // updateGrid
 
@@ -372,7 +496,7 @@ export class Pmpo {
   } // updateGrid
 
   /** Updates the desirability profile data */
-  private updateDesirabilityProfileData(descrStatsTable: DG.DataFrame): void {
+  private updateDesirabilityProfileData(descrStatsTable: DG.DataFrame, useSigmoidalCorrection: boolean): void {
     if (this.params == null)
       return;
 
@@ -380,7 +504,7 @@ export class Pmpo {
     this.desirabilityProfileRoots.forEach((root) => root.remove());
     this.desirabilityProfileRoots.clear();
 
-    const desirabilityProfile = getDesirabilityProfileJson(this.params, '', '');
+    const desirabilityProfile = getDesirabilityProfileJson(this.params, useSigmoidalCorrection, '', '', true);
 
     // Set weights
     const descrNames = descrStatsTable.col(DESCR_TITLE)!.toList();
@@ -416,52 +540,69 @@ export class Pmpo {
     });
   } // updateDesirabilityProfileData
 
-  /** Fits the pMPO model to the given data and updates the viewers accordingly */
-  private fitAndUpdateViewers(df: DG.DataFrame, descriptors: DG.ColumnList, desirability: DG.Column,
-    pValTresh: number, r2Tresh: number, qCutoff: number): void {
-    if (!Pmpo.isApplicable(descriptors, desirability, pValTresh, r2Tresh, qCutoff))
-      throw new Error('Failed to train pMPO model: the method is not applicable to the inputs');
-
-    const descriptorNames = descriptors.names();
-    const {desired, nonDesired} = getDesiredTables(df, desirability);
-
-    // Compute descriptors' statistics
-    const descrStats = new Map<string, DescriptorStatistics>();
-    descriptorNames.forEach((name) => {
-      descrStats.set(name, getDescriptorStatistics(desired.col(name)!, nonDesired.col(name)!));
+  /** Updates the ROC curve viewer with the given desirability (labels) and prediction columns
+   * @return Best threshold according to Youden's J statistic
+   */
+  private updateRocCurve(desirability: DG.Column, prediction: DG.Column): number {
+    const evaluation = getPmpoEvaluation(desirability, prediction);
+
+    const rocDf = DG.DataFrame.fromColumns([
+      DG.Column.fromFloat32Array(THRESHOLD, ROC_TRESHOLDS),
+      DG.Column.fromFloat32Array(FPR_TITLE, evaluation.fpr),
+      DG.Column.fromFloat32Array(TPR_TITLE, evaluation.tpr),
+    ]);
+
+    // Add baseline
+    rocDf.meta.formulaLines.addLine({
+      title: 'Non-informative baseline',
+      formula: `\${${TPR_TITLE}} = \${${FPR_TITLE}}`,
+      width: 1,
+      style: 'dashed',
+      min: 0,
+      max: 1,
     });
-    const descrStatsTable = getDescriptorStatisticsTable(descrStats);
-
-    // Set p-value column color coding
-    setPvalColumnColorCoding(descrStatsTable, pValTresh);
-
-    // Filter by p-value
-    const selectedByPvalue = getFilteredByPvalue(descrStatsTable, pValTresh);
-
-    // Compute correlation triples
-    const correlationTriples = getCorrelationTriples(descriptors, selectedByPvalue);
-
-    // Filter by correlations
-    const selectedByCorr = getFilteredByCorrelations(descriptors, selectedByPvalue, descrStats, r2Tresh, correlationTriples);
 
-    // Add the Selected column
-    addSelectedDescriptorsCol(descrStatsTable, selectedByCorr);
+    this.rocCurve.dataFrame = rocDf;
+    this.rocCurve.setOptions({
+      xColumnName: FPR_TITLE,
+      yColumnName: TPR_TITLE,
+      linesOrderColumnName: FPR_TITLE,
+      linesWidth: 5,
+      markerType: 'dot',
+      title: `ROC Curve (AUC = ${evaluation.auc.toFixed(3)})`,
+    });
 
-    // Add correlation columns
-    addCorrelationColumns(descrStatsTable, descriptorNames, correlationTriples, selectedByCorr);
+    return evaluation.threshold;
+  } // updateRocCurve
+
+  /** Updates the confusion matrix viewer with the given data frame, desirability column name, and best threshold */
+  private updateConfusionMatrix(df: DG.DataFrame, desColName: string, bestThreshold: number): void {
+    this.confusionMatrix.dataFrame = df;
+    this.confusionMatrix.setOptions({
+      xColumnName: desColName,
+      yColumnName: this.boolPredictionName,
+      description: `Threshold: ${bestThreshold.toFixed(3)} (optimized via Youden's J)`,
+      title: desColName + ' Confusion Matrix',
+    });
+  } // updateConfusionMatrix
 
-    // Set correlation columns color coding
-    setCorrColumnColorCoding(descrStatsTable, descriptorNames, r2Tresh);
+  /** Fits the pMPO model to the given data and updates the viewers accordingly */
+  private fitAndUpdateViewers(df: DG.DataFrame, descriptors: DG.ColumnList, desirability: DG.Column,
+    pValTresh: number, r2Tresh: number, qCutoff: number, useSigmoid: boolean): void {
+    const trainResult = Pmpo.fit(df, descriptors, desirability, pValTresh, r2Tresh, qCutoff);
+    this.params = trainResult.params;
+    const descrStatsTable = trainResult.descrStatsTable;
+    const selectedByPvalue = trainResult.selectedByPvalue;
+    const selectedByCorr = trainResult.selectedByCorr;
 
-    // Compute pMPO parameters - training
-    this.params = getModelParams(desired, nonDesired, selectedByCorr, qCutoff);
+    const descriptorNames = descriptors.names();
 
-    //const weightsTable = getWeightsTable(this.params);
-    const prediction = Pmpo.predict(df, this.params, this.predictionName);
+    const prediction = Pmpo.predict(df, this.params, useSigmoid, this.predictionName);
 
     // Mark predictions with a color
     prediction.colors.setLinear(getOutputPalette(OPT_TYPE.MAX), {min: prediction.stats.min, max: prediction.stats.max});
 
+    // Remove existing prediction column and add the new one
     df.columns.remove(this.predictionName);
     df.columns.add(prediction);
 
@@ -469,10 +610,25 @@ export class Pmpo {
     this.updateGrid();
 
     // Update desirability profile roots map
-    this.updateDesirabilityProfileData(descrStatsTable);
+    this.updateDesirabilityProfileData(descrStatsTable, useSigmoid);
 
     // Update statistics grid
     this.updateStatisticsGrid(descrStatsTable, descriptorNames, selectedByPvalue, selectedByCorr);
+
+    // Update ROC curve
+    const bestThreshold = this.updateRocCurve(desirability, prediction);
+
+    // Update desirability prediction column
+    const desColName = desirability.name;
+    df.columns.remove(this.boolPredictionName);
+    this.boolPredictionName = df.columns.getUnusedName(desColName + '(predicted)');
+    const boolPrediction = getBoolPredictionColumn(prediction, bestThreshold, this.boolPredictionName);
+    df.columns.add(boolPrediction);
+
+    // Update confusion matrix
+    this.updateConfusionMatrix(df, desColName, bestThreshold);
+
+    this.view.dataFrame.selection.setAll(false, true);
   } // fitAndUpdateViewers
 
   /** Runs the pMPO model training application */
@@ -480,7 +636,7 @@ export class Pmpo {
     const dockMng = this.view.dockManager;
 
     // Inputs form
-    dockMng.dock(this.getInputForm(), DG.DOCK_TYPE.LEFT, null, undefined, 0.1);
+    dockMng.dock(this.getInputForm(true).form, DG.DOCK_TYPE.LEFT, null, undefined, 0.1);
 
     // Dock viewers
     const gridNode = dockMng.findNode(this.view.grid.root);
@@ -488,13 +644,30 @@ export class Pmpo {
     if (gridNode == null)
       throw new Error('Failed to train pMPO: missing a grid in the table view.');
 
-    dockMng.dock(this.statGrid, DG.DOCK_TYPE.DOWN, gridNode, undefined, 0.5);
+    // Dock statistics grid
+    const statGridNode = dockMng.dock(this.statGrid, DG.DOCK_TYPE.DOWN, gridNode, undefined, 0.5);
+
+    // Dock ROC curve
+    const rocNode = dockMng.dock(this.rocCurve, DG.DOCK_TYPE.RIGHT, statGridNode, undefined, 0.3);
+
+    // Dock confusion matrix
+    dockMng.dock(this.confusionMatrix, DG.DOCK_TYPE.RIGHT, rocNode, undefined, 0.2);
 
     this.setRibbons();
   } // runTrainingApp
 
+  /** Runs the pMPO model training application */
+  public getPmpoAppItems(): PmpoAppItems {
+    return {
+      statsGrid: this.statGrid,
+      rocCurve: this.rocCurve,
+      confusionMatrix: this.confusionMatrix,
+      controls: this.getInputForm(false),
+    };
+  } // getViewers
+
   /** Creates and returns the input form for pMPO model training */
-  private getInputForm(): HTMLElement {
+  private getInputForm(addBtn: boolean): Controls {
     const form = ui.form([]);
     form.append(ui.h2('Training data'));
     const numericColNames = this.numericCols.map((col) => col.name);
@@ -502,16 +675,21 @@ export class Pmpo {
     // Function to run computations on input changes
     const runComputations = () => {
       try {
+        //grok.shell.info('Running...');
+
         this.fitAndUpdateViewers(
           this.table,
           DG.DataFrame.fromColumns(descrInput.value).columns,
-        this.table.col(desInput.value!)!,
-        pInput.value!,
-        rInput.value!,
-        qInput.value!,
+          this.table.col(desInput.value!)!,
+          pInput.value!,
+          rInput.value!,
+          qInput.value!,
+          useSigmoidInput.value,
         );
       } catch (err) {
-        grok.shell.error(err instanceof Error ? err.message : PMPO_COMPUTE_FAILED + ': the platform issue.');
+        err instanceof PmpoError ?
+          grok.shell.warning(err.message) :
+          grok.shell.error(err instanceof Error ? err.message : PMPO_COMPUTE_FAILED + ': the platform issue.');
       }
     };
 
@@ -523,8 +701,10 @@ export class Pmpo {
       checked: numericColNames,
       tooltipText: 'Descriptor columns used for model construction.',
       onValueChanged: (value) => {
-        if (value != null)
-          runComputations();
+        if (value != null) {
+          areTunedSettingsUsed = false;
+          checkAutoTuneAndRun();
+        }
       },
     });
     form.append(descrInput.root);
@@ -536,26 +716,95 @@ export class Pmpo {
       items: this.boolCols.map((col) => col.name),
       tooltipText: 'Desirability column.',
       onValueChanged: (value) => {
-        if (value != null)
-          runComputations();
+        if (value != null) {
+          areTunedSettingsUsed = false;
+          checkAutoTuneAndRun();
+        }
       },
     });
     form.append(desInput.root);
 
-    const header = ui.h2('Thresholds');
-    ui.tooltip.bind(header, 'Settings of the pMPO model training.');
+    const header = ui.h2('Settings');
     form.append(header);
+    ui.tooltip.bind(header, 'Settings of the pMPO model.');
+
+    // use sigmoid correction
+    const useSigmoidInput = ui.input.bool('\u03C3 correction', {
+      value: USE_SIGMOID_DEFAULT,
+      tooltipText: 'Use the sigmoidal correction to the weighted Gaussian scores.',
+      onValueChanged: (_value) => {
+        areTunedSettingsUsed = false;
+        checkAutoTuneAndRun();
+      },
+    });
+    form.append(useSigmoidInput.root);
+
+    const toUseAutoTune = (this.table.rowCount <= AUTO_TUNE_MAX_APPLICABLE_ROWS);
+
+    // Flag indicating whether optimal parameters from auto-tuning are currently used
+    let areTunedSettingsUsed = false;
+
+    const setOptimalParametersAndRun = async () => {
+      if (!areTunedSettingsUsed) {
+        const optimalSettings = await this.getOptimalSettings(
+          DG.DataFrame.fromColumns(descrInput.value).columns,
+          this.table.col(desInput.value!)!,
+          useSigmoidInput.value,
+        );
+
+        if (optimalSettings.success) {
+          pInput.value = Math.max(optimalSettings.pValTresh, P_VAL_TRES_MIN);
+          rInput.value = Math.max(optimalSettings.r2Tresh, R2_MIN);
+          qInput.value = Math.max(optimalSettings.qCutoff, Q_CUTOFF_MIN);
+          areTunedSettingsUsed = true;
+        } else
+          autoTuneInput.value = false; // revert to manual mode if optimization failed
+      }
+
+      runComputations();
+    };
+
+    const checkAutoTuneAndRun = () => {
+      if (autoTuneInput.value)
+        setOptimalParametersAndRun();
+      else
+        runComputations();
+    };
+
+    // autotuning input
+    const autoTuneInput = ui.input.bool('Auto-tuning', {
+      value: false,
+      tooltipText: 'Automatically select optimal p-value, R², and q-cutoff by maximizing AUC.',
+      onValueChanged: async (value) => {
+        setEnability(!value);
+
+        if (areTunedSettingsUsed)
+          return;
+
+        // If auto-tuning is turned on, set optimal parameters and run computations
+        if (value)
+          await setOptimalParametersAndRun();
+      },
+    });
+    form.append(autoTuneInput.root);
 
     // p-value threshold input
     const pInput = ui.input.float('p-value', {
       nullable: false,
       min: P_VAL_TRES_MIN,
-      max: 1,
-      step: 0.01,
-      value: 0.05,
-      tooltipText: 'Descriptors with p-values above this threshold are excluded.',
+      max: P_VAL_TRES_MAX,
+      step: 0.001,
+      value: P_VAL_TRES_DEFAULT,
+      // @ts-ignore
+      format: FORMAT,
+      tooltipText: 'P-value threshold. Descriptors with p-values above this threshold are excluded.',
       onValueChanged: (value) => {
-        if ((value != null) && (value >= P_VAL_TRES_MIN) && (value <= 1))
+        // Prevent running computations when auto-tuning is on, since parameters will be set automatically
+        if (autoTuneInput.value)
+          return;
+
+        areTunedSettingsUsed = false;
+        if ((value != null) && (value >= P_VAL_TRES_MIN) && (value <= P_VAL_TRES_MAX))
           runComputations();
       },
     });
@@ -563,15 +812,23 @@ export class Pmpo {
 
     // R² threshold input
     const rInput = ui.input.float('R²', {
+      // @ts-ignore
+      format: FORMAT,
       nullable: false,
       min: R2_MIN,
-      value: 0.5,
-      max: 1,
+      value: R2_DEFAULT,
+      max: R2_MAX,
       step: 0.01,
       // eslint-disable-next-line max-len
-      tooltipText: 'Descriptors with squared correlation above this threshold are considered highly correlated. Among them, the descriptor with the lower p-value is retained.',
+      tooltipText: 'Squared correlation threshold. Descriptors with squared correlation above this threshold are considered highly correlated. Among them, the descriptor with the lower p-value is retained.',
       onValueChanged: (value) => {
-        if ((value != null) && (value >= R2_MIN) && (value <= 1))
+        // Prevent running computations when auto-tuning is on, since parameters will be set automatically
+        if (autoTuneInput.value)
+          return;
+
+        areTunedSettingsUsed = false;
+
+        if ((value != null) && (value >= R2_MIN) && (value <= R2_MAX))
           runComputations();
       },
     });
@@ -579,36 +836,62 @@ export class Pmpo {
 
     // q-cutoff input
     const qInput = ui.input.float('q-cutoff', {
+      // @ts-ignore
+      format: FORMAT,
       nullable: false,
       min: Q_CUTOFF_MIN,
-      value: 0.05,
-      max: 1,
+      value: Q_CUTOFF_DEFAULT,
+      max: Q_CUTOFF_MAX,
       step: 0.01,
       tooltipText: 'Q-cutoff for the pMPO model computation.',
       onValueChanged: (value) => {
-        if ((value != null) && (value >= Q_CUTOFF_MIN) && (value <= 1))
+        // Prevent running computations when auto-tuning is on, since parameters will be set automatically
+        if (autoTuneInput.value)
+          return;
+
+        areTunedSettingsUsed = false;
+
+        if ((value != null) && (value >= Q_CUTOFF_MIN) && (value <= Q_CUTOFF_MAX))
           runComputations();
       },
     });
     form.append(qInput.root);
 
-    setTimeout(() => runComputations(), 10);
+    const setEnability = (toEnable: boolean) => {
+      pInput.enabled = toEnable;
+      rInput.enabled = toEnable;
+      qInput.enabled = toEnable;
+    };
+
+    setTimeout(() => {
+      runComputations();
+
+      if (toUseAutoTune)
+        autoTuneInput.value = true; // this will trigger setting optimal parameters and running computations
+      else
+        runComputations();
+    }, 10);
 
     // Save model button
-    const saveBtn = ui.button('Save model', async () => {
+    const saveBtn = ui.button('Save', async () => {
       if (this.params == null) {
         grok.shell.warning('Failed to save pMPO model: null parameters.');
         return;
       }
 
-      saveModel(this.params, this.table.name);
+      saveModel(this.params, this.table.name, useSigmoidInput.value);
     }, 'Save model as platform file.');
-    form.append(saveBtn);
+
+    if (addBtn)
+      form.append(saveBtn);
 
     const div = ui.div([form]);
     div.classList.add('eda-pmpo-input-form');
 
-    return div;
+    return {
+      form: div,
+      saveBtn: saveBtn,
+    };
   } // getInputForm
 
   /** Retrieves boolean columns from the data frame */
@@ -634,4 +917,75 @@ export class Pmpo {
 
     return res;
   } // getValidNumericCols
+
+  /** Fits the pMPO model to the given data and updates the viewers accordingly */
+  private async getOptimalSettings(descriptors: DG.ColumnList, desirability: DG.Column, useSigmoid: boolean): Promise<OptimalPoint> {
+    const failedResult: OptimalPoint = {
+      pValTresh: 0,
+      r2Tresh: 0,
+      qCutoff: 0,
+      success: false,
+    };
+
+    const descriptorNames = descriptors.names();
+    const {desired, nonDesired} = getDesiredTables(this.table, desirability);
+
+    // Compute descriptors' statistics
+    const descrStats = new Map<string, DescriptorStatistics>();
+    descriptorNames.forEach((name) => {
+      descrStats.set(name, getDescriptorStatistics(desired.col(name)!, nonDesired.col(name)!));
+    });
+    const descrStatsTable = getDescriptorStatisticsTable(descrStats);
+
+    // Filter by p-value
+    const selectedByPvalue = getFilteredByPvalue(descrStatsTable, P_VAL_TRES_DEFAULT);
+    if (selectedByPvalue.length < 1)
+      return failedResult;
+
+    const correlationTriples = getCorrelationTriples(descriptors, selectedByPvalue);
+
+    const funcToBeMinimized = (point: Float32Array) => {
+      // Filter by correlations
+      const selectedByCorr = getFilteredByCorrelations(descriptors, selectedByPvalue, descrStats, point[0], correlationTriples);
+
+      // Compute pMPO parameters - training
+      const params = getModelParams(desired, nonDesired, selectedByCorr, point[1]);
+
+      // Get predictions
+      const prediction = Pmpo.predict(this.table, params, useSigmoid, this.predictionName);
+
+      // Evaluate predictions and return 1 - AUC (since optimization minimizes the function, but we want to maximize AUC)
+      return 1 - getPmpoEvaluation(desirability, prediction).auc;
+    }; // funcToBeMinimized
+
+    const pi = DG.TaskBarProgressIndicator.create('Optimizing... ', {cancelable: true});
+
+    try {
+      const optimalResult = await optimizeNM(
+        pi,
+        funcToBeMinimized,
+        new Float32Array([R2_DEFAULT, Q_CUTOFF_DEFAULT]),
+        DEFAULT_OPTIMIZATION_SETTINGS,
+        LOW_PARAMS_BOUNDS,
+        HIGH_PARAMS_BOUNDS,
+      );
+
+      const success = !pi.canceled;
+      pi.close();
+
+      if (success) {
+        return {
+          pValTresh: P_VAL_TRES_DEFAULT,
+          r2Tresh: optimalResult.optimalPoint[0],
+          qCutoff: optimalResult.optimalPoint[1],
+          success: true,
+        };
+      } else
+        return failedResult;
+    } catch (err) {
+      pi.close();
+
+      return failedResult;
+    }
+  } // getOptimalSettings
 }; // Pmpo