opentox-ruby 0.0.1 → 0.0.2

data/lib/model.rb

@@ -1,143 +1,271 @@
 module OpenTox
-  module Model
 
-    class Generic
+  module Model
 
-      MODEL_ATTRIBS = [:uri, :title, :creator, :date, :format, :predictedVariables, :independentVariables, :dependentVariables, :trainingDataset, :algorithm]
-      MODEL_ATTRIBS.each{ |a| attr_accessor(a) }
+    include OpenTox
 
-      def self.find(uri)
-        owl = OpenTox::Owl.from_uri(uri, "Model")
-        return self.new(owl)
+    # Run a model with parameters
+    # @param [Hash] params Parameters for OpenTox model
+    # @return [text/uri-list] Task or resource URI
+    def run(params)
+      if CONFIG[:yaml_hosts].include?(URI.parse(@uri).host)
+        accept = 'application/x-yaml' 
+      else
+        accept = 'application/rdf+xml'
       end
-      
-      def self.to_rdf(model)
-        owl = OpenTox::Owl.create 'Model', model.uri
-        (MODEL_ATTRIBS - [:uri]).each do |a|
-          owl.set(a.to_s,model.send(a.to_s))
-        end
-        owl.rdf
-      end
-      
-      protected
-      def initialize(owl)
-        MODEL_ATTRIBS.each do |a|
-            self.send("#{a.to_s}=".to_sym, owl.get(a.to_s)) unless a==:uri
-        end
-        @uri = owl.uri 
-        if ENV['RACK_ENV'] =~ /test|debug/
-          begin
-            raise "uri invalid" unless Utils.is_uri?(@uri)
-            raise "no predicted variables" unless @predictedVariables and @predictedVariables.size>0
-          rescue => ex
-            RestClientWrapper.raise_uri_error "invalid model: '"+ex.message+"'\n"+self.to_yaml+"\n",@uri.to_s    
-          end
-          LOGGER.warn "model has no dependent variable" unless @dependentVariables and @dependentVariables.size>0
-          LOGGER.warn "model has no algorithm" unless @algorithm and @algorithm.size>0
-          LOGGER.warn "model has no indenpendent variables" unless @independentVariables
-        end
+      begin
+        RestClientWrapper.post(@uri,{:accept => accept},params).to_s
+      rescue => e
+        LOGGER.error "Failed to run #{@uri} with #{params.inspect} (#{e.inspect})"
+        raise "Failed to run #{@uri} with #{params.inspect}"
       end
     end
-  
-    class PredictionModel < Generic
-      
-      def self.build( algorithm_uri, algorithm_params )
-         
-        LOGGER.debug "Build model, algorithm_uri:"+algorithm_uri.to_s+", algorithm_parms: "+algorithm_params.inspect.to_s
-        uri = OpenTox::RestClientWrapper.post(algorithm_uri,algorithm_params).to_s
-        LOGGER.debug "Build model done: "+uri.to_s
-        RestClientWrapper.raise_uri_error("Invalid build model result: '"+uri.to_s+"'", algorithm_uri, algorithm_params ) unless Utils.model_uri?(uri)
-        return PredictionModel.find(uri)
-      end
-     
-      def predict_dataset( dataset_uri )
- 
-        LOGGER.debug "Predict dataset: "+dataset_uri.to_s+" with model "+@uri.to_s
-        uri = RestClientWrapper.post(@uri, {:accept => "text/uri-list", :dataset_uri=>dataset_uri})
-        RestClientWrapper.raise_uri_error("Prediciton result no dataset uri: "+uri.to_s, @uri, {:dataset_uri=>dataset_uri} ) unless Utils.dataset_uri?(uri)
-        uri
-      end
-     
-      def classification?
-        #HACK replace with request to ontology server
-        if @title =~ /(?i)classification/
-          return true
-        elsif @title =~ /(?i)regression/
-          return false
-        elsif @uri =~/ntua/ and @title =~ /mlr/
-          return false
-        elsif @uri =~/tu-muenchen/ and @title =~ /regression|M5P|GaussP/
-          return false
-        elsif @uri =~/ambit2/ and @title =~ /pKa/ || @title =~ /Regression|Caco/
-          return false
-        elsif @uri =~/majority/
-          return (@uri =~ /class/) != nil
-        else
-          raise "unknown model, uri:'"+@uri.to_s+"' title:'"+@title.to_s+"'"
-        end
-      end
+
+    # Generic OpenTox model class for all API compliant services
+    class Generic
+      include Model
     end
    
-    class Lazar < Generic
-      
-      attr_accessor :feature_dataset_uri, :effects, :activities, :p_values, :fingerprints, :features
-      
-      def initialize
-        @source = "http://github.com/helma/opentox-model"
-        @algorithm = File.join(@@config[:services]["opentox-algorithm"],"lazar")
-        #@independent_variables = File.join(@@config[:services]["opentox-algorithm"],"fminer#BBRC_representative")
+    # Lazy Structure Activity Relationship class
+    class Lazar
+
+      include Model
+      include Algorithm
+
+      attr_accessor :compound, :prediction_dataset, :features, :effects, :activities, :p_values, :fingerprints, :feature_calculation_algorithm, :similarity_algorithm, :prediction_algorithm, :min_sim
+
+      def initialize(uri=nil)
+
+        if uri
+          super uri
+        else
+          super CONFIG[:services]["opentox-model"]
+        end
+        
+        @metadata[OT.algorithm] = File.join(CONFIG[:services]["opentox-algorithm"],"lazar")
+
         @features = []
         @effects = {}
         @activities = {}
         @p_values = {}
         @fingerprints = {}
+
+        @feature_calculation_algorithm = "Substructure.match"
+        @similarity_algorithm = "Similarity.tanimoto"
+        @prediction_algorithm = "Neighbors.weighted_majority_vote"
+
+        @min_sim = 0.3
+
       end
 
-      def save
-        @features.uniq!
-        resource = RestClient::Resource.new(@@config[:services]["opentox-model"], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-        resource.post(self.to_yaml, :content_type => "application/x-yaml").chomp.to_s
+      # Get URIs of all lazar models
+      # @return [Array] List of lazar model URIs
+      def self.all
+        RestClientWrapper.get(CONFIG[:services]["opentox-model"]).to_s.split("\n")
       end
 
-      def self.find_all
-        RestClientWrapper.get(@@config[:services]["opentox-model"]).chomp.split("\n")
+      # Find a lazar model
+      # @param [String] uri Model URI
+      # @return [OpenTox::Model::Lazar] lazar model
+      def self.find(uri)
+        YAML.load RestClientWrapper.get(uri,:accept => 'application/x-yaml')
       end
 
-      def self.predict(compound_uri,model_uri)
-        #RestClientWrapper.post(model_uri,{:compound_uri => compound_uri, :accept => 'application/x-yaml'})
-        `curl -X POST -d 'compound_uri=#{compound_uri}' -H 'Accept:application/x-yaml' #{model_uri}`
+      # 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)
+        lazar_algorithm = OpenTox::Algorithm::Generic.new File.join( CONFIG[:services]["opentox-algorithm"],"lazar")
+        model_uri = lazar_algorithm.run(params)
+        OpenTox::Model::Lazar.find(model_uri)
       end
-    end
-   
-    class PropertyLazar < Generic
-      
-      attr_accessor :feature_dataset_uri, :properties, :features, :activities#, :effects, :p_values
-      
-      def initialize
-        @source = "http://github.com/helma/opentox-model"
-        @algorithm = File.join(@@config[:services]["opentox-algorithm"],"property_lazar")
-        #@independent_variables = File.join(@@config[:services]["opentox-algorithm"],"fminer#BBRC_representative")
-        @features = []
-        #@effects = {}
-        @activities = {}
-        #@p_values = {}
-        @properties = {}
+
+      # Get a parameter value
+      # @param [String] param Parameter name
+      # @return [String] Parameter value
+      def parameter(param)
+        @metadata[OT.parameters].collect{|p| p[OT.paramValue] if p[DC.title] == param}.compact.first
       end
 
-      def save
-        @features.uniq!
-        resource = RestClient::Resource.new(@@config[:services]["opentox-model"], :user => @@users[:users].keys[0], :password => @@users[:users].values[0])
-        resource.post(self.to_yaml, :content_type => "application/x-yaml").chomp.to_s
+      # Predict a dataset
+      # @param [String] dataset_uri Dataset URI
+      # @return [OpenTox::Dataset] Dataset with predictions
+      def predict_dataset(dataset_uri)
+        @prediction_dataset = Dataset.create
+        @prediction_dataset.add_metadata({
+          OT.hasSource => @uri,
+          DC.creator => @uri,
+          DC.title => URI.decode(File.basename( @metadata[OT.dependentVariables] )),
+          OT.parameters => [{DC.title => "dataset_uri", OT.paramValue => dataset_uri}]
+        })
+        d = Dataset.new(dataset_uri)
+        d.load_compounds
+        d.compounds.each do |compound_uri|
+          predict(compound_uri,false)
+        end
+        @prediction_dataset.save
+        @prediction_dataset
       end
 
-      def self.find_all
-        RestClientWrapper.get(@@config[:services]["opentox-model"]).chomp.split("\n")
+      # Predict a compound
+      # @param [String] compound_uri Compound URI
+      # @param [optinal,Boolean] verbose Verbose prediction (output includes neighbors and features)
+      # @return [OpenTox::Dataset] Dataset with prediction
+      def predict(compound_uri,verbose=false)
+
+        @compound = Compound.new compound_uri
+        features = {}
+
+        unless @prediction_dataset
+          #@prediction_dataset = cached_prediction
+          #return @prediction_dataset if cached_prediction
+          @prediction_dataset = Dataset.create
+          @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
+
+        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, {
+            OT.isA => 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]
+
+        else
+          @prediction_dataset.add_feature(prediction_feature_uri, {
+            OT.isA => 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]
+
+          if verbose
+            if @feature_calculation_algorithm == "Substructure.match"
+              f = 0
+              @compound_features.each do |feature|
+                feature_uri = File.join( @prediction_dataset.uri, "feature", "descriptor", f.to_s)
+                features[feature] = feature_uri
+                @prediction_dataset.add_feature(feature_uri, {
+                  OT.isA => OT.Substructure,
+                  OT.smarts => feature,
+                  OT.pValue => @p_values[feature],
+                  OT.effect => @effects[feature]
+                })
+                @prediction_dataset.add @compound.uri, feature_uri, true
+                f+=1
+              end
+            else
+              @compound_features.each do |feature|
+                features[feature] = feature
+                @prediction_dataset.add @compound.uri, feature, true
+              end
+            end
+            n = 0
+            @neighbors.each do |neighbor|
+              neighbor_uri = File.join( @prediction_dataset.uri, "feature", "neighbor", n.to_s )
+              @prediction_dataset.add_feature(neighbor_uri, {
+                OT.compound => neighbor[:compound],
+                OT.similarity => neighbor[:similarity],
+                OT.measuredActivity => neighbor[:activity],
+                OT.isA => OT.Neighbor
+              })
+              @prediction_dataset.add @compound.uri, neighbor_uri, true
+              f = 0 unless f
+              neighbor[:features].each do |feature|
+                if @feature_calculation_algorithm == "Substructure.match"
+                  feature_uri = File.join( @prediction_dataset.uri, "feature", "descriptor", f.to_s) unless feature_uri = features[feature]
+                else
+                  feature_uri = feature
+                end
+                @prediction_dataset.add neighbor[:compound], feature_uri, true
+                unless features.has_key? feature
+                  features[feature] = feature_uri
+                  @prediction_dataset.add_feature(feature_uri, {
+                    OT.isA => OT.Substructure,
+                    OT.smarts => feature,
+                    OT.pValue => @p_values[feature],
+                    OT.effect => @effects[feature]
+                  })
+                  f+=1
+                end
+              end
+              n+=1
+            end
+            # what happens with dataset predictions?
+          end
+        end
+
+        @prediction_dataset.save
+        @prediction_dataset
       end
 
-      def self.predict(compound_uri,model_uri)
-        #RestClientWrapper.post(model_uri,{:compound_uri => compound_uri, :accept => 'application/x-yaml'})
-        `curl -X POST -d 'compound_uri=#{compound_uri}' -H 'Accept:application/x-yaml' #{model_uri}`
+      # Find neighbors and store them as object variable
+      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
+        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
+        if @activities[@compound.uri]
+          @activities[@compound.uri].each { |act| @prediction_dataset.add @compound.uri, @metadata[OT.dependentVariables], act }
+          @prediction_dataset.add_metadata(OT.hasSource => @metadata[OT.trainingDataset])
+          @prediction_dataset.save
+          true
+        else
+          false
+        end
+      end
+
+      # Save model at model service
+      def save
+        self.uri = RestClientWrapper.post(@uri,{:content_type =>  "application/x-yaml"},self.to_yaml)
+      end
+
+      # Delete model at model service
+      def delete
+        RestClientWrapper.delete @uri unless @uri == CONFIG[:services]["opentox-model"]
+      end
+
     end
   end
 end

data/lib/opentox-ruby.rb

@@ -0,0 +1,13 @@
+['rubygems', 'sinatra', 'sinatra/url_for', 'rest_client', 'yaml', 'cgi', 'spork', 'overwrite', 'environment'].each do |lib|
+	require lib
+end
+
+begin
+	require 'openbabel'
+rescue LoadError
+	puts "Please install Openbabel with 'rake openbabel:install' in the compound component"
+end
+
+['opentox', 'compound','dataset', 'parser','serializer', 'algorithm','model','task','validation','feature', 'rest_client_wrapper'].each do |lib|
+	require lib
+end

data/lib/opentox.rb

@@ -0,0 +1,47 @@
+module OpenTox
+
+  attr_reader :uri
+  attr_accessor :metadata
+
+  # Initialize OpenTox object with optional uri
+  # @param [optional, String] URI
+  def initialize(uri=nil)
+    @metadata = {}
+    self.uri = uri if uri
+  end
+
+  # Set URI
+  # @param [String] URI
+  def uri=(uri)
+    @uri = uri
+    @metadata[XSD.anyURI] = uri
+  end
+
+  # Get all objects from a service
+  # @return [Array] List of available URIs
+  def self.all(uri)
+    RestClientWrapper.get(uri,:accept => "text/uri-list").to_s.split(/\n/)
+  end
+
+  # Load (and return) metadata from object URI
+  # @return [Hash] Metadata
+  def load_metadata
+    @metadata = Parser::Owl::Generic.new(@uri).load_metadata
+    @metadata
+  end
+
+  def add_metadata(metadata)
+    metadata.each { |k,v| @metadata[k] = v }
+  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_metadata(@uri,@metadata)
+    #s.add_parameters(@uri,@parameters) if @parameters
+    s.to_rdfxml
+  end
+
+end
+

data/lib/overwrite.rb

@@ -12,3 +12,75 @@ class Sinatra::Base
   end
 end
 
+class String
+    def task_uri?
+      self.uri? && !self.match(/task/).nil?
+    end
+    
+    def dataset_uri?
+     self.uri? && !self.match(/dataset/).nil?
+    end
+   
+    def self.model_uri?
+     self.uri? && !self.match(/model/).nil?
+    end
+
+    def uri?
+      begin
+        u = URI::parse(self)
+        return (u.scheme!=nil and u.host!=nil)
+      rescue URI::InvalidURIError
+        return false
+      end
+    end
+end
+
+require 'logger'
+# logging
+#class Logger
+class OTLogger < Logger
+  
+  def pwd
+    path = Dir.pwd.to_s
+    index = path.rindex(/\//)
+    return path if index==nil
+    path[(index+1)..-1]
+  end
+  
+  def trace()
+    lines = caller(0)
+    n = 2
+    line = lines[n]
+    
+    while (line =~ /spork.rb/ or line =~ /create/ or line =~ /ot-logger.rb/)
+      n += 1
+      line = lines[n]
+    end
+  
+    index = line.rindex(/\/.*\.rb/)
+    return line if index==nil
+    line[index..-1]
+  end
+  
+  def format(msg)
+    pwd.ljust(18)+" :: "+msg.to_s+"           :: "+trace+" :: "+($sinatra ? $sinatra.request.env['REMOTE_ADDR'] : nil).to_s
+  end
+  
+  def debug(msg)
+    super format(msg)
+  end
+  
+  def info(msg)
+    super format(msg)
+  end
+  
+  def warn(msg)
+    super format(msg)
+  end
+
+  def error(msg)
+    super format(msg)
+  end
+
+end
+