anchor.diff:                                          let digested =
                                               Classification.digestTryptic protein.Sequence
                                               |> Seq.map (fun x -> BioArray.toString x)
  -                                            |> Seq.filter (fun peptide -> distinctPeptides.Contains peptide)
                                               |> List.ofSeq
                                           let candidatePeptides = 
                                               digested
  -                                            |> Seq.filter (fun p -> distinctPeptides.Contains(p))
                                               |> Seq.map (fun p -> Classification.getPeptideFeatures digestionEfficiencyMap protId (BioArray.ofAminoAcidSymbolString p))
                                               |> Array.ofSeq
                                               |> Array.choose id
  +
                                           candidatePeptides
  -                                        |> Array.map (featureNormalization)
  -                                        |> scoreBy model
  -                                        |> Array.sortByDescending (fun (x) -> x.PredictionScore)
  -                                        |> fun x -> let max = (Array.maxBy (fun (x) -> x.PredictionScore) x).PredictionScore 
  -                                                    x |> Array.map (fun (x) -> if x.PredictionScore >= 0. then {x with PredictionScore = (x.PredictionScore/max)} else {x with PredictionScore = 0.0})
  +                                            |> Array.map (featureNormalization)
  +                                            |> scoreBy model distinctPeptides
  +                                            |> Array.sortByDescending (fun (x) -> x.PredictionScore)
  +                                            |> fun x -> let max = (Array.maxBy (fun (x) -> x.PredictionScore) x).PredictionScore 
  +                                                        x |> Array.map (fun (x) -> if x.PredictionScore >= 0. then {x with PredictionScore = (x.PredictionScore/max)} else {x with PredictionScore = 0.0})
  +
                   )
   
           ///Returns relative observability scores for uniquely mapping peptides of proteins of interest using dppops plant model and feature normalization procedure, given the proteome of the organism.
  
positive.code:         Sequence: string
          ///observability score returned by dppop prediction
          PredictionScore: float
      }
      /// returns a PredictionOutput type given the values for the record fields
      let createPredictionOutput pId sequence score = {ProteinId = pId; Sequence = sequence; PredictionScore = score}
  
      ///Contains functions to extract the features used in dppop to classify peptides for observability prediction
      module Classification =
  
negative.code:         /// For expert use.
          /// Returns the observability prediction for the input peptides.
          /// Loads a trained CNTK model (either dppops plant/nonPlant models or a custom model) and evaluates the scores for the given collection of features (PredictionInput)
          /// No feature normalization is done.
          let scoreBy (model:Model) (distinctPeptideSet: Set<string>) (data:PredictionInput []) = 
              let device = DeviceDescriptor.CPUDevice
  
              let PeptidePredictor : Function = 
  