source: branches/2457_ExpertSystem/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/SolutionModel/Univariate/UnivariateModelTrainer.cs @ 15762

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2016 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;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Core;

namespace HeuristicLab.Encodings.BinaryVectorEncoding.SolutionModel {
  public static class UnivariateModelTrainer {
    /// <summary>
    /// Creates a univariate sampling model out of a ranked population.
    /// The first solution in <paramref name="rankedPopulation"/> is the 
    /// highest influential one, the last solution has the least influence.
    /// </summary>
    /// <param name="random">The model is stochastic and will use this RNG for sampling.</param>
    /// <param name="maximization">Whether higher or lower qualities are better</param>
    /// <param name="population">The population that is ranked from highest influential to least influential, e.g. best to worst.</param>
    /// <param name="qualities">The solution quality of the respective solution.</param>
    /// <returns>The sampling model which is created with the given population.</returns>
    public static UnivariateModel TrainWithRankBias(IRandom random, bool maximization, IEnumerable<BinaryVector> population, IEnumerable<double> qualities) {
      var popSize = 0;
      double[] model = null;
      var pop = population.Zip(qualities, (b, q) => new { Solution = b, Fitness = q });
      foreach (var ind in maximization ? pop.OrderBy(x => x.Fitness) : pop.OrderByDescending(x => x.Fitness)) {
        // from worst to best, worst solution has 1 vote, best solution N votes
        popSize++;
        if (model == null) model = new double[ind.Solution.Length];
        for (var x = 0; x < model.Length; x++) {
          if (ind.Solution[x]) model[x] += popSize;
        }
      }
      if (model == null) throw new ArgumentException("Cannot train model from empty population.");
      // normalize to [0;1]
      var factor = 2.0 / (popSize + 1);
      for (var i = 0; i < model.Length; i++) {
        model[i] *= factor / popSize;
      }
      return new UnivariateModel(random, model);
    }

    /// <summary>
    /// Creates a univariate sampling model out of solutions and their given fitness.
    /// The best solution's influence is proportional to its fitness, while the worst
    /// solution does not have an influence at all (except if the fitness of worst and
    /// best are equal).
    /// </summary>
    /// <param name="random">The model is stochastic and makes use of this RNG instance for sampling.</param>
    /// <param name="maximization">Whether higher fitness values are better or lower ones.</param>
    /// <param name="population">The solutions that will be used to create the model.</param>
    /// <param name="qualities">The solutions' associated qualities.</param>
    /// <returns>The sampling model which is created with the given population.</returns>
    public static UnivariateModel TrainWithFitnessBias(IRandom random, bool maximization, IEnumerable<BinaryVector> population, IEnumerable<double> qualities) {
      var proportions = PrepareProportional(qualities, true, !maximization);
      var factor = 1.0 / proportions.Sum();
      double[] model = null;
      foreach (var ind in population.Zip(proportions, (p, q) => new { Solution = p, Proportion = q })) {
        if (model == null) model = new double[ind.Solution.Length];
        for (var x = 0; x < model.Length; x++) {
          if (ind.Solution[x]) model[x] += ind.Proportion * factor;
        }
      }
      if (model == null) throw new ArgumentException("Cannot train model from empty population.");
      return new UnivariateModel(random, model);
    }

    /// <summary>
    /// Creates a univariate sampling model out of solutions. Each of the solutions
    /// has the same influence on the model.
    /// </summary>
    /// <param name="random">The model is stochastic and will make use of this RNG instance.</param>
    /// <param name="population">The solutions that are used to create the model.</param>
    /// <returns>The model created from the population.</returns>
    public static UnivariateModel TrainUnbiased(IRandom random, IEnumerable<BinaryVector> population) {
      double[] model = null;
      var popSize = 0;
      foreach (var p in population) {
        popSize++;
        if (model == null) model = new double[p.Length];
        for (var x = 0; x < model.Length; x++) {
          if (p[x]) model[x]++;
        }
      }
      if (model == null) throw new ArgumentException("Cannot train model from empty population.");
      // normalize to [0;1]
      var factor = 1.0 / popSize;
      for (var x = 0; x < model.Length; x++) {
        model[x] *= factor;
      }
      return new UnivariateModel(random, model);
    }

    // TODO: make PrepareProportional public in EnumerableExtensions
    private static double[] PrepareProportional(IEnumerable<double> weights, bool windowing, bool inverseProportional) {
      double maxValue = double.MinValue, minValue = double.MaxValue;
      double[] valueArray = weights.ToArray();

      for (int i = 0; i < valueArray.Length; i++) {
        if (valueArray[i] > maxValue) maxValue = valueArray[i];
        if (valueArray[i] < minValue) minValue = valueArray[i];
      }
      if (minValue == maxValue) {  // all values are equal
        for (int i = 0; i < valueArray.Length; i++) {
          valueArray[i] = 1.0;
        }
      } else {
        if (windowing) {
          if (inverseProportional) InverseProportionalScale(valueArray, maxValue);
          else ProportionalScale(valueArray, minValue);
        } else {
          if (minValue < 0.0) throw new InvalidOperationException("Proportional selection without windowing does not work with values < 0.");
          if (inverseProportional) InverseProportionalScale(valueArray, 2 * maxValue);
        }
      }
      return valueArray;
    }
    private static void ProportionalScale(double[] values, double minValue) {
      for (int i = 0; i < values.Length; i++) {
        values[i] = values[i] - minValue;
      }
    }
    private static void InverseProportionalScale(double[] values, double maxValue) {
      for (int i = 0; i < values.Length; i++) {
        values[i] = maxValue - values[i];
      }
    }
  }
}