@datagrok/eda 1.1.25 → 1.1.28

package/wasm/regression-api.cpp

@@ -0,0 +1,66 @@
+#include "regression.h"
+
+#include <emscripten.h>
+
+// The following provides convenient naming of the exported functions.
+extern "C" {
+	int fitLinearRegressionParamsWithDataNormalizing(
+	  float * features, int featuresRowCount, int featuresColCount,
+	  float * featureAvgs, int featureAvgsCount,
+	  float * featureStdDevs, int featureStdDevsCount,
+	  float * targets, int targetsCount,
+	  float targetsAvg,
+	  float targetsStdDev,
+	  int paramsCount,
+	  float * params, int paramsLength) noexcept;
+
+	int fitLinearRegressionParams(
+	  float * features, int featuresRowCount, int featuresColCount,
+	  float * targets, int targetsCount,
+	  int paramsCount,
+	  float * params, int paramsLength) noexcept;
+}
+
+//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 [new(paramsCount)]
+EMSCRIPTEN_KEEPALIVE
+int fitLinearRegressionParamsWithDataNormalizing(
+	float * features, int featuresRowCount, int featuresColCount,
+	float * featureAvgs, int featureAvgsCount,
+	float * featureStdDevs, int featureStdDevsCount,
+	float * targets, int targetsCount,
+	float targetsAvg,
+	float targetsStdDev,
+	int paramsCount,
+	float * params, int paramsLength) noexcept {
+	// Check sizes
+	if ((featuresRowCount != targetsCount) || (featuresColCount != paramsLength - 1))
+		return regr::INCORRECT_SIZES;
+
+	return regr::fitLinearRegressionParams(features, featureAvgs, featureStdDevs, targets, targetsAvg, targetsStdDev, params, targetsCount, featuresColCount);
+}
+
+//name: fitLinearRegressionParams
+//input: column_list features
+//input: column targets
+//input: int paramsCount
+//output: column params [new(paramsCount)]
+EMSCRIPTEN_KEEPALIVE
+int fitLinearRegressionParams(
+	float * features, int featuresRowCount, int featuresColCount,
+	float * targets, int targetsCount,
+	int paramsCount,
+	float * params, int paramsLength) noexcept {
+	// Check sizes
+	if ((featuresRowCount != targetsCount) || (featuresColCount != paramsLength - 1))
+		return regr::INCORRECT_SIZES;
+
+	return regr::fitLinearRegressionParams(features, targets, params, targetsCount, featuresColCount);
+}

package/wasm/regression.h

@@ -0,0 +1,128 @@
+// regression.h
+
+/* Linear regression coefficients computation.
+   
+   Implemented 2 approaches: with & without data normalizing.
+   Data normalizing provides better results in te case of big data. */
+
+#include "../../../../Eigen/Eigen/Dense"
+using namespace Eigen;
+
+#ifndef REGRESSION_H
+#define REGRESSION_H
+
+namespace regr {
+
+	// computation result code
+	enum ResultCode {
+		NO_ERRORS = 0,
+		UNKNOWN_PROBLEM,
+		INCORRECT_SIZES,
+		DATA_WITH_ZERO_VARIATION
+	};
+
+	/* Compute coeffcicients of linear regression.
+	    features - features data pointer, X (column-by-column)
+		featureAvgs - mean values of feature columns
+		featureStdDevs - standard deviations of feature columns
+		targets - target values, Y
+		targetsAvg - target mean value
+		targetsStdDev - target standard deviation
+		params - parameters to be computed
+		samplesCount - number of samples
+		featuresCount - number of features
+
+	  REMARK. Data normalization is applied. */
+	template<typename Float>
+	int fitLinearRegressionParams(
+		Float* features, 
+		Float* featureAvgs,
+		Float* featureStdDevs,
+		Float* targets,
+		Float targetsAvg,
+		Float targetsStdDev,
+		Float* params, 
+		int samplesCount, 
+		int featuresCount) noexcept 
+	{
+		// Associate matrices with pointers
+		Map<Vector<Float, Dynamic>> beta(params, featuresCount);
+		
+		Map<Vector<Float, Dynamic>> y(targets, samplesCount);
+		Vector<Float, 1> avgY;
+		avgY(0) = targetsAvg;
+
+		Map<Matrix<Float, Dynamic, Dynamic, RowMajor>> X(features, featuresCount, samplesCount);
+		Map<Vector<Float, Dynamic>> avgX(featureAvgs, featuresCount);
+		Map<Vector<Float, Dynamic>> stdDevX(featureStdDevs, featuresCount);
+
+		// Normalize data
+		y = (y.rowwise() - avgY) / targetsStdDev;
+
+		X = X.colwise() - avgX;
+		for (int i = 0; i < featuresCount; ++i)
+			X.row(i) = X.row(i) / stdDevX(i);
+				
+		// Compute linear regression coefs
+		auto buf = X * y;
+
+		// Here, other Eigen decompositions can be used
+		beta = (X * X.transpose()).ldlt().solve(buf);		
+
+		// Rescale coefs, since data was normalized
+		Float sum = 0;
+		for (int i = 0; i < featuresCount; ++i) {
+			params[i] *= targetsStdDev / featureStdDevs[i];
+			sum += params[i] * featureAvgs[i];
+		}
+
+		params[featuresCount] = targetsAvg - sum;
+
+		return NO_ERRORS;
+	}
+
+	/* Compute coeffcicients of linear regression.
+		features - features data pointer, X (column-by-column)
+		targets - target values, Y
+		params - parameters to be computed
+		samplesCount - number of samples
+		featuresCount - number of features */
+	template<typename Float>
+	int fitLinearRegressionParams(
+		Float* features,
+		Float* targets,
+		Float* params,
+		int samplesCount,
+		int featuresCount) noexcept
+	{
+		// Associate matrices with pointers
+		Map<Vector<Float, Dynamic>> beta(params, featuresCount + 1);
+		Map<Vector<Float, Dynamic>> y(targets, samplesCount);
+		
+		// Data matrix: D = [X | 1] (transposed)
+		Matrix<Float, Dynamic, Dynamic, RowMajor> X(featuresCount + 1, samplesCount);
+		auto ptr = X.data();
+
+        // Fill D with feature values 
+		size_t size = sizeof(Float) * featuresCount * samplesCount;
+		std::memcpy(ptr, features, size);
+
+		ptr += featuresCount * samplesCount;
+
+		// Add row of 1-s
+		for (int i = 0; i < samplesCount; ++i)
+			ptr[i] = 1;
+
+		// Compute linear regression coefs
+		auto buf = X * y;
+
+		// Here, other Eigen decompositions can be used
+		beta = (X * X.transpose()).colPivHouseholderQr().solve(buf);
+						
+		return NO_ERRORS;
+	}
+
+}; // regr
+
+#endif // !REGRESSION_H
+

package/wasm/workers/fitLinearRegressionParamsWithDataNormalizingWorker.js

@@ -0,0 +1,13 @@
+// The following code is generated automatically.
+
+import {exportEDA} from '../../wasm/EDAForWebWorker';
+import {cppWrapper} from '../../wasm/callWasmForWebWorker.js';
+
+onmessage = async function (evt) {
+  exportEDA().then(module => 
+    {
+      let args = evt.data;
+      let result = cppWrapper(module, args, 'fitLinearRegressionParamsWithDataNormalizing', 'number');
+      postMessage({'callResult': result, 'args': args});
+    } )
+}

package/wasm/workers/fitLinearRegressionParamsWorker.js

@@ -0,0 +1,13 @@
+// The following code is generated automatically.
+
+import {exportEDA} from '../../wasm/EDAForWebWorker';
+import {cppWrapper} from '../../wasm/callWasmForWebWorker.js';
+
+onmessage = async function (evt) {
+  exportEDA().then(module => 
+    {
+      let args = evt.data;
+      let result = cppWrapper(module, args, 'fitLinearRegressionParams', 'number');
+      postMessage({'callResult': result, 'args': args});
+    } )
+}

package/webpack.config.js

@@ -23,7 +23,7 @@ module.exports = {
       },
     ],
   },
-  devtool: 'inline-source-map',
+  devtool: 'source-map',
   externals: {
     'datagrok-api/dg': 'DG',
     'datagrok-api/grok': 'grok',

package/dist/208.js

@@ -1,2 +0,0 @@
-var eda;(()=>{"use strict";var e,r,t={1208:(e,r,t)=>{var o=t(6845),a=t(2086);onmessage=async function(e){(0,o.P)().then((r=>{let t=e.data,o=(0,a.Gz)(r,t,"normalizeDataset","number");postMessage({callResult:o,args:t})}))}}},o={};function a(e){var r=o[e];if(void 0!==r)return r.exports;var n=o[e]={id:e,loaded:!1,exports:{}};return t[e](n,n.exports,a),n.loaded=!0,n.exports}a.m=t,a.x=()=>{var e=a.O(void 0,[902],(()=>a(1208)));return a.O(e)},a.amdO={},e=[],a.O=(r,t,o,n)=>{if(!t){var i=1/0;for(p=0;p<e.length;p++){for(var[t,o,n]=e[p],s=!0,c=0;c<t.length;c++)(!1&n||i>=n)&&Object.keys(a.O).every((e=>a.O[e](t[c])))?t.splice(c--,1):(s=!1,n<i&&(i=n));if(s){e.splice(p--,1);var l=o();void 0!==l&&(r=l)}}return r}n=n||0;for(var p=e.length;p>0&&e[p-1][2]>n;p--)e[p]=e[p-1];e[p]=[t,o,n]},a.d=(e,r)=>{for(var t in r)a.o(r,t)&&!a.o(e,t)&&Object.defineProperty(e,t,{enumerable:!0,get:r[t]})},a.f={},a.e=e=>Promise.all(Object.keys(a.f).reduce(((r,t)=>(a.f[t](e,r),r)),[])),a.u=e=>e+".js",a.g=function(){if("object"==typeof globalThis)return globalThis;try{return this||new Function("return this")()}catch(e){if("object"==typeof window)return window}}(),a.hmd=e=>((e=Object.create(e)).children||(e.children=[]),Object.defineProperty(e,"exports",{enumerable:!0,set:()=>{throw new Error("ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: "+e.id)}}),e),a.o=(e,r)=>Object.prototype.hasOwnProperty.call(e,r),(()=>{var e;a.g.importScripts&&(e=a.g.location+"");var r=a.g.document;if(!e&&r&&(r.currentScript&&(e=r.currentScript.src),!e)){var t=r.getElementsByTagName("script");if(t.length)for(var o=t.length-1;o>-1&&!e;)e=t[o--].src}if(!e)throw new Error("Automatic publicPath is not supported in this browser");e=e.replace(/#.*$/,"").replace(/\?.*$/,"").replace(/\/[^\/]+$/,"/"),a.p=e})(),(()=>{a.b=self.location+"";var e={208:1};a.f.i=(r,t)=>{e[r]||importScripts(a.p+a.u(r))};var r=self.webpackChunkeda=self.webpackChunkeda||[],t=r.push.bind(r);r.push=r=>{var[o,n,i]=r;for(var s in n)a.o(n,s)&&(a.m[s]=n[s]);for(i&&i(a);o.length;)e[o.pop()]=1;t(r)}})(),r=a.x,a.x=()=>a.e(902).then(r);var n=a.x();eda=n})();
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"208.js","mappings":"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","sources":["webpack://eda/webpack/runtime/chunk loaded","webpack://eda/webpack/runtime/startup chunk dependencies","webpack://eda/./wasm/workers/normalizeDatasetWorker.js","webpack://eda/webpack/bootstrap","webpack://eda/webpack/runtime/amd options","webpack://eda/webpack/runtime/define property getters","webpack://eda/webpack/runtime/ensure chunk","webpack://eda/webpack/runtime/get javascript chunk filename","webpack://eda/webpack/runtime/global","webpack://eda/webpack/runtime/harmony module decorator","webpack://eda/webpack/runtime/hasOwnProperty shorthand","webpack://eda/webpack/runtime/publicPath","webpack://eda/webpack/runtime/importScripts chunk loading","webpack://eda/webpack/startup"],"sourcesContent":["var deferred = [];\n__webpack_require__.O = (result, chunkIds, fn, priority) => {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar [chunkIds, fn, priority] = deferred[i];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","var next = __webpack_require__.x;\n__webpack_require__.x = () => {\n\treturn __webpack_require__.e(902).then(next);\n};","// The following code is generated automatically.\n\nimport {exportEDA} from '../../wasm/EDAForWebWorker';\nimport {cppWrapper} from '../../wasm/callWasmForWebWorker.js';\n\nonmessage = async function (evt) {\n  exportEDA().then(module => \n    {\n      let args = evt.data;\n      let result = cppWrapper(module, args, 'normalizeDataset', 'number');\n      postMessage({'callResult': result, 'args': args});\n    } )\n}","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n// the startup function\n__webpack_require__.x = () => {\n\t// Load entry module and return exports\n\t// This entry module depends on other loaded chunks and execution need to be delayed\n\tvar __webpack_exports__ = __webpack_require__.O(undefined, [902], () => (__webpack_require__(1208)))\n\t__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n\treturn __webpack_exports__;\n};\n\n","__webpack_require__.amdO = {};","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = (chunkId) => {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks and sibling chunks for the entrypoint\n__webpack_require__.u = (chunkId) => {\n\t// return url for filenames based on template\n\treturn \"\" + chunkId + \".js\";\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.hmd = (module) => {\n\tmodule = Object.create(module);\n\tif (!module.children) module.children = [];\n\tObject.defineProperty(module, 'exports', {\n\t\tenumerable: true,\n\t\tset: () => {\n\t\t\tthrow new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);\n\t\t}\n\t});\n\treturn module;\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","var scriptUrl;\nif (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + \"\";\nvar document = __webpack_require__.g.document;\nif (!scriptUrl && document) {\n\tif (document.currentScript)\n\t\tscriptUrl = document.currentScript.src;\n\tif (!scriptUrl) {\n\t\tvar scripts = document.getElementsByTagName(\"script\");\n\t\tif(scripts.length) {\n\t\t\tvar i = scripts.length - 1;\n\t\t\twhile (i > -1 && !scriptUrl) scriptUrl = scripts[i--].src;\n\t\t}\n\t}\n}\n// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration\n// or pass an empty string (\"\") and set the __webpack_public_path__ variable from your code to use your own logic.\nif (!scriptUrl) throw new Error(\"Automatic publicPath is not supported in this browser\");\nscriptUrl = scriptUrl.replace(/#.*$/, \"\").replace(/\\?.*$/, \"\").replace(/\\/[^\\/]+$/, \"/\");\n__webpack_require__.p = scriptUrl;","__webpack_require__.b = self.location + \"\";\n\n// object to store loaded chunks\n// \"1\" means \"already loaded\"\nvar installedChunks = {\n\t208: 1\n};\n\n// importScripts chunk loading\nvar installChunk = (data) => {\n\tvar [chunkIds, moreModules, runtime] = data;\n\tfor(var moduleId in moreModules) {\n\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t}\n\t}\n\tif(runtime) runtime(__webpack_require__);\n\twhile(chunkIds.length)\n\t\tinstalledChunks[chunkIds.pop()] = 1;\n\tparentChunkLoadingFunction(data);\n};\n__webpack_require__.f.i = (chunkId, promises) => {\n\t// \"1\" is the signal for \"already loaded\"\n\tif(!installedChunks[chunkId]) {\n\t\tif(true) { // all chunks have JS\n\t\t\timportScripts(__webpack_require__.p + __webpack_require__.u(chunkId));\n\t\t}\n\t}\n};\n\nvar chunkLoadingGlobal = self[\"webpackChunkeda\"] = self[\"webpackChunkeda\"] || [];\nvar parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);\nchunkLoadingGlobal.push = installChunk;\n\n// no HMR\n\n// no HMR manifest","// run startup\nvar __webpack_exports__ = __webpack_require__.x();\n"],"names":["deferred","next","onmessage","async","evt","then","module","args","data","result","postMessage","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","undefined","exports","id","loaded","__webpack_modules__","m","x","__webpack_exports__","O","amdO","chunkIds","fn","priority","notFulfilled","Infinity","i","length","fulfilled","j","Object","keys","every","key","splice","r","d","definition","o","defineProperty","enumerable","get","f","e","chunkId","Promise","all","reduce","promises","u","g","globalThis","this","Function","window","hmd","create","children","set","Error","obj","prop","prototype","hasOwnProperty","call","scriptUrl","importScripts","location","document","currentScript","src","scripts","getElementsByTagName","replace","p","b","self","installedChunks","chunkLoadingGlobal","parentChunkLoadingFunction","push","bind","moreModules","runtime","pop"],"sourceRoot":""}