@datagrok/eda 1.2.1 → 1.2.3

package/src/package-test.ts

@@ -1,9 +1,10 @@
 import * as DG from 'datagrok-api/dg';
-import {runTests, tests, TestContext} from '@datagrok-libraries/utils/src/test';
+import {runTests, tests, TestContext, initAutoTests as initTests} from '@datagrok-libraries/utils/src/test';
 import './tests/dim-reduction-tests';
 import './tests/linear-methods-tests';
 import './tests/classifiers-tests';
 import './tests/mis-vals-imputation-tests';
+import './tests/anova-tests';
 export const _package = new DG.Package();
 export {tests};
 
@@ -16,3 +17,8 @@ export async function test(category: string, test: string, testContext: TestCont
   const data = await runTests({category, test, testContext});
   return DG.DataFrame.fromObjects(data)!;
 }
+
+//name: initAutoTests
+export async function initAutoTests() {
+  await initTests(_package, _package.getModule('package-test.js'));
+}

package/src/package.ts

@@ -7,14 +7,14 @@ import * as DG from 'datagrok-api/dg';
 
 import {_initEDAAPI} from '../wasm/EDAAPI';
 import {computePCA} from './eda-tools';
-import {addPrefixToEachColumnName, addOneWayAnovaVizualization} from './eda-ui';
+import {addPrefixToEachColumnName} from './eda-ui';
 import {LINEAR, RBF, POLYNOMIAL, SIGMOID,
   getTrainedModel, getPrediction, isApplicableSVM, isInteractiveSVM, showTrainReport, getPackedModel} from './svm';
 
 import {PLS_ANALYSIS} from './pls/pls-constants';
 import {runMVA, runDemoMVA, getPlsAnalysis, PlsOutput} from './pls/pls-tools';
+import {runOneWayAnova} from './anova/anova-ui';
 
-import {oneWayAnova} from './stat-tools';
 import {getDbscanWorker} from '@datagrok-libraries/math';
 
 import {DistanceAggregationMethod, DistanceAggregationMethods} from '@datagrok-libraries/ml/src/distance-matrix/types';
@@ -304,7 +304,7 @@ export async function MVA(): Promise<void> {
 
 //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
+//meta.demoPath: Compute | Multivariate Analysis
 export async function demoMultivariateAnalysis(): Promise<any> {
   await runDemoMVA();
 }
@@ -547,15 +547,9 @@ export async function visualizeSigmoidKernelSVM(df: DG.DataFrame, targetColumn:
 
 //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.
-//input: dataframe table
-//input: column factor {type: categorical}
-//input: column feature {type: numerical}
-//input: double significance = 0.05 [The significance level is a value from the interval (0, 1) specifying the criterion used for rejecting the null hypothesis.]
-//input: bool validate = false [Indicates whether the normality of distribution and an eqaulity of varainces should be checked.]
-export function anova(table: DG.DataFrame, factor: DG.Column, feature: DG.Column, significance: number, validate: boolean) {
-  const res = oneWayAnova(factor, feature, significance, validate);
-  addOneWayAnovaVizualization(table, factor, feature, res);
+//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();
 }
 
 //top-menu: ML | Missing Values Imputation ...

package/src/tests/anova-tests.ts

@@ -0,0 +1,87 @@
+// Tests for ANOVA
+
+import * as grok from 'datagrok-api/grok';
+import * as ui from 'datagrok-api/ui';
+import * as DG from 'datagrok-api/dg';
+import {_package} from '../package-test';
+
+import {category, expect, test} from '@datagrok-libraries/utils/src/test';
+
+import {oneWayAnova, FactorizedData} from '../anova/anova-tools';
+
+const ROWS_M = 1;
+const M = 1000000;
+const TIMEOUT = 4000;
+const ALPHA = 0.05;
+const CATEGORIES = 'race';
+const FEATURES = 'height';
+const TO_VALIDATE = false;
+const ERR = 0.01;
+
+/** Validation features*/
+const FEATURES_COL = DG.Column.fromList(DG.COLUMN_TYPE.INT, 'features', [
+  9, 12, 4, 8, 7, 4, 6, 8, 2, 10, 1, 3, 4, 5, 2,
+]);
+
+/** Validation categories */
+const CATEGORIES_COL = DG.Column.fromStrings('features', [
+  'A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'B', 'B', 'C', 'C', 'C', 'C', 'C',
+]);
+
+/** Expected ANOVA results for the validation data */
+enum EXPECTED {
+  DF_BN = 2,
+  DF_TOT = 14,
+  DF_WN = 12,
+  SS_BN = 63.333,
+  SS_TOT = 147.333,
+  SS_WN = 84,
+  MS_BN = 31.666,
+  MS_WN = 7,
+  F_STAT = 4.523,
+  F_CRIT = 3.885,
+  P_VAL = 0.034,
+};
+
+category('ANOVA', () => {
+  test(`Performance: ${ROWS_M}M rows demog`, async () => {
+    const df = grok.data.demo.demog(ROWS_M * M);
+    const categories = df.col(CATEGORIES);
+    const features = df.col(FEATURES);
+
+    const factorized = new FactorizedData(categories!, features!, categories!.stats.uniqueCount);
+    factorized.areVarsEqual(ALPHA);
+
+    oneWayAnova(categories!, features!, ALPHA, TO_VALIDATE);
+  }, {timeout: TIMEOUT, benchmark: true});
+
+  test(`Correctness`, async () => {
+    const analysis = oneWayAnova(CATEGORIES_COL, FEATURES_COL, ALPHA, TO_VALIDATE);
+    const anova = analysis.anovaTable;
+
+    // check degrees of freedom (df-s)
+    expect(anova.dfBn, EXPECTED.DF_BN, 'Incorrect degrees of freedom: dfBn');
+    expect(anova.dfTot, EXPECTED.DF_TOT, 'Incorrect degrees of freedom: dfTot');
+    expect(anova.dfWn, EXPECTED.DF_WN, 'Incorrect degrees of freedom: dfWn');
+
+    const eq = (x: number, y: number) => Math.abs(x - y) < ERR;
+
+    // check sum of squares (ss-s)
+    expect(eq(anova.ssBn, EXPECTED.SS_BN), true, 'Incorrect sum of squares: ssBn');
+    expect(eq(anova.ssTot, EXPECTED.SS_TOT), true, 'Incorrect sum of squares: ssTot');
+    expect(eq(anova.ssWn, EXPECTED.SS_WN), true, 'Incorrect sum of squares: ssWn');
+
+    // check mean squares (ms-s)
+    expect(eq(anova.msBn, EXPECTED.MS_BN), true, 'Incorrect mean squares: msBn');
+    expect(eq(anova.msWn, EXPECTED.MS_WN), true, 'Incorrect mean squares: msWn');
+
+    // check F-statistics
+    expect(eq(anova.fStat, EXPECTED.F_STAT), true, 'Incorrect F-statistics value');
+
+    // check p-value
+    expect(eq(anova.pValue, EXPECTED.P_VAL), true, 'Incorrect p-value');
+
+    // check F-critical
+    expect(eq(analysis.fCritical, EXPECTED.F_CRIT), true, 'Incorrect F-critical');
+  }, {timeout: TIMEOUT, benchmark: true});
+});

package/src/tests/linear-methods-tests.ts

@@ -16,7 +16,7 @@ const ROWS = 100;
 const ROWS_K = 100;
 const COLS = 100;
 const COMPONENTS = 3;
-const TIMEOUT = 4000;
+const TIMEOUT = 8000;
 const INDEP_COLS = 2;
 const DEP_COLS = 5;
 const ERROR = 0.1;