Changeset 4022


Ignore:
Timestamp:
07/09/10 17:01:36 (11 years ago)
Author:
gkronber
Message:

Worked on symbolic regression classes to prepare for time series prognosis plugin. #1081

Location:
trunk/sources
Files:
4 added
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Compiler/SymbolicExpressionTreeCompiler.cs

    r3747 r4022  
    3737      List<Instruction> code = new List<Instruction>();
    3838      entryPoint.Clear();
    39       // compile main body
    40       code.AddRange(Compile(tree.Root.SubTrees[0].SubTrees[0], opCodeMapper));
    41       // compile branches
     39      // compile main body branches
     40      foreach (var branch in tree.Root.SubTrees[0].SubTrees) {
     41        code.AddRange(Compile(branch, opCodeMapper));
     42      }     
     43      // compile function branches
    4244      var functionBranches = from node in tree.IterateNodesPrefix()
    4345                             where node.Symbol is Defun
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/FixedValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs

    r3996 r4022  
    246246
    247247      #region validation best model
    248       int targetVariableIndex = ProblemData.Dataset.GetVariableIndex(ProblemData.TargetVariable.Value);
     248      string targetVariable = ProblemData.TargetVariable.Value;
    249249      int validationStart = ValidiationSamplesStart.Value;
    250250      int validationEnd = ValidationSamplesEnd.Value;
     
    257257      OnlineMeanSquaredErrorEvaluator mseEvaluator = new OnlineMeanSquaredErrorEvaluator();
    258258      foreach (var scaledTree in scaledTrees) {
    259         mseEvaluator.Reset();
    260         IEnumerable<double> estimatedValidationValues = SymbolicExpressionTreeInterpreter.GetSymbolicExpressionTreeValues(scaledTree, ProblemData.Dataset, Enumerable.Range(validationStart, validationEnd - validationStart));
    261         IEnumerable<double> originalValidationValues = ProblemData.Dataset.GetEnumeratedVariableValues(targetVariableIndex, validationStart, validationEnd);
    262         var estimatedEnumerator = estimatedValidationValues.GetEnumerator();
    263         var originalEnumerator = originalValidationValues.GetEnumerator();
    264         while (estimatedEnumerator.MoveNext() & originalEnumerator.MoveNext()) {
    265           double estimated = estimatedEnumerator.Current;
    266           if (double.IsNaN(estimated)) estimated = upperEstimationLimit;
    267           else estimated = Math.Min(upperEstimationLimit, Math.Max(lowerEstimationLimit, estimated));
    268           mseEvaluator.Add(originalEnumerator.Current, estimated);
    269         }
    270         double validationMse = mseEvaluator.MeanSquaredError;
     259        double validationMse = SymbolicRegressionMeanSquaredErrorEvaluator.Calculate(SymbolicExpressionTreeInterpreter, scaledTree,
     260          lowerEstimationLimit, upperEstimationLimit,
     261          ProblemData.Dataset, targetVariable,
     262          validationStart, validationEnd);
     263
    271264        if (validationMse < bestValidationMse) {
    272265          bestValidationMse = validationMse;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/HeuristicLab.Problems.DataAnalysis.Views-3.3.csproj

    r3975 r4022  
    172172      <DependentUpon>ConstantView.cs</DependentUpon>
    173173    </Compile>
     174    <Compile Include="Symbolic\Symbols\LaggedVariableView.cs">
     175      <SubType>UserControl</SubType>
     176    </Compile>
     177    <Compile Include="Symbolic\Symbols\LaggedVariableView.Designer.cs">
     178      <DependentUpon>LaggedVariableView.cs</DependentUpon>
     179    </Compile>
    174180    <Compile Include="Symbolic\Symbols\VariableView.cs">
    175181      <SubType>UserControl</SubType>
     
    252258      <Name>HeuristicLab.Problems.DataAnalysis-3.3</Name>
    253259    </ProjectReference>
     260  </ItemGroup>
     261  <ItemGroup>
     262    <EmbeddedResource Include="Symbolic\Symbols\LaggedVariableView.resx">
     263      <DependentUpon>LaggedVariableView.cs</DependentUpon>
     264    </EmbeddedResource>
    254265  </ItemGroup>
    255266  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs

    r3933 r4022  
    3939    #region default data
    4040    // y = x^4 + x^3 + x^2 + x
    41     private readonly double[,] kozaF1 = new double[,] {
     41    private static double[,] kozaF1 = new double[,] {
    4242{2.017885919, -1.449165046},
    4343{1.30060506,  -1.344523885},
     
    185185    }
    186186
     187    public DataAnalysisProblemData(Dataset dataset, IEnumerable<string> inputVariables, string targetVariable,
     188      int trainingSamplesStart, int trainingSamplesEnd, int testSamplesStart, int testSamplesEnd) {
     189      var inputVariablesList = new CheckedItemList<StringValue>(inputVariables.Select(x => new StringValue(x)));
     190      StringValue targetVariableValue = new StringValue(targetVariable);
     191      var validTargetVariables = new ItemSet<StringValue>();
     192      foreach (var variable in dataset.VariableNames)
     193        if (variable != targetVariable)
     194          validTargetVariables.Add(new StringValue(variable));
     195      validTargetVariables.Add(targetVariableValue);
     196      Parameters.Add(new ValueParameter<Dataset>("Dataset", dataset));
     197      Parameters.Add(new ValueParameter<ICheckedItemList<StringValue>>("InputVariables", inputVariablesList.AsReadOnly()));
     198      Parameters.Add(new ConstrainedValueParameter<StringValue>("TargetVariable", validTargetVariables, targetVariableValue));
     199      Parameters.Add(new ValueParameter<IntValue>("TrainingSamplesStart", new IntValue(trainingSamplesStart)));
     200      Parameters.Add(new ValueParameter<IntValue>("TrainingSamplesEnd", new IntValue(trainingSamplesEnd)));
     201      Parameters.Add(new ValueParameter<IntValue>("TestSamplesStart", new IntValue(testSamplesStart)));
     202      Parameters.Add(new ValueParameter<IntValue>("TestSamplesEnd", new IntValue(testSamplesEnd)));
     203      RegisterParameterEventHandlers();
     204      RegisterParameterValueEventHandlers();
     205    }
    187206
    188207    [StorableConstructor]
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/OnlineMeanAbsolutePercentageErrorEvaluator.cs

    r3996 r4022  
    4747    }
    4848
    49     #region IPairedEnumerableEvaluator Members
     49    #region IOnlineEvaluator Members
     50    public double Value {
     51      get { return MeanAbsolutePercentageError; }
     52    }
    5053    public void Reset() {
    5154      n = 0;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/OnlineMeanSquaredErrorEvaluator.cs

    r3996 r4022  
    4848
    4949    #region IOnlineEvaluator Members
     50    public double Value {
     51      get { return MeanSquaredError; }
     52    }
    5053    public void Reset() {
    5154      n = 0;
     
    5659      if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    5760          double.IsNaN(original) || double.IsInfinity(original)) {
    58             throw new ArgumentException("Mean squared error is not defined for NaN or infinity elements");
     61        throw new ArgumentException("Mean squared error is not defined for NaN or infinity elements");
    5962      } else {
    6063        double error = estimated - original;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/OnlinePearsonsRSquaredEvaluator.cs

    r3996 r4022  
    6161
    6262    #region IOnlineEvaluator Members
     63    public double Value {
     64      get { return RSquared; }
     65    }
    6366    public void Reset() {
    6467      sum_sq_x = 0.0;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Evaluators/SimpleNMSEEvaluator.cs

    r3462 r4022  
    5050
    5151    public static double Calculate(IEnumerable<double> original, IEnumerable<double> estimated) {
    52       double mse = SimpleMSEEvaluator.Calculate(original, estimated);
    53       return mse / original.Variance();
     52      OnlineNormalizedMeanSquaredErrorEvaluator nmseEvaluator = new OnlineNormalizedMeanSquaredErrorEvaluator();
     53      var originalEnumerator = original.GetEnumerator();
     54      var estimatedEnumerator = estimated.GetEnumerator();
     55      while (originalEnumerator.MoveNext() & estimatedEnumerator.MoveNext()) {
     56        nmseEvaluator.Add(originalEnumerator.Current, estimatedEnumerator.Current);
     57      }
     58      if (originalEnumerator.MoveNext() || estimatedEnumerator.MoveNext()) {
     59        throw new ArgumentException("Number of elements in original and estimated enumerations doesn't match.");
     60      }
     61      return nmseEvaluator.NormalizedMeanSquaredError;
    5462    }
    5563  }
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/HeuristicLab.Problems.DataAnalysis-3.3.csproj

    r3999 r4022  
    8484    <None Include="HeuristicLabProblemsDataAnalysisPlugin.cs.frame" />
    8585    <None Include="Properties\AssemblyInfo.frame" />
     86    <Compile Include="Evaluators\OnlineMeanAndVarianceCalculator.cs" />
     87    <Compile Include="Evaluators\OnlineNormalizedMeanSquaredErrorEvaluator.cs" />
    8688    <Compile Include="DataAnalysisSolution.cs" />
    8789    <Compile Include="CsvFileParser.cs" />
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Interfaces/IOnlineEvaluator.cs

    r3996 r4022  
    2828namespace HeuristicLab.Problems.DataAnalysis {
    2929  public interface IOnlineEvaluator {
     30    double Value { get; }
    3031    void Reset();
    3132    void Add(double original, double estimated);
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs

    r3996 r4022  
    2121
    2222using System;
     23using System.Linq;
    2324using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    2425using HeuristicLab.Common;
     
    9798    private Instruction[] code;
    9899    private int pc;
     100    private double[] argumentStack = new double[ARGUMENT_STACK_SIZE];
     101    private int argStackPointer;
    99102
    100103    public override bool CanChangeName {
     
    140143    }
    141144
    142     private double[] argumentStack = new double[ARGUMENT_STACK_SIZE];
    143     private int argStackPointer;
    144 
    145     public double Evaluate() {
    146       var currentInstr = code[pc++];
     145    private double Evaluate() {
     146      Instruction currentInstr = code[pc++];
    147147      switch (currentInstr.opCode) {
    148148        case OpCodes.Add: {
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariable.cs

    r3993 r4022  
    3434  [StorableClass]
    3535  [Item("LaggedVariable", "Represents a variable value with a time offset.")]
    36   public sealed class LaggedVariable : Symbol {
    37     #region Properties
    38     [Storable]
    39     private double weightNu;
    40     public double WeightNu {
    41       get { return weightNu; }
    42       set { weightNu = value; }
    43     }
    44     [Storable]
    45     private double weightSigma;
    46     public double WeightSigma {
    47       get { return weightSigma; }
    48       set {
    49         if (weightSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
    50         weightSigma = value;
    51       }
    52     }
    53     [Storable]
    54     private double weightManipulatorNu;
    55     public double WeightManipulatorNu {
    56       get { return weightManipulatorNu; }
    57       set { weightManipulatorNu = value; }
    58     }
    59     [Storable]
    60     private double weightManipulatorSigma;
    61     public double WeightManipulatorSigma {
    62       get { return weightManipulatorSigma; }
    63       set {
    64         if (weightManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
    65         weightManipulatorSigma = value;
    66       }
    67     }
    68     private List<string> variableNames;
    69     [Storable]
    70     public IEnumerable<string> VariableNames {
    71       get { return variableNames; }
    72       set {
    73         if (value == null) throw new ArgumentNullException();
    74         variableNames.Clear();
    75         variableNames.AddRange(value);
    76       }
    77     }
     36  public sealed class LaggedVariable : Variable {
     37    //#region Properties
     38    //[Storable]
     39    //private double weightNu;
     40    //public double WeightNu {
     41    //  get { return weightNu; }
     42    //  set { weightNu = value; }
     43    //}
     44    //[Storable]
     45    //private double weightSigma;
     46    //public double WeightSigma {
     47    //  get { return weightSigma; }
     48    //  set {
     49    //    if (weightSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
     50    //    weightSigma = value;
     51    //  }
     52    //}
     53    //[Storable]
     54    //private double weightManipulatorNu;
     55    //public double WeightManipulatorNu {
     56    //  get { return weightManipulatorNu; }
     57    //  set { weightManipulatorNu = value; }
     58    //}
     59    //[Storable]
     60    //private double weightManipulatorSigma;
     61    //public double WeightManipulatorSigma {
     62    //  get { return weightManipulatorSigma; }
     63    //  set {
     64    //    if (weightManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
     65    //    weightManipulatorSigma = value;
     66    //  }
     67    //}
     68    //private List<string> variableNames;
     69    //[Storable]
     70    //public IEnumerable<string> VariableNames {
     71    //  get { return variableNames; }
     72    //  set {
     73    //    if (value == null) throw new ArgumentNullException();
     74    //    variableNames.Clear();
     75    //    variableNames.AddRange(value);
     76    //  }
     77    //}
    7878    [Storable]
    7979    private int minLag;
     
    8888      set { maxLag = value; }
    8989    }
    90     #endregion
     90    //#endregion
    9191    public LaggedVariable()
    9292      : base("LaggedVariable", "Represents a variable value with a time offset.") {
    93       weightNu = 1.0;
    94       weightSigma = 1.0;
    95       weightManipulatorNu = 0.0;
    96       weightManipulatorSigma = 1.0;
    97       variableNames = new List<string>();
    98       minLag = 0; maxLag = 0;
     93      //weightNu = 1.0;
     94      //weightSigma = 1.0;
     95      //weightManipulatorNu = 0.0;
     96      //weightManipulatorSigma = 1.0;
     97      //variableNames = new List<string>();
     98      minLag = -1; maxLag = -1;
    9999    }
    100100
     
    105105    public override IDeepCloneable Clone(Cloner cloner) {
    106106      LaggedVariable clone = (LaggedVariable)base.Clone(cloner);
    107       clone.weightNu = weightNu;
    108       clone.weightSigma = weightSigma;
    109       clone.variableNames = new List<string>(variableNames);
    110       clone.weightManipulatorNu = weightManipulatorNu;
    111       clone.weightManipulatorSigma = weightManipulatorSigma;
     107      //clone.weightNu = weightNu;
     108      //clone.weightSigma = weightSigma;
     109      //clone.variableNames = new List<string>(variableNames);
     110      //clone.weightManipulatorNu = weightManipulatorNu;
     111      //clone.weightManipulatorSigma = weightManipulatorSigma;
    112112      clone.minLag = minLag;
    113113      clone.maxLag = maxLag;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs

    r3997 r4022  
    3030namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
    3131  [StorableClass]
    32   public sealed class LaggedVariableTreeNode : SymbolicExpressionTreeTerminalNode {
     32  public sealed class LaggedVariableTreeNode : VariableTreeNode {
    3333    public new LaggedVariable Symbol {
    3434      get { return (LaggedVariable)base.Symbol; }
    35     }
    36     [Storable]
    37     private double weight;
    38     public double Weight {
    39       get { return weight; }
    40       set { weight = value; }
    41     }
    42     [Storable]
    43     private string variableName;
    44     public string VariableName {
    45       get { return variableName; }
    46       set { variableName = value; }
    4735    }
    4836    [Storable]
     
    5846    private LaggedVariableTreeNode(LaggedVariableTreeNode original)
    5947      : base(original) {
    60       weight = original.weight;
    61       variableName = original.variableName;
    6248      lag = original.lag;
    6349    }
     
    7359    public override void ResetLocalParameters(IRandom random) {
    7460      base.ResetLocalParameters(random);
    75       weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightNu, Symbol.WeightSigma);
    76       variableName = Symbol.VariableNames.SelectRandom(random);
    7761      lag = random.Next(Symbol.MinLag, Symbol.MaxLag + 1);
    7862    }
     
    8064    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
    8165      base.ShakeLocalParameters(random, shakingFactor);
    82       double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorNu, Symbol.WeightManipulatorSigma);
    83       weight = weight + x * shakingFactor;
    84       variableName = Symbol.VariableNames.SelectRandom(random);
    85       lag = lag + random.Next(-1, 2);
     66      lag = Math.Min(Symbol.MaxLag, Math.Max(Symbol.MinLag, lag + random.Next(-1, 2)));
    8667    }
    8768
     
    9273
    9374    public override string ToString() {
    94       return weight.ToString("E4") + " " + variableName + " (t" + (lag > 0 ? "+" : "") + lag + ")";
     75      return base.ToString() +
     76        " (t" + (lag > 0 ? "+" : "") + lag + ")";
    9577    }
    9678  }
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs

    r3993 r4022  
    3434  [StorableClass]
    3535  [Item("Variable", "Represents a variable value.")]
    36   public sealed class Variable : Symbol {
     36  public class Variable : Symbol {
    3737    #region Properties
    3838    [Storable]
     
    9494    }
    9595    #endregion
    96     public Variable()
    97       : base("Variable", "Represents a variable value.") {
     96    public Variable() : this("Variable", "Represents a variable value.") { }
     97    public Variable(string name, string description)
     98      : base(name, description) {
    9899      weightNu = 1.0;
    99100      weightSigma = 1.0;
  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs

    r3997 r4022  
    3030namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
    3131  [StorableClass]
    32   public sealed class VariableTreeNode : SymbolicExpressionTreeTerminalNode {
     32  public class VariableTreeNode : SymbolicExpressionTreeTerminalNode {
    3333    public new Variable Symbol {
    3434      get { return (Variable)base.Symbol; }
     
    4848
    4949
    50     private VariableTreeNode() { }
     50    protected VariableTreeNode() { }
    5151
    5252    // copy constructor
    53     private VariableTreeNode(VariableTreeNode original)
     53    protected VariableTreeNode(VariableTreeNode original)
    5454      : base(original) {
    5555      weight = original.weight;
Note: See TracChangeset for help on using the changeset viewer.