lazar 0.0.7 → 0.0.9

data/lib/bbrc.rb

@@ -1,165 +0,0 @@
-module OpenTox
-  module Algorithm
-    class Fminer
-      TABLE_OF_ELEMENTS = [
-"H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn", "Uut", "Fl", "Uup", "Lv", "Uus", "Uuo"]
-        
-      #
-      # Run bbrc algorithm on dataset
-      #
-      # @param [OpenTox::Dataset] training dataset
-      # @param [optional] parameters BBRC parameters, accepted parameters are
-      #   - min_frequency  Minimum frequency (default 5)
-      #   - feature_type Feature type, can be 'paths' or 'trees' (default "trees")
-      #   - backbone BBRC classes, pass 'false' to switch off mining for BBRC representatives. (default "true")
-      #   - min_chisq_significance Significance threshold (between 0 and 1)
-      #   - nr_hits Set to "true" to get hit count instead of presence
-      #   - get_target Set to "true" to obtain target variable as feature
-      # @return [OpenTox::Dataset] Fminer Dataset
-      def self.bbrc training_dataset, params={}
-
-        time = Time.now
-        bad_request_error "More than one prediction feature found in training_dataset #{training_dataset.id}" unless training_dataset.features.size == 1
-
-        prediction_feature = training_dataset.features.first
-        if params[:min_frequency]
-          minfreq = params[:min_frequency]
-        else
-          per_mil = 5 # value from latest version
-          per_mil = 8 # as suggested below
-          i = training_dataset.feature_ids.index prediction_feature.id
-          nr_labeled_cmpds = training_dataset.data_entries.select{|de| !de[i].nil?}.size
-          minfreq = per_mil * nr_labeled_cmpds.to_f / 1000.0 # AM sugg. 8-10 per mil for BBRC, 50 per mil for LAST
-          minfreq = 2 unless minfreq > 2
-          minfreq = minfreq.round
-        end
-
-        @bbrc ||= Bbrc::Bbrc.new
-        @bbrc.Reset
-        if prediction_feature.numeric 
-          @bbrc.SetRegression(true) # AM: DO NOT MOVE DOWN! Must happen before the other Set... operations!
-        else
-          bad_request_error "No accept values for "\
-                            "dataset '#{training_dataset.id}' and "\
-                            "feature '#{prediction_feature.id}'" unless prediction_feature.accept_values
-          value2act = Hash[[*prediction_feature.accept_values.map.with_index]]
-        end
-        @bbrc.SetMinfreq(minfreq)
-        @bbrc.SetType(1) if params[:feature_type] == "paths"
-        @bbrc.SetBackbone(false) if params[:backbone] == "false"
-        @bbrc.SetChisqSig(params[:min_chisq_significance].to_f) if params[:min_chisq_significance]
-        @bbrc.SetConsoleOut(false)
-
-        params[:nr_hits] ? nr_hits = params[:nr_hits] : nr_hits = false
-        feature_dataset = FminerDataset.new(
-            :training_dataset_id => training_dataset.id,
-            :training_algorithm => "#{self.to_s}.bbrc",
-            :training_feature_id => prediction_feature.id ,
-            :training_parameters => {
-              :min_frequency => minfreq,
-              :nr_hits => nr_hits,
-              :backbone => (params[:backbone] == false ? false : true) 
-            }
-
-        )
-        feature_dataset.compounds = training_dataset.compounds
-
-        # add data 
-        training_dataset.compounds.each_with_index do |compound,i|
-          act = value2act[training_dataset.data_entries[i].first]
-          if act # TODO check if this works
-            @bbrc.AddCompound(compound.smiles,i+1)
-            @bbrc.AddActivity(act,i+1)
-          end
-        end
-        #g_median=@fminer.all_activities.values.to_scale.median
-
-        #task.progress 10
-        #step_width = 80 / @bbrc.GetNoRootNodes().to_f
-
-        $logger.debug "BBRC setup: #{Time.now-time}"
-        time = Time.now
-        ftime = 0
-        itime = 0
-        rtime = 0
-  
-        # run @bbrc
-        (0 .. @bbrc.GetNoRootNodes()-1).each do |j|
-          results = @bbrc.MineRoot(j)
-          results.each do |result|
-            rt = Time.now
-            f = YAML.load(result)[0]
-            smarts = f.shift
-            # convert fminer SMARTS representation into a more human readable format
-            smarts.gsub!(%r{\[#(\d+)&(\w)\]}) do
-             element = TABLE_OF_ELEMENTS[$1.to_i-1]
-             $2 == "a" ? element.downcase : element
-            end
-            p_value = f.shift
-            f.flatten!
-            compound_idxs = f.collect{|e| e.first.first-1}
-            # majority class
-            effect = compound_idxs.collect{|i| training_dataset.data_entries[i].first}.mode
-  
-=begin
-            if (!@bbrc.GetRegression)
-              id_arrs = f[2..-1].flatten
-              max = OpenTox::Algorithm::Fminer.effect(f[2..-1].reverse, @fminer.db_class_sizes) # f needs reversal for bbrc
-              effect = max+1
-            else #regression part
-              id_arrs = f[2]
-              # DV: effect calculation
-              f_arr=Array.new
-              f[2].each do |id|
-                id=id.keys[0] # extract id from hit count hash
-                f_arr.push(@fminer.all_activities[id])
-              end
-              f_median=f_arr.to_scale.median
-              if g_median >= f_median
-                effect = 'activating'
-              else
-                effect = 'deactivating'
-              end
-            end
-=end
-            rtime += Time.now - rt
-  
-            ft = Time.now
-            feature = OpenTox::FminerSmarts.find_or_create_by({
-              "smarts" => smarts,
-              "p_value" => p_value.to_f.abs.round(5),
-              "effect" => effect,
-              "dataset_id" => feature_dataset.id
-            })
-            feature_dataset.feature_ids << feature.id
-            ftime += Time.now - ft
-
-            it = Time.now
-            f.each do |id_count_hash|
-              id_count_hash.each do |id,count|
-                nr_hits ? count = count.to_i : count = 1
-                feature_dataset.data_entries[id-1] ||= []
-                feature_dataset.data_entries[id-1][feature_dataset.feature_ids.size-1] = count
-              end
-            end
-            itime += Time.now - it
-  
-          end
-        end
-
-        $logger.debug "Fminer: #{Time.now-time} (read: #{rtime}, iterate: #{itime}, find/create Features: #{ftime})"
-        time = Time.now
-
-        feature_dataset.fill_nil_with 0
-
-        $logger.debug "Prepare save: #{Time.now-time}"
-        time = Time.now
-        feature_dataset.save_all
-
-        $logger.debug "Save: #{Time.now-time}"
-        feature_dataset
-  
-      end
-    end
-  end
-end

data/lib/descriptor.rb

@@ -1,247 +0,0 @@
-require 'digest/md5'
-ENV["JAVA_HOME"] ||= "/usr/lib/jvm/java-7-openjdk" 
-# TODO store descriptors in mongodb
-
-module OpenTox
-
-  module Algorithm 
-    
-    # Class for descriptor calculations
-    class Descriptor 
-      include OpenTox
-
-      JAVA_DIR = File.join(File.dirname(__FILE__),"..","java")
-      CDK_JAR = Dir[File.join(JAVA_DIR,"cdk-*jar")].last
-      JOELIB_JAR = File.join(JAVA_DIR,"joelib2.jar")
-      LOG4J_JAR = File.join(JAVA_DIR,"log4j.jar")
-      JMOL_JAR = File.join(JAVA_DIR,"Jmol.jar")
-
-      obexclude = ["cansmi","cansmiNS","formula","InChI","InChIKey","s","smarts","title"]
-      OBDESCRIPTORS = 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]}]
-
-      cdk_desc = YAML.load(`java -classpath #{CDK_JAR}:#{JAVA_DIR}  CdkDescriptorInfo`)
-      CDKDESCRIPTORS = Hash[cdk_desc.collect { |d| ["Cdk."+d[:java_class].split('.').last.sub(/Descriptor/,''), d[:description]] }.sort{|a,b| a[0] <=> b[0]}]
-      CDKDESCRIPTOR_VALUES = cdk_desc.collect { |d| prefix="Cdk."+d[:java_class].split('.').last.sub(/Descriptor/,''); d[:names].collect{ |name| prefix+"."+name } }.flatten
-
-      # 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|
-        name = d[:java_class].sub(/^joelib2.feature.types./,'')
-        # impossible to obtain meaningful descriptions from JOELIb, see java/JoelibDescriptors.java
-        ["Joelib."+name, "no description available"] unless joelibexclude.include? name
-      end.compact.sort{|a,b| a[0] <=> b[0]}] 
-
-      DESCRIPTORS = OBDESCRIPTORS.merge(CDKDESCRIPTORS.merge(JOELIBDESCRIPTORS))
-      DESCRIPTOR_VALUES = OBDESCRIPTORS.keys + CDKDESCRIPTOR_VALUES + JOELIBDESCRIPTORS.keys
-
-      require_relative "unique_descriptors.rb"
-
-      # Description of available descriptors
-      def self.description descriptor
-        lib = descriptor.split('.').first
-        case lib
-        when "Openbabel"
-          OBDESCRIPTORS[descriptor]
-        when "Cdk"
-          name = descriptor.split('.')[0..-2].join('.')
-          CDKDESCRIPTORS[name]
-        when "Joelib"
-          JOELIBDESCRIPTORS[descriptor]
-        when "lookup"
-          "Read feature values from a dataset"
-        end
-      end
-
-      # Match an array of smarts features 
-      def self.smarts_match compounds, smarts_features, count=false
-        bad_request_error "Compounds for smarts_match are empty" unless compounds
-        bad_request_error "Smarts features for smarts_match are empty" unless smarts_features
-        parse compounds
-        @count = count
-        obconversion = OpenBabel::OBConversion.new
-        obmol = OpenBabel::OBMol.new
-        obconversion.set_in_format('smi')
-        smarts_pattern = OpenBabel::OBSmartsPattern.new
-        smarts_features = [smarts_features] if smarts_features.is_a?(Feature)
-        @smarts = smarts_features.collect{|f| f.smarts}
-        @physchem_descriptors = nil
-        @data_entries = Array.new(@compounds.size){Array.new(@smarts.size,false)}
-        @compounds.each_with_index do |compound,c|
-          obconversion.read_string(obmol,compound.smiles)
-          @smarts.each_with_index do |smart,s|
-            smarts_pattern.init(smart)
-            if smarts_pattern.match(obmol)
-              count ? value = smarts_pattern.get_map_list.to_a.size : value = 1
-            else
-              value = 0 
-            end
-            @data_entries[c][s] = value
-          end
-        end
-        serialize 
-      end
-
-      # Count matches of an array with smarts features 
-      def self.smarts_count compounds, smarts
-        # TODO: non-overlapping matches?
-        smarts_match compounds,smarts,true
-      end
-
-      # Calculate physchem descriptors
-      # @param [OpenTox::Compound,Array,OpenTox::Dataset] input object, either a compound, an array of compounds or a dataset
-      def self.physchem compounds, descriptors=UNIQUEDESCRIPTORS
-        parse compounds
-        @data_entries = Array.new(@compounds.size){[]}
-        @descriptors = descriptors
-        @smarts = nil
-        @physchem_descriptors = [] # CDK may return more than one result per descriptor, they are stored as separate features
-        des = {}
-        @descriptors.each do |d|
-          lib, descriptor = d.split(".",2)
-          lib = lib.downcase.to_sym
-          des[lib] ||= []
-          des[lib] << descriptor
-        end
-        des.each do |lib,descriptors|
-          send(lib, descriptors)
-        end
-        serialize
-      end
-
-      def self.openbabel descriptors
-        $logger.debug "compute #{descriptors.size} openbabel descriptors for #{@compounds.size} compounds"
-        obdescriptors = descriptors.collect{|d| OpenBabel::OBDescriptor.find_type d}
-        obmol = OpenBabel::OBMol.new
-        obconversion = OpenBabel::OBConversion.new
-        obconversion.set_in_format 'smi'
-        last_feature_idx = @physchem_descriptors.size
-        @compounds.each_with_index do |compound,c|
-          obconversion.read_string obmol, compound.smiles
-          obdescriptors.each_with_index do |descriptor,d|
-            @data_entries[c][d+last_feature_idx] = fix_value(descriptor.predict(obmol))
-          end
-        end
-        @physchem_descriptors += descriptors.collect{|d| "Openbabel.#{d}"}
-      end
-
-      def self.java_descriptors descriptors, lib
-        $logger.debug "compute #{descriptors.size} cdk descriptors for #{@compounds.size} compounds"
-        sdf = sdf_3d 
-        # use java system call (rjb blocks within tasks)
-        # use Tempfiles to avoid "Argument list too long" error 
-        case lib
-        when "cdk"
-          run_cmd "java -classpath #{CDK_JAR}:#{JAVA_DIR}  CdkDescriptors #{sdf} #{descriptors.join(" ")}"
-        when "joelib"
-          run_cmd "java -classpath #{JOELIB_JAR}:#{JMOL_JAR}:#{LOG4J_JAR}:#{JAVA_DIR}  JoelibDescriptors  #{sdf} #{descriptors.join(' ')}"
-        end
-        last_feature_idx = @physchem_descriptors.size
-        YAML.load_file("#{sdf}#{lib}.yaml").each_with_index do |calculation,i|
-          # TODO create warnings
-          #$logger.error "Descriptor calculation failed for compound #{@compounds[i].inchi}." if calculation.empty?
-          # CDK Descriptors may calculate multiple values, they are stored in separate features
-          @physchem_descriptors += calculation.keys if i == 0
-          calculation.keys.each_with_index do |name,j|
-            @data_entries[i][j+last_feature_idx] = fix_value(calculation[name])
-          end
-        end
-        FileUtils.rm "#{sdf}#{lib}.yaml"
-      end
-
-      def self.cdk descriptors
-        java_descriptors descriptors, "cdk"
-      end
-
-      def self.joelib descriptors
-        java_descriptors descriptors, "joelib"
-      end
-
-      def self.lookup compounds, features, dataset
-        parse compounds
-        fingerprint = []
-        compounds.each do |compound|
-          fingerprint << []
-          features.each do |feature|
-          end
-        end
-      end
-
-      def self.run_cmd cmd
-        cmd = "#{cmd} 2>&1"
-        $logger.debug "running external cmd: '#{cmd}'"
-        p = IO.popen(cmd) do |io|
-          while line = io.gets
-            $logger.debug "> #{line.chomp}"
-          end
-          io.close
-          raise "external cmd failed '#{cmd}' (see log file for error msg)" unless $?.to_i == 0
-        end
-      end
-
-      def self.sdf_3d 
-        # TODO check if 3d sdfs are stored in GridFS
-        sdf = ""
-        @compounds.each do |compound|
-          sdf << compound.sdf
-        end
-        sdf_file = "/tmp/#{SecureRandom.uuid}.sdf"
-        File.open(sdf_file,"w+"){|f| f.print sdf}
-        sdf_file
-      end
-
-      def self.parse compounds
-        @input_class = compounds.class.to_s
-        case @input_class
-        when "OpenTox::Compound"
-          @compounds = [compounds]
-        when "Array"
-          @compounds = compounds
-        when "OpenTox::Dataset"
-          @compounds = compounds.compounds
-        else
-          bad_request_error "Cannot calculate descriptors for #{compounds.class} objects."
-        end
-      end
-
-      def self.serialize
-        @data_entries.collect!{|de| de.collect{|v| v.round(5) unless v.nil?}}
-        case @input_class
-        when "OpenTox::Compound"
-          @data_entries.first
-        when "Array"
-          @data_entries
-        when "OpenTox::Dataset"
-          dataset = OpenTox::DescriptorDataset.new(:compound_ids => @compounds.collect{|c| c.id})
-          if @smarts
-            dataset.feature_ids = @smarts.collect{|smart| Smarts.find_or_create_by(:smarts => smart).id}
-            @count ? algo = "count" : algo = "match"
-            dataset.feature_calculation_algorithm = "#{self}.smarts_#{algo}"
-            
-          elsif @physchem_descriptors
-            dataset.feature_ids = @physchem_descriptors.collect{|d| PhysChemDescriptor.find_or_create_by(:name => d, :creator => __FILE__).id}
-            dataset.data_entries = @data_entries
-            dataset.feature_calculation_algorithm = "#{self}.physchem"
-            #TODO params?
-          end
-          dataset.save_all
-          dataset
-        end
-      end
-
-      def self.fix_value val
-        val = val.first if val.is_a? Array and val.size == 1
-        val = nil if val == "NaN"
-        if val.numeric?
-          val = Float(val)
-          val = nil if val.nan? or val.infinite?
-        end
-        val
-      end
-      private_class_method :sdf_3d, :fix_value, :parse, :run_cmd, :serialize
-    end
-  end
-end

data/lib/neighbor.rb

@@ -1,25 +0,0 @@
-module OpenTox
-  module Algorithm
-    class Neighbor
-
-      def self.fingerprint_similarity compound, params={}
-        compound.neighbors params[:min_sim]
-      end
-
-      def self.fminer_similarity compound, params
-        feature_dataset = Dataset.find params[:feature_dataset_id]
-        query_fingerprint = Algorithm::Descriptor.smarts_match(compound, feature_dataset.features)
-        neighbors = []
-
-        # find neighbors
-        feature_dataset.data_entries.each_with_index do |fingerprint, i|
-          sim = Algorithm::Similarity.tanimoto fingerprint, query_fingerprint
-          if sim > params[:min_sim]
-            neighbors << [feature_dataset.compound_ids[i],sim] # use compound_ids, instantiation of Compounds is too time consuming
-          end
-        end
-        neighbors
-      end
-    end
-  end
-end

data/lib/similarity.rb

@@ -1,58 +0,0 @@
-=begin
-* Name: similarity.rb
-* Description: Similarity algorithms
-* Author: Andreas Maunz <andreas@maunz.de
-* Date: 10/2012
-=end
-
-module OpenTox
-  module Algorithm
-
-    class Similarity
-
-      #TODO weighted tanimoto
-
-      # Tanimoto similarity
-      # @param [Array] a fingerprints of first compound
-      # @param [Array] b fingerprints of second compound
-      # @return [Float] Tanimoto similarity
-      def self.tanimoto(a,b)
-        bad_request_error "fingerprints #{a} and #{b} don't have equal size" unless a.size == b.size
-        #common = 0.0
-        #a.each_with_index do |n,i|
-          #common += 1 if n == b[i]
-        #end
-        #common/a.size
-        # TODO check if calculation speed can be improved
-        common_p_sum = 0.0
-        all_p_sum = 0.0
-        (0...a.size).each { |idx|
-          common_p_sum += [ a[idx], b[idx] ].min
-          all_p_sum += [ a[idx], b[idx] ].max
-        }
-        common_p_sum/all_p_sum
-      end
-
-
-      # Cosine similarity
-      # @param [Array] a fingerprints of first compound
-      # @param [Array] b fingerprints of second compound
-      # @return [Float] Cosine similarity, the cosine of angle enclosed between vectors a and b
-      def self.cosine(a, b)
-        val = 0.0
-        if a.size>0 and b.size>0
-          if a.size>12 && b.size>12
-            a = a[0..11]
-            b = b[0..11]
-          end
-          a_vec = a.to_gv
-          b_vec = b.to_gv
-          val = a_vec.dot(b_vec) / (a_vec.norm * b_vec.norm)
-        end
-        val
-      end
-
-    end
-
-  end
-end

data/mongoid.yml

@@ -1,8 +0,0 @@
-development:
-  clients:
-    default:
-      database: opentox
-      hosts:
-        - localhost:27017
-      options:
-        raise_not_found_error: false

data/test/descriptor-long.rb

@@ -1,26 +0,0 @@
-require_relative "setup.rb"
-class DescriptorLongTest < MiniTest::Test
-
-  def test_dataset_all
-    # TODO: improve CDK descriptor calculation speed or add timeout
-    skip "CDK descriptor calculation takes too long for some compounds"
-    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.mini.csv")
-    d = OpenTox::Algorithm::Descriptor.physchem dataset
-    assert_equal dataset.compounds, d.compounds
-    assert_equal 332, d.features.size
-    assert_equal 332, d.data_entries.first.size
-    d.delete
-  end
-
-  def test_dataset_openbabel
-    # TODO: improve CDK descriptor calculation speed or add timeout
-    dataset = Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.mini.csv")
-    d = Algorithm::Descriptor.physchem dataset, Algorithm::Descriptor::OBDESCRIPTORS.keys
-    assert_equal dataset.compounds, d.compounds
-    size = Algorithm::Descriptor::OBDESCRIPTORS.keys.size
-    assert_equal size, d.features.size
-    assert_equal size, d.data_entries.first.size
-    d.delete
-  end
-
-end

data/test/fminer-long.rb

@@ -1,38 +0,0 @@
-require_relative "setup.rb"
-
-class FminerTest < MiniTest::Test
-
-  def test_fminer_multicell
-    #skip "multicell segfaults"
-    # TODO aborts, probably fminer
-    # or OpenBabel segfault
-    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"multi_cell_call.csv")
-    feature_dataset = OpenTox::Algorithm::Fminer.bbrc(dataset)#, :min_frequency => 15)
-    p feature_dataset.training_parameters
-    assert_equal dataset.compound_ids, feature_dataset.compound_ids
-    dataset.delete
-    feature_dataset.delete
-  end
-
-  def test_fminer_isscan
-    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"ISSCAN-multi.csv")
-    feature_dataset = OpenTox::Algorithm::Fminer.bbrc(dataset)#, :min_frequency => 15)
-    assert_equal feature_dataset.compounds.size, dataset.compounds.size
-    p feature_dataset.features.size
-    p feature_dataset.training_parameters
-    dataset.delete
-    feature_dataset.delete
-  end
-
-  def test_fminer_kazius
-    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"kazius.csv")
-    # TODO reactivate default settings
-    feature_dataset = OpenTox::Algorithm::Fminer.bbrc(dataset, :min_frequency => 20)
-    assert_equal feature_dataset.compounds.size, dataset.compounds.size
-    feature_dataset = Dataset.find feature_dataset.id
-    assert feature_dataset.data_entries.size, dataset.compounds.size
-    dataset.delete
-    feature_dataset.delete
-  end
-
-end

data/test/fminer.rb

@@ -1,52 +0,0 @@
-require_relative "setup.rb"
-
-class FminerTest < MiniTest::Test
-
-  def test_fminer_bbrc
-    dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.csv")
-    refute_nil dataset.id
-    feature_dataset = OpenTox::Algorithm::Fminer.bbrc dataset
-    feature_dataset = Dataset.find feature_dataset.id
-    assert_equal dataset.compounds.size, feature_dataset.compounds.size
-    # TODO: fminer calculates 62 instead of 54 features
-    # it is unclear which commit changed the numbers (occurs with old libraries/mongodb branch too
-    # modification of Compound to use smiles instead of inchis seems to have no effect
-    #assert_equal 54, feature_dataset.features.size
-    #assert_equal "C-C-C=C", feature_dataset.features.first.smarts
-    compounds = feature_dataset.compounds
-    smarts = feature_dataset.features
-    smarts.each do |smart|
-      assert smart.p_value.round(2) >= 0.95
-    end
-    match = OpenTox::Algorithm::Descriptor.smarts_match compounds, smarts
-    feature_dataset.data_entries.each_with_index do |fingerprint,i|
-      assert_equal match[i], fingerprint
-    end
-
-    dataset.delete
-    feature_dataset.delete
-  end
-
-  def test_fminer_last
-    skip "last features have to be activated"
-    dataset = OpenTox::Dataset.new
-    dataset.upload File.join(DATA_DIR,"hamster_carcinogenicity.csv")
-    feature_dataset = OpenTox::Algorithm::Fminer.last :dataset => dataset
-    assert_equal dataset.compounds.size, feature_dataset.compounds.size
-    assert_equal 21, feature_dataset.features.size
-    assert_equal '[#6&A]-[#6&a]:[#6&a]:[#6&a]:[#6&a]:[#6&a]', feature_dataset.features.first.smarts
-
-    compounds = feature_dataset.compounds
-    smarts = feature_dataset.features.collect{|f| f.smarts}
-    match = OpenTox::Algorithm::Descriptor.smarts_match compounds, smarts
-    compounds.each_with_index do |c,i|
-      smarts.each_with_index do |s,j|
-        assert_equal match[i][j], feature_dataset.data_entries[i][j].to_i
-      end
-    end
-
-    dataset.delete
-    feature_dataset.delete
-  end
-
-end

data/test/lazar-fminer.rb

@@ -1,50 +0,0 @@
-require_relative "setup.rb"
-
-class LazarFminerTest < MiniTest::Test
-
-  def test_lazar_fminer
-    training_dataset = Dataset.from_csv_file File.join(DATA_DIR,"hamster_carcinogenicity.csv")
-    model = Model::LazarFminerClassification.create training_dataset#, feature_dataset
-    feature_dataset = Dataset.find model.neighbor_algorithm_parameters[:feature_dataset_id]
-    assert_equal training_dataset.compounds.size, feature_dataset.compounds.size
-    #TODO check fminer features, see fminer.rb
-    #assert_equal 54, feature_dataset.features.size
-    feature_dataset.data_entries.each do |e|
-      assert_equal e.size, feature_dataset.features.size
-    end
-    #assert_equal 'C-C-C=C', feature_dataset.features.first.smarts
-
-    [ {
-      :compound => OpenTox::Compound.from_inchi("InChI=1S/C6H6/c1-2-4-6-5-3-1/h1-6H"),
-      :prediction => "false",
-      :confidence => 0.25281385281385277,
-      :nr_neighbors => 11
-    },{
-      :compound => OpenTox::Compound.from_smiles("c1ccccc1NN"),
-      :prediction => "false",
-      :confidence => 0.3639589577089577,
-      :nr_neighbors => 14
-    }, {
-      :compound => Compound.from_smiles('OCCCCCCCC\C=C/CCCCCCCC'),
-      :prediction => "false",
-      :confidence => 0.5555555555555556,
-      :nr_neighbors => 1
-    }].each do |example|
-      prediction = model.predict example[:compound]
-
-      assert_equal example[:prediction], prediction[:value]
-      #assert_equal example[:confidence], prediction[:confidence]
-      #assert_equal example[:nr_neighbors], prediction[:neighbors].size
-    end
-
-    # make a dataset prediction
-    compound_dataset = OpenTox::Dataset.from_csv_file File.join(DATA_DIR,"EPAFHM.mini.csv")
-    prediction = model.predict compound_dataset
-    assert_equal compound_dataset.compounds, prediction.compounds
-
-    assert_equal "Cound not find similar compounds.", prediction.data_entries[7][2]
-    assert_equal "measured", prediction.data_entries[14][1]
-    # cleanup
-    [training_dataset,model,feature_dataset,compound_dataset].each{|o| o.delete}
-  end
-end