@datagrok/eda 1.1.24 → 1.1.27

package/package.json

@@ -1,94 +1,94 @@
 {
-  "name": "@datagrok/eda",
-  "friendlyName": "EDA",
-  "version": "1.1.24",
-  "description": "Exploratory Data Analysis Tools",
-  "dependencies": {
-    "@datagrok-libraries/math": "^1.1.7",
-    "@datagrok-libraries/ml": "^6.6.7",
-    "@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",
-    "dayjs": "^1.11.9",
-    "jstat": "^1.9.6",
-    "source-map-loader": "^4.0.1",
-    "umap-js": "^1.3.3",
-    "worker-loader": "latest"
-  },
-  "author": {
-    "name": "Viktor Makarichev",
-    "email": "vmakarichev@datagrok.ai"
-  },
-  "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.32.0",
-    "@typescript-eslint/parser": "^5.32.0",
-    "eslint": "^8.21.0",
-    "eslint-config-google": "^0.14.0",
-    "ts-loader": "latest",
-    "typescript": "latest",
-    "webpack": "latest",
-    "webpack-cli": "latest",
-    "css-loader": "latest",
-    "style-loader": "latest"
-  },
-  "scripts": {
-    "link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/tutorials",
-    "debug-eda": "webpack && grok publish",
-    "release-eda": "webpack && grok publish --release",
-    "build-eda": "webpack",
-    "build": "webpack",
-    "debug-eda-dev": "webpack && grok publish dev",
-    "release-eda-dev": "webpack && grok publish dev --release",
-    "debug-eda-local": "webpack && grok publish local",
-    "release-eda-local": "webpack && grok publish local --release",
-    "build-all": "npm --prefix ./../../js-api run build && npm --prefix ./../../libraries/utils run build && npm --prefix ./../../libraries/tutorials run build && npm run build"
-  },
-  "canEdit": [
-    "Developers"
-  ],
-  "canView": [
-    "All users"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/datagrok-ai/public.git",
-    "directory": "packages/EDA"
-  },
-  "category": "Machine Learning",
-  "sources": [
-    "wasm/EDA.js"
-  ],
-  "meta": {
-    "menu": {
-      "ML": {
-        "Tools": {
-          "Impute Missing Values...": null,
-          "Random Data...": null
-        },
-        "Cluster": {
-          "Cluster...": null,
-          "DBSCAN...": null
-        },
-        "Notebooks": {
-          "Browse Notebooks": null,
-          "Open in Notebook": null,
-          "New Notebook": null
-        },
-        "Models": {
-          "Browse Models": null,
-          "Train Model...": null,
-          "Apply Model...": null
-        },
-        "Analyse": {
-          "PCA...": null,
-          "ANOVA...": null,
-          "Multivariate Analysis...": null
-        },
-        "Reduce Dimensionality": null
-      }
+    "name": "@datagrok/eda",
+    "friendlyName": "EDA",
+    "version": "1.1.27",
+    "description": "Exploratory Data Analysis Tools",
+    "dependencies": {
+        "@datagrok-libraries/math": "^1.1.10",
+        "@datagrok-libraries/ml": "^6.6.11",
+        "@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",
+        "dayjs": "^1.11.9",
+        "jstat": "^1.9.6",
+        "source-map-loader": "^4.0.1",
+        "umap-js": "^1.3.3",
+        "worker-loader": "latest"
+    },
+    "author": {
+        "name": "Viktor Makarichev",
+        "email": "vmakarichev@datagrok.ai"
+    },
+    "devDependencies": {
+        "@typescript-eslint/eslint-plugin": "^5.32.0",
+        "@typescript-eslint/parser": "^5.32.0",
+        "eslint": "^8.21.0",
+        "eslint-config-google": "^0.14.0",
+        "ts-loader": "latest",
+        "typescript": "latest",
+        "webpack": "latest",
+        "webpack-cli": "latest",
+        "css-loader": "latest",
+        "style-loader": "latest"
+    },
+    "scripts": {
+        "link-all": "npm link datagrok-api @datagrok-libraries/utils @datagrok-libraries/tutorials",
+        "debug-eda": "webpack && grok publish",
+        "release-eda": "webpack && grok publish --release",
+        "build-eda": "webpack",
+        "build": "webpack",
+        "debug-eda-dev": "webpack && grok publish dev",
+        "release-eda-dev": "webpack && grok publish dev --release",
+        "debug-eda-local": "webpack && grok publish local",
+        "release-eda-local": "webpack && grok publish local --release",
+        "build-all": "npm --prefix ./../../js-api run build && npm --prefix ./../../libraries/utils run build && npm --prefix ./../../libraries/tutorials run build && npm run build"
+    },
+    "canEdit": [
+        "Developers"
+    ],
+    "canView": [
+        "All users"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/datagrok-ai/public.git",
+        "directory": "packages/EDA"
+    },
+    "category": "Machine Learning",
+    "sources": [
+        "wasm/EDA.js"
+    ],
+    "meta": {
+        "menu": {
+            "ML": {
+                "Tools": {
+                    "Impute Missing Values...": null,
+                    "Random Data...": null
+                },
+                "Cluster": {
+                    "Cluster...": null,
+                    "DBSCAN...": null
+                },
+                "Notebooks": {
+                    "Browse Notebooks": null,
+                    "Open in Notebook": null,
+                    "New Notebook": null
+                },
+                "Models": {
+                    "Browse Models": null,
+                    "Train Model...": null,
+                    "Apply Model...": null
+                },
+                "Analyse": {
+                    "PCA...": null,
+                    "ANOVA...": null,
+                    "Multivariate Analysis...": null
+                },
+                "Reduce Dimensionality": null
+            }
+        }
     }
-  }
-}
+}

package/scripts/command.txt

@@ -1 +1 @@
-em++ -O3 ../wasm/pcaExport.cpp ../wasm/PCA/PCA.cpp ../wasm/plsExport.cpp ../wasm/PLS/PLS.cpp ../wasm/svmApi.cpp -o ../wasm/EDA.js -s TOTAL_MEMORY=268435456 -s WASM=1 -s ALLOW_MEMORY_GROWTH=1 -s MODULARIZE=1 -s EXPORT_NAME="exportEDA" -s EXPORTED_FUNCTIONS=["_principalComponentAnalysis","_error","_partialLeastSquareRegression","_generateDataset","_normalizeDataset","_trainLSSVM","_predictByLSSVM","_trainAndAnalyzeLSSVM","_malloc","_free"] -s EXPORTED_RUNTIME_METHODS=["cwrap","ccall"] -sENVIRONMENT=web,worker
+em++ -O3 ../wasm/pcaExport.cpp ../wasm/PCA/PCA.cpp ../wasm/plsExport.cpp ../wasm/PLS/PLS.cpp ../wasm/svmApi.cpp ../wasm/regression-api.cpp -o ../wasm/EDA.js -s TOTAL_MEMORY=268435456 -s WASM=1 -s ALLOW_MEMORY_GROWTH=1 -s MODULARIZE=1 -s EXPORT_NAME="exportEDA" -s EXPORTED_FUNCTIONS=["_principalComponentAnalysis","_error","_partialLeastSquareRegression","_generateDataset","_normalizeDataset","_trainLSSVM","_predictByLSSVM","_trainAndAnalyzeLSSVM","_fitLinearRegressionParamsWithDataNormalizing","_fitLinearRegressionParams","_malloc","_free"] -s EXPORTED_RUNTIME_METHODS=["cwrap","ccall"] -sENVIRONMENT=web,worker

package/scripts/func.json

@@ -1 +1 @@
-{"pcaExport.cpp": {"principalComponentAnalysis": {"arguments": {"columns": {"type": "floatColumns"}, "componentsCount": {"type": "num"}, "centerNum": {"type": "num"}, "scaleNum": {"type": "num"}, "components": {"type": "newFloatColumns", "numOfRows": {"ref": "columns", "value": "numOfRows"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}}, "output": {"type": "tableFromColumns", "source": "components"}, "annotation": ["//name: principalComponentAnalysis", "//input: dataframe table", "//input: column_list columns", "//input: int componentsCount", "//input: int centerNum", "//input: int scaleNum", "//output: dataframe result "], "prototype": "principalComponentAnalysis(table, columns, componentsCount, centerNum, scaleNum)", "prototypeForWebWorker": "principalComponentAnalysisInWebWorker(table, columns, componentsCount, centerNum, scaleNum)", "callArgs": "[columns, componentsCount, centerNum, scaleNum]"}, "error": {"arguments": {"col1": {"type": "floatColumn"}, "col2": {"type": "floatColumn"}}, "output": {"type": "double", "source": "_callResult"}, "annotation": ["//name: error", "//input: dataframe df", "//input: column col1", "//input: column col2", "//output: double mad "], "prototype": "error(df, col1, col2)", "prototypeForWebWorker": "errorInWebWorker(df, col1, col2)", "callArgs": "[col1, col2]"}}, "PCA/PCA.cpp": {}, "plsExport.cpp": {"partialLeastSquareRegression": {"arguments": {"features": {"type": "floatColumns"}, "predict": {"type": "floatColumn"}, "componentsCount": {"type": "num"}, "prediction": {"type": "newFloatColumn", "numOfRows": {"ref": "predict", "value": "numOfRows"}}, "regressionCoefficients": {"type": "newFloatColumn", "numOfRows": {"ref": "features", "value": "numOfColumns"}}, "tScores": {"type": "newFloatColumns", "numOfRows": {"ref": "predict", "value": "numOfRows"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}, "uScores": {"type": "newFloatColumns", "numOfRows": {"ref": "predict", "value": "numOfRows"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}, "xLoadings": {"type": "newFloatColumns", "numOfRows": {"ref": "features", "value": "numOfColumns"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}, "yLoadings": {"type": "newFloatColumn", "numOfRows": {"ref": "componentsCount", "value": "data"}}}, "output": {"type": "objects", "source": "['prediction', 'regressionCoefficients', 'tScores', 'uScores', 'xLoadings', 'yLoadings']"}, "annotation": ["//name: partialLeastSquareRegression", "//input: dataframe table", "//input: column_list features", "//input: column predict", "//input: int componentsCount"], "prototype": "partialLeastSquareRegression(table, features, predict, componentsCount)", "prototypeForWebWorker": "partialLeastSquareRegressionInWebWorker(table, features, predict, componentsCount)", "callArgs": "[features, predict, componentsCount]"}}, "PLS/PLS.cpp": {}, "svmApi.cpp": {"generateDataset": {"arguments": {"kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "samplesCount": {"type": "num"}, "featuresCount": {"type": "num"}, "min": {"type": "num"}, "max": {"type": "num"}, "violatorsPercentage": {"type": "num"}, "dataset": {"type": "newFloatColumns", "numOfRows": {"ref": "samplesCount", "value": "data"}, "numOfColumns": {"ref": "featuresCount", "value": "data"}}, "labels": {"type": "newFloatColumn", "numOfRows": {"ref": "samplesCount", "value": "data"}}}, "output": {"type": "objects", "source": "['dataset', 'labels']"}, "annotation": ["//name: generateDataset", "//input: int kernel", "//input: column kernelParams", "//input: int samplesCount", "//input: int featuresCount", "//input: double min", "//input: double max", "//input: double violatorsPercentage"], "prototype": "generateDataset(kernel, kernelParams, samplesCount, featuresCount, min, max, violatorsPercentage)", "prototypeForWebWorker": "generateDatasetInWebWorker(kernel, kernelParams, samplesCount, featuresCount, min, max, violatorsPercentage)", "callArgs": "[kernel, kernelParams, samplesCount, featuresCount, min, max, violatorsPercentage]"}, "normalizeDataset": {"arguments": {"data": {"type": "floatColumns"}, "normalizedData": {"type": "newFloatColumns", "numOfRows": {"ref": "data", "value": "numOfColumns"}, "numOfColumns": {"ref": "data", "value": "numOfRows"}}, "means": {"type": "newFloatColumn", "numOfRows": {"ref": "data", "value": "numOfColumns"}}, "stdDevs": {"type": "newFloatColumn", "numOfRows": {"ref": "data", "value": "numOfColumns"}}}, "output": {"type": "objects", "source": "['normalizedData', 'means', 'stdDevs']"}, "annotation": ["//name: normalizeDataset", "//input: column_list data"], "prototype": "normalizeDataset(data)", "prototypeForWebWorker": "normalizeDatasetInWebWorker(data)", "callArgs": "[data]"}, "trainLSSVM": {"arguments": {"gamma": {"type": "num"}, "kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "modelParamsCount": {"type": "num"}, "precomputedWeightsCount": {"type": "num"}, "dataset": {"type": "floatColumns"}, "labels": {"type": "floatColumn"}, "normalizedData": {"type": "newFloatColumns", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}, "numOfColumns": {"ref": "dataset", "value": "numOfRows"}}, "means": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "stdDevs": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "modelParams": {"type": "newFloatColumn", "numOfRows": {"ref": "modelParamsCount", "value": "data"}}, "precomputedWeights": {"type": "newFloatColumn", "numOfRows": {"ref": "precomputedWeightsCount", "value": "data"}}}, "output": {"type": "objects", "source": "['normalizedData', 'means', 'stdDevs', 'modelParams', 'precomputedWeights']"}, "annotation": ["//name: trainLSSVM", "//input: double gamma", "//input: int kernel", "//input: column kernelParams", "//input: int modelParamsCount", "//input: int precomputedWeightsCount", "//input: column_list dataset", "//input: column labels"], "prototype": "trainLSSVM(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, dataset, labels)", "prototypeForWebWorker": "trainLSSVMInWebWorker(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, dataset, labels)", "callArgs": "[gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, dataset, labels]"}, "predictByLSSVM": {"arguments": {"kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "normalizedData": {"type": "floatColumns"}, "labels": {"type": "floatColumn"}, "means": {"type": "floatColumn"}, "stdDevs": {"type": "floatColumn"}, "modelParams": {"type": "floatColumn"}, "precomputedWeights": {"type": "floatColumn"}, "targetData": {"type": "floatColumns"}, "prediction": {"type": "newFloatColumn", "numOfRows": {"ref": "targetData", "value": "numOfRows"}}}, "output": {"type": "column", "source": "prediction"}, "annotation": ["//name: predictByLSSVM", "//input: int kernel", "//input: column kernelParams", "//input: column_list normalizedData", "//input: column labels", "//input: column means", "//input: column stdDevs", "//input: column modelParams", "//input: column precomputedWeights", "//input: column_list targetData", "//output: column prediction"], "prototype": "predictByLSSVM(kernel, kernelParams, normalizedData, labels, means, stdDevs, modelParams, precomputedWeights, targetData)", "prototypeForWebWorker": "predictByLSSVMInWebWorker(kernel, kernelParams, normalizedData, labels, means, stdDevs, modelParams, precomputedWeights, targetData)", "callArgs": "[kernel, kernelParams, normalizedData, labels, means, stdDevs, modelParams, precomputedWeights, targetData]"}, "trainAndAnalyzeLSSVM": {"arguments": {"gamma": {"type": "num"}, "kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "modelParamsCount": {"type": "num"}, "precomputedWeightsCount": {"type": "num"}, "confusionMatrixElementsCount": {"type": "num"}, "dataset": {"type": "floatColumns"}, "labels": {"type": "floatColumn"}, "normalizedData": {"type": "newFloatColumns", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}, "numOfColumns": {"ref": "dataset", "value": "numOfRows"}}, "means": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "stdDevs": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "modelParams": {"type": "newFloatColumn", "numOfRows": {"ref": "modelParamsCount", "value": "data"}}, "precomputedWeights": {"type": "newFloatColumn", "numOfRows": {"ref": "precomputedWeightsCount", "value": "data"}}, "predictedLabels": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfRows"}}, "correctness": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfRows"}}, "consfusionMatrix": {"type": "newIntColumn", "numOfRows": {"ref": "confusionMatrixElementsCount", "value": "data"}}}, "output": {"type": "objects", "source": "['normalizedData', 'means', 'stdDevs', 'modelParams', 'precomputedWeights', 'predictedLabels', 'correctness', 'consfusionMatrix']"}, "annotation": ["//name: trainAndAnalyzeLSSVM", "//input: double gamma", "//input: int kernel", "//input: column kernelParams", "//input: int modelParamsCount", "//input: int precomputedWeightsCount", "//input: int confusionMatrixElementsCount", "//input: column_list dataset", "//input: column labels"], "prototype": "trainAndAnalyzeLSSVM(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount, dataset, labels)", "prototypeForWebWorker": "trainAndAnalyzeLSSVMInWebWorker(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount, dataset, labels)", "callArgs": "[gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount, dataset, labels]"}}}
+{"pcaExport.cpp": {"principalComponentAnalysis": {"arguments": {"columns": {"type": "floatColumns"}, "componentsCount": {"type": "num"}, "centerNum": {"type": "num"}, "scaleNum": {"type": "num"}, "components": {"type": "newFloatColumns", "numOfRows": {"ref": "columns", "value": "numOfRows"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}}, "output": {"type": "tableFromColumns", "source": "components"}, "annotation": ["//name: principalComponentAnalysis", "//input: dataframe table", "//input: column_list columns", "//input: int componentsCount", "//input: int centerNum", "//input: int scaleNum", "//output: dataframe result "], "prototype": "principalComponentAnalysis(table, columns, componentsCount, centerNum, scaleNum)", "prototypeForWebWorker": "principalComponentAnalysisInWebWorker(table, columns, componentsCount, centerNum, scaleNum)", "callArgs": "[columns, componentsCount, centerNum, scaleNum]"}, "error": {"arguments": {"col1": {"type": "floatColumn"}, "col2": {"type": "floatColumn"}}, "output": {"type": "double", "source": "_callResult"}, "annotation": ["//name: error", "//input: dataframe df", "//input: column col1", "//input: column col2", "//output: double mad "], "prototype": "error(df, col1, col2)", "prototypeForWebWorker": "errorInWebWorker(df, col1, col2)", "callArgs": "[col1, col2]"}}, "PCA/PCA.cpp": {}, "plsExport.cpp": {"partialLeastSquareRegression": {"arguments": {"features": {"type": "floatColumns"}, "predict": {"type": "floatColumn"}, "componentsCount": {"type": "num"}, "prediction": {"type": "newFloatColumn", "numOfRows": {"ref": "predict", "value": "numOfRows"}}, "regressionCoefficients": {"type": "newFloatColumn", "numOfRows": {"ref": "features", "value": "numOfColumns"}}, "tScores": {"type": "newFloatColumns", "numOfRows": {"ref": "predict", "value": "numOfRows"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}, "uScores": {"type": "newFloatColumns", "numOfRows": {"ref": "predict", "value": "numOfRows"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}, "xLoadings": {"type": "newFloatColumns", "numOfRows": {"ref": "features", "value": "numOfColumns"}, "numOfColumns": {"ref": "componentsCount", "value": "data"}}, "yLoadings": {"type": "newFloatColumn", "numOfRows": {"ref": "componentsCount", "value": "data"}}}, "output": {"type": "objects", "source": "['prediction', 'regressionCoefficients', 'tScores', 'uScores', 'xLoadings', 'yLoadings']"}, "annotation": ["//name: partialLeastSquareRegression", "//input: dataframe table", "//input: column_list features", "//input: column predict", "//input: int componentsCount"], "prototype": "partialLeastSquareRegression(table, features, predict, componentsCount)", "prototypeForWebWorker": "partialLeastSquareRegressionInWebWorker(table, features, predict, componentsCount)", "callArgs": "[features, predict, componentsCount]"}}, "PLS/PLS.cpp": {}, "svmApi.cpp": {"generateDataset": {"arguments": {"kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "samplesCount": {"type": "num"}, "featuresCount": {"type": "num"}, "min": {"type": "num"}, "max": {"type": "num"}, "violatorsPercentage": {"type": "num"}, "dataset": {"type": "newFloatColumns", "numOfRows": {"ref": "samplesCount", "value": "data"}, "numOfColumns": {"ref": "featuresCount", "value": "data"}}, "labels": {"type": "newFloatColumn", "numOfRows": {"ref": "samplesCount", "value": "data"}}}, "output": {"type": "objects", "source": "['dataset', 'labels']"}, "annotation": ["//name: generateDataset", "//input: int kernel", "//input: column kernelParams", "//input: int samplesCount", "//input: int featuresCount", "//input: double min", "//input: double max", "//input: double violatorsPercentage"], "prototype": "generateDataset(kernel, kernelParams, samplesCount, featuresCount, min, max, violatorsPercentage)", "prototypeForWebWorker": "generateDatasetInWebWorker(kernel, kernelParams, samplesCount, featuresCount, min, max, violatorsPercentage)", "callArgs": "[kernel, kernelParams, samplesCount, featuresCount, min, max, violatorsPercentage]"}, "normalizeDataset": {"arguments": {"data": {"type": "floatColumns"}, "normalizedData": {"type": "newFloatColumns", "numOfRows": {"ref": "data", "value": "numOfColumns"}, "numOfColumns": {"ref": "data", "value": "numOfRows"}}, "means": {"type": "newFloatColumn", "numOfRows": {"ref": "data", "value": "numOfColumns"}}, "stdDevs": {"type": "newFloatColumn", "numOfRows": {"ref": "data", "value": "numOfColumns"}}}, "output": {"type": "objects", "source": "['normalizedData', 'means', 'stdDevs']"}, "annotation": ["//name: normalizeDataset", "//input: column_list data"], "prototype": "normalizeDataset(data)", "prototypeForWebWorker": "normalizeDatasetInWebWorker(data)", "callArgs": "[data]"}, "trainLSSVM": {"arguments": {"gamma": {"type": "num"}, "kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "modelParamsCount": {"type": "num"}, "precomputedWeightsCount": {"type": "num"}, "dataset": {"type": "floatColumns"}, "labels": {"type": "floatColumn"}, "normalizedData": {"type": "newFloatColumns", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}, "numOfColumns": {"ref": "dataset", "value": "numOfRows"}}, "means": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "stdDevs": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "modelParams": {"type": "newFloatColumn", "numOfRows": {"ref": "modelParamsCount", "value": "data"}}, "precomputedWeights": {"type": "newFloatColumn", "numOfRows": {"ref": "precomputedWeightsCount", "value": "data"}}}, "output": {"type": "objects", "source": "['normalizedData', 'means', 'stdDevs', 'modelParams', 'precomputedWeights']"}, "annotation": ["//name: trainLSSVM", "//input: double gamma", "//input: int kernel", "//input: column kernelParams", "//input: int modelParamsCount", "//input: int precomputedWeightsCount", "//input: column_list dataset", "//input: column labels"], "prototype": "trainLSSVM(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, dataset, labels)", "prototypeForWebWorker": "trainLSSVMInWebWorker(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, dataset, labels)", "callArgs": "[gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, dataset, labels]"}, "predictByLSSVM": {"arguments": {"kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "normalizedData": {"type": "floatColumns"}, "labels": {"type": "floatColumn"}, "means": {"type": "floatColumn"}, "stdDevs": {"type": "floatColumn"}, "modelParams": {"type": "floatColumn"}, "precomputedWeights": {"type": "floatColumn"}, "targetData": {"type": "floatColumns"}, "prediction": {"type": "newFloatColumn", "numOfRows": {"ref": "targetData", "value": "numOfRows"}}}, "output": {"type": "column", "source": "prediction"}, "annotation": ["//name: predictByLSSVM", "//input: int kernel", "//input: column kernelParams", "//input: column_list normalizedData", "//input: column labels", "//input: column means", "//input: column stdDevs", "//input: column modelParams", "//input: column precomputedWeights", "//input: column_list targetData", "//output: column prediction"], "prototype": "predictByLSSVM(kernel, kernelParams, normalizedData, labels, means, stdDevs, modelParams, precomputedWeights, targetData)", "prototypeForWebWorker": "predictByLSSVMInWebWorker(kernel, kernelParams, normalizedData, labels, means, stdDevs, modelParams, precomputedWeights, targetData)", "callArgs": "[kernel, kernelParams, normalizedData, labels, means, stdDevs, modelParams, precomputedWeights, targetData]"}, "trainAndAnalyzeLSSVM": {"arguments": {"gamma": {"type": "num"}, "kernel": {"type": "num"}, "kernelParams": {"type": "floatColumn"}, "modelParamsCount": {"type": "num"}, "precomputedWeightsCount": {"type": "num"}, "confusionMatrixElementsCount": {"type": "num"}, "dataset": {"type": "floatColumns"}, "labels": {"type": "floatColumn"}, "normalizedData": {"type": "newFloatColumns", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}, "numOfColumns": {"ref": "dataset", "value": "numOfRows"}}, "means": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "stdDevs": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfColumns"}}, "modelParams": {"type": "newFloatColumn", "numOfRows": {"ref": "modelParamsCount", "value": "data"}}, "precomputedWeights": {"type": "newFloatColumn", "numOfRows": {"ref": "precomputedWeightsCount", "value": "data"}}, "predictedLabels": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfRows"}}, "correctness": {"type": "newFloatColumn", "numOfRows": {"ref": "dataset", "value": "numOfRows"}}, "consfusionMatrix": {"type": "newIntColumn", "numOfRows": {"ref": "confusionMatrixElementsCount", "value": "data"}}}, "output": {"type": "objects", "source": "['normalizedData', 'means', 'stdDevs', 'modelParams', 'precomputedWeights', 'predictedLabels', 'correctness', 'consfusionMatrix']"}, "annotation": ["//name: trainAndAnalyzeLSSVM", "//input: double gamma", "//input: int kernel", "//input: column kernelParams", "//input: int modelParamsCount", "//input: int precomputedWeightsCount", "//input: int confusionMatrixElementsCount", "//input: column_list dataset", "//input: column labels"], "prototype": "trainAndAnalyzeLSSVM(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount, dataset, labels)", "prototypeForWebWorker": "trainAndAnalyzeLSSVMInWebWorker(gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount, dataset, labels)", "callArgs": "[gamma, kernel, kernelParams, modelParamsCount, precomputedWeightsCount, confusionMatrixElementsCount, dataset, labels]"}}, "regression-api.cpp": {"fitLinearRegressionParamsWithDataNormalizing": {"arguments": {"features": {"type": "floatColumns"}, "featureAvgs": {"type": "floatColumn"}, "featureStdDevs": {"type": "floatColumn"}, "targets": {"type": "floatColumn"}, "targetsAvg": {"type": "num"}, "targetsStdDev": {"type": "num"}, "paramsCount": {"type": "num"}, "params": {"type": "newFloatColumn", "numOfRows": {"ref": "paramsCount", "value": "data"}}}, "output": {"type": "column", "source": "params"}, "annotation": ["//name: fitLinearRegressionParamsWithDataNormalizing", "//input: column_list features", "//input: column featureAvgs", "//input: column featureStdDevs", "//input: column targets", "//input: double targetsAvg", "//input: double targetsStdDev", "//input: int paramsCount", "//output: column params"], "prototype": "fitLinearRegressionParamsWithDataNormalizing(features, featureAvgs, featureStdDevs, targets, targetsAvg, targetsStdDev, paramsCount)", "prototypeForWebWorker": "fitLinearRegressionParamsWithDataNormalizingInWebWorker(features, featureAvgs, featureStdDevs, targets, targetsAvg, targetsStdDev, paramsCount)", "callArgs": "[features, featureAvgs, featureStdDevs, targets, targetsAvg, targetsStdDev, paramsCount]"}, "fitLinearRegressionParams": {"arguments": {"features": {"type": "floatColumns"}, "targets": {"type": "floatColumn"}, "paramsCount": {"type": "num"}, "params": {"type": "newFloatColumn", "numOfRows": {"ref": "paramsCount", "value": "data"}}}, "output": {"type": "column", "source": "params"}, "annotation": ["//name: fitLinearRegressionParams", "//input: column_list features", "//input: column targets", "//input: int paramsCount", "//output: column params"], "prototype": "fitLinearRegressionParams(features, targets, paramsCount)", "prototypeForWebWorker": "fitLinearRegressionParamsInWebWorker(features, targets, paramsCount)", "callArgs": "[features, targets, paramsCount]"}}}

package/scripts/module.json

@@ -1,7 +1,7 @@
 {
     "name": "EDA",    
     "folder": "../wasm",
-    "source": ["pcaExport.cpp", "PCA/PCA.cpp", "plsExport.cpp", "PLS/PLS.cpp", "svmApi.cpp"],    
+    "source": ["pcaExport.cpp", "PCA/PCA.cpp", "plsExport.cpp", "PLS/PLS.cpp", "svmApi.cpp", "regression-api.cpp"],    
     "optimizationMode": "-O3",    
     "packageFile": "../src/package.ts",
     "packageJsonFile": "../package.json",    

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, showTrainReport, getPackedModel} from './svm';
+  getTrainedModel, getPrediction, isApplicableSVM, showTrainReport, getPackedModel} from './svm';
 
 import {PLS_ANALYSIS} from './pls/pls-constants';
 import {runMVA, runDemoMVA, getPlsAnalysis, PlsOutput} from './pls/pls-tools';
@@ -29,6 +29,9 @@ import {DimReductionMethods} from '@datagrok-libraries/ml/src/multi-column-dimen
 import {runKNNImputer} from './missing-values-imputation/ui';
 import {MCLEditor} from '@datagrok-libraries/ml/src/MCL/mcl-editor';
 import {markovCluster} from '@datagrok-libraries/ml/src/MCL/clustering-view';
+import {MCL_OPTIONS_TAG, MCLSerializableOptions} from '@datagrok-libraries/ml/src/MCL';
+
+import {getLinearRegressionParams, getPredictionByLinearRegression, getTestDatasetForLinearRegression} from './regression';
 
 export const _package = new DG.Package();
 
@@ -189,7 +192,7 @@ export function GetMCLEditor(call: DG.FuncCall): void {
           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,
+          useWebGPU: params.useWebGPU, inflate: params.inflateFactor,
         }).call(true);
       }).show();
   } catch (err: any) {
@@ -214,13 +217,46 @@ export function GetMCLEditor(call: DG.FuncCall): void {
 //input: int threshold = 80
 //input: int maxIterations = 10
 //input: bool useWebGPU = false
+//input: double inflate = 2
 //editor: EDA: GetMCLEditor
 export async function MCL(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,
+  preprocessingFuncArgs: any[], threshold: number = 80, maxIterations: number = 10, useWebGPU: boolean = false, inflate: number = 0,
 ): Promise< DG.ScatterPlotViewer | undefined> {
-  const res = (await markovCluster(df, cols, metrics, weights,
-    aggregationMethod, preprocessingFuncs, preprocessingFuncArgs, threshold, maxIterations, useWebGPU));
+  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,
+  } satisfies MCLSerializableOptions);
+  df.setTag(MCL_OPTIONS_TAG, serializedOptions);
+
+  const sc = tv.addViewer(DG.VIEWER.SCATTER_PLOT, {title: 'MCL', initializationFunction: 'EDA:MCLInitializationFunction'}) as DG.ScatterPlotViewer;
+  return sc;
+}
+
+//name: MCLInitializationFunction
+//input: viewer sc
+export async function MCLInitializationFunction(sc: DG.ScatterPlotViewer) {
+  const df = sc.dataFrame;
+  if (df === null)
+    throw new Error('Data frame of the scatter plot is null');
+  const mclTag = df.getTag(MCL_OPTIONS_TAG);
+  if (!mclTag)
+    throw new Error('MCL options tag on the dataFrame is not found');
+  const options: MCLSerializableOptions = JSON.parse(mclTag);
+  const cols = options.cols.map((colName) => df.columns.byName(colName));
+  const preprocessingFuncs = options.preprocessingFuncs.map((funcName) => funcName ? DG.Func.byName(funcName) : null);
+  const res = await markovCluster(df, cols, options.metrics, options.weights,
+    options.aggregationMethod, preprocessingFuncs, options.preprocessingFuncArgs, options.threshold,
+    options.maxIterations, options.useWebGPU, options.inflate, sc);
   return res?.sc;
 }
 
@@ -300,15 +336,10 @@ export async function testDataLinearNonSeparable(name: string, sigma: number, sa
 //input: dataframe df
 //input: string predict_column
 //input: double gamma = 1.0 {category: Hyperparameters}
-//input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
 export async function trainLinearKernelSVM(df: DG.DataFrame, predict_column: string,
-  gamma: number, toShowReport: boolean): Promise<any> {
+  gamma: number): Promise<any> {
   const trainedModel = await getTrainedModel({gamma: gamma, kernel: LINEAR}, df, predict_column);
-
-  if (toShowReport)
-    showTrainReport(df, trainedModel);
-
   return getPackedModel(trainedModel);
 }
 
@@ -322,6 +353,29 @@ export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promis
   return await getPrediction(df, model);
 }
 
+//name: isApplicableLinearKernelSVM
+//meta.mlname: linear kernel LS-SVM
+//meta.mlrole: isApplicable
+//input: dataframe df
+//input: string predict_column
+//output: bool result
+export async function isApplicableLinearKernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
+  return isApplicableSVM(df, predict_column);
+}
+
+//name: visualizeLinearKernelSVM
+//meta.mlname: linear kernel LS-SVM
+//meta.mlrole: visualize
+//input: dataframe df
+//input: string target_column
+//input: string predict_column
+//input: dynamic model
+//output: dynamic widget
+export async function visualizeLinearKernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+  return showTrainReport(df, model);
+}
+
+
 //name: trainRBFkernelSVM
 //meta.mlname: RBF-kernel LS-SVM
 //meta.mlrole: train
@@ -329,17 +383,13 @@ export async function applyLinearKernelSVM(df: DG.DataFrame, model: any): Promis
 //input: string predict_column
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: double sigma = 1.5 {category: Hyperparameters}
-//input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
 export async function trainRBFkernelSVM(df: DG.DataFrame, predict_column: string,
-  gamma: number, sigma: number, toShowReport: boolean): Promise<any> {
+  gamma: number, sigma: number): Promise<any> {
   const trainedModel = await getTrainedModel(
     {gamma: gamma, kernel: RBF, sigma: sigma},
     df, predict_column);
 
-  if (toShowReport)
-    showTrainReport(df, trainedModel);
-
   return getPackedModel(trainedModel);
 }
 
@@ -353,6 +403,28 @@ export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<D
   return await getPrediction(df, model);
 }
 
+//name: isApplicableRBFkernelSVM
+//meta.mlname: RBF-kernel LS-SVM
+//meta.mlrole: isApplicable
+//input: dataframe df
+//input: string predict_column
+//output: bool result
+export async function isApplicableRBFkernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
+  return isApplicableSVM(df, predict_column);
+}
+
+//name: visualizeRBFkernelSVM
+//meta.mlname: RBF-kernel LS-SVM
+//meta.mlrole: visualize
+//input: dataframe df
+//input: string target_column
+//input: string predict_column
+//input: dynamic model
+//output: dynamic widget
+export async function visualizeRBFkernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+  return showTrainReport(df, model);
+}
+
 //name: trainPolynomialKernelSVM
 //meta.mlname: polynomial kernel LS-SVM
 //meta.mlrole: train
@@ -361,17 +433,13 @@ export async function applyRBFkernelSVM(df: DG.DataFrame, model: any): Promise<D
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: double c = 1 {category: Hyperparameters}
 //input: double d = 2 {category: Hyperparameters}
-//input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
 export async function trainPolynomialKernelSVM(df: DG.DataFrame, predict_column: string,
-  gamma: number, c: number, d: number, toShowReport: boolean): Promise<any> {
+  gamma: number, c: number, d: number): Promise<any> {
   const trainedModel = await getTrainedModel(
     {gamma: gamma, kernel: POLYNOMIAL, cParam: c, dParam: d},
     df, predict_column);
 
-  if (toShowReport)
-    showTrainReport(df, trainedModel);
-
   return getPackedModel(trainedModel);
 } // trainPolynomialKernelSVM
 
@@ -385,6 +453,28 @@ export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Pr
   return await getPrediction(df, model);
 }
 
+//name: isApplicablePolynomialKernelSVM
+//meta.mlname: polynomial kernel LS-SVM
+//meta.mlrole: isApplicable
+//input: dataframe df
+//input: string predict_column
+//output: bool result
+export async function isApplicablePolynomialKernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
+  return isApplicableSVM(df, predict_column);
+}
+
+//name: visualizePolynomialKernelSVM
+//meta.mlname: polynomial kernel LS-SVM
+//meta.mlrole: visualize
+//input: dataframe df
+//input: string target_column
+//input: string predict_column
+//input: dynamic model
+//output: dynamic widget
+export async function visualizePolynomialKernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+  return showTrainReport(df, model);
+}
+
 //name: trainSigmoidKernelSVM
 //meta.mlname: sigmoid kernel LS-SVM
 //meta.mlrole: train
@@ -393,17 +483,13 @@ export async function applyPolynomialKernelSVM(df: DG.DataFrame, model: any): Pr
 //input: double gamma = 1.0 {category: Hyperparameters}
 //input: double kappa = 1 {category: Hyperparameters}
 //input: double theta = 1 {category: Hyperparameters}
-//input: bool toShowReport = false {caption: to show report; category: Report}
 //output: dynamic model
 export async function trainSigmoidKernelSVM(df: DG.DataFrame, predict_column: string,
-  gamma: number, kappa: number, theta: number, toShowReport: boolean): Promise<any> {
+  gamma: number, kappa: number, theta: number): Promise<any> {
   const trainedModel = await getTrainedModel(
     {gamma: gamma, kernel: SIGMOID, kappa: kappa, theta: theta},
     df, predict_column);
 
-  if (toShowReport)
-    showTrainReport(df, trainedModel);
-
   return getPackedModel(trainedModel);
 } // trainSigmoidKernelSVM
 
@@ -417,6 +503,28 @@ export async function applySigmoidKernelSVM(df: DG.DataFrame, model: any): Promi
   return await getPrediction(df, model);
 }
 
+//name: isApplicableSigmoidKernelSVM
+//meta.mlname: sigmoid kernel LS-SVM
+//meta.mlrole: isApplicable
+//input: dataframe df
+//input: string predict_column
+//output: bool result
+export async function isApplicableSigmoidKernelSVM(df: DG.DataFrame, predict_column: string): Promise<boolean> {
+  return isApplicableSVM(df, predict_column);
+}
+
+//name: visualizeSigmoidKernelSVM
+//meta.mlname: sigmoid kernel LS-SVM
+//meta.mlrole: visualize
+//input: dataframe df
+//input: string target_column
+//input: string predict_column
+//input: dynamic model
+//output: dynamic widget
+export async function visualizeSigmoidKernelSVM(df: DG.DataFrame, target_column: string, predict_column: string, model: any): Promise<any> {
+  return showTrainReport(df, model);
+}
+
 //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 studied feature.
@@ -436,3 +544,87 @@ export function anova(table: DG.DataFrame, factor: DG.Column, feature: DG.Column
 export function kNNImputation() {
   runKNNImputer();
 }
+
+//name: linearRegression
+//description: Linear Regression demo
+//input: dataframe table
+//input: column_list features {type: numerical}
+//input: column target {type: numerical}
+//input: bool plot = true {caption: plot}
+export async function linearRegression(table: DG.DataFrame, features: DG.ColumnList, target: DG.Column, plot: boolean): Promise<void> {
+  const t1 = performance.now();
+  const params = await getLinearRegressionParams(features, target);
+  const t2 = performance.now();
+  console.log(`Fit: ${t2 - t1} ms.`);
+  const prediction = getPredictionByLinearRegression(features, params);
+  console.log(`Predict: ${performance.now() - t2} ms.`);
+
+  prediction.name = table.columns.getUnusedName(prediction.name);
+
+  table.columns.add(prediction);
+
+  if (plot) {
+    const view = grok.shell.tableView(table.name);
+    view.addViewer(DG.VIEWER.SCATTER_PLOT, {
+      xColumnName: target.name,
+      yColumnName: prediction.name,
+      showRegressionLine: true,
+    });
+  }
+}
+
+//name: generateDatasetForLinearRegressionTest
+//description: Create demo dataset for linear regression
+//input: int rowCount = 10000 {min: 1000; max: 10000000; step: 10000}
+//input: int colCount = 10 {min: 1; max: 1000; step: 10}
+//input: double featuresScale = 10 {min: -1000; max: 1000; step: 10}
+//input: double featuresBias = 10 {min: -1000; max: 1000; step: 10}
+//input: double paramsScale = 10 {min: -1000; max: 1000; step: 10}
+//input: double paramsBias = 10 {min: -1000; max: 1000; step: 10}
+//output: dataframe table
+export function generateDatasetForLinearRegressionTest(rowCount: number, colCount: number,
+  featuresScale: number, featuresBias: number, paramsScale: number, paramsBias: number): DG.DataFrame {
+  return getTestDatasetForLinearRegression(rowCount, colCount, featuresScale, featuresBias, paramsScale, paramsBias);
+}
+
+//name: trainLinearRegression
+//meta.mlname: Linear Regression
+//meta.mlrole: train
+//input: dataframe df
+//input: string predict_column
+//output: dynamic model
+export async function trainLinearRegression(df: DG.DataFrame, predict_column: string): Promise<Uint8Array> {
+  const features = df.columns;
+  const target = features.byName(predict_column);
+  features.remove(predict_column);
+
+  const params = await getLinearRegressionParams(features, target);
+
+  return new Uint8Array(params.buffer);
+}
+
+//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: string predict_column
+//output: bool result
+export function isApplicableLinearRegression(df: DG.DataFrame, predict_column: string): 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))
+      return false;
+  }
+  return true;
+}