source: branches/OptimizationNetworks/HeuristicLab.Networks/3.3/FeatureSelection Network/FeatureSelectionNetwork.cs @ 12327

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2014 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.Linq;
using System.Threading;
using HeuristicLab.Algorithms.DataAnalysis;
using HeuristicLab.Algorithms.GeneticAlgorithm;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Core.Networks;
using HeuristicLab.Data;
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Networks.FeatureSelection_Network;
using HeuristicLab.Networks.Programmable;
using HeuristicLab.Problems.DataAnalysis;
using HeuristicLab.Problems.Instances.DataAnalysis;
using HeuristicLab.Random;

namespace HeuristicLab.Networks {
  [Creatable("Optimization Networks")]
  [Item("Feature Selection Network", "An optimization network which contains a binary GA and a LR.")]
  public sealed class FeatureSelectionNetwork : Network {
    private FeatureSelectionNetwork(FeatureSelectionNetwork original, Cloner cloner) : base(original, cloner) { }
    public FeatureSelectionNetwork()
      : base() {
      if (Nodes.Count == 0)
        Initialize();
    }

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

    public void Initialize() {


      #region ParametersNode
      var paramsNode = new UserDefinedNode("ParametersNode");
      Nodes.Add(paramsNode);

      var paramsPort = new MessagePort("Parameters");
      paramsNode.Ports.Add(paramsPort);

      var rand = new MersenneTwister();
      var normRand = new NormalDistributedRandom(rand, 0, 1);
      var instanceProvider = new FeatureSelectionInstanceProvider();
      var problemData = instanceProvider.LoadData(new FeatureSelection(100, 0.1, 0.2, rand, normRand));

      paramsPort.Parameters.Add(new PortParameter<IRegressionProblemData>("ProblemData") {
        Type = PortParameterType.Output,
        DefaultValue = problemData
      });
      paramsPort.Parameters.Add(new PortParameter<IntValue>("Length") {
        Type = PortParameterType.Output,
        DefaultValue = new IntValue(problemData.AllowedInputVariables.Count())
      });
      #endregion

      #region Selection Node
      var selectionNode = new AlgorithmNode("SelectionNode");
      Nodes.Add(selectionNode);

      var configPort = new ConfigurationPort("ConfigureSelection");
      selectionNode.Ports.Add(configPort);

      configPort.Parameters.Add(new PortParameter<IRegressionProblemData>("ProblemData") {
        Type = PortParameterType.Input
      });

      var evaluatePort = new MessagePort("EvaluateSelection");
      selectionNode.Ports.Add(evaluatePort);

      evaluatePort.Parameters.Add(new PortParameter<BinaryVector>("Selection") {
        Type = PortParameterType.Output
      });
      evaluatePort.Parameters.Add(new PortParameter<DoubleValue>("Quality") {
        Type = PortParameterType.Output | PortParameterType.Input
      });

      Func<BinaryVector, double> eval = vector => {
        // hook returns test quality!, LR optimizes training quality only!

        var msg = evaluatePort.PrepareMessage();
        msg["Selection"] = vector;
        evaluatePort.SendMessage(msg, new CancellationToken(false));

        return ((DoubleValue)msg["Quality"]).Value;
      };

      var selectionGa = new GeneticAlgorithm();
      var selectionProb = new SelectionProblem(eval, false);

      selectionGa.Problem = selectionProb;
      selectionGa.MaximumGenerations.Value = 50;
      selectionGa.PopulationSize.Value = 10;
      selectionGa.Mutator = selectionGa.MutatorParameter.ValidValues.Where(x => x.Name == "SinglePositionBitflipManipulator").First();
      selectionNode.Algorithm = selectionGa;

      #endregion

      #region RegressionNode
      var regressionNode = new AlgorithmNode("Regression");
      Nodes.Add(regressionNode);

      var executePort = new ExecutionPort("Execute");
      regressionNode.Ports.Add(executePort);

      executePort.Parameters.Add(new PortParameter<IRegressionProblemData>("ProblemData") {
        Type = PortParameterType.Input
      });
      executePort.Parameters.Add(new PortParameter<IRegressionSolution>("Linear regression solution") {
        Type = PortParameterType.Output
      });

      var linReg = new LinearRegression();
      regressionNode.Algorithm = linReg;
      #endregion

      #region Connector
      var featureSelectionConnector = (INode)new FeatureSelectionConnector();
      Nodes.Add(featureSelectionConnector);
      #endregion

      #region Wire Ports
      configPort.ConnectedPort = paramsPort;
      evaluatePort.ConnectedPort = (IMessagePort)featureSelectionConnector.Ports["Selection Connector"];
      ((IMessagePort)featureSelectionConnector.Ports["Parameters"]).ConnectedPort = paramsPort;
      ((IMessagePort)featureSelectionConnector.Ports["Regression Connector"]).ConnectedPort = executePort;

      paramsPort.SendMessage(paramsPort.PrepareMessage());
      #endregion
    }
  }
}