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

Timestamp:

08/13/09 17:28:07 (15 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/BaseClasses

Files:

• AlgorithmBase.cs (modified) (7 diffs)
• TreeEvaluatorBase.cs (modified) (5 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);
+    }
   }
 }