Changeset 6991 for branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/Generator/RegressionBenchmark.cs

Timestamp:

11/14/11 17:08:32 (12 years ago)

Author:

sforsten

Message:

#1669: First version with a simpler design as discussed with Michael Kommenda has been implemented and will be tested soon. Currently only the KotanchekFunction.cs is changed accordingly. Other benchmarks are going to follow soon.

The classes for the different distributions are not needed any longer. Static methods in RegressionBenchmark replace them.

File:

• branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/Generator/RegressionBenchmark.cs (modified) (4 diffs)

branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/Generator/RegressionBenchmark.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -26 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Data;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
   public abstract class RegressionBenchmark : Benchmark, IRegressionBenchmarkProblemDataGenerator {
+
+    #region properties
+    public abstract List<string> InputVariable { get; }
+    public abstract string TargetVariable { get; }
+    public abstract IntRange TrainingPartition { get; }
+    public abstract IntRange TestPartition { get; }
+    #endregion
 
     protected RegressionBenchmark() { }
@@ -35 +42 @@
     }
 
-    #region properties
-    public string TargetVariable { get; protected set; }
-    public Dictionary<string, IntRange> Inputvariables { get; protected set; }
-    public int AmountOfPoints { get; protected set; }
-    public IntRange TrainingPartition { get; protected set; }
-    public IntRange TestPartition { get; protected set; }
-    #endregion
+    protected abstract List<double> CalculateFunction(Dictionary<string, IList<double>> data);
 
-    protected abstract double CalculateFunction(Dictionary<string, IList<double>> data, List<string> vars);
+    protected abstract Dictionary<string, IList<double>> GenerateInput(Dictionary<string, IList<double>> data);
 
     public IDataAnalysisProblemData GenerateProblemData() {
-      //prepare dictionary
       Dictionary<string, IList<double>> data = new Dictionary<string, IList<double>>();
-      data.Add(TargetVariable, new List<double>());
-      foreach (var variable in Inputvariables.Keys) {
+      data.Add(this.TargetVariable, new List<double>());
+      foreach (var variable in this.InputVariable) {
         data.Add(variable, new List<double>());
       }
 
-      data = CalculateValues(data);
+      data = GenerateInput(data);
 
       List<IList> values = new List<IList>();
@@ -65 +65 @@
       RegressionProblemData problemData = new RegressionProblemData(dataset, dataset.DoubleVariables.Skip(1), dataset.DoubleVariables.First());
 
-      #region set ProblemData specific parameters
       problemData.Name = "Data generated for benchmark problem \"" + this.Name + "\"";
 
-      problemData.TargetVariableParameter.Value =
-        problemData.TargetVariableParameter.ValidValues.First(v => v.Value == TargetVariable);
-      problemData.InputVariables.SetItemCheckedState(
-        problemData.InputVariables.Single(x => x.Value == TargetVariable), false);
-
-      foreach (var variable in this.Inputvariables) {
-        problemData.InputVariables.SetItemCheckedState(
-          problemData.InputVariables.Single(x => x.Value == variable.Key), true);
-      }
 
       problemData.TestPartition.Start = this.TestPartition.Start;
       problemData.TestPartition.End = this.TestPartition.End;
+
       problemData.TrainingPartition.Start = this.TrainingPartition.Start;
       problemData.TrainingPartition.End = this.TrainingPartition.End;
-      #endregion
 
       return problemData;
     }
 
-    private Dictionary<string, IList<double>> CalculateValues(Dictionary<string, IList<double>> data) {
-      Random rand = new Random();
-      List<string> vars = new List<string>(Inputvariables.Keys);
-      for (int i = 0; i < AmountOfPoints; i++) {
-        foreach (var variable in vars) {
-          data[variable].Add(rand.NextDouble() *
-            (Inputvariables[variable].End - Inputvariables[variable].Start) +
-            Inputvariables[variable].Start);
-        }
+    //private Dictionary<string, IList<double>> CalculateValues(Dictionary<string, IList<double>> data, DatasetDefinition dataDef) {
+    //  Random rand = new Random();
+    //  var combinationDataSet = AllCombinationsOf(dataDef.RangeVariables.Values.Select(range => range.Values).ToList());
+    //  int index = 0;
+    //  var help = dataDef.RangeVariables.Keys;
+    //  foreach (var dataSet in combinationDataSet) {
+    //    data[help.ElementAt(index)] = dataSet;
+    //    index++;
+    //  }
+    //  List<string> vars = new List<string>(dataDef.RandomVariables.Keys);
+    //  for (int i = 0; i < dataDef.AmountOfPoints; i++) {
+    //    foreach (var variable in vars) {
+    //      data[variable].Add(dataDef.RandomVariables[variable].Next());
+    //    }
+    //    //  data[TargetVariable].Add(CalculateFunction(data, vars));
+    //  }
+    //  int bla = 0;
+    //  var test = data.Values.Select((ind) => (ind.ElementAt(bla)));
 
-        data[TargetVariable].Add(CalculateFunction(data, vars));
+    //  return data;
+    //}
+
+    public static List<double> generateSteps(DoubleRange range, double stepWidth) {
+      return Enumerable.Range(0, (int)((range.End - range.Start) / stepWidth) + 1)
+                                      .Select(i => (range.Start + i * stepWidth))
+                                      .ToList<double>();
+    }
+
+    public static List<double> generateUniformDistributedValues(int amount, DoubleRange range) {
+      List<double> values = new List<double>();
+      System.Random rand = new System.Random();
+      for (int i = 0; i < amount; i++) {
+        values.Add(rand.NextDouble() * (range.End - range.Start) + range.Start);
       }
-      return data;
+      return values;
+    }
+
+    public static List<double> generateNormalDistributedValues(int amount, double mu, double sigma) {
+      List<double> values = new List<double>();
+      FastRandom rand = new FastRandom();
+      for (int i = 0; i < amount; i++) {
+        values.Add(NormalDistributedRandom.NextDouble(rand, mu, sigma));
+      }
+      return values;
+    }
+
+    public static List<List<double>> AllCombinationsOf(List<List<double>> sets) {
+
+      var combinations = new List<List<double>>();
+
+      foreach (var value in sets[0])
+        combinations.Add(new List<double> { value });
+
+      foreach (var set in sets.Skip(1))
+        combinations = AddExtraSet(combinations, set);
+
+      return combinations;
+    }
+
+    private static List<List<double>> AddExtraSet
+         (List<List<double>> combinations, List<double> set) {
+      var newCombinations = from value in set
+                            from combination in combinations
+                            select new List<double>(combination) { value };
+
+      return newCombinations.ToList();
     }
   }