Changeset 1873 for trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs

Timestamp:

05/20/09 17:38:19 (15 years ago)

Author:

gkronber

Message:

Worked on different dispatching of deterministic and non-deterministic modeling algorithms. #635

File:

• trunk/sources/HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs (moved) (moved from trunk/sources/HeuristicLab.CEDMA.Server/3.3/RandomDispatcher.cs) (2 diffs)

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

@@ -38 +38 @@
 
 namespace HeuristicLab.CEDMA.Server {
-  public class RandomDispatcher : DispatcherBase {
+  public class SimpleDispatcher : DispatcherBase {
     private Random random;
-    public RandomDispatcher(IStore store)
+    private IStore store;
+    private Dictionary<Entity, Dictionary<int, List<string>>> finishedAndDispatchedRuns;
+
+    public SimpleDispatcher(IStore store)
       : base(store) {
+      this.store = store;
       random = new Random();
+      finishedAndDispatchedRuns = new Dictionary<Entity, Dictionary<int, List<string>>>();
+      PopulateFinishedRuns();
     }
 
-    public override IAlgorithm SelectAlgorithm(DataSet dataSet, int targetVariable, LearningTask learningTask) {
+    public override IAlgorithm SelectAlgorithm(Entity dataSetEntity, int targetVariable, LearningTask learningTask) {
       DiscoveryService ds = new DiscoveryService();
       IAlgorithm[] algos = ds.GetInstances<IAlgorithm>();
+      IAlgorithm selectedAlgorithm = null;
       switch (learningTask) {
         case LearningTask.Regression: {
             var regressionAlgos = algos.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
-            if (regressionAlgos.Count() == 0) return null;
-            return regressionAlgos.ElementAt(random.Next(regressionAlgos.Count()));
+            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, regressionAlgos) ?? ChooseStochastic(regressionAlgos);
+            break;
           }
         case LearningTask.Classification: {
             var classificationAlgos = algos.Where(a => (a as IClassificationAlgorithm) != null);
-            if (classificationAlgos.Count() == 0) return null;
-            return classificationAlgos.ElementAt(random.Next(classificationAlgos.Count()));
+            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, classificationAlgos) ?? ChooseStochastic(classificationAlgos);
+            break;
           }
         case LearningTask.TimeSeries: {
             var timeSeriesAlgos = algos.Where(a => (a as ITimeSeriesAlgorithm) != null);
-            if (timeSeriesAlgos.Count() == 0) return null;
-            return timeSeriesAlgos.ElementAt(random.Next(timeSeriesAlgos.Count()));
+            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, timeSeriesAlgos) ?? ChooseStochastic(timeSeriesAlgos);
+            break;
           }
       }
-      return null;
+      if (selectedAlgorithm != null) {
+        AddDispatchedRun(dataSetEntity, targetVariable, selectedAlgorithm.Name);
+      }
+      return selectedAlgorithm;
+    }
+
+    private IAlgorithm ChooseDeterministic(Entity dataSetEntity, int targetVariable, IEnumerable<IAlgorithm> algos) {
+      var deterministicAlgos = algos
+        .Where(a => (a as IStochasticAlgorithm) == null)
+        .Where(a => AlgorithmFinishedOrDispatched(dataSetEntity, targetVariable, a.Name) == false);
+
+      if (deterministicAlgos.Count() == 0) return null;
+      return deterministicAlgos.ElementAt(random.Next(deterministicAlgos.Count()));
+    }
+
+    private IAlgorithm ChooseStochastic(IEnumerable<IAlgorithm> regressionAlgos) {
+      var stochasticAlgos = regressionAlgos.Where(a => (a as IStochasticAlgorithm) != null);
+      if (stochasticAlgos.Count() == 0) return null;
+      return stochasticAlgos.ElementAt(random.Next(stochasticAlgos.Count()));
     }
 
@@ -72 +97 @@
     }
 
-    public override int SelectTargetVariable(DataSet dataSet, int[] targetVariables) {
+    public override int SelectTargetVariable(Entity dataSet, int[] targetVariables) {
       return targetVariables[random.Next(targetVariables.Length)];
+    }
+
+    private void PopulateFinishedRuns() {
+      var result = store
+        .Query("?DataSet <" + Ontology.PredicateInstanceOf.Uri + "> <" + Ontology.TypeDataSet.Uri + "> ." + Environment.NewLine +
+        "?DataSet <" + Ontology.PredicateHasModel + "> ?Model ." + Environment.NewLine +
+        "?Model <" + Ontology.TargetVariable + "> ?TargetVariable ." + Environment.NewLine +
+        "?Model <" + Ontology.AlgorithmName + "> ?AlgoName .",
+        0, 1000)
+        .Select(x => new Resource[] { (Entity)x.Get("DataSet"), (Literal)x.Get("TargetVariable"), (Literal)x.Get("AlgoName") });
+
+      foreach (Resource[] row in result) {
+        Entity dataset = (Entity)row[0];
+        int targetVariable = (int)((Literal)row[1]).Value;
+        string algoName = (string)((Literal)row[2]).Value;
+        if (!AlgorithmFinishedOrDispatched(dataset, targetVariable, algoName))
+          AddDispatchedRun(dataset, targetVariable, algoName);
+      }
+    }
+
+    private void AddDispatchedRun(Entity dataSetEntity, int targetVariable, string algoName) {
+      if (!finishedAndDispatchedRuns.ContainsKey(dataSetEntity)) {
+        finishedAndDispatchedRuns[dataSetEntity] = new Dictionary<int, List<string>>();
+      }
+      if (!finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable)) {
+        finishedAndDispatchedRuns[dataSetEntity][targetVariable] = new List<string>();
+      }
+      finishedAndDispatchedRuns[dataSetEntity][targetVariable].Add(algoName);
+    }
+
+    private bool AlgorithmFinishedOrDispatched(Entity dataSetEntity, int targetVariable, string algoName) {
+      return
+        finishedAndDispatchedRuns.ContainsKey(dataSetEntity) &&
+        finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable) &&
+        finishedAndDispatchedRuns[dataSetEntity][targetVariable].Contains(algoName);
     }
   }