opentox-ruby 0.0.1 → 0.0.2

data/README.rdoc

@@ -1,4 +1,4 @@
-= opentox-ruby-api-wrapper
+= opentox-ruby
 
 Ruby wrapper for the OpenTox REST API (http://www.opentox.org)
 
@@ -10,14 +10,14 @@ Run the following if you haven't already:
 
 Install the gem:
 
-	sudo gem install helma-opentox-ruby-api-wrapper 
+	sudo gem install helma-opentox-ruby 
 
 == Usage
 
 - adjust the settings in $HOME/.opentox/config
-- require 'opentox-ruby-api-wrapper' in your ruby application
+- require 'opentox-ruby' in your ruby application
 - consult the rdoc API documentation for details 
 
 == Copyright
 
-Copyright (c) 2009 Christoph Helma. See LICENSE for details.
+Copyright (c) 2009-2010 Christoph Helma. See LICENSE for details.

data/Rakefile

@@ -4,46 +4,46 @@ require 'rake'
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
-    gem.name = "opentox-ruby-api-wrapper"
+    gem.name = "opentox-ruby"
     gem.summary = %Q{Ruby wrapper for the OpenTox REST API}
     gem.description = %Q{Ruby wrapper for the OpenTox REST API (http://www.opentox.org)}
     gem.email = "helma@in-silico.ch"
-    gem.homepage = "http://github.com/helma/opentox-ruby-api-wrapper"
-    gem.authors = ["Christoph Helma, Martin Guetlein"]
-		# dependencies
-		[ "sinatra",
-			"emk-sinatra-url-for",
-			"sinatra-respond_to",
-			"sinatra-static-assets",
-			"rest-client",
-			"rack",
-			"rack-contrib",
-			"rack-flash",
-			"nokogiri",
-			"rubyzip",
-			"builder",
-			"roo",
-			"spreadsheet",
-			"google-spreadsheet-ruby",
-			"tmail",
-			"rinruby",
-			"rjb"
-		].each { |dep| gem.add_dependency dep }
-		[ "dm-core",
-			'dm-serializer',
-			'dm-timestamps',
-			'dm-types',
-			'dm-migrations',
-			"dm-mysql-adapter",
+    gem.homepage = "http://github.com/helma/opentox-ruby"
+    gem.authors = ["Christoph Helma, Martin Guetlein, Andreas Maunz, Micha Rautenberg, David Vorgrimmler"]
+    # dependencies
+    [ "sinatra",
+      "emk-sinatra-url-for",
+      "sinatra-respond_to",
+      "sinatra-static-assets",
+      "rest-client",
+      "rack",
+      "rack-contrib",
+      "rack-flash",
+      "nokogiri",
+      "rubyzip",
+      "roo",
+      "spreadsheet",
+      "google-spreadsheet-ruby",
+      "yajl-ruby",
+      "tmail",
+      "rinruby",
+      "rjb"
+    ].each { |dep| gem.add_dependency dep }
+    [ "dm-core",
+      'dm-serializer',
+      'dm-timestamps',
+      'dm-types',
+      'dm-migrations',
+      "dm-mysql-adapter",
       "dm-validations",
-		].each {|dep| gem.add_dependency dep, ">= 1" }
-		gem.add_dependency "haml", ">=3"
-		['cucumber','jeweler'].each { |dep| gem.add_development_dependency dep }
-		gem.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
-		gem.files.include %w(lib/tasks/owl.rb, lib/environment.rb, lib/algorithm.rb, lib/compound.rb, lib/dataset.rb, lib/model.rb, lib/utils.rb, lib/validation.rb, lib/templates/*)
+    ].each {|dep| gem.add_dependency dep, ">= 1" }
+    gem.add_dependency "haml", ">=3"
+    ['jeweler'].each { |dep| gem.add_development_dependency dep }
+    gem.files =  FileList["[A-Z]*", "{bin,generators,lib,test}/**/*", 'lib/jeweler/templates/.gitignore']
+    #gem.files.include %w(lib/environment.rb, lib/algorithm.rb, lib/compound.rb, lib/dataset.rb, lib/model.rb, lib/validation.rb, lib/templates/*)
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
-	Jeweler::GemcutterTasks.new
+  Jeweler::GemcutterTasks.new
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
 end
@@ -81,7 +81,7 @@ Rake::RDocTask.new do |rdoc|
   end
 
   rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "opentox-ruby-api-wrapper #{version}"
+  rdoc.title = "opentox-ruby #{version}"
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end

data/VERSION

@@ -1 +1 @@
-1.6.5
+0.0.2

data/lib/algorithm.rb

@@ -1,82 +1,252 @@
+# R integration
+# workaround to initialize R non-interactively (former rinruby versions did this by default)
+# avoids compiling R with X
+R = nil
+require "rinruby" 
 
 module OpenTox
+
+  # Wrapper for OpenTox Algorithms
   module Algorithm 
+
+    include OpenTox
+
+    # Execute algorithm with parameters, please consult the OpenTox API and the webservice documentation for acceptable parameters
+    # @param [optional,Hash] params Algorithm parameters
+    # @return [String] URI of new resource (dataset, model, ...)
+    def run(params=nil)
+      RestClientWrapper.post(@uri, {:accept => 'text/uri-list'}, params).to_s
+    end
     
-    
-    class Generic
-      
-      attr_accessor :uri, :title, :date
-      
-      def self.find(uri)
-        owl = OpenTox::Owl.from_uri(uri, "Algorithm")
-        return self.new(owl)
-      end
-      
-      protected
-      def initialize(owl)
-        @title = owl.get("title")
-        @date = owl.get("date")
-        @uri = owl.uri 
-      end
-      
+    # Get OWL-DL representation in RDF/XML format
+    # @return [application/rdf+xml] RDF/XML representation
+    def to_rdfxml
+      s = Serializer::Owl.new
+      s.add_algorithm(@uri,@metadata)
+      s.to_rdfxml
+    end
+
+    # Generic Algorithm class, should work with all OpenTox webservices
+    class Generic 
+      include Algorithm
     end
 
-    class Fminer 
+    # Fminer algorithms (https://github.com/amaunz/fminer2)
+    module Fminer
+      include Algorithm
+
+      # Backbone Refinement Class mining (http://bbrc.maunz.de/)
+      class BBRC
+        include Fminer
+        # Initialize bbrc algorithm
+        def initialize
+          super File.join(CONFIG[:services]["opentox-algorithm"], "fminer/bbrc")
+          load_metadata
+        end
+      end
 
-      def self.create_feature_dataset(params)
-				LOGGER.debug File.basename(__FILE__) + ": creating feature dataset"
-        resource = RestClient::Resource.new(params[:feature_generation_uri], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-        resource.post :dataset_uri => params[:dataset_uri], :feature_uri => params[:feature_uri]
+      # LAtent STructure Pattern Mining (http://last-pm.maunz.de)
+      class LAST
+        include Fminer
+        # Initialize last algorithm
+        def initialize
+          super File.join(CONFIG[:services]["opentox-algorithm"], "fminer/last")
+          load_metadata
+        end
       end
 
-			def self.uri
-				File.join(@@config[:services]["opentox-algorithm"], "fminer")
-			end
     end
 
-    class Lazar 
-			
-			def self.create_model(params)
-				LOGGER.debug params
-				LOGGER.debug File.basename(__FILE__) + ": creating model"
-				LOGGER.debug File.join(@@config[:services]["opentox-algorithm"], "lazar")
-        resource = RestClient::Resource.new(File.join(@@config[:services]["opentox-algorithm"], "lazar"), :user => @@users[:users].keys[0], :password => @@users[:users].values[0], :content_type => "application/x-yaml")
-        @uri = resource.post(:dataset_uri => params[:dataset_uri], :prediction_feature => params[:prediction_feature], :feature_generation_uri => File.join(@@config[:services]["opentox-algorithm"], "fminer")).body.chomp
-			end
+    # Create lazar prediction model
+    class Lazar
+      include Algorithm
+      # Initialize lazar algorithm
+      def initialize
+        super File.join(CONFIG[:services]["opentox-algorithm"], "lazar")
+        load_metadata
+      end
+    end
 
-			def self.uri
-				File.join(@@config[:services]["opentox-algorithm"], "lazar")
-			end
+    # Utility methods without dedicated webservices
 
-    end
+    # Similarity calculations
+    module Similarity
+      include Algorithm
 
-    class Similarity
-      def self.weighted_tanimoto(fp_a,fp_b,p)
-        common_features = fp_a & fp_b
-        all_features = (fp_a + fp_b).uniq
+      # Tanimoto similarity
+      # @param [Array] features_a Features of first compound
+      # @param [Array] features_b Features of second compound
+      # @param [optional, Hash] weights Weights for all features
+      # @return [Float] (Weighted) tanimoto similarity
+      def self.tanimoto(features_a,features_b,weights=nil)
+        common_features = features_a & features_b
+        all_features = (features_a + features_b).uniq
         common_p_sum = 0.0
         if common_features.size > 0
-          common_features.each{|f| common_p_sum += OpenTox::Utils.gauss(p[f])}
-          all_p_sum = 0.0
-          all_features.each{|f| all_p_sum += OpenTox::Utils.gauss(p[f])}
-          common_p_sum/all_p_sum
+          if weights
+            common_features.each{|f| common_p_sum += Algorithm.gauss(weights[f])}
+            all_p_sum = 0.0
+            all_features.each{|f| all_p_sum += Algorithm.gauss(weights[f])}
+            common_p_sum/all_p_sum
+          else
+            common_features.to_f/all_features
+          end
         else
           0.0
         end
       end
-      def self.euclidean(prop_a,prop_b)
-        common_properties = prop_a.keys & prop_b.keys
+
+      # Euclidean similarity
+      # @param [Hash] properties_a Properties of first compound
+      # @param [Hash] properties_b Properties of second compound
+      # @param [optional, Hash] weights Weights for all properties
+      # @return [Float] (Weighted) euclidean similarity
+      def self.euclidean(properties_a,properties_b,weights=nil)
+        common_properties = properties_a.keys & properties_b.keys
         if common_properties.size > 1
           dist_sum = 0
           common_properties.each do |p|
-            dist_sum += (prop_a[p] - prop_b[p])**2
+            if weights
+              dist_sum += ( (properties_a[p] - properties_b[p]) * Algorithm.gauss(weights[p]) )**2
+            else
+              dist_sum += (properties_a[p] - properties_b[p])**2
+            end
           end
           1/(1+Math.sqrt(dist_sum))
         else
-          nil
+          0.0
         end
       end
     end
 
+    module Neighbors
+
+      # Classification with majority vote from neighbors weighted by similarity
+      # @param [Array] neighbors, each neighbor is a hash with keys `:similarity, :activity`
+      # @param [optional] params Ignored (only for compatibility with local_svm_regression)
+      # @return [Hash] Hash with keys `:prediction, :confidence`
+      def self.weighted_majority_vote(neighbors,params={})
+        conf = 0.0
+        confidence = 0.0
+        neighbors.each do |neighbor|
+          case neighbor[:activity].to_s
+          when 'true'
+            conf += Algorithm.gauss(neighbor[:similarity])
+          when 'false'
+            conf -= Algorithm.gauss(neighbor[:similarity])
+          end
+        end
+        if conf > 0.0
+          prediction = true
+        elsif conf < 0.0
+          prediction = false
+        else
+          prediction = nil
+        end
+        confidence = conf/neighbors.size if neighbors.size > 0
+        {:prediction => prediction, :confidence => confidence.abs}
+      end
+
+      # Local support vector regression from neighbors 
+      # @param [Array] neighbors, each neighbor is a hash with keys `:similarity, :activity, :features`
+      # @param [Hash] params Keys `:similarity_algorithm,:p_values` are required
+      # @return [Hash] Hash with keys `:prediction, :confidence`
+      def self.local_svm_regression(neighbors,params )
+        sims = neighbors.collect{ |n| n[:similarity] } # similarity values between query and neighbors
+        conf = sims.inject{|sum,x| sum + x }
+        acts = neighbors.collect do |n|
+          act = n[:activity] 
+          Math.log10(act.to_f)
+        end # activities of neighbors for supervised learning
+
+        neighbor_matches = neighbors.collect{ |n| n[:features] } # as in classification: URIs of matches
+        gram_matrix = [] # square matrix of similarities between neighbors; implements weighted tanimoto kernel
+        if neighbor_matches.size == 0
+          raise "No neighbors found"
+        else
+          # gram matrix
+          (0..(neighbor_matches.length-1)).each do |i|
+            gram_matrix[i] = [] unless gram_matrix[i]
+            # upper triangle
+            ((i+1)..(neighbor_matches.length-1)).each do |j|
+              sim = eval("#{params[:similarity_algorithm]}(neighbor_matches[i], neighbor_matches[j], params[:p_values])")
+              gram_matrix[i][j] = Algorithm.gauss(sim)
+              gram_matrix[j] = [] unless gram_matrix[j] 
+              gram_matrix[j][i] = gram_matrix[i][j] # lower triangle
+            end
+            gram_matrix[i][i] = 1.0
+          end
+
+          LOGGER.debug gram_matrix.to_yaml
+
+          @r = RinRuby.new(false,false) # global R instance leads to Socket errors after a large number of requests
+          @r.eval "library('kernlab')" # this requires R package "kernlab" to be installed
+          LOGGER.debug "Setting R data ..."
+          # set data
+          @r.gram_matrix = gram_matrix.flatten
+          @r.n = neighbor_matches.size
+          @r.y = acts
+          @r.sims = sims
+
+          LOGGER.debug "Preparing R data ..."
+          # prepare data
+          @r.eval "y<-as.vector(y)"
+          @r.eval "gram_matrix<-as.kernelMatrix(matrix(gram_matrix,n,n))"
+          @r.eval "sims<-as.vector(sims)"
+          
+          # model + support vectors
+          LOGGER.debug "Creating SVM model ..."
+          @r.eval "model<-ksvm(gram_matrix, y, kernel=matrix, type=\"nu-svr\", nu=0.8)"
+          @r.eval "sv<-as.vector(SVindex(model))"
+          @r.eval "sims<-sims[sv]"
+          @r.eval "sims<-as.kernelMatrix(matrix(sims,1))"
+          LOGGER.debug "Predicting ..."
+          @r.eval "p<-predict(model,sims)[1,1]"
+          prediction = 10**(@r.p.to_f)
+          LOGGER.debug "Prediction is: '" + @prediction.to_s + "'."
+          @r.quit # free R
+        end
+        confidence = conf/neighbors.size if neighbors.size > 0
+        {:prediction => prediction, :confidence => confidence}
+        
+      end
+
+    end
+
+    module Substructure
+      include Algorithm
+      # Substructure matching
+      # @param [OpenTox::Compound] compound Compound
+      # @param [Array] features Array with Smarts strings
+      # @return [Array] Array with matching Smarts
+      def self.match(compound,features)
+        compound.match(features)
+      end
+    end
+
+    module Dataset
+      include Algorithm
+      # API should match Substructure.match
+      def features(dataset_uri,compound_uri)
+      end
+    end
+    
+    # Gauss kernel
+    # @return [Float] 
+    def self.gauss(x, sigma = 0.3) 
+      d = 1.0 - x
+      Math.exp(-(d*d)/(2*sigma*sigma))
+    end
+    
+    # Median of an array
+    # @param [Array] Array with values
+    # @return [Float] Median
+    def self.median(array)
+      return nil if array.empty?
+      array.sort!
+      m_pos = array.size / 2
+      return array.size % 2 == 1 ? array[m_pos] : (array[m_pos-1] + array[m_pos])/2
+    end
+
   end
 end