Changeset 1922 for trunk/sources/HeuristicLab.CEDMA.Server

Timestamp:

05/27/09 18:26:10 (15 years ago)

Author:

gkronber

Message:

#650 (IAlgorithm and derived interfaces should provide properties to retrieve results):

• Implemented properties to retrieve model quality
• Changed CEDMA executor to retrieve results via properties
• Removed obsolete class Execution in CEDMA (replaced by the interface IAlgorithm)

Location:

trunk/sources/HeuristicLab.CEDMA.Server/3.3

Files:

• DispatcherBase.cs (modified) (3 diffs)
• ExecuterBase.cs (modified) (2 diffs)
• Execution.cs (deleted)
• GridExecuter.cs (modified) (5 diffs)
• HeuristicLab.CEDMA.Server-3.3.csproj (modified) (1 diff)
• HiveExecuter.cs (modified) (6 diffs)
• IDispatcher.cs (modified) (1 diff)

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

@@ -44 +44 @@
     }
 
-    public Execution GetNextJob() {
+    public IAlgorithm GetNextJob() {
       // find and select a dataset
       var dataSetVar = new HeuristicLab.CEDMA.DB.Interfaces.Variable("DataSet");
@@ -67 +67 @@
 
       if (selectedAlgorithm != null) {
-        Execution exec = CreateExecution(dataSet.Problem, targetVariable, selectedAlgorithm);
-        exec.DataSetEntity = dataSetEntity;
-        exec.TargetVariable = targetVariableName;
-        return exec;
-      } else return null;
+        SetProblemParameters(selectedAlgorithm, dataSet.Problem, targetVariable);
+      }
+      return selectedAlgorithm;
     }
 
@@ -78 +76 @@
     public abstract IAlgorithm SelectAlgorithm(Entity dataSet, int targetVariable, LearningTask learningTask);
 
-    private Execution CreateExecution(Problem problem, int targetVariable, IAlgorithm algorithm) {
-      SetProblemParameters(algorithm, problem, targetVariable);
-      Execution exec = new Execution(algorithm.Engine);
-      exec.Description = algorithm.Name;
-      return exec;
-    }
-
     private void SetProblemParameters(IAlgorithm algo, Problem problem, int targetVariable) {
-      algo.ProblemInjector.GetVariable("Dataset").Value = problem.DataSet;
-      algo.ProblemInjector.GetVariable("TargetVariable").GetValue<IntData>().Data = targetVariable;
+      algo.Dataset = problem.DataSet;
+      algo.TargetVariable = targetVariable;
       algo.ProblemInjector.GetVariable("TrainingSamplesStart").GetValue<IntData>().Data = problem.TrainingSamplesStart;
       algo.ProblemInjector.GetVariable("TrainingSamplesEnd").GetValue<IntData>().Data = problem.TrainingSamplesEnd;

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

@@ -38 +38 @@
 using HeuristicLab.Core;
 using System.Threading;
+using HeuristicLab.Modeling;
 
 namespace HeuristicLab.CEDMA.Server {
@@ -68 +69 @@
     protected abstract void StartJobs();
 
-    protected void StoreResults(Execution finishedExecution, IEngine finishedEngine) {
-      Entity model = new Entity(Ontology.CedmaNameSpace + Guid.NewGuid());
-      store.Add(new Statement(finishedExecution.DataSetEntity, Ontology.PredicateHasModel, model));
-      StoreModelAttribute(model, Ontology.TargetVariable, finishedExecution.TargetVariable);
-      StoreModelAttribute(model, Ontology.AlgorithmName, finishedExecution.Description);
-      Scope bestModelScope = finishedEngine.GlobalScope.GetVariableValue<Scope>("BestValidationSolution", false);
-      StoreModelVariable(model, Ontology.TrainingMeanSquaredError, bestModelScope, "Quality");
-      StoreModelVariable(model, Ontology.ValidationMeanSquaredError, bestModelScope, "ValidationQuality");
-      StoreModelVariable(model, Ontology.TestMeanSquaredError, bestModelScope, "TestQuality");
-      StoreModelVariable(model, Ontology.TrainingMeanAbsolutePercentageError, bestModelScope, "TrainingMAPE");
-      StoreModelVariable(model, Ontology.ValidationMeanAbsolutePercentageError, bestModelScope, "ValidationMAPE");
-      StoreModelVariable(model, Ontology.TestMeanAbsolutePercentageError, bestModelScope, "TestMAPE");
-      StoreModelVariable(model, Ontology.TrainingMeanAbsolutePercentageOfRangeError, bestModelScope, "TrainingMAPRE");
-      StoreModelVariable(model, Ontology.ValidationMeanAbsolutePercentageOfRangeError, bestModelScope, "ValidationMAPRE");
-      StoreModelVariable(model, Ontology.TestMeanAbsolutePercentageOfRangeError, bestModelScope, "TestMAPRE");
-      StoreModelVariable(model, Ontology.TrainingCoefficientOfDetermination, bestModelScope, "TrainingR2");
-      StoreModelVariable(model, Ontology.ValidationCoefficientOfDetermination, bestModelScope, "ValidationR2");
-      StoreModelVariable(model, Ontology.TestCoefficientOfDetermination, bestModelScope, "TestR2");
-      StoreModelVariable(model, Ontology.TrainingCoefficientOfDetermination, bestModelScope, "TrainingVAF");
-      StoreModelVariable(model, Ontology.ValidationCoefficientOfDetermination, bestModelScope, "ValidationVAF");
-      StoreModelVariable(model, Ontology.TestCoefficientOfDetermination, bestModelScope, "TestVAF");
-      StoreModelVariable(model, Ontology.TrainingTheilsInequalityCoefficient, bestModelScope, "TrainingTheilInequalityCoefficient");
-      StoreModelVariable(model, Ontology.ValidationTheilsInequalityCoefficient, bestModelScope, "ValidationTheilInequalityCoefficient");
-      StoreModelVariable(model, Ontology.TestTheilsInequalityCoefficient, bestModelScope, "TestTheilInequalityCoefficient");
-      StoreModelVariable(model, Ontology.TrainingAccuracy, bestModelScope, "TrainingAccuracy");
-      StoreModelVariable(model, Ontology.ValidationAccuracy, bestModelScope, "ValidationAccuracy");
-      StoreModelVariable(model, Ontology.TestAccuracy, bestModelScope, "TestAccuracy");
-      StoreModelVariable(model, Ontology.TreeSize, bestModelScope, "TreeSize");
-      StoreModelVariable(model, Ontology.TreeHeight, bestModelScope, "TreeHeight");
-      StoreModelVariable(model, Ontology.EvaluatedSolutions, bestModelScope, "EvaluatedSolutions");
+    protected void StoreResults(IAlgorithm finishedAlgorithm) {
+      Entity modelEntity = new Entity(Ontology.CedmaNameSpace + Guid.NewGuid());
+      // TODO (gkronber 27052009)
+      // store.Add(new Statement(finishedAlgorithm.DataSetEntity, Ontology.PredicateHasModel, modelEntity));
+      StoreModelAttribute(modelEntity, Ontology.TargetVariable, finishedAlgorithm.Model.TargetVariable);
+      StoreModelAttribute(modelEntity, Ontology.AlgorithmName, finishedAlgorithm.Description);
+      
+      IModel model = finishedAlgorithm.Model;
+      StoreModelAttribute(modelEntity, Ontology.TrainingMeanSquaredError, model.TrainingMeanSquaredError);
+      StoreModelAttribute(modelEntity, Ontology.ValidationMeanSquaredError, model.ValidationMeanSquaredError);
+      StoreModelAttribute(modelEntity, Ontology.TestMeanSquaredError, model.TestMeanSquaredError);
+      StoreModelAttribute(modelEntity, Ontology.TrainingCoefficientOfDetermination, model.TrainingCoefficientOfDetermination);
+      StoreModelAttribute(modelEntity, Ontology.ValidationCoefficientOfDetermination, model.ValidationCoefficientOfDetermination);
+      StoreModelAttribute(modelEntity, Ontology.TestCoefficientOfDetermination, model.TestCoefficientOfDetermination);
+      StoreModelAttribute(modelEntity, Ontology.TrainingVarianceAccountedFor, model.TrainingVarianceAccountedFor);
+      StoreModelAttribute(modelEntity, Ontology.ValidationVarianceAccountedFor, model.ValidationVarianceAccountedFor);
+      StoreModelAttribute(modelEntity, Ontology.TestVarianceAccountedFor, model.TestVarianceAccountedFor);
+      StoreModelAttribute(modelEntity, Ontology.TrainingMeanAbsolutePercentageError, model.TrainingMeanAbsolutePercentageError);
+      StoreModelAttribute(modelEntity, Ontology.ValidationMeanAbsolutePercentageError, model.ValidationMeanAbsolutePercentageError);
+      StoreModelAttribute(modelEntity, Ontology.TestMeanAbsolutePercentageError, model.TestMeanAbsolutePercentageError);
+      StoreModelAttribute(modelEntity, Ontology.TrainingMeanAbsolutePercentageOfRangeError, model.TrainingMeanAbsolutePercentageOfRangeError);
+      StoreModelAttribute(modelEntity, Ontology.ValidationMeanAbsolutePercentageOfRangeError, model.ValidationMeanAbsolutePercentageOfRangeError);
+      StoreModelAttribute(modelEntity, Ontology.TestMeanAbsolutePercentageOfRangeError, model.TestMeanAbsolutePercentageOfRangeError);
 
-      byte[] serializedModel = PersistenceManager.SaveToGZip(bestModelScope.GetVariableValue("FunctionTree", false));
-      store.Add(new Statement(model, Ontology.PredicateSerializedData, new Literal(Convert.ToBase64String(serializedModel))));
-    }
-
-    private void StoreModelVariable(Entity model, Entity entity, Scope scope, string variableName) {
-      if (scope.GetVariable(variableName) != null)
-        StoreModelAttribute(model, entity, scope.GetVariableValue<ObjectData>(variableName, false).Data);
+      byte[] serializedModel = PersistenceManager.SaveToGZip(model.Data);
+      store.Add(new Statement(modelEntity, Ontology.PredicateSerializedData, new Literal(Convert.ToBase64String(serializedModel))));
     }
 

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

@@ -38 +38 @@
 using HeuristicLab.Core;
 using System.Threading;
+using HeuristicLab.Modeling;
 
 namespace HeuristicLab.CEDMA.Server {
   public class GridExecuter : ExecuterBase {
     private JobManager jobManager;
-    private Dictionary<WaitHandle, Execution> activeExecutions;
+    private Dictionary<WaitHandle, IAlgorithm> activeAlgorithms;
 
     private TimeSpan StartJobInterval {
@@ -66 +67 @@
             Thread.Sleep(StartJobInterval);
             // get an execution from the dispatcher and execute in grid via job-manager
-            Execution execution = Dispatcher.GetNextJob();
-            if (execution != null) {
-              AtomicOperation op = new AtomicOperation(execution.Engine.OperatorGraph.InitialOperator, execution.Engine.GlobalScope);
-              WaitHandle opWh = jobManager.BeginExecuteOperation(execution.Engine.GlobalScope, op);
+            IAlgorithm algorithm = Dispatcher.GetNextJob();
+            if (algorithm != null) {
+              AtomicOperation op = new AtomicOperation(algorithm.Engine.OperatorGraph.InitialOperator, algorithm.Engine.GlobalScope);
+              WaitHandle opWh = jobManager.BeginExecuteOperation(algorithm.Engine.GlobalScope, op);
               wh.Add(opWh);
               activeOperations.Add(opWh, op);
-              lock (activeExecutions) {
-                activeExecutions.Add(opWh, execution);
+              lock (activeAlgorithms) {
+                activeAlgorithms.Add(opWh, algorithm);
               }
             }
@@ -84 +85 @@
             AtomicOperation finishedOp = activeOperations[readyHandle];
             wh.Remove(readyHandle);
-            Execution finishedExecution = null;
-            lock (activeExecutions) {
-              finishedExecution = activeExecutions[readyHandle];
-              activeExecutions.Remove(readyHandle);
+            IAlgorithm finishedAlgorithm = null;
+            lock (activeAlgorithms) {
+              finishedAlgorithm = activeAlgorithms[readyHandle];
+              activeAlgorithms.Remove(readyHandle);
             }
             activeOperations.Remove(readyHandle);
@@ -99 +100 @@
             }
             if (finishedEngine != null) {
-              StoreResults(finishedExecution, finishedEngine);
+              StoreResults(finishedAlgorithm);
             }
           }
@@ -110 +111 @@
 
     public override string[] GetJobs() {
-      lock (activeExecutions) {
-        string[] retVal = new string[activeExecutions.Count];
+      lock (activeAlgorithms) {
+        string[] retVal = new string[activeAlgorithms.Count];
         int i = 0;
-        foreach (Execution e in activeExecutions.Values) {
-          retVal[i++] = "Target-Variable: " + e.TargetVariable + " " + e.Description;
+        foreach (IAlgorithm a in activeAlgorithms.Values) {
+          retVal[i++] = "Target-Variable: " + a.TargetVariable + " " + a.Description;
         }
         return retVal;

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

@@ -99 +99 @@
     <Compile Include="GridExecuter.cs" />
     <Compile Include="IDispatcher.cs" />
-    <Compile Include="Execution.cs" />
     <Compile Include="Server.cs" />
     <Compile Include="ServerApplication.cs" />

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

@@ -39 +39 @@
 using System.Threading;
 using HeuristicLab.Hive.Engine;
+using HeuristicLab.Modeling;
 
 namespace HeuristicLab.CEDMA.Server {
   public class HiveExecuter : ExecuterBase {
-    private Dictionary<WaitHandle, Execution> activeExecutions;
+    private Dictionary<WaitHandle, IAlgorithm> activeAlgorithms;
     private Dictionary<WaitHandle, HiveEngine> activeEngines;
     private string hiveUrl;
@@ -57 +58 @@
       : base(dispatcher, store) {
       this.hiveUrl = hiveUrl;
-      activeExecutions = new Dictionary<WaitHandle, Execution>();
+      activeAlgorithms = new Dictionary<WaitHandle, IAlgorithm>();
       activeEngines = new Dictionary<WaitHandle, HiveEngine>();
     }
@@ -68 +69 @@
           while (wh.Count < MaxActiveJobs) {
             Thread.Sleep(StartJobInterval);
-            // get an execution from the dispatcher and execute in grid via job-manager
-            Execution execution = Dispatcher.GetNextJob();
-            if (execution != null) {
+            // get an algo from the dispatcher and execute in grid via job-manager
+            IAlgorithm algorithm = Dispatcher.GetNextJob();
+            if (algorithm != null) {
               HiveEngine engine = new HiveEngine();
               engine.HiveServerUrl = hiveUrl;
-              IOperator initialOp = execution.Engine.OperatorGraph.InitialOperator;
+              IOperator initialOp = algorithm.Engine.OperatorGraph.InitialOperator;
               engine.OperatorGraph.AddOperator(initialOp);
               engine.OperatorGraph.InitialOperator = initialOp;
-              RegisterFinishedCallback(engine, execution, wh);
+              RegisterFinishedCallback(engine, algorithm, wh);
               engine.Reset();
               engine.Execute();
@@ -90 +91 @@
             activeEngines.Remove(readyHandle);
 
-            Execution finishedExecution = activeExecutions[readyHandle];
-            lock (activeExecutions) {
-              activeExecutions.Remove(readyHandle);
+            IAlgorithm finishedAlgorithm = activeAlgorithms[readyHandle];
+            lock (activeAlgorithms) {
+              activeAlgorithms.Remove(readyHandle);
             }
-            StoreResults(finishedExecution, finishedEngine);
+            StoreResults(finishedAlgorithm);
             readyHandle.Close();
           }
@@ -104 +105 @@
     }
 
-    private void RegisterFinishedCallback(HiveEngine engine, Execution execution, List<WaitHandle> wh) {
+    private void RegisterFinishedCallback(HiveEngine engine, IAlgorithm algorithm, List<WaitHandle> wh) {
       ManualResetEvent waithandle = new ManualResetEvent(false);
       wh.Add(waithandle);
       engine.Finished += (sender, args) => waithandle.Set();
-      lock (activeExecutions) {
-        activeExecutions.Add(waithandle, execution);
+      lock (activeAlgorithms) {
+        activeAlgorithms.Add(waithandle, algorithm);
       }
       activeEngines.Add(waithandle, engine);
@@ -115 +116 @@
 
     public override string[] GetJobs() {
-      lock (activeExecutions) {
-        string[] retVal = new string[activeExecutions.Count];
+      lock (activeAlgorithms) {
+        string[] retVal = new string[activeAlgorithms.Count];
         int i = 0;
-        foreach (Execution e in activeExecutions.Values) {
-          retVal[i++] = "Target-Variable: " + e.TargetVariable + " " + e.Description;
+        foreach (IAlgorithm a in activeAlgorithms.Values) {
+          retVal[i++] = "Target-Variable: " + a.TargetVariable + " " + a.Description;
         }
         return retVal;

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

@@ -35 +35 @@
 using HeuristicLab.Data;
 using HeuristicLab.Core;
+using HeuristicLab.Modeling;
 
 namespace HeuristicLab.CEDMA.Server {
   public interface IDispatcher {
-    Execution GetNextJob();
+    IAlgorithm GetNextJob();
   }
 }