Changeset 10230 for branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic

Timestamp:

12/16/13 16:11:31 (11 years ago)

Author:

mkommend

Message:

#1997: Updated symbolic island algorithm evaluators and added automatic wiring of evaluators.

Location:

branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3

Files:

• ConsecutiveSamplesEvaluator.cs (modified) (3 diffs)
• ISymbolicDataAnalysisIslandAlgorithmEvaluator .cs (modified) (1 diff)
• RandomSamplesEvaluator .cs (modified) (4 diffs)
• SymbolicDataAnalysisIslandGeneticAlgorithm.cs (modified) (2 diffs)
• SymbolicDataAnalysisIslandOffspringSelectionGeneticAlgorithm.cs (modified) (2 diffs)

branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ConsecutiveSamplesEvaluator.cs

@@ -47 +47 @@
     private const string MaximumIterationsParameterName = "Maximum Iterations";
 
-
     #region parameter properties
     public ILookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
@@ -59 +58 @@
     }
     public ILookupParameter<IntRange> FitnessCalculationPartitionParameter {
-      get { return (IValueLookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
+      get { return (ILookupParameter<IntRange>)Parameters[FitnessCalculationPartitionParameterName]; }
     }
     public ILookupParameter<IntRange> FixedSamplesPartitionParameter {
@@ -128 +127 @@
       var fixedSamples = FixedSamplesPartitionParameter.ActualValue;
 
-      //create fixed rows enumerable
-      var rows = Enumerable.Range(fixedSamples.Start, fixedSamples.Size);
-      //create consecutive rows enumerable
-      if (ConsecutiveSamples > 0) {
-        var dataMigrationInterval = DataMigrationIntervalParameter.ActualValue.Value;
-        var islandIndex = IslandIndexParameter.ActualValue.Value;
-        var generation = IterationsParameter.ActualValue.Value;
-        var iteration = islandIndex + (generation / dataMigrationInterval);
-        var consecutiveRows = GenerateRows(samples, fixedSamples, ConsecutiveSamples, Overlap, iteration);
-        rows = rows.Concat(consecutiveRows);
+      var dataMigrationInterval = DataMigrationIntervalParameter.ActualValue.Value;
+      var generationValue = IterationsParameter.ActualValue;
+      var generation = generationValue == null ? 0 : generationValue.Value;
+
+      //calculat new rows for evaluation
+      if (generation % dataMigrationInterval == 0) {
+        //create fixed rows enumerable
+        var rows = Enumerable.Range(fixedSamples.Start, fixedSamples.Size);
+        //create consecutive rows enumerable
+        if (ConsecutiveSamples > 0) {
+          var islandIndex = IslandIndexParameter.ActualValue.Value;
+          var iteration = islandIndex + (generation / dataMigrationInterval);
+          var consecutiveRows = GenerateRows(samples, fixedSamples, ConsecutiveSamples, Overlap, iteration);
+          rows = rows.Concat(consecutiveRows);
+        }
+        //filter out test rows
+        rows = rows.Where(r => r < problemData.TestPartition.Start || r > problemData.TestPartition.End);
+
+        //TODO change to lookup parameter
+        ExecutionContext.Scope.Variables.Remove("Rows");
+        ExecutionContext.Scope.Variables.Add(new HeuristicLab.Core.Variable("Rows", new EnumerableItem<int>(rows)));
       }
-      //filter out test rows
-      rows = rows.Where(r => r < problemData.TestPartition.Start || r > problemData.TestPartition.End);
 
-      //execution context is created manually to be able to clear the rows parameter easily
       var executionContext = new ExecutionContext(ExecutionContext, evaluator, ExecutionContext.Scope);
-
-      //TODO change to lookup parameter
-      executionContext.Scope.Variables.Remove("Rows");
-      executionContext.Scope.Variables.Add(new HeuristicLab.Core.Variable("Rows", new EnumerableItem<int>(rows)));
       var successor = evaluator.Execute(executionContext, this.CancellationToken);
       return new OperationCollection(successor, base.Apply());

branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/ISymbolicDataAnalysisIslandAlgorithmEvaluator .cs

@@ -20 +20 @@
 #endregion
 
+using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
-  public interface ISymbolicDataAnalysisIslandGeneticAlgorithmEvaluator : ISingleObjectiveEvaluator {
+  public interface ISymbolicDataAnalysisIslandGeneticAlgorithmEvaluator : ISingleObjectiveEvaluator, IIterationBasedOperator {
+    IValueLookupParameter<IntValue> DataMigrationIntervalParameter { get; }
   }
 }

branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/RandomSamplesEvaluator .cs

@@ -41 +41 @@
     private const string FitnessCalculationPartitionParameterName = "FitnessCalculationPartition";
     private const string FixedSamplesPartitionParameterName = "FixedSamplesPartition";
+    private const string DataMigrationIntervalParameterName = "DataMigrationInterval";
     private const string RandomSamplesParameterName = "RandomSamples";
+    private const string IterationsParameterName = "Iterations";
+    private const string MaximumIterationsParameterName = "Maximum Iterations";
 
     #region parameter properties
@@ -62 +65 @@
       get { return (ILookupParameter<IntRange>)Parameters[FixedSamplesPartitionParameterName]; }
     }
+    public IValueLookupParameter<IntValue> DataMigrationIntervalParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[DataMigrationIntervalParameterName]; }
+    }
     public IFixedValueParameter<IntValue> RandomSamplesParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[RandomSamplesParameterName]; }
+    }
+    public ILookupParameter<IntValue> IterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters[IterationsParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumIterationsParameterName]; }
     }
     #endregion
@@ -93 +105 @@
       Parameters.Add(new LookupParameter<IntRange>(FixedSamplesPartitionParameterName, "The data partition which is used to calculate the fitness on the fixed samples."));
       Parameters.Add(new FixedValueParameter<IntValue>(RandomSamplesParameterName, "The number of random samples used for fitness calculation in each island.", new IntValue()));
+      Parameters.Add(new ValueLookupParameter<IntValue>(DataMigrationIntervalParameterName, "The number of generations that should pass between data migration phases."));
+      Parameters.Add(new LookupParameter<IntValue>(IterationsParameterName, "The number of performed iterations."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumIterationsParameterName, "The maximum number of performed iterations.") { Hidden = true });
     }
 
@@ -103 +118 @@
       var randomSamples = RandomSamples;
 
-      //create fixed rows enumerable
-      var rows = Enumerable.Range(fixedSamples.Start, fixedSamples.Size);
-      //create randomly chosen rows enumerable
-      if (randomSamples > 0) {
-        if (randomSamples > samples.Size - fixedSamples.Size) {
-          var error = string.Format("Could not select {0} random samples, because there are {1} total samples present from which {2} where used in the fixed partition. Please lower the number of random samples in the algorithm configuration.", randomSamples, samples.Size, fixedSamples.Size);
-          throw new OperatorExecutionException(this, error);
+      var dataMigrationInterval = DataMigrationIntervalParameter.ActualValue.Value;
+      var generationValue = IterationsParameter.ActualValue;
+      var generation = generationValue == null ? 0 : generationValue.Value;
+
+      //calculat new rows for evaluation
+      if (generation % dataMigrationInterval == 0) {
+        //create fixed rows enumerable
+        var rows = Enumerable.Range(fixedSamples.Start, fixedSamples.Size);
+        //create randomly chosen rows enumerable
+        if (randomSamples > 0) {
+          if (randomSamples > samples.Size - fixedSamples.Size) {
+            var error = string.Format("Could not select {0} random samples, because there are {1} total samples present from which {2} where used in the fixed partition. Please lower the number of random samples in the algorithm configuration.", randomSamples, samples.Size, fixedSamples.Size);
+            throw new OperatorExecutionException(this, error);
+          }
+          var randomRows = Enumerable.Range(samples.Start, samples.Size).Where(r => r < fixedSamples.Start || r >= fixedSamples.End);
+          randomRows = randomRows.SampleRandomWithoutRepetition(RandomParameter.ActualValue, randomSamples, samples.Size - fixedSamples.Size);
+
+          rows = rows.Concat(randomRows);
         }
-        var randomRows = Enumerable.Range(samples.Start, samples.Size).Where(r => r < fixedSamples.Start || r >= fixedSamples.End);
-        randomRows = randomRows.SampleRandomWithoutRepetition(RandomParameter.ActualValue, randomSamples, samples.Size - fixedSamples.Size);
+        //filter out test rows
+        rows = rows.Where(r => r < problemData.TestPartition.Start || r > problemData.TestPartition.End);
+        ExecutionContext.Scope.Variables.Remove("Rows");
+        ExecutionContext.Scope.Variables.Add(new HeuristicLab.Core.Variable("Rows", new EnumerableItem<int>(rows)));
+      }
 
-        rows = rows.Concat(randomRows);
-      }
-      //filter out test rows
-      rows = rows.Where(r => r < problemData.TestPartition.Start || r > problemData.TestPartition.End);
-
-      //execution context is created manually to be able to clear the rows parameter easily
       var executionContext = new ExecutionContext(ExecutionContext, evaluator, ExecutionContext.Scope);
-
-      //TODO change to lookup parameter
-      executionContext.Scope.Variables.Remove("Rows");
-      executionContext.Scope.Variables.Add(new HeuristicLab.Core.Variable("Rows", new EnumerableItem<int>(rows)));
       var successor = evaluator.Execute(executionContext, this.CancellationToken);
       return new OperationCollection(successor, base.Apply());

branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandGeneticAlgorithm.cs

@@ -132 +132 @@
       FixedSamplesParameter.Value.ValueChanged += (o, e) => {
         RecalculateFixedSamplesPartitions();
-        ReevaluateImmigrants = FixedSamples >= Problem.FitnessCalculationPartition.Size;
+        ReevaluateImmigrants = FixedSamples < Problem.FitnessCalculationPartition.Size;
       };
       Analyzer.Operators.PropertyChanged += (o, e) => ParameterizeAnalyzers();
@@ -162 +162 @@
     private void ParameterizeEvaluator() {
       var evaluator = EvaluatorParameter.Value;
-
-      var randomEvaluator = evaluator as RandomSamplesEvaluator;
-      if (randomEvaluator != null) {
-        ReevaluteElites = randomEvaluator.RandomSamples != 0;
-      }
-
-      var consecutiveEvaluator = evaluator as ConsecutiveSamplesEvaluator;
-      if (consecutiveEvaluator != null) {
-        consecutiveEvaluator.DataMigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
-      }
+      evaluator.IterationsParameter.ActualName = "Generations";
+      evaluator.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
+      evaluator.DataMigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
+
+      ParameterizeStochasticOperatorForIsland(evaluator);
     }
 

branches/DataAnalysis.IslandAlgorithms/HeuristicLab.Algorithms.DataAnalysis.Symbolic/3.3/SymbolicDataAnalysisIslandOffspringSelectionGeneticAlgorithm.cs

@@ -128 +128 @@
       FixedSamplesParameter.Value.ValueChanged += (o, e) => {
         RecalculateFixedSamplesPartitions();
-        ReevaluateImmigrants = FixedSamples >= Problem.FitnessCalculationPartition.Size;
+        ReevaluateImmigrants = FixedSamples < Problem.FitnessCalculationPartition.Size;
       };
       Analyzer.Operators.PropertyChanged += (o, e) => ParameterizeAnalyzers();
@@ -158 +158 @@
     private void ParameterizeEvaluator() {
       var evaluator = EvaluatorParameter.Value;
-
-      var randomEvaluator = evaluator as RandomSamplesEvaluator;
-      if (randomEvaluator != null) {
-        ReevaluteElites = randomEvaluator.RandomSamples != 0;
-      }
-
-      var consecutiveEvaluator = evaluator as ConsecutiveSamplesEvaluator;
-      if (consecutiveEvaluator != null) {
-        consecutiveEvaluator.DataMigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
-      }
+      evaluator.IterationsParameter.ActualName = "Generations";
+      evaluator.MaximumIterationsParameter.ActualName = MaximumGenerationsParameter.Name;
+      evaluator.DataMigrationIntervalParameter.ActualName = MigrationIntervalParameter.Name;
+
+      ParameterizeStochasticOperator(evaluator);
     }