Changeset 9090

Timestamp:

12/29/12 20:15:48 (11 years ago)

Author:

sforsten

Message:

#1980: implemented covering and changed SinglePointCrossover for CombinedIntegerVectorEncoding

Location:

branches/LearningClassifierSystems

Files:

• HeuristicLab.Algorithms.LearningClassifierSystems/3.3 (modified) (1 prop)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs (modified) (7 diffs)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3 (modified) (1 prop)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs (modified) (3 diffs)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs (modified) (1 diff)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj (modified) (1 diff)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs (modified) (1 diff)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionInConditionManipulator.cs (added)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformSomePositionsManipulator.cs (deleted)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3 (modified) (1 prop)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs (modified) (3 diffs)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs (modified) (1 diff)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs (modified) (1 diff)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs (modified) (1 diff)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs (modified) (4 diffs)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/Properties (modified) (1 prop)
• HeuristicLab.Problems.ConditionActionClassification/3.3 (modified) (1 prop)
• HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs (modified) (7 diffs)
• HeuristicLab.Problems.ConditionActionClassification/3.3/Properties (modified) (1 prop)

branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj

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

@@ -54 +54 @@
     #region private properties
     private SolutionsCreator initialSolutionsCreator;
-    private SolutionsCreator coveringMechanism;
     private MatchConditionOperator matchConditionOperator;
     private PredictionArrayCalculator predictionArrayCalculator;
     private ActionSelector actionSelector;
+    private CoveringOperator covering;
 
     private Placeholder evaluator;
@@ -100 +100 @@
       ConditionalSelector conditionMatchSelector = new ConditionalSelector();
       ConditionalSelector actionMatchSelector = new ConditionalSelector();
-      SubScopesProcessor coveringSubScopesProcessor = new SubScopesProcessor();
-      SubScopesCounter matchsetCounter = new SubScopesCounter();
-      Comparator comparator = new Comparator();
-      ConditionalBranch coveringConditionalBranch = new ConditionalBranch();
+      SubScopesProcessor matchSetSubScopesProcessor = new SubScopesProcessor();
+      CountNumberOfUniqueActions countNumberOfUniqueActions = new CountNumberOfUniqueActions();
+      covering = new CoveringOperator();
       MergingReducer mergingReducer = new MergingReducer();
       MergingReducer mergingReducerWithSuccessor = new MergingReducer();
-      coveringMechanism = new SolutionsCreator();
       evaluator = new Placeholder();
       SubScopesProcessor actionSetSubScopesProcessor = new SubScopesProcessor();
@@ -137 +135 @@
       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 = matchsetCounter.ValueParameter.ActualName;
-      comparator.ResultParameter.ActualName = "Covering";
-      //more than zero solutions have to be selected
-      comparator.RightSideParameter.ActualName = "ZeroIntValue";
-
-      coveringConditionalBranch.Name = "Covering Branch";
-      coveringConditionalBranch.ConditionParameter.ActualName = "Covering";
+      countNumberOfUniqueActions.ClassifiersParameter.ActualName = "CombinedIntegerVector";
+
+      covering.ActionsInMatchSetParameter.ActualName = countNumberOfUniqueActions.UniqueActionsParameter.ActualName;
+      covering.ParallelParameter.Value.Value = true;
+      covering.RandomParameter.ActualName = "Random";
 
       matchActionSubScopesProcessor.Operator = matchActionOperator;
@@ -154 +145 @@
       matchActionOperator.MatchParameter.ActualName = "CombinedIntegerVector";
       matchActionOperator.TargetMatchParameter.ActualName = actionSelector.SelectedActionParameter.ActualName;
-
-      coveringMechanism.NumberOfSolutionsParameter.ActualName = "OneIntValue";
 
       predictionArrayCalculator.MatchParameter.ActualName = "CombinedIntegerVector";
@@ -211 +200 @@
       //adaptedGeneticAlgorithmMainLoop.Successor = conditionMatchSelector;
 
-      conditionMatchSelector.Successor = coveringSubScopesProcessor;
-      coveringSubScopesProcessor.Operators.Add(new EmptyOperator());
-      coveringSubScopesProcessor.Operators.Add(matchsetCounter);
-      coveringSubScopesProcessor.Successor = mergingReducerWithSuccessor;
-      matchsetCounter.Successor = comparator;
-      comparator.Successor = coveringConditionalBranch;
-      coveringConditionalBranch.TrueBranch = coveringMechanism;
-      coveringConditionalBranch.FalseBranch = new EmptyOperator();
-      coveringConditionalBranch.Successor = predictionArrayCalculator;
+      conditionMatchSelector.Successor = matchSetSubScopesProcessor;
+      matchSetSubScopesProcessor.Operators.Add(new EmptyOperator());
+      matchSetSubScopesProcessor.Operators.Add(countNumberOfUniqueActions);
+      matchSetSubScopesProcessor.Successor = mergingReducerWithSuccessor;
+      countNumberOfUniqueActions.Successor = covering;
+      covering.Successor = predictionArrayCalculator;
       predictionArrayCalculator.Successor = actionSelector;
       actionSelector.Successor = matchActionSubScopesProcessor;
@@ -253 +239 @@
       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;
 
@@ -266 +249 @@
       actionExecuter.OperatorParameter.ActualName = problem.ActionExecuterParameter.Name;
 
-      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.Name;
+      matchConditionOperator.TargetMatchParameter.ActualName = problem.ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+
+      covering.SolutionCreatorParameter.ActualName = problem.CoveringSolutionCreatorParameter.Name;
+      covering.EvaluatorParameter.ActualName = problem.EvaluatorParameter.Name;
+      covering.MinimalNumberOfUniqueActionsParameter.ActualName = problem.ThetaMinimalNumberOfActionsParameter.Name;
+      covering.PossibleActionsParameter.ActualName = problem.PossibleActionsParameter.Name;
 
       predictionArrayCalculator.PredictionParameter.ActualName = problem.Evaluator.PredictionParameter.ActualName;

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs

@@ -28 +28 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding.Covering {
+namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
   [Item("CombinedIntegerVectorCoveringCreator", "Description missing")]
   [StorableClass]
@@ -43 +43 @@
       get { return (IValueLookupParameter<IClassifier>)Parameters["CreatedClassifier"]; }
     }
-    public IValueLookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
-      get { return (IValueLookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
+    public ILookupParameter<PercentValue> ChangeSymbolProbabilityParameter {
+      get { return (ILookupParameter<PercentValue>)Parameters["ChangeSymbolProbability"]; }
     }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
     #endregion
 
@@ -61 +65 @@
       Parameters.Add(new LookupParameter<IClassifier>("Action"));
       Parameters.Add(new ValueLookupParameter<IClassifier>("CreatedClassifier"));
-      Parameters.Add(new ValueLookupParameter<PercentValue>("ChangeSymbolProbability"));
+      Parameters.Add(new LookupParameter<PercentValue>("ChangeSymbolProbability"));
+      Parameters.Add(new LookupParameter<IRandom>("Random"));
     }
 
     public override IOperation Apply() {
+      CombinedIntegerVector newCondition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition.Clone();
+
       CombinedIntegerVector condition = (CombinedIntegerVector)CoverClassifierParameter.ActualValue.Condition;
       CombinedIntegerVector action = (CombinedIntegerVector)ActionParameter.ActualValue.Action;
 
-      //TODO: manipulation
+      newCondition = UniformSomePositionInConditionManipulator.ManipulateCondition(RandomParameter.ActualValue, condition, newCondition, ChangeSymbolProbabilityParameter.ActualValue.Value);
 
-      CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(condition, condition.Bounds, action, action.Bounds);
+      CreatedClassifierParameter.ActualValue = new CombinedIntegerVector(newCondition, newCondition.Bounds, action, action.Bounds);
       return base.Apply();
     }

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs

@@ -38 +38 @@
     }
 
+    public static CombinedIntegerVector Apply(IRandom random, CombinedIntegerVector parent1, CombinedIntegerVector parent2) {
+      if (parent1.Length != parent2.Length && parent1.ActionLength != parent2.ActionLength && parent1.Bounds.Equals(parent2.Bounds))
+        throw new ArgumentException("SinglePointCrossover: The parents are of different length.");
+
+      int length = parent1.Length;
+      int actionLength = parent1.ActionLength;
+      int conditionLength = length - actionLength;
+      int[] result = new int[length];
+      int breakPoint = random.Next(1, conditionLength);
+
+      for (int i = 0; i < breakPoint; i++) {
+        result[i] = parent1[i];
+      }
+      for (int i = breakPoint; i < conditionLength; i++) {
+        result[i] = parent2[i];
+      }
+
+      CombinedIntegerVector actionParent = random.Next(2) == 1 ? parent1 : parent2;
+      for (int i = conditionLength; i < length; i++) {
+        result[i] = actionParent[i];
+      }
+
+      return new CombinedIntegerVector(result, actionLength, parent1.Bounds);
+    }
+
     protected override CombinedIntegerVector Cross(IRandom random, ItemArray<CombinedIntegerVector> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
-      return new CombinedIntegerVector(HeuristicLab.Encodings.IntegerVectorEncoding.SinglePointCrossover.Apply(random, parents[0], parents[1]), parents[0].ActionLength, parents[0].Bounds);
+      return Apply(random, parents[0], parents[1]);
     }
   }

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj

@@ -118 +118 @@
     </Compile>
     <Compile Include="Manipulator\UniformOnePositionInConditionManipulator.cs" />
-    <Compile Include="Manipulator\UniformSomePositionsManipulator.cs" />
+    <Compile Include="Manipulator\UniformSomePositionInConditionManipulator.cs" />
     <Compile Include="Plugin.cs" />
     <None Include="Properties\AssemblyInfo.cs.frame" />

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs

@@ -46 +46 @@
 
     public static CombinedIntegerVector Manipulate(CombinedIntegerVector parent, CombinedIntegerVector child, int index) {
-      int max = child.Bounds[index % child.Bounds.Rows, 1];
+      int max = child.Bounds[index % child.Bounds.Rows, 1] - 1;
       if (child[index].Equals(max)) {
         child[index] = parent[index];

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/CoveringOperator.cs

@@ -35 +35 @@
 
     #region Parameter Properties
-    public ILookupParameter<IClassifier> CoverClassifierParameter {
-      get { return (ILookupParameter<IClassifier>)Parameters["CoverClassifier"]; }
-    }
     public ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter {
       get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["ActionsInMatchSet"]; }
@@ -48 +45 @@
     }
     public IValueLookupParameter<IOperator> EvaluatorParameter {
-      get { return (IValueLookupParameter<IOperator>)Parameters[" Evaluator"]; }
+      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
     }
     public IValueLookupParameter<ICoveringSolutionCreator> SolutionCreatorParameter {
@@ -78 +75 @@
       : base() {
       Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
-      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("ActionsInMatchSet"));
-      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("PossibleActions"));
+      Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("ActionsInMatchSet"));
+      Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("PossibleActions"));
       Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
       Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator"));

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICovering.cs

@@ -26 +26 @@
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
   public interface ICovering : IStochasticOperator {
-    ILookupParameter<IClassifier> CoverClassifierParameter { get; }
     ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter { get; }
     ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter { get; }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/ICoveringSolutionCreator.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.ConditionActionEncoding {
-  public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+  public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable, IStochasticOperator {
     ILookupParameter<IClassifier> CoverClassifierParameter { get; }
     ILookupParameter<IClassifier> ActionParameter { get; }
 
     IValueLookupParameter<IClassifier> CreatedClassifierParameter { get; }
+    ILookupParameter<PercentValue> ChangeSymbolProbabilityParameter { get; }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblem.cs

@@ -31 +31 @@
     IParameter ClassifierFetcherParameter { get; }
     IClassifierFetcher ClassifierFetcher { get; }
+    IParameter ThetaMinimalNumberOfActionsParameter { get; }
 
     IParameter PossibleActionsParameter { get; }
     IItemSet<IClassifier> PossibleActions { get; }
 
+    ICoveringSolutionCreator CoveringSolutionCreator { get; }
+    IParameter CoveringSolutionCreatorParameter { get; }
+
     new IXCSEvaluator Evaluator { get; }
   }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/CountNumberOfUniqueActions.cs

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Parameters;
@@ -37 +38 @@
       get { return (IValueLookupParameter<IItemSet<IClassifier>>)Parameters["UniqueActions"]; }
     }
+    public IValueLookupParameter<IntValue> NumberOfUniqueActionsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["NumberOfUniqueActions"]; }
+    }
 
     [StorableConstructor]
@@ -50 +54 @@
       Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
       Parameters.Add(new ValueLookupParameter<IItemSet<IClassifier>>("UniqueActions"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfUniqueActions"));
     }
+
     public override IOperation Apply() {
       ItemSet<IClassifier> actions = new ItemSet<IClassifier>();
@@ -56 +62 @@
         actions.Add(classifier.Action);
       }
-      UniqueActionsParameter.Value = actions;
+      UniqueActionsParameter.ActualValue = actions;
+      NumberOfUniqueActionsParameter.ActualValue = new IntValue(actions.Count);
       return base.Apply();
     }

branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/Implementation/ConditionActionClassificationProblem.cs

@@ -45 +45 @@
       get { return (IValueParameter<ConditionActionClassificationProblemData>)Parameters["ProblemData"]; }
     }
+    public IValueParameter<ICoveringSolutionCreator> CoveringSolutionCreatorParameter {
+      get { return (IValueParameter<ICoveringSolutionCreator>)Parameters["CoveringSolutionCreator"]; }
+    }
+    public IFixedValueParameter<PercentValue> ChangeSymbolProbabilityInCoveringParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters["ChangeSymbolProbabilityInCovering"]; }
+    }
     public IFixedValueParameter<DoubleValue> PositiveRewardParameter {
       get { return (IFixedValueParameter<DoubleValue>)Parameters["PositiveReward"]; }
@@ -60 +66 @@
       get { return (IFixedValueParameter<DoubleValue>)Parameters["InitialFitness"]; }
     }
-    public IFixedValueParameter<IItemSet<IClassifier>> PossibleActionsParameter {
-      get { return (IFixedValueParameter<IItemSet<IClassifier>>)Parameters["PossibleActions"]; }
-    }
-    private IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
+    public IFixedValueParameter<ItemSet<IClassifier>> PossibleActionsParameter {
+      get { return (IFixedValueParameter<ItemSet<IClassifier>>)Parameters["PossibleActions"]; }
+    }
+    public IFixedValueParameter<IntValue> ThetaMinimalNumberOfActionsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters["ThetaMinimalNumberOfActions"]; }
     }
@@ -94 +100 @@
       get { return PossibleActions; }
     }
-    public IItemSet<IClassifier> PossibleActions {
+    public ItemSet<IClassifier> PossibleActions {
       get { return PossibleActionsParameter.Value; }
     }
@@ -115 +121 @@
     private IntValue ThetaMinimalNumberOfActions {
       get { return ThetaMinimalNumberOfActionsParameter.Value; }
+    }
+    IParameter IConditionActionProblem.ThetaMinimalNumberOfActionsParameter {
+      get { return ThetaMinimalNumberOfActionsParameter; }
+    }
+    public ICoveringSolutionCreator CoveringSolutionCreator {
+      get { return CoveringSolutionCreatorParameter.Value; }
+    }
+    IParameter IConditionActionProblem.CoveringSolutionCreatorParameter {
+      get { return CoveringSolutionCreatorParameter; }
     }
     #endregion
@@ -130 +145 @@
       this(new ConditionActionClassificationProblemData(new Dataset(ConditionActionClassificationProblemData.defaultVariableNames, ConditionActionClassificationProblemData.defaultData),
         ConditionActionClassificationProblemData.defaultVariableNames.Take(ConditionActionClassificationProblemData.defaultVariableNames.Length - 1), ConditionActionClassificationProblemData.defaultVariableNames.Last().ToEnumerable()),
-        new XCSEvaluator(), new UniformRandomCombinedIntegerVectorCreator()) {
-    }
-
-    public ConditionActionClassificationProblem(ConditionActionClassificationProblemData problemData, XCSEvaluator evaluator, UniformRandomCombinedIntegerVectorCreator solutionCreator)
+        new XCSEvaluator(), new UniformRandomCombinedIntegerVectorCreator(), new CombinedIntegerVectorCoveringCreator()) {
+    }
+
+    public ConditionActionClassificationProblem(ConditionActionClassificationProblemData problemData, XCSEvaluator evaluator, UniformRandomCombinedIntegerVectorCreator solutionCreator, ICoveringSolutionCreator coveringSolutionCreator)
       : base(evaluator, solutionCreator) {
       Parameters.Add(new FixedValueParameter<IntValue>("Length", "The operator to create a solution.", new IntValue(7)));
@@ -151 +166 @@
       Parameters.Add(new FixedValueParameter<IntValue>("ThetaMinimalNumberOfActions", "Minimal number of actions, which have to be present in the match set, or else covering will occure."));
 
+      Parameters.Add(new ValueParameter<ICoveringSolutionCreator>("CoveringSolutionCreator", "", coveringSolutionCreator));
+      Parameters.Add(new FixedValueParameter<PercentValue>("ChangeSymbolProbabilityInCovering", "", new PercentValue(0.5)));
+
       Evaluator.InitialErrorParameter.ActualName = "InitialError";
       Evaluator.InitialFitnessParameter.ActualName = "InitialFitness";
@@ -158 +176 @@
       SolutionCreator.LengthParameter.ActualName = LengthParameter.Name;
       SolutionCreator.BoundsParameter.ActualName = BoundsParameter.Name;
+
+      coveringSolutionCreator.ChangeSymbolProbabilityParameter.ActualName = ChangeSymbolProbabilityInCoveringParameter.Name;
+      coveringSolutionCreator.CoverClassifierParameter.ActualName = ClassifierFetcher.CurrentClassifierToMatchParameter.ActualName;
+      coveringSolutionCreator.CreatedClassifierParameter.ActualName = "CombinedIntegerVector";
 
       ClassifierFetcher.ActionPartLengthParameter.ActualName = ActionPartLengthParameter.Name;

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj

@@ -1 +1 @@
 *.user
 Plugin.cs
+obj