lazar 0.9.3 → 1.0.0

data/lib/overwrite.rb

@@ -28,6 +28,11 @@ class Float
   def signif(n)
     Float("%.#{n}g" % self)
   end
+
+  # converts -10 logarithmized values back
+  def delog10
+    10**(-1*self)
+  end
 end
 
 module Enumerable
@@ -101,19 +106,35 @@ class Array
   end
 
   def mean
-    self.inject{ |sum, el| sum + el }.to_f / self.size
+    self.compact.inject{ |sum, el| sum + el }.to_f / self.compact.size
   end
 
   def sample_variance
     m = self.mean
-    sum = self.inject(0){|accum, i| accum +(i-m)**2 }
-    sum/(self.length - 1).to_f
+    sum = self.compact.inject(0){|accum, i| accum +(i-m)**2 }
+    sum/(self.compact.length - 1).to_f
   end
 
   def standard_deviation
     Math.sqrt(self.sample_variance)
   end
 
+  def for_R
+    if self.first.is_a?(String) 
+      #"\"#{self.collect{|v| v.sub('[','').sub(']','')}.join(" ")}\"" # quote and remove square brackets
+      "NA"
+    else
+      self.median
+    end
+  end
+
+  def collect_with_index
+    result = []
+    self.each_with_index do |elt, idx|
+      result << yield(elt, idx)
+    end
+    result
+  end
 end
 
 module URI

data/lib/physchem.rb

@@ -14,7 +14,7 @@ module OpenTox
     JMOL_JAR = File.join(JAVA_DIR,"Jmol.jar")
 
     obexclude = ["cansmi","cansmiNS","formula","InChI","InChIKey","s","smarts","title","L5"]
-    OBDESCRIPTORS = Hash[OpenBabel::OBDescriptor.list_as_string("descriptors").split("\n").collect do |d|
+    OPENBABEL = Hash[OpenBabel::OBDescriptor.list_as_string("descriptors").split("\n").collect do |d|
       name,description = d.split(/\s+/,2)
       ["Openbabel."+name,description] unless obexclude.include? name
     end.compact.sort{|a,b| a[0] <=> b[0]}]
@@ -25,24 +25,24 @@ module OpenTox
       prefix="Cdk."+d[:java_class].split('.').last.sub(/Descriptor/,'')
       d[:names].each { |name| cdkdescriptors[prefix+"."+name] = d[:description] }
     end
-    CDKDESCRIPTORS = cdkdescriptors
+    CDK = cdkdescriptors
 
     # exclude Hashcode (not a physchem property) and GlobalTopologicalChargeIndex (Joelib bug)
     joelibexclude = ["MoleculeHashcode","GlobalTopologicalChargeIndex"]
     # strip Joelib messages from stdout
-    JOELIBDESCRIPTORS = Hash[YAML.load(`java -classpath #{JOELIB_JAR}:#{LOG4J_JAR}:#{JAVA_DIR}  JoelibDescriptorInfo | sed '0,/---/d'`).collect do |d|
+    JOELIB = Hash[YAML.load(`java -classpath #{JOELIB_JAR}:#{LOG4J_JAR}:#{JAVA_DIR}  JoelibDescriptorInfo | sed '0,/---/d'`).collect do |d|
       name = d[:java_class].sub(/^joelib2.feature.types./,'')
       ["Joelib."+name, "JOELIb does not provide meaningful descriptions, see java/JoelibDescriptors.java for details."] unless joelibexclude.include? name
     end.compact.sort{|a,b| a[0] <=> b[0]}] 
 
-    DESCRIPTORS = OBDESCRIPTORS.merge(CDKDESCRIPTORS.merge(JOELIBDESCRIPTORS))
+    DESCRIPTORS = OPENBABEL.merge(CDK.merge(JOELIB))
 
     require_relative "unique_descriptors.rb"
 
     def self.descriptors desc=DESCRIPTORS
       desc.collect do |name,description|
         lib,desc = name.split('.',2)
-        self.find_or_create_by(:name => name, :library => lib, :descriptor => desc, :description => description, :measured => false, :calculated => true, :numeric => true, :nominal => false)
+        self.find_or_create_by(:name => name, :library => lib, :descriptor => desc, :description => description, :measured => false, :calculated => true)
       end
     end
 
@@ -54,26 +54,26 @@ module OpenTox
           CDK_DESCRIPTIONS.select{|d| desc == d[:java_class].split('.').last.sub('Descriptor','') }.first[:names].each do |n|
             dname = "#{name}.#{n}"
             description = DESCRIPTORS[dname]
-            udesc << self.find_or_create_by(:name => dname, :library => lib, :descriptor => desc, :description => description, :measured => false, :calculated => true, :numeric => true, :nominal => false)
+            udesc << self.find_or_create_by(:name => dname, :library => lib, :descriptor => desc, :description => description, :measured => false, :calculated => true)
           end
         else
           description = DESCRIPTORS[name]
-          udesc << self.find_or_create_by(:name => name, :library => lib, :descriptor => desc, :description => description, :measured => false, :calculated => true, :numeric => true, :nominal => false)
+          udesc << self.find_or_create_by(:name => name, :library => lib, :descriptor => desc, :description => description, :measured => false, :calculated => true)
         end
       end
       udesc
     end
 
     def self.openbabel_descriptors
-      descriptors OBDESCRIPTORS
+      descriptors OPENBABEL
     end
 
     def self.cdk_descriptors
-      descriptors CDKDESCRIPTORS
+      descriptors CDK
     end
 
     def self.joelib_descriptors
-      descriptors JOELIBDESCRIPTORS
+      descriptors JOELIB
     end
 
     def calculate compound
@@ -131,3 +131,4 @@ module OpenTox
   end
 
 end
+OpenTox::PhysChem.descriptors # load descriptor features

data/lib/regression.rb

@@ -3,148 +3,18 @@ module OpenTox
     
     class Regression
 
-      def self.local_weighted_average compound, params
+      def self.weighted_average dependent_variables:, independent_variables:nil, weights:, query_variables:nil
+        # TODO: prediction_interval
         weighted_sum = 0.0
         sim_sum = 0.0
-        neighbors = params[:neighbors]
-        neighbors.each do |row|
-          sim = row["tanimoto"]
-          if row["features"][params[:prediction_feature_id].to_s]
-            row["features"][params[:prediction_feature_id].to_s].each do |act|
-              weighted_sum += sim*Math.log10(act)
-              sim_sum += sim
-            end
-          end
-        end
-        sim_sum == 0 ? prediction = nil : prediction = 10**(weighted_sum/sim_sum)
+        dependent_variables.each_with_index do |v,i|
+          weighted_sum += weights[i]*dependent_variables[i]
+          sim_sum += weights[i]
+        end if dependent_variables
+        sim_sum == 0 ? prediction = nil : prediction = weighted_sum/sim_sum
         {:value => prediction}
       end
 
-      # TODO explicit neighbors, also for physchem
-      def self.local_fingerprint_regression  compound, params, method='pls'#, method_params="sigma=0.05"
-        neighbors = params[:neighbors]
-        return {:value => nil, :confidence => nil, :warning => "No similar compounds in the training data"} unless neighbors.size > 0
-        activities = []
-        fingerprints = {}
-        weights = []
-        fingerprint_ids = neighbors.collect{|row| Compound.find(row["_id"]).fingerprint}.flatten.uniq.sort
-        
-        neighbors.each_with_index do |row,i|
-          neighbor = Compound.find row["_id"]
-          fingerprint = neighbor.fingerprint
-          if row["features"][params[:prediction_feature_id].to_s]
-            row["features"][params[:prediction_feature_id].to_s].each do |act|
-              activities << Math.log10(act)
-              weights << row["tanimoto"]
-              fingerprint_ids.each_with_index do |id,j|
-                fingerprints[id] ||= []
-                fingerprints[id] << fingerprint.include?(id) 
-              end
-            end
-          end
-        end
-
-        variables = []
-        data_frame = [activities]
-        fingerprints.each do |k,v| 
-          unless v.uniq.size == 1
-            data_frame << v.collect{|m| m ? "T" : "F"}
-            variables << k
-          end
-        end
-
-        if variables.empty?
-            result = local_weighted_average(compound, params)
-            result[:warning] = "No variables for regression model. Using weighted average of similar compounds."
-            return result
-
-        else
-          compound_features = variables.collect{|f| compound.fingerprint.include?(f) ? "T" : "F"} 
-          prediction = r_model_prediction method, data_frame, variables, weights, compound_features
-          if prediction.nil? or prediction[:value].nil?
-            prediction = local_weighted_average(compound, params)
-            prediction[:warning] = "Could not create local PLS model. Using weighted average of similar compounds."
-            return prediction
-          else
-            prediction[:prediction_interval] = [10**(prediction[:value]-1.96*prediction[:rmse]), 10**(prediction[:value]+1.96*prediction[:rmse])]
-            prediction[:value] = 10**prediction[:value]
-            prediction[:rmse] = 10**prediction[:rmse]
-            prediction
-          end
-        end
-      
-      end
-
-      def self.local_physchem_regression  compound, params, method="plsr"#, method_params="ncomp = 4"
-
-        neighbors = params[:neighbors]
-        return {:value => nil, :confidence => nil, :warning => "No similar compounds in the training data"} unless neighbors.size > 0
-        return {:value => neighbors.first["features"][params[:prediction_feature_id]], :confidence => nil, :warning => "Only one similar compound in the training set"} unless neighbors.size > 1
-
-        activities = []
-        weights = []
-        physchem = {}
-        
-        neighbors.each_with_index do |row,i|
-          neighbor = Compound.find row["_id"]
-          if row["features"][params[:prediction_feature_id].to_s]
-            row["features"][params[:prediction_feature_id].to_s].each do |act|
-              activities << Math.log10(act)
-              weights << row["tanimoto"] # TODO cosine ?
-              neighbor.physchem.each do |pid,v| # insert physchem only if there is an activity
-                physchem[pid] ||= []
-                physchem[pid] <<  v
-              end
-            end
-          end
-        end
-
-        # remove properties with a single value
-        physchem.each do |pid,v|
-          physchem.delete(pid) if v.uniq.size <= 1
-        end
-
-        if physchem.empty?
-          result = local_weighted_average(compound, params)
-          result[:warning] = "No variables for regression model. Using weighted average of similar compounds."
-          return result
-
-        else
-          data_frame = [activities] + physchem.keys.collect { |pid| physchem[pid] }
-          prediction = r_model_prediction method, data_frame, physchem.keys, weights, physchem.keys.collect{|pid| compound.physchem[pid]}
-          if prediction.nil?
-            prediction = local_weighted_average(compound, params)
-            prediction[:warning] = "Could not create local PLS model. Using weighted average of similar compounds."
-            return prediction
-          else
-            prediction[:value] = 10**prediction[:value]
-            prediction
-          end
-        end
-      
-      end
-
-      def self.r_model_prediction method, training_data, training_features, training_weights, query_feature_values
-        R.assign "weights", training_weights
-        r_data_frame = "data.frame(#{training_data.collect{|r| "c(#{r.join(',')})"}.join(', ')})"
-        R.eval "data <- #{r_data_frame}"
-        R.assign "features", training_features
-        R.eval "names(data) <- append(c('activities'),features)" #
-        begin
-          R.eval "model <- train(activities ~ ., data = data, method = '#{method}')"
-        rescue 
-          return nil
-        end
-        R.eval "fingerprint <- data.frame(rbind(c(#{query_feature_values.join ','})))"
-        R.eval "names(fingerprint) <- features" 
-        R.eval "prediction <- predict(model,fingerprint)"
-        {
-          :value => R.eval("prediction").to_f,
-          :rmse => R.eval("getTrainPerf(model)$TrainRMSE").to_f,
-          :r_squared => R.eval("getTrainPerf(model)$TrainRsquared").to_f,
-        }
-      end
-
     end
   end
 end

data/lib/rest-client-wrapper.rb

@@ -55,14 +55,8 @@ module OpenTox
           if [301, 302, 307].include? response.code and request.method == :get
             response.follow_redirection(request, result)
           elsif response.code >= 400 and !URI.task?(uri)
-            #TODO add parameters to error-report
-            #parameters = request.args
-            #parameters[:headers][:subjectid] = "REMOVED" if parameters[:headers] and parameters[:headers][:subjectid]
-            #parameters[:url] = parameters[:url].gsub(/(http|https|)\:\/\/[a-zA-Z0-9\-]+\:[a-zA-Z0-9]+\@/, "REMOVED@") if parameters[:url]
-            #message += "\nREST parameters:\n#{parameters.inspect}" 
             error = known_errors.collect{|e| e if e[:code] == response.code}.compact.first
             begin # errors are returned as error reports in json, try to parse
-              # TODO: may be the reason for failure of task.rb -n test_11_wait_for_error_task
               content = JSON.parse(response)
               msg = content["message"].to_s
               cause = content["errorCause"].to_s

data/lib/similarity.rb

@@ -0,0 +1,65 @@
+module OpenTox
+  module Algorithm
+
+    class Vector
+      def self.dot_product(a, b)
+        products = a.zip(b).map{|a, b| a * b}
+        products.inject(0) {|s,p| s + p}
+      end
+
+      def self.magnitude(point)
+        squares = point.map{|x| x ** 2}
+        Math.sqrt(squares.inject(0) {|s, c| s + c})
+      end
+    end
+
+    class Similarity
+
+      def self.tanimoto fingerprints
+        ( fingerprints[0] & fingerprints[1]).size/(fingerprints[0]|fingerprints[1]).size.to_f
+      end
+
+      #def self.weighted_tanimoto fingerprints
+        #( fingerprints[0] & fingerprints[1]).size/(fingerprints[0]|fingerprints[1]).size.to_f
+      #end
+
+      def self.euclid scaled_properties
+        sq = scaled_properties[0].zip(scaled_properties[1]).map{|a,b| (a - b) ** 2}
+        Math.sqrt(sq.inject(0) {|s,c| s + c})
+      end
+
+      # http://stackoverflow.com/questions/1838806/euclidean-distance-vs-pearson-correlation-vs-cosine-similarity
+      def self.cosine scaled_properties
+        scaled_properties = remove_nils scaled_properties
+        Algorithm::Vector.dot_product(scaled_properties[0], scaled_properties[1]) / (Algorithm::Vector.magnitude(scaled_properties[0]) * Algorithm::Vector.magnitude(scaled_properties[1]))
+      end
+
+      def self.weighted_cosine scaled_properties # [a,b,weights]
+        a,b,w = remove_nils scaled_properties
+        return cosine(scaled_properties) if w.uniq.size == 1
+        dot_product = 0
+        magnitude_a = 0
+        magnitude_b = 0
+        (0..a.size-1).each do |i|
+          dot_product += w[i].abs*a[i]*b[i]
+          magnitude_a += w[i].abs*a[i]**2
+          magnitude_b += w[i].abs*b[i]**2
+        end
+        dot_product/(Math.sqrt(magnitude_a)*Math.sqrt(magnitude_b))
+      end
+
+      def self.remove_nils scaled_properties
+        a =[]; b = []; w = []
+        (0..scaled_properties.first.size-1).each do |i|
+          if scaled_properties[0][i] and scaled_properties[1][i] and !scaled_properties[0][i].nan? and !scaled_properties[1][i].nan?
+            a << scaled_properties[0][i]
+            b << scaled_properties[1][i]
+            w << scaled_properties[2][i]
+          end
+        end
+        [a,b,w]
+      end
+
+    end
+  end
+end

data/lib/substance.rb

@@ -0,0 +1,8 @@
+module OpenTox
+
+  class Substance
+    field :properties, type: Hash, default: {}
+    field :dataset_ids, type: Array, default: []
+  end
+
+end

data/lib/train-test-validation.rb

@@ -0,0 +1,69 @@
+module OpenTox
+
+  module Validation
+
+    class TrainTest < Validation
+
+      field :training_dataset_id, type: BSON::ObjectId
+      field :test_dataset_id, type: BSON::ObjectId
+
+      def self.create model, training_set, test_set
+        
+        validation_model = model.class.create prediction_feature: model.prediction_feature, training_dataset: training_set, algorithms: model.algorithms
+        validation_model.save
+        predictions = validation_model.predict test_set.substances
+        nr_unpredicted = 0
+        predictions.each do |cid,prediction|
+          if prediction[:value]
+            prediction[:measurements] = test_set.values(cid, prediction[:prediction_feature_id])
+          else
+            nr_unpredicted += 1
+          end
+        end
+        predictions.select!{|cid,p| p[:value] and p[:measurements]}
+        validation = self.new(
+          :model_id => validation_model.id,
+          :test_dataset_id => test_set.id,
+          :nr_instances => test_set.substances.size,
+          :nr_unpredicted => nr_unpredicted,
+          :predictions => predictions
+        )
+        validation.save
+        validation
+      end
+
+      def test_dataset
+        Dataset.find test_dataset_id
+      end
+
+      def training_dataset
+        Dataset.find training_dataset_id
+      end
+
+    end
+
+    class ClassificationTrainTest < TrainTest
+      include ClassificationStatistics
+      field :accept_values, type: Array
+      field :confusion_matrix, type: Array
+      field :weighted_confusion_matrix, type: Array
+      field :accuracy, type: Float
+      field :weighted_accuracy, type: Float
+      field :true_rate, type: Hash
+      field :predictivity, type: Hash
+      field :probability_plot_id, type: BSON::ObjectId
+    end
+
+    class RegressionTrainTest < TrainTest
+      include RegressionStatistics
+      field :rmse, type: Float, default:0
+      field :mae, type: Float, default:0
+      field :r_squared, type: Float
+      field :within_prediction_interval, type: Integer, default:0
+      field :out_of_prediction_interval, type: Integer, default:0
+      field :correlation_plot_id, type: BSON::ObjectId
+    end
+
+  end
+
+end

data/lib/validation-statistics.rb

@@ -0,0 +1,223 @@
+module OpenTox
+  module Validation
+    module ClassificationStatistics
+
+      def statistics 
+        self.accept_values = model.prediction_feature.accept_values
+        self.confusion_matrix = Array.new(accept_values.size){Array.new(accept_values.size,0)}
+        self.weighted_confusion_matrix = Array.new(accept_values.size){Array.new(accept_values.size,0)}
+        nr_instances = 0
+        predictions.each do |cid,pred|
+          # TODO
+          # use predictions without probabilities (single neighbor)??
+          # use measured majority class??
+          if pred[:measurements].uniq.size == 1 and pred[:probabilities]
+            m = pred[:measurements].first
+            if pred[:value] == m
+              if pred[:value] == accept_values[0]
+                confusion_matrix[0][0] += 1
+                weighted_confusion_matrix[0][0] += pred[:probabilities][pred[:value]]
+                nr_instances += 1
+              elsif pred[:value] == accept_values[1]
+                confusion_matrix[1][1] += 1
+                weighted_confusion_matrix[1][1] += pred[:probabilities][pred[:value]]
+                nr_instances += 1
+              end
+            elsif pred[:value] != m
+              if pred[:value] == accept_values[0]
+                confusion_matrix[0][1] += 1
+                weighted_confusion_matrix[0][1] += pred[:probabilities][pred[:value]]
+                nr_instances += 1
+              elsif pred[:value] == accept_values[1]
+                confusion_matrix[1][0] += 1
+                weighted_confusion_matrix[1][0] += pred[:probabilities][pred[:value]]
+                nr_instances += 1
+              end
+            end
+          end
+        end
+        self.true_rate = {}
+        self.predictivity = {}
+        accept_values.each_with_index do |v,i|
+          self.true_rate[v] = confusion_matrix[i][i]/confusion_matrix[i].reduce(:+).to_f
+          self.predictivity[v] = confusion_matrix[i][i]/confusion_matrix.collect{|n| n[i]}.reduce(:+).to_f
+        end
+        confidence_sum = 0
+        weighted_confusion_matrix.each do |r|
+          r.each do |c|
+            confidence_sum += c
+          end
+        end
+        self.accuracy = (confusion_matrix[0][0]+confusion_matrix[1][1])/nr_instances.to_f
+        self.weighted_accuracy = (weighted_confusion_matrix[0][0]+weighted_confusion_matrix[1][1])/confidence_sum.to_f
+        $logger.debug "Accuracy #{accuracy}"
+        save
+        {
+          :accept_values => accept_values,
+          :confusion_matrix => confusion_matrix,
+          :weighted_confusion_matrix => weighted_confusion_matrix,
+          :accuracy => accuracy,
+          :weighted_accuracy => weighted_accuracy,
+          :true_rate => self.true_rate,
+          :predictivity => self.predictivity,
+        }
+      end
+
+      def probability_plot format: "pdf"
+        #unless probability_plot_id
+
+          #tmpdir = File.join(ENV["HOME"], "tmp")
+          tmpdir = "/tmp"
+          #p tmpdir
+          FileUtils.mkdir_p tmpdir
+          tmpfile = File.join(tmpdir,"#{id.to_s}_probability.#{format}")
+          accuracies = []
+          probabilities = []
+          correct_predictions = 0
+          incorrect_predictions = 0
+          pp = []
+          predictions.values.select{|p| p["probabilities"]}.compact.each do |p|
+            p["measurements"].each do |m|
+              pp << [ p["probabilities"][p["value"]], p["value"] == m ]
+            end
+          end
+          pp.sort_by!{|p| 1-p.first}
+          pp.each do |p|
+            p[1] ? correct_predictions += 1 : incorrect_predictions += 1
+            accuracies << correct_predictions/(correct_predictions+incorrect_predictions).to_f
+            probabilities << p[0]
+          end
+          R.assign "accuracy", accuracies
+          R.assign "probability", probabilities
+          R.eval "image = qplot(probability,accuracy)+ylab('Accumulated accuracy')+xlab('Prediction probability')+ylim(c(0,1))+scale_x_reverse()+geom_line()"
+          R.eval "ggsave(file='#{tmpfile}', plot=image)"
+          file = Mongo::Grid::File.new(File.read(tmpfile), :filename => "#{self.id.to_s}_probability_plot.svg")
+          plot_id = $gridfs.insert_one(file)
+          update(:probability_plot_id => plot_id)
+        #end
+        $gridfs.find_one(_id: probability_plot_id).data
+      end
+    end
+
+    module RegressionStatistics
+
+      def statistics
+        self.rmse = 0
+        self.mae = 0
+        self.within_prediction_interval = 0
+        self.out_of_prediction_interval = 0
+        x = []
+        y = []
+        predictions.each do |cid,pred|
+          if pred[:value] and pred[:measurements] 
+            x << pred[:measurements].median
+            y << pred[:value]
+            error = pred[:value]-pred[:measurements].median
+            self.rmse += error**2
+            self.mae += error.abs
+            if pred[:prediction_interval]
+              if pred[:measurements].median >= pred[:prediction_interval][0] and pred[:measurements].median <= pred[:prediction_interval][1]
+                self.within_prediction_interval += 1
+              else
+                self.out_of_prediction_interval += 1
+              end
+            end
+          else
+            warnings << "No training activities for #{Compound.find(compound_id).smiles} in training dataset #{model.training_dataset_id}."
+            $logger.debug "No training activities for #{Compound.find(compound_id).smiles} in training dataset #{model.training_dataset_id}."
+          end
+        end
+        R.assign "measurement", x
+        R.assign "prediction", y
+        R.eval "r <- cor(measurement,prediction,use='pairwise')"
+        self.r_squared = R.eval("r").to_ruby**2
+        self.mae = self.mae/predictions.size
+        self.rmse = Math.sqrt(self.rmse/predictions.size)
+        $logger.debug "R^2 #{r_squared}"
+        $logger.debug "RMSE #{rmse}"
+        $logger.debug "MAE #{mae}"
+        $logger.debug "#{percent_within_prediction_interval.round(2)}% of measurements within prediction interval"
+        save
+        {
+          :mae => mae,
+          :rmse => rmse,
+          :r_squared => r_squared,
+          :within_prediction_interval => within_prediction_interval,
+          :out_of_prediction_interval => out_of_prediction_interval,
+        }
+      end
+
+      def percent_within_prediction_interval
+        100*within_prediction_interval.to_f/(within_prediction_interval+out_of_prediction_interval)
+      end
+
+      def correlation_plot format: "png"
+        unless correlation_plot_id
+          tmpfile = "/tmp/#{id.to_s}_correlation.#{format}"
+          x = []
+          y = []
+          feature = Feature.find(predictions.first.last["prediction_feature_id"])
+          predictions.each do |sid,p|
+            x << p["measurements"].median
+            y << p["value"]
+          end
+          R.assign "measurement", x
+          R.assign "prediction", y
+          R.eval "all = c(measurement,prediction)"
+          R.eval "range = c(min(all), max(all))"
+          title = feature.name
+          title += "[#{feature.unit}]" if feature.unit and !feature.unit.blank?
+          R.eval "image = qplot(prediction,measurement,main='#{title}',xlab='Prediction',ylab='Measurement',asp=1,xlim=range, ylim=range)"
+          R.eval "image = image + geom_abline(intercept=0, slope=1)"
+          R.eval "ggsave(file='#{tmpfile}', plot=image)"
+          file = Mongo::Grid::File.new(File.read(tmpfile), :filename => "#{id.to_s}_correlation_plot.#{format}")
+          plot_id = $gridfs.insert_one(file)
+          update(:correlation_plot_id => plot_id)
+        end
+        $gridfs.find_one(_id: correlation_plot_id).data
+      end
+
+      def worst_predictions n: 5, show_neigbors: true, show_common_descriptors: false
+        worst_predictions = predictions.sort_by{|sid,p| -(p["value"] - p["measurements"].median).abs}[0,n]
+        worst_predictions.collect do |p|
+          substance = Substance.find(p.first)
+          prediction = p[1]
+          if show_neigbors
+            neighbors = prediction["neighbors"].collect do |n|
+              common_descriptors = []
+              if show_common_descriptors
+                common_descriptors = n["common_descriptors"].collect do |d|
+                  f=Feature.find(d)
+                  {
+                    :id => f.id.to_s,
+                    :name => "#{f.name} (#{f.conditions})",
+                    :p_value => d[:p_value],
+                    :r_squared => d[:r_squared],
+                  }
+                end
+              else
+                common_descriptors = n["common_descriptors"].size
+              end
+              {
+                :name => Substance.find(n["_id"]).name,
+                :id => n["_id"].to_s,
+                :common_descriptors => common_descriptors
+              }
+            end
+          else
+            neighbors = prediction["neighbors"].size
+          end
+          {
+            :id => substance.id.to_s,
+            :name => substance.name,
+            :feature => Feature.find(prediction["prediction_feature_id"]).name,
+            :error => (prediction["value"] - prediction["measurements"].median).abs,
+            :prediction => prediction["value"],
+            :measurements => prediction["measurements"],
+            :neighbors => neighbors
+          }
+        end
+      end
+    end
+  end
+end