@datagrok/eda 1.4.4 → 1.4.6

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@datagrok/eda",
   "friendlyName": "EDA",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "Exploratory Data Analysis Tools",
   "dependencies": {
     "@datagrok-libraries/math": "^1.2.6",
@@ -26,7 +26,7 @@
     "@typescript-eslint/eslint-plugin": "^5.32.0",
     "@typescript-eslint/parser": "^5.32.0",
     "css-loader": "^7.1.2",
-    "datagrok-tools": "^4.14.48",
+    "datagrok-tools": "^4.14.55",
     "eslint": "^8.21.0",
     "eslint-config-google": "^0.14.0",
     "style-loader": "^4.0.0",

package/src/anova/anova-ui.ts

@@ -27,31 +27,36 @@ enum DEFAULT {
 };
 
 /** Add one-way ANOVA results */
-function addVizualization(df: DG.DataFrame, factorsName: string, featuresName: string, report: OneWayAnovaReport) {
+function addVizualization(df: DG.DataFrame, factorsName: string, featuresName: string, report: OneWayAnovaReport): void {
+  const view = grok.shell.getTableView(df.name);
+  grok.shell.v = view;
+  
   const test = report.anovaTable.fStat > report.fCritical;
-
   const shortConclusion = test ?
     `"${factorsName}" affects the "${featuresName}"` :
     `"${factorsName}" doesn't affect the "${featuresName}"`;
 
-  const view = grok.shell.getTableView(df.name);
-  const boxPlot = DG.Viewer.boxPlot(df, {
+  const chart = DG.Viewer.boxPlot(df, {
     categoryColumnNames: [factorsName],
     valueColumnName: featuresName,
     showPValue: false,
     showStatistics: false,
     description: shortConclusion,
     showColorSelector: false,
+    autoLayout: false,
   });
-  const boxPlotNode = view.dockManager.dock(boxPlot.root, DG.DOCK_TYPE.RIGHT, null, 'ANOVA');
 
-  const hypoMd = ui.markdown(`**H0:** the "${factorsName}" 
-  factor does not produce a significant difference in the "${featuresName}" feature.`);
-  ui.tooltip.bind(hypoMd, 'Null hypothesis');
+  let node = view.dockManager.dock(chart, DG.DOCK_TYPE.RIGHT, null, 'ANOVA');
 
-  const testMd = ui.markdown(`**Test result:** ${test ?
-    'means differ significantly.' :
-    'means do not differ significantly.'}`,
+  const nullHypoMd = ui.markdown(`**Null Hypothesis:** all group means are equal.`);  
+  ui.tooltip.bind(nullHypoMd, `The "${factorsName}" factor does not produce a significant difference in the "${featuresName}" feature.`);
+
+  const altHypoMd = ui.markdown(`**Alternative Hypothesis:** at least one group mean differs significantly.`);
+  ui.tooltip.bind(altHypoMd, `The "${factorsName}" factor produces a significant difference in the "${featuresName}" feature.`);
+
+  const testMd = ui.markdown(`**Conclusion:** ${test ?
+    'significant differences exist between groups.' :
+    'no significant differences detected.'}`,
   );
 
   const tooltipDiv = test ?
@@ -69,20 +74,30 @@ function addVizualization(df: DG.DataFrame, factorsName: string, featuresName: s
   ui.tooltip.bind(testMd, () => tooltipDiv);
 
   const divResult = ui.divV([
-    hypoMd,
+    nullHypoMd,
+    altHypoMd,
     testMd,
     ui.link('Learn more',
       () => window.open('https://en.wikipedia.org/wiki/F-test', '_blank'),
-      'Click to open in a new tab',
+      'Click to open in a new tab.',
     ),
   ]);
   divResult.style.marginLeft = '20px';
 
-  const hypoNode = grok.shell.dockManager.dock(divResult, DG.DOCK_TYPE.DOWN, boxPlotNode, 'F-test', 0.3);
+  const reportViewer = getAnovaGrid(report);  
+  const tabControl = ui.tabControl({    
+    'Analysis': ui.panel([reportViewer.root]),
+    'F-test': ui.panel([divResult]),
+  });
 
-  const reportViewer = getAnovaGrid(report);
-  grok.shell.dockManager.dock(reportViewer.root, DG.DOCK_TYPE.FILL, hypoNode, 'Analysis');
-}
+  ui.tooltip.bind(tabControl.getPane('Analysis').header, 'ANOVA results summary.');
+  ui.tooltip.bind(tabControl.getPane('F-test').header, 'Null hypothesis testing.');
+
+
+  view.dockManager.dock(tabControl.root, DG.DOCK_TYPE.DOWN, node, '', 0.25);
+
+  reportViewer.root.style.width = '100%';
+} // addVizualization
 
 /** Create dataframe with one-way ANOVA results. */
 function getAnovaGrid(report: OneWayAnovaReport): DG.Grid {
@@ -99,13 +114,13 @@ function getAnovaGrid(report: OneWayAnovaReport): DG.Grid {
   ]));
 
   const tooltip = new Map([
-    ['Source of variance', 'List of the explored variation sources'],
-    ['SS', 'Sum of squares (SS)'],
-    ['DF', 'Degrees of freedom (DF)'],
-    ['MS', 'Mean square (MS)'],
-    ['F', 'F-statistics (F)'],
-    ['F-critical', `${report.significance}-critical value of F-statistics (F)`],
-    ['p-value', `Probability to obtain F-statistics (F) greater than the actual observation.`],
+    ['Source of variance', 'List of the explored variation sources.'],
+    ['SS', 'Sum of squares (SS). Measure of total variation in the data.'],
+    ['DF', 'Degrees of freedom (DF). Number of independent values that can vary.'],
+    ['MS', 'Mean square (MS). Sum of squares divided by degrees of freedom.'],
+    ['F', 'F-statistics (F). Ratio of between-group to within-group variance.'],
+    ['F-critical', `${report.significance}-critical value of F-statistics.`],
+    ['p-value', `Probability of observing this result if groups have equal means.`],
   ]);
 
   grid.onCellTooltip(function(cell, x, y) {

package/src/package-api.ts

@@ -8,6 +8,10 @@ import * as DG from 'datagrok-api/dg';
 
 
 export namespace funcs {
+  export async function info(): Promise<void> {
+    return await grok.functions.call('EDA:Info', {});
+  }
+
   export async function init(): Promise<void> {
     return await grok.functions.call('EDA:Init', {});
   }

package/src/package.g.ts

@@ -1,6 +1,7 @@
 import {PackageFunctions} from './package';
 import * as DG from 'datagrok-api/dg';
 
+//name: info
 export function info() : void {
   PackageFunctions.info();
 }
@@ -15,8 +16,8 @@ export async function init() : Promise<void> {
 //input: dataframe df 
 //input: column xCol { type: numerical }
 //input: column yCol { type: numerical }
-//input: double epsilon { caption: Epsilon; default: 0.02; description: The maximum distance between two samples for them to be considered as in the same neighborhood. }
-//input: int minPts { caption: Minimum points; default: 4; description: The number of samples (or total weight) in a neighborhood for a point to be considered as a core point. }
+//input: double epsilon = 0.02 { caption: Epsilon; description: The maximum distance between two samples for them to be considered as in the same neighborhood. }
+//input: int minPts = 4 { caption: Minimum points; description: The number of samples (or total weight) in a neighborhood for a point to be considered as a core point. }
 //output: column result
 //top-menu: ML | Cluster | DBSCAN...
 export async function dbScan(df: DG.DataFrame, xCol: DG.Column, yCol: DG.Column, epsilon: number, minPts: number) : Promise<any> {
@@ -26,9 +27,9 @@ export async function dbScan(df: DG.DataFrame, xCol: DG.Column, yCol: DG.Column,
 //description: Principal component analysis (PCA)
 //input: dataframe table { caption: Table }
 //input: column_list features { type: numerical; nullable: false }
-//input: int components { showPlusMinus: true; caption: Components; nullable: false; min: 1; default: 2; description: Number of components. }
-//input: bool center { caption: Center; default: false; description: Indicating whether the variables should be shifted to be zero centered. }
-//input: bool scale { caption: Scale; default: false; description: Indicating whether the variables should be scaled to have unit variance. }
+//input: int components = 2 { showPlusMinus: true; caption: Components; nullable: false; min: 1; description: Number of components. }
+//input: bool center = false { caption: Center; description: Indicating whether the variables should be shifted to be zero centered. }
+//input: bool scale = false { caption: Scale; description: Indicating whether the variables should be scaled to have unit variance. }
 //top-menu: ML | Analyze | PCA...
 //help-url: /help/explore/dim-reduction#pca
 export async function PCA(table: DG.DataFrame, features: DG.ColumnList, components: number, center: boolean, scale: boolean) : Promise<void> {
@@ -39,8 +40,8 @@ export async function PCA(table: DG.DataFrame, features: DG.ColumnList, componen
 //tags: dim-red-postprocessing-function
 //input: column col1 
 //input: column col2 
-//input: double epsilon { default: 0.01; description: Minimum distance between two points to be considered as in the same neighborhood. }
-//input: int minimumPoints { default: 5; description: Minimum number of points to form a dense region. }
+//input: double epsilon = 0.01 { description: Minimum distance between two points to be considered as in the same neighborhood. }
+//input: int minimumPoints = 5 { description: Minimum number of points to form a dense region. }
 //meta.defaultPostProcessingFunction: true
 export async function dbscanPostProcessingFunction(col1: DG.Column, col2: DG.Column, epsilon: number, minimumPoints: number) : Promise<void> {
   await PackageFunctions.dbscanPostProcessingFunction(col1, col2, epsilon, minimumPoints);
@@ -88,11 +89,11 @@ export function GetMCLEditor(call: DG.FuncCall) : void {
 //input: string aggregationMethod 
 //input: list<func> preprocessingFuncs 
 //input: object preprocessingFuncArgs 
-//input: int threshold { default: 80 }
-//input: int maxIterations { default: 10 }
-//input: bool useWebGPU { default: false }
-//input: double inflate { default: 2 }
-//input: int minClusterSize { default: 5 }
+//input: int threshold = 80 
+//input: int maxIterations = 10 
+//input: bool useWebGPU = false 
+//input: double inflate = 2 
+//input: int minClusterSize = 5 
 //top-menu: ML | Cluster | MCL...
 //editor: EDA:GetMCLEditor
 export async function MCLClustering(df: DG.DataFrame, cols: DG.Column[], metrics: any, weights: number[], aggregationMethod: any, preprocessingFuncs: any[], preprocessingFuncArgs: any[], threshold: number, maxIterations: number, useWebGPU: boolean, inflate: number, minClusterSize: number) : Promise<any> {
@@ -111,7 +112,7 @@ export function markovClusteringViewer() : any {
 //input: dataframe table 
 //input: column_list features { type: numerical }
 //input: column predict { type: numerical }
-//input: int components { default: 3 }
+//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<any> {
@@ -140,7 +141,7 @@ export async function demoMultivariateAnalysis() : Promise<void> {
 
 //input: dataframe df 
 //input: column predictColumn 
-//input: double gamma { category: Hyperparameters; default: 1.0 }
+//input: double gamma = 1.0 { category: Hyperparameters }
 //output: dynamic result
 //meta.mlname: linear kernel LS-SVM
 //meta.mlrole: train
@@ -188,8 +189,8 @@ export async function visualizeLinearKernelSVM(df: DG.DataFrame, targetColumn: D
 
 //input: dataframe df 
 //input: column predictColumn 
-//input: double gamma { category: Hyperparameters; default: 1.0 }
-//input: double sigma { category: Hyperparameters; default: 1.5 }
+//input: double gamma = 1.0 { category: Hyperparameters }
+//input: double sigma = 1.5 { category: Hyperparameters }
 //output: dynamic result
 //meta.mlname: RBF-kernel LS-SVM
 //meta.mlrole: train
@@ -237,9 +238,9 @@ export async function visualizeRBFkernelSVM(df: DG.DataFrame, targetColumn: DG.C
 
 //input: dataframe df 
 //input: column predictColumn 
-//input: double gamma { category: Hyperparameters; default: 1.0 }
-//input: double c { category: Hyperparameters; default: 1 }
-//input: double d { category: Hyperparameters; default: 2 }
+//input: double gamma = 1.0 { category: Hyperparameters }
+//input: double c = 1 { category: Hyperparameters }
+//input: double d = 2 { category: Hyperparameters }
 //output: dynamic result
 //meta.mlname: polynomial kernel LS-SVM
 //meta.mlrole: train
@@ -287,9 +288,9 @@ export async function visualizePolynomialKernelSVM(df: DG.DataFrame, targetColum
 
 //input: dataframe df 
 //input: column predictColumn 
-//input: double gamma { category: Hyperparameters; default: 1.0 }
-//input: double kappa { category: Hyperparameters; default: 1 }
-//input: double theta { category: Hyperparameters; default: 1 }
+//input: double gamma = 1.0 { category: Hyperparameters }
+//input: double kappa = 1 { category: Hyperparameters }
+//input: double theta = 1 { category: Hyperparameters }
 //output: dynamic result
 //meta.mlname: sigmoid kernel LS-SVM
 //meta.mlrole: train
@@ -394,10 +395,10 @@ export function isInteractiveLinearRegression(df: DG.DataFrame, predictColumn: D
 
 //input: dataframe df 
 //input: column predictColumn 
-//input: double rate { category: Hyperparameters; default: 1.0; min: 0.001; max: 20; description: Learning rate. }
-//input: double iterations { category: Hyperparameters; default: 100; min: 1; max: 10000; step: 10; description: Fitting iterations count }
-//input: double penalty { category: Hyperparameters; default: 0.1; min: 0.0001; max: 1; description: Regularization rate. }
-//input: double tolerance { category: Hyperparameters; default: 0.001; min: 0.00001; max: 0.1; description: Fitting tolerance. }
+//input: double rate = 1.0 { category: Hyperparameters; min: 0.001; max: 20; description: Learning rate. }
+//input: double iterations = 100 { category: Hyperparameters; min: 1; max: 10000; step: 10; description: Fitting iterations count }
+//input: double penalty = 0.1 { category: Hyperparameters; min: 0.0001; max: 1; description: Regularization rate. }
+//input: double tolerance = 0.001 { category: Hyperparameters; min: 0.00001; max: 0.1; description: Fitting tolerance. }
 //output: dynamic model
 //meta.mlname: Softmax
 //meta.mlrole: train
@@ -434,7 +435,7 @@ export function isInteractiveSoftmax(df: DG.DataFrame, predictColumn: DG.Column)
 
 //input: dataframe df 
 //input: column predictColumn 
-//input: int components { min: 1; max: 10; default: 3; description: Number of latent components. }
+//input: int components = 3 { min: 1; max: 10; description: Number of latent components. }
 //output: dynamic model
 //meta.mlname: PLS Regression
 //meta.mlrole: train
@@ -482,11 +483,11 @@ export function isInteractivePLSRegression(df: DG.DataFrame, predictColumn: DG.C
 
 //input: dataframe df 
 //input: column predictColumn 
-//input: int iterations { min: 1; max: 100; default: 20; description: Number of training iterations. }
-//input: double eta { caption: Rate; min: 0; max: 1; default: 0.3; description: Learning rate. }
-//input: int maxDepth { min: 0; max: 20; default: 6; description: Maximum depth of a tree. }
-//input: double lambda { min: 0; max: 100; default: 1; description: L2 regularization term. }
-//input: double alpha { min: 0; max: 100; default: 0; description: L1 regularization term. }
+//input: int iterations = 20 { min: 1; max: 100; description: Number of training iterations. }
+//input: double eta = 0.3 { caption: Rate; min: 0; max: 1; description: Learning rate. }
+//input: int maxDepth = 6 { min: 0; max: 20; description: Maximum depth of a tree. }
+//input: double lambda = 1 { min: 0; max: 100; description: L2 regularization term. }
+//input: double alpha = 0 { min: 0; max: 100; description: L1 regularization term. }
 //output: dynamic model
 //meta.mlname: XGBoost
 //meta.mlrole: train

package/src/package.ts

@@ -65,8 +65,8 @@ export class PackageFunctions {
   })
   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({type: 'column', 'options':{'type':'numerical'}})   xCol: DG.Column,
+    @grok.decorators.param({type: 'column', '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> {