source: branches/OptimizationNetworks/HeuristicLab.Networks/3.3/FeatureSelection Network/FeatureSelectionConnector.cs @ 15689

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Core.Networks;
using HeuristicLab.Data;
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Problems.DataAnalysis;

namespace HeuristicLab.Networks.FeatureSelection_Network {
  [Item("FeatureSelectionConnector", "")]
  public sealed class FeatureSelectionConnector : Node {
    private FeatureSelectionConnector(FeatureSelectionConnector original, Cloner cloner) : base(original, cloner) { }
    public FeatureSelectionConnector()
      : base() {
      if (Ports.Count == 0)
        Initialize();
    }

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

    public void Initialize() {
      var parameters = new MessagePort("Parameters");
      Ports.Add(parameters);
      parameters.Parameters.Add(new PortParameter<IRegressionProblemData>("ProblemData") { Type = PortParameterType.Input });

      var selectionPort = new MessagePort("Selection Connector");
      Ports.Add(selectionPort);
      selectionPort.Parameters.Add(new PortParameter<BinaryVector>("Selection") { Type = PortParameterType.Input });
      selectionPort.Parameters.Add(new PortParameter<DoubleValue>("Quality") { Type = PortParameterType.Input | PortParameterType.Output });

      var regressionPort = new MessagePort("Regression Connector");
      Ports.Add(regressionPort);
      regressionPort.Parameters.Add(new PortParameter<IRegressionProblemData>("ProblemData") { Type = PortParameterType.Output });
      regressionPort.Parameters.Add(new PortParameter<IRegressionSolution>("Linear regression solution") { Type = PortParameterType.Input });
      RegisterEvents();
    }

    public void RegisterEvents() {
      var selection = (IMessagePort)Ports["Selection Connector"];
      selection.MessageReceived += Selection_MessageReceived;
    }
    public void DeregisterEvents() {
      var selection = (IMessagePort)Ports["Selection Connector"];
      selection.MessageReceived -= Selection_MessageReceived;
    }

    private Dictionary<BinaryVector, double> solutionCache = new Dictionary<BinaryVector, double>(new BinaryVectorComparer());

    private void Selection_MessageReceived(object sender, EventArgs<IMessage, CancellationToken> e) {
      // get parameters
      var parametersPort = (IMessagePort)Ports["Parameters"];
      var parameters = parametersPort.PrepareMessage();
      parametersPort.SendMessage(parameters, e.Value2);
      var problemData = (IRegressionProblemData)parameters["ProblemData"];

      // filter allowed variables
      var selectionMsg = e.Value;
      var selection = (BinaryVector)selectionMsg["Selection"];

      // if possible return the cached answer 
      double solutionQuality;
      if (solutionCache.TryGetValue(selection, out solutionQuality)) {
        selectionMsg["Quality"] = new DoubleValue(solutionQuality);
      } else {
        var allowedVariables = problemData.AllowedInputVariables;

        var selectedInputVariables = from t in selection.Zip(allowedVariables, Tuple.Create)
                                     where t.Item1
                                     select t.Item2;

        var clonedProblemData = new RegressionProblemData(problemData.Dataset, selectedInputVariables, problemData.TargetVariable);

        // solve Regression
        var regressionConPort = (IMessagePort)Ports["Regression Connector"];
        var regressionMsg = regressionConPort.PrepareMessage();
        regressionMsg["ProblemData"] = clonedProblemData;
        regressionConPort.SendMessage(regressionMsg, e.Value2);
        var solution = regressionMsg.Values.Select(v => v.Value).OfType<IRegressionSolution>().Single();

        selectionMsg["Quality"] = new DoubleValue(solution.TestNormalizedMeanSquaredError);
        // cache solution quality
        solutionCache.Add(selection, solution.TestNormalizedMeanSquaredError);
      }
    }
  }

  internal class BinaryVectorComparer : IEqualityComparer<BinaryVector> {
    public bool Equals(BinaryVector x, BinaryVector y) {
      return x.Length == y.Length &&
        x.Zip(y, Tuple.Create).All(t => t.Item1 == t.Item2);
    }

    public int GetHashCode(BinaryVector obj) {
      // return number of set bits
      return obj.Count(t => t);
    }
  }
}