source: branches/FitnessLandscapeAnalysis/HeuristicLab.Problems.NK/NKEvaluatator.cs @ 11890

using System;
using System.Security.Cryptography;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using System.Threading;
namespace HeuristicLab.Problems.NK {

  [Item("NK Landscape Evaluator", "Evaluates 'points' on an NK Landscape.")]
  [StorableClass]
  public class NKEvaluator : SingleSuccessorOperator, INKEvaluator {

    #region Parameters

    public ILookupParameter<DoubleValue> QualityParameter {
      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
    }
    public LookupParameter<DoubleArray> F_iParameter {
      get { return (LookupParameter<DoubleArray>)Parameters["F_i"]; }
    }
    public ILookupParameter<BinaryVector> BinaryVectorParameter {
      get { return (ILookupParameter<BinaryVector>)Parameters["BinaryVector"]; }
    }
    public LookupParameter<BoolMatrix> GeneInteractionsParameter {
      get { return (LookupParameter<BoolMatrix>)Parameters["GeneInteractions"]; }
    }
    public LookupParameter<IntValue> InteractionSeedParameter {
      get { return (LookupParameter<IntValue>)Parameters["InteractionSeed"]; }
    }
    public LookupParameter<DoubleArray> WeightsParameter {
      get { return (LookupParameter<DoubleArray>)Parameters["Weights"]; }
    }
    public ValueLookupParameter<BoolValue> StoreComponentsParameter {
      get { return (ValueLookupParameter<BoolValue>)Parameters["StoreComponents"]; }
    }

    #endregion

    #region ParameterValues
    private double Quality {
      set { QualityParameter.ActualValue = new DoubleValue(value); }
    }
    private BinaryVector BinaryVector {
      get { return BinaryVectorParameter.ActualValue; }
    }
    private BoolMatrix GeneInteractions {
      get { return GeneInteractionsParameter.ActualValue; }
    }
    private int InteractionSeed {
      get { return InteractionSeedParameter.ActualValue.Value; }
    }
    private DoubleArray Weights {
      get { return WeightsParameter.ActualValue; }
    }
    private bool StoreComponents {
      get {
        IParameter param;
        return Parameters.TryGetValue("StoreComponents", out param)
          && ((ValueLookupParameter<BoolValue>)param).ActualValue.Value == true;
      }
    }
    #endregion

    private ThreadLocal<HashAlgorithm> hashAlgorithm;

    [StorableConstructor]
    protected NKEvaluator(bool deserializing) : base(deserializing) {
      hashAlgorithm = new ThreadLocal<HashAlgorithm>(() => HashAlgorithm.Create("MD5"));
    }
    protected NKEvaluator(NKEvaluator original, Cloner cloner) : base(original, cloner) {
      hashAlgorithm = new ThreadLocal<HashAlgorithm>(() => HashAlgorithm.Create("MD5"));
    }
    public NKEvaluator() {
      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The evaluated quality of the OneMax solution."));
      Parameters.Add(new LookupParameter<DoubleArray>("F_i", "Fitness component functions."));
      Parameters.Add(new LookupParameter<BinaryVector>("BinaryVector", "The solution given in path representation which should be evaluated."));
      Parameters.Add(new LookupParameter<BoolMatrix>("GeneInteractions", "Matrix indicating gene interactions."));
      Parameters.Add(new LookupParameter<IntValue>("InteractionSeed", "Seed used for randomly generting gene interactions."));
      Parameters.Add(new LookupParameter<DoubleArray>("Weights", "The weights for the component functions. If shorter, will be repeated."));
      Parameters.Add(new ValueLookupParameter<BoolValue>("StoreComponents", "Inject values of component functions into the scope (F_i)", new BoolValue(false)));
      hashAlgorithm = new ThreadLocal<HashAlgorithm>(() => HashAlgorithm.Create("MD5"));
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new NKEvaluator(this, cloner);
    }

    public long Hash(long x) {
      return BitConverter.ToInt64(hashAlgorithm.Value.ComputeHash(BitConverter.GetBytes(x), 0, 8), 0);
    }

    public double F_i(long x, long i, long g_i, long seed) {
      return Math.Abs((double)Hash((x & g_i) ^ Hash(g_i ^ Hash(i ^ seed))))/long.MaxValue;
    }

    public double F(long x, long[] g, double[] w, long seed, ref double[] f_i) {
      double value = 0;
      for (int i = 0; i<g.Length; i++) {
        f_i[i] = F_i(x, i, g[i], seed);
        value += w[i%w.Length] * f_i[i];
      }
      return value;
    }

    public long Encode(BinaryVector v) {
      long x = 0;
      for (int i = 0; i<64 && i<v.Length; i++) {
        x |= (v[i] ? (long)1 : (long)0) << i;
      }
      return x;
    }

    public static long[] Encode(BoolMatrix m) {
      long[] x = new long[m.Columns];
      for (int c = 0; c<m.Columns; c++) {
        x[c] = 0;
        for (int r = 0; r<64 && r<m.Rows; r++) {
          x[c] |= (m[r, c] ? (long)1 : (long)0) << r;
        }
      }
      return x;
    }

    public static double[] Normalize(DoubleArray weights) {
      double sum = 0;
      double[] w = new double[weights.Length];
      foreach (var v in weights) {
        sum += Math.Abs(v);
      }
      for (int i = 0; i<weights.Length; i++) {
        w[i] = Math.Abs(weights[i])/sum;
      }
      return w;
    }

    public sealed override IOperation Apply() {
      double[] f_i;
      Quality = Evaluate(BinaryVector, GeneInteractions, Weights, InteractionSeed, out f_i);
      if (StoreComponents)
        F_iParameter.ActualValue = new DoubleArray(f_i);
      return base.Apply();
    }

    public double Evaluate(BinaryVector vector, BoolMatrix interactions, DoubleArray weights, int seed, out double[] f_i) {
      long x = Encode(vector);
      long[] g = Encode(interactions);
      double[] w = Normalize(weights);
      f_i = new double[interactions.Columns];
      return F(x, g, w, (long)seed, ref f_i);
    }
  }
}