@datagrok/eda 1.4.3 → 1.4.4

package/src/package.ts

@@ -38,750 +38,979 @@ import {initXgboost} from '../wasm/xgbooster';
 import {XGBooster} from './xgbooster';
 
 export const _package = new DG.Package();
+export * from './package.g';
 
-//name: info
-export function info() {
-  grok.shell.info(_package.webRoot);
-}
+export class PackageFunctions {
+  @grok.decorators.func({
+    'name': 'info'
+  })
+  static info() {
 
-//tags: init
-export async function init(): Promise<void> {
-  await _initEDAAPI();
-  await initXgboost();
-}
+    grok.shell.info(_package.webRoot);
+  }
 
-//top-menu: ML | Cluster | DBSCAN...
-//name: DBSCAN
-//description: Density-based spatial clustering of applications with noise (DBSCAN)
-//input: dataframe df
-//input: column xCol {type: numerical}
-//input: column yCol {type: numerical}
-//input: double epsilon = 0.02 {caption: Epsilon} [The maximum distance between two samples for them to be considered as in the same neighborhood.]
-//input: int minPts = 4 {caption: Minimum points} [The number of samples (or total weight) in a neighborhood for a point to be considered as a core point.]
-//output: column cluster
-export async function dbScan(df: DG.DataFrame, xCol: DG.Column, yCol: DG.Column, epsilon: number, minPts: number) {
-  const x = xCol.getRawData() as Float32Array;
-  const y = yCol.getRawData() as Float32Array;
-  const res = await getDbscanWorker(x, y, epsilon, minPts);
-  const clusterColName = df.columns.getUnusedName('Cluster (DBSCAN)');
-  const cluster = DG.Column.fromInt32Array(clusterColName, res);
-  df.columns.add(cluster);
-  return cluster;
-}
 
-//top-menu: ML | Analyze | PCA...
-//name: PCA
-//description: Principal component analysis (PCA)
-//input: dataframe table
-//input: column_list features {type: numerical; allowNulls: false}
-//input: int components = 2 {caption: Components; nullable: false; min: 1} [Number of components.]
-//input: bool center = false [Indicating whether the variables should be shifted to be zero centered.]
-//input: bool scale = false [Indicating whether the variables should be scaled to have unit variance.]
-export async function PCA(table: DG.DataFrame, features: DG.ColumnList, components: number, center: boolean, scale: boolean): Promise<void> {
-  try {
-    const pcaTable = await computePCA(table, features, components, center, scale);
-    addPrefixToEachColumnName('PC', pcaTable.columns);
-
-    if (table.id === null) // table is loaded from a local file
-      grok.shell.addTableView(pcaTable);
-    else {
-      const cols = table.columns;
-
-      for (const col of pcaTable.columns) {
-        col.name = cols.getUnusedName(col.name);
-        cols.add(col);
+  @grok.decorators.init({})
+  static async init(): Promise<void> {
+
+    await _initEDAAPI();
+    await initXgboost();
+  }
+
+
+  @grok.decorators.func({
+    'top-menu': 'ML | Cluster | DBSCAN...',
+    'name': 'DBSCAN',
+    'description': 'Density-based spatial clustering of applications with noise (DBSCAN)'
+  })
+  static async dbScan(
+    df: DG.DataFrame,
+    @grok.decorators.param({'options':{'type':'numerical'}})   xCol: DG.Column,
+    @grok.decorators.param({'options':{'type':'numerical'}})   yCol: DG.Column,
+    @grok.decorators.param({'options':{'caption':'Epsilon','initialValue':'0.02', description: 'The maximum distance between two samples for them to be considered as in the same neighborhood.'}})   epsilon: number,
+    @grok.decorators.param({'type':'int','options':{'caption':'Minimum points','initialValue':'4', description: 'The number of samples (or total weight) in a neighborhood for a point to be considered as a core point.'}})   minPts: number) : Promise<DG.Column> {
+
+    const x = xCol.getRawData() as Float32Array;
+    const y = yCol.getRawData() as Float32Array;
+    const res = await getDbscanWorker(x, y, epsilon, minPts);
+    const clusterColName = df.columns.getUnusedName('Cluster (DBSCAN)');
+    const cluster = DG.Column.fromInt32Array(clusterColName, res);
+    df.columns.add(cluster);
+    return cluster;
+  }
+
+  @grok.decorators.func({
+    'top-menu': 'ML | Analyze | PCA...',
+    'description': 'Principal component analysis (PCA)',
+    helpUrl: '/help/explore/dim-reduction#pca',
+  })
+  static async PCA(
+    @grok.decorators.param({'type':'dataframe','options':{'caption':'Table'}})  table: DG.DataFrame,
+    @grok.decorators.param({'type':'column_list','options':{'type':'numerical', 'nullable': false}})   features: DG.ColumnList,
+    //@ts-ignore
+    @grok.decorators.param({'type':'int','options':{'showPlusMinus': true, 'caption':'Components', 'nullable':false, 'min':'1', 'initialValue':'2', description: 'Number of components.'}})   components: number,
+    @grok.decorators.param({'type':'bool', 'options':{'caption':'Center', 'initialValue':'false', description: 'Indicating whether the variables should be shifted to be zero centered.'}})   center: boolean,
+    @grok.decorators.param({'type':'bool','options':{'caption':'Scale', 'initialValue':'false', description: 'Indicating whether the variables should be scaled to have unit variance.'}})   scale: boolean): Promise<void> {
+
+    try {
+      const pcaTable = await computePCA(table, features, components, center, scale);
+      addPrefixToEachColumnName('PC', pcaTable.columns);
+
+      if (table.id === null) // table is loaded from a local file
+        grok.shell.addTableView(pcaTable);
+      else {
+        const cols = table.columns;
+        const pcaTableCols = pcaTable.columns.toList();
+
+        for (const col of pcaTableCols) {
+          pcaTable.columns.remove(col.name);
+          col.name = cols.getUnusedName(col.name);
+          cols.add(col);
+        }
       }
+    } catch (error) {
+      grok.shell.warning(`Failed to compute PCA: ${error instanceof Error ? error.message : 'platform issue'}`);
     }
-  } catch (error) {
-    grok.shell.warning(`Failed to compute PCA: ${error instanceof Error ? error.message : 'platform issue'}`);
   }
-}
 
-//name: DBSCAN clustering
-//tags: dim-red-postprocessing-function
-//meta.defaultPostProcessingFunction: true
-//input: column col1
-//input: column col2
-//input: double epsilon = 0.01 {default: 0.01}[Minimum distance between two points to be considered as in the same neighborhood.]
-//input: int minimumPoints = 5 {default: 5}[Minimum number of points to form a dense region.]
-export async function dbscanPostProcessingFunction(col1: DG.Column, col2: DG.Column, epsilon: number, minimumPoints: number) {
-  const df = col1.dataFrame;
-  if (df === null)
-    return;
-  const resCol = await dbScan(df, col1, col2, epsilon, minimumPoints);
-  df.changeColumnType(resCol, 'string');
-  const colNames = [col1.name, col2.name];
-  const tv = grok.shell.tableView(df.name);
-  if (!tv)
-    return;
-  // find the correct scatterPlotViewer and set the colorColumnName
-  for (const v of tv.viewers) {
-    if (v instanceof DG.ScatterPlotViewer && colNames.includes(v.props.xColumnName) && colNames.includes(v.props.yColumnName)) {
-      v.props.colorColumnName = resCol.name;
+
+  @grok.decorators.func({
+    'meta': {
+      'defaultPostProcessingFunction': 'true'
+    },
+    'tags': [
+      'dim-red-postprocessing-function'
+    ],
+    'name': 'DBSCAN clustering'
+  })
+  static async dbscanPostProcessingFunction(
+    col1: DG.Column,
+    col2: DG.Column,
+    @grok.decorators.param({'options':{'initialValue':'0.01', description: 'Minimum distance between two points to be considered as in the same neighborhood.'}})   epsilon: number,
+    @grok.decorators.param({'type':'int','options':{'initialValue':'5', description: 'Minimum number of points to form a dense region.'}})   minimumPoints: number) {
+
+    const df = col1.dataFrame;
+    if (df === null)
       return;
+    const resCol = await PackageFunctions.dbScan(df, col1, col2, epsilon, minimumPoints);
+    df.changeColumnType(resCol, 'string');
+    const colNames = [col1.name, col2.name];
+    const tv = grok.shell.tableView(df.name);
+    if (!tv)
+      return;
+    for (const v of tv.viewers) {
+      if (v instanceof DG.ScatterPlotViewer && colNames.includes(v.props.xColumnName) && colNames.includes(v.props.yColumnName)) {
+        v.props.colorColumnName = resCol.name;
+        return;
+      }
     }
   }
-}
 
-//name: None (number)
-//tags: dim-red-preprocessing-function
-//meta.supportedTypes: int,float,double,qnum
-//meta.supportedDistanceFunctions: Difference
-//input: column col
-//input: string _metric {optional: true}
-//output: object result
-export function numberPreprocessingFunction(col: DG.Column, _metric: string) {
-  const range = col.stats.max - col.stats.min;
-  const entries = col.toList();
-  return {entries, options: {range}};
-}
 
-//name: None (string)
-//tags: dim-red-preprocessing-function
-//meta.supportedTypes: string
-//meta.supportedDistanceFunctions: One-Hot,Levenshtein,Hamming
-//input: column col
-//input: string _metric {optional: true}
-//output: object result
-export function stringPreprocessingFunction(col: DG.Column, _metric: string) {
-  const entries = col.toList();
-  return {entries, options: {}};
-}
+  @grok.decorators.func({
+    'meta': {
+      'supportedTypes': 'int,float,double,qnum',
+      'supportedDistanceFunctions': 'Difference'
+    },
+    'tags': ['dim-red-preprocessing-function'],
+    'name': 'None (number)',
+    'outputs': [{name: 'result', type:'object'}]
+  })
+  static numberPreprocessingFunction(
+    col: DG.Column,
+    @grok.decorators.param({'options':{'optional':true}})   _metric: string) {
+
+    const range = col.stats.max - col.stats.min;
+    const entries = col.toList();
+    return {entries, options: {range}};
+  }
 
-//top-menu: ML | Reduce Dimensionality...
-//name: Multi Column Dimensionality Reduction
-export async function reduceDimensionality(): Promise<void> {
-  const editor = new MultiColumnDimReductionEditor();
-  const dialog = ui.dialog('Dimensionality reduction')
-    .add(editor.getEditor())
-    .onOK(async () => {
-      const params = editor.getParams();
-      if (params.columns.length === 0)
+
+  @grok.decorators.func({
+    'meta': {
+      'supportedTypes': 'string',
+      'supportedDistanceFunctions': 'One-Hot,Levenshtein,Hamming'
+    },
+    'tags': ['dim-red-preprocessing-function'],
+    'name': 'None (string)',
+    'outputs': [{name: 'result', type:'object'}]
+  })
+  static stringPreprocessingFunction(
+    col: DG.Column,
+    @grok.decorators.param({'options':{'optional':true}})   _metric: string) {
+
+    const entries = col.toList();
+    return {entries, options: {}};
+  }
+
+
+  @grok.decorators.func({
+    'top-menu': 'ML | Reduce Dimensionality...',
+    'name': 'Multi Column Dimensionality Reduction'
+  })
+  static async reduceDimensionality(): Promise<void> {
+
+    const editor = new MultiColumnDimReductionEditor();
+    const dialog = ui.dialog('Dimensionality reduction')
+      .add(editor.getEditor())
+      .onOK(async () => {
+        const params = editor.getParams();
+        if (params.columns.length === 0)
+          return;
+        await multiColReduceDimensionality(params.table, params.columns, params.methodName as DimReductionMethods,
+        params.distanceMetrics as KnownMetrics[],
+        params.weights, params.preprocessingFunctions, params.aggreaggregationMethod as DistanceAggregationMethods,
+        !!params.plotEmbeddings, !!params.clusterEmbeddings, params.options, {
+          fastRowCount: 10000,
+        }, params.postProcessingFunction, params.postProcessingFunctionArgs, params.vectorDistanceMetric);
+      }).show();
+    dialog.helpUrl = 'https://datagrok.ai/help/explore/dim-reduction.md';
+    const validate = () => {
+      const cols = editor.columnsInput.value;
+      const okButton = dialog.getButton('OK');
+      if (!okButton)
         return;
-      await multiColReduceDimensionality(params.table, params.columns, params.methodName as DimReductionMethods,
-      params.distanceMetrics as KnownMetrics[],
-      params.weights, params.preprocessingFunctions, params.aggreaggregationMethod as DistanceAggregationMethods,
-      !!params.plotEmbeddings, !!params.clusterEmbeddings, params.options, {
-        fastRowCount: 10000,
-      }, params.postProcessingFunction, params.postProcessingFunctionArgs, params.vectorDistanceMetric);
-    }).show();
-  dialog.helpUrl = 'https://datagrok.ai/help/explore/dim-reduction.md';
-  const validate = () => {
-    const cols = editor.columnsInput.value;
-    const okButton = dialog.getButton('OK');
-    if (!okButton)
-      return;
-    const isDisabled = !cols || cols.length === 0;
-    if (isDisabled)
-      okButton.classList.add('disabled');
-    else
-      okButton.classList.remove('disabled');
-  };
-  dialog.history(() => ({editorSettings: editor.getStringInput()}), (x: any) => editor.applyStringInput(x['editorSettings']));
-  editor.onColumnsChanged.subscribe(() => {
+      const isDisabled = !cols || cols.length === 0;
+      if (isDisabled)
+        okButton.classList.add('disabled');
+      else
+        okButton.classList.remove('disabled');
+    };
+    dialog.history(() => ({editorSettings: editor.getStringInput()}), (x: any) => editor.applyStringInput(x['editorSettings']));
+    editor.onColumnsChanged.subscribe(() => {
+      try {
+        validate();
+      } catch (e) {
+        console.error(e);
+      }
+    });
+    validate();
+  }
+
+
+  @grok.decorators.editor()
+  static GetMCLEditor(
+      call: DG.FuncCall): void {
+
     try {
-      validate();
-    } catch (e) {
-      console.error(e);
+      const funcEditor = new MCLEditor();
+      const dialog = ui.dialog('Markov clustering')
+        .add(funcEditor.getEditor())
+        .onOK(async () => {
+          const params = funcEditor.params;
+          return call.func.prepare({
+            df: params.table, cols: params.columns, metrics: params.distanceMetrics,
+            weights: params.weights, aggregationMethod: params.aggreaggregationMethod, preprocessingFuncs: params.preprocessingFunctions,
+            preprocessingFuncArgs: params.preprocessingFuncArgs, threshold: params.threshold, maxIterations: params.maxIterations,
+            useWebGPU: params.useWebGPU, inflate: params.inflateFactor, minClusterSize: params.minClusterSize,
+          }).call(true);
+        }).show();
+      dialog.history(() => ({editorSettings: funcEditor.getStringInput()}), (x: any) => funcEditor.applyStringInput(x['editorSettings']));
+    } catch (err: any) {
+      const errMsg = err instanceof Error ? err.message : err.toString();
+      const errStack = err instanceof Error ? err.stack : undefined;
+      grok.shell.error(`Get region editor error: ${errMsg}`);
+      _package.logger.error(errMsg, undefined, errStack);
     }
-  });
-  validate();
-}
+  }
 
-//name: GetMCLEditor
-//tags: editor
-//input: funccall call
-export function GetMCLEditor(call: DG.FuncCall): void {
-  try {
-    const funcEditor = new MCLEditor();
-    const dialog = ui.dialog('Markov clustering')
-      .add(funcEditor.getEditor())
-      .onOK(async () => {
-        const params = funcEditor.params;
-        return call.func.prepare({
-          df: params.table, cols: params.columns, metrics: params.distanceMetrics,
-          weights: params.weights, aggregationMethod: params.aggreaggregationMethod, preprocessingFuncs: params.preprocessingFunctions,
-          preprocessingFuncArgs: params.preprocessingFuncArgs, threshold: params.threshold, maxIterations: params.maxIterations,
-          useWebGPU: params.useWebGPU, inflate: params.inflateFactor, minClusterSize: params.minClusterSize,
-        }).call(true);
-      }).show();
-    dialog.history(() => ({editorSettings: funcEditor.getStringInput()}), (x: any) => funcEditor.applyStringInput(x['editorSettings']));
-  } catch (err: any) {
-    const errMsg = err instanceof Error ? err.message : err.toString();
-    const errStack = err instanceof Error ? err.stack : undefined;
-    grok.shell.error(`Get region editor error: ${errMsg}`);
-    _package.logger.error(errMsg, undefined, errStack);
+
+
+  @grok.decorators.func({
+    'top-menu': 'ML | Cluster | MCL...',
+    'name': 'MCLClustering',
+    'description': 'Markov clustering (MCL) is an unsupervised clustering algorithm for graphs based on simulation of stochastic flow.',
+    'editor': 'EDA:GetMCLEditor',
+    'outputs': [],
+  })
+  static async MCLClustering(
+    df: DG.DataFrame,
+    cols: DG.Column[],
+    @grok.decorators.param({'type':'list<string>'}) metrics: KnownMetrics[],
+    weights: number[],
+    @grok.decorators.param({'type':'string'})   aggregationMethod: DistanceAggregationMethod,
+    @grok.decorators.param({'type':'list<func>'})   preprocessingFuncs: any[],
+    @grok.decorators.param({'type':'object'})   preprocessingFuncArgs: any[],
+    @grok.decorators.param({'type':'int','options':{'initialValue':'80'}})   threshold: number = 80,
+    @grok.decorators.param({'type':'int','options':{'initialValue':'10'}})   maxIterations: number = 10,
+    @grok.decorators.param({'type':'bool','options':{'initialValue':'false'}})   useWebGPU: boolean = false,
+    @grok.decorators.param({'type':'double','options':{'initialValue':'2'}})   inflate: number = 0,
+    @grok.decorators.param({'type':'int','options':{'initialValue':'5'}})   minClusterSize: number = 5): Promise<MCLViewer> {
+    const tv = grok.shell.tableView(df.name) ?? grok.shell.addTableView(df);
+    const serializedOptions: string = JSON.stringify({
+      cols: cols.map((col) => col.name),
+      metrics: metrics,
+      weights: weights,
+      aggregationMethod: aggregationMethod,
+      preprocessingFuncs: preprocessingFuncs.map((func) => func?.name ?? null),
+      preprocessingFuncArgs: preprocessingFuncArgs,
+      threshold: threshold,
+      maxIterations: maxIterations,
+      useWebGPU: useWebGPU,
+      inflate: inflate,
+      minClusterSize: minClusterSize ?? 5,
+    } satisfies MCLSerializableOptions);
+
+    const viewer = tv.addViewer('MCL', {mclProps: serializedOptions}) as MCLViewer;
+    return viewer;
   }
-}
 
+  @grok.decorators.func({
+    'outputs': [{'name': 'result','type': 'viewer'}],
+    'tags': [
+      'viewer'
+    ],
+    'name': 'MCL',
+    'description': 'Markov clustering viewer'
+  })
+  static markovClusteringViewer(): MCLViewer {
+    return new MCLViewer();
+  }
 
-//top-menu: ML | Cluster | MCL...
-//name: MCLClustering
-//description: Markov clustering (MCL) is an unsupervised clustering algorithm for graphs based on simulation of stochastic flow.
-//input: dataframe df
-//input: list<column> cols
-//input: list<string> metrics
-//input: list<double> weights
-//input: string aggregationMethod
-//input: list<func> preprocessingFuncs
-//input: object preprocessingFuncArgs
-//input: int threshold = 80
-//input: int maxIterations = 10
-//input: bool useWebGPU = false
-//input: double inflate = 2
-//input: int minClusterSize = 5
-//editor: EDA: GetMCLEditor
-export async function MCLClustering(df: DG.DataFrame, cols: DG.Column[], metrics: KnownMetrics[],
-  weights: number[], aggregationMethod: DistanceAggregationMethod, preprocessingFuncs: (DG.Func | null | undefined)[],
-  preprocessingFuncArgs: any[], threshold: number = 80, maxIterations: number = 10, useWebGPU: boolean = false, inflate: number = 0,
-  minClusterSize: number = 5,
-): Promise<MCLViewer> {
-  const tv = grok.shell.tableView(df.name) ?? grok.shell.addTableView(df);
-  const serializedOptions: string = JSON.stringify({
-    cols: cols.map((col) => col.name),
-    metrics: metrics,
-    weights: weights,
-    aggregationMethod: aggregationMethod,
-    preprocessingFuncs: preprocessingFuncs.map((func) => func?.name ?? null),
-    preprocessingFuncArgs: preprocessingFuncArgs,
-    threshold: threshold,
-    maxIterations: maxIterations,
-    useWebGPU: useWebGPU,
-    inflate: inflate,
-    minClusterSize: minClusterSize ?? 5,
-  } satisfies MCLSerializableOptions);
-  //df.setTag(MCL_OPTIONS_TAG, serializedOptions);
-
-  const viewer = tv.addViewer('MCL', {mclProps: serializedOptions}) as MCLViewer;
-  return viewer;
-}
+  @grok.decorators.func({
+    'outputs': [{'name': 'plsResults', 'type': 'object'}],
+    'description': 'Compute partial least squares (PLS) regression analysis components: prediction, regression coefficients, T- & U-scores, X-loadings.'
+  })
+  static async PLS(
+      table: DG.DataFrame,
+    @grok.decorators.param({'type':'column_list','options':{'type':'numerical'}})   features: DG.ColumnList,
+    @grok.decorators.param({'type':'column','options':{'type':'numerical'}})   predict: DG.Column,
+    @grok.decorators.param({'type':'int','options':{'initialValue':'3'}})   components: number,
+    @grok.decorators.param({'type':'column','options':{'type':'string'}})   names: DG.Column): Promise<PlsOutput> {
+
+    return await getPlsAnalysis({
+      table: table,
+      features: features,
+      predict: predict,
+      components: components,
+      isQuadratic: false,
+      names: names,
+    });
+  }
 
-//name: MCL
-//description: Markov clustering viewer
-//tags: viewer
-//output: viewer result
-export function markovClusteringViewer(): MCLViewer {
-  return new MCLViewer();
-}
 
-//name: PLS
-//description: Compute partial least squares (PLS) regression analysis components: prediction, regression coefficients, T- & U-scores, X-loadings.
-//input: dataframe table
-//input: column_list features {type: numerical}
-//input: column predict {type: numerical}
-//input: int components = 3
-//input: column names {type: string}
-//output: object plsResults
-export async function PLS(table: DG.DataFrame, features: DG.ColumnList, predict: DG.Column, components: number, names: DG.Column): Promise<PlsOutput> {
-  return await getPlsAnalysis({
-    table: table,
-    features: features,
-    predict: predict,
-    components: components,
-    isQuadratic: false,
-    names: names,
-  });
-}
+  @grok.decorators.func({
+    'top-menu': 'ML | Analyze | PLS...',
+    'description': 'Compute partial least squares (PLS) regression components. They maximally summarize the variation of the predictors while maximizing correlation with the response variable.'
+  })
+  static async topMenuPLS(): Promise<void> {
 
-//top-menu: ML | Analyze | PLS...
-//name: topMenuPLS
-//description: Compute partial least squares (PLS) regression components. They maximally summarize the variation of the predictors while maximizing correlation with the response variable.
-export async function topMenuPLS(): Promise<void> {
-  await runMVA(PLS_ANALYSIS.COMPUTE_COMPONENTS);
-}
+    await runMVA(PLS_ANALYSIS.COMPUTE_COMPONENTS);
+  }
 
-//top-menu: ML | Analyze | Multivariate Analysis...
-//name: multivariateAnalysis
-//description: Multidimensional data analysis using partial least squares (PLS) regression.
-export async function MVA(): Promise<void> {
-  await runMVA(PLS_ANALYSIS.PERFORM_MVA);
-}
 
-//name: MVA demo
-//description: Multidimensional data analysis using partial least squares (PLS) regression. It identifies latent factors and constructs a linear model based on them.
-//meta.demoPath: Compute | Multivariate Analysis
-export async function demoMultivariateAnalysis(): Promise<any> {
-  await runDemoMVA();
-}
+  @grok.decorators.func({
+    'top-menu': 'ML | Analyze | Multivariate Analysis...',
+    'name': 'multivariateAnalysis',
+    'description': 'Multidimensional data analysis using partial least squares (PLS) regression.'
+  })
+  static async MVA(): Promise<void> {
 
-//name: trainLinearKernelSVM
-//meta.mlname: linear kernel LS-SVM
-//meta.mlrole: train
-//input: dataframe df
-//input: column predictColumn
-//input: double gamma = 1.0 {category: Hyperparameters}
-//output: dynamic model
-export async function trainLinearKernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
-  gamma: number): Promise<any> {
-  const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predictColumn);
-  return getPackedModel(trainedModel);
-}
+    await runMVA(PLS_ANALYSIS.PERFORM_MVA);
+  }
 
-//name: applyLinearKernelSVM
-//meta.mlname: linear kernel LS-SVM
-//meta.mlrole: apply
-//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);
-}
 
-//name: isApplicableLinearKernelSVM
-//meta.mlname: linear kernel LS-SVM
-//meta.mlrole: isApplicable
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export async function isApplicableLinearKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
-  return isApplicableSVM(df, predictColumn);
-}
+  @grok.decorators.func({
+    'meta': {
+      'demoPath': 'Compute | Multivariate Analysis'
+    },
+    'name': 'MVA demo',
+    'description': 'Multidimensional data analysis using partial least squares (PLS) regression. It identifies latent factors and constructs a linear model based on them.'
+  })
+  static async demoMultivariateAnalysis(): Promise<void> {
+    await runDemoMVA();
+  }
 
-//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: column targetColumn
-//input: column predictColumn
-//input: dynamic model
-//output: dynamic widget
-export async function visualizeLinearKernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
-  return showTrainReport(df, model);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'linear kernel LS-SVM',
+      'mlrole': 'train'
+    }
+  })
+  static async trainLinearKernelSVM(
+    df: DG.DataFrame,
+    predictColumn: DG.Column,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1.0'}}) gamma: number): Promise<any> {
+
+    const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predictColumn);
+    return getPackedModel(trainedModel);
+  }
 
 
-//name: trainRBFkernelSVM
-//meta.mlname: RBF-kernel LS-SVM
-//meta.mlrole: train
-//input: dataframe df
-//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, predictColumn: DG.Column,
-  gamma: number, sigma: number): Promise<any> {
-  const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: RBF, sigma: sigma},
-    df, predictColumn);
-
-  return getPackedModel(trainedModel);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'linear kernel LS-SVM',
+      'mlrole': 'apply'
+    }
+  })
+  static async applyLinearKernelSVM(
+    df: DG.DataFrame,
+    model: any): Promise<DG.DataFrame> {
 
-//name: applyRBFkernelSVM
-//meta.mlname: RBF-kernel LS-SVM
-//meta.mlrole: apply
-//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);
-}
+    return await getPrediction(df, model);
+  }
 
-//name: isApplicableRBFkernelSVM
-//meta.mlname: RBF-kernel LS-SVM
-//meta.mlrole: isApplicable
-//input: dataframe df
-//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 isInteractiveRBFkernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
-  return isInteractiveSVM(df, predictColumn);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'linear kernel LS-SVM',
+      'mlrole': 'isApplicable'
+    }
+  })
+  static async isApplicableLinearKernelSVM(
+    df: DG.DataFrame,
+    predictColumn: DG.Column): Promise<boolean> {
 
+    return isApplicableSVM(df, predictColumn);
+  }
 
-//name: visualizeRBFkernelSVM
-//meta.mlname: RBF-kernel LS-SVM
-//meta.mlrole: visualize
-//input: dataframe df
-//input: column targetColumn
-//input: column predictColumn
-//input: dynamic model
-//output: dynamic widget
-export async function visualizeRBFkernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
-  return showTrainReport(df, model);
-}
 
-//name: trainPolynomialKernelSVM
-//meta.mlname: polynomial kernel LS-SVM
-//meta.mlrole: train
-//input: dataframe df
-//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, predictColumn: DG.Column,
-  gamma: number, c: number, d: number): Promise<any> {
-  const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d},
-    df, predictColumn);
-
-  return getPackedModel(trainedModel);
-} // trainPolynomialKernelSVM
-
-//name: applyPolynomialKernelSVM
-//meta.mlname: polynomial kernel LS-SVM
-//meta.mlrole: apply
-//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);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'linear kernel LS-SVM',
+      'mlrole': 'isInteractive'
+    }
+  })
+  static async isInteractiveLinearKernelSVM(
+    df: DG.DataFrame,
+    predictColumn: DG.Column): Promise<boolean> {
 
-//name: isApplicablePolynomialKernelSVM
-//meta.mlname: polynomial kernel LS-SVM
-//meta.mlrole: isApplicable
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export async function isApplicablePolynomialKernelSVM(df: DG.DataFrame, predictColumn: DG.Column): Promise<boolean> {
-  return isApplicableSVM(df, predictColumn);
-}
+    return isInteractiveSVM(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 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: column targetColumn
-//input: column predictColumn
-//input: dynamic model
-//output: dynamic widget
-export async function visualizePolynomialKernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
-  return showTrainReport(df, model);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'linear kernel LS-SVM',
+      'mlrole': 'visualize'
+    }
+  })
+  static async visualizeLinearKernelSVM(
+    df: DG.DataFrame,
+    targetColumn: DG.Column,
+    predictColumn: DG.Column,
+    model: any): Promise<any> {
+    return showTrainReport(df, model);
+  }
 
-//name: trainSigmoidKernelSVM
-//meta.mlname: sigmoid kernel LS-SVM
-//meta.mlrole: train
-//input: dataframe df
-//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, predictColumn: DG.Column,
-  gamma: number, kappa: number, theta: number): Promise<any> {
-  const trainedModel = await getTrainedModel(
-    {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta},
-    df, predictColumn);
-
-  return getPackedModel(trainedModel);
-} // trainSigmoidKernelSVM
-
-//name: applySigmoidKernelSVM
-//meta.mlname: sigmoid kernel LS-SVM
-//meta.mlrole: apply
-//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);
-}
 
-//name: isApplicableSigmoidKernelSVM
-//meta.mlname: sigmoid kernel LS-SVM
-//meta.mlrole: isApplicable
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-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);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'RBF-kernel LS-SVM',
+      'mlrole': 'train'
+    }
+  })
+  static async trainRBFkernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1.0'}}) gamma: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1.5'}}) sigma: number): Promise<any> {
 
-//name: visualizeSigmoidKernelSVM
-//meta.mlname: sigmoid kernel LS-SVM
-//meta.mlrole: visualize
-//input: dataframe df
-//input: column targetColumn
-//input: column predictColumn
-//input: dynamic model
-//output: dynamic widget
-export async function visualizeSigmoidKernelSVM(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
-  return showTrainReport(df, model);
-}
+    const trainedModel = await getTrainedModel(
+      {gamma: gamma, kernel: RBF, sigma: sigma},
+      df, predictColumn);
 
-//top-menu: ML | Analyze | ANOVA...
-//name: ANOVA
-//description: One-way analysis of variances (ANOVA) determines whether the examined factor has a significant impact on the explored feature.
-export function anova(): void {
-  runOneWayAnova();
-}
+    return getPackedModel(trainedModel);
+  }
 
-//top-menu: ML | Impute Missing Values...
-//name: KNN impute
-//description: Missing values imputation using the k-nearest neighbors method (KNN)
-export function kNNImputation() {
-  runKNNImputer();
-}
 
-//name: KNN imputation for a table
-//description: Missing values imputation using the k-nearest neighbors method
-//input: dataframe table
-export async function kNNImputationForTable(table: DG.DataFrame) {
-  await runKNNImputer(table);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'RBF-kernel LS-SVM',
+      'mlrole': 'apply'
+    }
+  })
+  static async applyRBFkernelSVM(
+    df: DG.DataFrame,
+    model: any): Promise<DG.DataFrame> {
 
-//name: trainLinearRegression
-//meta.mlname: Linear Regression
-//meta.mlrole: train
-//input: dataframe df
-//input: column predictColumn
-//output: dynamic model
-export async function trainLinearRegression(df: DG.DataFrame, predictColumn: DG.Column): Promise<Uint8Array> {
-  const features = df.columns;
-  const params = await getLinearRegressionParams(features, predictColumn);
-
-  return new Uint8Array(params.buffer);
-}
+    return await getPrediction(df, model);
+  }
 
-//name: applyLinearRegression
-//meta.mlname: Linear Regression
-//meta.mlrole: apply
-//input: dataframe df
-//input: dynamic model
-//output: dataframe table
-export function applyLinearRegression(df: DG.DataFrame, model: any): DG.DataFrame {
-  const features = df.columns;
-  const params = new Float32Array((model as Uint8Array).buffer);
-  return DG.DataFrame.fromColumns([getPredictionByLinearRegression(features, params)]);
-}
 
-//name: isApplicableLinearRegression
-//meta.mlname: Linear Regression
-//meta.mlrole: isApplicable
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export function isApplicableLinearRegression(df: DG.DataFrame, predictColumn: DG.Column): boolean {
-  for (const col of df.columns) {
-    if (!col.matches('numerical'))
-      return false;
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'RBF-kernel LS-SVM',
+      'mlrole': 'isApplicable'
+    }
+  })
+  static async isApplicableRBFkernelSVM(
+    df: DG.DataFrame,
+    predictColumn: DG.Column): Promise<boolean> {
+
+    return isApplicableSVM(df, predictColumn);
   }
 
-  return predictColumn.matches('numerical');
-}
 
-//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;
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'RBF-kernel LS-SVM',
+      'mlrole': 'isInteractive'
+    }
+  })
+  static async isInteractiveRBFkernelSVM(
+    df: DG.DataFrame,
+    predictColumn: DG.Column): Promise<boolean> {
 
-//name: trainSoftmax
-//meta.mlname: Softmax
-//meta.mlrole: train
-//input: dataframe df
-//input: column predictColumn
-//input: double rate = 1.0 {category: Hyperparameters; min: 0.001; max: 20} [Learning rate]
-//input: int iterations = 100 {category: Hyperparameters; min: 1; max: 10000; step: 10} [Fitting iterations count]
-//input: double penalty = 0.1 {category: Hyperparameters; min: 0.0001; max: 1} [Regularization rate]
-//input: double tolerance = 0.001 {category: Hyperparameters; min: 0.00001; max: 0.1} [Fitting tolerance]
-//output: dynamic model
-export async function trainSoftmax(df: DG.DataFrame, predictColumn: DG.Column, rate: number,
-  iterations: number, penalty: number, tolerance: number): Promise<Uint8Array> {
-  const features = df.columns;
-
-  const model = new SoftmaxClassifier({
-    classesCount: predictColumn.categories.length,
-    featuresCount: features.length,
-  });
-
-  await model.fit(features, predictColumn, rate, iterations, penalty, tolerance);
-
-  return model.toBytes();
-}
+    return isInteractiveSVM(df, predictColumn);
+  }
 
-//name: applySoftmax
-//meta.mlname: Softmax
-//meta.mlrole: apply
-//input: dataframe df
-//input: dynamic model
-//output: dataframe table
-export function applySoftmax(df: DG.DataFrame, model: any): DG.DataFrame {
-  const features = df.columns;
-  const unpackedModel = new SoftmaxClassifier(undefined, model);
-
-  return DG.DataFrame.fromColumns([unpackedModel.predict(features)]);
-}
 
-//name: isApplicableSoftmax
-//meta.mlname: Softmax
-//meta.mlrole: isApplicable
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export function isApplicableSoftmax(df: DG.DataFrame, predictColumn: DG.Column): boolean {
-  return SoftmaxClassifier.isApplicable(df.columns, predictColumn);
-}
 
-//name: isInteractiveSoftmax
-//meta.mlname: Softmax
-//meta.mlrole: isInteractive
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export function isInteractiveSoftmax(df: DG.DataFrame, predictColumn: DG.Column): boolean {
-  return SoftmaxClassifier.isInteractive(df.columns, predictColumn);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'RBF-kernel LS-SVM',
+      'mlrole': 'visualize'
+    }
+  })
+  static async visualizeRBFkernelSVM(
+    df: DG.DataFrame,
+    targetColumn: DG.Column,
+    predictColumn: DG.Column,
+    model: any): Promise<any> {
+
+    return showTrainReport(df, model);
+  }
 
-//name: trainPLSRegression
-//meta.mlname: PLS Regression
-//meta.mlrole: train
-//input: dataframe df
-//input: column predictColumn
-//input: int components = 3 {min: 1; max: 10} [Number of latent components]
-//output: dynamic model
-export async function trainPLSRegression(df: DG.DataFrame, predictColumn: DG.Column, components: number): Promise<Uint8Array> {
-  const features = df.columns;
-
-  const model = new PlsModel();
-  await model.fit(
-    features,
-    predictColumn,
-    Math.min(components, features.length),
-  );
-
-  return model.toBytes();
-}
 
-//name: applyPLSRegression
-//meta.mlname: PLS Regression
-//meta.mlrole: apply
-//input: dataframe df
-//input: dynamic model
-//output: dataframe table
-export function applyPLSRegression(df: DG.DataFrame, model: any): DG.DataFrame {
-  const unpackedModel = new PlsModel(model);
-  return DG.DataFrame.fromColumns([unpackedModel.predict(df.columns)]);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'polynomial kernel LS-SVM',
+      'mlrole': 'train'
+    },
+  })
+  static async trainPolynomialKernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1.0'}}) gamma: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1'}}) c: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '2'}}) d: number): Promise<any> {
+
+    const trainedModel = await getTrainedModel(
+      {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d},
+      df, predictColumn);
+
+    return getPackedModel(trainedModel);
+  } // trainPolynomialKernelSVM
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'polynomial kernel LS-SVM',
+      'mlrole': 'apply'
+    },
+  })
+  static async applyPolynomialKernelSVM(
+      df: DG.DataFrame,
+       model: any): Promise<DG.DataFrame> {
+
+    return await getPrediction(df, model);
+  }
 
-//name: isApplicablePLSRegression
-//meta.mlname: PLS Regression
-//meta.mlrole: isApplicable
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export function isApplicablePLSRegression(df: DG.DataFrame, predictColumn: DG.Column): boolean {
-  return PlsModel.isApplicable(df.columns, predictColumn);
-}
 
-//name: visualizePLSRegression
-//meta.mlname: PLS Regression
-//meta.mlrole: visualize
-//input: dataframe df
-//input: column targetColumn
-//input: column predictColumn
-//input: dynamic model
-//output: dynamic widget
-export async function visualizePLSRegression(df: DG.DataFrame, targetColumn: DG.Column, predictColumn: DG.Column, model: any): Promise<any> {
-  const unpackedModel = new PlsModel(model);
-  const viewers = unpackedModel.viewers();
-
-  return viewers.map((v) => v.root);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'polynomial kernel LS-SVM',
+      'mlrole': 'isApplicable'
+    }
+  })
+  static async isApplicablePolynomialKernelSVM(
+    df: DG.DataFrame,
+    predictColumn: DG.Column): Promise<boolean> {
 
-//name: isInteractivePLSRegression
-//meta.mlname: PLS Regression
-//meta.mlrole: isInteractive
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export function isInteractivePLSRegression(df: DG.DataFrame, predictColumn: DG.Column): boolean {
-  return PlsModel.isInteractive(df.columns, predictColumn);
-}
+    return isApplicableSVM(df, predictColumn);
+  }
 
-//name: trainXGBooster
-//meta.mlname: XGBoost
-//meta.mlrole: train
-//input: dataframe df
-//input: column predictColumn
-//input: int iterations = 20 {min: 1; max: 100} [Number of training iterations]
-//input: double eta = 0.3 {caption: Rate; min: 0; max: 1} [Learning rate]
-//input: int maxDepth = 6 {min: 0; max: 20} [Maximum depth of a tree]
-//input: double lambda = 1 {min: 0; max: 100} [L2 regularization term]
-//input: double alpha = 0 {min: 0; max: 100} [L1 regularization term]
-//output: dynamic model
-export async function trainXGBooster(df: DG.DataFrame, predictColumn: DG.Column,
-  iterations: number, eta: number, maxDepth: number, lambda: number, alpha: number): Promise<Uint8Array> {
-  const features = df.columns;
-
-  const booster = new XGBooster();
-  await booster.fit(features, predictColumn, iterations, eta, maxDepth, lambda, alpha);
-
-  return booster.toBytes();
-}
 
-//name: applyXGBooster
-//meta.mlname: XGBoost
-//meta.mlrole: apply
-//input: dataframe df
-//input: dynamic model
-//output: dataframe table
-export function applyXGBooster(df: DG.DataFrame, model: any): DG.DataFrame {
-  const unpackedModel = new XGBooster(model);
-  return DG.DataFrame.fromColumns([unpackedModel.predict(df.columns)]);
-}
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'polynomial kernel LS-SVM',
+      'mlrole': 'isInteractive'
+    }
+  })
+  static async isInteractivePolynomialKernelSVM(
+    df: DG.DataFrame,
+    predictColumn: DG.Column): Promise<boolean> {
 
-//name: isInteractiveXGBooster
-//meta.mlname: XGBoost
-//meta.mlrole: isInteractive
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export function isInteractiveXGBooster(df: DG.DataFrame, predictColumn: DG.Column): boolean {
-  return XGBooster.isInteractive(df.columns, predictColumn);
-}
+    return isInteractiveSVM(df, predictColumn);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'polynomial kernel LS-SVM',
+      'mlrole': 'visualize'
+    },
+    'outputs': [{'name': 'widget','type': 'dynamic'}],
+    'name': 'visualizePolynomialKernelSVM'
+  })
+  static async visualizePolynomialKernelSVM(
+      df: DG.DataFrame,
+       targetColumn: DG.Column,
+       predictColumn: DG.Column,
+       model: any): Promise<any> {
+
+    return showTrainReport(df, model);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'sigmoid kernel LS-SVM',
+      'mlrole': 'train'
+    },
+    'name': 'trainSigmoidKernelSVM'
+  })
+  static async trainSigmoidKernelSVM(df: DG.DataFrame, predictColumn: DG.Column,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1.0'}}) gamma: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1'}}) kappa: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1'}}) theta: number): Promise<any> {
+
+    const trainedModel = await getTrainedModel(
+      {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta},
+      df, predictColumn);
+
+    return getPackedModel(trainedModel);
+  } // trainSigmoidKernelSVM
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'sigmoid kernel LS-SVM',
+      'mlrole': 'apply'
+    },
+    'name': 'applySigmoidKernelSVM'
+  })
+  static async applySigmoidKernelSVM(
+      df: DG.DataFrame,
+       model: any): Promise<DG.DataFrame> {
+
+    return await getPrediction(df, model);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'sigmoid kernel LS-SVM',
+      'mlrole': 'isApplicable'
+    },
+    'name': 'isApplicableSigmoidKernelSVM'
+  })
+  static async isApplicableSigmoidKernelSVM(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): Promise<boolean> {
+
+    return isApplicableSVM(df, predictColumn);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'sigmoid kernel LS-SVM',
+      'mlrole': 'isInteractive'
+    },
+    'name': 'isInteractiveSigmoidKernelSVM'
+  })
+  static async isInteractiveSigmoidKernelSVM(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): Promise<boolean> {
+
+    return isInteractiveSVM(df, predictColumn);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'sigmoid kernel LS-SVM',
+      'mlrole': 'visualize'
+    },
+    'name': 'visualizeSigmoidKernelSVM'
+  })
+  static async visualizeSigmoidKernelSVM(
+      df: DG.DataFrame,
+       targetColumn: DG.Column,
+       predictColumn: DG.Column,
+       model: any): Promise<any> {
+
+    return showTrainReport(df, model);
+  }
+
+
+  @grok.decorators.func({
+    'top-menu': 'ML | Analyze | ANOVA...',
+    'name': 'ANOVA',
+    'description': 'One-way analysis of variances (ANOVA) determines whether the examined factor has a significant impact on the explored feature.'
+  })
+  static anova(): void {
+
+    runOneWayAnova();
+  }
+
+
+  @grok.decorators.func({
+    'top-menu': 'ML | Impute Missing Values...',
+    'name': 'KNN impute',
+    'description': 'Missing values imputation using the k-nearest neighbors method (KNN)'
+  })
+  static kNNImputation() {
+
+    runKNNImputer();
+  }
+
+
+  @grok.decorators.func({
+    'name': 'KNN imputation for a table',
+    'description': 'Missing values imputation using the k-nearest neighbors method'
+  })
+  static async kNNImputationForTable(
+      table: DG.DataFrame) {
+
+    await runKNNImputer(table);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Linear Regression',
+      'mlrole': 'train'
+    },
+    'name': 'trainLinearRegression',
+    'outputs': [{'type': 'dynamic', 'name': 'model'}]
+  })
+  static async trainLinearRegression(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): Promise<Uint8Array> {
+
+    const features = df.columns;
+    const params = await getLinearRegressionParams(features, predictColumn);
+
+    return new Uint8Array(params.buffer);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Linear Regression',
+      'mlrole': 'apply'
+    },
+    'name': 'applyLinearRegression'
+  })
+  static applyLinearRegression(
+      df: DG.DataFrame,
+       model: any): DG.DataFrame {
+
+    const features = df.columns;
+    const params = new Float32Array((model as Uint8Array).buffer);
+    return DG.DataFrame.fromColumns([getPredictionByLinearRegression(features, params)]);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Linear Regression',
+      'mlrole': 'isApplicable'
+    },
+    'name': 'isApplicableLinearRegression'
+  })
+  static isApplicableLinearRegression(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    for (const col of df.columns) {
+      if (!col.matches('numerical'))
+        return false;
+    }
+
+    return predictColumn.matches('numerical');
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Linear Regression',
+      'mlrole': 'isInteractive'
+    },
+    'name': 'isInteractiveLinearRegression'
+  })
+  static isInteractiveLinearRegression(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    return df.rowCount <= 100000;
+  }
 
-//name: isApplicableXGBooster
-//meta.mlname: XGBoost
-//meta.mlrole: isApplicable
-//input: dataframe df
-//input: column predictColumn
-//output: bool result
-export function isApplicableXGBooster(df: DG.DataFrame, predictColumn: DG.Column): boolean {
-  return XGBooster.isApplicable(df.columns, predictColumn);
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Softmax',
+      'mlrole': 'train'
+    },
+    'name': 'trainSoftmax',
+    'outputs': [{'type': 'dynamic', 'name': 'model'}]
+  })
+  static async trainSoftmax(df: DG.DataFrame, predictColumn: DG.Column,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '1.0', 'min': '0.001', 'max': '20', description: 'Learning rate.'}}) rate: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '100', 'min': '1', 'max': '10000', 'step': '10', description: 'Fitting iterations count'}}) iterations: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '0.1', 'min': '0.0001', 'max': '1', description: 'Regularization rate.'}}) penalty: number,
+    @grok.decorators.param({'options':{'category':'Hyperparameters', 'initialValue': '0.001', 'min': '0.00001', 'max': '0.1', description: 'Fitting tolerance.'}}) tolerance: number): Promise<Uint8Array> {
+
+    const features = df.columns;
+
+    const model = new SoftmaxClassifier({
+      classesCount: predictColumn.categories.length,
+      featuresCount: features.length,
+    });
+
+    await model.fit(features, predictColumn, rate, iterations, penalty, tolerance);
+
+    return model.toBytes();
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Softmax',
+      'mlrole': 'apply'
+    },
+    'name': 'applySoftmax'
+  })
+  static applySoftmax(
+      df: DG.DataFrame,
+       model: any): DG.DataFrame {
+
+    const features = df.columns;
+    const unpackedModel = new SoftmaxClassifier(undefined, model);
+
+    return DG.DataFrame.fromColumns([unpackedModel.predict(features)]);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Softmax',
+      'mlrole': 'isApplicable'
+    },
+    'name': 'isApplicableSoftmax'
+  })
+  static isApplicableSoftmax(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    return SoftmaxClassifier.isApplicable(df.columns, predictColumn);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'Softmax',
+      'mlrole': 'isInteractive'
+    },
+    'name': 'isInteractiveSoftmax'
+  })
+  static isInteractiveSoftmax(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    return SoftmaxClassifier.isInteractive(df.columns, predictColumn);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'PLS Regression',
+      'mlrole': 'train'
+    },
+    'name': 'trainPLSRegression',
+    'outputs': [{'name': 'model', 'type': 'dynamic'}],
+  })
+  static async trainPLSRegression(
+      df: DG.DataFrame,
+       predictColumn: DG.Column,
+    @grok.decorators.param({'type':'int','options':{'min':'1','max':'10','initialValue':'3', description: 'Number of latent components.'}})   components: number): Promise<Uint8Array> {
+
+    const features = df.columns;
+
+    const model = new PlsModel();
+    await model.fit(
+      features,
+      predictColumn,
+      Math.min(components, features.length),
+    );
+
+    return model.toBytes();
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'PLS Regression',
+      'mlrole': 'apply'
+    },
+    'name': 'applyPLSRegression'
+  })
+  static applyPLSRegression(
+      df: DG.DataFrame,
+       model: any): DG.DataFrame {
+
+    const unpackedModel = new PlsModel(model);
+    return DG.DataFrame.fromColumns([unpackedModel.predict(df.columns)]);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'PLS Regression',
+      'mlrole': 'isApplicable'
+    },
+    'name': 'isApplicablePLSRegression'
+  })
+  static isApplicablePLSRegression(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    return PlsModel.isApplicable(df.columns, predictColumn);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'PLS Regression',
+      'mlrole': 'visualize'
+    },
+    'name': 'visualizePLSRegression'
+  })
+  static async visualizePLSRegression(
+      df: DG.DataFrame,
+       targetColumn: DG.Column,
+       predictColumn: DG.Column,
+       model: any): Promise<any> {
+
+    const unpackedModel = new PlsModel(model);
+    const viewers = unpackedModel.viewers();
+
+    return viewers.map((v) => v.root);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'PLS Regression',
+      'mlrole': 'isInteractive'
+    },
+    'name': 'isInteractivePLSRegression'
+  })
+  static isInteractivePLSRegression(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    return PlsModel.isInteractive(df.columns, predictColumn);
+  }
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'XGBoost',
+      'mlrole': 'train'
+    },
+    'name': 'trainXGBooster',
+    'outputs': [{'name': 'model', 'type': 'dynamic'}],
+  })
+  static async trainXGBooster(
+      df: DG.DataFrame,
+       predictColumn: DG.Column,
+    @grok.decorators.param({'type':'int','options':{'min':'1','max':'100','initialValue':'20', description: 'Number of training iterations.'}})   iterations: number,
+    @grok.decorators.param({'type':'double','options':{'caption':'Rate','min':'0','max':'1','initialValue':'0.3', description: 'Learning rate.'}})   eta: number,
+    @grok.decorators.param({'type':'int','options':{'min':'0','max':'20','initialValue':'6', description: 'Maximum depth of a tree.'}})   maxDepth: number,
+    @grok.decorators.param({'type':'double','options':{'min':'0','max':'100','initialValue':'1', description: 'L2 regularization term.'}})   lambda: number,
+    @grok.decorators.param({'type':'double','options':{'min':'0','max':'100','initialValue':'0', description: 'L1 regularization term.'}})   alpha: number): Promise<Uint8Array> {
+    const features = df.columns;
+
+    const booster = new XGBooster();
+    await booster.fit(features, predictColumn, iterations, eta, maxDepth, lambda, alpha);
+
+    return booster.toBytes();
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'XGBoost',
+      'mlrole': 'apply'
+    },
+    'name': 'applyXGBooster'
+  })
+  static applyXGBooster(
+      df: DG.DataFrame,
+       model: any): DG.DataFrame {
+
+    const unpackedModel = new XGBooster(model);
+    return DG.DataFrame.fromColumns([unpackedModel.predict(df.columns)]);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'XGBoost',
+      'mlrole': 'isInteractive'
+    },
+    'name': 'isInteractiveXGBooster'
+  })
+  static isInteractiveXGBooster(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    return XGBooster.isInteractive(df.columns, predictColumn);
+  }
+
+
+  @grok.decorators.func({
+    'meta': {
+      'mlname': 'XGBoost',
+      'mlrole': 'isApplicable'
+    },
+    'name': 'isApplicableXGBooster'
+  })
+  static isApplicableXGBooster(
+      df: DG.DataFrame,
+       predictColumn: DG.Column): boolean {
+
+    return XGBooster.isApplicable(df.columns, predictColumn);
+  }
 }