Changeset 2012

Timestamp:

06/04/09 19:14:48 (16 years ago)

Author:

gkronber

Message:

Fixed a few bugs introduced with r2000. #656 (CEDMA server should handle only one data set (problem) at a time)

Location:

trunk/sources

Files:

• HeuristicLab.CEDMA.Server/3.3/DispatcherBase.cs (modified) (2 diffs)
• HeuristicLab.CEDMA.Server/3.3/GridExecuter.cs (modified) (2 diffs)
• HeuristicLab.CEDMA.Server/3.3/HiveExecuter.cs (modified) (1 diff)
• HeuristicLab.CEDMA.Server/3.3/SimpleDispatcher.cs (modified) (4 diffs)
• HeuristicLab.DataAnalysis/3.2/Dataset.cs (modified) (2 diffs)

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

@@ -40 +40 @@
   public abstract class DispatcherBase : IDispatcher {
     private IStore store;
+    private DataSet dataset;
+    
     public DispatcherBase(IStore store) {
       this.store = store;
@@ -45 +47 @@
 
     public IAlgorithm GetNextJob() {
-      // find and select a dataset
-      var dataSetVar = new HeuristicLab.CEDMA.DB.Interfaces.Variable("DataSet");
-      var dataSetQuery = new Statement[] {
-        new Statement(dataSetVar, Ontology.PredicateInstanceOf, Ontology.TypeDataSet)
-      };
-
-      Entity[] datasets = store.Query("?DataSet <" + Ontology.PredicateInstanceOf.Uri + "> <" + Ontology.TypeDataSet.Uri + "> .", 0, 100)
-        .Select(x => (Entity)x.Get("DataSet"))
-        .ToArray();
-
-      // no datasets => do nothing
-      if (datasets.Length == 0) return null;
-
-      Entity dataSetEntity = SelectDataSet(datasets);
-      DataSet dataSet = new DataSet(store, dataSetEntity);
-
-      int targetVariable = SelectTargetVariable(dataSetEntity, dataSet.Problem.AllowedTargetVariables.ToArray());
-      IAlgorithm selectedAlgorithm = SelectAlgorithm(dataSetEntity, targetVariable, dataSet.Problem.LearningTask);
-      string targetVariableName = dataSet.Problem.GetVariableName(targetVariable);
+      if (dataset == null) {
+        var datasetEntities = store.Query("?DataSet <" + Ontology.PredicateInstanceOf.Uri + "> <" + Ontology.TypeDataSet.Uri + "> .", 0, 1)
+          .Select(x => (Entity)x.Get("DataSet"));
+        if (datasetEntities.Count() == 0) return null;
+        dataset = new DataSet(store, datasetEntities.ElementAt(0));
+      }
+      int targetVariable = SelectTargetVariable(dataset.Problem.AllowedTargetVariables.ToArray());
+      IAlgorithm selectedAlgorithm = SelectAlgorithm(targetVariable, dataset.Problem.LearningTask);
+      string targetVariableName = dataset.Problem.GetVariableName(targetVariable);
 
       if (selectedAlgorithm != null) {
-        SetProblemParameters(selectedAlgorithm, dataSet.Problem, targetVariable);
+        SetProblemParameters(selectedAlgorithm, dataset.Problem, targetVariable);
       }
       return selectedAlgorithm;
     }
 
-    public abstract Entity SelectDataSet(Entity[] datasets);
-    public abstract int SelectTargetVariable(Entity dataSet, int[] targetVariables);
-    public abstract IAlgorithm SelectAlgorithm(Entity dataSet, int targetVariable, LearningTask learningTask);
+    public abstract int SelectTargetVariable(int[] targetVariables);
+    public abstract IAlgorithm SelectAlgorithm(int targetVariable, LearningTask learningTask);
 
     private void SetProblemParameters(IAlgorithm algo, Problem problem, int targetVariable) {

trunk/sources/HeuristicLab.CEDMA.Server/3.3/GridExecuter.cs ¶

@@ -53 +53 @@
     }
 
-    public GridExecuter(IDispatcher dispatcher, IStore store, string gridUrl) : base(dispatcher, store) {
+    public GridExecuter(IDispatcher dispatcher, IStore store, string gridUrl)
+      : base(dispatcher, store) {
       this.jobManager = new JobManager(gridUrl);
+      activeAlgorithms = new Dictionary<WaitHandle, IAlgorithm>();
       jobManager.Reset();
     }
@@ -115 +117 @@
         int i = 0;
         foreach (IAlgorithm a in activeAlgorithms.Values) {
-          retVal[i++] = "Target-Variable: " + a.TargetVariable + " " + a.Description;
+          retVal[i++] = a.Name + " " + a.Dataset.GetVariableName(a.TargetVariable);
         }
         return retVal;

trunk/sources/HeuristicLab.CEDMA.Server/3.3/HiveExecuter.cs ¶

@@ -120 +120 @@
         int i = 0;
         foreach (IAlgorithm a in activeAlgorithms.Values) {
-          retVal[i++] = "Target-Variable: " + a.TargetVariable + " " + a.Description;
+          retVal[i++] = a.Name + " " + a.Dataset.GetVariableName(a.TargetVariable);
         }
         return retVal;

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

@@ -41 +41 @@
     private Random random;
     private IStore store;
-    private Dictionary<Entity, Dictionary<int, List<string>>> finishedAndDispatchedRuns;
+    private Dictionary<int, List<string>> finishedAndDispatchedRuns;
 
     public SimpleDispatcher(IStore store)
@@ -47 +47 @@
       this.store = store;
       random = new Random();
-      finishedAndDispatchedRuns = new Dictionary<Entity, Dictionary<int, List<string>>>();
+      finishedAndDispatchedRuns = new Dictionary<int, List<string>>();
       PopulateFinishedRuns();
     }
 
-    public override IAlgorithm SelectAlgorithm(Entity dataSetEntity, int targetVariable, LearningTask learningTask) {
+    public override IAlgorithm SelectAlgorithm(int targetVariable, LearningTask learningTask) {
       DiscoveryService ds = new DiscoveryService();
       IAlgorithm[] algos = ds.GetInstances<IAlgorithm>();
@@ -58 +58 @@
         case LearningTask.Regression: {
             var regressionAlgos = algos.Where(a => (a as IClassificationAlgorithm) == null && (a as ITimeSeriesAlgorithm) == null);
-            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, regressionAlgos) ?? ChooseStochastic(regressionAlgos);
+            selectedAlgorithm = ChooseDeterministic(targetVariable, regressionAlgos) ?? ChooseStochastic(regressionAlgos);
             break;
           }
         case LearningTask.Classification: {
             var classificationAlgos = algos.Where(a => (a as IClassificationAlgorithm) != null);
-            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, classificationAlgos) ?? ChooseStochastic(classificationAlgos);
+            selectedAlgorithm = ChooseDeterministic(targetVariable, classificationAlgos) ?? ChooseStochastic(classificationAlgos);
             break;
           }
         case LearningTask.TimeSeries: {
             var timeSeriesAlgos = algos.Where(a => (a as ITimeSeriesAlgorithm) != null);
-            selectedAlgorithm = ChooseDeterministic(dataSetEntity, targetVariable, timeSeriesAlgos) ?? ChooseStochastic(timeSeriesAlgos);
+            selectedAlgorithm = ChooseDeterministic(targetVariable, timeSeriesAlgos) ?? ChooseStochastic(timeSeriesAlgos);
             break;
           }
       }
       if (selectedAlgorithm != null) {
-        AddDispatchedRun(dataSetEntity, targetVariable, selectedAlgorithm.Name);
+        AddDispatchedRun(targetVariable, selectedAlgorithm.Name);
       }
       return selectedAlgorithm;
     }
 
-    private IAlgorithm ChooseDeterministic(Entity dataSetEntity, int targetVariable, IEnumerable<IAlgorithm> algos) {
+    private IAlgorithm ChooseDeterministic(int targetVariable, IEnumerable<IAlgorithm> algos) {
       var deterministicAlgos = algos
         .Where(a => (a as IStochasticAlgorithm) == null)
-        .Where(a => AlgorithmFinishedOrDispatched(dataSetEntity, targetVariable, a.Name) == false);
+        .Where(a => AlgorithmFinishedOrDispatched(targetVariable, a.Name) == false);
 
       if (deterministicAlgos.Count() == 0) return null;
@@ -93 +93 @@
     }
 
-    public override Entity SelectDataSet(Entity[] datasets) {
-      return datasets[random.Next(datasets.Length)];
-    }
-
-    public override int SelectTargetVariable(Entity dataSet, int[] targetVariables) {
+    public override int SelectTargetVariable(int[] targetVariables) {
       return targetVariables[random.Next(targetVariables.Length)];
     }
 
     private void PopulateFinishedRuns() {
+      var datasetEntity = store
+        .Query(
+        "?Dataset <" + Ontology.PredicateInstanceOf + "> <" + Ontology.TypeDataSet + "> .", 0, 1)
+        .Select(x => (Entity)x.Get("Dataset")).ElementAt(0);
+      DataSet ds = new DataSet(store, datasetEntity);
+
       var result = store
-        .Query("?DataSet <" + Ontology.PredicateInstanceOf.Uri + "> <" + Ontology.TypeDataSet.Uri + "> ." + Environment.NewLine +
-        "?DataSet <" + Ontology.PredicateHasModel + "> ?Model ." + Environment.NewLine +
+        .Query(
         "?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") });
+        .Select(x => new Resource[] { (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);
+        string targetVariable = (string)((Literal)row[0]).Value;
+        string algoName = (string)((Literal)row[1]).Value;
+
+        int targetVariableIndex = ds.Problem.Dataset.GetVariableIndex(targetVariable);
+        if (!AlgorithmFinishedOrDispatched(targetVariableIndex, algoName))
+          AddDispatchedRun(targetVariableIndex, algoName);
       }
     }
 
-    private void AddDispatchedRun(Entity dataSetEntity, int targetVariable, string algoName) {
-      if (!finishedAndDispatchedRuns.ContainsKey(dataSetEntity)) {
-        finishedAndDispatchedRuns[dataSetEntity] = new Dictionary<int, List<string>>();
+    private void AddDispatchedRun(int targetVariable, string algoName) {
+      if (!finishedAndDispatchedRuns.ContainsKey(targetVariable)) {
+        finishedAndDispatchedRuns[targetVariable] = new List<string>();
       }
-      if (!finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable)) {
-        finishedAndDispatchedRuns[dataSetEntity][targetVariable] = new List<string>();
-      }
-      finishedAndDispatchedRuns[dataSetEntity][targetVariable].Add(algoName);
+      finishedAndDispatchedRuns[targetVariable].Add(algoName);
     }
 
-    private bool AlgorithmFinishedOrDispatched(Entity dataSetEntity, int targetVariable, string algoName) {
+    private bool AlgorithmFinishedOrDispatched(int targetVariable, string algoName) {
       return
-        finishedAndDispatchedRuns.ContainsKey(dataSetEntity) &&
-        finishedAndDispatchedRuns[dataSetEntity].ContainsKey(targetVariable) &&
-        finishedAndDispatchedRuns[dataSetEntity][targetVariable].Contains(algoName);
+        finishedAndDispatchedRuns.ContainsKey(targetVariable) &&
+        finishedAndDispatchedRuns[targetVariable].Contains(algoName);
     }
   }

trunk/sources/HeuristicLab.DataAnalysis/3.2/Dataset.cs ¶

@@ -120 +120 @@
     }
 
+    public int GetVariableIndex(string variableName) {
+      for (int i = 0; i < variableNames.Length; i++) {
+        if (variableNames[i].Equals(variableName)) return i;
+      }
+      throw new ArgumentException("The variable name " + variableName + " was not found.");
+    }
+
     public void SetVariableName(int variableIndex, string name) {
       variableNames[variableIndex] = name;
     }
 
-
     public override IView CreateView() {
       return new DatasetView(this);
     }
 
+    #region persistence
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       Dataset clone = new Dataset();
@@ -256 +263 @@
       return xs;
     }
+    #endregion
 
     public double GetMean(int column) {