Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
03/17/11 15:14:45 (14 years ago)
Author:
gkronber
Message:

#1418 implemented linear scaling for classification solutions, fixed bugs interactive simplifier view for classification solutions.

Location:
branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/Interfaces/ISymbolicDiscriminantFunctionClassificationModel.cs

    r5717 r5736  
    2323namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Classification {
    2424  public interface ISymbolicDiscriminantFunctionClassificationModel : IDiscriminantFunctionClassificationModel, ISymbolicClassificationModel {
     25    double LowerEstimationLimit { get; }
     26    double UpperEstimationLimit { get; }
    2527  }
    2628}

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveTrainingBestSolutionAnalyzer.cs

    r5722 r5736  
    9595    }
    9696
    97 
    9897    protected override ISymbolicClassificationSolution CreateSolution(ISymbolicExpressionTree bestTree, double[] bestQuality) {
    99       double[] classValues;
    100       double[] thresholds;
    101       var estimatedValues = SymbolicDataAnalysisTreeInterpreter.GetSymbolicExpressionTreeValues(bestTree, ProblemData.Dataset, ProblemData.TrainingIndizes)
    102         .LimitToRange(LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    103       var targetValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
    104       AccuracyMaximizationThresholdCalculator.CalculateThresholds(ProblemData, estimatedValues, targetValues, out classValues, out thresholds);
    105       var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, classValues, thresholds, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    106       return new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     98      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
     99      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     100      if (ApplyLinearScaling.Value) {
     101        solution.ScaleModel();
     102      }
     103      return solution;
    107104    }
    108105  }

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveValidationBestSolutionAnalyzer.cs

    r5722 r5736  
    8181
    8282    protected override ISymbolicClassificationSolution CreateSolution(ISymbolicExpressionTree bestTree, double[] bestQualities) {
    83       double[] classValues;
    84       double[] thresholds;
    85       // calculate thresholds on the whole training set even for the validation best solution
    86       var estimatedValues = SymbolicDataAnalysisTreeInterpreter.GetSymbolicExpressionTreeValues(bestTree, ProblemData.Dataset, ProblemData.TrainingIndizes)
    87         .LimitToRange(LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    88       var targetClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
    89       AccuracyMaximizationThresholdCalculator.CalculateThresholds(ProblemData, estimatedValues, targetClassValues, out classValues, out thresholds);
    90       var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, classValues, thresholds, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    91       return new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     83      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
     84      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     85      if (ApplyLinearScaling.Value) {
     86        solution.ScaleModel();
     87      }
     88      return solution;
    9289    }
    9390  }

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveTrainingBestSolutionAnalyzer.cs

    r5722 r5736  
    9696
    9797    protected override ISymbolicClassificationSolution CreateSolution(ISymbolicExpressionTree bestTree, double bestQuality) {
    98       double[] classValues;
    99       double[] thresholds;
    100       var estimatedValues = SymbolicDataAnalysisTreeInterpreter.GetSymbolicExpressionTreeValues(bestTree, ProblemData.Dataset, ProblemData.TrainingIndizes)
    101         .LimitToRange(LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    102       var targetValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
    103       AccuracyMaximizationThresholdCalculator.CalculateThresholds(ProblemData, estimatedValues, targetValues, out classValues, out thresholds);
    104       var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, classValues, thresholds, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    105       return new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     98      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
     99      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     100      if (ApplyLinearScaling.Value) {
     101        solution.ScaleModel();
     102      }
     103      return solution;
    106104    }
    107105  }

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveValidationBestSolutionAnalyzer.cs

    r5722 r5736  
    8282
    8383    protected override ISymbolicClassificationSolution CreateSolution(ISymbolicExpressionTree bestTree, double bestQuality) {
    84       double[] classValues;
    85       double[] thresholds;
    86       // calculate thresholds on the whole training set even for the validation best solution
    87       var estimatedValues = SymbolicDataAnalysisTreeInterpreter.GetSymbolicExpressionTreeValues(bestTree, ProblemData.Dataset, ProblemData.TrainingIndizes)
    88         .LimitToRange(LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    89       var targetClassValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
    90       AccuracyMaximizationThresholdCalculator.CalculateThresholds(ProblemData, estimatedValues, targetClassValues, out classValues, out thresholds);
    91       var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, classValues, thresholds, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
    92       return new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     84      var model = new SymbolicDiscriminantFunctionClassificationModel(bestTree, SymbolicDataAnalysisTreeInterpreter, LowerEstimationLimit.Value, UpperEstimationLimit.Value);
     85      var solution = new SymbolicDiscriminantFunctionClassificationSolution(model, ProblemData);
     86      if (ApplyLinearScaling.Value) {
     87        solution.ScaleModel();
     88      }
     89      return solution;
    9390    }
    9491  }

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationSolution.cs

    r5717 r5736  
    3939  [Item(Name = "SymbolicClassificationSolution", Description = "Represents a symbolic classification solution (model + data) and attributes of the solution like accuracy and complexity.")]
    4040  public sealed class SymbolicClassificationSolution : ClassificationSolution, ISymbolicClassificationSolution {
    41     #region ISymbolicClassificationSolution Members
     41    private const string ModelLengthResultName = "ModelLength";
     42    private const string ModelDepthResultName = "ModelDepth";
    4243
    4344    public new ISymbolicClassificationModel Model {
    … …  
    4950      get { return (ISymbolicDataAnalysisModel)base.Model; }
    5051    }
     52    public int ModelLength {
     53      get { return ((IntValue)this[ModelLengthResultName].Value).Value; }
     54      private set { ((IntValue)this[ModelLengthResultName].Value).Value = value; }
     55    }
    5156
    52     #endregion
     57    public int ModelDepth {
     58      get { return ((IntValue)this[ModelDepthResultName].Value).Value; }
     59      private set { ((IntValue)this[ModelDepthResultName].Value).Value = value; }
     60    }
     61
    5362    [StorableConstructor]
    5463    private SymbolicClassificationSolution(bool deserializing) : base(deserializing) { }
    … …  
    5867    public SymbolicClassificationSolution(ISymbolicClassificationModel model, IClassificationProblemData problemData)
    5968      : base(model, problemData) {
     69      Add(new Result(ModelLengthResultName, "Length of the symbolic classification model.", new IntValue()));
     70      Add(new Result(ModelDepthResultName, "Depth of the symbolic classification model.", new IntValue()));
     71      RecalculateResults();
    6072    }
    6173
    … …  
    6375      return new SymbolicClassificationSolution(this, cloner);
    6476    }
     77
     78    protected override void OnModelChanged(EventArgs e) {
     79      base.OnModelChanged(e);
     80      RecalculateResults();
     81    }
     82
     83    private new void RecalculateResults() {
     84      ModelLength = Model.SymbolicExpressionTree.Length;
     85      ModelDepth = Model.SymbolicExpressionTree.Depth;
     86    }
    6587  }
    6688}

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs

    r5720 r5736  
    4444    public IEnumerable<double> Thresholds {
    4545      get { return (IEnumerable<double>)thresholds.Clone(); }
    46       set {
    47         thresholds = value.ToArray();
    48         OnThresholdsChanged(EventArgs.Empty);
    49       }
     46      private set { thresholds = value.ToArray(); }
    5047    }
    5148    [Storable]
    … …  
    5350    public IEnumerable<double> ClassValues {
    5451      get { return (IEnumerable<double>)classValues.Clone(); }
    55       set { classValues = value.ToArray(); }
     52      private set { classValues = value.ToArray(); }
    5653    }
    5754    [Storable]
    … …  
    7269    }
    7370    public SymbolicDiscriminantFunctionClassificationModel(ISymbolicExpressionTree tree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
    74       IEnumerable<double> classValues, IEnumerable<double> thresholds,
    7571      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue)
    7672      : base(tree, interpreter) {
    77       this.classValues = classValues.ToArray();
    78       this.thresholds = thresholds.ToArray();
     73      thresholds = new double[] { double.NegativeInfinity };
     74      classValues = new double[] { 0.0 };
    7975      this.lowerEstimationLimit = lowerEstimationLimit;
    8076      this.upperEstimationLimit = upperEstimationLimit;
    … …  
    8581    }
    8682
     83    public void SetThresholdsAndClassValues(IEnumerable<double> thresholds, IEnumerable<double> classValues) {
     84      var classValuesArr = classValues.ToArray();
     85      var thresholdsArr = thresholds.ToArray();
     86      if (thresholdsArr.Length != classValuesArr.Length) throw new ArgumentException();
     87
     88      this.classValues = classValuesArr;
     89      this.thresholds = thresholdsArr;
     90      OnThresholdsChanged(EventArgs.Empty);
     91    }
     92
    8793    public IEnumerable<double> GetEstimatedValues(Dataset dataset, IEnumerable<int> rows) {
    88       return Interpreter.GetSymbolicExpressionTreeValues(SymbolicExpressionTree, dataset, rows);
     94      return Interpreter.GetSymbolicExpressionTreeValues(SymbolicExpressionTree, dataset, rows)
     95        .LimitToRange(lowerEstimationLimit, upperEstimationLimit);
    8996    }
    9097

  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationSolution.cs

    r5717 r5736  
    3939  [Item(Name = "SymbolicDiscriminantFunctionClassificationSolution", Description = "Represents a symbolic classification solution (model + data) and attributes of the solution like accuracy and complexity.")]
    4040  public sealed class SymbolicDiscriminantFunctionClassificationSolution : DiscriminantFunctionClassificationSolution, ISymbolicClassificationSolution {
     41    private const string ModelLengthResultName = "ModelLength";
     42    private const string ModelDepthResultName = "ModelDepth";
    4143
    4244    public new ISymbolicDiscriminantFunctionClassificationModel Model {
    … …  
    5254      get { return Model; }
    5355    }
     56    public int ModelLength {
     57      get { return ((IntValue)this[ModelLengthResultName].Value).Value; }
     58      private set { ((IntValue)this[ModelLengthResultName].Value).Value = value; }
     59    }
    5460
     61    public int ModelDepth {
     62      get { return ((IntValue)this[ModelDepthResultName].Value).Value; }
     63      private set { ((IntValue)this[ModelDepthResultName].Value).Value = value; }
     64    }
    5565    [StorableConstructor]
    5666    private SymbolicDiscriminantFunctionClassificationSolution(bool deserializing) : base(deserializing) { }
    … …  
    6070    public SymbolicDiscriminantFunctionClassificationSolution(ISymbolicDiscriminantFunctionClassificationModel model, IClassificationProblemData problemData)
    6171      : base(model, problemData) {
     72      Add(new Result(ModelLengthResultName, "Length of the symbolic classification model.", new IntValue()));
     73      Add(new Result(ModelDepthResultName, "Depth of the symbolic classification model.", new IntValue()));
     74      RecalculateResults();
    6275    }
    6376
    … …  
    6578      return new SymbolicDiscriminantFunctionClassificationSolution(this, cloner);
    6679    }
     80
     81    protected override void OnModelChanged(EventArgs e) {
     82      base.OnModelChanged(e);
     83      RecalculateResults();
     84    }
     85
     86    private new void RecalculateResults() {
     87      ModelLength = Model.SymbolicExpressionTree.Length;
     88      ModelDepth = Model.SymbolicExpressionTree.Depth;
     89    }
     90
     91    public void ScaleModel() {
     92      var dataset = ProblemData.Dataset;
     93      var targetVariable = ProblemData.TargetVariable;
     94      var rows = ProblemData.TrainingIndizes;
     95      var estimatedValues = GetEstimatedValues(rows);
     96      var targetValues = dataset.GetEnumeratedVariableValues(targetVariable, rows);
     97      double alpha;
     98      double beta;
     99      OnlineLinearScalingParameterCalculator.Calculate(estimatedValues, targetValues, out alpha, out beta);
     100
     101      ConstantTreeNode alphaTreeNode = null;
     102      ConstantTreeNode betaTreeNode = null;
     103      // check if model has been scaled previously by analyzing the structure of the tree
     104      var startNode = Model.SymbolicExpressionTree.Root.GetSubtree(0);
     105      if (startNode.GetSubtree(0).Symbol is Addition) {
     106        var addNode = startNode.GetSubtree(0);
     107        if (addNode.SubtreesCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication && addNode.GetSubtree(1).Symbol is Constant) {
     108          alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode;
     109          var mulNode = addNode.GetSubtree(0);
     110          if (mulNode.SubtreesCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
     111            betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode;
     112          }
     113        }
     114      }
     115      // if tree structure matches the structure necessary for linear scaling then reuse the existing tree nodes
     116      if (alphaTreeNode != null && betaTreeNode != null) {
     117        betaTreeNode.Value *= beta;
     118        alphaTreeNode.Value *= beta;
     119        alphaTreeNode.Value += alpha;
     120      } else {
     121        var mainBranch = startNode.GetSubtree(0);
     122        startNode.RemoveSubtree(0);
     123        var scaledMainBranch = MakeSum(MakeProduct(beta, mainBranch), alpha);
     124        startNode.AddSubtree(scaledMainBranch);
     125      }
     126
     127      OnModelChanged(EventArgs.Empty);
     128    }
     129
     130    private static ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode treeNode, double alpha) {
     131      if (alpha.IsAlmost(0.0)) {
     132        return treeNode;
     133      } else {
     134        var node = (new Addition()).CreateTreeNode();
     135        var alphaConst = MakeConstant(alpha);
     136        node.AddSubtree(treeNode);
     137        node.AddSubtree(alphaConst);
     138        return node;
     139      }
     140    }
     141
     142    private static ISymbolicExpressionTreeNode MakeProduct(double beta, ISymbolicExpressionTreeNode treeNode) {
     143      if (beta.IsAlmost(1.0)) {
     144        return treeNode;
     145      } else {
     146        var node = (new Multiplication()).CreateTreeNode();
     147        var betaConst = MakeConstant(beta);
     148        node.AddSubtree(treeNode);
     149        node.AddSubtree(betaConst);
     150        return node;
     151      }
     152    }
     153
     154    private static ISymbolicExpressionTreeNode MakeConstant(double c) {
     155      var node = (ConstantTreeNode)(new Constant()).CreateTreeNode();
     156      node.Value = c;
     157      return node;
     158    }
    67159  }
    68160}
Note: See TracChangeset for help on using the changeset viewer.