resolve merge conflicts: now checking in the right files

2 files changed, 8 insertions, 159 deletions

diff --git a/webapp/fminer.rb b/webapp/fminer.rb
index 8f4b058..379a863 100644
--- a/webapp/fminer.rb
+++ b/webapp/fminer.rb
@@ -267,25 +267,14 @@ module OpenTox
           features.each { |f|
             row << (fminer_results[c] ? fminer_results[c][f.uri] : nil)
           }
-<<<<<<< HEAD
-          
-          $logger.debug "fminer found #{feature_dataset.features.size} features for #{feature_dataset.compounds.size} compounds"
-          feature_dataset.put @subjectid
-          $logger.debug feature_dataset.uri
-          feature_dataset.uri
-
-        rescue => e
-          $logger.debug "#{e.class}: #{e.message}"
-          $logger.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
-        end
-=======
           row.collect! { |v| v ? v : 0 } unless fminer_noact_compounds.include? c
           feature_dataset << row
         }
+          
+        $logger.debug "fminer found #{feature_dataset.features.size} features for #{feature_dataset.compounds.size} compounds"
         feature_dataset.put @subjectid
         $logger.debug feature_dataset.uri
         feature_dataset.uri
->>>>>>> 424c542130ef5b8ebd8f95403d21fd8df515bcd0
 
       end
       response['Content-Type'] = 'text/uri-list'
diff --git a/webapp/lazar.rb b/webapp/lazar.rb
index ed4d623..9eec397 100644
--- a/webapp/lazar.rb
+++ b/webapp/lazar.rb
@@ -70,40 +70,17 @@ module OpenTox
                                     RDF::DC.creator => to('/lazar',:full)
                                   }
                                 ) do |task|
-<<<<<<< HEAD
-        begin 
-          lazar = OpenTox::Model.new(nil, @subjectid)
-          lazar.parameters = lazar.check_params($lazar_params, params)
-          prediction_feature = OpenTox::Feature.find(lazar.find_parameter_value("prediction_feature_uri"))
-          lazar.metadata = { 
-            DC.title => "lazar model", 
-            OT.dependentVariables => lazar.find_parameter_value("prediction_feature_uri"),
-            OT.predictedVariables => [ predicted_variable(prediction_feature).uri, predicted_confidence.uri ],
-            OT.trainingDataset => lazar.find_parameter_value("training_dataset_uri"),
-            OT.featureDataset => lazar.find_parameter_value("feature_dataset_uri"),
-            RDF.type => ( prediction_feature.feature_type == "classification" ? 
-              [OT.Model, OTA.ClassificationLazySingleTarget] :
-              [OT.Model, OTA.RegressionLazySingleTarget] 
-            )
-          }
-          # task.progress 10
-          lazar.put @subjectid
-          $logger.debug lazar.uri
-          lazar.uri
-        rescue => e
-          $logger.debug "#{e.class}: #{e.message}"
-          $logger.debug "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
-        end
-=======
 
         lazar = OpenTox::Model.new(nil, @subjectid)
         lazar.parameters = lazar.check_params($lazar_params, params)
+        prediction_feature = OpenTox::Feature.find(lazar.find_parameter_value("prediction_feature_uri"))
         lazar.metadata = { 
           DC.title => "lazar model", 
           OT.dependentVariables => lazar.find_parameter_value("prediction_feature_uri"),
+          OT.predictedVariables => [ predicted_variable(prediction_feature).uri, predicted_confidence.uri ],
           OT.trainingDataset => lazar.find_parameter_value("training_dataset_uri"),
           OT.featureDataset => lazar.find_parameter_value("feature_dataset_uri"),
-          RDF.type => ( OpenTox::Feature.find(lazar.find_parameter_value("prediction_feature_uri")).feature_type == "classification" ? 
+          RDF.type => ( prediction_feature.feature_type == "classification" ? 
             [OT.Model, OTA.ClassificationLazySingleTarget] :
             [OT.Model, OTA.RegressionLazySingleTarget] 
           )
@@ -111,7 +88,6 @@ module OpenTox
         # task.progress 10
         lazar.put @subjectid
         lazar.uri
->>>>>>> 424c542130ef5b8ebd8f95403d21fd8df515bcd0
       end
       response['Content-Type'] = 'text/uri-list'
       #service_unavailable_error "Service unavailable" if task.cancelled?
@@ -145,13 +121,8 @@ module OpenTox
         $task[:uri],
         @subjectid,
         { 
-<<<<<<< HEAD
           RDF::DC.description => "Apply lazar model",
-          RDF::DC.creator => url_for('/lazar/predict',:full)
-=======
-          RDF::DC.description => "Create lazar model",
           RDF::DC.creator => to('/lazar/predict',:full)
->>>>>>> 424c542130ef5b8ebd8f95403d21fd8df515bcd0
         }
       ) do |task|
 
@@ -173,38 +144,7 @@ module OpenTox
             }
             @model = OpenTox::Model.new(@model_params_hash)
 
-            @prediction_dataset.metadata = {
-              DC.title => "Lazar prediction",
-              DC.creator => @uri.to_s,
-              OT.hasSource => @uri.to_s,
-              OT.dependentVariables => @model_params_hash["prediction_feature_uri"],
-              OT.predictedVariables => @model_params_hash["prediction_feature_uri"]
-            }
-
-            puts "Loading t dataset"
-            @training_dataset = OpenTox::Dataset.find(params[:training_dataset_uri], @subjectid)
-            @prediction_feature = OpenTox::Feature.find(params[:prediction_feature_uri],@subjectid)
-            #@training_dataset = OpenTox::Dataset.find(params[:training_dataset], @subjectid)
-            #@prediction_feature = OpenTox::Feature.find(params[:prediction_feature],@subjectid)
-            @confidence_feature = OpenTox::Feature.find_by_title("confidence", {RDF.type => [RDF::OT.NumericFeature]})
-            @similarity_feature = OpenTox::Feature.find_by_title("similarity", {RDF.type => [RDF::OT.NumericFeature]})
-            @prediction_dataset.features = [ @prediction_feature, @confidence_feature, @similarity_feature ]
-          end
-          
-          database_activity = @training_dataset.database_activity(params)
-          if database_activity
-
-            prediction_value = database_activity.to_f
-            confidence_value = 1.0
-
-<<<<<<< HEAD
-              @model_params_hash = $lazar_params.inject({}){ |h,p|
-                h[p] = params[p].to_s unless params[p].nil?
-                h
-              }
-              @model = OpenTox::Model.new(@model_params_hash)
-
-              $logger.debug "Loading t dataset"
+              $logger.debug "Loading training dataset"
               @training_dataset = OpenTox::Dataset.find(params[:training_dataset_uri], @subjectid)
               @prediction_feature = OpenTox::Feature.find(params[:prediction_feature_uri],@subjectid)
               @predicted_variable = predicted_variable(@prediction_feature)
@@ -221,53 +161,14 @@ module OpenTox
               }
             end
             
-            database_activity = @training_dataset.database_activity(params)
-            if database_activity
+          database_activity = @training_dataset.database_activity(params)
+          if database_activity
 
               orig_value = database_activity.to_f
               predicted_value = orig_value
               confidence_value = 1.0
-=======
-          else
-            puts "Creating prediction"
-            @model = OpenTox::Model.new(@model_params_hash)
-
-            unless @feature_dataset
-              puts "Loading f dataset"
-              @feature_dataset = OpenTox::Dataset.find(params[:feature_dataset_uri], @subjectid)
-              #@feature_dataset = OpenTox::Dataset.find(params[:feature_dataset], @subjectid)
-            end
->>>>>>> 424c542130ef5b8ebd8f95403d21fd8df515bcd0
 
-            case @feature_dataset.find_parameter_value("nr_hits")
-              when "true" then @model.feature_calculation_algorithm = "match_hits"
-              when "false" then @model.feature_calculation_algorithm = "match"
-            end
-              puts @model.feature_calculation_algorithm 
-            pc_type = @feature_dataset.find_parameter_value("pc_type")
-            @model.pc_type = pc_type unless pc_type.nil?
-            lib = @feature_dataset.find_parameter_value("lib")
-            @model.lib = lib unless lib.nil?
-
-            print "cosine transformation ..."
-            # AM: transform to cosine space
-            @model.min_sim = (@model.min_sim.to_f*2.0-1.0).to_s if @model.similarity_algorithm =~ /cosine/
-              puts "finished"
-
-            #puts @model.pc_type
-            puts @feature_dataset.features.size 
-            if @feature_dataset.features.size > 0
-              compound_params = { 
-                :compound => query_compound, 
-                :feature_dataset => @feature_dataset,
-                :pc_type => @model.pc_type,
-                :lib => @model.lib
-              }
-              # use send, not eval, for calling the method (good backtrace)
-              $logger.debug "Calculating q fps"
-              compound_fingerprints = OpenTox::Algorithm::FeatureValues.send( @model.feature_calculation_algorithm, compound_params, @subjectid )
             else
-<<<<<<< HEAD
               @model = OpenTox::Model.new(@model_params_hash)
 
               unless @feature_dataset
@@ -323,41 +224,9 @@ module OpenTox
 
               $logger.debug "Prediction: '#{predicted_value}'"
               $logger.debug "Confidence: '#{confidence_value}'"
-=======
-              bad_request_error "No features found"
->>>>>>> 424c542130ef5b8ebd8f95403d21fd8df515bcd0
             end
 
-            @model.add_data(@training_dataset, @feature_dataset, @prediction_feature, compound_fingerprints, @subjectid)
-            mtf = OpenTox::Algorithm::Transform::ModelTransformer.new(@model)
-            mtf.transform
-            $logger.debug "Predicting q"
-            prediction = OpenTox::Algorithm::Neighbors.send(@model.prediction_algorithm,  { :props => mtf.props,
-                                                          :acts => mtf.acts,
-                                                          :sims => mtf.sims,
-                                                          :value_map => @training_dataset.value_map(@prediction_feature),
-                                                          :min_train_performance => @model.min_train_performance
-                                                        } )
-            prediction_value = prediction[:prediction].to_f
-            confidence_value = prediction[:confidence].to_f
-
-            # AM: transform to original space
-            confidence_value = ((confidence_value+1.0)/2.0).abs if @model.similarity_algorithm =~ /cosine/
-            prediction_value = @training_dataset.value_map(@prediction_feature)[prediction[:prediction].to_i] if @prediction_feature.feature_type == "classification"
-
-            $logger.debug "Prediction: '#{prediction_value}'"
-            $logger.debug "Confidence: '#{confidence_value}'"
-          end
-
-          @prediction_dataset << [ 
-            query_compound, 
-            prediction_value, 
-            confidence_value, 
-            nil
-          ]
-          @model.neighbors.each { |neighbor|
             @prediction_dataset << [ 
-<<<<<<< HEAD
               query_compound, 
               orig_value,
               predicted_value, 
@@ -374,17 +243,8 @@ module OpenTox
               ]
             }
 
-=======
-              OpenTox::Compound.new(neighbor[:compound]), 
-              @training_dataset.value_map(@prediction_feature)[neighbor[:activity]], 
-              nil, 
-              neighbor[:similarity] 
-            ]
->>>>>>> 424c542130ef5b8ebd8f95403d21fd8df515bcd0
           }
 
-        }
-
        @prediction_dataset.parameters = $lazar_params.collect { |p|
          {DC.title => p, OT.paramValue => @model.instance_variable_get("@#{p}")} unless  @model.instance_variable_get("@#{p}").nil?
        }