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

Timestamp:

12/27/12 19:14:51 (11 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/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj (modified) (2 diffs)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LCSAdaptedGeneticAlgorithm.cs (added)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs (modified) (7 diffs)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs (modified) (6 diffs)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/Properties (modified) (1 prop)

branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/HeuristicLab.Algorithms.LearningClassifierSystems-3.3.csproj

@@ -96 +96 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="ActionSelection\ActionSelector.cs" />
-    <Compile Include="ActionSelection\MaxValueActionSelector.cs" />
-    <Compile Include="ActionSelection\RandomActionSelector.cs" />
+    <Compile Include="LCSAdaptedGeneticAlgorithm.cs" />
     <Compile Include="LearningClassifierSystem.cs" />
     <Compile Include="LearningClassifierSystemMainLoop.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Plugin.cs" />
-    <Compile Include="Selectors\IMatchSelector.cs" />
-    <Compile Include="Selectors\MatchSelector.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />
   </ItemGroup>
@@ -115 +111 @@
       <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
       <Name>HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
+      <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
+      <Name>HeuristicLab.Encodings.ConditionActionEncoding-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.ConditionActionClassification\3.3\HeuristicLab.Problems.ConditionActionClassification-3.3.csproj">
+      <Project>{EA51D441-F6A3-41E1-9993-A2488E93C222}</Project>
+      <Name>HeuristicLab.Problems.ConditionActionClassification-3.3</Name>
     </ProjectReference>
   </ItemGroup>

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

@@ -24 +24 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.CombinedIntegerVectorEncoding;
-using HeuristicLab.Operators;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Optimization;
-using HeuristicLab.Optimization.Operators;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -39 +37 @@
   [Creatable("Algorithms")]
   [StorableClass]
-  public class LearningClassifierSystem : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+  public sealed class LearningClassifierSystem : HeuristicOptimizationEngineAlgorithm, IStorableContent {
     public string Filename { get; set; }
 
     #region Problem Properties
     public override Type ProblemType {
-      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
-    }
-    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
-      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      get { return typeof(IConditionActionProblem); }
+    }
+    public new IConditionActionProblem Problem {
+      get { return (IConditionActionProblem)base.Problem; }
       set { base.Problem = value; }
     }
@@ -59 +57 @@
       get { return (ValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
     }
+    private ValueParameter<BoolValue> CreateInitialPopulationParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["CreateInitialPopulation"]; }
+    }
     private ValueParameter<IntValue> PopulationSizeParameter {
-      get { return (ValueParameter<IntValue>)Parameters["PopulationSize"]; }
-    }
-    //for test purpose
-    public ValueParameter<ICombinedIntegerVectorCreator> SolutionCreatorParameter {
-      get { return (ValueParameter<ICombinedIntegerVectorCreator>)Parameters["SolutionCreator"]; }
-    }
-    public ValueParameter<IntValue> Length {
-      get { return (ValueParameter<IntValue>)Parameters["Length"]; }
-    }
-    public ValueParameter<IntValue> ActionPartLength {
-      get { return (ValueParameter<IntValue>)Parameters["ActionPartLength"]; }
-    }
-    public ValueParameter<IntMatrix> Bounds {
-      get { return (ValueParameter<IntMatrix>)Parameters["Bounds"]; }
+      get { return (ValueParameter<IntValue>)Parameters["N"]; }
+    }
+    private ValueParameter<PercentValue> BetaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Beta"]; }
+    }
+    private ValueParameter<PercentValue> AlphaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Alpha"]; }
+    }
+    private ValueParameter<DoubleValue> ErrorZeroParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["ErrorZero"]; }
+    }
+    private ValueParameter<DoubleValue> PowerParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["v"]; }
+    }
+    private ValueParameter<PercentValue> GammaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Gamma"]; }
+    }
+    private ValueParameter<PercentValue> CrossoverProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["CrossoverProbability"]; }
+    }
+    private ValueParameter<PercentValue> MutationProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    private ValueParameter<IntValue> ThetaGAParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaGA"]; }
+    }
+    private ValueParameter<IntValue> ThetaDeletionParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaDeletion"]; }
+    }
+    private ValueParameter<IntValue> ThetaSubsumptionParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ThetaSubsumption"]; }
+    }
+    private ValueParameter<PercentValue> DeltaParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["Delta"]; }
+    }
+    private ValueParameter<PercentValue> ExplorationProbabilityParameter {
+      get { return (ValueParameter<PercentValue>)Parameters["ExplorationProbability"]; }
+    }
+    private ValueParameter<BoolValue> DoGASubsumptionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["DoGASubsumption"]; }
+    }
+    private ValueParameter<BoolValue> DoActionSetSubsumptionParameter {
+      get { return (ValueParameter<BoolValue>)Parameters["DoActionSetSubsumption"]; }
     }
     #endregion
@@ -86 +116 @@
       set { SetSeedRandomlyParameter.Value = value; }
     }
+    public BoolValue CreateInitialPopulation {
+      get { return CreateInitialPopulationParameter.Value; }
+      set { CreateInitialPopulationParameter.Value = value; }
+    }
     public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
     }
-
+    public PercentValue Beta {
+      get { return BetaParameter.Value; }
+      set { BetaParameter.Value = value; }
+    }
+    public PercentValue Alpha {
+      get { return AlphaParameter.Value; }
+      set { AlphaParameter.Value = value; }
+    }
+    public DoubleValue ErrorZero {
+      get { return ErrorZeroParameter.Value; }
+      set { ErrorZeroParameter.Value = value; }
+    }
+    public DoubleValue Power {
+      get { return PowerParameter.Value; }
+      set { PowerParameter.Value = value; }
+    }
+    public PercentValue Gamma {
+      get { return GammaParameter.Value; }
+      set { GammaParameter.Value = value; }
+    }
+    public PercentValue CrossoverProbability {
+      get { return CrossoverProbabilityParameter.Value; }
+      set { CrossoverProbabilityParameter.Value = value; }
+    }
+    public PercentValue MutationProbability {
+      get { return MutationProbabilityParameter.Value; }
+      set { MutationProbabilityParameter.Value = value; }
+    }
+    public IntValue ThetaGA {
+      get { return ThetaGAParameter.Value; }
+      set { ThetaGAParameter.Value = value; }
+    }
+    public IntValue ThetaDeletion {
+      get { return ThetaDeletionParameter.Value; }
+      set { ThetaDeletionParameter.Value = value; }
+    }
+    public IntValue ThetaSubsumption {
+      get { return ThetaSubsumptionParameter.Value; }
+      set { ThetaSubsumptionParameter.Value = value; }
+    }
+    public PercentValue Delta {
+      get { return DeltaParameter.Value; }
+      set { DeltaParameter.Value = value; }
+    }
+    public PercentValue ExplorationProbability {
+      get { return ExplorationProbabilityParameter.Value; }
+      set { ExplorationProbabilityParameter.Value = value; }
+    }
+    public BoolValue DoGASubsumption {
+      get { return DoGASubsumptionParameter.Value; }
+      set { DoGASubsumptionParameter.Value = value; }
+    }
+    public BoolValue DoActionSetSubsumption {
+      get { return DoActionSetSubsumptionParameter.Value; }
+      set { DoActionSetSubsumptionParameter.Value = value; }
+    }
+    private RandomCreator RandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+    public LearningClassifierSystemMainLoop MainLoop {
+      get { return (LearningClassifierSystemMainLoop)RandomCreator.Successor; }
+    }
     #endregion
 
@@ -98 +193 @@
       Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
       Parameters.Add(new ValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
-      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
-      //for test purpose
-      Parameters.Add(new ValueParameter<ICombinedIntegerVectorCreator>("SolutionCreator", "The operator to create a solution.", new UniformRandomCombinedIntegerVectorCreator()));
-      Parameters.Add(new ValueParameter<IntValue>("Length", "The operator to create a solution.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<IntValue>("ActionPartLength", "The operator to create a solution.", new IntValue(1)));
-      int[,] elements = new int[,] { { 0, 3 }, { 0, 3 }, { 0, 2 } };
-      Parameters.Add(new ValueParameter<IntMatrix>("Bounds", "The operator to create a solution.", new IntMatrix(elements)));
+      Parameters.Add(new ValueParameter<BoolValue>("CreateInitialPopulation", "Specifies if a population should be created at the beginning of the algorithm.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<IntValue>("N", "Max size of the population of solutions.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<PercentValue>("Beta", "Learning rate", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<PercentValue>("Alpha", "", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<DoubleValue>("ErrorZero", "The error below which classifiers are considered to have equal accuracy", new DoubleValue(10)));
+      Parameters.Add(new ValueParameter<DoubleValue>("v", "Power parameter", new DoubleValue(5)));
+      Parameters.Add(new ValueParameter<PercentValue>("Gamma", "Discount factor", new PercentValue(0.71)));
+      Parameters.Add(new ValueParameter<PercentValue>("CrossoverProbability", "Probability of crossover", new PercentValue(0.9)));
+      Parameters.Add(new ValueParameter<PercentValue>("MutationProbability", "Probability of mutation", new PercentValue(0.05)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaGA", "GA threshold. GA is applied in a set when the average time since the last GA is greater than ThetaGA.", new IntValue(25)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaDeletion", "Deletion threshold. If the experience of a classifier is greater than ThetaDeletion, its fitness may be considered in its probability of deletion.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<IntValue>("ThetaSubsumption", "Subsumption threshold. The experience of a classifier must be greater than TheatSubsumption to be able to subsume another classifier.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<PercentValue>("Delta", "Delta specifies the fraction of mean fitness in [P] below which the fitness of a classifier may be considered in its probability of deletion", new PercentValue(0.1)));
+      Parameters.Add(new ValueParameter<PercentValue>("ExplorationProbability", "Probability of selecting the action uniform randomly", new PercentValue(0.5)));
+      Parameters.Add(new ValueParameter<BoolValue>("DoGASubsumption", "Specifies if offsprings are tested for possible logical subsumption by parents.", new BoolValue(true)));
+      Parameters.Add(new ValueParameter<BoolValue>("DoActionSetSubsumption", "Specifies if action set is tested for subsuming classifiers.", new BoolValue(true)));
       #endregion
 
       #region Create operators
       RandomCreator randomCreator = new RandomCreator();
-      SolutionsCreator solutionsCreator = new SolutionsCreator();
-      UniformSubScopesProcessor uniformSubScopeProcessor = new UniformSubScopesProcessor();
-      UniformRandomizer uniformRandomizer = new UniformRandomizer();
+
       //ResultsCollector resultsCollector = new ResultsCollector();
       LearningClassifierSystemMainLoop mainLoop = new LearningClassifierSystemMainLoop();
@@ -120 +222 @@
       randomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
       randomCreator.SetSeedRandomlyParameter.Value = null;
-
-      SolutionCreatorParameter.Value.ActionPartLengthParameter.ActualName = ActionPartLength.Name;
-      SolutionCreatorParameter.Value.LengthParameter.ActualName = Length.Name;
-      SolutionCreatorParameter.Value.BoundsParameter.ActualName = Bounds.Name;
-
-      solutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
-      solutionsCreator.SolutionCreatorParameter.ActualName = SolutionCreatorParameter.Name;
-
-      uniformSubScopeProcessor.Parallel = new BoolValue(true);
-
-      uniformRandomizer.RandomParameter.ActualName = randomCreator.RandomParameter.ActualName;
-      uniformRandomizer.MinParameter.Value = new DoubleValue(0);
-      uniformRandomizer.MaxParameter.Value = new DoubleValue(100);
-      uniformRandomizer.ValueParameter.ActualName = "Fitness";
-
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = randomCreator;
-      randomCreator.Successor = solutionsCreator;
-      solutionsCreator.Successor = uniformSubScopeProcessor;
-      uniformSubScopeProcessor.Operator = uniformRandomizer;
-      uniformSubScopeProcessor.Successor = mainLoop;
+      randomCreator.Successor = mainLoop;
       #endregion
     }
-    protected LearningClassifierSystem(LearningClassifierSystem original, Cloner cloner)
+    private LearningClassifierSystem(LearningClassifierSystem original, Cloner cloner)
       : base(original, cloner) {
     }
@@ -153 +237 @@
     [StorableConstructor]
     private LearningClassifierSystem(bool deserializing) : base(deserializing) { }
+
+    protected override void OnProblemChanged() {
+      if (Problem != null) {
+        ParameterizeEvaluator(Problem.Evaluator);
+        MainLoop.SetCurrentProblem(Problem);
+      }
+      base.OnProblemChanged();
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      ParameterizeEvaluator(Problem.Evaluator);
+      MainLoop.SetCurrentProblem(Problem);
+      base.Problem_EvaluatorChanged(sender, e);
+    }
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      MainLoop.SetCurrentProblem(Problem);
+      base.Problem_SolutionCreatorChanged(sender, e);
+    }
+
+    private void ParameterizeEvaluator(IXCSEvaluator evaluator) {
+      evaluator.ActualTimeParameter.ActualName = "Iteration";
+      evaluator.BetaParameter.ActualName = BetaParameter.Name;
+      evaluator.AlphaParameter.ActualName = AlphaParameter.Name;
+      evaluator.PowerParameter.ActualName = PowerParameter.Name;
+      evaluator.ErrorZeroParameter.ActualName = ErrorZeroParameter.Name;
+    }
   }
 }

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() {