Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
03/30/11 18:04:03 (13 years ago)
Author:
gkronber
Message:

#1453: Added an ErrorState property to online evaluators to indicate if the result value is valid or if there has been an error in the calculation. Adapted all classes that use one of the online evaluators to check this property.

Location:
trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineAccuracyEvaluator.cs

    r5809 r5894  
    3131    public double Accuracy {
    3232      get {
    33         if (n < 1)
    34           throw new InvalidOperationException("No elements");
    35         else
    36           return correctlyClassified / (double)n;
     33        return correctlyClassified / (double)n;
    3734      }
    3835    }
    … …  
    4340
    4441    #region IOnlineEvaluator Members
     42    private OnlineEvaluatorError errorState;
     43    public OnlineEvaluatorError ErrorState {
     44      get { return errorState; }
     45    }
    4546    public double Value {
    4647      get { return Accuracy; }
    … …  
    4950      n = 0;
    5051      correctlyClassified = 0;
     52      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    5153    }
    5254
    5355    public void Add(double original, double estimated) {
    54       if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    55           double.IsNaN(original) || double.IsInfinity(original)) {
    56         throw new ArgumentException("Accuracy is not defined for NaN or infinity elements");
    57       } else {
    58         if (original.IsAlmost(estimated)) correctlyClassified++;
     56      // ignore cases where original is NaN completly
     57      if (!double.IsNaN(original)) {
     58        // increment number of observed samples
    5959        n++;
     60        if (original.IsAlmost(estimated)) {
     61          // original = estimated = +Inf counts as correctly classified
     62          // original = estimated = -Inf counts as correctly classified
     63          correctlyClassified++;
     64        }
     65        errorState = OnlineEvaluatorError.None; // number of (non-NaN) samples >= 1
    6066      }
    6167    }
    6268    #endregion
    6369
    64     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     70    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6571      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6672      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7884        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    7985      } else {
     86        errorState = accuracyEvaluator.ErrorState;
    8087        return accuracyEvaluator.Accuracy;
    8188      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineCovarianceEvaluator.cs

    r5845 r5894  
    3939
    4040    #region IOnlineEvaluator Members
     41    private OnlineEvaluatorError errorState;
     42    public OnlineEvaluatorError ErrorState {
     43      get { return errorState; }
     44    }
    4145    public double Value {
    4246      get { return Covariance; }
    … …  
    4751      originalMean = 0.0;
    4852      estimatedMean = 0.0;
     53      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    4954    }
    5055
    5156    public void Add(double original, double estimated) {
    52       if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    53           double.IsNaN(original) || double.IsInfinity(original) ||
    54          double.IsNaN(Cn)) {
    55         Cn = double.NaN;
    56       } else {
     57      if (double.IsNaN(estimated) || double.IsInfinity(estimated) || double.IsNaN(original) || double.IsInfinity(original)) {
     58        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     59      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
    5760        n++;
     61        errorState = OnlineEvaluatorError.None;        // n >= 1
     62
    5863        // online calculation of tMean
    5964        originalMean = originalMean + (original - originalMean) / n;
    … …  
    6772    #endregion
    6873
    69     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     74    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    7075      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    7176      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    8388        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    8489      } else {
     90        errorState = covarianceEvaluator.ErrorState;
    8591        return covarianceEvaluator.Covariance;
    8692      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineLinearScalingParameterCalculator.cs

    r5818 r5894  
    3232    public double Alpha {
    3333      get {
    34         if (cnt < 2)
    35           return 0;
    36         else
    37           return targetMeanCalculator.Mean - Beta * originalMeanAndVarianceCalculator.Mean;
     34        return targetMeanCalculator.Mean - Beta * originalMeanAndVarianceCalculator.Mean;
    3835      }
    3936    }
    … …  
    4441    public double Beta {
    4542      get {
    46         if (cnt < 2)
    47           return 1;
    48         else if (originalMeanAndVarianceCalculator.PopulationVariance.IsAlmost(0.0))
     43        if (originalMeanAndVarianceCalculator.PopulationVariance.IsAlmost(0.0))
    4944          return 1;
    5045        else
    5146          return originalTargetCovarianceEvaluator.Covariance / originalMeanAndVarianceCalculator.PopulationVariance;
     47      }
     48    }
     49
     50    public OnlineEvaluatorError ErrorState {
     51      get {
     52        return targetMeanCalculator.MeanErrorState | originalMeanAndVarianceCalculator.MeanErrorState |
     53          originalMeanAndVarianceCalculator.PopulationVarianceErrorState | originalTargetCovarianceEvaluator.ErrorState;
    5254      }
    5355    }
    … …  
    9496    /// <param name="alpha">Additive constant for the linear scaling</param>
    9597    /// <param name="beta">Multiplicative factor for the linear scaling</param>
    96     public static void Calculate(IEnumerable<double> original, IEnumerable<double> target, out double alpha, out double beta) {
     98    /// <param name="errorState">Flag that indicates if errors occurred in the calculation of the linea scaling parameters.</param>
     99    public static void Calculate(IEnumerable<double> original, IEnumerable<double> target, out double alpha, out double beta, out OnlineEvaluatorError errorState) {
    97100      OnlineLinearScalingParameterCalculator calculator = new OnlineLinearScalingParameterCalculator();
    98101      IEnumerator<double> originalEnumerator = original.GetEnumerator();
    … …  
    110113        throw new ArgumentException("Number of elements in original and target enumeration do not match.");
    111114      } else {
     115        errorState = calculator.ErrorState;
    112116        alpha = calculator.Alpha;
    113117        beta = calculator.Beta;

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAbsolutePercentageErrorEvaluator.cs

    r5845 r5894  
    4040
    4141    #region IOnlineEvaluator Members
     42    private OnlineEvaluatorError errorState;
     43    public OnlineEvaluatorError ErrorState {
     44      get { return errorState; }
     45    }
    4246    public double Value {
    4347      get { return MeanAbsolutePercentageError; }
    … …  
    4650      n = 0;
    4751      sre = 0.0;
     52      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    4853    }
    4954
    … …  
    5156      if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    5257          double.IsNaN(original) || double.IsInfinity(original) ||
    53         double.IsNaN(sre)) {
    54         sre = double.NaN;
    55       } else {
    56         if (!original.IsAlmost(0.0)) {
    57           sre += Math.Abs((estimated - original) / original);
    58           n++;
    59         }
     58        original.IsAlmost(0.0)) {
     59        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     60      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
     61        sre += Math.Abs((estimated - original) / original);
     62        n++;
     63        errorState = OnlineEvaluatorError.None; // n >= 1
    6064      }
    6165    }
    … …  
    6367    #endregion
    6468
    65     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     69    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6670      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6771      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7983        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    8084      } else {
     85        errorState = evaluator.ErrorState;
    8186        return evaluator.MeanAbsolutePercentageError;
    8287      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanAndVarianceCalculator.cs

    r5845 r5894  
    2929    private int n;
    3030
     31    private OnlineEvaluatorError varianceErrorState;
     32    public OnlineEvaluatorError VarianceErrorState {
     33      get { return varianceErrorState; }
     34    }
     35
    3136    public double Variance {
    3237      get {
    … …  
    3540    }
    3641
     42    private OnlineEvaluatorError errorState;
     43    public OnlineEvaluatorError PopulationVarianceErrorState {
     44      get { return errorState; }
     45    }
    3746    public double PopulationVariance {
    3847      get {
    … …  
    4150    }
    4251
     52    public OnlineEvaluatorError MeanErrorState {
     53      get { return errorState; }
     54    }
    4355    public double Mean {
    4456      get {
    … …  
    5769    public void Reset() {
    5870      n = 0;
     71      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
     72      varianceErrorState = OnlineEvaluatorError.InsufficientElementsAdded;
    5973    }
    6074
    6175    public void Add(double x) {
    62       if (double.IsNaN(x) || double.IsInfinity(x) || double.IsNaN(m_newM)) {
    63         m_newM = double.NaN;
    64         m_newS = double.NaN;
    65       } else {
     76      if (double.IsNaN(x) || double.IsInfinity(x)) {
     77        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     78        varianceErrorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     79      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
    6680        n++;
    6781        // See Knuth TAOCP vol 2, 3rd edition, page 232
    … …  
    6983          m_oldM = m_newM = x;
    7084          m_oldS = 0.0;
     85          errorState = OnlineEvaluatorError.None; // n >= 1
    7186        } else {
     87          varianceErrorState = OnlineEvaluatorError.None; // n >= 1
    7288          m_newM = m_oldM + (x - m_oldM) / n;
    7389          m_newS = m_oldS + (x - m_oldM) * (x - m_newM);
    … …  
    8096    }
    8197
    82     public static void Calculate(IEnumerable<double> x, out double mean, out double variance) {
     98    public static void Calculate(IEnumerable<double> x, out double mean, out double variance, out OnlineEvaluatorError meanErrorState, out OnlineEvaluatorError varianceErrorState) {
    8399      OnlineMeanAndVarianceCalculator meanAndVarianceCalculator = new OnlineMeanAndVarianceCalculator();
    84100      foreach (double xi in x) {
    … …  
    87103      mean = meanAndVarianceCalculator.Mean;
    88104      variance = meanAndVarianceCalculator.Variance;
     105      meanErrorState = meanAndVarianceCalculator.MeanErrorState;
     106      varianceErrorState = meanAndVarianceCalculator.VarianceErrorState;
    89107    }
    90108  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineMeanSquaredErrorEvaluator.cs

    r5845 r5894  
    3939
    4040    #region IOnlineEvaluator Members
     41    private OnlineEvaluatorError errorState;
     42    public OnlineEvaluatorError ErrorState {
     43      get { return errorState; }
     44    }
    4145    public double Value {
    4246      get { return MeanSquaredError; }
    … …  
    4549      n = 0;
    4650      sse = 0.0;
     51      errorState = OnlineEvaluatorError.InsufficientElementsAdded;
    4752    }
    4853
    4954    public void Add(double original, double estimated) {
    5055      if (double.IsNaN(estimated) || double.IsInfinity(estimated) ||
    51           double.IsNaN(original) || double.IsInfinity(original) ||
    52         double.IsNaN(sse)) {
    53         sse = double.NaN;
    54       } else {
     56          double.IsNaN(original) || double.IsInfinity(original)) {
     57        errorState = errorState | OnlineEvaluatorError.InvalidValueAdded;
     58      } else if (!errorState.HasFlag(OnlineEvaluatorError.InvalidValueAdded)) {
    5559        double error = estimated - original;
    5660        sse += error * error;
    5761        n++;
     62        errorState = OnlineEvaluatorError.None; // n >= 1
    5863      }
    5964    }
    6065    #endregion
    6166
    62     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     67    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6368      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6469      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7681        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    7782      } else {
     83        errorState = mseEvaluator.ErrorState;
    7884        return mseEvaluator.MeanSquaredError;
    7985      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlineNormalizedMeanSquaredErrorEvaluator.cs

    r5809 r5894  
    4343
    4444    #region IOnlineEvaluator Members
     45    public OnlineEvaluatorError ErrorState {
     46      get { return meanSquaredErrorCalculator.MeanErrorState | originalVarianceCalculator.VarianceErrorState; }
     47    }
    4548    public double Value {
    4649      get { return NormalizedMeanSquaredError; }
    … …  
    6063    #endregion
    6164
    62     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     65    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6366      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6467      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    7679        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    7780      } else {
     81        errorState = normalizedMSEEvaluator.ErrorState;
    7882        return normalizedMSEEvaluator.NormalizedMeanSquaredError;
    7983      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/OnlineEvaluators/OnlinePearsonsRSquaredEvaluator.cs

    r5809 r5894  
    4646
    4747    #region IOnlineEvaluator Members
     48    public OnlineEvaluatorError ErrorState {
     49      get { return covEvaluator.ErrorState | sxEvaluator.PopulationVarianceErrorState | syEvaluator.PopulationVarianceErrorState; }
     50    }
    4851    public double Value {
    4952      get { return RSquared; }
    … …  
    6467    #endregion
    6568
    66     public static double Calculate(IEnumerable<double> first, IEnumerable<double> second) {
     69    public static double Calculate(IEnumerable<double> first, IEnumerable<double> second, out OnlineEvaluatorError errorState) {
    6770      IEnumerator<double> firstEnumerator = first.GetEnumerator();
    6871      IEnumerator<double> secondEnumerator = second.GetEnumerator();
    … …  
    8083        throw new ArgumentException("Number of elements in first and second enumeration doesn't match.");
    8184      } else {
     85        errorState = rSquaredEvaluator.ErrorState;
    8286        return rSquaredEvaluator.RSquared;
    8387      }
Note: See TracChangeset for help on using the changeset viewer.