@datagrok/eda 1.2.0 → 1.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/eda",
   "friendlyName": "EDA",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Exploratory Data Analysis Tools",
   "dependencies": {
     "@datagrok-libraries/math": "^1.2.0",

package/src/missing-values-imputation/knn-imputer.ts

@@ -18,24 +18,24 @@ export const SUPPORTED_COLUMN_TYPES = [
 /** Return null value with respect to the column type */
 export function getNullValue(col: DG.Column): number {
   switch (col.type) {
-    case DG.COLUMN_TYPE.INT:        
-      return DG.INT_NULL;
-
-    case DG.COLUMN_TYPE.FLOAT:
-      return DG.FLOAT_NULL;
-    
-    case DG.COLUMN_TYPE.QNUM:
-      return DG.FLOAT_NULL;
-
-    case DG.COLUMN_TYPE.DATE_TIME:
-      return DG.FLOAT_NULL;
-
-    case DG.COLUMN_TYPE.STRING:
-      return col.max;
-  
-    default:
-      throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
-  }  
+  case DG.COLUMN_TYPE.INT:
+    return DG.INT_NULL;
+
+  case DG.COLUMN_TYPE.FLOAT:
+    return DG.FLOAT_NULL;
+
+  case DG.COLUMN_TYPE.QNUM:
+    return DG.FLOAT_NULL;
+
+  case DG.COLUMN_TYPE.DATE_TIME:
+    return DG.FLOAT_NULL;
+
+  case DG.COLUMN_TYPE.STRING:
+    return col.max;
+
+  default:
+    throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
+  }
 }
 
 /** Metric types (between column elements) */
@@ -76,8 +76,8 @@ type Item = {
 
 /** Impute missing values using the KNN method and returns an array of items for which an imputation fails */
 export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetrics: Map<string, MetricInfo>,
-  missingValsIndices: Map<string, number[]>, distance: DISTANCE_TYPE, neighbors: number, inPlace: boolean): Map<string, number[]>
-{
+  missingValsIndices: Map<string, number[]>, distance: DISTANCE_TYPE, neighbors: number,
+  inPlace: boolean): Map<string, number[]> {
   // 1. Check inputs completness
 
   if (neighbors < MIN_NEIGHBORS)
@@ -91,16 +91,17 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
 
   if (featuresMetrics.size === 0)
     throw new Error(ERROR_MSG.KNN_NO_FEATURE_COLUMNS);
-  
-  if (featuresMetrics.size === 1)
+
+  if (featuresMetrics.size === 1) {
     targetColNames.forEach((name) => {
       if (featuresMetrics.has(name))
         throw new Error(`${ERROR_MSG.KNN_NO_FEATURE_COLUMNS} can be used for the column '${name}'`);
-      });
+    });
+  }
 
   targetColNames.forEach((name) => {
     if (!missingValsIndices.has(name))
-      throw new Error(`${ERROR_MSG.KNN_FAILS}: ${ERROR_MSG.WRONG_PREDICTIONS}`);      
+      throw new Error(`${ERROR_MSG.KNN_FAILS}: ${ERROR_MSG.WRONG_PREDICTIONS}`);
   });
 
   const columns = df.columns;
@@ -140,21 +141,22 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
         const feature = columns.byName(name);
         featureSource.push(feature.getRawData());
         featureNullVal.push(getNullValue(feature));
-        
+
         switch (metricInfo.type) {
-          case METRIC_TYPE.DIFFERENCE:
-            metricFunc.push((a: number, b: number) => metricInfo.weight * Math.abs(a - b));            
-            break;
-
-          case METRIC_TYPE.ONE_HOT:
-            metricFunc.push((a: number, b: number) => metricInfo.weight * ((a === b) ? 0 : 1));            
-            break;
-        
-          default:
-            break;
+        case METRIC_TYPE.DIFFERENCE:
+          metricFunc.push((a: number, b: number) => metricInfo.weight * Math.abs(a - b));
+          break;
+
+        case METRIC_TYPE.ONE_HOT:
+          metricFunc.push((a: number, b: number) => metricInfo.weight * ((a === b) ? 0 : 1));
+          break;
+
+        default:
+          break;
         }
-    }});
-    
+      }
+    });
+
     const featuresCount = featureSource.length;
     const properIndices = new Uint32Array(featureSource.length);
     const bufferVector = new Float32Array(featureSource.length);
@@ -173,19 +175,20 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
     /** Obtain proper indices for KNN: features with missing vals are skipped */
     const getProperIndeces = (idx: number) => {
       properIndicesCount = 0;
-      
-      for (let i = 0; i < featuresCount; ++i)
+
+      for (let i = 0; i < featuresCount; ++i) {
         if (featureSource[i][idx] !== featureNullVal[i]) {
           properIndices[properIndicesCount] = i;
           ++properIndicesCount;
         }
+      }
     };
 
     /** Compute buffer vector */
     const computeBufferVector = (idx: number, cur: number) => {
       properIndices.forEach((properIndex, k) => {
         bufferVector[k] = metricFunc[properIndex](featureSource[properIndex][idx], featureSource[properIndex][cur]);
-      })
+      });
     };
 
     /** Euclidean distance function */
@@ -201,10 +204,10 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
     /** Manhattan distance function */
     const manhattanDistFunc = () => {
       let sum = 0;
-    
+
       for (let i = 0; i < properIndicesCount; ++i)
         sum += Math.abs(bufferVector[i]);
-    
+
       return Math.sqrt(sum);
     };
 
@@ -216,16 +219,17 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
       if (source[cur] === nullValue)
         return false;
 
-      for (let i = 0; i < properIndicesCount; ++i)        
+      for (let i = 0; i < properIndicesCount; ++i) {
         if (featureSource[properIndices[i]][cur] === featureNullVal[properIndices[i]])
           return false;
+      }
 
       return true;
     };
 
     /** Return the most frequent of the nearest items (for categorial data) */
     const mostFrequentOfTheNearestItems = () => {
-      frequencies.forEach((v, i,arr) => arr[i] = 0);
+      frequencies.forEach((v, i, arr) => arr[i] = 0);
       let i = 0;
 
       for (i = 0; i < nearestItemsCount; ++i)
@@ -233,7 +237,7 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
 
       let maxFreq = frequencies[0];
       let maxFreqIdx = 0;
-      
+
       frequencies.forEach((v, i) => {
         if (v > maxFreq) {
           maxFreq = v;
@@ -245,7 +249,7 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
     };
 
     /** Get imputation value */
-    const getFillValue = (idx: number) => {      
+    const getFillValue = (idx: number) => {
       getProperIndeces(idx);
 
       // check available features
@@ -255,9 +259,9 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
       nearestItemsCount = 0;
 
       // search for the closest items
-      for (let cur = 0; cur < len; ++cur)
+      for (let cur = 0; cur < len; ++cur) {
         if (canItemBeUsed(cur) && (cur !== idx)) {
-          // 1) compute distance between cur-th and idx-th items
+        // 1) compute distance between cur-th and idx-th items
           computeBufferVector(idx, cur);
           const curDist = dist();
 
@@ -265,24 +269,25 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
           if (nearestItemsCount < neighbors) {
             nearestItems[nearestItemsCount] = {index: cur, dist: curDist};
             ++nearestItemsCount;
-          }
-          else {
-            // 2.1) find the farest
+          } else {
+          // 2.1) find the farest
             maxInd = 0;
             maxDist = nearestItems[0].dist;
 
-            for(let i = 1; i < nearestItemsCount; ++i)
+            for (let i = 1; i < nearestItemsCount; ++i) {
               if (maxDist < nearestItems[i].dist) {
                 maxDist = nearestItems[i].dist;
                 maxInd = i;
               }
-            
+            }
+
             // 2.2) replace
             if (curDist < maxDist)
               nearestItems[maxInd] = {index: cur, dist: curDist};
           } // else
-        } // for cur
-      
+        }
+      } // for cur
+
       // check found nearest items
       if (nearestItemsCount === 0)
         throw new Error(`${ERROR_MSG.KNN_IMPOSSIBLE_IMPUTATION}: the column "${col.name}", row ${idx + 1}`);
@@ -293,35 +298,35 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
       // compute fill value
       sum = 0;
       for (let i = 0; i < nearestItemsCount; ++i)
-        sum += source[nearestItems[i].index];        
+        sum += source[nearestItems[i].index];
 
       fillValue = sum / nearestItemsCount;
 
       if (col.type === DG.COLUMN_TYPE.INT)
         return Math.round(fillValue);
 
-      return fillValue;      
+      return fillValue;
     }; // getFillValue
-    
+
     if (inPlace) {
       // use indices found previousely
-      for (const i of missingValsIndices.get(name)!)        
+      for (const i of missingValsIndices.get(name)!) {
         try {
           source[i] = getFillValue(i);
-        }  catch (err) {
-            failedToImputeIndices.push(i);
-              
-            if (!(err instanceof Error))
-              grok.shell.error(ERROR_MSG.CORE_ISSUE);
+        } catch (err) {
+          failedToImputeIndices.push(i);
+
+          if (!(err instanceof Error))
+            grok.shell.error(ERROR_MSG.CORE_ISSUE);
         }
-      
+      }
+
       if (failedToImputeIndices.length > 0)
         failedToImpute.set(name, failedToImputeIndices);
 
-      // to reset view      
+      // to reset view
       col.set(0, col.get(0));
-    } // if
-    else {
+    } else {
       //@ts-ignore
       const copy = col.clone();
 
@@ -335,19 +340,20 @@ export function impute(df: DG.DataFrame, targetColNames: string[], featuresMetri
       }
 
       copy.name = copyName;
-      
+
       const copySource = copy.getRawData();
 
       // use indices found previousely
-      for (const i of missingValsIndices.get(name)!)        
+      for (const i of missingValsIndices.get(name)!) {
         try {
           copySource[i] = getFillValue(i);
-        }  catch (err) {
-            failedToImputeIndices.push(i);              
-              
-            if (!(err instanceof Error))
-              grok.shell.error(ERROR_MSG.CORE_ISSUE);
+        } catch (err) {
+          failedToImputeIndices.push(i);
+
+          if (!(err instanceof Error))
+            grok.shell.error(ERROR_MSG.CORE_ISSUE);
         }
+      }
 
       if (failedToImputeIndices.length > 0)
         failedToImpute.set(copyName, failedToImputeIndices);
@@ -374,7 +380,7 @@ export function getMissingValsIndices(columns: DG.Column[]): Map<string, number[
 
     const indices = [] as number[];
     const nullValue = getNullValue(col);
-    
+
     col.getRawData().forEach((val, idx) => {
       if (val === nullValue)
         indices.push(idx);
@@ -387,11 +393,13 @@ export function getMissingValsIndices(columns: DG.Column[]): Map<string, number[
 }
 
 /** Predict existence of missing values imputation fails */
-export function areThereFails(targetColNames: string[], featureColNames: string[], misValsInds: Map<string, number[]>): boolean {
+export function areThereFails(targetColNames: string[], featureColNames: string[],
+  misValsInds: Map<string, number[]>): boolean {
   // check feature columns
-  for (const name of featureColNames)
+  for (const name of featureColNames) {
     if (!misValsInds.has(name))
       return false;
+  }
 
   // check target columns
   for (const target of targetColNames) {
@@ -399,7 +407,7 @@ export function areThereFails(targetColNames: string[], featureColNames: string[
 
     if (indices === undefined)
       throw new Error(ERROR_MSG.FAILS_TO_PREDICT_IMPUTATION_FAILS);
-    
+
     for (const idx of indices) {
       let failToImpute = true;
 
@@ -429,27 +437,28 @@ function getFirstNonNull<T>(col: DG.Column<T>): T {
   const raw = col.getRawData();
   const len = raw.length;
 
-  for (let i = 0; i < len; ++i)
+  for (let i = 0; i < len; ++i) {
     if (raw[i] !== nullValue)
       return col.get(i)!;
+  }
 
-  throw new Error(ERROR_MSG.EMPTY_COLUMN);  
+  throw new Error(ERROR_MSG.EMPTY_COLUMN);
 }
 
 /** Return default fill value with respect to the column type */
 function getDefaultFillValue<T>(col: DG.Column<T>): T {
   switch (col.type) {
-    case DG.COLUMN_TYPE.STRING:
-    case DG.COLUMN_TYPE.DATE_TIME:
-      return getFirstNonNull(col); // TODO: replace by most frequent
+  case DG.COLUMN_TYPE.STRING:
+  case DG.COLUMN_TYPE.DATE_TIME:
+    return getFirstNonNull(col); // TODO: replace by most frequent
 
-    case DG.COLUMN_TYPE.INT:
-    case DG.COLUMN_TYPE.FLOAT:
-    case DG.COLUMN_TYPE.QNUM:
-      return col.stats.avg as T;
+  case DG.COLUMN_TYPE.INT:
+  case DG.COLUMN_TYPE.FLOAT:
+  case DG.COLUMN_TYPE.QNUM:
+    return col.stats.avg as T;
 
-    default:
-      throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
+  default:
+    throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
   }
 }
 
@@ -459,7 +468,7 @@ export function imputeFailed(df: DG.DataFrame, failedToImpute: Map<string, numbe
     const col = df.col(colName);
     if (col !== null) {
       if (!SUPPORTED_COLUMN_TYPES.includes(col.type))
-        throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);        
+        throw new Error(ERROR_MSG.UNSUPPORTED_COLUMN_TYPE);
 
       const fillVal = getDefaultFillValue(col);
       indices.forEach((idx) => col.set(idx, fillVal));

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

@@ -44,9 +44,9 @@ export enum TITLE {
 };
 
 /** Help links */
-export const KNN_IMPUTER = '/help/transform/missing-values-imputation';
+export const KNN_IMPUTER = '/help/explore/missing-values-imputation';
 
-/** Tooltips */ 
+/** Tooltips */
 export enum HINT {
   TARGET = 'Columns with missing values that must be filled',
   FEATURES = "Columns with features to be used for determining the 'nearest' elements in the KNN method",

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

@@ -14,7 +14,7 @@ type FeatureInputSettings = {
 };
 
 /** Return default setting of the feature metric inputs */
-function getFeatureInputSettings(type: DG.COLUMN_TYPE): FeatureInputSettings {
+export function getFeatureInputSettings(type: DG.COLUMN_TYPE): FeatureInputSettings {
   switch (type) {
   case DG.COLUMN_TYPE.STRING:
   case DG.COLUMN_TYPE.DATE_TIME:
@@ -61,9 +61,13 @@ export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
   df.columns.toList()
     .filter((col) => SUPPORTED_COLUMN_TYPES.includes(col.type))
     .forEach((col) => {
+      const misValsCount = col.stats.missingValueCount;
+      if (misValsCount === col.length)
+        return;
+
       availableFeatureColsNames.push(col.name);
 
-      if (col.stats.missingValueCount > 0) {
+      if (misValsCount > 0) {
         colsWithMissingVals.push(col);
         availableTargetColsNames.push(col.name);
       }
@@ -96,14 +100,17 @@ export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
 
   // Neighbors components
   let neighbors = DEFAULT.NEIGHBORS;
-  const neighborsInput = ui.input.int(TITLE.NEIGHBORS, {value: neighbors, onValueChanged: (value) => {
-    if (value === null)
-      neighborsInput.value = neighbors;
-    else if (value >= MIN_NEIGHBORS)
-      neighbors = value;
-    else
-      neighborsInput.value = neighbors;
-  }});
+  const neighborsInput = ui.input.int(TITLE.NEIGHBORS, {
+    value: neighbors,
+    showPlusMinus: true,
+    min: MIN_NEIGHBORS,
+    nullable: false,
+    onValueChanged: (value) => {
+      if ((value !== null) && (value >= MIN_NEIGHBORS))
+        neighbors = value;
+      checkApplicability();
+    },
+  });
   neighborsInput.setTooltip(HINT.NEIGHBORS);
 
   // Distance components
@@ -116,23 +123,32 @@ export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
 
   // Target columns components (cols with missing values to be imputed)
   let targetColNames = colsWithMissingVals.map((col) => col.name);
-  const targetColInput = ui.input.columns(TITLE.COLUMNS, {table: df, value: df.columns.byNames(availableTargetColsNames), onValueChanged: (value) => {
-    targetColNames = value.map((col) => col.name);
-    checkApplicability();
-  }, available: availableTargetColsNames});
+  const targetColInput = ui.input.columns(TITLE.COLUMNS, {
+    table: df,
+    value: df.columns.byNames(availableTargetColsNames),
+    onValueChanged: (value) => {
+      targetColNames = value.map((col) => col.name);
+      checkApplicability();
+    },
+    available: availableTargetColsNames,
+  });
   targetColInput.setTooltip(HINT.TARGET);
 
   // Feature columns components
   let selectedFeatureColNames = availableFeatureColsNames as string[];
-  const featuresInput = ui.input.columns(TITLE.FEATURES, {value: df.columns.byNames(availableFeatureColsNames), table: df, onValueChanged: (value) => {
-    selectedFeatureColNames = value.map((col) => col.name);
-
-    if (selectedFeatureColNames.length > 0) {
-      checkApplicability();
-      metricInfoInputs.forEach((div, name) => div.hidden = !selectedFeatureColNames.includes(name));
-    } else
-      hideWidgets();
-  }, available: availableFeatureColsNames});
+  const featuresInput = ui.input.columns(TITLE.FEATURES, {
+    value: df.columns.byNames(availableFeatureColsNames),
+    table: df, onValueChanged: (value) => {
+      selectedFeatureColNames = value.map((col) => col.name);
+
+      if (selectedFeatureColNames.length > 0) {
+        checkApplicability();
+        metricInfoInputs.forEach((div, name) => div.hidden = !selectedFeatureColNames.includes(name));
+      } else
+        hideWidgets();
+    },
+    available: availableFeatureColsNames,
+  });
   featuresInput.setTooltip(HINT.FEATURES);
 
   /** Hide widgets (use if run is not applicable) */
@@ -147,7 +163,7 @@ export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
 
   /** Show widgets (use if run is applicable) */
   const showWidgets = () => {
-    dlg.getButton(TITLE.RUN).disabled = false;
+    dlg.getButton(TITLE.RUN).disabled = (neighborsInput.value === null) || (neighborsInput.value < MIN_NEIGHBORS);
     distDiv.hidden = false;
     inPlaceInput.root.hidden = false;
     neighborsInput.root.hidden = false;
@@ -167,6 +183,9 @@ export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
         }
       });
     }
+
+    if (targetColNames.length < 1)
+      hideWidgets();
   };
 
   // Metrics components
@@ -236,6 +255,28 @@ export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
     resolve = res;
     reject = rej;
   });
+
+  dlg.addButton(TITLE.RUN, () => {
+    okClicked = true;
+    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);
+      resolve();
+    } 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}`);
+      reject(err);
+    }
+  });
+
   dlg.add(targetColInput)
     .add(featuresInput)
     .add(distDiv)
@@ -244,26 +285,7 @@ export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
     .add(inPlaceInput)
     .add(keepEmptyInput)
     .show()
-    .onOK(() => {
-      okClicked = true;
-      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);
-        resolve();
-      } 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}`);
-        reject(err);
-      }
-    }).onClose.subscribe(() => !okClicked && resolve());
+    .onClose.subscribe(() => !okClicked && resolve());
 
   return promise;
 } // runKNNImputer

package/src/package-test.ts

@@ -3,6 +3,7 @@ import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
 import './tests/dim-reduction-tests';
 import './tests/linear-methods-tests';
 import './tests/classifiers-tests';
+import './tests/mis-vals-imputation-tests';
 export const _package = new DG.Package();
 export {tests};
 

package/src/tests/mis-vals-imputation-tests.ts

@@ -0,0 +1,58 @@
+// Tests for missing values imputation
+
+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/utils/src/test';
+
+import {MetricInfo, DISTANCE_TYPE, impute} from '../missing-values-imputation/knn-imputer';
+import {getFeatureInputSettings} from '../missing-values-imputation/ui';
+import {dataWithMissingVals} from './utils';
+
+const ROWS_K = 100;
+const K = 1000;
+const INT_COLS = 5;
+const FLOAT_COLS = 5;
+const STRING_COLS = 5;
+const MIS_VALS_COUNT = 5;
+const NEIGHBORS = 5;
+const TIMEOUT = 10000;
+const TOTAL_COLS = INT_COLS + FLOAT_COLS + STRING_COLS;
+
+const testKNN = (dist: DISTANCE_TYPE) => {
+  test(`${dist} dist, ${ROWS_K}K rows, ${TOTAL_COLS} cols, ${MIS_VALS_COUNT * TOTAL_COLS} missing vals`, async () => {
+    // Data
+    const data = dataWithMissingVals(ROWS_K * K, INT_COLS, FLOAT_COLS, STRING_COLS, MIS_VALS_COUNT);
+    const df = data.df;
+    const cols = df.columns;
+
+    // Inputs for kNN imputer
+    const targetColNames = cols.names();
+    const featuresMetrics = new Map<string, MetricInfo>();
+    const missingValsIndices = data.misValsIds;
+
+    // Imputation settings
+    for (const col of df.columns) {
+      const settings = getFeatureInputSettings(col.type as DG.COLUMN_TYPE);
+      featuresMetrics.set(col.name, {
+        weight: settings.defaultWeight,
+        type: settings.defaultMetric,
+      });
+    }
+
+    // Impute missing values & get fails
+    const failedToImput = impute(df, targetColNames, featuresMetrics, missingValsIndices, dist, NEIGHBORS, true);
+
+    // Check fails
+    let fails = 0;
+    failedToImput.forEach((inds, _) => fails += inds.length);
+    expect(fails, 0, `Failed to impute ${fails} missing values`);
+  }, {timeout: TIMEOUT, benchmark: true});
+};
+
+category(`Missing values imputation`, () => {
+  testKNN(DISTANCE_TYPE.EUCLIDEAN);
+  testKNN(DISTANCE_TYPE.MANHATTAN);
+});