source: branches/ClassificationEnsembleVoting/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/WeightCalculators/ClassificationWeightCalculator.cs @ 8811

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.DataAnalysis {
  /// <summary>
  /// Base class for weight calculators for classification solutions in an ensemble.
  /// </summary>
  [StorableClass]
  public abstract class ClassificationWeightCalculator : NamedItem, IClassificationEnsembleSolutionWeightCalculator {
    [StorableConstructor]
    protected ClassificationWeightCalculator(bool deserializing) : base(deserializing) { }
    protected ClassificationWeightCalculator(ClassificationWeightCalculator original, Cloner cloner)
      : base(original, cloner) {
    }
    public ClassificationWeightCalculator()
      : base() {
      this.name = ItemName;
      this.description = ItemDescription;
    }

    private IDictionary<IClassificationSolution, double> weights;

    /// <summary>
    /// calls CalculateWeights and removes negative weights 
    /// </summary>
    /// <param name="classificationSolutions"></param>
    /// <returns>weights which are equal or bigger than zero</returns>
    public void CalculateNormalizedWeights(IEnumerable<IClassificationSolution> classificationSolutions) {
      List<double> weights = new List<double>();
      if (classificationSolutions.Count() > 0) {
        foreach (var weight in CalculateWeights(classificationSolutions)) {
          weights.Add(weight >= 0 ? weight : 0);
        }
      }
      double sum = weights.Sum();
      this.weights = classificationSolutions.Zip(weights, (sol, wei) => new { sol, wei }).ToDictionary(x => x.sol, x => x.wei / sum);
    }

    protected abstract IEnumerable<double> CalculateWeights(IEnumerable<IClassificationSolution> classificationSolutions);

    #region delegate CheckPoint
    public CheckPoint GetTestClassDelegate() {
      return PointInTest;
    }
    public CheckPoint GetTrainingClassDelegate() {
      return PointInTraining;
    }
    public CheckPoint GetAllClassDelegate() {
      return AllPoints;
    }
    #endregion

    public virtual IEnumerable<double> AggregateEstimatedClassValues(IEnumerable<IClassificationSolution> solutions, Dataset dataset, IEnumerable<int> rows, CheckPoint handler) {
      return from xs in GetEstimatedClassValues(solutions, dataset, rows, handler)
             select AggregateEstimatedClassValues(xs);
    }

    protected double AggregateEstimatedClassValues(IDictionary<IClassificationSolution, double> estimatedClassValues) {
      IDictionary<double, double> weightSum = new Dictionary<double, double>();
      foreach (var item in estimatedClassValues) {
        if (!weightSum.ContainsKey(item.Value))
          weightSum[item.Value] = 0.0;
        weightSum[item.Value] += weights[item.Key];
      }
      if (weightSum.Count <= 0)
        return double.NaN;
      var max = weightSum.Max(x => x.Value);
      max = weightSum
        .Where(x => x.Value.Equals(max))
        .Select(x => x.Key)
        .First();
      return max;
    }

    protected IEnumerable<IDictionary<IClassificationSolution, double>> GetEstimatedClassValues(IEnumerable<IClassificationSolution> solutions, Dataset dataset, IEnumerable<int> rows, CheckPoint handler) {
      var estimatedValuesEnumerators = (from solution in solutions
                                        select new { Solution = solution, EstimatedValuesEnumerator = solution.Model.GetEstimatedClassValues(dataset, rows).GetEnumerator() })
                                       .ToList();

      var rowEnumerator = rows.GetEnumerator();
      while (rowEnumerator.MoveNext() & estimatedValuesEnumerators.All(x => x.EstimatedValuesEnumerator.MoveNext())) {
        yield return (from enumerator in estimatedValuesEnumerators
                      where handler(enumerator.Solution.ProblemData, rowEnumerator.Current)
                      select enumerator)
                     .ToDictionary(x => x.Solution, x => x.EstimatedValuesEnumerator.Current);
      }
    }

    public virtual double GetConfidence(IEnumerable<IClassificationSolution> solutions, int index, double estimatedClassValue) {
      if (solutions.Count() < 1)
        return double.NaN;
      Dataset dataset = solutions.First().ProblemData.Dataset;
      var correctSolutions = solutions.Select(s => new { Solution = s, Values = s.Model.GetEstimatedClassValues(dataset, Enumerable.Repeat(index, 1)).First() })
                                      .Where(a => a.Values.Equals(estimatedClassValue))
                                      .Select(a => a.Solution);
      return (from sol in correctSolutions
              select weights[sol]).Sum();
    }

    public virtual IEnumerable<double> GetConfidence(IEnumerable<IClassificationSolution> solutions, IEnumerable<int> indices, IEnumerable<double> estimatedClassValue) {
      if (solutions.Count() < 1)
        return Enumerable.Repeat(double.NaN, indices.Count());

      Dataset dataset = solutions.First().ProblemData.Dataset;
      Dictionary<IClassificationSolution, double[]> solValues = solutions.ToDictionary(x => x, x => x.Model.GetEstimatedClassValues(dataset, indices).ToArray());
      double[] estimatedClassValueArr = estimatedClassValue.ToArray();
      double[] confidences = new double[indices.Count()];

      for (int i = 0; i < indices.Count(); i++) {
        var correctSolutions = solValues.Where(x => DoubleExtensions.IsAlmost(x.Value[i], estimatedClassValueArr[i]));
        confidences[i] = (from sol in correctSolutions
                          select weights[sol.Key]).Sum();
      }

      return confidences;
    }

    #region Helper
    protected IEnumerable<double> GetValues(IList<double> targetValues, IEnumerable<int> indizes) {
      return from i in indizes
             select targetValues[i];
    }
    protected bool PointInTraining(IClassificationProblemData problemData, int point) {
      IntRange trainingPartition = problemData.TrainingPartition;
      IntRange testPartition = problemData.TestPartition;
      return (trainingPartition.Start <= point && point < trainingPartition.End)
        && !(testPartition.Start <= point && point < testPartition.End);
    }
    protected bool PointInTest(IClassificationProblemData problemData, int point) {
      IntRange testPartition = problemData.TestPartition;
      return testPartition.Start <= point && point < testPartition.End;
    }
    protected bool AllPoints(IClassificationProblemData problemData, int point) {
      return true;
    }
    #endregion
  }
}