Changeset 17779 for branches/3022-FastFunctionExtraction/FFX/BFUtils.cs

Timestamp:

10/29/20 15:24:40 (3 years ago)

Author:

gkronber

Message:

#3022: made a few changes while reviewing the code.

File:

• branches/3022-FastFunctionExtraction/FFX/BFUtils.cs (modified) (10 diffs)

branches/3022-FastFunctionExtraction/FFX/BFUtils.cs

@@ -14 +14 @@
         public static IEnumerable<IBasisFunction> CreateBasisFunctions(IRegressionProblemData data, Approach approach) {
             var exponents = approach.AllowExp ? approach.Exponents : new HashSet<double> { 1 };
-            var funcs = approach.AllowNonlinFuncs ? approach.NonlinFuncs : new HashSet<NonlinearOperator> { NonlinearOperator.None };
+            var funcs = approach.AllowNonLinearFunctions ? approach.NonLinearFunctions : new HashSet<NonlinearOperator> { NonlinearOperator.None };
             var simpleBasisFuncs = CreateSimpleBases(data, exponents, funcs);
 
@@ -20 +20 @@
                 // only allow hinge functions for features with exponent = 1 (deemed too complex otherwise)
                 var linearSimpleBasisFuncs = simpleBasisFuncs.Where(simpleBf => simpleBf.Exponent == 1 && simpleBf.Operator.Equals(NonlinearOperator.None));
-                simpleBasisFuncs = simpleBasisFuncs.Concat(CreateHingeBases(data, linearSimpleBasisFuncs, approach.MinHingeThr, approach.MaxHingeThr, approach.NumHingeThrs));
+                simpleBasisFuncs = simpleBasisFuncs.Concat(CreateHingeBases(data, linearSimpleBasisFuncs, approach.MinHingeThreshold, approach.MaxHingeThreshold, approach.NumHingeThresholds));
             }
 
             IEnumerable<IBasisFunction> functions = simpleBasisFuncs;
 
-            if (approach.AllowInter) {
+            if (approach.AllowInteractions) {
                 var multivariateBases = CreateMultivariateBases(data, simpleBasisFuncs.ToArray());
                 functions = functions.Concat(multivariateBases);
             }
 
-            if (approach.AllowDenom) {
+            if (approach.AllowDenominators) {
                 var denominatorBases = CreateDenominatorBases(functions);
                 functions = functions.Concat(denominatorBases);
@@ -37 +37 @@
         }
 
-        public static IEnumerable<ISimpleBasisFunction> CreateSimpleBases(IRegressionProblemData problemData, HashSet<double> exponents, HashSet<NonlinearOperator> nonlinFuncs) {
+        public static IEnumerable<ISimpleBasisFunction> CreateSimpleBases(IRegressionProblemData problemData, HashSet<double> exponents, HashSet<NonlinearOperator> nonLinearFunctions) {
             var simpleBasisFunctions = new List<ISimpleBasisFunction>();
             foreach (var variableName in problemData.AllowedInputVariables) {
@@ -45 +45 @@
                     var simpleBase = new SimpleBasisFunction(variableName, exp, NonlinearOperator.None);
                     // if the basis function is not valid without any operator, then it won't be valid in combination with any nonlinear operator -> skip
-                    if (!Ok(simpleBase.Simulate(problemData))) continue;
-
-                    foreach (NonlinearOperator op in nonlinFuncs) {
+                    if (!Ok(simpleBase.Evaluate(problemData))) continue;
+
+                    foreach (NonlinearOperator op in nonLinearFunctions) {
                         // ignore cases where op has no effect
-                        if (op.Equals(NonlinearOperator.Abs) && new[] { -2.0, 2.0 }.Contains(exp) && nonlinFuncs.Contains(NonlinearOperator.None)) continue;
+                        if (op.Equals(NonlinearOperator.Abs) && new[] { -2.0, 2.0 }.Contains(exp) && nonLinearFunctions.Contains(NonlinearOperator.None)) continue;
                         if (op.Equals(NonlinearOperator.Abs) && min >= 0) continue;
                         var nonsimpleBase = (SimpleBasisFunction)simpleBase.DeepCopy();
                         nonsimpleBase.Operator = op;
-                        if (!Ok(nonsimpleBase.Simulate(problemData))) continue;
+                        if (!Ok(nonsimpleBase.Evaluate(problemData))) continue;
                         simpleBasisFunctions.Add(nonsimpleBase);
                     }
@@ -77 +77 @@
                     if (b_j.Operator != NonlinearOperator.None) continue; // disallow op() * op(); deemed to complex
                     var b_inter = new ProductBaseFunction(b_i, b_j, true);
-                    if (!Ok(b_inter.Simulate(data))) continue;
+                    if (!Ok(b_inter.Evaluate(data))) continue;
                     multivariateBases.Add(b_inter);
                     if (multivariateBases.Count() >= maxSize)
@@ -98 +98 @@
         }
 
-        public static IList<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, IEnumerable<ISimpleBasisFunction> simple_bfs, double relative_start_thr = 0.0, double relative_end_thr = 1.0, int num_thrs = 3, IntRange trainingPartition = null) {
+        public static IList<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, IEnumerable<ISimpleBasisFunction> simple_bfs, 
+          double relative_start_thr = 0.0, double relative_end_thr = 1.0, int num_thrs = 3, IntRange trainingPartition = null) {
             var hingeBases = new List<ISimpleBasisFunction>();
 
@@ -107 +108 @@
         }
 
-        private static IEnumerable<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, ISimpleBasisFunction simple_bf, double relative_start_thr, double relative_end_thr, int num_thrs, IntRange trainingPartition) {
+        private static IEnumerable<ISimpleBasisFunction> CreateHingeBases(IRegressionProblemData data, ISimpleBasisFunction simple_bf, 
+          double relative_start_thr, double relative_end_thr, int num_thrs, IntRange trainingPartition) {
             if (relative_start_thr >= relative_end_thr) throw new ArgumentException($"{nameof(relative_start_thr)} must be smaller than {nameof(relative_end_thr)}.");
             var ans = new List<ISimpleBasisFunction>();
 
-            var vals = simple_bf.Simulate(data);
+            var vals = simple_bf.Evaluate(data);
             var temp = trainingPartition ?? data.TrainingPartition;
             double min = Double.MaxValue;
@@ -126 +128 @@
 
             foreach (var thr in thresholds) {
-                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.Gth, true, thr));
-                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.Lth, true, thr));
+                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.GT_Hinge, true, thr));
+                ans.Add(new SimpleBasisFunction(simple_bf.Feature, 1, NonlinearOperator.LT_Hinge, true, thr));
             }
             return ans;
@@ -135 +137 @@
             List<IBasisFunction> ans = new List<IBasisFunction>();
             foreach (var bf in basisFunctions) {
-                if (!bf.IsNominator) continue;
+                if (!bf.IsDenominator) continue;
                 var denomFunc = bf.DeepCopy();
-                denomFunc.IsNominator = false;
+                denomFunc.IsDenominator = false;
                 ans.Add(denomFunc);
             }
@@ -151 +153 @@
             int col = 0;
             foreach (var basisFunc in basisFunctions) {
-                allowedInputVars.Add(basisFunc.ToString() + (!basisFunc.IsNominator ? " * " + problemData.TargetVariable : ""));
-                var vals = basisFunc.Simulate(problemData);
+                allowedInputVars.Add(basisFunc.ToString() + (!basisFunc.IsDenominator ? " * " + problemData.TargetVariable : ""));
+                var vals = basisFunc.Evaluate(problemData);
                 for (int i = 0; i < numRows; i++) {
                     variableValues[i, col] = vals[i];