Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
01/28/13 17:54:46 (12 years ago)
Author:
sforsten
Message:

#1980:

  • added necessary interface ICondition, IAction, IInput
  • removed not used class MatchSelector and interface IMatchSelector
  • added constructors to ItemDictionary
  • added new encoding
Location:
branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3
Files:
2 deleted
26 edited

Legend:

Unmodified
Added
Removed

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/ActionSelector.cs

    r9089 r9194  
    3737      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
    3838    }
    39     public IValueLookupParameter<IClassifier> SelectedActionParameter {
    40       get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
     39    public IValueLookupParameter<IAction> SelectedActionParameter {
     40      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
    4141    }
    42     public ILookupParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
    43       get { return (ILookupParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
     42    public ILookupParameter<IItemDictionary<IAction, DoubleValue>> PredictionArrayParameter {
     43      get { return (ILookupParameter<IItemDictionary<IAction, DoubleValue>>)Parameters["PredictionArray"]; }
    4444    }
    4545    public ILookupParameter<PercentValue> ExplorationProbabilityParameter {
    … …  
    5555      : base() {
    5656      Parameters.Add(new LookupParameter<IRandom>("Random"));
    57       Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction", "Action, which has been selected."));
    58       Parameters.Add(new LookupParameter<IItemDictionary<IClassifier, DoubleValue>>("PredictionArray"));
     57      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction", "Action, which has been selected."));
     58      Parameters.Add(new LookupParameter<IItemDictionary<IAction, DoubleValue>>("PredictionArray"));
    5959      Parameters.Add(new LookupParameter<PercentValue>("ExplorationProbability"));
    6060    }

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/MaxValueActionSelector.cs

    r9089 r9194  
    3636      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["ValueParameter"]; }
    3737    }
     38    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     39      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     40    }
    3841
    3942    [StorableConstructor]
    … …  
    4346      : base() {
    4447      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ValueParameter", "DoubleValue which will be summed up."));
     48      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    4549    }
    4650    public override IDeepCloneable Clone(Cloner cloner) {
    … …  
    4852    }
    4953
    50     protected override IClassifier SelectAction(List<IScope> scopes) {
    51       Dictionary<IClassifier, double> actionSet = new Dictionary<IClassifier, double>();
     54    protected override IAction SelectAction(List<IScope> scopes) {
     55      Dictionary<IAction, double> actionSet = new Dictionary<IAction, double>(ClassifierComparerParameter.ActualValue);
    5256      for (int i = 0; i < MatchParameter.ActualValue.Length; i++) {
    5357        var action = MatchParameter.ActualValue[i].Action;

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/OldActionSelector.cs

    r9089 r9194  
    3838      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["MatchParameter"]; }
    3939    }
    40     public IValueLookupParameter<IClassifier> SelectedActionParameter {
    41       get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
     40    public IValueLookupParameter<IAction> SelectedActionParameter {
     41      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
    4242    }
    4343
    … …  
    5454      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
    5555      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
    56       Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction", "Action, which has been selected."));
     56      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction", "Action, which has been selected."));
    5757    }
    5858
    … …  
    6363    }
    6464
    65     protected abstract IClassifier SelectAction(List<IScope> scopes);
     65    protected abstract IAction SelectAction(List<IScope> scopes);
    6666  }
    6767}

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/ActionSelection/RandomActionSelector.cs

    r9089 r9194  
    4545    }
    4646
    47     protected override IClassifier SelectAction(List<IScope> scopes) {
     47    protected override IAction SelectAction(List<IScope> scopes) {
    4848      IRandom random = RandomParameter.ActualValue;
    4949      int index = random.Next(MatchParameter.ActualValue.Length);

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Analyzer/XCSSolutionAnalyzer.cs

    r9175 r9194  
    6666      get { return (ValueLookupParameter<ResultCollection>)Parameters["Results"]; }
    6767    }
     68    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     69      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     70    }
    6871
    6972    public ResultCollection Results { get { return ResultsParameter.ActualValue; } }
    … …  
    8487      Parameters.Add(new LookupParameter<IConditionActionProblemData>("ProblemData", ""));
    8588      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the solution should be stored."));
     89      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    8690    }
    8791
    … …  
    105109
    106110      XCSModel xcsModel = new XCSModel(xcsClassifiers);
    107 
     111      xcsModel.ClassifierComparer = ClassifierComparerParameter.ActualValue;
    108112      UseCurrentXCSSolution(xcsModel.CreateConditionActionSolution(problemData));
    109113      return base.Apply();

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

    r9110 r9194  
    3535
    3636    #region Parameter Properties
    37     public ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter {
    38       get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["ActionsInMatchSet"]; }
     37    public ILookupParameter<IItemSet<IAction>> ActionsInMatchSetParameter {
     38      get { return (ILookupParameter<IItemSet<IAction>>)Parameters["ActionsInMatchSet"]; }
    3939    }
    40     public ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter {
    41       get { return (ILookupParameter<IItemSet<IClassifier>>)Parameters["PossibleActions"]; }
     40    public ILookupParameter<IItemSet<IAction>> PossibleActionsParameter {
     41      get { return (ILookupParameter<IItemSet<IAction>>)Parameters["PossibleActions"]; }
    4242    }
    4343    public ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter {
    … …  
    7777    public CoveringOperator()
    7878      : base() {
    79       Parameters.Add(new LookupParameter<IClassifier>("CoverClassifier"));
    80       Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("ActionsInMatchSet"));
    81       Parameters.Add(new LookupParameter<IItemSet<IClassifier>>("PossibleActions"));
     79      Parameters.Add(new LookupParameter<IItemSet<IAction>>("ActionsInMatchSet"));
     80      Parameters.Add(new LookupParameter<IItemSet<IAction>>("PossibleActions"));
    8281      Parameters.Add(new LookupParameter<IntValue>("MinimalNumberOfUniqueActions"));
    8382      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator"));
    … …  
    9594      bool parallel = ParallelParameter.ActualValue.Value;
    9695
    97       IItemSet<IClassifier> clone = (IItemSet<IClassifier>)PossibleActionsParameter.ActualValue.Clone();
     96      IItemSet<IAction> clone = (IItemSet<IAction>)PossibleActionsParameter.ActualValue.Clone();
    9897      clone.ExceptWith(ActionsInMatchSetParameter.ActualValue);
    9998
    … …  
    116115          VariableCreator variableCreator = new VariableCreator();
    117116          int pos = RandomParameter.ActualValue.Next(clone.Count);
    118           IClassifier action = clone.ElementAt(pos);
     117          IAction action = clone.ElementAt(pos);
    119118          clone.Remove(action);
    120           variableCreator.CollectedValues.Add(new ValueParameter<IClassifier>("Action", action));
     119          variableCreator.CollectedValues.Add(new ValueParameter<IAction>("Action", action));
    121120          variableCreation.Add(ExecutionContext.CreateOperation(variableCreator, CurrentScope.SubScopes[current + i]));
    122121          creation.Add(ExecutionContext.CreateOperation(creator, CurrentScope.SubScopes[current + i]));

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Covering/DoDeletionBeforeCovering.cs

    r9110 r9194  
    5555      get { return (IValueLookupParameter<IntValue>)Parameters["NumberToDelete"]; }
    5656    }
     57    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     58      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     59    }
    5760    #endregion
    5861
    … …  
    7174      Parameters.Add(new ValueLookupParameter<BoolValue>("DoDeletion"));
    7275      Parameters.Add(new ValueLookupParameter<IntValue>("NumberToDelete"));
     76      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    7377    }
    7478    public override IDeepCloneable Clone(Cloner cloner) {
    … …  
    7781
    7882    public override IOperation Apply() {
    79       IItemSet<IClassifier> uniqueActions = new ItemSet<IClassifier>();
     83      IItemSet<IAction> uniqueActions = new ItemSet<IAction>(ClassifierComparerParameter.ActualValue);
    8084      var classifiers = ClassifiersParameter.ActualValue;
    8185      var matchcondition = MatchConditionParameter.ActualValue;

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

    r9105 r9194  
    2626namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2727  public interface ICovering : IStochasticOperator {
    28     ILookupParameter<IItemSet<IClassifier>> ActionsInMatchSetParameter { get; }
    29     ILookupParameter<IItemSet<IClassifier>> PossibleActionsParameter { get; }
     28    ILookupParameter<IItemSet<IAction>> ActionsInMatchSetParameter { get; }
     29    ILookupParameter<IItemSet<IAction>> PossibleActionsParameter { get; }
    3030
    3131    ILookupParameter<IntValue> MinimalNumberOfUniqueActionsParameter { get; }

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

    r9090 r9194  
    2828namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2929  public interface ICoveringSolutionCreator : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable, IStochasticOperator {
    30     ILookupParameter<IClassifier> CoverClassifierParameter { get; }
    31     ILookupParameter<IClassifier> ActionParameter { get; }
     30    ILookupParameter<IInput> CoverInputParameter { get; }
     31    ILookupParameter<IAction> ActionParameter { get; }
    3232
    3333    IValueLookupParameter<IClassifier> CreatedClassifierParameter { get; }

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/GA/InsertInPopulationOperator.cs

    r9110 r9194  
    8686        IClassifier cl = classifiers[indices];
    8787        for (int i = 0; i < classifiers.Length; i++) {
    88           if (!hasToBeDeleted[i].Value && !insertInPopulation[i].Value && cl.Equals(classifiers[i])) {
     88          if (!hasToBeDeleted[i].Value && !insertInPopulation[i].Value && cl.Identical(classifiers[i])) {
    8989            numerosities[i].Value += numerosities[indices].Value;
    9090            hasToBeDeleted[indices].Value = true;

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj

    r9175 r9194  
    4343    </Reference>
    4444    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    45       <Private>False</Private>
    46     </Reference>
    47     <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
    4845      <Private>False</Private>
    4946    </Reference>
    … …  
    124121    <Compile Include="Reinforcement\IActionExecuter.cs" />
    125122    <Compile Include="Reinforcement\IClassifierFetcher.cs" />
    126     <Compile Include="Selectors\IMatchSelector.cs" />
    127     <Compile Include="Selectors\MatchSelector.cs" />
    128123    <Compile Include="Selectors\PreservingRightReducer.cs" />
    129124    <Compile Include="Subsumption\ActionSetSubsumptionOperator.cs" />
    … …  
    140135    <None Include="Plugin.cs.frame" />
    141136  </ItemGroup>
    142   <ItemGroup />
     137  <ItemGroup>
     138    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
     139      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
     140      <Name>HeuristicLab.Core-3.3</Name>
     141    </ProjectReference>
     142  </ItemGroup>
    143143  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
    144144  <PropertyGroup>

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/IClassifier.cs

    r9175 r9194  
    2020#endregion
    2121
    22 using System;
     22using System.Collections.Generic;
    2323using HeuristicLab.Core;
    2424
    2525namespace HeuristicLab.Encodings.ConditionActionEncoding {
    26   /// <summary>
    27   /// IMatching is used in dictinoaries, therefore the methods "Equals" and "GetHashCode" have to be overriden
    28   /// IEquatable<IMatching> should be implemented as well.
    29   ///
    30   /// This also helps to implement macroclassifiers later on
    31   /// </summary>
    32   public interface IClassifier : IItem, IEquatable<IClassifier> {
    33     IClassifier Condition { get; }
    34     IClassifier Action { get; }
    35     bool MatchCondition(IClassifier target);
    36     bool MatchAction(IClassifier target);
     26  public interface IClassifier : IItem {
     27    ICondition Condition { get; }
     28    IAction Action { get; }
     29
     30    bool MatchInput(IInput target);
     31    bool MatchAction(IAction target);
    3732    bool IsMoreGeneral(IClassifier target);
     33    bool IsMoreGeneral(ICondition target);
    3834
    39     //to use IMatching as key in a dictionary, Equals and GetHashCode have to be override.
    40     //Also IEquatable<Class> should be implemented.
    41     bool Equals(object obj);
    42     int GetHashCode();
     35    bool Identical(IClassifier target);
    4336  }
     37
     38  public interface ICondition : IItem {
     39    bool Match(IInput target);
     40  }
     41
     42  public interface IAction : IItem {
     43    bool Match(IAction target);
     44  }
     45
     46  public interface IInput : IItem { }
     47
     48  public interface IClassifierComparer : IEqualityComparer<IAction>, IItem { }
    4449}

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionModel.cs

    r9161 r9194  
    2828
    2929    int ClassifierCount { get; }
    30     IEnumerable<IClassifier> GetAction(IEnumerable<IClassifier> classifiers);
    31     IClassifier GetAction(IClassifier classifier);
     30    IEnumerable<IAction> GetAction(IEnumerable<IInput> classifiers);
     31    IAction GetAction(IInput classifier);
    3232  }
    3333}

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

    r9110 r9194  
    3737    //IItemSet<IClassifier> PossibleActions { get; }
    3838
     39    IParameter ClassifierComparerParameter { get; }
     40
    3941    ICoveringSolutionCreator CoveringSolutionCreator { get; }
    4042    IParameter CoveringSolutionCreatorParameter { get; }

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Interfaces/IConditionActionProblemData.cs

    r9161 r9194  
    4343    bool IsTestSample(int index);
    4444
    45     IEnumerable<IClassifier> FetchClassifier(IEnumerable<int> rows);
    46     IClassifier FetchClassifier(int rowNumber);
     45    IEnumerable<IInput> FetchInput(IEnumerable<int> rows);
     46    IInput FetchInput(int rowNumber);
     47
     48    IEnumerable<IAction> FetchAction(IEnumerable<int> rows);
     49    IAction FetchAction(int rowNumber);
    4750
    4851    event EventHandler Changed;

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

    r9090 r9194  
    3535      get { return (ILookupParameter<ItemArray<IClassifier>>)Parameters["Classifiers"]; }
    3636    }
    37     public IValueLookupParameter<IItemSet<IClassifier>> UniqueActionsParameter {
    38       get { return (IValueLookupParameter<IItemSet<IClassifier>>)Parameters["UniqueActions"]; }
     37    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     38      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     39    }
     40    public IValueLookupParameter<IItemSet<IAction>> UniqueActionsParameter {
     41      get { return (IValueLookupParameter<IItemSet<IAction>>)Parameters["UniqueActions"]; }
    3942    }
    4043    public IValueLookupParameter<IntValue> NumberOfUniqueActionsParameter {
    … …  
    5356      : base() {
    5457      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("Classifiers"));
    55       Parameters.Add(new ValueLookupParameter<IItemSet<IClassifier>>("UniqueActions"));
     58      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
     59      Parameters.Add(new ValueLookupParameter<IItemSet<IAction>>("UniqueActions"));
    5660      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfUniqueActions"));
    5761    }
    5862
    5963    public override IOperation Apply() {
    60       ItemSet<IClassifier> actions = new ItemSet<IClassifier>();
     64      ItemSet<IAction> actions = new ItemSet<IAction>(ClassifierComparerParameter.ActualValue);
    6165      foreach (var classifier in ClassifiersParameter.ActualValue) {
    6266        actions.Add(classifier.Action);

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchActionOperator.cs

    r9089 r9194  
    3434      get { return (ILookupParameter<BoolValue>)Parameters["MatchAction"]; }
    3535    }
    36     public ILookupParameter<IClassifier> TargetMatchParameter {
    37       get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
     36    public ILookupParameter<IAction> TargetMatchParameter {
     37      get { return (ILookupParameter<IAction>)Parameters["TargetMatchParameter"]; }
    3838    }
    3939    public ILookupParameter<IClassifier> MatchParameter {
    … …  
    4949      : base() {
    5050      Parameters.Add(new LookupParameter<BoolValue>("MatchAction", "True if the action matches."));
    51       Parameters.Add(new ValueLookupParameter<IClassifier>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
     51      Parameters.Add(new ValueLookupParameter<IAction>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
    5252      Parameters.Add(new ValueLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
    5353    }
    … …  
    5757
    5858    public override IOperation Apply() {
    59       IClassifier target = TargetMatchParameter.ActualValue;
     59      IAction target = TargetMatchParameter.ActualValue;
    6060      IClassifier match = MatchParameter.ActualValue;
    6161      MatchActionParameter.ActualValue = new BoolValue(match.MatchAction(target));

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/MatchConditionOperator.cs

    r9110 r9194  
    3434      get { return (ILookupParameter<BoolValue>)Parameters["MatchCondition"]; }
    3535    }
    36     public ILookupParameter<IClassifier> TargetMatchParameter {
    37       get { return (ILookupParameter<IClassifier>)Parameters["TargetMatchParameter"]; }
     36    public ILookupParameter<IInput> TargetMatchParameter {
     37      get { return (ILookupParameter<IInput>)Parameters["TargetMatchParameter"]; }
    3838    }
    3939    public ILookupParameter<IClassifier> MatchParameter {
    … …  
    4949      : base() {
    5050      Parameters.Add(new LookupParameter<BoolValue>("MatchCondition", "True if the condition matches."));
    51       Parameters.Add(new ValueLookupParameter<IClassifier>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
     51      Parameters.Add(new ValueLookupParameter<IInput>("TargetMatchParameter", "Target that has to be matched by the match parameter."));
    5252      Parameters.Add(new ValueLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
    5353    }
    … …  
    5757
    5858    public override IOperation Apply() {
    59       IClassifier target = TargetMatchParameter.ActualValue;
     59      IInput target = TargetMatchParameter.ActualValue;
    6060      IClassifier match = MatchParameter.ActualValue;
    61       MatchConditionParameter.ActualValue = new BoolValue(match.MatchCondition(target));
     61      MatchConditionParameter.ActualValue = new BoolValue(match.MatchInput(target));
    6262      return base.Apply();
    6363    }

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/PredictionArrayCalculator.cs

    r9089 r9194  
    3333  public class PredictionArrayCalculator : SingleSuccessorOperator {
    3434
     35    public ILookupParameter<IClassifierComparer> ClassifierComparerParameter {
     36      get { return (ILookupParameter<IClassifierComparer>)Parameters["ClassifierComparer"]; }
     37    }
    3538    public ILookupParameter<ItemArray<DoubleValue>> FitnessParameter {
    3639      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Fitness"]; }
    … …  
    3942      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Prediction"]; }
    4043    }
    41     public IValueParameter<IItemDictionary<IClassifier, DoubleValue>> PredictionArrayParameter {
    42       get { return (IValueParameter<IItemDictionary<IClassifier, DoubleValue>>)Parameters["PredictionArray"]; }
     44    public IValueParameter<IItemDictionary<IAction, DoubleValue>> PredictionArrayParameter {
     45      get { return (IValueParameter<IItemDictionary<IAction, DoubleValue>>)Parameters["PredictionArray"]; }
    4346    }
    4447    public ILookupParameter<ItemArray<IClassifier>> MatchParameter {
    … …  
    5356    public PredictionArrayCalculator()
    5457      : base() {
     58      Parameters.Add(new LookupParameter<IClassifierComparer>("ClassifierComparer"));
    5559      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Fitness"));
    5660      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Prediction"));
    57       Parameters.Add(new ValueLookupParameter<IItemDictionary<IClassifier, DoubleValue>>("PredictionArray"));
     61      Parameters.Add(new ValueLookupParameter<IItemDictionary<IAction, DoubleValue>>("PredictionArray"));
    5862      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope from which sub-scopes should be selected."));
    5963      Parameters.Add(new ScopeTreeLookupParameter<IClassifier>("MatchParameter", "The matching encoding contained in each sub-scope which is used for selection."));
    … …  
    6468
    6569    public sealed override IOperation Apply() {
    66       IItemDictionary<IClassifier, DoubleValue> predictionArray = new ItemDictionary<IClassifier, DoubleValue>();
    67       IDictionary<IClassifier, double> fitnessSumPerAction = new Dictionary<IClassifier, double>();
     70      IItemDictionary<IAction, DoubleValue> predictionArray = new ItemDictionary<IAction, DoubleValue>(ClassifierComparerParameter.ActualValue);
     71      IDictionary<IAction, double> fitnessSumPerAction = new Dictionary<IAction, double>(ClassifierComparerParameter.ActualValue);
    6872      ItemArray<DoubleValue> fitnesses = FitnessParameter.ActualValue;
    6973      ItemArray<DoubleValue> predictions = PredictionParameter.ActualValue;

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ActionExecuter.cs

    r9175 r9194  
    3333
    3434    #region parameter
    35     public IValueLookupParameter<IClassifier> SelectedActionParameter {
    36       get { return (IValueLookupParameter<IClassifier>)Parameters["SelectedAction"]; }
     35    public IValueLookupParameter<IAction> SelectedActionParameter {
     36      get { return (IValueLookupParameter<IAction>)Parameters["SelectedAction"]; }
    3737    }
    38     public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
    39       get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
     38    public IValueLookupParameter<IAction> CurrentActionToMatchParameter {
     39      get { return (IValueLookupParameter<IAction>)Parameters["CurrentActionToMatch"]; }
    4040    }
    4141    public IValueLookupParameter<DoubleValue> CurrentPayoffParameter {
    … …  
    6161    public ActionExecuter()
    6262      : base() {
    63       Parameters.Add(new ValueLookupParameter<IClassifier>("SelectedAction"));
    64       Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
     63      Parameters.Add(new ValueLookupParameter<IAction>("SelectedAction"));
     64      Parameters.Add(new ValueLookupParameter<IAction>("CurrentActionToMatch"));
    6565      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentPayoff"));
    6666      Parameters.Add(new ValueLookupParameter<DoubleValue>("NegativeReward"));
    … …  
    6969
    7070    public override IOperation Apply() {
    71       if (SelectedActionParameter.ActualValue.MatchAction(CurrentClassifierToMatchParameter.ActualValue)) {
     71      if (SelectedActionParameter.ActualValue.Match(CurrentActionToMatchParameter.ActualValue)) {
    7272        CurrentPayoffParameter.ActualValue = PositiveRewardParameter.ActualValue;
    7373      } else {

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/ClassifierFetcher.cs

    r9161 r9194  
    3333  [StorableClass]
    3434  public class ClassifierFetcher : SingleSuccessorOperator, IClassifierFetcher {
     35
    3536    #region parameters
    36     public IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter {
    37       get { return (IValueLookupParameter<IClassifier>)Parameters["CurrentClassifierToMatch"]; }
     37    public IValueLookupParameter<IInput> CurrentInputToMatchParameter {
     38      get { return (IValueLookupParameter<IInput>)Parameters["CurrentConditionToMatch"]; }
     39    }
     40    public IValueLookupParameter<IAction> CurrentActionToMatchParameter {
     41      get { return (IValueLookupParameter<IAction>)Parameters["CurrentActionToMatch"]; }
    3842    }
    3943    public ILookupParameter<IConditionActionProblemData> ProblemDataParameter {
    … …  
    5660    public ClassifierFetcher()
    5761      : base() {
    58       Parameters.Add(new ValueLookupParameter<IClassifier>("CurrentClassifierToMatch"));
     62      Parameters.Add(new ValueLookupParameter<IInput>("CurrentConditionToMatch"));
     63      Parameters.Add(new ValueLookupParameter<IAction>("CurrentActionToMatch"));
    5964      Parameters.Add(new LookupParameter<IConditionActionProblemData>("ProblemData"));
    6065      Parameters.Add(new LookupParameter<IntValue>("Iteration"));
    … …  
    6873      var trainingIndices = ProblemData.TrainingIndices.ToList();
    6974      int index = IterationParameter.ActualValue.Value % trainingIndices.Count;
    70       CurrentClassifierToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchClassifier(trainingIndices[index]);
     75      CurrentInputToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchInput(trainingIndices[index]);
     76      CurrentActionToMatchParameter.ActualValue = ProblemDataParameter.ActualValue.FetchAction(trainingIndices[index]);
    7177      return base.Apply();
    7278    }

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IActionExecuter.cs

    r9089 r9194  
    2727namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2828  public interface IActionExecuter : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
    29     IValueLookupParameter<IClassifier> SelectedActionParameter { get; }
    30     IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
     29    IValueLookupParameter<IAction> SelectedActionParameter { get; }
     30    IValueLookupParameter<IAction> CurrentActionToMatchParameter { get; }
    3131    IValueLookupParameter<DoubleValue> CurrentPayoffParameter { get; }
    3232    ILookupParameter<DoubleValue> NegativeRewardParameter { get; }

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Reinforcement/IClassifierFetcher.cs

    r9089 r9194  
    2727namespace HeuristicLab.Encodings.ConditionActionEncoding {
    2828  public interface IClassifierFetcher : IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
    29     IValueLookupParameter<IClassifier> CurrentClassifierToMatchParameter { get; }
     29    IValueLookupParameter<IInput> CurrentInputToMatchParameter { get; }
     30    IValueLookupParameter<IAction> CurrentActionToMatchParameter { get; }
    3031    ILookupParameter<IConditionActionProblemData> ProblemDataParameter { get; }
    3132    ILookupParameter<IntValue> IterationParameter { get; }

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/Subsumption/CheckGASubsumptionOperator.cs

    r9110 r9194  
    105105      for (int i = 0; i < parents.Length; i++) {
    106106        IClassifier curParent = parents[i];
    107         if (curParent.MatchAction(child)) {
     107        if (curParent.MatchAction(child.Action)) {
    108108          if (CouldSubsume(experiences[i], errors[i])) {
    109109            if (curParent.IsMoreGeneral(child)) {

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSModel.cs

    r9161 r9194  
    3434    public int ClassifierCount { get { return Count; } }
    3535
     36    public IClassifierComparer ClassifierComparer { get; set; }
     37
    3638    [StorableConstructor]
    3739    protected XCSModel(bool deserializing) : base(deserializing) { }
    … …  
    5153    }
    5254
    53     public IEnumerable<IClassifier> GetAction(IEnumerable<IClassifier> classifiers) {
     55    public IEnumerable<IAction> GetAction(IEnumerable<IInput> classifiers) {
    5456      foreach (var classifier in classifiers) {
    5557        yield return GetAction(classifier);
    … …  
    5759    }
    5860
    59     public IClassifier GetAction(IClassifier classifier) {
     61    public IAction GetAction(IInput classifier) {
    6062      var matchedClassifiers = new ItemCollection<XCSClassifier>();
    6163      foreach (var xcsClassifier in this) {
    62         if (xcsClassifier.Classifier.MatchCondition(classifier)) {
     64        if (xcsClassifier.Classifier.MatchInput(classifier)) {
    6365          matchedClassifiers.Add(xcsClassifier);
    6466        }
    … …  
    6769      if (matchedClassifiers.Count == 0) { return null; }
    6870
    69       IDictionary<IClassifier, double> predictionArray = CreatePredictionArray(matchedClassifiers);
     71      IDictionary<IAction, double> predictionArray = CreatePredictionArray(matchedClassifiers);
    7072      return predictionArray.OrderByDescending(x => x.Value).First().Key;
    7173    }
    7274
    73     private IDictionary<IClassifier, double> CreatePredictionArray(ItemCollection<XCSClassifier> matchedClassifiers) {
    74       var predictionArray = new Dictionary<IClassifier, double>();
    75       var fitnessSumPerAction = new Dictionary<IClassifier, double>();
     75    private IDictionary<IAction, double> CreatePredictionArray(ItemCollection<XCSClassifier> matchedClassifiers) {
     76      var predictionArray = new Dictionary<IAction, double>(ClassifierComparer);
     77      var fitnessSumPerAction = new Dictionary<IAction, double>(ClassifierComparer);
    7678
    7779      foreach (var xcsClassifier in matchedClassifiers) {
    … …  
    8688      }
    8789
    88       var actions = new List<IClassifier>(predictionArray.Keys);
     90      var actions = new List<IAction>(predictionArray.Keys);
    8991      foreach (var action in actions) {
    9092        if (fitnessSumPerAction[action] != 0) {

  • branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/XCSSolution.cs

    r9175 r9194  
    104104
    105105    private void RecalculateResults() {
    106       var originalTrainingClassifer = ProblemData.FetchClassifier(ProblemData.TrainingIndices);
    107       var originalTestClassifer = ProblemData.FetchClassifier(ProblemData.TestIndices);
    108       var estimatedTrainingClassifier = Model.GetAction(originalTrainingClassifer);
    109       var estimatedTestClassifier = Model.GetAction(originalTestClassifer);
    110 
    111       TrainingAccuracy = CalculateAccuracy(originalTrainingClassifer, estimatedTrainingClassifier);
    112       TestAccuracy = CalculateAccuracy(originalTestClassifer, estimatedTestClassifier);
    113     }
    114 
    115     private double CalculateAccuracy(IEnumerable<IClassifier> original, IEnumerable<IClassifier> estimated) {
     106      var originalTrainingCondition = ProblemData.FetchInput(ProblemData.TrainingIndices);
     107      var originalTestCondition = ProblemData.FetchInput(ProblemData.TestIndices);
     108      var estimatedTrainingClassifier = Model.GetAction(originalTrainingCondition);
     109      var estimatedTestClassifier = Model.GetAction(originalTestCondition);
     110
     111      var originalTrainingAction = ProblemData.FetchAction(ProblemData.TrainingIndices);
     112      var originalTestAction = ProblemData.FetchAction(ProblemData.TestIndices);
     113
     114      TrainingAccuracy = CalculateAccuracy(originalTrainingAction, estimatedTrainingClassifier);
     115      TestAccuracy = CalculateAccuracy(originalTestAction, estimatedTestClassifier);
     116    }
     117
     118    private double CalculateAccuracy(IEnumerable<IAction> original, IEnumerable<IAction> estimated) {
    116119      double correctClassified = 0;
    117120
    … …  
    121124
    122125      while (originalEnumerator.MoveNext() && estimatedActionEnumerator.MoveNext()) {
    123         if (originalEnumerator.Current.MatchAction(estimatedActionEnumerator.Current)) {
     126        if (originalEnumerator.Current.Match(estimatedActionEnumerator.Current)) {
    124127          correctClassified++;
    125128        }
Note: See TracChangeset for help on using the changeset viewer.