Changeset 10974

Timestamp:

06/11/14 12:07:15 (10 years ago)

Author:

gkronber

Message:

#2109: minor code cleanup

Location:

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution

Files:

• ArtificialAnt/GEArtificialAntEvaluator.cs (modified) (1 diff)
• ArtificialAnt/GEArtificialAntProblem.cs (modified) (1 diff)
• Mappers/GenotypeToPhenotypeMapper.cs (modified) (2 diffs)
• Mappers/PIGEMapper.cs (modified) (3 diffs)
• Symbolic/GESymbolicDataAnalysisEvaluator.cs (modified) (1 diff)
• Symbolic/GESymbolicDataAnalysisProblem.cs (modified) (6 diffs)
• Symbolic/GESymbolicRegressionSingleObjectiveEvaluator.cs (modified) (2 diffs)
• Symbolic/GESymbolicRegressionSingleObjectiveProblem.cs (modified) (3 diffs)
• Symbolic/IGESymbolicDataAnalysisProblem.cs (modified) (3 diffs)
• Symbolic/IGESymbolicRegressionSingleObjectiveEvaluator.cs (modified) (1 diff)

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/ArtificialAnt/GEArtificialAntEvaluator.cs

@@ -35 +35 @@
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {
-  [Item("GEArtificialAntEvaluator", "Evaluates an artificial ant solution, implemented in Grammatical Evolution.")]
+  [Item("GEArtificialAntEvaluator", "Evaluates an artificial ant solution for grammatical evolution.")]
   [StorableClass]
   public class GEArtificialAntEvaluator : SingleSuccessorOperator,

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/ArtificialAnt/GEArtificialAntProblem.cs

@@ -128 +128 @@
     #endregion
 
-    // BackwardsCompatibility3.3
-    #region Backwards compatible code, remove with 3.4
-    [Obsolete]
-    [Storable(Name = "operators")]
-    private IEnumerable<IOperator> oldOperators {
-      get { return null; }
-      set {
-        if (value != null && value.Any())
-          Operators.AddRange(value);
-      }
-    }
-    #endregion
-
     [StorableConstructor]
     private GEArtificialAntProblem(bool deserializing) : base(deserializing) { }

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Mappers/GenotypeToPhenotypeMapper.cs

@@ -34 +34 @@
 namespace HeuristicLab.Problems.GrammaticalEvolution {
   /// <summary>
-  /// GenotypeToPhenotypeMapper
+  /// Abstract base class for GenotypeToPhenotypeMappers
   /// </summary>
   public abstract class GenotypeToPhenotypeMapper : IntegerVectorOperator, IGenotypeToPhenotypeMapper {
@@ -66 +66 @@
 
       // no terminal node exists for the given parent node
-      if (possibleSymbolsList.Count() < 1) return null;
+      if (!possibleSymbolsList.Any()) return null;
 
       var newNode = possibleSymbolsList.SelectRandom(random).CreateTreeNode();

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Mappers/PIGEMapper.cs

@@ -71 +71 @@
   public class PIGEMapper : GenotypeToPhenotypeMapper {
 
+    private object nontVectorLocker = new object();
     private IntegerVector nontVector;
 
@@ -78 +79 @@
     }
 
-    private IntegerVector GetNontVector(IRandom random, IntMatrix bounds, int length) {
+    private static IntegerVector GetNontVector(IRandom random, IntMatrix bounds, int length) {
       IntegerVector v = new IntegerVector(length);
       v.Randomize(random, bounds);
@@ -114 +115 @@
       tree.Root = rootNode;
 
-      if (NontVector == null) {
-        NontVector = GetNontVector(random, bounds, length);
+      // Map can be called simultaniously on multiple threads
+      lock (nontVectorLocker) {
+        if (NontVector == null) {
+          NontVector = GetNontVector(random, bounds, length);
+        }
       }
 

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicDataAnalysisEvaluator.cs

@@ -129 +129 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (Parameters.ContainsKey(ApplyLinearScalingParameterName) && !(Parameters[ApplyLinearScalingParameterName] is LookupParameter<BoolValue>))
-        Parameters.Remove(ApplyLinearScalingParameterName);
-      if (!Parameters.ContainsKey(ApplyLinearScalingParameterName))
-        Parameters.Add(new LookupParameter<BoolValue>(ApplyLinearScalingParameterName, "Flag that indicates if the individual should be linearly scaled before evaluating."));
-      if (!Parameters.ContainsKey(ValidRowIndicatorParameterName))
-        Parameters.Add(new ValueLookupParameter<StringValue>(ValidRowIndicatorParameterName, "An indicator variable in the data set that specifies which rows should be evaluated (those for which the indicator <> 0) (optional)."));
-    }
-
-    protected IEnumerable<int> GenerateRowsToEvaluate() {
-      return GenerateRowsToEvaluate(RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value);
-    }
-
-    protected IEnumerable<int> GenerateRowsToEvaluate(double percentageOfRows) {
-      IEnumerable<int> rows;
-      int samplesStart = EvaluationPartitionParameter.ActualValue.Start;
-      int samplesEnd = EvaluationPartitionParameter.ActualValue.End;
-      int testPartitionStart = ProblemDataParameter.ActualValue.TestPartition.Start;
-      int testPartitionEnd = ProblemDataParameter.ActualValue.TestPartition.End;
-      if (samplesEnd < samplesStart) throw new ArgumentException("Start value is larger than end value.");
-
-      if (percentageOfRows.IsAlmost(1.0))
-        rows = Enumerable.Range(samplesStart, samplesEnd - samplesStart);
-      else {
-        int seed = RandomParameter.ActualValue.Next();
-        int count = (int)((samplesEnd - samplesStart) * percentageOfRows);
-        if (count == 0) count = 1;
-        rows = RandomEnumerable.SampleRandomNumbers(seed, samplesStart, samplesEnd, count);
-      }
-
-      rows = rows.Where(i => i < testPartitionStart || testPartitionEnd <= i);
-      if (ValidRowIndicatorParameter.ActualValue != null) {
-        string indicatorVar = ValidRowIndicatorParameter.ActualValue.Value;
-        var problemData = ProblemDataParameter.ActualValue;
-        var indicatorRow = problemData.Dataset.GetReadOnlyDoubleValues(indicatorVar);
-        rows = rows.Where(r => !indicatorRow[r].IsAlmost(0.0));
-      }
-      return rows;
-    }
-
-    [ThreadStatic]
-    private static double[] cache;
-    protected static void CalculateWithScaling(IEnumerable<double> targetValues, IEnumerable<double> estimatedValues,
-      double lowerEstimationLimit, double upperEstimationLimit,
-      IOnlineCalculator calculator, int maxRows) {
-      if (cache == null || cache.Length < maxRows) {
-        cache = new double[maxRows];
-      }
-
-      // calculate linear scaling
-      int i = 0;
-      var linearScalingCalculator = new OnlineLinearScalingParameterCalculator();
-      var targetValuesEnumerator = targetValues.GetEnumerator();
-      var estimatedValuesEnumerator = estimatedValues.GetEnumerator();
-      while (targetValuesEnumerator.MoveNext() & estimatedValuesEnumerator.MoveNext()) {
-        double target = targetValuesEnumerator.Current;
-        double estimated = estimatedValuesEnumerator.Current;
-        cache[i] = estimated;
-        if (!double.IsNaN(estimated) && !double.IsInfinity(estimated))
-          linearScalingCalculator.Add(estimated, target);
-        i++;
-      }
-      if (linearScalingCalculator.ErrorState == OnlineCalculatorError.None && (targetValuesEnumerator.MoveNext() || estimatedValuesEnumerator.MoveNext()))
-        throw new ArgumentException("Number of elements in target and estimated values enumeration do not match.");
-
-      double alpha = linearScalingCalculator.Alpha;
-      double beta = linearScalingCalculator.Beta;
-      if (linearScalingCalculator.ErrorState != OnlineCalculatorError.None) {
-        alpha = 0.0;
-        beta = 1.0;
-      }
-
-      //calculate the quality by using the passed online calculator
-      targetValuesEnumerator = targetValues.GetEnumerator();
-      var scaledBoundedEstimatedValuesEnumerator = Enumerable.Range(0, i).Select(x => cache[x] * beta + alpha)
-        .LimitToRange(lowerEstimationLimit, upperEstimationLimit).GetEnumerator();
-
-      while (targetValuesEnumerator.MoveNext() & scaledBoundedEstimatedValuesEnumerator.MoveNext()) {
-        calculator.Add(targetValuesEnumerator.Current, scaledBoundedEstimatedValuesEnumerator.Current);
-      }
     }
   }

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicDataAnalysisProblem.cs

@@ -61 +61 @@
     private const string BoundsParameterName = "Bounds";
     private const string GenotypeToPhenotypeMapperParameterName = "GenotypeToPhenotypeMapper";
-
     private const string ProblemDataParameterDescription = "";
     private const string SymbolicExpressionTreeGrammarParameterDescription = "The grammar that should be used for symbolic expression tree.";
-    private const string SymoblicExpressionTreeInterpreterParameterDescription = "The interpreter that should be used to evaluate the symbolic expression tree.";
-    private const string MaximumSymbolicExpressionTreeDepthParameterDescription = "Maximal depth of the symbolic expression. The minimum depth needed for the algorithm is 3 because two levels are reserved for the ProgramRoot and the Start symbol.";
+    private const string SymbolicExpressionTreeInterpreterParameterDescription = "The interpreter that should be used to evaluate the symbolic expression tree.";
     private const string MaximumSymbolicExpressionTreeLengthParameterDescription = "Maximal length of the symbolic expression.";
-    private const string MaximumFunctionDefinitionsParameterDescription = "Maximal number of automatically defined functions";
-    private const string MaximumFunctionArgumentsParameterDescription = "Maximal number of arguments of automatically defined functions.";
     private const string RelativeNumberOfEvaluatedSamplesParameterDescription = "The relative number of samples of the dataset partition, which should be randomly chosen for evaluation.";
     private const string FitnessCalculationPartitionParameterDescription = "The partition of the problem data training partition, that should be used to calculate the fitness of an individual.";
@@ -84 +80 @@
       get { return (IValueParameter<T>)Parameters[ProblemDataParameterName]; }
     }
-    public IValueParameter<GESymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter {
-      get { return (IValueParameter<GESymbolicExpressionGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
+    public IValueParameter<ISymbolicDataAnalysisGrammar> SymbolicExpressionTreeGrammarParameter {
+      get { return (IValueParameter<ISymbolicDataAnalysisGrammar>)Parameters[SymbolicExpressionTreeGrammarParameterName]; }
     }
     public IValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
@@ -125 +121 @@
     }
 
-    public GESymbolicExpressionGrammar SymbolicExpressionTreeGrammar {
+    public ISymbolicDataAnalysisGrammar SymbolicExpressionTreeGrammar {
       get { return SymbolicExpressionTreeGrammarParameter.Value; }
       set { SymbolicExpressionTreeGrammarParameter.Value = value; }
@@ -167 +163 @@
       : base(evaluator, solutionCreator) {
       Parameters.Add(new ValueParameter<T>(ProblemDataParameterName, ProblemDataParameterDescription, problemData));
-      Parameters.Add(new ValueParameter<GESymbolicExpressionGrammar>(SymbolicExpressionTreeGrammarParameterName, SymbolicExpressionTreeGrammarParameterDescription));
-      Parameters.Add(new ValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, SymoblicExpressionTreeInterpreterParameterDescription));
+      Parameters.Add(new ValueParameter<ISymbolicDataAnalysisGrammar>(SymbolicExpressionTreeGrammarParameterName, SymbolicExpressionTreeGrammarParameterDescription));
+      Parameters.Add(new ValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, SymbolicExpressionTreeInterpreterParameterDescription));
       Parameters.Add(new FixedValueParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, MaximumSymbolicExpressionTreeLengthParameterDescription));
       Parameters.Add(new FixedValueParameter<IntRange>(FitnessCalculationPartitionParameterName, FitnessCalculationPartitionParameterDescription));
@@ -200 +196 @@
     }
 
-    protected virtual void UpdateGrammar() {
+    private void UpdateGrammar() {
       DeregisterGrammarHandler();
       // create a new grammar instance with the correct allowed input variables
@@ -209 +205 @@
 
     private void InitializeOperators() {
-      Operators.AddRange(ApplicationManager.Manager.GetInstances<IIntegerVectorOperator>().OfType<IOperator>());
+      Operators.AddRange(ApplicationManager.Manager.GetInstances<IIntegerVectorOperator>());
       Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
       Operators.Add(new SymbolicDataAnalysisVariableFrequencyAnalyzer());

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicRegressionSingleObjectiveEvaluator.cs

@@ -44 +44 @@
       get { return (IValueParameter<ISymbolicRegressionSingleObjectiveEvaluator>)Parameters[EvaluatorParameterName]; }
     }
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (ILookupParameter<IRandom>)Parameters[RandomParameterName]; }
-    }
     public ILookupParameter<IntMatrix> BoundsParameter {
       get { return (ILookupParameter<IntMatrix>)Parameters[BoundsParameterName]; }
@@ -54 +51 @@
     }
 
-    private ISymbolicRegressionSingleObjectiveEvaluator Evaluator {
+    public ISymbolicRegressionSingleObjectiveEvaluator Evaluator {
       get { return EvaluatorParameter.Value; }
     }

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/GESymbolicRegressionSingleObjectiveProblem.cs

@@ -35 +35 @@
 namespace HeuristicLab.Problems.GrammaticalEvolution {
   [Item("Grammatical Evolution Symbolic Regression Problem (single objective)",
-        "Represents a single objective symbolic regression problem, implemented in Grammatical Evolution.")]
+        "Represents grammatical evolution for single objective symbolic regression problems.")]
   [StorableClass]
   [Creatable("Problems")]
@@ -72 +72 @@
 
       ApplyLinearScalingParameter.Value.Value = true;
-      Maximization.Value = true;
+      Maximization.Value = Evaluator.Maximization;
       MaximumSymbolicExpressionTreeLength.Value = InitialMaximumTreeLength;
 
@@ -86 +86 @@
 
     private void RegisterEventHandlers() {
-      // nothing to do
+      // when the ge evaluator itself changes
+      EvaluatorParameter.ValueChanged += (sender, args) => {
+        // register a new hander for the symbreg evaluator in the ge evaluator
+        // hacky because we the evaluator does not have an event for changes of the maximization property
+        EvaluatorParameter.Value.EvaluatorParameter.ValueChanged +=
+          (_, __) => Maximization.Value = Evaluator.Maximization;
+      };
+      EvaluatorParameter.Value.EvaluatorParameter.ValueChanged +=
+        (sender, args) => Maximization.Value = Evaluator.Maximization;
     }
 

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/IGESymbolicDataAnalysisProblem.cs

@@ -32 +32 @@
   public interface IGESymbolicDataAnalysisProblem : IDataAnalysisProblem, IHeuristicOptimizationProblem {
 
-    IValueParameter<GESymbolicExpressionGrammar> SymbolicExpressionTreeGrammarParameter { get; }
+    IValueParameter<ISymbolicDataAnalysisGrammar> SymbolicExpressionTreeGrammarParameter { get; }
     IValueParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter { get; }
     IFixedValueParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter { get; }
@@ -39 +39 @@
     IFixedValueParameter<IntRange> ValidationPartitionParameter { get; }
 
-    GESymbolicExpressionGrammar SymbolicExpressionTreeGrammar { get; set; }
+    ISymbolicDataAnalysisGrammar SymbolicExpressionTreeGrammar { get; set; }
     ISymbolicDataAnalysisExpressionTreeInterpreter SymbolicExpressionTreeInterpreter { get; set; }
     IntValue MaximumSymbolicExpressionTreeLength { get; }
@@ -48 +48 @@
 
   public interface IGESymbolicDataAnalysisSingleObjectiveProblem : IGESymbolicDataAnalysisProblem, ISingleObjectiveHeuristicOptimizationProblem { }
-  public interface IGESymbolicDataAnalysisMultiObjectiveProblem : IGESymbolicDataAnalysisProblem, IMultiObjectiveHeuristicOptimizationProblem { }
 }

branches/GrammaticalEvolution/HeuristicLab.Problems.GrammaticalEvolution/Symbolic/IGESymbolicRegressionSingleObjectiveEvaluator.cs

@@ -23 +23 @@
 #endregion
 
+using HeuristicLab.Core;
 using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
 
 namespace HeuristicLab.Problems.GrammaticalEvolution {
   public interface IGESymbolicRegressionSingleObjectiveEvaluator : IGESymbolicRegressionEvaluator,
                                                                    IGESymbolicDataAnalysisSingleObjectiveEvaluator<IRegressionProblemData> {
+    IValueParameter<ISymbolicRegressionSingleObjectiveEvaluator> EvaluatorParameter { get; }
   }
 }