Changeset 8725 for branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysis.cs

Timestamp:

10/03/12 17:13:31 (12 years ago)

Author:

epitzer

Message:

improve information analysis #1696

• fixed a bug in quality delta filtering
• report finer-grained results
• add total entropy
• add peak values to results

File:

• branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysis.cs (modified) (3 diffs)

branches/FitnessLandscapeAnalysis/HeuristicLab.Analysis.FitnessLandscape/Analysis/InformationAnalysis.cs

@@ -19 +19 @@
     public List<double> PartialInformationContent { get; private set; }
     public List<double> DensityBasinInformation { get; private set; }
+    public List<double> TotalEntropy { get; private set; } 
     public List<double> QualityDelta { get; private set; }
     public double InformationStability { get; private set; }
     public int Regularity { get; private set; }
+    public int Diversity { get; private set; }
     public Peak PeakInformationContent { get; private set; }
     public Peak PeakPartialInformationContent { get; private set; }
     public Peak PeakDensityBasinInformation { get; private set; }
+    public Peak PeakTotalEntropy { get; private set; }
 
-    public InformationAnalysis(IEnumerable<double> qualities, int nQuantiles) {
+    public InformationAnalysis(IList<double> qualities, int nQuantiles) {
       InformationContent = new List<double>();
       PartialInformationContent = new List<double>();
       DensityBasinInformation = new List<double>();
+      TotalEntropy = new List<double>();
       QualityDelta = new List<double>();
       PerformAnalysis(qualities, nQuantiles);
     }
 
-    private void PerformAnalysis(IEnumerable<double> qualities, int nQuantiles) {
+    private void PerformAnalysis(IList<double> qualities, int nQuantiles) {
       var differences = Differences(qualities).ToList();
       InformationStability = differences.Select(d => Math.Abs(d)).Max();
       Regularity = new HashSet<double>(differences).Count;
-      var thresholds = UniqueThresholdCalculator.DetermineThresholds(differences, nQuantiles).ToList();
+      Diversity = new HashSet<double>(qualities).Count;
+      //var thresholds = UniqueThresholdCalculator.DetermineThresholds(differences, nQuantiles).ToList();
+      var thresholds = differences.Select(d => Math.Abs(d)).OrderBy(d => d);
       foreach (var eps in thresholds) {
         var shapes = Shapes(eps, differences).ToList();
-        int[] shape_counts = CountShapes(shapes);
+        int[] shapeCounts = CountShapes(shapes);
         QualityDelta.Add(eps);
-        InformationContent.Add(CalculateInformationContent(shape_counts, shapes.Count));
+        InformationContent.Add(CalculateInformationContent(shapeCounts, shapes.Count));
         PartialInformationContent.Add(CalculatePartialInformationContent(eps, differences));
-        DensityBasinInformation.Add(CalculateDensityBasinInformation(shape_counts, shapes.Count));
+        DensityBasinInformation.Add(CalculateDensityBasinInformation(shapeCounts, shapes.Count));
+        TotalEntropy.Add(CalculateTotalEntropy(shapeCounts, shapes.Count));
       }
-      PeakDensityBasinInformation = GetPeak(QualityDelta, InformationContent);
+      PeakInformationContent = GetPeak(QualityDelta, InformationContent);
+      PeakDensityBasinInformation = GetPeak(QualityDelta, DensityBasinInformation);
       PeakPartialInformationContent = GetPeak(QualityDelta, PartialInformationContent);
-      PeakDensityBasinInformation = GetPeak(QualityDelta, DensityBasinInformation);
+      PeakTotalEntropy = GetPeak(QualityDelta, TotalEntropy);
     }
 
@@ -72 +80 @@
       return Utils.Delta(differences, (x, y) =>
         (Shape)
-          ((x >= eps ? 1 : (x <= -eps ? -1 : 0)) +
-           (y >= eps ? 3 : (y <= -eps ? -3 : 0))));
+          ((x > eps ? 1 : (x < -eps ? -1 : 0)) +
+           (y > eps ? 3 : (y < -eps ? -3 : 0))));
     }
 
-    private static double CalculateInformationContent(int[] shape_counts, int total_n_shapes) {
+    private static double CalculateInformationContent(int[] shapeCounts, int totalNShapes) {
       return
-        -Entropy(shape_counts[(int)Shape.EquDec + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.IncDec + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.DecEqu + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.IncEqu + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.DecInc + 4], total_n_shapes, 6)
-        - Entropy(shape_counts[(int)Shape.EquInc + 4], total_n_shapes, 6);
+        -Entropy(shapeCounts[(int)Shape.EquDec + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.IncDec + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.DecEqu + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.IncEqu + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.DecInc + 4], totalNShapes, 6)
+        - Entropy(shapeCounts[(int)Shape.EquInc + 4], totalNShapes, 6);
     }
 
-    private static double CalculateDensityBasinInformation(int[] shape_counts, int total_n_shapes) {
+    private static double CalculateDensityBasinInformation(int[] shapeCounts, int totalNShapes) {
       return
-        -Entropy(shape_counts[(int)Shape.DecDec + 4], total_n_shapes, 3)
-        - Entropy(shape_counts[(int)Shape.EquEqu + 4], total_n_shapes, 3)
-        - Entropy(shape_counts[(int)Shape.IncInc + 4], total_n_shapes, 3);
+        -Entropy(shapeCounts[(int)Shape.DecDec + 4], totalNShapes, 3)
+        - Entropy(shapeCounts[(int)Shape.EquEqu + 4], totalNShapes, 3)
+        - Entropy(shapeCounts[(int)Shape.IncInc + 4], totalNShapes, 3);
     }
 
-    private static double CalculatePartialInformationContent(double eps, List<double> differences) {
+    private static double CalculateTotalEntropy(int[] shapeCounts, int totalNShapes) {
+      return shapeCounts.Aggregate(0.0, (current, t) => current - Entropy(t, totalNShapes, 9));
+    }
+
+    private static double CalculatePartialInformationContent(double eps, ICollection<double> differences) {
       int slope = 0;
       int nPeaks = 0;
       foreach (var d in differences) {
-        if (d >= eps) {
+        if (d > eps) {
           if (slope < 0) nPeaks++;
           slope = +1;
-        } else if (d <= -eps) {
+        } else if (d < -eps) {
           if (slope > 0) nPeaks++;
           slope = -1;
@@ -109 +121 @@
 
     private static int[] CountShapes(IEnumerable<Shape> shapes) {
-      int[] shape_counts = new int[9];
+      int[] shapeCounts = new int[9];
       foreach (var s in shapes) {
-        shape_counts[(int)s + 4]++;
+        shapeCounts[(int)s + 4]++;
       }
-      return shape_counts;
+      return shapeCounts;
     }
 
-    private static double Entropy(int count, int total, int n_cases) {
+    private static double Entropy(int count, int total, int nCases) {
       if (count == 0)
         return 0;
       double freq = 1.0 * count / total;
-      return freq * Math.Log(freq, n_cases);
+      return freq * Math.Log(freq, nCases);
     }