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

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

Location:

trunk/sources/HeuristicLab.CEDMA.Server/3.3

Files:

• DispatcherBase.cs (modified) (2 diffs)
• Executer.cs (modified) (1 diff)
• HeuristicLab.CEDMA.Server-3.3.csproj (modified) (2 diffs)
• ServerForm.cs (modified) (1 diff)
• SimpleDispatcher.cs (moved) (moved from trunk/sources/HeuristicLab.CEDMA.Server/3.3/RandomDispatcher.cs) (2 diffs)

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

@@ -61 +61 @@
       DataSet dataSet = new DataSet(store, dataSetEntity);
 
-      int targetVariable = SelectTargetVariable(dataSet, dataSet.Problem.AllowedTargetVariables.ToArray());
-      IAlgorithm selectedAlgorithm = SelectAlgorithm(dataSet, targetVariable, dataSet.Problem.LearningTask);
+      int targetVariable = SelectTargetVariable(dataSetEntity, dataSet.Problem.AllowedTargetVariables.ToArray());
+      IAlgorithm selectedAlgorithm = SelectAlgorithm(dataSetEntity, targetVariable, dataSet.Problem.LearningTask);
       string targetVariableName = dataSet.Problem.GetVariableName(targetVariable);
 
@@ -75 +75 @@
 
     public abstract Entity SelectDataSet(Entity[] datasets);
-    public abstract int SelectTargetVariable(DataSet dataSet, int[] targetVariables);
-    public abstract IAlgorithm SelectAlgorithm(DataSet dataSet, int targetVariable, LearningTask learningTask);
+    public abstract int SelectTargetVariable(Entity dataSet, int[] targetVariables);
+    public abstract IAlgorithm SelectAlgorithm(Entity dataSet, int targetVariable, LearningTask learningTask);
 
     private Execution CreateExecution(Problem problem, int targetVariable, IAlgorithm algorithm) {

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

@@ -129 +129 @@
     private void StoreResults(Execution finishedExecution, ProcessingEngine finishedEngine) {
       Entity model = new Entity(Ontology.CedmaNameSpace + Guid.NewGuid());
-      store.Add(new Statement(model, Ontology.PredicateInstanceOf, Ontology.TypeGeneticProgrammingFunctionTree));
       store.Add(new Statement(finishedExecution.DataSetEntity, Ontology.PredicateHasModel, model));
       StoreModelAttribute(model, Ontology.TargetVariable, finishedExecution.TargetVariable);

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

@@ -95 +95 @@
     <Compile Include="Execution.cs" />
     <Compile Include="Executer.cs" />
-    <Compile Include="RandomDispatcher.cs" />
     <Compile Include="Server.cs" />
     <Compile Include="ServerApplication.cs" />
@@ -106 +105 @@
       <DependentUpon>ServerForm.cs</DependentUpon>
     </Compile>
+    <Compile Include="SimpleDispatcher.cs" />
   </ItemGroup>
   <ItemGroup>

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

@@ -63 +63 @@
 
     private void connectButton_Click(object sender, EventArgs e) {
-      dispatcher = new RandomDispatcher(store);
+      dispatcher = new SimpleDispatcher(store);
       executer = new Executer(dispatcher, store, gridAddress.Text);
       executer.Start();

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);
     }
   }