Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HL-3.2-MonoMigration/HeuristicLab.StructureIdentification/Evaluation/GPEvaluatorBase.cs @ 3494

Last change on this file since 3494 was 532, checked in by gkronber, 16 years ago

implemented #265 (GP evaluator for profit simulation with financial forecast models)

File size: 6.3 KB
Line 
1#region License Information
2/* HeuristicLab
3 * Copyright (C) 2002-2008 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Linq;
25using System.Text;
26using HeuristicLab.Core;
27using HeuristicLab.Data;
28using HeuristicLab.Operators;
29using HeuristicLab.Functions;
30using HeuristicLab.DataAnalysis;
31
32namespace HeuristicLab.StructureIdentification {
33  public abstract class GPEvaluatorBase : OperatorBase {
34    private IEvaluator evaluator;
35    private int targetVariable;
36    private int start;
37    private int end;
38    private bool useEstimatedValues;
39    private double[] backupValues;
40    private int evaluatedSamples;
41    private double estimatedValueMax;
42    private double estimatedValueMin;
43    private int treeSize;
44    private double totalEvaluatedNodes;
45    protected Dataset dataset;
46    private double targetMean;
47    protected double TargetMean { get { return targetMean; } }
48
49    public GPEvaluatorBase()
50      : base() {
51      AddVariableInfo(new VariableInfo("FunctionTree", "The function tree that should be evaluated", typeof(IFunctionTree), VariableKind.In));
52      AddVariableInfo(new VariableInfo("TreeSize", "Size (number of nodes) of the tree to evaluate", typeof(IntData), VariableKind.In));
53      AddVariableInfo(new VariableInfo("Dataset", "Dataset with all samples on which to apply the function", typeof(Dataset), VariableKind.In));
54      AddVariableInfo(new VariableInfo("TargetVariable", "Index of the column of the dataset that holds the target variable", typeof(IntData), VariableKind.In));
55      AddVariableInfo(new VariableInfo("PunishmentFactor", "Punishment factor for invalid estimations", typeof(DoubleData), VariableKind.In));
56      AddVariableInfo(new VariableInfo("TotalEvaluatedNodes", "Number of evaluated nodes", typeof(DoubleData), VariableKind.In | VariableKind.Out));
57      AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
58      AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
59      AddVariableInfo(new VariableInfo("UseEstimatedTargetValue", "Wether to use the original (measured) or the estimated (calculated) value for the targat variable when doing autoregressive modelling", typeof(BoolData), VariableKind.In));
60    }
61
62    public override IOperation Apply(IScope scope) {
63      // get all variable values
64      targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
65      dataset = GetVariableValue<Dataset>("Dataset", scope, true);
66      IFunctionTree functionTree = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
67      double maximumPunishment = GetVariableValue<DoubleData>("PunishmentFactor", scope, true).Data * dataset.GetRange(targetVariable);
68      treeSize = scope.GetVariableValue<IntData>("TreeSize", false).Data;
69      totalEvaluatedNodes = scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data;
70      int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
71      int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
72      useEstimatedValues = GetVariableValue<BoolData>("UseEstimatedTargetValue", scope, true).Data;
73      // prepare for autoregressive modelling by saving the original values of the target-variable to a backup array
74      if(useEstimatedValues &&
75        (backupValues == null || start != this.start || end != this.end)) {
76        this.start = start;
77        this.end = end;
78        backupValues = new double[end - start];
79        for(int i = start; i < end; i++) {
80          backupValues[i - start] = dataset.GetValue(i, targetVariable);
81        }
82      }
83      // get the mean of the values of the target variable to determin the max and min bounds of the estimated value
84      targetMean = dataset.GetMean(targetVariable, start, end - 1);
85      estimatedValueMin = targetMean - maximumPunishment;
86      estimatedValueMax = targetMean + maximumPunishment;
87
88      // initialize and reset the evaluator
89      if(evaluator == null) evaluator = functionTree.CreateEvaluator();
90      evaluator.ResetEvaluator(functionTree, dataset);
91      evaluatedSamples = 0;
92
93      Evaluate(start, end);
94
95      // restore the values of the target variable from the backup array if necessary
96      if(useEstimatedValues) RestoreDataset(dataset, targetVariable, start, end);
97      // update the value of total evaluated nodes
98      scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data = totalEvaluatedNodes + treeSize * evaluatedSamples;
99      return null;
100    }
101
102    private void RestoreDataset(Dataset dataset, int targetVariable, int from, int to) {
103      for(int i = from; i < to; i++) {
104        dataset.SetValue(i, targetVariable, backupValues[i - from]);
105      }
106    }
107
108    public abstract void Evaluate(int start, int end);
109
110    public void SetOriginalValue(int sample, double value) {
111      if(useEstimatedValues) {
112        dataset.SetValue(sample, targetVariable, value);
113      }
114    }
115
116    public double GetOriginalValue(int sample) {
117      return dataset.GetValue(sample, targetVariable);
118    }
119
120    public double GetEstimatedValue(int sample) {
121      evaluatedSamples++;
122      double estimated = evaluator.Evaluate(sample);
123      if(double.IsNaN(estimated) || double.IsInfinity(estimated)) {
124        estimated = estimatedValueMax;
125      } else if(estimated > estimatedValueMax) {
126        estimated = estimatedValueMax;
127      } else if(estimated < estimatedValueMin) {
128        estimated = estimatedValueMin;
129      }
130      return estimated;
131    }
132  }
133}
Note: See TracBrowser for help on using the repository browser.