Changeset 2285 for trunk/sources/HeuristicLab.GP.StructureIdentification

Timestamp:

08/13/09 17:28:07 (16 years ago)

Author:

gkronber

Message:

Worked on #722 (IModel should provide a Predict() method to get predicted values for an input vector).
At the same time removed parameter PunishmentFactor from GP algorithms (this parameter is internal to TreeEvaluators now).

Location:

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3

Files:

• BaseClasses/AlgorithmBase.cs (modified) (7 diffs)
• BaseClasses/TreeEvaluatorBase.cs (modified) (5 diffs)
• Evaluators/GPEvaluatorBase.cs (modified) (3 diffs)
• Evaluators/VariableEvaluationImpactCalculator.cs (modified) (2 diffs)
• Evaluators/VariableQualityImpactCalculator.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification-3.3.csproj (modified) (1 diff)
• ITreeEvaluator.cs (modified) (1 diff)
• Predictor.cs (added)
• StandardGP.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/AlgorithmBase.cs ¶

@@ -70 +70 @@
     }
 
-    private IModel model;
-    public virtual IModel Model {
+    private IAnalyzerModel model;
+    public virtual IAnalyzerModel Model {
       get {
         if (!engine.Terminated) throw new InvalidOperationException("The algorithm is still running. Wait until the algorithm is terminated to retrieve the result.");
@@ -100 +100 @@
       get { return GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data; }
       set { GetVariableInjector().GetVariable("Parents").GetValue<IntData>().Data = value; }
-    }
-
-    public virtual double PunishmentFactor {
-      get { return GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data; }
-      set { GetVariableInjector().GetVariable("PunishmentFactor").GetValue<DoubleData>().Data = value; }
     }
 
@@ -132 +127 @@
       MaxTreeHeight = 10;
       Parents = 2000;
-      PunishmentFactor = 10;
       UseEstimatedTargetValue = false;
     }
@@ -212 +206 @@
       injector.AddVariable(new HeuristicLab.Core.Variable("TotalEvaluatedNodes", new DoubleData(0)));
       injector.AddVariable(new HeuristicLab.Core.Variable("Parents", new IntData()));
-      injector.AddVariable(new HeuristicLab.Core.Variable("PunishmentFactor", new DoubleData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("UseEstimatedTargetValue", new BoolData()));
       injector.AddVariable(new HeuristicLab.Core.Variable("TreeEvaluator", new HL2TreeEvaluator()));
@@ -416 +409 @@
     }
 
-    protected internal virtual Model CreateGPModel(IScope bestModelScope) {
+    protected internal virtual IAnalyzerModel CreateGPModel(IScope bestModelScope) {
       Engine.GlobalScope.AddSubScope(bestModelScope);
-      Model model = new Model();
+      IGeneticProgrammingModel tree = bestModelScope.GetVariableValue<IGeneticProgrammingModel>("FunctionTree", false);
+      ITreeEvaluator evaluator = bestModelScope.GetVariableValue<ITreeEvaluator>("TreeEvaluator", false);
+      IAnalyzerModel model = new AnalyzerModel();
+      model.Predictor = new Predictor(evaluator, tree);
       Dataset ds = bestModelScope.GetVariableValue<Dataset>("Dataset", true);
-      model.Data = bestModelScope.GetVariableValue<IGeneticProgrammingModel>("FunctionTree", false);
       model.Dataset = ds;
       model.TargetVariable = ds.GetVariableName(bestModelScope.GetVariableValue<IntData>("TargetVariable", true).Data);
@@ -450 +445 @@
         double impact = ((DoubleData)row[1]).Data;
         model.SetVariableEvaluationImpact(variableName, impact);
-        model.AddInputVariables(variableName);
+        model.AddInputVariable(variableName);
       }
       foreach (ItemList row in qualityImpacts) {
@@ -456 +451 @@
         double impact = ((DoubleData)row[1]).Data;
         model.SetVariableQualityImpact(variableName, impact);
-        model.AddInputVariables(variableName);
+        model.AddInputVariable(variableName);
       }
       Engine.GlobalScope.RemoveSubScope(bestModelScope);

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/BaseClasses/TreeEvaluatorBase.cs ¶

@@ -25 +25 @@
 using HeuristicLab.DataAnalysis;
 using HeuristicLab.GP.Interfaces;
+using System.Xml;
 
 namespace HeuristicLab.GP.StructureIdentification {
@@ -32 +33 @@
   public abstract class TreeEvaluatorBase : ItemBase, ITreeEvaluator {
     protected const double EPSILON = 1.0e-7;
-    protected double maxValue;
-    protected double minValue;
+    protected double maxValue = double.MaxValue;
+    protected double minValue = double.MinValue;
+    private double punishmentFactor = 10.0; // we should provide a view for treeevaluators that allows to change this value
 
     protected class Instr {
@@ -48 +50 @@
     protected int sampleIndex;
 
-    public void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, double punishmentFactor, IFunctionTree functionTree) {
+    public void PrepareForEvaluation(Dataset dataset, IFunctionTree functionTree) {
       this.dataset = dataset;
+      codeArr = new Instr[functionTree.GetSize()];
+      int i = 0;
+      foreach (IFunctionTree tree in IteratePrefix(functionTree)) {
+        codeArr[i++] = TranslateToInstr(tree);
+      }
+    }
+
+    public void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, IFunctionTree functionTree) {
       // calculate upper and lower bounds for the estimated value (mean +/- punishmentFactor * range)
       double mean = dataset.GetMean(targetVariable, start, end);
@@ -55 +65 @@
       maxValue = mean + punishmentFactor * range;
       minValue = mean - punishmentFactor * range;
-
-      codeArr = new Instr[functionTree.GetSize()];
-      int i = 0;
-      foreach (IFunctionTree tree in IteratePrefix(functionTree)) {
-        codeArr[i++] = TranslateToInstr(tree);
-      }
+      PrepareForEvaluation(dataset, functionTree);
     }
 
@@ -118 +123 @@
 
     protected abstract double EvaluateBakedCode();
+
+    public override object Clone(IDictionary<Guid, object> clonedObjects) {
+      TreeEvaluatorBase clone = (TreeEvaluatorBase)base.Clone(clonedObjects);
+      clone.maxValue = maxValue;
+      clone.minValue = minValue;
+      clone.punishmentFactor = punishmentFactor;
+      return clone;
+    }
+
+    public override System.Xml.XmlNode GetXmlNode(string name, System.Xml.XmlDocument document, IDictionary<Guid, IStorable> persistedObjects) {
+      XmlNode node = base.GetXmlNode(name, document, persistedObjects);
+      XmlAttribute maxValueAttribute = document.CreateAttribute("MaxPredictionValue");
+      XmlAttribute minValueAttribute = document.CreateAttribute("MinPredictionValue");
+      XmlAttribute punishmentFactorAttribute = document.CreateAttribute("PunishmentFactor");
+      maxValueAttribute.Value = XmlConvert.ToString(maxValue);
+      minValueAttribute.Value = XmlConvert.ToString(minValue);
+      punishmentFactorAttribute.Value = XmlConvert.ToString(punishmentFactor);
+
+      node.Attributes.Append(punishmentFactorAttribute);
+      node.Attributes.Append(minValueAttribute);
+      node.Attributes.Append(maxValueAttribute);
+      return node;
+    }
+
+    public override void Populate(System.Xml.XmlNode node, IDictionary<Guid, IStorable> restoredObjects) {
+      base.Populate(node, restoredObjects);
+      minValue = XmlConvert.ToDouble(node.Attributes["MinPredictionValue"].Value);
+      maxValue = XmlConvert.ToDouble(node.Attributes["MaxPredictionValue"].Value);
+      punishmentFactor = XmlConvert.ToDouble(node.Attributes["PunishmentFactor"].Value);
+    }
   }
 }

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/GPEvaluatorBase.cs ¶

@@ -33 +33 @@
       AddVariableInfo(new VariableInfo("Dataset", "Dataset with all samples on which to apply the function", typeof(Dataset), VariableKind.In));
       AddVariableInfo(new VariableInfo("TargetVariable", "Index of the column of the dataset that holds the target variable", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("PunishmentFactor", "Punishment factor for invalid estimations", typeof(DoubleData), VariableKind.In));
       AddVariableInfo(new VariableInfo("TotalEvaluatedNodes", "Number of evaluated nodes", typeof(DoubleData), VariableKind.In | VariableKind.Out));
       AddVariableInfo(new VariableInfo("TrainingSamplesStart", "Start index of training samples in dataset", typeof(IntData), VariableKind.In));
@@ -47 +46 @@
       Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
       IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, true);
-      double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
       double totalEvaluatedNodes = scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data;
       int trainingStart = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
@@ -55 +53 @@
       bool useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
-      evaluator.PrepareForEvaluation(dataset, targetVariable, trainingStart, trainingEnd, punishmentFactor, gpModel.FunctionTree);
+      evaluator.PrepareForEvaluation(dataset, targetVariable, trainingStart, trainingEnd, gpModel.FunctionTree);
 
       double[] backupValues = null;

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableEvaluationImpactCalculator.cs ¶

@@ -33 +33 @@
       AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be evaluated", typeof(IGeneticProgrammingModel), VariableKind.In));
       AddVariableInfo(new VariableInfo("TreeSize", "Size (number of nodes) of the tree to evaluate", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("PunishmentFactor", "Punishment factor for invalid estimations", typeof(DoubleData), VariableKind.In));
     }
 
@@ -41 +40 @@
       IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, true);
       double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
-      evaluator.PrepareForEvaluation(dataset, targetVariable, start, end, punishmentFactor, gpModel.FunctionTree);
+      evaluator.PrepareForEvaluation(dataset, targetVariable, start, end, gpModel.FunctionTree);
 
       double[] result = new double[end - start];

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableQualityImpactCalculator.cs ¶

@@ -33 +33 @@
       AddVariableInfo(new VariableInfo("TreeEvaluator", "The evaluator that should be used to evaluate the expression tree", typeof(ITreeEvaluator), VariableKind.In));
       AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be evaluated", typeof(IGeneticProgrammingModel), VariableKind.In));
-      AddVariableInfo(new VariableInfo("PunishmentFactor", "Punishment factor for invalid estimations", typeof(DoubleData), VariableKind.In));
     }
 
@@ -40 +39 @@
       IGeneticProgrammingModel gpModel = GetVariableValue<IGeneticProgrammingModel>("FunctionTree", scope, true);
       double punishmentFactor = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data;
-      evaluator.PrepareForEvaluation(dataset, targetVariable, start, end, punishmentFactor, gpModel.FunctionTree);
+      evaluator.PrepareForEvaluation(dataset, targetVariable, start, end, gpModel.FunctionTree);
 
       double[,] result = new double[end - start, 2];

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/HeuristicLab.GP.StructureIdentification-3.3.csproj ¶

@@ -85 +85 @@
     <Compile Include="BaseClasses\FunctionTreeBase.cs" />
     <Compile Include="BaseClasses\TreeEvaluatorBase.cs" />
+    <Compile Include="Predictor.cs" />
     <Compile Include="Evaluators\SimpleGPEvaluatorBase.cs" />
     <Compile Include="HL3TreeEvaluator.cs" />

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/ITreeEvaluator.cs ¶

@@ -26 +26 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public interface ITreeEvaluator : IItem {
-    void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, double punishmentFactor, IFunctionTree functionTree);
+    void PrepareForEvaluation(Dataset dataset, int targetVariable, int start, int end, IFunctionTree functionTree);
+    void PrepareForEvaluation(Dataset dataset, IFunctionTree functionTree);
     double Evaluate(int sampleIndex);
   }

trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/StandardGP.cs ¶

@@ -110 +110 @@
       FullTreeShakingFactor = 0.1;
       OnePointShakingFactor = 1.0;
-      PunishmentFactor = 10.0;
       UseEstimatedTargetValue = false;
       SetSeedRandomly = true;
@@ -337 +336 @@
     }
 
-    protected internal override Model CreateGPModel(IScope bestModelScope) {
-      Model model = base.CreateGPModel(bestModelScope);
+    protected internal override IAnalyzerModel CreateGPModel(IScope bestModelScope) {
+      IAnalyzerModel model = base.CreateGPModel(bestModelScope);
       model.TestMeanSquaredError = bestModelScope.GetVariableValue<DoubleData>("TestQuality", false).Data;
       model.TrainingCoefficientOfDetermination = bestModelScope.GetVariableValue<DoubleData>("TrainingR2", false).Data;