#region License Information
/* HeuristicLab
* Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
*
* This file is part of HeuristicLab.
*
* HeuristicLab is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* HeuristicLab is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with HeuristicLab. If not, see .
*/
#endregion
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Optimization.Operators.LCS;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
namespace HeuristicLab.Encodings.DecisionList {
[Item("MDLEvaluator", "Description missing")]
[StorableClass]
public class MDLEvaluator : SingleSuccessorOperator, IDecisionListEvaluator, IDecisionListOperator, IMDLCalculatorBasedOperator, IIterationBasedOperator, IStochasticOperator {
#region Parameter Properties
public ILookupParameter RandomParameter {
get { return (ILookupParameter)Parameters["Random"]; }
}
public ILookupParameter DecisionListParameter {
get { return (ILookupParameter)Parameters["DecisionList"]; }
}
public IValueLookupParameter SizePenaltyMinRulesParameter {
get { return (IValueLookupParameter)Parameters["SizePenaltyMinRules"]; }
}
public ILookupParameter QualityParameter {
get { return (ILookupParameter)Parameters["Quality"]; }
}
public IValueLookupParameter ProblemDataParameter {
get { return (IValueLookupParameter)Parameters["ProblemData"]; }
}
public ILookupParameter MDLCalculatorParameter {
get { return (ILookupParameter)Parameters["MDLCalculator"]; }
}
public ILookupParameter IterationsParameter {
get { return (ILookupParameter)Parameters["Iterations"]; }
}
public IValueLookupParameter MaximumIterationsParameter {
get { return (IValueLookupParameter)Parameters["MaximumIterations"]; }
}
public IValueLookupParameter IterationRuleDeletionParameter {
get { return (IValueLookupParameter)Parameters["IterationRuleDeletion"]; }
}
public IValueLookupParameter RuleDeletionMinRulesParameter {
get { return (IValueLookupParameter)Parameters["RuleDeletionMinRules"]; }
}
public ILookupParameter>> StrataParameter {
get { return (ILookupParameter>>)Parameters["Strata"]; }
}
#endregion
public IRandom Random {
get { return RandomParameter.ActualValue; }
}
[StorableConstructor]
protected MDLEvaluator(bool deserializing) : base(deserializing) { }
protected MDLEvaluator(MDLEvaluator original, Cloner cloner)
: base(original, cloner) {
}
public MDLEvaluator()
: base() {
Parameters.Add(new LookupParameter("Random", "The random generator to use."));
Parameters.Add(new LookupParameter("DecisionList", ""));
Parameters.Add(new ValueLookupParameter("SizePenaltyMinRules", ""));
Parameters.Add(new LookupParameter("Quality", ""));
Parameters.Add(new ValueLookupParameter("ProblemData", ""));
Parameters.Add(new LookupParameter("MDLCalculator", ""));
Parameters.Add(new LookupParameter("Iterations", ""));
Parameters.Add(new ValueLookupParameter("MaximumIterations", ""));
Parameters.Add(new ValueLookupParameter("IterationRuleDeletion", "", new IntValue(5)));
Parameters.Add(new ValueLookupParameter("RuleDeletionMinRules", "", new IntValue(12)));
Parameters.Add(new ValueLookupParameter>>("Strata", ""));
}
public override IDeepCloneable Clone(Cloner cloner) {
return new MDLEvaluator(this, cloner);
}
public override IOperation Apply() {
double penalty = 1;
var strata = StrataParameter.ActualValue;
int iteration = IterationsParameter.ActualValue.Value;
int numberOfStrata = strata.Count;
var dl = DecisionListParameter.ActualValue;
var problemData = ProblemDataParameter.ActualValue;
bool lastIteration = iteration == MaximumIterationsParameter.ActualValue.Value - 1;
IEnumerable rows;
if (lastIteration) {
rows = from s in strata
from row in s
select row.Value;
} else {
rows = strata[iteration % numberOfStrata].Select(x => x.Value);
}
var input = problemData.FetchInput(rows);
var actions = problemData.FetchAction(rows);
ItemSet aliveRules;
double theoryLength;
var estimated = dl.Evaluate(input, out aliveRules, out theoryLength);
if (aliveRules.Count < SizePenaltyMinRulesParameter.ActualValue.Value) {
penalty = (1 - 0.025 * (SizePenaltyMinRulesParameter.ActualValue.Value - aliveRules.Count));
if (penalty <= 0) penalty = 0.01;
penalty *= penalty;
}
double accuracy = DecisionListSolution.CalculateAccuracy(actions, estimated);
QualityParameter.ActualValue = new DoubleValue(MDLCalculatorParameter.ActualValue.CalculateFitness(theoryLength, accuracy) / penalty);
if (iteration >= IterationRuleDeletionParameter.ActualValue.Value) {
if (lastIteration) {
DoRuleDeletion(dl, aliveRules, 1);
} else {
DoRuleDeletion(dl, aliveRules, RuleDeletionMinRulesParameter.ActualValue.Value);
}
}
return base.Apply();
}
// default rule cannot be deleted, but it has to be considered in the rule set size
private void DoRuleDeletion(DecisionList dl, IEnumerable aliveRules, int minRules) {
int ruleSetSize = dl.RuleSetSize;
if (ruleSetSize <= minRules) { return; }
var deadRules = dl.Rules.Except(aliveRules).ToList();
int numberOfDeadRules = deadRules.Count();
int keepRules = minRules - (ruleSetSize - numberOfDeadRules);
if (keepRules > 0) {
for (int i = 0; i < keepRules; i++) {
int pos = Random.Next(deadRules.Count);
deadRules.RemoveAt(pos);
}
}
dl.RemoveRules(deadRules);
}
}
}