validation tests ok

8 files changed, 57 insertions, 47 deletions

diff --git a/lib/prediction_data.rb b/lib/prediction_data.rb
index 2f80e8e..9182307 100644
--- a/lib/prediction_data.rb
+++ b/lib/prediction_data.rb
@@ -101,7 +101,7 @@ module Lib
         
         if feature_type=="classification"
           av = OpenTox::Feature.find(prediction_feature).accept_values
-          internal_server_error "'"+OT.acceptValue.to_s+"' missing/invalid for feature '"+prediction_feature.to_s+"' in dataset '"+
+          internal_server_error "'"+RDF::OT.acceptValue.to_s+"' missing/invalid for feature '"+prediction_feature.to_s+"' in dataset '"+
             test_dataset_uri.to_s+"', acceptValues are: '"+av.inspect+"'" if av==nil or av.length<2
           if accept_values==nil
             accept_values=av
@@ -129,11 +129,11 @@ module Lib
         internal_server_error "predicted_variable not found in prediction_dataset\n"+
             "predicted_variable '"+predicted_variable.to_s+"'\n"+
             "prediction_dataset: '"+prediction_dataset_uri.to_s+"'\n"+
-            "available features are: "+prediction_dataset.features.inspect if prediction_dataset.find_feature(predicted_variable)==nil and prediction_dataset.compounds.size>0
+            "available features are: "+prediction_dataset.features.inspect if prediction_dataset.find_feature_uri(predicted_variable)==nil and prediction_dataset.compounds.size>0
         internal_server_error "predicted_confidence not found in prediction_dataset\n"+
                 "predicted_confidence '"+predicted_confidence.to_s+"'\n"+
                 "prediction_dataset: '"+prediction_dataset_uri.to_s+"'\n"+
-                "available features are: "+prediction_dataset.features.inspect if predicted_confidence and prediction_dataset.find_feature(predicted_confidence)==nil and prediction_dataset.compounds.size>0
+                "available features are: "+prediction_dataset.features.inspect if predicted_confidence and prediction_dataset.find_feature_uri(predicted_confidence)==nil and prediction_dataset.compounds.size>0
 
         #internal_server_error "more predicted than test compounds, #test: "+test_dataset.compounds.size.to_s+" < #prediction: "+
         #  prediction_dataset.compounds.size.to_s+", test-dataset: "+test_dataset_uri.to_s+", prediction-dataset: "+
@@ -178,6 +178,10 @@ module Lib
         
         task.progress( task_status += task_step ) if task # loaded predicted values and confidence
       end
+        puts all_compounds.inspect
+        puts all_predicted_values.inspect
+        puts all_actual_values.inspect
+        puts all_confidence_values.inspect
       
       #sort according to confidence if available
       if all_confidence_values.compact.size>0
@@ -204,6 +208,7 @@ module Lib
       data = { :predicted_values => all_predicted_values, :actual_values => all_actual_values, :confidence_values => all_confidence_values,
         :feature_type => feature_type, :accept_values => accept_values }
         
+      puts data.inspect
       PredictionData.new(data, all_compounds)
     end
     
@@ -226,7 +231,10 @@ module Lib
     end
     
     def self.classification_val(dataset, compound_index, feature, accept_values)
+      puts compound_index
+      puts feature.inspect
       v = dataset.data_entry_value(compound_index, feature)
+      puts v.to_s
       i = accept_values.index(v)
       internal_server_error "illegal class_value of prediction (value is '"+v.to_s+"'), accept values are "+
         accept_values.inspect unless v==nil or i!=nil
diff --git a/report/report_application.rb b/report/report_application.rb
index 1273463..a4d3d1f 100755
--- a/report/report_application.rb
+++ b/report/report_application.rb
@@ -145,6 +145,7 @@ class Validation::Application < OpenTox::Service
     bad_request_error "validation_uris missing" unless params[:validation_uris].to_s.size>0
     task = OpenTox::Task.run("Create report",to("/validation/report/"+params[:type], :full)) do |task| #,params
       perform do |rs|
+        puts rs.inspect
         rs.create_report(params[:type],params[:validation_uris]?params[:validation_uris].split(/\n|,/):nil,
           params[:identifier]?params[:identifier].split(/\n|,/):nil,params,@subjectid,task)
       end
diff --git a/report/report_persistance.rb b/report/report_persistance.rb
index 6832b0f..a0f16d5 100755
--- a/report/report_persistance.rb
+++ b/report/report_persistance.rb
@@ -234,7 +234,7 @@ module Reports
     
     def to_rdf
       s = OpenTox::Serializer::Owl.new
-      s.add_resource(report_uri,OT.Report,get_content_as_hash.keys_to_rdf_format.keys_to_owl_uris)
+      s.add_resource(report_uri,RDF::OT.Report,get_content_as_hash.keys_to_rdf_format.keys_to_owl_uris)
       s.to_rdfxml
     end
   end
diff --git a/report/validation_access.rb b/report/validation_access.rb
index fe2c401..c6f6d2f 100755
--- a/report/validation_access.rb
+++ b/report/validation_access.rb
@@ -177,7 +177,7 @@ class Reports::ValidationDB
       uri = OpenTox::RestClientWrapper.post(feat_gen,{:subjectid => subjectid,
         :feature_dataset_uri=>training_feature_dataset_uri(validation,subjectid),
         :dataset_uri=>validation.test_dataset_uri})
-      @@tmp_resources << OpenTox.wait_for_task(uri)
+      @@tmp_resources << wait_for_task(uri)
     end
     uri
   end
@@ -219,8 +219,8 @@ class Reports::ValidationDB
   
   def feature_type( validation, subjectid=nil )
     m = OpenTox::Model.new(validation.model_uri,subjectid)
-    m.get
-    m.feature_type(subjectid)
+    #m.get
+    m.feature_type
     #get_model(validation).classification?
   end
   
@@ -229,7 +229,7 @@ class Reports::ValidationDB
     model = OpenTox::Model.new(validation.model_uri,subjectid)
     model.get
     resource_not_found_error "model not found '"+validation.model_uri+"'" unless model
-    model.predicted_variable(subjectid)
+    model.predicted_variable
   end
   
   def predicted_confidence(validation, subjectid=nil)
@@ -237,7 +237,7 @@ class Reports::ValidationDB
     model = OpenTox::Model.new(validation.model_uri,subjectid)
     model.get
     resource_not_found_error "model not found '"+validation.model_uri+"'" unless model
-    model.predicted_confidence(subjectid)
+    model.predicted_confidence
   end
   
 #  private
diff --git a/test/test_examples_util.rb b/test/test_examples_util.rb
index 2edd91a..5cc2011 100755
--- a/test/test_examples_util.rb
+++ b/test/test_examples_util.rb
@@ -84,7 +84,7 @@ module ValidationExamples
       else
         params[:accept] = accept_header
         uri = OpenTox::RestClientWrapper.post(File.join($validation[:uri],uri),params,{},waiting_task).to_s
-        uri = OpenTox.wait_for_task(uri)
+        uri = wait_for_task(uri)
       end
       raise "validation post result not a validation uri: #{uri}" unless uri.validation_uri?
       uri
@@ -359,19 +359,19 @@ module ValidationExamples
         size = 0
         target = nil
         
-        cv.metadata[OT.validation].each do |v|
+        cv.metadata[RDF::OT.validation].each do |v|
           val = OpenTox::Validation.find(v)
           dataset = {}
-          dataset[:test] = val.metadata[OT.testDataset]
-          dataset[:training] = val.metadata[OT.trainingDataset]
-          #dataset[:target] = val.metadata[OT.testTargetDataset]
-          raise if (target!=nil and target!=val.metadata[OT.testTargetDataset])
-          target = val.metadata[OT.testTargetDataset]
+          dataset[:test] = val.metadata[RDF::OT.testDataset]
+          dataset[:training] = val.metadata[RDF::OT.trainingDataset]
+          #dataset[:target] = val.metadata[RDF::OT.testTargetDataset]
+          raise if (target!=nil and target!=val.metadata[RDF::OT.testTargetDataset])
+          target = val.metadata[RDF::OT.testTargetDataset]
             
-          dataset[:prediction] = val.metadata[OT.predictionDataset]
-          m =  val.metadata[OT.model]
+          dataset[:prediction] = val.metadata[RDF::OT.predictionDataset]
+          m =  val.metadata[RDF::OT.model]
           model = OpenTox::Model::Generic.find(m)
-          dataset[:feature] = model.metadata[OT.featureDataset]
+          dataset[:feature] = model.metadata[RDF::OT.featureDataset]
           
           puts v
           val_size = 0
diff --git a/validation/validation_application.rb b/validation/validation_application.rb
index 036b083..2bf838d 100755
--- a/validation/validation_application.rb
+++ b/validation/validation_application.rb
@@ -24,8 +24,8 @@ class Validation::Application < OpenTox::Service
       model_uri = params.delete("model") || params.delete("model_uri")
       if model_uri
         model = OpenTox::Model::Generic.find(model_uri, @subjectid)
-        params[:algorithm] = model.metadata[OT.algorithm]
-        params[:dataset] = model.metadata[OT.trainingDataset]
+        params[:algorithm] = model.metadata[RDF::OT.algorithm]
+        params[:dataset] = model.metadata[RDF::OT.trainingDataset]
       end
       uri_list = Lib::OhmUtil.find( Validation::Crossvalidation, params ).sort.collect{|v| v.crossvalidation_uri}.join("\n") + "\n"
       if request.env['HTTP_ACCEPT'] =~ /text\/html/
diff --git a/validation/validation_format.rb b/validation/validation_format.rb
index d17c3c1..9b7904d 100755
--- a/validation/validation_format.rb
+++ b/validation/validation_format.rb
@@ -16,7 +16,7 @@ module Validation
          h[p] = self.send(p.to_s)
       end
       if crossvalidation_id!=nil
-        cv = {:type => OT.CrossvalidationInfo.to_s}
+        cv = {:type => RDF::OT.CrossvalidationInfo.to_s}
         #skip crossvalidation_id
         cv[:crossvalidation_fold] = self.crossvalidation_fold
         cv[:crossvalidation_uri] = self.crossvalidation_uri.force_encoding("UTF-8")
@@ -25,7 +25,7 @@ module Validation
       if classification_statistics 
         internal_server_error "classification_statistics is no hash: "+classification_statistics.class.to_s+" -> '"+
           classification_statistics.to_s+"'" unless classification_statistics.is_a?(Hash)
-        clazz = { :type => OT.ClassificationStatistics.to_s }
+        clazz = { :type => RDF::OT.ClassificationStatistics.to_s }
         VAL_CLASS_PROPS_SINGLE.each{ |p| clazz[p] = classification_statistics[p] }
         
         # transpose results per class
@@ -33,7 +33,7 @@ module Validation
         VAL_CLASS_PROPS_PER_CLASS.each do |p|
           internal_server_error "missing classification statitstics: "+p.to_s+" "+classification_statistics.inspect if classification_statistics[p]==nil
           classification_statistics[p].each do |class_value, property_value|
-            class_values[class_value] = {:class_value => class_value, :type => OT.ClassValueStatistics.to_s} unless class_values.has_key?(class_value)
+            class_values[class_value] = {:class_value => class_value, :type => RDF::OT.ClassValueStatistics.to_s} unless class_values.has_key?(class_value)
             map = class_values[class_value]
             map[p] = property_value
           end
@@ -44,18 +44,18 @@ module Validation
         cells = []
         internal_server_error "confusion matrix missing" unless classification_statistics[:confusion_matrix]!=nil
         classification_statistics[:confusion_matrix].each do |k,v|
-          cell = { :type => OT.ConfusionMatrixCell.to_s }
+          cell = { :type => RDF::OT.ConfusionMatrixCell.to_s }
           # key in confusion matrix is map with predicted and actual attribute 
           k.each{ |kk,vv| cell[kk] = vv }
           cell[:confusion_matrix_value] = v
           cells.push cell
         end
-        cm = { :confusion_matrix_cell => cells, :type => OT.ConfusionMatrix.to_s }
+        cm = { :confusion_matrix_cell => cells, :type => RDF::OT.ConfusionMatrix.to_s }
         clazz[:confusion_matrix] = cm
         
         h[:classification_statistics] = clazz
       elsif regression_statistics
-        regr = {:type => OT.RegressionStatistics.to_s }
+        regr = {:type => RDF::OT.RegressionStatistics.to_s }
         VAL_REGR_PROPS.each{ |p| regr[p] = regression_statistics[p]}
         h[:regression_statistics] = regr
       end
@@ -64,7 +64,7 @@ module Validation
     
     def to_rdf
       s = OpenTox::Serializer::Owl.new
-      s.add_resource(validation_uri,OT.Validation.to_s,get_content_as_hash.keys_to_rdf_format.keys_to_owl_uris)
+      s.add_resource(validation_uri,RDF::OT.Validation.to_s,get_content_as_hash.keys_to_rdf_format.keys_to_owl_uris)
       s.to_rdfxml
     end
     
@@ -88,7 +88,7 @@ module Validation
 
     def to_rdf
       s = OpenTox::Serializer::Owl.new
-      s.add_resource(crossvalidation_uri,OT.Crossvalidation.to_s,get_content_as_hash.keys_to_rdf_format.keys_to_owl_uris)
+      s.add_resource(crossvalidation_uri,RDF::OT.Crossvalidation.to_s,get_content_as_hash.keys_to_rdf_format.keys_to_owl_uris)
       s.to_rdfxml
     end
     
diff --git a/validation/validation_service.rb b/validation/validation_service.rb
index 8609f85..c48d1db 100755
--- a/validation/validation_service.rb
+++ b/validation/validation_service.rb
@@ -169,20 +169,21 @@ module Validation
       #model = OpenTox::Model::PredictionModel.find(self.model_uri)
       #resource_not_found_error "model not found: "+self.model_uri.to_s unless model
       model = OpenTox::Model.new(self.model_uri, self.subjectid)
-      model.get
+      #model.get
       
       unless self.algorithm_uri
-        self.algorithm_uri = model.metadata[RDF::OT.algorithm.to_s]
+        self.algorithm_uri = model.metadata[RDF::OT.algorithm]
       end
       if self.prediction_feature.to_s.size==0
-        dependentVariables = model.metadata[RDF::OT.dependentVariables.to_s]
+        dependentVariables = model.metadata[RDF::OT.dependentVariables]
         internal_server_error "model has no dependentVariables specified, please give prediction_feature for model validation" unless dependentVariables
-        self.prediction_feature = model.metadata[RDF::OT.dependentVariables.to_s]
+        self.prediction_feature = model.metadata[RDF::OT.dependentVariables]
       end
       
       prediction_dataset_uri = ""
       benchmark = Benchmark.measure do 
         #prediction_dataset_uri = model.predict_dataset(self.test_dataset_uri, OpenTox::SubTask.create(task, 0, 50))
+        puts self.test_dataset_uri
         prediction_dataset_uri = model.run({:dataset_uri => self.test_dataset_uri, :subjectid => self.subjectid})
           #"text/uri-list",OpenTox::SubTask.create(task, 0, 50))
       end
@@ -200,12 +201,12 @@ module Validation
     
     def compute_prediction_data_with_cv(cv_vals, waiting_task=nil)
       models = cv_vals.collect{|v| m = OpenTox::Model.new(v.model_uri, subjectid); m.get; m}
-      feature_type = models.first.feature_type(subjectid)
+      feature_type = models.first.feature_type # CH: subjectid is a object variable, no need to pass it as a parameter
       test_dataset_uris = cv_vals.collect{|v| v.test_dataset_uri}
       prediction_feature = cv_vals.first.prediction_feature
       prediction_dataset_uris = cv_vals.collect{|v| v.prediction_dataset_uri}
-      predicted_variables = models.collect{|m| m.predicted_variable(subjectid)}
-      predicted_confidences = models.collect{|m| m.predicted_confidence(subjectid)}
+      predicted_variables = models.collect{|m| m.predicted_variable}
+      predicted_confidences = models.collect{|m| m.predicted_confidence}
       p_data = Lib::PredictionData.create( feature_type, test_dataset_uris, prediction_feature, 
         prediction_dataset_uris, predicted_variables, predicted_confidences, subjectid, waiting_task )
       self.prediction_data = p_data.data
@@ -214,16 +215,15 @@ module Validation
     
     def compute_prediction_data_with_model(model=nil, task=nil)
       #model = OpenTox::Model::Generic.find(self.model_uri, self.subjectid) if model==nil and self.model_uri
-      #resource_not_found_error "model not found: "+self.model_uri.to_s unless model
-      model = OpenTox::Model.new(self.model_uri, self.subjectid) if model==nil
-      model.get
+      model = OpenTox::Model.find(self.model_uri, self.subjectid) if model==nil and self.model_uri
+      resource_not_found_error "model not found: "+self.model_uri.to_s unless model
             
-      feature_type = model.feature_type(self.subjectid)
-      dependentVariables = model.metadata[RDF::OT.dependentVariables.to_s]
+      feature_type = model.feature_type # CH: subjectid is a object variable, no need to pass it as a parameter
+      dependentVariables = model.metadata[RDF::OT.dependentVariables]
       prediction_feature = self.prediction_feature ? nil : dependentVariables
-      algorithm_uri = self.algorithm_uri ? nil : model.metadata[RDF::OT.algorithm.to_s]
-      predicted_variable = model.predicted_variable(self.subjectid)
-      predicted_confidence = model.predicted_confidence(self.subjectid)
+      algorithm_uri = self.algorithm_uri ? nil : model.metadata[RDF::OT.algorithm]
+      predicted_variable = model.predicted_variable
+      predicted_confidence = model.predicted_confidence
       internal_server_error "cannot determine whether model '"+model.uri.to_s+"' performs classification or regression: '#{feature_type}', "+
           "please set rdf-type of predictedVariables feature '"+predicted_variable.to_s+
           "' to NominalFeature or NumericFeature" if
@@ -280,6 +280,7 @@ module Validation
       if p_data==nil
         # this is to ensure backwards compatibilty
         # may cause a timeout on the first run, as this is not meant to run in a task
+        puts validation_type
         if validation_type=="crossvalidation_statistics"
           vals = Validation.find( :crossvalidation_id => self.crossvalidation_id, :validation_type => "crossvalidation" ).collect{|x| x}
           compute_prediction_data_with_cv(vals)
@@ -327,9 +328,9 @@ module Validation
         if (delete_feature_datasets)
           begin
             model = OpenTox::Model::Generic.find(v.model_uri)
-            if model.metadata[RDF::OT.featureDataset.to_s]
-              $logger.debug "loo-cleanup> delete feature dataset "+model.metadata[RDF::OT.featureDataset.to_s]
-              OpenTox::RestClientWrapper.delete model.metadata[RDF::OT.featureDataset.to_s],subjectid
+            if model.metadata[RDF::OT.featureDataset]
+              $logger.debug "loo-cleanup> delete feature dataset "+model.metadata[RDF::OT.featureDataset]
+              OpenTox::RestClientWrapper.delete model.metadata[RDF::OT.featureDataset],subjectid
             end
           rescue
           end