anchor.diff:          /// 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 or determination of distinct peptides for the organism is done.
  -        let scoreBy (model:Model) (data:PredictionInput []) = 
  +        /// No feature normalization is done.
  +        let scoreBy (model:Model) (distinctPeptideSet: Set<string>) (data:PredictionInput []) = 
               let device = DeviceDescriptor.CPUDevice
   
               let PeptidePredictor : Function = 
  
positive.code:                                         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})
                  )
  
          ///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.
  
negative.code:         Sequence: string
          ///observability score returned by dppop prediction
          PredictionScore: float
          ///Indicates wether the peptide is uniquely mapping to the protein of interest
          Distinct: bool
      }
      /// returns a PredictionOutput type given the values for the record fields
      let createPredictionOutput pId sequence score distinct = {ProteinId = pId; Sequence = sequence; PredictionScore = score; Distinct=distinct}
  
      ///Contains functions to extract the features used in dppop to classify peptides for observability prediction
      module Classification =
  