Changeset 9089 for branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs

Timestamp:

12/27/12 19:14:51 (12 years ago)

Author:

sforsten

Message:

#1980:

• added ConditionActionClassificationProblem
• added ConditionActionEncoding
• added Manipulators, Crossovers and an LCSAdaptedGeneticAlgorithm
• changed LearningClassifierSystemMainLoop

Location:

branches/LearningClassifierSystems

Files:

• . (modified) (1 prop)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3 (modified) (1 prop)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs (modified) (6 diffs)

branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs

@@ -20 +20 @@
 #endregion
 
-using HeuristicLab.Algorithms.GeneticAlgorithm;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Operators;
@@ -31 +30 @@
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Random;
 using HeuristicLab.Selection;
 
@@ -40 +38 @@
   [Item("LearningClassifierSystemMainLoop", "An operator which represents the main loop of a learning classifier system.")]
   [StorableClass]
-  public class LearningClassifierSystemMainLoop : AlgorithmOperator {
+  public sealed class LearningClassifierSystemMainLoop : AlgorithmOperator {
 
     #region Parameter Properties
@@ -54 +52 @@
     #endregion
 
-    #region Properties
-    public ISelector Selector {
-      get { return SelectorParameter.Value; }
-      set { SelectorParameter.Value = value; }
-    }
-    public ICrossover Crossover {
-      get { return CrossoverParameter.Value; }
-      set { CrossoverParameter.Value = value; }
-    }
-    public IManipulator Mutator {
-      get { return MutatorParameter.Value; }
-      set { MutatorParameter.Value = value; }
-    }
+    #region private properties
+    private SolutionsCreator initialSolutionsCreator;
+    private SolutionsCreator coveringMechanism;
+    private MatchConditionOperator matchConditionOperator;
+    private PredictionArrayCalculator predictionArrayCalculator;
+    private ActionSelector actionSelector;
+
+    private Placeholder evaluator;
+    private Placeholder actionExecuter;
+    private Placeholder classifierFetcher;
     #endregion
 
     [StorableConstructor]
     private LearningClassifierSystemMainLoop(bool deserializing) : base(deserializing) { }
-    protected LearningClassifierSystemMainLoop(LearningClassifierSystemMainLoop original, Cloner cloner)
+    private LearningClassifierSystemMainLoop(LearningClassifierSystemMainLoop original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -85 +80 @@
       #region Create parameters
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction.", new ItemSet<ISelector>() { new ProportionalSelector() }, new ProportionalSelector()));
-      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions.", new ItemSet<ICrossover>() { new SinglePointCrossover() }, new SinglePointCrossover()));
-      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, new UniformOnePositionManipulator()));
-      //for test purposes
-      int[] numbers = new int[3] { 1, 1, 1 };
-      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 2 } };
-      Parameters.Add(new ValueLookupParameter<CombinedIntegerVector>("TestTarget", "Target for test", new CombinedIntegerVector(numbers, 1, elements)));
-
+      Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions.", new ItemSet<ICrossover>() { new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover() }, new HeuristicLab.Encodings.CombinedIntegerVectorEncoding.SinglePointCrossover()));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
+      UniformOnePositionManipulator test = new UniformOnePositionManipulator();
+      test.IntegerVectorParameter.ActualName = "CombinedIntegerVector";
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions.", new ItemSet<IManipulator>() { new UniformOnePositionManipulator() }, test));
       #endregion
 
       #region Create operators
       VariableCreator variableCreator = new VariableCreator();
-      MatchSelector conditionMatchSelector = new MatchSelector();
-      MatchSelector actionMatchSelector = new MatchSelector();
+      ConditionalBranch initialPopulationConditionalBranch = new ConditionalBranch();
+      initialSolutionsCreator = new SolutionsCreator();
+      IntCounter iterationCounter = new IntCounter();
+      UniformSubScopesProcessor matchCondtionSubScopesProcessor = new UniformSubScopesProcessor();
+      matchConditionOperator = new MatchConditionOperator();
+      predictionArrayCalculator = new PredictionArrayCalculator();
+      actionSelector = new ActionSelector();
+      UniformSubScopesProcessor matchActionSubScopesProcessor = new UniformSubScopesProcessor();
+      MatchActionOperator matchActionOperator = new MatchActionOperator();
+      ConditionalSelector conditionMatchSelector = new ConditionalSelector();
+      ConditionalSelector actionMatchSelector = new ConditionalSelector();
       SubScopesProcessor coveringSubScopesProcessor = new SubScopesProcessor();
-      SubScopesRemover subScopesRemover = new SubScopesRemover();
+      SubScopesCounter matchsetCounter = new SubScopesCounter();
       Comparator comparator = new Comparator();
-      ConditionalBranch conditionalBranch = new ConditionalBranch();
+      ConditionalBranch coveringConditionalBranch = new ConditionalBranch();
       MergingReducer mergingReducer = new MergingReducer();
-      SolutionsCreator coveringMechanism = new SolutionsCreator();
-      SubScopesProcessor actionSelectionSubScopesProcessor = new SubScopesProcessor();
-      MaxValueActionSelector maxValueActionSelection = new MaxValueActionSelector();
-      GeneticAlgorithmMainLoop geneticAlgorithmMainLoop = new GeneticAlgorithmMainLoop();
-
-      UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
-      UniformRandomizer uniformRandomizer = new UniformRandomizer();
+      MergingReducer mergingReducerWithSuccessor = new MergingReducer();
+      coveringMechanism = new SolutionsCreator();
+      evaluator = new Placeholder();
+      SubScopesProcessor actionSetSubScopesProcessor = new SubScopesProcessor();
+      DataReducer actionSetSizeDataReducer = new DataReducer();
+      UniformSubScopesProcessor accuracySubScopesProcessor = new UniformSubScopesProcessor();
+      CalculateAccuracy calculateAccuracy = new CalculateAccuracy();
+      SumAccuracy sumAccuracy = new SumAccuracy();
+      UniformSubScopesProcessor updateParametersSubScopesProcessor = new UniformSubScopesProcessor();
+      LCSAdaptedGeneticAlgorithm adaptedGeneticAlgorithmMainLoop = new LCSAdaptedGeneticAlgorithm();
+
+      classifierFetcher = new Placeholder();
+      actionExecuter = new Placeholder();
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("ZeroIntValue", new IntValue(0)));
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OneIntValue", new IntValue(1)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iteration", new IntValue(0)));
+
+      initialPopulationConditionalBranch.ConditionParameter.ActualName = "CreateInitialPopulation";
+
+      initialSolutionsCreator.NumberOfSolutionsParameter.ActualName = "N";
+
+      iterationCounter.ValueParameter.ActualName = "Iteration";
+      iterationCounter.IncrementParameter.ActualName = "OneIntValue";
+
+      matchCondtionSubScopesProcessor.Operator = matchConditionOperator;
+
+      matchConditionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
 
       conditionMatchSelector.CopySelected = new BoolValue(false);
-      conditionMatchSelector.MatchCondition = new BoolValue(true);
-      //this has to be set differently
-      conditionMatchSelector.MatchParameter.ActualName = "CombinedIntegerVector";
-      conditionMatchSelector.TargetMatchParameter.ActualName = "TestTarget";
+      conditionMatchSelector.ConditionParameter.ActualName = "MatchCondition";
+
+      matchsetCounter.Name = "Count number of rules in match set";
+      matchsetCounter.AccumulateParameter.Value = new BoolValue(false);
+      matchsetCounter.ValueParameter.ActualName = "MatchSetCount";
 
       comparator.Comparison = new Comparison(ComparisonType.LessOrEqual);
-      comparator.LeftSideParameter.ActualName = conditionMatchSelector.NumberOfSelectedSubScopesParameter.ActualName;
+      comparator.LeftSideParameter.ActualName = matchsetCounter.ValueParameter.ActualName;
       comparator.ResultParameter.ActualName = "Covering";
       //more than zero solutions have to be selected
       comparator.RightSideParameter.ActualName = "ZeroIntValue";
 
-      conditionalBranch.ConditionParameter.ActualName = "Covering";
-
-      subScopesRemover.SubScopeIndexParameter.ActualName = "OneIntValue";
-      subScopesRemover.RemoveAllSubScopes = false;
+      coveringConditionalBranch.Name = "Covering Branch";
+      coveringConditionalBranch.ConditionParameter.ActualName = "Covering";
+
+      matchActionSubScopesProcessor.Operator = matchActionOperator;
+
+      matchActionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
+      matchActionOperator.TargetMatchParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
 
       coveringMechanism.NumberOfSolutionsParameter.ActualName = "OneIntValue";
-      coveringMechanism.SolutionCreatorParameter.ActualName = "SolutionCreator";
-
-      maxValueActionSelection.ValueParameter.ActualName = "Fitness";
-      maxValueActionSelection.MatchParameter.ActualName = "CombinedIntegerVector";
+
+      predictionArrayCalculator.MatchParameter.ActualName = "CombinedIntegerVector";
+
+      actionSelector.PredictionArrayParameter.ActualName = predictionArrayCalculator.PredictionArrayParameter.Name;
+      actionSelector.RandomParameter.ActualName = "Random";
+      actionSelector.ExplorationProbabilityParameter.ActualName = "ExplorationProbability";
 
       actionMatchSelector.CopySelected = new BoolValue(false);
-      actionMatchSelector.MatchCondition = new BoolValue(false);
-      //this has to be set differently
-      actionMatchSelector.MatchParameter.ActualName = "CombinedIntegerVector";
-      actionMatchSelector.TargetMatchParameter.ActualName = maxValueActionSelection.SelectedActionParameter.ActualName;
+      actionMatchSelector.ConditionParameter.ActualName = "MatchAction";
 
       SelectorParameter.Value.CopySelected = new BoolValue(true);
       SelectorParameter.Value.NumberOfSelectedSubScopesParameter.Value = new IntValue(200);
 
-      geneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
-      geneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
-      geneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
-      geneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
-      geneticAlgorithmMainLoop.ElitesParameter.ActualName = "OneIntValue";
-      geneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
-      geneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
+      evaluator.Name = "Evaluator";
+
+      classifierFetcher.Name = "ClassifierFetcher";
+
+      actionExecuter.Name = "ActionExecuter";
+
+      actionSetSizeDataReducer.TargetParameter.ActualName = "CurrentActionSetSize";
+      actionSetSizeDataReducer.ParameterToReduce.ActualName = "Numerosity";
+      actionSetSizeDataReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      actionSetSizeDataReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Assign);
+
+      calculateAccuracy.AlphaParameter.ActualName = "Alpha";
+      calculateAccuracy.ErrorParameter.ActualName = "Error";
+      calculateAccuracy.ErrorZeroParameter.ActualName = "ErrorZero";
+      calculateAccuracy.PowerParameter.ActualName = "v";
+
+      sumAccuracy.AccuracyParameter.ActualName = calculateAccuracy.AccuracyParameter.ActualName;
+      sumAccuracy.NumerosityParameter.ActualName = "Numerosity";
+
+      adaptedGeneticAlgorithmMainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
+      adaptedGeneticAlgorithmMainLoop.RandomParameter.ActualName = "Random";
+      adaptedGeneticAlgorithmMainLoop.MaximumGenerationsParameter.ActualName = "ZeroIntValue";
+      adaptedGeneticAlgorithmMainLoop.QualityParameter.ActualName = "Fitness";
       //needed?
-      geneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
-      geneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
-
-      uniformSubScopeProcessor.Parallel = new BoolValue(true);
-
-      uniformRandomizer.RandomParameter.ActualName = "Random";
-      uniformRandomizer.MinParameter.Value = new DoubleValue(0);
-      uniformRandomizer.MaxParameter.Value = new DoubleValue(100);
-      uniformRandomizer.ValueParameter.ActualName = "Fitness";
-
-      //ParameterizeSelectors();
+      adaptedGeneticAlgorithmMainLoop.MutationProbabilityParameter.Value = new PercentValue(10);
+      adaptedGeneticAlgorithmMainLoop.MaximizationParameter.Value = new BoolValue(true);
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = variableCreator;
-      variableCreator.Successor = conditionMatchSelector;
-      //variableCreator.Successor = geneticAlgorithmMainLoop;
-      //geneticAlgorithmMainLoop.Successor = conditionMatchSelector;
-      conditionMatchSelector.Successor = comparator;
-      comparator.Successor = conditionalBranch;
-      conditionalBranch.TrueBranch = coveringSubScopesProcessor;
-      conditionalBranch.FalseBranch = actionSelectionSubScopesProcessor;
-      conditionalBranch.Successor = subScopesRemover;
-      coveringMechanism.Successor = uniformSubScopeProcessor;
-      uniformSubScopeProcessor.Operator = uniformRandomizer;
+
+      variableCreator.Successor = initialPopulationConditionalBranch;
+      initialPopulationConditionalBranch.TrueBranch = initialSolutionsCreator;
+      initialPopulationConditionalBranch.FalseBranch = new EmptyOperator();
+      initialPopulationConditionalBranch.Successor = classifierFetcher;
+      classifierFetcher.Successor = matchCondtionSubScopesProcessor;
+      matchCondtionSubScopesProcessor.Successor = conditionMatchSelector;
+      //variableCreator.Successor = adaptedGeneticAlgorithmMainLoop;
+      //adaptedGeneticAlgorithmMainLoop.Successor = conditionMatchSelector;
+
+      conditionMatchSelector.Successor = coveringSubScopesProcessor;
       coveringSubScopesProcessor.Operators.Add(new EmptyOperator());
-      coveringSubScopesProcessor.Operators.Add(coveringMechanism);
-      coveringSubScopesProcessor.Successor = actionSelectionSubScopesProcessor;
-      actionSelectionSubScopesProcessor.Operators.Add(new EmptyOperator());
-      actionSelectionSubScopesProcessor.Operators.Add(maxValueActionSelection);
-      maxValueActionSelection.Successor = actionMatchSelector;
-      subScopesRemover.Successor = mergingReducer;
-      mergingReducer.Successor = conditionMatchSelector;
-      //mergingReducer.Successor = geneticAlgorithmMainLoop;
+      coveringSubScopesProcessor.Operators.Add(matchsetCounter);
+      coveringSubScopesProcessor.Successor = mergingReducerWithSuccessor;
+      matchsetCounter.Successor = comparator;
+      comparator.Successor = coveringConditionalBranch;
+      coveringConditionalBranch.TrueBranch = coveringMechanism;
+      coveringConditionalBranch.FalseBranch = new EmptyOperator();
+      coveringConditionalBranch.Successor = predictionArrayCalculator;
+      predictionArrayCalculator.Successor = actionSelector;
+      actionSelector.Successor = matchActionSubScopesProcessor;
+      matchActionSubScopesProcessor.Successor = actionMatchSelector;
+      actionMatchSelector.Successor = actionExecuter;
+      actionExecuter.Successor = actionSetSubScopesProcessor;
+      actionSetSubScopesProcessor.Operators.Add(new EmptyOperator());
+      actionSetSubScopesProcessor.Operators.Add(actionSetSizeDataReducer);
+      actionSetSizeDataReducer.Successor = accuracySubScopesProcessor;
+      accuracySubScopesProcessor.Operator = calculateAccuracy;
+      accuracySubScopesProcessor.Successor = sumAccuracy;
+      sumAccuracy.Successor = updateParametersSubScopesProcessor;
+      updateParametersSubScopesProcessor.Operator = evaluator;
+
+      actionSetSubScopesProcessor.Successor = mergingReducer;
+
+      mergingReducerWithSuccessor.Successor = iterationCounter;
+      iterationCounter.Successor = classifierFetcher;
+      //mergingReducer.Successor = adaptedGeneticAlgorithmMainLoop;
       #endregion
     }
@@ -197 +247 @@
         stochasticOp.RandomParameter.Hidden = true;
       }
+    }
+
+    internal void SetCurrentProblem(IConditionActionProblem problem) {
+      initialSolutionsCreator.SolutionCreatorParameter.ActualName = problem.SolutionCreatorParameter.Name;
+      initialSolutionsCreator.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
+
+      coveringMechanism.SolutionCreatorParameter.ActualName = problem.SolutionCreatorParameter.Name;
+      coveringMechanism.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
+
+      problem.ActionExecuter.SelectedActionParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
+
+      problem.ClassifierFetcher.IterationParameter.ActualName = "Iteration";
+
+      evaluator.OperatorParameter.ActualName = problem.EvaluatorParameter.Name;
+
+      classifierFetcher.OperatorParameter.ActualName = problem.ClassifierFetcherParameter.Name;
+
+      actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
+
+      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.Name;
+
+      predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;
+      predictionArrayCalculator.FitnessParameter.ActualName = problem.Evaluator.FitnessParameter.ActualName;
     }
     //private void ParameterizeSelectors() {