Changeset 4044 for trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Operators/WeightedParentsQualityVarianceComparator.cs

Timestamp:

07/19/10 14:36:11 (14 years ago)

Author:

mkommend

Message:

added statistical comperator operator for SymReg OSGP (ticket #1082)

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Operators

Files:

• . (added)
• WeightedParentsQualityVarianceComparator.cs (copied) (copied from trunk/sources/HeuristicLab.Optimization.Operators/3.3/WeightedParentsQualityComparator.cs) (2 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Operators/WeightedParentsQualityVarianceComparator.cs

@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using alglib;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Optimization.Operators {
-  [Item("WeightedParentsQualityComparator", "Compares the quality against that of its parents (assumes the parents are subscopes to the child scope). This operator works with any number of subscopes > 0.")]
+namespace HeuristicLab.Problems.DataAnalysis.Operators {
+  [Item("WeightedParentsQualityVarianceComparator", "Compares the quality and variance of the quality against that of its parents (assumes the parents are subscopes to the child scope). This operator works with any number of subscopes > 0.")]
   [StorableClass]
-  public class WeightedParentsQualityComparator : SingleSuccessorOperator, ISubScopesQualityComparator {
+  public class WeightedParentsQualityVarianceComparator : SingleSuccessorOperator, ISubScopesQualityComparator {
     public IValueLookupParameter<BoolValue> MaximizationParameter {
       get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    public ILookupParameter<BoolValue> ResultParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Result"]; }
+    }
+    public IValueLookupParameter<DoubleValue> ConfidenceIntervalParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["ConfidenceInterval"]; }
     }
     public ILookupParameter<DoubleValue> LeftSideParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters["LeftSide"]; }
     }
+    public ILookupParameter<DoubleValue> LeftSideVarianceParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["LeftSideVariance"]; }
+    }
+    public ILookupParameter<IntValue> LeftSideSamplesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["LeftSideSamples"]; }
+    }
     public ILookupParameter<ItemArray<DoubleValue>> RightSideParameter {
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["RightSide"]; }
     }
-    public ILookupParameter<BoolValue> ResultParameter {
-      get { return (ILookupParameter<BoolValue>)Parameters["Result"]; }
+    public ILookupParameter<ItemArray<DoubleValue>> RightSideVariancesParameters {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["RightSideVariances"]; }
     }
-    public ValueLookupParameter<DoubleValue> ComparisonFactorParameter {
-      get { return (ValueLookupParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
+    public ILookupParameter<ItemArray<IntValue>> RightSideSamplesParameters {
+      get { return (ILookupParameter<ItemArray<IntValue>>)Parameters["RightSideSamples"]; }
     }
 
-    public WeightedParentsQualityComparator()
+    public WeightedParentsQualityVarianceComparator()
       : base() {
       Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, false otherwise"));
+      Parameters.Add(new LookupParameter<BoolValue>("Result", "The result of the comparison: True means Quality is better, False means it is worse than parents."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("ConfidenceInterval", "The confidence interval used for the test.", new DoubleValue(0.05)));
+
       Parameters.Add(new LookupParameter<DoubleValue>("LeftSide", "The quality of the child."));
+      Parameters.Add(new LookupParameter<DoubleValue>("LeftSideVariance", "The variances of the quality of the new child."));
+      Parameters.Add(new LookupParameter<IntValue>("LeftSideSamples", "The number of samples used to calculate the quality of the new child."));
+
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("RightSide", "The qualities of the parents."));
-      Parameters.Add(new LookupParameter<BoolValue>("Result", "The result of the comparison: True means Quality is better, False means it is worse than parents."));
-      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactor", "Determines if the quality should be compared to the better parent (1.0), to the worse (0.0) or to any linearly interpolated value between them."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("RightSideVariances", "The variances of the parents."));
+      Parameters.Add(new LookupParameter<IntValue>("RightSideSamples", "The number of samples used to calculate the quality of the parent."));
     }
 
     public override IOperation Apply() {
+      double leftQuality = LeftSideParameter.ActualValue.Value;
+      double leftVariance = LeftSideVarianceParameter.ActualValue.Value;
+      int leftSamples = LeftSideSamplesParameter.ActualValue.Value;
+
       ItemArray<DoubleValue> rightQualities = RightSideParameter.ActualValue;
+      ItemArray<DoubleValue> rightVariances = RightSideVariancesParameters.ActualValue;
+      ItemArray<IntValue> rightSamples = RightSideSamplesParameters.ActualValue;
+
       if (rightQualities.Length < 1) throw new InvalidOperationException(Name + ": No subscopes found.");
-      double compFact = ComparisonFactorParameter.ActualValue.Value;
       bool maximization = MaximizationParameter.ActualValue.Value;
-      double leftQuality = LeftSideParameter.ActualValue.Value;
 
-      double threshold = 0;
+      int bestParentIndex;
+      double bestParentQuality;
+      double bestParentVariance;
+      int bestParentSamples;
 
-      #region Calculate threshold
-      if (rightQualities.Length == 2) { // this case will probably be used most often
-        double minQuality = Math.Min(rightQualities[0].Value, rightQualities[1].Value);
-        double maxQuality = Math.Max(rightQualities[0].Value, rightQualities[1].Value);
-        if (maximization)
-          threshold = minQuality + (maxQuality - minQuality) * compFact;
-        else
-          threshold = maxQuality - (maxQuality - minQuality) * compFact;
-      } else if (rightQualities.Length == 1) { // case for just one parent
-        threshold = rightQualities[0].Value;
-      } else { // general case extended to 3 or more parents
-        List<double> sortedQualities = rightQualities.Select(x => x.Value).ToList();
-        sortedQualities.Sort();
-        double minimumQuality = sortedQualities.First();
+      if (maximization)
+        bestParentQuality = rightQualities.Max(x => x.Value);
+      else
+        bestParentQuality = rightQualities.Min(x => x.Value);
+      bestParentIndex = rightQualities.FindIndex(x => x.Value == bestParentQuality);
+      bestParentVariance = rightVariances[bestParentIndex].Value;
+      bestParentSamples = rightSamples[bestParentIndex].Value;
 
-        double integral = 0;
-        for (int i = 0; i < sortedQualities.Count - 1; i++) {
-          integral += (sortedQualities[i] + sortedQualities[i + 1]) / 2.0; // sum of the trapezoid
-        }
-        integral -= minimumQuality * sortedQualities.Count;
-        if (integral == 0) threshold = sortedQualities[0]; // all qualities are equal
-        else {
-          double selectedArea = integral * (maximization ? compFact : (1 - compFact));
-          integral = 0;
-          for (int i = 0; i < sortedQualities.Count - 1; i++) {
-            double currentSliceArea = (sortedQualities[i] + sortedQualities[i + 1]) / 2.0;
-            double windowedSliceArea = currentSliceArea - minimumQuality;
-            if (windowedSliceArea == 0) continue;
-            integral += windowedSliceArea;
-            if (integral >= selectedArea) {
-              double factor = 1 - ((integral - selectedArea) / (windowedSliceArea));
-              threshold = sortedQualities[i] + (sortedQualities[i + 1] - sortedQualities[i]) * factor;
-              break;
-            }
-          }
-        }
-      }
-      #endregion
+      double xmean = leftQuality;
+      double xvar = leftVariance;
+      int n = leftSamples;
+      double ymean = bestParentQuality;
+      double yvar = bestParentVariance;
+      double m = bestParentSamples;
 
-      bool result = maximization && leftQuality > threshold || !maximization && leftQuality < threshold;
+
+      //following code taken from ALGLIB studentttest line 351
+      // Two-sample unpooled test
+      double p = 0;
+      double stat = (xmean - ymean) / Math.Sqrt(xvar / n + yvar / m);
+      double c = xvar / n / (xvar / n + yvar / m);
+      double df = (n - 1) * (m - 1) / ((m - 1) * AP.Math.Sqr(c) + (n - 1) * (1 - AP.Math.Sqr(c)));
+      if ((double)(stat) > (double)(0))
+        p = 1 - 0.5 * ibetaf.incompletebeta(df / 2, 0.5, df / (df + AP.Math.Sqr(stat)));
+      else
+        p = 0.5 * ibetaf.incompletebeta(df / 2, 0.5, df / (df + AP.Math.Sqr(stat)));
+      double bothtails = 2 * Math.Min(p, 1 - p);
+      double lefttail = p;
+      double righttail = 1 - p;
+
+      bool result = false;
+      if (maximization)
+        result = righttail < ConfidenceIntervalParameter.ActualValue.Value;
+      else
+        result = lefttail < ConfidenceIntervalParameter.ActualValue.Value;
+
       BoolValue resultValue = ResultParameter.ActualValue;
       if (resultValue == null) {
@@ -114 +138 @@
       }
 
+
+
       return base.Apply();
     }