Changeset 2290 for trunk/sources/HeuristicLab.CEDMA.Server/3.3

Timestamp:

08/14/09 19:56:04 (15 years ago)

Author:

gkronber

Message:

• introduced a variablename to index mapping for SVM models (to make sure we can use the model for prediction in the model analyzer)
• added support to enable and disable algorithms in the dispatcher and removed DispatcherBase
• fixed bugs when calculating variable impacts and reading the final model of GP algorithms

#722 (IModel should provide a Predict() method to get predicted values for an input vector)

Location:

trunk/sources/HeuristicLab.CEDMA.Server/3.3

Files:

• DispatcherBase.cs (modified) (1 diff)
• DispatcherView.Designer.cs (modified) (6 diffs)
• DispatcherView.cs (modified) (4 diffs)
• ExecuterBase.cs (modified) (2 diffs)
• ExecuterView.Designer.cs (modified) (5 diffs)
• ExecuterView.cs (modified) (1 diff)
• HeuristicLab.CEDMA.Server-3.3.csproj (modified) (1 diff)
• ProblemView.cs (modified) (5 diffs)
• SimpleDispatcher.cs (modified) (3 diffs)

trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherBase.cs

@@ -37 +37 @@
 namespace HeuristicLab.CEDMA.Server {
   public abstract class DispatcherBase : IDispatcher {
-    private IModelingDatabase database;
-    public IModelingDatabase Database {
-      get {
-        return database;
-      }
-    }
-    private List<int> allowedTargetVariables;
-    private Dictionary<int, List<int>> activeInputVariables;
-    private Problem problem;
-    public Problem Problem {
-      get {
-        return problem;
-      }
-    }
-    internal event EventHandler Changed;
-    private object locker = new object();
-
-    public IEnumerable<string> TargetVariables {
-      get {
-        if (problem != null) {
-          return Enumerable.Range(0, problem.Dataset.Columns).Select(x => problem.Dataset.GetVariableName(x));
-        } else return new string[0];
-      }
-    }
-
-    public IEnumerable<string> InputVariables {
-      get {
-        if (problem != null) {
-          return TargetVariables;
-        } else return new string[0];
-      }
-    }
-
-    public DispatcherBase(IModelingDatabase database, Problem problem) {
-      this.problem = problem;
-      allowedTargetVariables = new List<int>();
-      activeInputVariables = new Dictionary<int, List<int>>();
-      problem.Changed += (sender, args) => {
-        lock (locker) {
-          allowedTargetVariables.Clear();
-          activeInputVariables.Clear();
-        }
-        OnChanged();
-      };
-      this.database = database;
-    }
-
-    public HeuristicLab.Modeling.IAlgorithm GetNextJob() {
-      if (allowedTargetVariables.Count > 0) {
-        int[] targetVariables, inputVariables;
-        lock (locker) {
-          targetVariables = allowedTargetVariables.ToArray();
-        }
-
-        int targetVariable = SelectTargetVariable(targetVariables);
-
-        lock (locker) {
-          inputVariables = activeInputVariables[targetVariable].ToArray();
-        }
-
-        HeuristicLab.Modeling.IAlgorithm selectedAlgorithm = SelectAndConfigureAlgorithm(targetVariable, inputVariables, problem);
-
-        return selectedAlgorithm;
-      } else return null;
-    }
-
-    public virtual int SelectTargetVariable(int[] targetVariables) {
-      Random rand = new Random();
-      return targetVariables[rand.Next(targetVariables.Length)];
-    }
-    public abstract HeuristicLab.Modeling.IAlgorithm SelectAndConfigureAlgorithm(int targetVariable, int[] inputVariables, Problem problem);
-
-    #region IViewable Members
-
-    public IView CreateView() {
-      return new DispatcherView(this);
-    }
-
-    #endregion
-
-    internal void EnableTargetVariable(string name) {
-      lock (locker)
-        allowedTargetVariables.Add(problem.Dataset.GetVariableIndex(name));
-    }
-
-    internal void DisableTargetVariable(string name) {
-      lock (locker)
-        allowedTargetVariables.Remove(problem.Dataset.GetVariableIndex(name));
-    }
-
-    internal void EnableInputVariable(string target, string name) {
-      lock (locker) {
-        int targetIndex = problem.Dataset.GetVariableIndex(target);
-        int inputIndex = problem.Dataset.GetVariableIndex(name);
-        if (!activeInputVariables.ContainsKey(targetIndex)) activeInputVariables[targetIndex] = new List<int>();
-        if (!activeInputVariables[targetIndex].Contains(inputIndex)) {
-          activeInputVariables[targetIndex].Add(inputIndex);
-        }
-      }
-    }
-
-    internal void DisableInputVariable(string target, string name) {
-      lock (locker) {
-        int targetIndex = problem.Dataset.GetVariableIndex(target);
-        int inputIndex = problem.Dataset.GetVariableIndex(name);
-        if (!activeInputVariables.ContainsKey(targetIndex)) activeInputVariables[targetIndex] = new List<int>();
-        while (activeInputVariables[targetIndex].Remove(inputIndex)) { }
-      }
-    }
-
-    private void OnChanged() {
-      if (Changed != null) Changed(this, new EventArgs());
-    }
-
-    internal IEnumerable<string> GetInputVariables(string target) {
-      int targetIndex = problem.Dataset.GetVariableIndex(target);
-      if (!activeInputVariables.ContainsKey(targetIndex)) activeInputVariables[targetIndex] = new List<int>();
-      return activeInputVariables[targetIndex]
-        .Select(i => problem.Dataset.GetVariableName(i));
-    }
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherView.Designer.cs

@@ -29 +29 @@
       this.inputVariablesLabel = new System.Windows.Forms.Label();
       this.splitContainer = new System.Windows.Forms.SplitContainer();
+      this.algorithmsListBox = new System.Windows.Forms.CheckedListBox();
+      this.algorithmsLabel = new System.Windows.Forms.Label();
       this.setAllButton = new System.Windows.Forms.Button();
       this.splitContainer.Panel1.SuspendLayout();
@@ -42 +44 @@
       this.targetVariableList.FormattingEnabled = true;
       this.targetVariableList.HorizontalScrollbar = true;
-      this.targetVariableList.Location = new System.Drawing.Point(6, 16);
+      this.targetVariableList.Location = new System.Drawing.Point(6, 181);
       this.targetVariableList.Name = "targetVariableList";
-      this.targetVariableList.Size = new System.Drawing.Size(193, 454);
+      this.targetVariableList.Size = new System.Drawing.Size(193, 289);
       this.targetVariableList.TabIndex = 0;
       this.targetVariableList.ItemCheck += new System.Windows.Forms.ItemCheckEventHandler(this.targetVariableList_ItemCheck);
@@ -65 +67 @@
       // 
       this.targetVariablesLabel.AutoSize = true;
-      this.targetVariablesLabel.Location = new System.Drawing.Point(3, 0);
+      this.targetVariablesLabel.Location = new System.Drawing.Point(3, 165);
       this.targetVariablesLabel.Name = "targetVariablesLabel";
       this.targetVariablesLabel.Size = new System.Drawing.Size(86, 13);
@@ -88 +90 @@
       // splitContainer.Panel1
       // 
+      this.splitContainer.Panel1.Controls.Add(this.algorithmsListBox);
+      this.splitContainer.Panel1.Controls.Add(this.algorithmsLabel);
       this.splitContainer.Panel1.Controls.Add(this.targetVariablesLabel);
       this.splitContainer.Panel1.Controls.Add(this.targetVariableList);
@@ -100 +104 @@
       this.splitContainer.SplitterWidth = 1;
       this.splitContainer.TabIndex = 4;
+      // 
+      // algorithmsListBox
+      // 
+      this.algorithmsListBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.algorithmsListBox.FormattingEnabled = true;
+      this.algorithmsListBox.HorizontalScrollbar = true;
+      this.algorithmsListBox.Location = new System.Drawing.Point(6, 16);
+      this.algorithmsListBox.Name = "algorithmsListBox";
+      this.algorithmsListBox.Size = new System.Drawing.Size(193, 139);
+      this.algorithmsListBox.TabIndex = 4;
+      this.algorithmsListBox.ItemCheck += new System.Windows.Forms.ItemCheckEventHandler(this.algorithmsListBox_ItemCheck);
+      // 
+      // algorithmsLabel
+      // 
+      this.algorithmsLabel.AutoSize = true;
+      this.algorithmsLabel.Location = new System.Drawing.Point(3, 0);
+      this.algorithmsLabel.Name = "algorithmsLabel";
+      this.algorithmsLabel.Size = new System.Drawing.Size(58, 13);
+      this.algorithmsLabel.TabIndex = 3;
+      this.algorithmsLabel.Text = "Algorithms:";
       // 
       // setAllButton
@@ -136 +161 @@
     private System.Windows.Forms.SplitContainer splitContainer;
     private System.Windows.Forms.Button setAllButton;
+    private System.Windows.Forms.CheckedListBox algorithmsListBox;
+    private System.Windows.Forms.Label algorithmsLabel;
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/3.3/DispatcherView.cs

@@ -11 +11 @@
 namespace HeuristicLab.CEDMA.Server {
   public partial class DispatcherView : ViewBase {
-    private DispatcherBase dispatcher;
-    public DispatcherView(DispatcherBase dispatcher)
+    private SimpleDispatcher dispatcher;
+    public DispatcherView(SimpleDispatcher dispatcher)
       : base() {
       this.dispatcher = dispatcher;
@@ -26 +26 @@
       } else {
         base.UpdateControls();
+        algorithmsListBox.Items.Clear();
         targetVariableList.Items.Clear();
         inputVariableList.Items.Clear();
@@ -35 +36 @@
         foreach (string inputVar in dispatcher.InputVariables) {
           inputVariableList.Items.Add(inputVar, false);
+        }
+
+        foreach (HeuristicLab.Modeling.IAlgorithm algo in dispatcher.Algorithms) {
+          algorithmsListBox.Items.Add(algo, false);
         }
         targetVariableList.ClearSelected();
@@ -83 +88 @@
       }
     }
+
+    private void algorithmsListBox_ItemCheck(object sender, ItemCheckEventArgs e) {
+      if(e.NewValue == CheckState.Checked) {
+        dispatcher.EnableAlgorithm((HeuristicLab.Modeling.IAlgorithm)algorithmsListBox.Items[e.Index]);
+      } else if(e.NewValue == CheckState.Unchecked) {
+        dispatcher.DisableAlgorithm((HeuristicLab.Modeling.IAlgorithm)algorithmsListBox.Items[e.Index]);
+      }
+    }
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/3.3/ExecuterBase.cs

@@ -58 +58 @@
     }
 
+    public int CalculatedJobs {
+      get;
+      set;
+    }
+    public int StoredJobs {
+      get;
+      set;
+    }
+
     public ExecuterBase(IDispatcher dispatcher, IModelingDatabase databaseService) {
+      CalculatedJobs = 0;
       maxActiveJobs = 10;
       this.dispatcher = dispatcher;
       this.databaseService = databaseService;
+      StoredJobs = databaseService.GetAllModels().Count();
     }
 
@@ -83 +94 @@
 
     protected void StoreResults(HeuristicLab.Modeling.IAlgorithm finishedAlgorithm) {
+      CalculatedJobs++;
       databaseService.Persist(finishedAlgorithm);
+      StoredJobs++;
+      OnChanged();
     }
 

trunk/sources/HeuristicLab.CEDMA.Server/3.3/ExecuterView.Designer.cs

@@ -27 +27 @@
       this.maxJobsLabel = new System.Windows.Forms.Label();
       this.maxActiveJobs = new System.Windows.Forms.NumericUpDown();
+      this.finishedLabel = new System.Windows.Forms.Label();
+      this.finishedTextBox = new System.Windows.Forms.TextBox();
       ((System.ComponentModel.ISupportInitialize)(this.maxActiveJobs)).BeginInit();
       this.SuspendLayout();
@@ -36 +38 @@
                   | System.Windows.Forms.AnchorStyles.Right)));
       this.jobsList.FormattingEnabled = true;
-      this.jobsList.Location = new System.Drawing.Point(3, 29);
+      this.jobsList.Location = new System.Drawing.Point(3, 55);
       this.jobsList.Name = "jobsList";
-      this.jobsList.Size = new System.Drawing.Size(327, 264);
+      this.jobsList.Size = new System.Drawing.Size(327, 238);
       this.jobsList.TabIndex = 0;
       // 
@@ -52 +54 @@
       // maxActiveJobs
       // 
-      this.maxActiveJobs.Location = new System.Drawing.Point(98, 3);
+      this.maxActiveJobs.Location = new System.Drawing.Point(117, 3);
       this.maxActiveJobs.Maximum = new decimal(new int[] {
             200,
@@ -63 +65 @@
       this.maxActiveJobs.ValueChanged += new System.EventHandler(this.maxActiveJobs_ValueChanged);
       // 
+      // finishedLabel
+      // 
+      this.finishedLabel.AutoSize = true;
+      this.finishedLabel.Location = new System.Drawing.Point(5, 32);
+      this.finishedLabel.Name = "finishedLabel";
+      this.finishedLabel.Size = new System.Drawing.Size(106, 13);
+      this.finishedLabel.TabIndex = 3;
+      this.finishedLabel.Text = "Stored models (new):";
+      // 
+      // finishedTextBox
+      // 
+      this.finishedTextBox.Location = new System.Drawing.Point(117, 29);
+      this.finishedTextBox.Name = "finishedTextBox";
+      this.finishedTextBox.ReadOnly = true;
+      this.finishedTextBox.Size = new System.Drawing.Size(100, 20);
+      this.finishedTextBox.TabIndex = 4;
+      // 
       // ExecuterView
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.finishedTextBox);
+      this.Controls.Add(this.finishedLabel);
       this.Controls.Add(this.maxActiveJobs);
       this.Controls.Add(this.maxJobsLabel);
@@ -83 +104 @@
     private System.Windows.Forms.Label maxJobsLabel;
     private System.Windows.Forms.NumericUpDown maxActiveJobs;
+    private System.Windows.Forms.Label finishedLabel;
+    private System.Windows.Forms.TextBox finishedTextBox;
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/3.3/ExecuterView.cs

@@ -24 +24 @@
       else {
         base.UpdateControls();
+        finishedTextBox.Text = executer.StoredJobs+" ("+executer.CalculatedJobs+")";
         maxActiveJobs.Value = executer.MaxActiveJobs;
         jobsList.DataSource = executer.GetJobs();

trunk/sources/HeuristicLab.CEDMA.Server/3.3/HeuristicLab.CEDMA.Server-3.3.csproj

@@ -113 +113 @@
     <Compile Include="ExecuterBase.cs" />
     <Compile Include="IExecuter.cs" />
-    <Compile Include="DispatcherBase.cs" />
     <Compile Include="GridExecuter.cs" />
     <Compile Include="IDispatcher.cs" />

trunk/sources/HeuristicLab.CEDMA.Server/3.3/ProblemView.cs

@@ -111 +111 @@
     private void autoregressiveCheckBox_CheckedChanged(object sender, EventArgs e) {
       problem.AutoRegressive = autoregressiveCheckBox.Checked;
+      problem.FireChanged();
     }
 
@@ -145 +146 @@
       problem.TestSamplesStart = int.Parse(testSamplesStartTextBox.Text);
       problem.TestSamplesEnd = int.Parse(testSamplesEndTextBox.Text);
+      problem.FireChanged();
     }
 
@@ -193 +195 @@
     }
 
-    #region gui events
     private void radioButton_CheckedChanged(object sender, EventArgs e) {
       minTimeOffsetLabel.Enabled = timeSeriesRadioButton.Checked;
@@ -204 +205 @@
       else if (classificationRadioButton.Checked) problem.LearningTask = LearningTask.Classification;
       else if (regressionRadioButton.Checked) problem.LearningTask = LearningTask.Regression;
+      problem.FireChanged();
     }
 
@@ -215 +217 @@
       problem.MinTimeOffset = int.Parse(minTimeOffsetTextBox.Text);
       problem.MaxTimeOffset = int.Parse(maxTimeOffsetTextBox.Text);
-    }
-    #endregion
+      problem.FireChanged();
+    }
   }
 }

trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs

@@ -36 +36 @@
 
 namespace HeuristicLab.CEDMA.Server {
-  public class SimpleDispatcher : DispatcherBase {
+  public class SimpleDispatcher : IDispatcher {
     private class AlgorithmConfiguration {
       public string name;
@@ -43 +43 @@
     }
 
+    private IModelingDatabase database;
+    public IModelingDatabase Database {
+      get {
+        return database;
+      }
+    }
+
+    private Problem problem;
+    public Problem Problem {
+      get {
+        return problem;
+      }
+    }
+    internal event EventHandler Changed;
+
+    public IEnumerable<string> TargetVariables {
+      get {
+        return Enumerable.Range(0, problem.Dataset.Columns).Select(x => problem.Dataset.GetVariableName(x));
+      }
+    }
+
+    public IEnumerable<string> InputVariables {
+      get {
+        return TargetVariables;
+      }
+    }
+
+    private HeuristicLab.Modeling.IAlgorithm[] algorithms;
+    public IEnumerable<HeuristicLab.Modeling.IAlgorithm> Algorithms {
+      get {
+        switch (Problem.LearningTask) {
+          case LearningTask.Regression: {
+              return algorithms.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
+            }
+          case LearningTask.Classification: {
+              return algorithms.Where(a => (a as IClassificationAlgorithm) != null);
+            }
+          case LearningTask.TimeSeries: {
+              return algorithms.Where(a => (a as ITimeSeriesAlgorithm) != null);
+            }
+        }
+        return new HeuristicLab.Modeling.IAlgorithm[] { };
+      }
+    }
+
+    private List<HeuristicLab.Modeling.IAlgorithm> activeAlgorithms;
+    public IEnumerable<HeuristicLab.Modeling.IAlgorithm> ActiveAlgorithms {
+      get { return activeAlgorithms; }
+    }
+
     private Random random;
+    private List<int> allowedTargetVariables;
+    private Dictionary<int, List<int>> activeInputVariables;
     private Dictionary<int, List<AlgorithmConfiguration>> finishedAndDispatchedRuns;
-
-    public SimpleDispatcher(IModelingDatabase database, Problem problem)
-      : base(database, problem) {
-      random = new Random();
-      finishedAndDispatchedRuns = new Dictionary<int, List<AlgorithmConfiguration>>();
+    private object locker = new object();
+
+    public SimpleDispatcher(IModelingDatabase database, Problem problem) {
+      this.problem = problem;
+      this.database = database;
+      this.random = new Random();
+
+      this.finishedAndDispatchedRuns = new Dictionary<int, List<AlgorithmConfiguration>>();
+      this.allowedTargetVariables = new List<int>();
+      this.activeInputVariables = new Dictionary<int, List<int>>();
+      this.activeAlgorithms = new List<HeuristicLab.Modeling.IAlgorithm>();
+      DiscoveryService ds = new DiscoveryService();
+      this.algorithms = ds.GetInstances<HeuristicLab.Modeling.IAlgorithm>();
+      problem.Changed += (sender, args) => {
+        lock (locker) {
+          allowedTargetVariables.Clear();
+          activeInputVariables.Clear();
+          activeAlgorithms.Clear();
+        }
+        OnChanged();
+      };
+
       PopulateFinishedRuns();
     }
 
-    public override HeuristicLab.Modeling.IAlgorithm SelectAndConfigureAlgorithm(int targetVariable, int[] inputVariables, Problem problem) {
+    public HeuristicLab.Modeling.IAlgorithm GetNextJob() {
+      lock (locker) {
+        if (allowedTargetVariables.Count > 0) {
+          int[] targetVariables = allowedTargetVariables.ToArray();
+          int targetVariable = SelectTargetVariable(targetVariables);
+          int[] inputVariables = activeInputVariables[targetVariable].ToArray();
+
+          HeuristicLab.Modeling.IAlgorithm selectedAlgorithm = SelectAndConfigureAlgorithm(targetVariable, inputVariables, problem);
+
+          return selectedAlgorithm;
+        } else return null;
+      }
+    }
+
+    public virtual int SelectTargetVariable(int[] targetVariables) {
+      return targetVariables[random.Next(targetVariables.Length)];
+    }
+
+    public HeuristicLab.Modeling.IAlgorithm SelectAndConfigureAlgorithm(int targetVariable, int[] inputVariables, Problem problem) {
+      HeuristicLab.Modeling.IAlgorithm selectedAlgorithm = null;
       DiscoveryService ds = new DiscoveryService();
-      HeuristicLab.Modeling.IAlgorithm[] algos = ds.GetInstances<HeuristicLab.Modeling.IAlgorithm>();
-      HeuristicLab.Modeling.IAlgorithm selectedAlgorithm = null;
-      switch (problem.LearningTask) {
-        case LearningTask.Regression: {
-            var regressionAlgos = algos.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
-            selectedAlgorithm = ChooseDeterministic(targetVariable, inputVariables, regressionAlgos) ?? ChooseStochastic(regressionAlgos);
-            break;
-          }
-        case LearningTask.Classification: {
-            var classificationAlgos = algos.Where(a => (a as IClassificationAlgorithm) != null);
-            selectedAlgorithm = ChooseDeterministic(targetVariable, inputVariables, classificationAlgos) ?? ChooseStochastic(classificationAlgos);
-            break;
-          }
-        case LearningTask.TimeSeries: {
-            var timeSeriesAlgos = algos.Where(a => (a as ITimeSeriesAlgorithm) != null);
-            selectedAlgorithm = ChooseDeterministic(targetVariable, inputVariables, timeSeriesAlgos) ?? ChooseStochastic(timeSeriesAlgos);
-            break;
-          }
-      }
-
-
+      var allAlgorithms = ds.GetInstances<HeuristicLab.Modeling.IAlgorithm>();
+      var allowedAlgorithmTypes = activeAlgorithms.Select(x => x.GetType());
+      var possibleAlgos =
+        allAlgorithms
+        .Where(x => allowedAlgorithmTypes.Contains(x.GetType()) &&
+          ((x is IStochasticAlgorithm) || !AlgorithmFinishedOrDispatched(targetVariable, inputVariables, x.Name)));
+      if (possibleAlgos.Count() > 0) selectedAlgorithm = possibleAlgos.ElementAt(random.Next(possibleAlgos.Count()));
       if (selectedAlgorithm != null) {
         SetProblemParameters(selectedAlgorithm, problem, targetVariable, inputVariables);
-        AddDispatchedRun(targetVariable, inputVariables, selectedAlgorithm.Name);
+        if (!(selectedAlgorithm is IStochasticAlgorithm))
+          AddDispatchedRun(targetVariable, inputVariables, selectedAlgorithm.Name);
       }
       return selectedAlgorithm;
-    }
-
-    private HeuristicLab.Modeling.IAlgorithm ChooseDeterministic(int targetVariable, int[] inputVariables, IEnumerable<HeuristicLab.Modeling.IAlgorithm> algos) {
-      var deterministicAlgos = algos
-        .Where(a => (a as IStochasticAlgorithm) == null)
-        .Where(a => AlgorithmFinishedOrDispatched(targetVariable, inputVariables, a.Name) == false);
-
-      if (deterministicAlgos.Count() == 0) return null;
-      return deterministicAlgos.ElementAt(random.Next(deterministicAlgos.Count()));
-    }
-
-    private HeuristicLab.Modeling.IAlgorithm ChooseStochastic(IEnumerable<HeuristicLab.Modeling.IAlgorithm> regressionAlgos) {
-      var stochasticAlgos = regressionAlgos.Where(a => (a as IStochasticAlgorithm) != null);
-      if (stochasticAlgos.Count() == 0) return null;
-      return stochasticAlgos.ElementAt(random.Next(stochasticAlgos.Count()));
     }
 
@@ -169 +229 @@
                                                            inputVariables.All(v => x.inputVariables.Contains(v)));
     }
+
+    public void EnableAlgorithm(HeuristicLab.Modeling.IAlgorithm algo) {
+      lock (locker) {
+        if (!activeAlgorithms.Contains(algo)) activeAlgorithms.Add(algo);
+      }
+    }
+
+    public void DisableAlgorithm(HeuristicLab.Modeling.IAlgorithm algo) {
+      lock (locker) {
+        while (activeAlgorithms.Remove(algo)) ;
+      }
+    }
+
+    internal void EnableTargetVariable(string name) {
+      int varIndex = problem.Dataset.GetVariableIndex(name);
+      lock (locker)
+        if (!allowedTargetVariables.Contains(varIndex)) allowedTargetVariables.Add(varIndex);
+    }
+
+    internal void DisableTargetVariable(string name) {
+      int varIndex = problem.Dataset.GetVariableIndex(name);
+      lock (locker)
+        while (allowedTargetVariables.Remove(varIndex)) ;
+    }
+
+    internal void EnableInputVariable(string target, string name) {
+      int targetIndex = problem.Dataset.GetVariableIndex(target);
+      int inputIndex = problem.Dataset.GetVariableIndex(name);
+      lock (locker) {
+        if (!activeInputVariables.ContainsKey(targetIndex)) activeInputVariables[targetIndex] = new List<int>();
+        if (!activeInputVariables[targetIndex].Contains(inputIndex)) {
+          activeInputVariables[targetIndex].Add(inputIndex);
+        }
+      }
+    }
+
+    internal void DisableInputVariable(string target, string name) {
+      int targetIndex = problem.Dataset.GetVariableIndex(target);
+      int inputIndex = problem.Dataset.GetVariableIndex(name);
+      lock (locker) {
+        if (!activeInputVariables.ContainsKey(targetIndex)) activeInputVariables[targetIndex] = new List<int>();
+        while (activeInputVariables[targetIndex].Remove(inputIndex)) ;
+      }
+    }
+
+    public void OnChanged() {
+      if (Changed != null) Changed(this, new EventArgs());
+    }
+
+    internal IEnumerable<string> GetInputVariables(string target) {
+      int targetIndex = problem.Dataset.GetVariableIndex(target);
+      lock (locker) {
+        if (!activeInputVariables.ContainsKey(targetIndex)) activeInputVariables[targetIndex] = new List<int>();
+        return activeInputVariables[targetIndex]
+          .Select(i => problem.Dataset.GetVariableName(i));
+      }
+    }
+
+
+    #region IViewable Members
+
+    public virtual IView CreateView() {
+      return new DispatcherView(this);
+    }
+
+    #endregion
+
+
   }
 }