@datagrok/eda 1.1.9 → 1.1.11

package/src/missing-values-imputation/ui.ts

@@ -0,0 +1,246 @@
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+
+import { TITLE, KNN_IMPUTER, ERROR_MSG, HINT } from './ui-constants';
+import { SUPPORTED_COLUMN_TYPES, METRIC_TYPE, DISTANCE_TYPE, MetricInfo, DEFAULT, MIN_NEIGHBORS, 
+  impute, getMissingValsIndices, areThereFails, imputeFailed } from "./knn-imputer";
+
+/** Setting of the feature metric inputs */
+type FeatureInputSettings = {
+  defaultWeight: number,
+  defaultMetric: METRIC_TYPE,
+  availableMetrics: METRIC_TYPE[], 
+};
+
+/** Return default setting of the feature metric inputs */
+function getFeatureInputSettings(type: DG.COLUMN_TYPE): FeatureInputSettings {
+  switch (type) {
+    case DG.COLUMN_TYPE.STRING:
+    case DG.COLUMN_TYPE.DATE_TIME:
+      return {
+        defaultWeight: DEFAULT.WEIGHT,
+        defaultMetric: METRIC_TYPE.ONE_HOT,
+        availableMetrics: [METRIC_TYPE.ONE_HOT]
+      };
+
+    case DG.COLUMN_TYPE.INT:
+    case DG.COLUMN_TYPE.FLOAT:
+    case DG.COLUMN_TYPE.QNUM:
+      return {
+        defaultWeight: DEFAULT.WEIGHT,
+        defaultMetric: METRIC_TYPE.DIFFERENCE,
+        availableMetrics: [METRIC_TYPE.DIFFERENCE, METRIC_TYPE.ONE_HOT]
+      };
+
+    default:
+      throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
+  }
+}
+
+/** Run the KNN missing values imputer */
+export function runKNNImputer(): void {
+  /** current dataframe */
+  let df: DG.DataFrame | null = grok.shell.t;
+
+  if (df === null) {
+    grok.shell.warning(ERROR_MSG.NO_DATAFRAME);
+    return;
+  }    
+
+  /** columns with missing values */
+  const colsWithMissingVals = [] as DG.Column[];
+
+  /** names of columns with missing values */
+  const availableTargetColsNames = [] as string[];
+
+  /** names of columns that can be used as features */
+  const availableFeatureColsNames = [] as string[];
+
+  // get columns with missing vals & available feature cols
+  df.columns.toList()
+    .filter((col) => SUPPORTED_COLUMN_TYPES.includes(col.type))
+    .forEach((col) => {
+      availableFeatureColsNames.push(col.name);
+
+      if (col.stats.missingValueCount > 0) {
+        colsWithMissingVals.push(col);
+        availableTargetColsNames.push(col.name);
+      }
+    });
+
+  // get indices of missing values: col name -> array of indices
+  const misValsInds = getMissingValsIndices(colsWithMissingVals);
+
+  if (colsWithMissingVals.length === 0) {
+    grok.shell.info(ERROR_MSG.NO_MISSING_VALUES);
+    return;
+  }
+
+  if (availableFeatureColsNames.length === 1) {
+    grok.shell.error(ERROR_MSG.ONE_AVAILABLE_FEATURE);
+    return;
+  }
+
+  // In-place components
+  let inPlace = DEFAULT.IN_PLACE > 0;
+  const inPlaceInput = ui.boolInput(TITLE.IN_PLACE, inPlace, () => { inPlace = inPlaceInput.value ?? false;});
+  inPlaceInput.setTooltip(HINT.IN_PLACE);
+
+  // Keep empty feature
+  let keepEmpty = DEFAULT.KEEP_EMPTY > 0;
+  const keepEmptyInput = ui.boolInput(TITLE.KEEP_EMPTY, keepEmpty, () => { keepEmpty = keepEmptyInput.value ?? false });
+  keepEmptyInput.setTooltip(HINT.KEEP_EMPTY);
+
+  // Neighbors components
+  let neighbors = DEFAULT.NEIGHBORS;
+  const neighborsInput = ui.intInput(TITLE.NEIGHBORS, neighbors, () => {
+    const val = neighborsInput.value;
+    if (val === null)
+      neighborsInput.value = neighbors;
+    else if (val >= MIN_NEIGHBORS) 
+      neighbors = val;
+    else
+      neighborsInput.value = neighbors;
+  });
+  neighborsInput.setTooltip(HINT.NEIGHBORS);
+
+  // Distance components
+  let distType = DISTANCE_TYPE.EUCLIDEAN;
+  const distTypeInput = ui.choiceInput(TITLE.DISTANCE, distType, [DISTANCE_TYPE.EUCLIDEAN, DISTANCE_TYPE.MANHATTAN], 
+    () => distType = distTypeInput.value ?? DISTANCE_TYPE.EUCLIDEAN);
+  distTypeInput.setTooltip(HINT.DISTANCE);
+
+  // Target columns components (cols with missing values to be imputed)
+  let targetColNames = colsWithMissingVals.map((col) => col.name);
+  const targetColInput = ui.columnsInput(TITLE.COLUMNS, df, () => {
+    targetColNames = targetColInput.value.map((col) => col.name);    
+    checkApplicability();
+  }, {available: availableTargetColsNames, checked: availableTargetColsNames});
+  targetColInput.setTooltip(HINT.TARGET);
+
+  // Feature columns components
+  let selectedFeatureColNames = availableFeatureColsNames as string[];
+  const featuresInput = ui.columnsInput(TITLE.FEATURES, df, () => {    
+    selectedFeatureColNames = featuresInput.value.map((col) => col.name);
+
+    if (selectedFeatureColNames.length > 0) {
+      checkApplicability();
+      metricInfoInputs.forEach((div, name) => div.hidden = !selectedFeatureColNames.includes(name));      
+    }
+    else
+      hideWidgets();
+  }, {available: availableFeatureColsNames, checked: availableFeatureColsNames});
+  featuresInput.setTooltip(HINT.FEATURES);
+
+  /** Hide widgets (use if run is not applicable) */
+  const hideWidgets = () => {
+    dlg.getButton(TITLE.RUN).disabled = true;
+    inPlaceInput.root.hidden = true;
+    keepEmptyInput.root.hidden = true;
+    neighborsInput.root.hidden = true;
+    distDiv.hidden = true;
+    metricsDiv.hidden = true;
+  };
+
+  /** Show widgets (use if run is applicable) */
+  const showWidgets = () => {
+    dlg.getButton(TITLE.RUN).disabled = false;
+    distDiv.hidden = false;
+    inPlaceInput.root.hidden = false;
+    neighborsInput.root.hidden = false;
+    distTypeInput.root.hidden = false;
+    keepEmptyInput.root.hidden = !areThereFails(targetColNames, selectedFeatureColNames, misValsInds);
+  };
+
+  /** Check applicability of the imputation */
+  const checkApplicability = () => {
+    showWidgets();    
+    
+    if (selectedFeatureColNames.length === 1) {
+      targetColNames.forEach((name) => {
+        if (selectedFeatureColNames[0] === name) {
+          hideWidgets();
+          grok.shell.warning(`${ERROR_MSG.ONE_FEATURE_SELECTED} the column '${name}'`);
+      }});
+    }
+  };
+
+  // Metrics components
+  const featuresMetrics = new Map<string, MetricInfo>();
+  const metricInfoInputs = new Map<string, HTMLDivElement>();
+  const metricsDiv = ui.divV([]);
+  metricsDiv.style.overflow = 'auto';
+
+  // Create metrics UI
+  availableFeatureColsNames.forEach((name) => {    
+    // initialization
+    const type = df!.col(name)!.type as DG.COLUMN_TYPE;
+    const settings = getFeatureInputSettings(type);
+    featuresMetrics.set(name, {weight: settings.defaultWeight, type: settings.defaultMetric});
+
+    // distance input
+    const distTypeInput = ui.choiceInput(name, settings.defaultMetric, settings.availableMetrics, () => {
+      const distInfo = featuresMetrics.get(name) ?? {weight: settings.defaultWeight, type: settings.defaultMetric};
+      distInfo.type = distTypeInput.value ?? settings.defaultMetric;
+      featuresMetrics.set(name, distInfo);
+    });
+    distTypeInput.root.style.width = '50%';
+    distTypeInput.setTooltip(HINT.METRIC);
+    distTypeInput.root.hidden = true; // this input will be used further
+
+    // The following should provide a slider (see th bug https://reddata.atlassian.net/browse/GROK-14431)
+    // @ts-ignore
+    const prop = DG.Property.fromOptions({ "name": name, "inputType": "Float", min: 0, max: 10, "showSlider": true, "step": 1});
+    const weightInput = ui.input.forProperty(prop);
+    weightInput.value = settings.defaultWeight;
+    weightInput.onChanged(() => {
+      const distInfo = featuresMetrics.get(name) ?? {weight: settings.defaultWeight, type: settings.defaultMetric};
+      distInfo.weight = weightInput.value ?? settings.defaultWeight;
+      featuresMetrics.set(name, distInfo);
+    });
+    weightInput.setTooltip(HINT.WEIGHT);
+    
+    const div = ui.divH([distTypeInput.root, weightInput.root]);
+    metricInfoInputs.set(name, div);
+    metricsDiv.append(div);
+  });
+
+  // The main dialog
+  const dlg = ui.dialog({title: TITLE.KNN_IMPUTER, helpUrl: KNN_IMPUTER});
+  grok.shell.v.root.appendChild(dlg.root);
+
+  metricsDiv.hidden = true;
+  keepEmptyInput.root.hidden = !areThereFails(targetColNames, selectedFeatureColNames, misValsInds);
+
+  // Icon showing/hiding metrics UI
+  const settingsIcon = ui.icons.settings(() => { metricsDiv.hidden = !metricsDiv.hidden;}, HINT.METRIC_SETTINGS);
+
+  const distDiv = ui.divH([distTypeInput.root, settingsIcon]);
+
+  dlg.addButton(TITLE.RUN, () => {
+      dlg.close();
+      availableFeatureColsNames.filter((name) => !selectedFeatureColNames.includes(name)).forEach((name) => featuresMetrics.delete(name));
+
+      try {
+        const failedToImpute = impute(df!, targetColNames, featuresMetrics, misValsInds, distType, neighbors, inPlace);
+
+        if (!keepEmpty)
+          imputeFailed(df!, failedToImpute);
+      }
+      catch (err) {
+        if (err instanceof Error)
+          grok.shell.error(`${ERROR_MSG.KNN_FAILS}: ${err.message}`);
+        else
+          grok.shell.error(`${ERROR_MSG.KNN_FAILS}: ${ERROR_MSG.CORE_ISSUE}`);
+      }      
+    })
+    .add(targetColInput)
+    .add(featuresInput)    
+    .add(distDiv)
+    .add(metricsDiv)
+    .add(neighborsInput)
+    .add(inPlaceInput)
+    .add(keepEmptyInput)
+    .show();
+} // runKNNImputer

package/src/package-test.ts

@@ -1,7 +1,7 @@
-import * as DG from "datagrok-api/dg";
+import * as DG from 'datagrok-api/dg';
 import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
 
-export let _package = new DG.Package();
+export const _package = new DG.Package();
 export {tests};
 
 //name: test

package/src/package.ts

@@ -1,3 +1,5 @@
+/* eslint-disable camelcase */
+/* eslint-disable max-len */
 /* Do not change these import lines to match external modules in webpack configuration */
 import * as grok from 'datagrok-api/grok';
 import * as ui from 'datagrok-api/ui';
@@ -7,22 +9,24 @@ import {DemoScript} from '@datagrok-libraries/tutorials/src/demo-script';
 
 import {_initEDAAPI} from '../wasm/EDAAPI';
 import {computePCA, computePLS} from './eda-tools';
-import {addPrefixToEachColumnName, addPLSvisualization, regressionCoefficientsBarChart, 
+import {addPrefixToEachColumnName, addPLSvisualization, regressionCoefficientsBarChart,
   scoresScatterPlot, predictedVersusReferenceScatterPlot, addOneWayAnovaVizualization} from './eda-ui';
 import {carsDataframe, testDataForBinaryClassification} from './data-generators';
-import {LINEAR, RBF, POLYNOMIAL, SIGMOID, 
+import {LINEAR, RBF, POLYNOMIAL, SIGMOID,
   getTrainedModel, getPrediction, showTrainReport, getPackedModel} from './svm';
 
 import {oneWayAnova} from './stat-tools';
-import { getDbscanWorker } from '@datagrok-libraries/math';
+import {getDbscanWorker} from '@datagrok-libraries/math';
 
 import {DistanceAggregationMethods} from '@datagrok-libraries/ml/src/distance-matrix/types';
 import {MultiColumnDimReductionEditor} from
   '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reduction-editor';
 import {multiColReduceDimensionality} from
   '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/reduce-dimensionality';
-import { KnownMetrics } from '@datagrok-libraries/ml/src/typed-metrics';
-import { DimReductionMethods } from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
+import {KnownMetrics} from '@datagrok-libraries/ml/src/typed-metrics';
+import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/types';
+
+import {runKNNImputer} from './missing-values-imputation/ui';
 
 export const _package = new DG.Package();
 
@@ -63,8 +67,7 @@ export async function dbScan(df: DG.DataFrame, xCol: DG.Column, yCol: DG.Column,
 //input: bool scale = false [Indicating whether the variables should be scaled to have unit variance.]
 //output: dataframe result {action:join(table)}
 export async function PCA(table: DG.DataFrame, features: DG.ColumnList, components: number,
-  center: boolean, scale: boolean): Promise<DG.DataFrame> 
-{
+  center: boolean, scale: boolean): Promise<DG.DataFrame> {
   const pcaTable = await computePCA(table, features, components, center, scale);
   addPrefixToEachColumnName('PCA', pcaTable.columns);
   return pcaTable;
@@ -120,9 +123,8 @@ export async function reduceDimensionality(): Promise<void> {
 //input: column_list features {type: numerical}
 //input: column predict {type: numerical}
 //input: int components = 3
-export async function PLS(table: DG.DataFrame, names: DG.Column, features: DG.ColumnList, 
-  predict: DG.Column, components: number): Promise<void> 
-{
+export async function PLS(table: DG.DataFrame, names: DG.Column, features: DG.ColumnList,
+  predict: DG.Column, components: number): Promise<void> {
   const plsResults = await computePLS(table, features, predict, components);
   addPLSvisualization(table, names, features, predict, plsResults);
 }
@@ -131,17 +133,17 @@ export async function PLS(table: DG.DataFrame, names: DG.Column, features: DG.Co
 //description: Multidimensional data analysis using partial least squares (PLS) regression. It reduces the predictors to a smaller set of uncorrelated components and performs least squares regression on them.
 //meta.demoPath: Compute | Multivariate analysis
 //meta.isDemoScript: True
-export async function demoMultivariateAnalysis(): Promise<any>  {
-  const demoScript = new DemoScript('Partial least squares regression', 
-    'Analysis of multidimensional data.'); 
-  
+export async function demoMultivariateAnalysis(): Promise<any> {
+  const demoScript = new DemoScript('Partial least squares regression',
+    'Analysis of multidimensional data.');
+
   const cars = carsDataframe();
 
   const components = 3;
   const names = cars.columns.byName('model');
   const predict = cars.columns.byName('price');
   const features = cars.columns.remove('price').remove('model');
-  const plsOutput = await computePLS(cars, features, predict, components);  
+  const plsOutput = await computePLS(cars, features, predict, components);
 
   const sourceCars = carsDataframe();
   sourceCars.name = 'Cars';
@@ -154,7 +156,7 @@ export async function demoMultivariateAnalysis(): Promise<any>  {
       view = grok.shell.getTableView(sourceCars.name);
     }, {description: 'Each car has many features - patterns extraction is complicated.', delay: 0})
     .step('Model', async () => {
-      dialog = ui.dialog({title:'Multivariate Analysis (PLS)'})
+      dialog = ui.dialog({title: 'Multivariate Analysis (PLS)'})
         .add(ui.tableInput('Table', sourceCars))
         .add(ui.columnsInput('Features', cars, features.toList, {available: undefined, checked: features.names()}))
         .add(ui.columnInput('Names', cars, names, undefined))
@@ -165,16 +167,14 @@ export async function demoMultivariateAnalysis(): Promise<any>  {
         })
         .show({x: 400, y: 140});
     }, {description: 'Predict car price by its other features.', delay: 0})
-    .step('Regression coeffcicients', async () => 
-      {
-        dialog.close();
-        view.addViewer(regressionCoefficientsBarChart(features, plsOutput[1]))},
-      {description: 'The feature "diesel" affects the price the most.', delay: 0})
-    .step('Scores', async () => 
-      {view.addViewer(scoresScatterPlot(names, plsOutput[2], plsOutput[3]))}, 
+    .step('Regression coeffcicients', async () => {
+      dialog.close();
+      view.addViewer(regressionCoefficientsBarChart(features, plsOutput[1]));
+    },
+    {description: 'The feature "diesel" affects the price the most.', delay: 0})
+    .step('Scores', async () => {view.addViewer(scoresScatterPlot(names, plsOutput[2], plsOutput[3]));},
       {description: 'Similarities & dissimilarities: alfaromeo and mercedes are different.', delay: 0})
-    .step('Prediction', async () => 
-      {view.addViewer(predictedVersusReferenceScatterPlot(names, predict, plsOutput[0]))}, 
+    .step('Prediction', async () => {view.addViewer(predictedVersusReferenceScatterPlot(names, predict, plsOutput[0]));},
       {description: 'Closer to the line means better price prediction.', delay: 0})
     .start();
 }
@@ -188,9 +188,8 @@ export async function demoMultivariateAnalysis(): Promise<any>  {
 //input: double max = 173 {caption: max; category: Range}
 //input: double violatorsPercentage = 5 {caption: violators; units: %; category: Dataset}
 //output: dataframe df
-export async function testDataLinearSeparable(name: string, samplesCount: number, featuresCount: number, 
-  min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> 
-{
+export async function testDataLinearSeparable(name: string, samplesCount: number, featuresCount: number,
+  min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> {
   return await testDataForBinaryClassification(LINEAR, [0, 0], name, samplesCount, featuresCount,
     min, max, violatorsPercentage);
 }
@@ -205,9 +204,8 @@ export async function testDataLinearSeparable(name: string, samplesCount: number
 //input: double max = 173 {caption: max; category: Range}
 //input: double violatorsPercentage = 5 {caption: violators; units: %; category: Dataset}
 //output: dataframe df
-export async function testDataLinearNonSeparable(name: string, sigma: number, samplesCount: number, 
-  featuresCount: number, min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> 
-{
+export async function testDataLinearNonSeparable(name: string, sigma: number, samplesCount: number,
+  featuresCount: number, min: number, max: number, violatorsPercentage: number): Promise<DG.DataFrame> {
   return await testDataForBinaryClassification(RBF, [sigma, 0], name, samplesCount, featuresCount,
     min, max, violatorsPercentage);
 }
@@ -220,10 +218,9 @@ export async function testDataLinearNonSeparable(name: string, sigma: number, sa
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, toShowReport: boolean): Promise<any> 
-{    
-  const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predict_column);   
+export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, toShowReport: boolean): Promise<any> {
+  const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -237,8 +234,8 @@ export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: str
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
+export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
 }
 
 //name: trainRBFkernelSVM
@@ -250,12 +247,11 @@ export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promis
 //input: double sigma = 1.5 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, sigma: number, toShowReport: boolean): Promise<any> 
-{  
+export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, sigma: number, toShowReport: boolean): Promise<any> {
   const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: RBF, sigma: sigma}, 
-    df, predict_column);   
+    {gamma: gamma, kernel: RBF, sigma: sigma},
+    df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -269,9 +265,9 @@ export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
-} 
+export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
+}
 
 //name: trainPolynomialKernelSVM
 //meta.mlname: polynomial kernel LS-SVM
@@ -283,12 +279,11 @@ export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<D
 //input: double d = 2 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, c: number, d: number, toShowReport: boolean): Promise<any> 
-{  
+export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, c: number, d: number, toShowReport: boolean): Promise<any> {
   const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d}, 
-    df, predict_column);   
+    {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d},
+    df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -302,8 +297,8 @@ export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column:
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
+export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
 }
 
 //name: trainSigmoidKernelSVM
@@ -316,12 +311,11 @@ export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Pr
 //input: double theta = 1 {category: Hyperparameters}
 //input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
-export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: string, 
-  gamma: number, kappa: number, theta: number, toShowReport: boolean): Promise<any> 
-{  
+export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: string,
+  gamma: number, kappa: number, theta: number, toShowReport: boolean): Promise<any> {
   const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta}, 
-    df, predict_column);   
+    {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta},
+    df, predict_column);
 
   if (toShowReport)
     showTrainReport(df, trainedModel);
@@ -335,8 +329,8 @@ export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: st
 //input: dataframe df
 //input: dynamic model
 //output: dataframe table
-export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> { 
-  return await getPrediction(df, model); 
+export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promise<DG.DataFrame> {
+  return await getPrediction(df, model);
 }
 
 //top-menu: ML | Analyze | ANOVA...
@@ -349,5 +343,12 @@ export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promi
 //input: bool validate = false [Indicates whether the normality of distribution and an eqaulity of varainces should be checked.]
 export function anova(table: DG.DataFrame, factor: DG.Column, feature: DG.Column, significance: number, validate: boolean) {
   const res = oneWayAnova(factor, feature, significance, validate);
-  addOneWayAnovaVizualization(table, factor, feature, res);  
+  addOneWayAnovaVizualization(table, factor, feature, res);
+}
+
+//top-menu: ML | Missing Values Imputation ...
+//name: KNN impute
+//desription: Missing values imputation using the k-nearest neighbors method
+export function kNNImputation() {  
+  runKNNImputer();  
 }