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

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/LearningClassifierSystem.cs (modified) (7 diffs)

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;
+    }
   }
 }