@datagrok/eda 1.1.27 → 1.1.28

package/package.json

@@ -1,17 +1,17 @@
 {
     "name": "@datagrok/eda",
     "friendlyName": "EDA",
-    "version": "1.1.27",
+    "version": "1.1.28",
     "description": "Exploratory Data Analysis Tools",
     "dependencies": {
         "@datagrok-libraries/math": "^1.1.10",
-        "@datagrok-libraries/ml": "^6.6.11",
+        "@datagrok-libraries/ml": "^6.6.13",
         "@datagrok-libraries/tutorials": "^1.3.6",
         "@datagrok-libraries/utils": "^4.1.44",
         "@keckelt/tsne": "^1.0.2",
         "@webgpu/types": "^0.1.40",
         "cash-dom": "^8.1.1",
-        "datagrok-api": "^1.16.0",
+        "datagrok-api": "^1.20.0",
         "dayjs": "^1.11.9",
         "jstat": "^1.9.6",
         "source-map-loader": "^4.0.1",

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

@@ -2,51 +2,51 @@ 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";
+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[], 
+  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);
+  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 {
+export async function runKNNImputer(df?: DG.DataFrame): Promise<void> {
   /** current dataframe */
-  let df: DG.DataFrame | null = grok.shell.t;
+  df ??= grok.shell.t;
 
   if (df === null) {
     grok.shell.warning(ERROR_MSG.NO_DATAFRAME);
     return;
-  }    
+  }
 
   /** columns with missing values */
   const colsWithMissingVals = [] as DG.Column[];
@@ -84,53 +84,54 @@ export function runKNNImputer(): void {
 
   // In-place components
   let inPlace = DEFAULT.IN_PLACE > 0;
-  const inPlaceInput = ui.boolInput(TITLE.IN_PLACE, inPlace, () => { inPlace = inPlaceInput.value ?? false;});
+  const inPlaceInput = ui.input.bool(TITLE.IN_PLACE, {value: inPlace,
+    onValueChanged: () => {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 });
+  const keepEmptyInput = ui.input.bool(TITLE.KEEP_EMPTY, {value: keepEmpty,
+    onValueChanged: () => {keepEmpty = keepEmptyInput.value ?? false;}});
   keepEmptyInput.setTooltip(HINT.KEEP_EMPTY);
 
   // Neighbors components
   let neighbors = DEFAULT.NEIGHBORS;
-  const neighborsInput = ui.intInput(TITLE.NEIGHBORS, neighbors, () => {
+  const neighborsInput = ui.input.int(TITLE.NEIGHBORS, {value: neighbors, onValueChanged: () => {
     const val = neighborsInput.value;
     if (val === null)
       neighborsInput.value = neighbors;
-    else if (val >= MIN_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);
+  const distTypeInput: DG.ChoiceInput<DISTANCE_TYPE> = ui.input.choice(TITLE.DISTANCE, {value: distType,
+    items: [DISTANCE_TYPE.EUCLIDEAN, DISTANCE_TYPE.MANHATTAN], onValueChanged: () => distType = distTypeInput.value ?? DISTANCE_TYPE.EUCLIDEAN}) as DG.ChoiceInput<DISTANCE_TYPE>;
   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);    
+  const targetColInput = ui.input.columns(TITLE.COLUMNS, {table: df, onValueChanged: () => {
+    targetColNames = targetColInput.value.map((col) => col.name);
     checkApplicability();
-  }, {available: availableTargetColsNames, checked: availableTargetColsNames});
+  }, available: availableTargetColsNames, checked: availableTargetColsNames});
   targetColInput.setTooltip(HINT.TARGET);
 
   // Feature columns components
   let selectedFeatureColNames = availableFeatureColsNames as string[];
-  const featuresInput = ui.columnsInput(TITLE.FEATURES, df, () => {    
+  const featuresInput = ui.input.columns(TITLE.FEATURES, {table: df, onValueChanged: () => {
     selectedFeatureColNames = featuresInput.value.map((col) => col.name);
 
     if (selectedFeatureColNames.length > 0) {
       checkApplicability();
-      metricInfoInputs.forEach((div, name) => div.hidden = !selectedFeatureColNames.includes(name));      
-    }
-    else
+      metricInfoInputs.forEach((div, name) => div.hidden = !selectedFeatureColNames.includes(name));
+    } else
       hideWidgets();
-  }, {available: availableFeatureColsNames, checked: availableFeatureColsNames});
+  }, available: availableFeatureColsNames, checked: availableFeatureColsNames});
   featuresInput.setTooltip(HINT.FEATURES);
 
   /** Hide widgets (use if run is not applicable) */
@@ -155,14 +156,15 @@ export function runKNNImputer(): void {
 
   /** Check applicability of the imputation */
   const checkApplicability = () => {
-    showWidgets();    
-    
+    showWidgets();
+
     if (selectedFeatureColNames.length === 1) {
       targetColNames.forEach((name) => {
         if (selectedFeatureColNames[0] === name) {
           hideWidgets();
           grok.shell.warning(`${ERROR_MSG.ONE_FEATURE_SELECTED} the column '${name}'`);
-      }});
+        }
+      });
     }
   };
 
@@ -173,25 +175,26 @@ export function runKNNImputer(): void {
   metricsDiv.style.overflow = 'auto';
 
   // Create metrics UI
-  availableFeatureColsNames.forEach((name) => {    
+  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);
-    });
+    const distTypeInput = ui.input.choice(name, {value: settings.defaultMetric,
+      items: settings.availableMetrics, onValueChanged: () => {
+        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 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(() => {
@@ -200,7 +203,7 @@ export function runKNNImputer(): void {
       featuresMetrics.set(name, distInfo);
     });
     weightInput.setTooltip(HINT.WEIGHT);
-    
+
     const div = ui.divH([distTypeInput.root, weightInput.root]);
     metricInfoInputs.set(name, div);
     metricsDiv.append(div);
@@ -214,11 +217,27 @@ export function runKNNImputer(): void {
   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 settingsIcon = ui.icons.settings(() => {metricsDiv.hidden = !metricsDiv.hidden;}, HINT.METRIC_SETTINGS);
 
   const distDiv = ui.divH([distTypeInput.root, settingsIcon]);
 
-  dlg.addButton(TITLE.RUN, () => {
+  let resolve: (value: void | PromiseLike<void>) => void;
+  let reject: (reason?: any) => void;
+  let okClicked = false;
+  const promise = new Promise<void>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  dlg.add(targetColInput)
+    .add(featuresInput)
+    .add(distDiv)
+    .add(metricsDiv)
+    .add(neighborsInput)
+    .add(inPlaceInput)
+    .add(keepEmptyInput)
+    .show()
+    .onOK(() => {
+      okClicked = true;
       dlg.close();
       availableFeatureColsNames.filter((name) => !selectedFeatureColNames.includes(name)).forEach((name) => featuresMetrics.delete(name));
 
@@ -227,20 +246,15 @@ export function runKNNImputer(): void {
 
         if (!keepEmpty)
           imputeFailed(df!, failedToImpute);
-      }
-      catch (err) {
+        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}`);
-      }      
-    })
-    .add(targetColInput)
-    .add(featuresInput)    
-    .add(distDiv)
-    .add(metricsDiv)
-    .add(neighborsInput)
-    .add(inPlaceInput)
-    .add(keepEmptyInput)
-    .show();
+        reject(err);
+      }
+    }).onClose.subscribe(() => !okClicked && reject());
+
+    return promise;
 } // runKNNImputer

package/src/package.ts

@@ -10,7 +10,7 @@ import {computePCA} from './eda-tools';
 import {addPrefixToEachColumnName, addOneWayAnovaVizualization} from './eda-ui';
 import {testDataForBinaryClassification} from './data-generators';
 import {LINEAR, RBF, POLYNOMIAL, SIGMOID,
-  getTrainedModel, getPrediction, isApplicableSVM, showTrainReport, getPackedModel} from './svm';
+  getTrainedModel, getPrediction, isApplicableSVM, isInteractiveSVM, showTrainReport, getPackedModel} from './svm';
 
 import {PLS_ANALYSIS} from './pls/pls-constants';
 import {runMVA, runDemoMVA, getPlsAnalysis, PlsOutput} from './pls/pls-tools';
@@ -334,12 +334,12 @@ export async function testDataLinearNonSeparable(name: string, sigma: number, sa
 //meta.mlname: linear kernel LS-SVM
 //meta.mlrole: train
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //input: double gamma = 1.0 {category: Hyperparameters}
 //output: dynamic model
-export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: string,
+export async function trainLinearKernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
   gamma: number): Promise<any> {
-  const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predict_column);
+  const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predictColumn);
   return getPackedModel(trainedModel);
 }
 
@@ -357,21 +357,31 @@ export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promis
 //meta.mlname: linear kernel LS-SVM
 //meta.mlrole: isApplicable
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //output: bool result
-export async function isApplicableLinearKernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
-  return isApplicableSVM(df, predict_column);
+export async function isApplicableLinearKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isApplicableSVM(df, predictColumn);
+}
+
+//name: isInteractiveLinearKernelSVM
+//meta.mlname: linear kernel LS-SVM
+//meta.mlrole: isInteractive
+//input: dataframe df
+//input: column predictColumn
+//output: bool result
+export async function isInteractiveLinearKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isInteractiveSVM(df, predictColumn);
 }
 
 //name: visualizeLinearKernelSVM
 //meta.mlname: linear kernel LS-SVM
 //meta.mlrole: visualize
 //input: dataframe df
-//input: string target_column
-//input: string predict_column
+//input: column targetColumn
+//input: column predictColumn
 //input: dynamic model
 //output: dynamic widget
-export async function visualizeLinearKernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+export async function visualizeLinearKernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
   return showTrainReport(df, model);
 }
 
@@ -380,15 +390,15 @@ export async function visualizeLinearKernelSVM(df: DG.DataFrame, target_column:
 //meta.mlname: RBF-kernel LS-SVM
 //meta.mlrole: train
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: double sigma = 1.5 {category: Hyperparameters}
 //output: dynamic model
-export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string,
+export async function trainRBFkernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
   gamma: number, sigma: number): Promise<any> {
   const trainedModel = await getTrainedModel(
     {gamma: gamma, kernel: RBF, sigma: sigma},
-    df, predict_column);
+    df, predictColumn);
 
   return getPackedModel(trainedModel);
 }
@@ -407,21 +417,32 @@ export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<D
 //meta.mlname: RBF-kernel LS-SVM
 //meta.mlrole: isApplicable
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
+//output: bool result
+export async function isApplicableRBFkernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isApplicableSVM(df, predictColumn);
+}
+
+//name: isInteractiveRBFkernelSVM
+//meta.mlname: RBF-kernel LS-SVM
+//meta.mlrole: isInteractive
+//input: dataframe df
+//input: column predictColumn
 //output: bool result
-export async function isApplicableRBFkernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
-  return isApplicableSVM(df, predict_column);
+export async function isInteractiveRBFkernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isInteractiveSVM(df, predictColumn);
 }
 
+
 //name: visualizeRBFkernelSVM
 //meta.mlname: RBF-kernel LS-SVM
 //meta.mlrole: visualize
 //input: dataframe df
-//input: string target_column
-//input: string predict_column
+//input: column targetColumn
+//input: column predictColumn
 //input: dynamic model
 //output: dynamic widget
-export async function visualizeRBFkernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+export async function visualizeRBFkernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
   return showTrainReport(df, model);
 }
 
@@ -429,16 +450,16 @@ export async function visualizeRBFkernelSVM(df: DG.DataFrame, target_column: str
 //meta.mlname: polynomial kernel LS-SVM
 //meta.mlrole: train
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: double c = 1 {category: Hyperparameters}
 //input: double d = 2 {category: Hyperparameters}
 //output: dynamic model
-export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column: string,
+export async function trainPolynomialKernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
   gamma: number, c: number, d: number): Promise<any> {
   const trainedModel = await getTrainedModel(
     {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d},
-    df, predict_column);
+    df, predictColumn);
 
   return getPackedModel(trainedModel);
 } // trainPolynomialKernelSVM
@@ -457,21 +478,31 @@ export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Pr
 //meta.mlname: polynomial kernel LS-SVM
 //meta.mlrole: isApplicable
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
+//output: bool result
+export async function isApplicablePolynomialKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isApplicableSVM(df, predictColumn);
+}
+
+//name: isInteractivePolynomialKernelSVM
+//meta.mlname: polynomial kernel LS-SVM
+//meta.mlrole: isInteractive
+//input: dataframe df
+//input: column predictColumn
 //output: bool result
-export async function isApplicablePolynomialKernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
-  return isApplicableSVM(df, predict_column);
+export async function isInteractivePolynomialKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isInteractiveSVM(df, predictColumn);
 }
 
 //name: visualizePolynomialKernelSVM
 //meta.mlname: polynomial kernel LS-SVM
 //meta.mlrole: visualize
 //input: dataframe df
-//input: string target_column
-//input: string predict_column
+//input: column targetColumn
+//input: column predictColumn
 //input: dynamic model
 //output: dynamic widget
-export async function visualizePolynomialKernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+export async function visualizePolynomialKernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
   return showTrainReport(df, model);
 }
 
@@ -479,16 +510,16 @@ export async function visualizePolynomialKernelSVM(df: DG.DataFrame, target_colu
 //meta.mlname: sigmoid kernel LS-SVM
 //meta.mlrole: train
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: double kappa = 1 {category: Hyperparameters}
 //input: double theta = 1 {category: Hyperparameters}
 //output: dynamic model
-export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: string,
+export async function trainSigmoidKernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
   gamma: number, kappa: number, theta: number): Promise<any> {
   const trainedModel = await getTrainedModel(
     {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta},
-    df, predict_column);
+    df, predictColumn);
 
   return getPackedModel(trainedModel);
 } // trainSigmoidKernelSVM
@@ -507,21 +538,31 @@ export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promi
 //meta.mlname: sigmoid kernel LS-SVM
 //meta.mlrole: isApplicable
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //output: bool result
-export async function isApplicableSigmoidKernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
-  return isApplicableSVM(df, predict_column);
+export async function isApplicableSigmoidKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isApplicableSVM(df, predictColumn);
+}
+
+//name: isInteractiveSigmoidKernelSVM
+//meta.mlname: sigmoid kernel LS-SVM
+//meta.mlrole: isInteractive
+//input: dataframe df
+//input: column predictColumn
+//output: bool result
+export async function isInteractiveSigmoidKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
+  return isInteractiveSVM(df, predictColumn);
 }
 
 //name: visualizeSigmoidKernelSVM
 //meta.mlname: sigmoid kernel LS-SVM
 //meta.mlrole: visualize
 //input: dataframe df
-//input: string target_column
-//input: string predict_column
+//input: column targetColumn
+//input: column predictColumn
 //input: dynamic model
 //output: dynamic widget
-export async function visualizeSigmoidKernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+export async function visualizeSigmoidKernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
   return showTrainReport(df, model);
 }
 
@@ -545,6 +586,13 @@ export function kNNImputation() {
   runKNNImputer();
 }
 
+//name: KNN imputation for a table
+//desription: Missing values imputation using the k-nearest neighbors method for a given table
+//input: dataframe table
+export async function kNNImputationForTable(table: DG.DataFrame) {
+  await runKNNImputer(table);
+}
+
 //name: linearRegression
 //description: Linear Regression demo
 //input: dataframe table
@@ -591,14 +639,11 @@ export function generateDatasetForLinearRegressionTest(rowCount: number, colCoun
 //meta.mlname: Linear Regression
 //meta.mlrole: train
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //output: dynamic model
-export async function trainLinearRegression(df: DG.DataFrame, predict_column: string): Promise<Uint8Array> {
+export async function trainLinearRegression(df: DG.DataFrame, predictColumn: DG.Column): Promise<Uint8Array> {
   const features = df.columns;
-  const target = features.byName(predict_column);
-  features.remove(predict_column);
-
-  const params = await getLinearRegressionParams(features, target);
+  const params = await getLinearRegressionParams(features, predictColumn);
 
   return new Uint8Array(params.buffer);
 }
@@ -619,12 +664,25 @@ export function applyLinearRegression(df: DG.DataFrame, model: any): DG.DataFram
 //meta.mlname: Linear Regression
 //meta.mlrole: isApplicable
 //input: dataframe df
-//input: string predict_column
+//input: column predictColumn
 //output: bool result
-export function isApplicableLinearRegression(df: DG.DataFrame, predict_column: string): boolean {
+export function isApplicableLinearRegression(df: DG.DataFrame, predictColumn: DG.Column): boolean {
   for (const col of df.columns) {
-    if ((col.type !== DG.COLUMN_TYPE.INT) && (col.type !== DG.COLUMN_TYPE.FLOAT) && (col.type !== DG.COLUMN_TYPE.QNUM) && (col.type !== DG.COLUMN_TYPE.BIG_INT))
+    if (!col.matches('numerical'))
       return false;
   }
+  if (!predictColumn.matches('numerical'))
+    return false;
+
   return true;
 }
+
+//name: isInteractiveLinearRegression
+//meta.mlname: Linear Regression
+//meta.mlrole: isInteractive
+//input: dataframe df
+//input: column predictColumn
+//output: bool result
+export function isInteractiveLinearRegression(df: DG.DataFrame, predictColumn: DG.Column): boolean {
+  return df.rowCount <= 100000;
+}

package/src/pls/pls-tools.ts

@@ -283,17 +283,16 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
 
   // responce (to predict)
   let predict = numCols[numCols.length - 1];
-  const predictInput = ui.columnInput(TITLE.PREDICT, table, predict, () => {
+  const predictInput = ui.input.column(TITLE.PREDICT, {table: table, value: predict, onValueChanged: () => {
     predict = predictInput.value!;
     updateIputs();
-  },
-  {filter: (col: DG.Column) => isValidNumeric(col)},
+  }, filter: (col: DG.Column) => isValidNumeric(col)},
   );
   predictInput.setTooltip(HINT.PREDICT);
 
   // predictors (features)
   let features: DG.Column[];
-  const featuresInput = ui.columnsInput(TITLE.USING, table, () => {}, {available: numColNames});
+  const featuresInput = ui.input.columns(TITLE.USING, {table: table, available: numColNames});
   featuresInput.onInput(() => updateIputs());
   featuresInput.setTooltip(HINT.FEATURES);
 
@@ -336,8 +335,8 @@ export async function runMVA(analysisType: PLS_ANALYSIS): Promise<void> {
 
   // names of samples
   let names = (strCols.length > 0) ? strCols[0] : null;
-  const namesInputs = ui.columnInput(TITLE.NAMES, table, names, () => names = predictInput.value,
-    {filter: (col: DG.Column) => col.type === DG.COLUMN_TYPE.STRING},
+  const namesInputs = ui.input.column(TITLE.NAMES, {table: table, value: names!, onValueChanged: () => names = predictInput.value,
+    filter: (col: DG.Column) => col.type === DG.COLUMN_TYPE.STRING},
   );
   namesInputs.setTooltip(HINT.NAMES);
   namesInputs.root.hidden = (strCols.length === 0) || (analysisType === PLS_ANALYSIS.COMPUTE_COMPONENTS);