mspire 0.4.9 → 0.5.0

data/lib/validator/prot_from_pep.rb

@@ -1,234 +0,0 @@
-require 'validator'
-
-require 'set'
-require 'group_by'
-require 'shuffle'
-
-# calculates protein hit precision based on peptide precision
-class Validator::ProtFromPep < Validator
-
-  # calculate protein precision based on the number of false peptides
-  # returns the precision based on the number of proteins *completely false*
-  # calculates the worst precision by assuming that proteins with the fewest
-  # peptides are all false (before prots with more pephits)
-  # note that this approaches the worst, but is not guaranteed to be worst
-  # unless each pephit maps to a single protein hit.
-  # [worst, normal_mean, normal_stddev]
-  # options
-  #    :num_its_normal => Integer, # num iterations for normal (d: 10)
-  #    :num_its_worstcase => Integer, # num iterations for worstcase (d: 10)
-  #
-  def prothit_precision(peps, num_false_pephits, opts={})
-    opts[:num_its_normal] ||= 10
-    opts[:num_its_worstcase] ||= 10
-    # get the num_peps_per_protein array
-    worst = worstcase_prothit_precision(peps, num_false_pephits, :num_its => opts[:num_its_worstcase])
-    (normal_mean, normal_stdev) = normal_prothit_precision( peps, num_false_pephits, :num_its => opts[:num_its_normal])
-    [worst, normal_mean, normal_stdev]
-  end
-
-  # returns an array of the number of peptide hits in each protein
-  def num_peps_per_protein(peps)
-    num_pephits_by_prot = Hash.new { 0 }
-    peps.each do |pep|
-      pep.prots.each do |prot|
-        num_pephits_by_prot[prot.reference] += 1
-      end
-    end
-    num_pephits_by_prot.values
-  end
-
-  # returns the worstcase precision.  This assumes that every small protein
-  # with the fewest peptide hits is completely 'filled' with incorrect hits in
-  # preference to any higher hit protein.  
-  # Where each peptide hit maps to a single protein, this is guaranteed to be
-  # worst-case.  If this doesn't hold, there are some extreme cases where a
-  # poorer precision could be generated, but this is still probably fairly
-  # close.  Thus, a slightly different answer may be generated each time.
-  # ...variation is produced by shuffling the order of the proteins from which
-  # peptides are removed within groups of proteins having the same number of
-  # peptides.
-  # This method does NOT require that the prothits be updated to reflect only
-  # those pephits being passed in.
-  #
-  #   validator.worstcase_prothit_precision(peps, 14, 1) # => 0.232111
-  #
-  # options:
-  #   :num_its => Integer (default: 10) number of times to run (finds minimum)
-  #   :one_prot_per_pep => true | *false   assumes each peptide maps to a
-  #                                        single protein
-  def worstcase_prothit_precision(peps, num_false_pephits, opts = {})
-    num_its = opts[:num_its] || 10
-    one_prot_per_pep = opts[:one_prot_per_pep]  # nil or false still == false
-    one_prot_per_pep = false if one_prot_per_pep == nil
-    
-
-    ##############################################
-    # The END Cases (can be dealt with quickly)
-    ##############################################
-    if num_false_pephits == 0
-      return 1.0
-    elsif num_false_pephits >=  peps.size
-      return 0.0
-    end
-
-    if one_prot_per_pep
-      num_peps_per_prot = num_peps_per_protein(peps)
-      return worstcase_prothit_precision_by_numbers(num_peps_per_prot, num_false_pephits)
-    else
-      #####################################
-      # HERE's the basic plan!!
-      #####################################
-      # order the proteins by num peptides
-      # create a set of peptides
-      # delete peptides from the proteins off the set o' peptides (ensuring that
-      # a deleted one cannot be deleted twice)
-
-      #####################################
-      # order the proteins by num peptides
-      # and create a hash that holds the peptides (given here) in those proteins
-      prots_to_peps_here = Hash.new {|h,k| h[k] = [] }
-      prots_to_peps_size = Hash.new { 0 }
-      pep_ids = []
-      pep_ids_to_prot_ids = Hash.new {|h,k| h[k] = [] }
-      peps.each do |pep|
-        #puts pep.prots.size
-        pep.prots.each do |prot|
-          #p prot.reference
-          prots_to_peps_here[prot] << pep
-          prots_to_peps_size[prot] += 1
-          pep_ids << pep
-          pep_ids_to_prot_ids[pep] << prot
-        end
-      end
-      prot_ids_listed_by_peps_size = prots_to_peps_size.keys
-      tot_num_prots = prot_ids_listed_by_peps_size.size
-
-      sample = Array.new(num_its)
-
-      srand( 777 )
-      precision_sample = (0...num_its).to_a.map do
-        num_false_pephits_counter = num_false_pephits
-        # create a set of peptides
-        pep_ids_set = pep_ids.to_set
-        # shuffle the proteins within size groups
-        finished = false
-        prot_ids_listed_by_peps_size.group_by {|prot_id| prots_to_peps_size[prot_id] }.sort.each do |k,group_of_proteins_with_same_pep_size|
-          group_of_proteins_with_same_pep_size.shuffle!
-          group_of_proteins_with_same_pep_size.each do |prot_id|
-            prots_to_peps_here[prot_id].each do |pep_id|
-              if pep_ids_set.include?(pep_id)  # if 1
-                # remove a peptide
-                pep_ids_set.delete(pep_id)
-                num_false_pephits_counter -= 1
-                if num_false_pephits_counter == 0  # if 2
-                  finished = true
-                end                                # close if 2
-              end                                  # close if 1
-              break if finished  # each pep
-            end
-            break if finished  # each prot
-          end
-          break if finished  # each group_of_proteins_with_same_pep_size
-        end # each group_of_proteins_with_same_pep_size
-        ## Figure out the number of proteins left!
-        proteins_still_around = pep_ids_set.inject(Set.new) {|protset,pep_id| protset.merge( pep_ids_to_prot_ids[pep_id]) }
-
-        proteins_still_around.size.to_f / tot_num_prots
-      end # a sample
-      return precision_sample.min
-    end # FINAL else
-  end
-
-  # returns the precision of the worst possible outcome
-  def worstcase_prothit_precision_by_numbers(num_peps_per_prot, num_false_pephits)
-    completely_false_proteins = 0
-    num_peps_per_prot.sort.each do |num_peps|
-      num_false_pephits -= num_peps
-      if num_false_pephits >= 0
-        completely_false_proteins += 1
-      end
-      if num_false_pephits <= 0
-        break
-      end
-    end
-    num_prots = num_peps_per_prot.size
-    (num_prots - completely_false_proteins).to_f/num_prots
-  end
-
-  # normal as in a standard normal distribution of peptide hits per protein
-  # they are distributed randomly and the precision is assumed to take on a
-  # standard normal distribution.
-  # num_peps_per_protein is an array of the number of peptides per protein hit
-  # (these are the true hits)
-  # assumes that the number follows a gaussian distribution (binomial
-  # distributions tend toward gaussians, I believe, at large N)
-  # returns [mean_precision, stdev_precision]
-  # options:
-  #   :num_its => Integer (default: 10)
-  #
-  # if num_iterations is set at 1, then only the precision will be returned
-  # though random, the same seed is always used to start this process, meaning
-  # that the same results will be produced on consecutive attempts.
-  #
-  #   validator.normal_prothit_precision(peps, 13, :num_its => 1) # -> 0.95433
-  #   validator.normal_prothit_precision(peps, 13, :num_its => 2) # -> [0.92002, 1.2223]
-  def normal_prothit_precision( peps, num_false_pephits, opts={})
-    num_iterations = opts[:num_its] || 10
-    srand( 38272 )
-
-    ##############################################
-    # The END Cases (can be dealt with quickly)
-    ##############################################
-    if num_false_pephits == 0
-      if num_iterations == 1
-        return 1.0
-      else
-        return [1.0, 0.0] 
-      end
-    elsif num_false_pephits >=  peps.size
-      if num_iterations == 1
-        return 0.0
-      else
-        return [0.0, 0.0]
-      end
-    end
-
-    ##############################################
-    # Everything else:
-    ##############################################
-
-    sample = Array.new(num_iterations)
-    base_indices = (0...(peps.size)).to_a
-    ### ACUTALLY, I THINK WE WANT TO CREATE AND MERGE!!!!
-    # This would mean that only a single hit would validate the protein
-    # if we are subtracting, then we lose the protein on a single peptide!!!!
-    prot_id_set = peps.inject(Set.new) do |prtset, pep|
-      prtset.merge( pep.prots.map {|prot| prot } )
-    end
-
-    tot_num_prots = prot_id_set.size
-    # could also merge off the good indices
-    # TODO: we should optimize based on how many false pephits given...
-    
-    precision_sample = (0...num_iterations).to_a.map do
-      shuffled_indices = base_indices.map
-      shuffled_indices.shuffle!
-      good_indices = shuffled_indices[num_false_pephits..-1] 
-      still_remaining = Set.new
-      
-      peps.values_at(*good_indices).each do |pep| 
-        still_remaining.merge(pep.prots.map {|prot| prot })
-      end
-      still_remaining.size.to_f / tot_num_prots
-    end
-    if num_iterations == 1
-      precision_sample.shift
-    else
-      #puts "PRECISION GROUP: "
-      #p precision_sample
-      sample_stats(precision_sample)
-    end
-  end
-end
-

data/lib/validator/q_value.rb

@@ -1,32 +0,0 @@
-
-
-# from percolator
-# This is a trivial class (since q-values are so straightforward with regards
-# to precision), but it allows us to work with q-values using the same
-# interface as all other validators
-class Validator::QValue
-
-  # objs should respond_to :q_value
-  # q-values: 0.0 means no false discoveries, 0.5 means 50% false discoveries
-  # 1 - (the largest q value) is the precision
-  def precision(objs)
-    return 1.0 if objs.size == 0
-    largest_q_value = objs.map {|v| v.q_value }.max
-    prec = 1.0 - largest_q_value
-  end
-
-
-  # objs should respond_to :q_value
-  # These should be added from low q-value to high q-value
-  # The last q-value added determines the precision
-  def increment_precision(objs)
-    if objs.is_a?(SpecID::Pep) or objs.is_a?(SpecID::Prot)
-      objs = [objs]
-    end
-    precision(objs)
-  end
-
-  alias_method :pephit_precision, :precision
-  alias_method :prothit_precision, :precision
-  alias_method :increment_pephits_precision, :increment_precision
-end

data/lib/validator/transmem.rb

@@ -1,272 +0,0 @@
-require 'validator'
-require 'validator/digestion_based'
-require 'transmem'
-require 'fasta'
-require 'spec_id/digestor'
-require 'spec_id/sequest/params'
-require 'spec_id/sequest/pepxml'
-
-
-module Validator::Transmem ; end
-
-# objects of this class can calculate pephit_precision given an array of
-# SpecID::Pep objects using the pephit_precision method.
-class Validator::Transmem::Protein < Validator::DigestionBased
-  include Precision::Calculator
-
-  # a hash keyed by index reference which is true if >= min_num_tms
-  attr_accessor :transmem_by_ti_key
-  attr_accessor :transmem_index
-
-  # min_num_tms: Integer (1...), the min # certain transmembrane segments to
-  # consider the protein a transmembrane protein
-  attr_reader :min_num_tms
-
-  # soluble_fraction: *true/false
-  attr_accessor :soluble_fraction
-
-  # correct_wins: *true/false,
-  #   if the peptide is found in some proteins that are transmembrane and some
-  #   that are not, then if soluble_fraction==true, this peptide will be
-  #   considered non-transmembrane.  If soluble_fraction==false, then this
-  #   will be considered transmembrane.
-  attr_accessor :correct_wins
-
-  # no_include_tm_peps: false or Float (0.0-1.0), peptides that have a
-  #   fraction of amino acids that fall inside transmembrane sequences greater
-  #   than or equal to the value of the argument will not be considered in the final
-  #   calculation of peptide hit precision.  (A transmembrane segment is
-  #   likely to have very different properties than the rest of the peptides,
-  #   so the assumption of equally flyable peptides is broken unless these are
-  #   removed)  nil or false will skip this filter.  A reasonable value is
-  #   probably 0.7.
-  attr_accessor :no_include_tm_peps
-
-  # if nil, then this will be calculated whe pephit_precision is called.
-  attr_accessor :transmem_status_hash
-
-  # the file used (toppred or phobius file)
-  attr_accessor :transmem_file
-
-  DEFAULTS = Validator::DigestionBased::DEFAULTS.merge( { :min_num_tms => 1, :soluble_fraction  =>  true, :correct_wins  =>  true, :no_include_tm_peps => false, :transmem_status_hash => nil} )
-
-  # expects a toppred.out file (see transmem/toppred)
-  # other types of transmembrane predictions)
-  # fasta_obj is a Fasta object.
-  # sequest_params_obj is a Sequest::Params object.
-  # OPTIONS:
-  #   (see Validator::Transmem::Protein::DEFAULTS for defaults)
-  #   
-  #   no_include_tm_peps: *false
-  #   
-  # NOTE: if fasta_obj and sequest_params_obj are not passed in then
-  #   'false_to_total_ratio' must be set later.
-  def initialize(a_transmem_file, options={})
-    @transmem_file = a_transmem_file
-    opts = self.class::DEFAULTS.merge(options)
-
-    (@min_num_tms, @soluble_fraction, @correct_wins, @no_include_tm_peps, @background, @transmem_status_hash, @false_to_total_ratio, fasta) = opts.values_at(:min_num_tms, :soluble_fraction, :correct_wins, :no_include_tm_peps, :background, :transmem_status_hash, :false_to_total_ratio, :fasta)
-
-    # fasta object is used to update hte phobius index if given
-    # a hash by reference => true/false (depending on min_num_tms)
-    @transmem_index = TransmemIndex.new(@transmem_file, fasta)
-    @transmem_by_ti_key = create_transmem_by_ti_key_hash(@transmem_index, @min_num_tms)
-  end
-
-  # Designates each protein as transmembrane or not depending on :min_num_tms
-  # The hash is keyed by the TransmemIndex key.
-  def create_transmem_by_ti_key_hash(transmem_index, min_num_tms)
-    _transmem_by_ti_key = {}
-    num_certain_hash = transmem_index.num_certain_index
-    num_certain_hash.each do |id, num_certain|
-      if num_certain >= min_num_tms
-        _transmem_by_ti_key[id] = true
-      else
-        _transmem_by_ti_key[id] = false
-      end
-    end
-    _transmem_by_ti_key
-  end
-
-  # returns a hash where each protein (and peptide if given peps) is indexed
-  # with itself with true/false/nil depending on transmembrane status.  If
-  # given peptides, and :no_include_tm_peps is not false, will also set the
-  # attribute for peptides.
-  # the attribute (:no_include_tm_peps)
-  # NOTE: if given a list of peptides, this implementation will not overwrite a
-  # protein if it already has a true/false for transmem.  This is so that a
-  # lookup does not have to be performed if the value is already defined as
-  # the assumption is that many peptides will point to the same protein.
-  def create_transmem_status_hash(peps)
-    thash = {}
-    peps.each do |pep|
-      pep.prots.each do |prot|
-        if !thash.key?(prot)
-          #prot.transmem == nil
-          thash[prot] = @transmem_by_ti_key[@transmem_index.reference_to_key(prot.reference)]
-        end
-      end
-      if @no_include_tm_peps
-        thash[pep] = pep_is_transmem?(pep)   
-      end
-    end
-    thash
-  end
-
-  # sets the false_to_total_ratio and returns self for chaining.
-  # peps will usually be the peptides created by calling:
-  #     peps = Digestor.digest( fasta_obj, sequest_params_obj )
-  def set_false_to_total_ratio(peps)
-    tm_hash = create_transmem_status_hash(peps)
-    (tps, fps) = partition(peps, tm_hash)
-    @false_to_total_ratio = fps.size.to_f / (tps.size + fps.size) 
-    self
-  end
-
-  def pephit_precision(peps)
-    if !@transmem_status_hash
-      @transmem_status_hash = create_transmem_status_hash(peps)
-    end
-    super(peps)
-  end
-
-  # regardless of transmembrane status of proteins peptide belongs to, asks
-  # what the avg overlap is with transmembrane sequences.
-  def pep_is_transmem?(pep)
-    prts = pep.prots
-    prts_w_keys = 0
-    sum_of_fractions = 0.0
-    prts.each do |prot|
-      key = @transmem_index.reference_to_key(prot.reference)
-      ans = @transmem_index.avg_overlap(key, pep.aaseq, :fraction)
-      if ans
-        sum_of_fractions += ans
-        prts_w_keys += 1
-      end
-    end
-    if prts_w_keys > 0
-      avg_of_fractions = sum_of_fractions / prts_w_keys
-      avg_of_fractions >= @no_include_tm_peps
-    else
-      nil
-    end
-  end
-
-  # each peptide must have prots and the prots must respond true/false to
-  # the 'transmem' method
-  # if given a hash, it will override the @transmem_status_hash
-  def partition(peps, transmem_status_hash=nil)
-    # The fast way to do this is to play with the logic
-    # For the insoluble fraction we calculate as if incorrect wins
-    # and swap the tp's and fp's (I've verified that this is correct
-    # empirically)
-
-    # the code could be cleaner here, but efforts to minimize calls in the
-    # inner loops create this structure...
-    tm_hash = transmem_status_hash || @transmem_status_hash
-
-    my_peps = 
-      if @no_include_tm_peps
-        # remove all thos peps with fractional overlap >= @no_include
-        # [1,2,3,4].reject {|n| n >= 3}  #-> [1, 2]
-        # remove pep.transmem == true and pep.transmem == nil
-        
-        if tm_hash
-          peps.reject do |pep|
-            tm_hash[pep] != false 
-          end
-        else
-          peps.reject do |pep|
-            pep_is_transmem?(pep) != false 
-          end
-        end
-      else
-        peps
-      end
-    cw = @correct_wins
-    sf = @soluble_fraction
-    if !sf
-      cw = !cw
-    end
-
-    tp = []
-    fp = []
-
-    if cw
-      my_peps.each do |pep|
-        one_prot_is_not_transmem = false
-        not_all_nil = false
-        if tm_hash
-          pep.prots.each do |prot|
-            tm_status = tm_hash[prot]
-            if tm_status == false
-              one_prot_is_not_transmem = true  
-              break
-            elsif tm_status == true
-              not_all_nil = true
-            end
-          end
-        else
-          pep.prots.each do |prot|
-            tm_status = @transmem_by_ti_key[@transmem_index.reference_to_key(prot.reference)]
-            if tm_status == false
-              one_prot_is_not_transmem = true  
-              break
-            elsif tm_status == true
-              not_all_nil = true
-            end
-          end
-        end
-        if one_prot_is_not_transmem
-          tp << pep
-        else
-          if not_all_nil
-            fp << pep
-          end
-        end
-      end
-    else
-      my_peps.each do |pep|
-        one_prot_is_transmem = false
-        not_all_nil = false
-        if tm_hash
-          pep.prots.each do |prot|
-            tm_status = tm_hash[prot]
-            if tm_status == true
-              one_prot_is_transmem = true  
-              break
-            elsif tm_status == false
-              not_all_nil = true
-            end
-          end
-        else
-          pep.prots.each do |prot|
-            tm_status = @transmem_by_ti_key[@transmem_index.reference_to_key(prot.reference)]
-            if tm_status == true
-              one_prot_is_transmem = true  
-              break
-            elsif tm_status == false
-              not_all_nil = true
-            end
-          end
-        end
-        if one_prot_is_transmem
-          fp << pep
-        else
-          if not_all_nil
-            tp << pep
-          end
-        end
-      end
-    end
-    if !sf # swap
-      fp,tp = tp,fp
-      cw = !cw
-    end
-    #puts "PARTITION ARRAY"
-    #p [tp, fp].map{|v| v.size}
-    [tp, fp]
-  end
-
-end
-

data/lib/validator/true_pos.rb

@@ -1,46 +0,0 @@
-require 'validator'
-
-class Validator::TruePos < Validator
-  include Precision::Calculator
-  attr_reader :fasta
-  attr_accessor :correct_wins
-
-  # correct_wins means that only a single protein from a pep.aaseq must match
-  # the fasta object for the pep hit to be considered valid.  Otherwise, all
-  # must be a match
-  def initialize(fasta_obj, correct_wins = true)
-    @fasta = fasta_obj
-    @fasta_headers = @fasta.prots.map {|prot| prot.header }
-    @correct_wins = correct_wins
-  end
-
-  def partition(peps)
-    if @correct_wins
-      peps.partition do |pep|
-        @fasta_headers.any? do |header| 
-          pep.prots.any? do |pepprot| 
-            header.include? pepprot.reference
-          end
-        end
-      end
-    else
-      peps.partition do |pep|
-        pep.prots.all? do |pepprot| 
-          @fasta_headers.any? do |header| 
-            header.include? pepprot.reference
-          end
-        end
-      end
-    end
-  end
-
-  def pephit_precision(peps)
-    (tp, fp) = partition(peps)
-    calc_precision(tp.size, fp.size)
-  end
-
-  def to_param_string
-    "true_positives(tps)=" +  ["{fasta=#{@fasta.filename}", "correct_wins=#{@correct_wins}}"].join(", ")
-  end
-
-end