opentox-ruby-api-wrapper 1.2.1 → 1.2.2

data/VERSION

@@ -1 +1 @@
-1.2.1
+1.2.2

data/bin/yaml2owl.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'opentox-ruby-api-wrapper'
+
+input = YAML.load_file(ARGV[0])
+dataset = OpenTox::Dataset.new
+dataset.title = input[:title]
+dataset.source = input[:source]
+input[:data].each do |c,f|
+	f.each do |k,v|
+		v.each do |value|
+			dataset.add c,k,value
+		end
+	end
+end
+outfile = File.expand_path(File.join(File.dirname(__FILE__),ARGV[0].sub(/yaml/,'owl')))
+dataset.uri = outfile
+File.open(outfile,'w+'){|f| f.puts dataset.rdf}

data/lib/algorithm.rb

@@ -14,6 +14,10 @@ module OpenTox
 					"Feature URI for dependent variable" => { :scope => "mandatory", :value => "feature_uri" }
 				}
 			end
+
+			def self.create_feature_dataset(params)
+				RestClient.post params[:feature_generation_uri], :dataset_uri => params[:dataset_uri], :feature_uri => params[:feature_uri] 
+			end
 		end
 
 		class Lazar #< OpenTox
@@ -35,5 +39,23 @@ module OpenTox
 			end
 		end
 
+		class Similarity
+
+			def self.weighted_tanimoto(fp_a,fp_b,p)
+				common_features = fp_a & fp_b
+				all_features = fp_a + fp_b
+				common_p_sum = 0.0
+				if common_features.size > 0
+					common_features.each{|f| common_p_sum += p[f]}
+					all_p_sum = 0.0
+					all_features.each{|f| all_p_sum += p[f]}
+					common_p_sum/all_p_sum
+				else
+					0.0
+				end
+			end
+
+		end
+
 	end
 end

data/lib/dataset.rb

@@ -3,12 +3,55 @@ module OpenTox
 	class Dataset 
 		include Owl
 
-		#attr_accessor :model
-
 		def initialize 
 			super
 		end
 
+		# create/add to entry from uris or Redland::Resources
+		def add(compound,feature,value)
+			compound = self.find_or_create_compound compound unless compound.class == Redland::Resource
+			feature = self.find_or_create_feature feature unless feature.class == Redland::Resource
+			data_entry = @model.subject OT['compound'], compound
+			if data_entry.nil?
+				data_entry = @model.create_resource
+				@model.add data_entry, RDF['type'], OT["DataEntry"]
+				@model.add data_entry, OT['compound'], compound
+			end
+			values = @model.create_resource
+			@model.add data_entry, OT['values'], values
+			@model.add values, RDF['type'], OT['FeatureValue']
+			@model.add values, OT['feature'], feature
+			@model.add values, OT['value'], value.to_s
+		end
+
+		def add_tuple(compound,tuple)
+			compound = self.find_or_create_compound compound unless compound.class == Redland::Resource
+			data_entry = @model.subject OT['compound'], compound
+			if data_entry.nil?
+				data_entry = @model.create_resource
+				@model.add data_entry, RDF['type'], OT["DataEntry"]
+				@model.add data_entry, OT['compound'], compound
+			end
+			@model.add data_entry, OT['values'], tuple
+		end
+
+		def create_tuple(feature,t)
+			feature = self.find_or_create_feature feature unless feature.class == Redland::Resource
+			tuple = @model.create_resource
+			@model.add tuple, RDF['type'], OT["Tuple"]
+			@model.add tuple, OT['feature'], feature
+			t.each do |name,value|
+				f = self.find_or_create_feature name unless name.class == Redland::Resource
+				complex_value = @model.create_resource
+				feature = self.find_or_create_feature(name) 
+				@model.add tuple, OT['complexValue'], complex_value
+				@model.add complex_value, RDF['type'], OT["FeatureValue"]
+				@model.add complex_value, OT['feature'], f
+				@model.add complex_value, OT['value'], value.to_s 
+			end
+			tuple
+		end
+
 		# find or create a new compound and return the resource
 		def find_or_create_compound(uri)
 			compound = @model.subject(DC["identifier"], uri)
@@ -21,74 +64,18 @@ module OpenTox
 		end
 
 		# find or create a new feature and return the resource
-		def find_or_create_feature(f)
-			feature = @model.subject(DC["title"], f[:name].to_s)
+		def find_or_create_feature(uri)
+			feature = @model.subject(DC["identifier"], uri)
 			if feature.nil?
 				feature = @model.create_resource
 				@model.add feature, RDF['type'], OT["Feature"]
-				@model.add feature, DC["identifier"], File.join("feature",feature.to_s.gsub(/[()]/,'')) # relative uri as we don know the final uri
-				@model.add feature, DC["title"], f[:name].to_s
-				@model.add feature, OT['hasSource'], f[:source].to_s if f[:source]
+				@model.add feature, DC["identifier"], uri
+				@model.add feature, DC["title"], File.basename(uri).split(/#/)[1]
+				@model.add feature, DC['source'], uri
 			end
 			feature
 		end
 
-		# find or create a new value and return the resource
-		def find_or_create_value(v)
-			value = @model.subject OT["value"], v.to_s
-			if value.nil?
-				value = @model.create_resource
-				@model.add value, RDF['type'], OT["FeatureValue"]
-				@model.add value, OT["value"], v.to_s
-			end
-			value
-		end
-
-		def tuple?(t)
-			statements = []
-			has_tuple = true
-			t.each do |name,v|
-				feature = self.find_or_create_feature(:name => name)
-				value = self.find_or_create_value(v)
-				tuple = @model.subject(feature,value)
-				has_tuple = false if tuple.nil?
-				statements << [tuple,feature,value]
-			end
-			tuples_found = statements.collect{|s| s[0]}.uniq
-			has_tuple = false unless tuples_found.size == 1
-			has_tuple
-		end
-
-		def create_tuple(t)
-			tuple = @model.create_resource
-			@model.add tuple, RDF['type'], OT["Tuple"]
-			t.each do |name,value|
-				feature = self.find_or_create_feature(:name => name)
-				value = self.find_or_create_value(value)
-				pair = @model.create_resource
-				@model.add tuple, OT['tuple'], pair
-				@model.add pair, OT['feature'], feature
-				@model.add pair, OT['value'], value
-			end
-			tuple
-		end
-
-		def find_or_create_tuple(t)
-			if self.tuple?(t)
-				t 
-			else
-				self.create_tuple(t)
-			end
-		end
-
-		def add_data_entry(compound,feature,value)
-			data_entry = @model.create_resource
-			@model.add data_entry, RDF['type'], OT["DataEntry"]
-			@model.add data_entry, OT['compound'], compound
-			@model.add data_entry, OT['feature'], feature
-			@model.add data_entry, OT['values'], value
-		end
-
 		def self.create(data, content_type = 'application/rdf+xml')
 			uri = RestClient.post @@config[:services]["opentox-dataset"], data, :content_type => content_type
 			dataset = Dataset.new
@@ -98,7 +85,7 @@ module OpenTox
 
 		def self.find(uri)
 			begin
-				RestClient.get uri # check if the resource is available
+				RestClient.get uri, :accept => 'application/rdf+xml' # check if the resource is available
 				dataset = Dataset.new
 				dataset.read uri.to_s
 				dataset
@@ -108,26 +95,61 @@ module OpenTox
 		end
 
 		def features
+			features = []
+			@model.subjects(RDF['type'], OT["Feature"]).each do |feature_node|
+				features << @model.object(feature_node,  DC["identifier"])#
+			end
+			features
+		end
+
+		def data
+			data = {}
+			@model.subjects(RDF['type'], OT['DataEntry']).each do |data_entry|
+				compound_node  = @model.object(data_entry, OT['compound'])
+				@model.find(compound_node, OT['identifier'],nil) {|s,p,o| puts o.to_s}
+				compound_uri = @model.object(compound_node, DC['identifier']).to_s
+				data[compound_uri] = [] unless data[compound_uri]
+				@model.find(data_entry, OT['values'], nil) do |s,p,values|
+					entry = {}
+					feature_node = @model.object values, OT['feature']
+					feature_uri = @model.object(feature_node, DC['identifier']).to_s
+					# TODO simple features
+					type = @model.object(values, RDF['type'])
+					if type == OT['FeatureValue']
+						#entry[feature_uri] = [] unless entry[feature_uri]
+						entry[feature_uri] = @model.object(values, OT['value']).to_s
+					elsif type == OT['Tuple']
+						entry[feature_uri] = {} unless entry[feature_uri]
+						@model.find(values, OT['complexValue'],nil) do |s,p,complex_value|
+							name_node = @model.object complex_value, OT['feature']
+							name = @model.object(name_node, DC['title']).to_s
+							value = @model.object(complex_value, OT['value']).to_s
+							entry[feature_uri][name] = value
+						end
+					end
+					data[compound_uri] << entry
+				end
+			end
+			data
 		end
 
-		def feature_values(uri)
+		def feature_values(feature_uri)
 			features = {}
-			feature = @model.subject(DC["identifier"],uri)
+			feature = @model.subject(DC["identifier"],feature_uri)
 			@model.subjects(RDF['type'], OT["Compound"]).each do |compound_node|
 				compound = @model.object(compound_node,  DC["identifier"]).to_s.sub(/^\[(.*)\]$/,'\1')
 				features[compound] = [] unless features[compound]
-				@model.subjects(OT['compound'], compound_node).each do |data_entry|
-					if feature == @model.object(data_entry, OT['feature'])
-						values_node = @model.object(data_entry, OT['values'])
-						@model.find(values_node, OT['value'], nil) do |s,p,value| 
-							case value.to_s
-							when "true"
-								features[compound] << true
-							when "false"
-								features[compound] << false
-							else
-								features[compound] << value.to_s
-							end
+				data_entry = @model.subject(OT['compound'], compound_node)
+				@model.find( data_entry, OT['values'], nil ) do |s,p,values|
+					if feature == @model.object(values, OT['feature'])
+						value = @model.object(values, OT['value'])
+						case value.to_s
+						when "true"
+							features[compound] << true
+						when "false"
+							features[compound] << false
+						else
+							features[compound] << value.to_s
 						end
 					end
 				end
@@ -135,6 +157,7 @@ module OpenTox
 			features
 		end
 
+=begin
 		def tuples
 			tuples = []
 			@model.subjects(RDF['type'], OT["Tuple"]).each do |t|
@@ -172,11 +195,12 @@ module OpenTox
 				#puts values_node
 			end
 		end
+=end
 
 		def compounds
 			compounds = []
 			@model.subjects(RDF['type'], OT["Compound"]).each do |compound_node|
-				compounds << @model.object(compound_node,  DC["identifier"])#.to_s.sub(/^\[(.*)\]$/,'\1')
+				compounds << @model.object(compound_node,  DC["identifier"]).to_s
 			end
 			compounds
 		end
@@ -190,60 +214,19 @@ module OpenTox
 			RestClient.post(@@config[:services]["opentox-dataset"], self.rdf, :content_type =>  "application/rdf+xml").to_s
 		end
 
+		def to_yaml
+			{
+				:uri => self.uri,
+				:opentox_class => self.owl_class,
+				:title => self.title,
+				:source => self.source,
+				:identifier => self.identifier,
+				:compounds => self.compounds.collect{|c| c.to_s.to_s.sub(/^\[(.*)\]$/,'\1')},
+				:features => self.features.collect{|f| f.to_s },
+				:data_entries => self.data_entries,
+			}.to_yaml
+		end
+
 	end
 
 end
-
-
-#		def tanimoto(dataset)
-#			RestClient.get(File.join(@uri,'tanimoto',dataset.path))
-#		end
-#
-#		def weighted_tanimoto(dataset)
-#			RestClient.get(File.join(@uri,'weighted_tanimoto',dataset.path))
-#		end
-=begin
-		def data_entries
-			data = {}
-			@model.subjects(RDF['type'], OT["Compound"]).each do |compound_node|
-				compound = @model.object(compound_node,  DC["identifier"]).to_s#.sub(/^\[(.*)\]$/,'\1')
-				#compound = OpenTox::Compound.new(:inchi => compound).smiles
-				data[compound] = [] unless data[compound]
-				#puts compound
-				@model.subjects(OT['compound'], compound_node).each do |data_entry|
-					feature_node = @model.object(data_entry, OT['feature'])
-					feature = @model.object(feature_node,  DC["identifier"]).to_s
-					values_node = @model.object(data_entry, OT['values'])
-					type = @model.object(values_node,RDF['type']).to_s
-					case type
-					when /FeatureValue/
-						@model.find(values_node, OT['value'], nil) do |s,p,value| 
-							case value.to_s
-							when "true"
-								data[compound] << {feature => true}
-							when "false"
-								data[compound] << {feature => false}
-							else
-								data[compound] << {feature => value.to_s}
-							end
-						end
-					when /Tuple/ # this is really slow
-						t = {}
-						@model.find(values_node, OT['tuple'], nil) do |s,p,tuple| 
-							@model.find(tuple, OT['feature'], nil) do |s,p,feature|
-								@name = @model.object(feature,DC['title']).to_s
-							end
-							@model.find(tuple, OT['value'], nil) do |s,p,value|
-								v = @model.object(value,OT['value']).to_s
-								t[@name] = v
-								#print @name + ": "
-								#puts v
-							end
-						end
-						data[compound] << t
-					end
-				end
-			end
-			data
-		end
-=end

data/lib/model.rb

@@ -1,16 +1,18 @@
 module OpenTox
 	module Model
+
 		class Lazar
 			include Owl
+
+			attr_accessor :dataset, :predictions
 			
 			# Create a new prediction model from a dataset
-			def initialize
-				super
-			end
-
-			def read_yaml(id,yaml)
-				@lazar = YAML.load yaml
-				self.identifier = File.join(@@config[:services]["opentox-model"],'lazar',id)
+			def initialize(yaml)
+				super()
+				id = File.basename(yaml,'.yaml')
+				# TODO Untyped Individual: http://localhost:4003/lazar/{id} ????
+				@lazar = YAML.load_file yaml
+				self.uri = File.join(@@config[:services]["opentox-model"],'lazar',id)
 				self.title = "lazar model for #{@lazar[:endpoint]}"
 				self.source = "http://github.com/helma/opentox-model"
 				self.parameters = {
@@ -18,19 +20,24 @@ module OpenTox
 					"Feature URI for dependent variable" => { :scope => "mandatory", :value => "feature_uri=#{@lazar[:endpoint]}" },
 					"Feature generation URI" => { :scope => "mandatory", :value => "feature_generation_uri=" } #TODO write to yaml
 				}
-				self.algorithm = File.join(@@config[:services]["opentox-model"],"lazar")
+				self.algorithm = File.join(@@config[:services]["opentox-algorithm"],"lazar")
 				self.trainingDataset = @lazar[:activity_dataset]
 				self.dependentVariables = @lazar[:endpoint]
-				self.predictedVariables = @lazar[:endpoint] + " lazar prediction"
+				self.independentVariables = "http://localhost:4002/fminer#BBRC_representative" # TODO read this from dataset
+				self.predictedVariables = @lazar[:endpoint] #+ " lazar prediction"
+				@dataset = OpenTox::Dataset.new
+				@predictions = {}
 			end
 
 			def self.find(uri)
+=begin
 				begin
 					YAML.load(RestClient.get uri)
 					Lazar.new uri
 				rescue
 					halt 404, "Model #{uri} not found."
 				end
+=end
 			end
 
 			def self.find_all
@@ -42,6 +49,65 @@ module OpenTox
 				RestClient.post(@uri, :compound_uri => compound.uri)
 			end
 
+			def database_activity?(compound_uri)
+				# find database activities
+				db_activities = @lazar[:activities][compound_uri]
+				if db_activities
+					c = @dataset.find_or_create_compound(compound_uri)
+					f = @dataset.find_or_create_feature(@lazar[:endpoint])
+					v = db_activities.join(',')
+					@dataset.add c,f,v
+					@predictions[compound_uri] = { @lazar[:endpoint] => {:measured_activities => db_activities}}
+					true
+				else
+					false
+				end
+			end
+
+			def classify(compound_uri)
+
+				compound = OpenTox::Compound.new(:uri => compound_uri)
+				compound_matches = compound.match @lazar[:features]
+
+				conf = 0.0
+				neighbors = []
+				classification = nil
+
+				@lazar[:fingerprints].each do |uri,matches|
+
+					sim = OpenTox::Algorithm::Similarity.weighted_tanimoto(compound_matches,matches,@lazar[:p_values])
+					if sim > 0.3
+						neighbors << uri
+						@lazar[:activities][uri].each do |act|
+							case act.to_s
+							when 'true'
+								conf += OpenTox::Utils.gauss(sim)
+							when 'false'
+								conf -= OpenTox::Utils.gauss(sim)
+							end
+						end
+					end
+				end
+
+				conf = conf/neighbors.size
+				if conf > 0.0
+					classification = true
+				elsif conf < 0.0
+					classification = false
+				end
+			
+				compound = @dataset.find_or_create_compound(compound_uri)
+				feature = @dataset.find_or_create_feature(@lazar[:endpoint])
+				tuple = @dataset.create_tuple(feature,{ 'lazar#classification' => classification, 'lazar#confidence' => conf})
+				@dataset.add_tuple compound,tuple
+				@predictions[compound_uri] = { @lazar[:endpoint] => { :lazar_prediction => {
+						:classification => classification,
+						:confidence => conf,
+						:neighbors => neighbors,
+						:features => compound_matches
+					} } }
+			end
+
 			def self.base_uri
 				@@config[:services]["opentox-model"]
 			end
@@ -54,50 +120,35 @@ module OpenTox
 				YAML.load(RestClient.get uri)[:endpoint]
 			end
 
-		end
-	end
-
-
-=begin
-	module Model 
-
-		class LazarClassification < OpenTox
-
-
-		end
-
-	end
-
-	module Prediction
-
-		module Classification
-
-			class Lazar < OpenTox
-
-				def initialize(params)
-					super(params[:uri])
-				end
-
-				def classification
-					YAML.load(RestClient.get(@uri))[:classification]
-				end
-
-				def confidence
-					YAML.load(RestClient.get(@uri))[:confidence]
-				end
+			def algorithm=(algorithm)
+				me = @model.subject(RDF['type'],OT[self.owl_class])
+				@model.add me, OT['algorithm'], Redland::Uri.new(algorithm) # untyped individual comes from this line, why??
+				@model.add Redland::Uri.new(algorithm), RDF['type'], OT['Algorithm']
+			end
 
-				def neighbors
-					RestClient.get @uri + '/neighbors' 
-				end
+			def trainingDataset=(trainingDataset)
+				me = @model.subject(RDF['type'],OT[self.owl_class])
+				@model.add me, OT['trainingDataset'], Redland::Uri.new(trainingDataset) # untyped individual comes from this line, why??
+				@model.add Redland::Uri.new(trainingDataset), RDF['type'], OT['Dataset']
+			end
 
-				def features
-					RestClient.get @uri + '/features' 
-				end
+			def dependentVariables=(dependentVariables)
+				me = @model.subject(RDF['type'],OT[self.owl_class])
+				@model.add me, OT['dependentVariables'], Redland::Uri.new(dependentVariables) # untyped individual comes from this line, why??
+				@model.add Redland::Uri.new(dependentVariables), RDF['type'], OT['Feature']
+			end
 
+			def independentVariables=(independentVariables)
+				me = @model.subject(RDF['type'],OT[self.owl_class])
+				@model.add me, OT['independentVariables'], Redland::Uri.new(independentVariables) # untyped individual comes from this line, why??
+				@model.add Redland::Uri.new(independentVariables), RDF['type'], OT['Feature']
 			end
 
+			def predictedVariables=(predictedVariables)
+				me = @model.subject(RDF['type'],OT[self.owl_class])
+				@model.add me, OT['predictedVariables'], Redland::Uri.new(predictedVariables) # untyped individual comes from this line, why??
+				@model.add Redland::Uri.new(predictedVariables), RDF['type'], OT['Feature']
+			end
 		end
-
 	end
-=end
 end