opentox-ruby 2.0.1 → 2.1.0

data/lib/compound.rb

@@ -21,6 +21,17 @@ module OpenTox
       else
         @inchi = RestClientWrapper.get(@uri, :accept => 'chemical/x-inchi').to_s.chomp if @uri
       end
+      
+      if @uri and @inchi.to_s.size==0
+        LOGGER.warn "REMOVE ABMIT HACK: no inchi for compound "+@uri.to_s+", load via smiles"
+        @inchi = Compound.smiles2inchi(Compound.smiles(@uri))
+      end
+    end
+    
+    # request smiles from compound service via accept header
+    # @return smiles as string
+    def self.smiles(uri)
+      RestClientWrapper.get(uri, :accept => 'chemical/x-daylight-smiles').to_s.chomp
     end
 
     # Create a compound from smiles string
@@ -153,6 +164,35 @@ module OpenTox
       #smarts_array.collect { |s| s if match?(s)}.compact
 		end
 
+    # Match_hits an array of smarts strings, returns hash with matching smarts as key and number of non-unique hits as value 
+    # @example
+    #   compound = OpenTox::Compound.from_name("Benzene")
+    #   compound.match(['cc','cN']) # returns ['cc']
+    # @param [Array] smarts_array Array with Smarts strings
+    # @return [Hash] Hash with matching smarts as key and number of non-unique hits as value
+		def match_hits(smarts_array)
+      # avoid recreation of OpenBabel objects
+			obconversion = OpenBabel::OBConversion.new
+			obmol = OpenBabel::OBMol.new
+			obconversion.set_in_format('inchi')
+			obconversion.read_string(obmol,@inchi) 
+			smarts_pattern = OpenBabel::OBSmartsPattern.new
+			smarts_hits = {}
+      #LOGGER.debug "dv ----------- obmol  #{Compound.new(@inchi).to_smiles}"
+      smarts_array.collect do |smarts|
+        #LOGGER.debug "dv ----------- all smarts  #{smarts}"
+        smarts_pattern.init(smarts)
+        if smarts_pattern.match(obmol)
+          hits = smarts_pattern.get_map_list
+          smarts_hits[smarts] = hits.size 
+        end
+      end
+      #LOGGER.debug "dv ----------- smarts => hits #{smarts_hits}"
+      return smarts_hits
+      #smarts_array.collect { |s| s if match?(s)}.compact
+		end
+
+
     # Get URI of compound image with highlighted fragments
     #
     # @param [Array] activating Array with activating Smarts strings

data/lib/config/config_ru.rb

@@ -19,6 +19,7 @@ set :lock, true
 end
  
 use Rack::ShowExceptions
+=begin
 if defined?(MAIL)
 
 	# monkeypatch with the original method
@@ -50,3 +51,4 @@ if defined?(MAIL)
 			mail.smtp MAIL
 	end 
 end
+=end

data/lib/dataset.rb

@@ -102,6 +102,13 @@ module OpenTox
       copy parser.load_uri(subjectid)
     end
 
+    def load_sdf(sdf,subjectid=nil)
+      save(subjectid) unless @uri # get a uri for creating features
+      parser = Parser::Sdf.new
+      parser.dataset = self
+      parser.load_sdf(sdf)
+    end
+
     # Load CSV string (format specification: http://toxcreate.org/help)
     # - loads data_entries, compounds, features
     # - sets metadata (warnings) for parser errors
@@ -149,7 +156,11 @@ module OpenTox
     # Load and return only compound URIs from the dataset service
     # @return [Array]  Compound URIs in the dataset
     def load_compounds(subjectid=nil)
-      RestClientWrapper.get(File.join(uri,"compounds"),{:accept=> "text/uri-list", :subjectid => subjectid}).to_s.each_line do |compound_uri|
+      # fix for datasets like http://apps.ideaconsult.net:8080/ambit2/dataset/272?max=50
+      u = URI::parse(uri)
+      u.path = File.join(u.path,"compounds")
+      u = u.to_s
+      RestClientWrapper.get(u,{:accept=> "text/uri-list", :subjectid => subjectid}).to_s.each_line do |compound_uri|
         @compounds << compound_uri.chomp
       end
       @compounds.uniq!
@@ -167,19 +178,15 @@ module OpenTox
       @features
     end
 
-    def feature_classes(feature, subjectid=nil)
-      if Feature.find(feature, subjectid).feature_type == "classification"
-        classes = []
-        @data_entries.each do |c,e|
-          e[feature].each { |v| classes << v.to_s }
-        end
-        classes.uniq.sort
-      else
-        nil
-      end
+    # returns the accept_values of a feature, i.e. the classification domain / all possible feature values 
+    # @param [String] feature the URI of the feature
+    # @return [Array] return array with strings, nil if value is not set (e.g. when feature is numeric)
+    def accept_values(feature)
+      accept_values = features[feature][OT.acceptValue]
+      accept_values.sort if accept_values
+      accept_values
     end
 
-=begin
     # Detect feature type(s) in the dataset
     # @return [String] `classification", "regression", "mixed" or unknown`
     def feature_type(subjectid=nil)
@@ -193,6 +200,7 @@ module OpenTox
         "unknown"
       end
     end
+=begin
 =end
 
     # Get Spreadsheet representation
@@ -229,6 +237,30 @@ module OpenTox
       s.to_rdfxml
     end
 
+    # Get SDF representation of compounds
+    # @return [String] SDF representation
+    def to_sdf
+      sum=""
+      @compounds.each{ |c|
+        sum << OpenTox::Compound.new(c).to_inchi
+        sum << OpenTox::Compound.new(c).to_sdf.sub(/\n\$\$\$\$/,'')
+        @data_entries[c].each{ |f,v|
+          sum << ">  <\"#{f}\">\n"
+          sum << v.join(", ")
+          sum << "\n\n"
+        }
+        sum << "$$$$\n"
+      }
+      sum
+    end
+
+    def to_urilist
+      @compounds.inject { |sum, c|
+        sum << OpenTox::Compound.new(c).uri
+        sum + "\n"
+      }
+    end
+
     # Get name (DC.title) of a feature
     # @param [String] feature Feature URI
     # @return [String] Feture title
@@ -307,6 +339,12 @@ module OpenTox
           end
         end
       end
+      # set feature metadata in new dataset accordingly (including accept values)      
+      features.each do |f|
+        self.features[f].each do |k,v|
+          dataset.features[f][k] = v
+        end
+      end
       dataset.add_metadata(metadata)
       dataset.save(subjectid)
       dataset
@@ -369,12 +407,14 @@ module OpenTox
     end
 
     def value(compound)
-      @data_entries[compound.uri].collect{|f,v| v.first if f.match(/prediction/)}.compact.first
+      v = nil
+      v = @data_entries[compound.uri].collect{|f,v| v.first if f.match(/value/)}.compact.first if @data_entries[compound.uri]
+      v = nil if v.is_a? Array and v.empty?
+      v
     end
 
     def confidence(compound)
-      feature_uri = @data_entries[compound.uri].collect{|f,v| f if f.match(/prediction/)}.compact.first
-      @features[feature_uri][OT.confidence]
+      @data_entries[compound.uri].collect{|f,v| v.first if f.match(/confidence/)}.compact.first if @data_entries[compound.uri]
     end
 
     def descriptors(compound)
@@ -382,12 +422,11 @@ module OpenTox
     end
 
     def measured_activities(compound)
-      source = @metadata[OT.hasSource]
-      @data_entries[compound.uri].collect{|f,v| v if f.match(/#{source}/)}.compact.flatten
+      @data_entries[compound.uri].collect{|f,v| v if f.match(/#{@metadata[OT.hasSource]}/)}.compact.flatten if @data_entries[compound.uri]
     end
 
     def neighbors(compound)
-      @data_entries[compound.uri].collect{|f,v| @features[f] if f.match(/neighbor/)}.compact
+      @data_entries[compound.uri].collect{|f,v| @features[f] if f.match(/neighbor/)}.compact if @data_entries[compound.uri]
     end
 
 #    def errors(compound)

data/lib/environment.rb

@@ -27,7 +27,7 @@ end
 Ohm.connect :thread_safe => true
 
 # load mail settings for error messages
-load File.join config_dir,"mail.rb" if File.exists?(File.join config_dir,"mail.rb")
+#load File.join config_dir,"mail.rb" if File.exists?(File.join config_dir,"mail.rb")
 
 logfile = "#{LOG_DIR}/#{ENV["RACK_ENV"]}.log"
 #LOGGER = OTLogger.new(logfile,'daily') # daily rotation
@@ -40,8 +40,8 @@ else
 end
 
 # Regular expressions for parsing classification data
-TRUE_REGEXP = /^(true|active|1|1.0|tox)$/i
-FALSE_REGEXP = /^(false|inactive|0|0.0|low tox)$/i
+TRUE_REGEXP = /^(true|active|1|1.0|tox|activating)$/i
+FALSE_REGEXP = /^(false|inactive|0|0.0|low tox|deactivating)$/i
 
 # Task durations
 DEFAULT_TASK_MAX_DURATION = 36000

data/lib/feature.rb

@@ -2,6 +2,8 @@ module OpenTox
   class Feature
     include OpenTox
 
+    attr_accessor :subjectid
+
     # Find a feature
     # @param [String] uri Feature URI
     # @return [OpenTox::Task] Feature object
@@ -13,31 +15,31 @@ module OpenTox
       else
         feature.add_metadata  Parser::Owl::Dataset.new(uri).load_metadata
       end
+      feature.subjectid = subjectid
       feature
     end
-    
+
     # provides feature type, possible types are "regression" or "classification"
     # @return [String] feature type, unknown if OT.isA property is unknown/ not set
     def feature_type
+      raise OpenTox::BadRequestError.new("rdf type of feature '"+uri.to_s+"' not set") unless metadata[RDF.type]
       if metadata[RDF.type].flatten.include?(OT.NominalFeature)
         "classification"
       elsif metadata[RDF.type].flatten.include?(OT.NumericFeature)
         "regression"
-      else
-        #"unknown"
-        metadata[RDF.type].inspect
-      end
-=begin
-      case metadata[RDF.type]
-      when /NominalFeature/
-        "classification"
-      when /NumericFeature/
-        "regression"
+      elsif metadata[OWL.sameAs]
+        metadata[OWL.sameAs].each do |f|
+          begin
+            type = Feature.find(f, subjectid).feature_type
+            return type unless type=="unknown"
+          rescue => ex
+            LOGGER.warn "could not load same-as-feature '"+f.to_s+"' for feature '"+uri.to_s+"' : "+ex.message.to_s
+          end
+        end
+        "unknown"
       else
         "unknown"
       end
-=end
     end    
-    
   end
 end

data/lib/helper.rb

@@ -81,7 +81,7 @@ helpers do
       when "css"
         @accept = 'text/css'
       else
-        # halt 404, "File format #{extension} not supported."
+        # raise OpenTox::NotFoundError.new "File format #{extension} not supported."
       end
     end
   end
@@ -94,4 +94,3 @@ before do
     protected!(@subjectid)
   end
 end
-

data/lib/model.rb

@@ -23,7 +23,7 @@ module OpenTox
     # Generic OpenTox model class for all API compliant services
     class Generic
       include Model
-      
+
       # Find Generic Opentox Model via URI, and loads metadata, could raise NotFound/NotAuthorized error 
       # @param [String] uri Model URI
       # @return [OpenTox::Model::Generic] Model instance
@@ -34,42 +34,75 @@ module OpenTox
         raise "could not load model metadata '"+uri.to_s+"'" if model.metadata==nil or model.metadata.size==0
         model
       end
-    
-       # provides feature type, possible types are "regression" or "classification"
-       # @return [String] feature type, "unknown" if type could not be estimated
+
+      # provides feature type, possible types are "regression" or "classification"
+      # @return [String] feature type, "unknown" if type could not be estimated
       def feature_type(subjectid=nil)
-        return @feature_type if @feature_type
-        
-        # dynamically perform restcalls if necessary
-        load_metadata(subjectid) if @metadata==nil or @metadata.size==0 or (@metadata.size==1 && @metadata.values[0]==@uri)
-        algorithm = OpenTox::Algorithm::Generic.find(@metadata[OT.algorithm], subjectid)
-        algorithm_title = algorithm ? algorithm.metadata[DC.title] : nil
-        algorithm_type = algorithm ? algorithm.metadata[RDF.type] : nil
-        dependent_variable = OpenTox::Feature.find( @metadata[OT.dependentVariables],subjectid )
-        dependent_variable_type = dependent_variable ? dependent_variable.feature_type : nil
-        type_indicators = [dependent_variable_type, @metadata[RDF.type], @metadata[DC.title], @uri, algorithm_type, algorithm_title].flatten
-        type_indicators.each do |type|
-          case type
-          when /(?i)classification/
-            @feature_type =  "classification"
-            break
-          when /(?i)regression/
-            @feature_type = "regression"
-          end
+        unless @feature_type
+          load_predicted_variables( subjectid ) unless @predicted_variable
+          @feature_type = OpenTox::Feature.find( @predicted_variable, subjectid ).feature_type
         end
-        raise "unknown model "+type_indicators.inspect unless @feature_type
         @feature_type
       end
-      
-    end
     
+      def predicted_variable( subjectid )
+        load_predicted_variables( subjectid ) unless @predicted_variable
+        @predicted_variable
+      end
+
+      def predicted_variables( subjectid )
+        load_predicted_variables( subjectid, false ) unless @predicted_variables
+        @predicted_variables
+      end
+
+      def predicted_confidence( subjectid )
+        load_predicted_variables( subjectid ) unless @predicted_confidence
+        @predicted_confidence
+      end
+  
+      private
+      def load_predicted_variables( subjectid=nil, use_confidence=true )
+        load_metadata(subjectid) if @metadata==nil or @metadata.size==0 or (@metadata.size==1 && @metadata.values[0]==@uri)
+        if @metadata[OT.predictedVariables]
+          predictedVariables = @metadata[OT.predictedVariables]
+          if predictedVariables.is_a?(Array)
+            if (predictedVariables.size==1)
+              @predicted_variable = predictedVariables[0]
+            elsif (predictedVariables.size>=2)
+              # PENDING identify confidence
+              if use_confidence
+                conf_index = -1
+                predictedVariables.size.times do |i|
+                  f = OpenTox::Feature.find(predictedVariables[i], subjectid)
+                  conf_index = i if f.metadata[DC.title]=~/(?i)confidence/
+                end
+                raise "could not estimate predicted variable from model: '"+uri.to_s+
+                  "', number of predicted-variables==2, but no confidence found" if conf_index==-1
+              end
+              if (predictedVariables.size==2) && use_confidence
+                @predicted_variable = predictedVariables[1-conf_index]
+                @predicted_confidence = predictedVariables[conf_index]
+              else
+                @predicted_variables = predictedVariables
+              end
+            else
+              raise "could not estimate predicted variable from model: '"+uri.to_s+"', number of predicted-variables == 0"  
+            end
+          else
+            raise "could not estimate predicted variable from model: '"+uri.to_s+"', predicted-variables is no array"
+          end        
+        end
+        raise "could not estimate predicted variable from model: '"+uri.to_s+"'" unless (@predicted_variable || @predicted_variables)
+      end
+    end
+
     # Lazy Structure Activity Relationship class
     class Lazar
 
-      include Model
       include Algorithm
+      include Model
 
-      attr_accessor :compound, :prediction_dataset, :features, :effects, :activities, :p_values, :fingerprints, :feature_calculation_algorithm, :similarity_algorithm, :prediction_algorithm, :min_sim, :subjectid
+      attr_accessor :compound, :prediction_dataset, :features, :effects, :activities, :p_values, :fingerprints, :feature_calculation_algorithm, :similarity_algorithm, :prediction_algorithm, :min_sim, :subjectid, :prop_kernel, :value_map, :nr_hits, :transform, :conf_stdev, :prediction_min_max
 
       def initialize(uri=nil)
 
@@ -78,7 +111,7 @@ module OpenTox
         else
           super CONFIG[:services]["opentox-model"]
         end
-        
+
         @metadata[OT.algorithm] = File.join(CONFIG[:services]["opentox-algorithm"],"lazar")
 
         @features = []
@@ -86,12 +119,18 @@ module OpenTox
         @activities = {}
         @p_values = {}
         @fingerprints = {}
+        @value_map = {}
+        @prediction_min_max = [] 
 
         @feature_calculation_algorithm = "Substructure.match"
         @similarity_algorithm = "Similarity.tanimoto"
         @prediction_algorithm = "Neighbors.weighted_majority_vote"
-
+        
+        @nr_hits = false
         @min_sim = 0.3
+        @prop_kernel = false
+        @transform = { "class" => "NOP"  }
+        @conf_stdev = false
 
       end
 
@@ -111,13 +150,25 @@ module OpenTox
       # Create a new lazar model
       # @param [optional,Hash] params Parameters for the lazar algorithm (OpenTox::Algorithm::Lazar)
       # @return [OpenTox::Model::Lazar] lazar model
-      def self.create(params)
+      def self.create(params, waiting_task=nil )
         subjectid = params[:subjectid]
         lazar_algorithm = OpenTox::Algorithm::Generic.new File.join( CONFIG[:services]["opentox-algorithm"],"lazar")
-        model_uri = lazar_algorithm.run(params)
+        model_uri = lazar_algorithm.run(params, waiting_task)
         OpenTox::Model::Lazar.find(model_uri, subjectid)      
       end
 
+      def run( params, accept_header=nil, waiting_task=nil )
+      unless accept_header
+        if CONFIG[:yaml_hosts].include?(URI.parse(@uri).host)
+          accept_header = 'application/x-yaml' 
+        else
+          accept_header = 'application/rdf+xml'
+        end
+      end
+      LOGGER.info "running model "+@uri.to_s+", params: "+params.inspect+", accept: "+accept_header.to_s
+      RestClientWrapper.post(@uri,params,{:accept => accept_header},waiting_task).to_s
+      end
+
       # Get a parameter value
       # @param [String] param Parameter name
       # @return [String] Parameter value
@@ -131,6 +182,7 @@ module OpenTox
       # @param [optional,OpenTox::Task] waiting_task (can be a OpenTox::Subtask as well), progress is updated accordingly
       # @return [OpenTox::Dataset] Dataset with predictions
       def predict_dataset(dataset_uri, subjectid=nil, waiting_task=nil)
+      
         @prediction_dataset = Dataset.create(CONFIG[:services]["opentox-dataset"], subjectid)
         @prediction_dataset.add_metadata({
           OT.hasSource => @uri,
@@ -150,7 +202,7 @@ module OpenTox
             LOGGER.warn "prediction for compound "+compound_uri.to_s+" failed: "+ex.message
           end
         end
-        @prediction_dataset.save(subjectid)
+        #@prediction_dataset.save(subjectid)
         @prediction_dataset
       end
 
@@ -164,49 +216,52 @@ module OpenTox
         features = {}
 
         unless @prediction_dataset
-          #@prediction_dataset = cached_prediction
-          #return @prediction_dataset if cached_prediction
           @prediction_dataset = Dataset.create(CONFIG[:services]["opentox-dataset"], subjectid)
           @prediction_dataset.add_metadata( {
             OT.hasSource => @uri,
             DC.creator => @uri,
-            # TODO: fix dependentVariable
             DC.title => URI.decode(File.basename( @metadata[OT.dependentVariables] )),
             OT.parameters => [{DC.title => "compound_uri", OT.paramValue => compound_uri}]
           } )
         end
 
-        return @prediction_dataset if database_activity(subjectid)
-
-        neighbors
-        prediction = eval("#{@prediction_algorithm}(@neighbors,{:similarity_algorithm => @similarity_algorithm, :p_values => @p_values})")
-
-        prediction_feature_uri = File.join( @prediction_dataset.uri, "feature", "prediction", File.basename(@metadata[OT.dependentVariables]),@prediction_dataset.compounds.size.to_s)
-        # TODO: fix dependentVariable
-        @prediction_dataset.metadata[OT.dependentVariables] = prediction_feature_uri
-
-        if @neighbors.size == 0
-          @prediction_dataset.add_feature(prediction_feature_uri, {
-            RDF.type => [OT.MeasuredFeature],
-            OT.hasSource => @uri,
-            DC.creator => @uri,
-            DC.title => URI.decode(File.basename( @metadata[OT.dependentVariables] )),
-            OT.error => "No similar compounds in training dataset.",
-            OT.parameters => [{DC.title => "compound_uri", OT.paramValue => compound_uri}]
-          })
-          @prediction_dataset.add @compound.uri, prediction_feature_uri, prediction[:prediction]
+        if OpenTox::Feature.find(metadata[OT.dependentVariables]).feature_type == "regression"
+          all_activities = [] 
+          all_activities = @activities.values.flatten.collect! { |i| i.to_f }
+          @prediction_min_max[0] = (all_activities.to_scale.min/2)
+          @prediction_min_max[1] = (all_activities.to_scale.max*2)
+        end
 
-        else
-          @prediction_dataset.add_feature(prediction_feature_uri, {
-            RDF.type => [OT.ModelPrediction],
-            OT.hasSource => @uri,
-            DC.creator => @uri,
-            DC.title => URI.decode(File.basename( @metadata[OT.dependentVariables] )),
-            OT.prediction => prediction[:prediction],
-            OT.confidence => prediction[:confidence],
-            OT.parameters => [{DC.title => "compound_uri", OT.paramValue => compound_uri}]
-          })
-          @prediction_dataset.add @compound.uri, prediction_feature_uri, prediction[:prediction]
+        unless database_activity(subjectid) # adds database activity to @prediction_dataset
+
+          neighbors
+          prediction = eval("#{@prediction_algorithm} ( { :neighbors => @neighbors, 
+                                                          :compound => @compound,
+                                                          :features => @features, 
+                                                          :p_values => @p_values, 
+                                                          :fingerprints => @fingerprints,
+                                                          :similarity_algorithm => @similarity_algorithm, 
+                                                          :prop_kernel => @prop_kernel,
+                                                          :value_map => @value_map,
+                                                          :nr_hits => @nr_hits,
+                                                          :conf_stdev => @conf_stdev,
+                                                          :prediction_min_max => @prediction_min_max,
+                                                          :transform => @transform } ) ")
+
+          value_feature_uri = File.join( @uri, "predicted", "value")
+          confidence_feature_uri = File.join( @uri, "predicted", "confidence")
+
+          @prediction_dataset.metadata[OT.dependentVariables] = @metadata[OT.dependentVariables] unless @prediction_dataset.metadata[OT.dependentVariables] 
+          @prediction_dataset.metadata[OT.predictedVariables] = [value_feature_uri, confidence_feature_uri] unless @prediction_dataset.metadata[OT.predictedVariables] 
+
+          if OpenTox::Feature.find(metadata[OT.dependentVariables], subjectid).feature_type == "classification"
+            @prediction_dataset.add @compound.uri, value_feature_uri, @value_map[prediction[:prediction]]
+          else
+            @prediction_dataset.add @compound.uri, value_feature_uri, prediction[:prediction]
+          end
+          @prediction_dataset.add @compound.uri, confidence_feature_uri, prediction[:confidence]
+          @prediction_dataset.features[value_feature_uri][DC.title] = @prediction_dataset.metadata[DC.title]
+          @prediction_dataset.features[confidence_feature_uri][DC.title] = "Confidence"
 
           if verbose
             if @feature_calculation_algorithm == "Substructure.match"
@@ -260,7 +315,6 @@ module OpenTox
               end
               n+=1
             end
-            # what happens with dataset predictions?
           end
         end
 
@@ -268,33 +322,53 @@ module OpenTox
         @prediction_dataset
       end
 
-      # Find neighbors and store them as object variable
-      def neighbors
+      
 
+      # Find neighbors and store them as object variable, access all compounds for that.
+      def neighbors
         @compound_features = eval("#{@feature_calculation_algorithm}(@compound,@features)") if @feature_calculation_algorithm
-
         @neighbors = []
-        @fingerprints.each do |training_compound,training_features|
-          sim = eval("#{@similarity_algorithm}(@compound_features,training_features,@p_values)")
-          if sim > @min_sim
-            @activities[training_compound].each do |act|
-              @neighbors << {
-                :compound => training_compound,
-                :similarity => sim,
-                :features => training_features,
-                :activity => act
-              }
-            end
-          end
+        @fingerprints.keys.each do |training_compound| # AM: access all compounds
+          add_neighbor @fingerprints[training_compound].keys, training_compound
         end
+      end
 
+      # Adds a neighbor to @neighbors if it passes the similarity threshold.
+      def add_neighbor(training_features, training_compound)
+        compound_features_hits = {}
+        training_compound_features_hits = {}
+        if @nr_hits
+          compound_features_hits = @compound.match_hits(@compound_features)
+          training_compound_features_hits = @fingerprints[training_compound]
+          #LOGGER.debug "dv ------------ training_compound_features_hits:#{training_compound_features_hits.class}  #{training_compound_features_hits}"
+        end
+        params = {}
+        params[:nr_hits] = @nr_hits
+        params[:compound_features_hits] = compound_features_hits
+        params[:training_compound_features_hits] = training_compound_features_hits
+
+        sim = eval("#{@similarity_algorithm}(training_features, @compound_features, @p_values, params)")
+        if sim > @min_sim
+          @activities[training_compound].each do |act|
+            @neighbors << {
+              :compound => training_compound,
+              :similarity => sim,
+              :features => training_features,
+              :activity => act
+            }
+          end
+        end
       end
 
       # Find database activities and store them in @prediction_dataset
       # @return [Boolean] true if compound has databasse activities, false if not
       def database_activity(subjectid)
         if @activities[@compound.uri]
-          @activities[@compound.uri].each { |act| @prediction_dataset.add @compound.uri, @metadata[OT.dependentVariables], act }
+          if OpenTox::Feature.find(metadata[OT.dependentVariables], subjectid).feature_type == "classification"
+            @activities[@compound.uri].each { |act| @prediction_dataset.add @compound.uri, @metadata[OT.dependentVariables], @value_map[act] }
+          else
+            @activities[@compound.uri].each { |act| @prediction_dataset.add @compound.uri, @metadata[OT.dependentVariables], act }
+          end
           @prediction_dataset.add_metadata(OT.hasSource => @metadata[OT.trainingDataset])
           @prediction_dataset.save(subjectid)
           true
@@ -303,6 +377,35 @@ module OpenTox
         end
       end
 
+      def prediction_features
+        [prediction_value_feature,prediction_confidence_feature]
+      end
+
+      def prediction_value_feature
+        dependent_uri = @metadata[OT.dependentVariables].first
+        feature = OpenTox::Feature.new File.join( @uri, "predicted", "value")
+        feature.add_metadata( {
+          RDF.type => [OT.ModelPrediction],
+          OT.hasSource => @uri,
+          DC.creator => @uri,
+          DC.title => URI.decode(File.basename( dependent_uri )),
+          OWL.sameAs => dependent_uri
+        })
+        feature
+      end
+
+      def prediction_confidence_feature
+        dependent_uri = @metadata[OT.dependentVariables].first
+        feature = OpenTox::Feature.new File.join( @uri, "predicted", "confidence")
+        feature.add_metadata( {
+          RDF.type => [OT.ModelPrediction],
+          OT.hasSource => @uri,
+          DC.creator => @uri,
+          DC.title => "#{URI.decode(File.basename( dependent_uri ))} confidence"
+        })
+        feature
+      end
+
       # Save model at model service
       def save(subjectid)
         self.uri = RestClientWrapper.post(@uri,self.to_yaml,{:content_type =>  "application/x-yaml", :subjectid => subjectid})