Abstract:
System and methods are disclosed to perform peptide-MHC interaction prediction by applying a high-order kernel function to determine a similarity between peptide sequences; applying one or more supervised strategies to the kernel to encode relevant physicochemical and interaction information about peptide sequence and MHC molecule; and applying a classifier to the kernel to identify the peptide-MHC interaction of interest in response to a query.

Description:
[0001]    This application claims priority to Provisional Application 61/969,928 filed Mar. 25, 2014, the content of which is incorporated by reference. 
     
    
     BACKGROUND 
       [0002]    Complex biological functions in living cells are often performed through different types of protein-protein interactions. An important class of protein-protein interactions are peptide (i.e. short chains of amino acids) mediated interactions, and they regulate important biological processes such as protein localization, endocytosis, post-translational modifications, signaling pathways, and immune responses etc. Moreover, peptide-mediated interactions play important roles in the development of several human diseases including cancer and viral infections. Due to the high medical value of peptide-protein interactions, a lot of research has been done to identify ideal peptides for therapeutic and cosmetic purposes, which renders in silico peptide-protein binding prediction by computational methods a highly important problem in immunomics and bioinformatics. In this paper, we propose novel machine learning methods to study a specific type of peptide-protein interaction, that is, the interaction between peptides and Major Histocompatibility Complex class I (MHC I) proteins, although our methods can be readily applicable to other types of peptide-protein interactions. Peptide-MHC I protein interactions are essential in cell-mediated immunity, regulation of immune responses, vaccine design, and transplant rejection. Therefore, effective computational methods for peptide-MHC I binding prediction will significantly reduce cost and time in clinical peptide vaccine search and design. 
         [0003]    Previous computational approaches to predicting peptide-MHC interactions are mainly based on linear or bi-linear models, and they fail to capture non-linear high-order dependencies between different peptide amino acid positions. Although previous Kernel SVM and Neural Network (NetMHC) approaches can capture nonlinear interactions between input features, they fail to model the direct strong high-order interactions between features. As a result, the quality of the peptide rankings produced by previous methods is not good enough. Producing high-quality rankings of peptide vaccine candidates is essential to the successful deployment of computational methods for vaccine design, for which modeling direct non-linear high-order feature interactions between different amino acid positions becomes very important. 
       SUMMARY 
       [0004]    A system modeling high-order feature interactions uses high-order Kernel Support Vector Machines to efficiently predict peptide-Major Histocompatibility Complex (MHC) binding. 
         [0005]    Advantages of the above system may include one or more of the following. The peptide-MHC binding prediction methods improve quality of binding predictions over other prediction methods. With the methods, a significant gain of 10-25% is observed on benchmark and reference peptide data sets and tasks. The prediction methods allow integration of both qualitative (i.e., binding/non-binding/eluted) and quantitative (experimental measurements of binding affinity) peptide-MHC binding data to enlarge the set of reference peptides and enhance predictive ability of the method, whereas the existing methods (e.g., NetMHC) are limited to only less widespread quantitative binding data. As the instant methods are based on the analysis of sequences of known binders and non-binders, the predictive performance will continue to improve with accumulation of the experimentally verified binding/non-binding peptides. This ability to accommodate and scale with increasing amounts of data is critical for further refinement of the prediction ability of the method. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0006]      FIG. 1  shows an exemplary system for peptide-MHC binding recognition. 
           [0007]      FIG. 2  shows an exemplary peptide prediction method. 
           [0008]      FIG. 3  shows an exemplary peptide descriptor sequence representation. 
           [0009]      FIG. 4A-4C  shows additional exemplary peptide matrix representations. 
           [0010]      FIG. 5  shows the placement of the computational method in the machine learning pipeline for training and prediction. 
       
    
    
     DESCRIPTION 
       [0011]    An exemplary system containing the proposed kernel or similarity computation unit is shown in  FIG. 1 . The system receives an input peptide sequence and performs kernel calculation and mapping. In one embodiment, the system generates a descriptor sequence matrix representation of the input peptide sequence; applies a convolutional attributed set representation to determine a kernel between peptides, wherein the kernel considers a similarity of individual amino acids or string of amino acids and a similarity of a context including location or coordinate, or a set of neighboring amino acids, or peptide-MHC amino acid contact residues to compute the degree-of-similarity value between peptides. Once the kernel calculation and mapping operations are done, the system applies one or more prediction models including binding models or quantitative binding affinity models to determine peptide-MHC binding recognition and generates an output. 
         [0012]    In implementations, the operations include applying an MHC-peptide interaction model to the matrix representation. The system can apply MHC, source protein sequence, and structural information. The system designed kernel functions are applied to peptides during training to estimate a set of predictor parameters, and wherein the kernel functions compute the prediction values for unlabeled peptides. The kernel functions determine similarity between peptides using descriptor sequence representation of the peptides. The kernel contains specialized kernel functions including position-set, context, and property kernel functions for peptide binding and T-cell epitope prediction. 
         [0013]    The nonlinear high-order machine learning method uses High-Order Kernel SVM for peptide-MHC I protein binding prediction. Experimental results on both public and private evaluation datasets according to both binary and non-binary performance metrics (AUC and nDCG) clearly demonstrate the advantages of our method over the state-of-the-art approach NetMHC, which suggests the importance of modeling nonlinear high-order feature interactions across different amino acid positions of peptides. 
         [0014]      FIG. 2  shows an exemplary peptide prediction process.  FIGS. 3 and 4A-4C  show exemplary peptide descriptor sequence representations while  FIG. 5  shows the placement of the computational method in the machine learning pipeline for training and prediction. 
         [0015]    The method of computing the degree-of-similarity (kernel) between peptides for training (Step  2  in  FIG. 2 ) or prediction (Step  3 ) using kernel functions based on descriptor sequence representations of peptides. 
         [0016]    As shown in  FIG. 3 , the flow of MHC-peptide prediction model construction is as follows:
       1. Using the reference peptide-allele database with measurements of peptide binding activities (quantitative or qualitative), form a training set by assigning each peptide to the class “Binding” (B) or “Not-binding” (NB) (or multiple binding classes defining various intensities of binding activities) according to the reference binding strength (quantitative or qualitative measurements of binding activity) of the corresponding peptide. This is Step  1 .   2. Appropriately defined kernel function K(•,•) is then applied to pairs of peptides in the training set (Step  2 ). Kernel function K(•,•) is defined such that pairs of similar peptides X i , X j  should have small differences in their corresponding high dimensional feature expansions Φ(X i ) and Φ(X j ), thus differentiating between binding and non-binding peptide instances. The kernel functions on peptides will be described in detail below.   3. Using machine learning algorithm and kernel function output values for peptides in the training set, a model that differentiates instances of binding peptides from instances of non-binding peptides (Step  3 ) is constructed. The trained model when applied to the unlabeled peptide sequence X produces a prediction value f(X), which suggests whether the peptide would bind (and to what degree) to the target MHC molecule.       
 
         [0020]    The design of peptide representations and corresponding kernel functions used in Steps  2  and  3  is detailed next. 
         [0021]    As detailed below, given amino acid sequences of test peptides in question and a set of representative peptides with binary binding strengths for the MHC molecule of interest, we use a nonlinear high-order machine learning method called high-order Kernel SVM to efficiently predict peptide-MHC binding. The method covers identification of MHC-binding, naturally processed and presented (NPP), and immunogenic peptides (T-cell epitopes). 
         [0022]    In order for the peptides to bind to a particular MHC allele (i.e., fit their peptide-binding groove), the sequences of these binding peptides should be approximately superimposable: contain similar (in some sense, e.g., in the sense of the physicochemical descriptors) amino-acids or strings of amino acids (k-mers) at approximately the same positions along the peptide chain. 
         [0023]    It is then natural to model peptide sequences X=x 1 , x 2 , . . . , x |X| , x i εΣ (i.e., sequences of amino acid residues) as a sequences of descriptor vectors d 1 , . . . , d n  encoding positions/relevant properties of amino acids observed along the peptide chain. 
         [0024]    Then, the sequence of the descriptors corresponding to the peptide X=x 1 , x 2 , . . . , x |X| , x i εΣ can be modeled as an attributed set of descriptors corresponding to different positions (or groups of positions) in the peptide and amino acids or strings of amino acids occupying these positions: 
         [0000]        X   A ={( p   i   ,d   i )} i=1   n    
         [0000]    where p i  is the coordinate (position) or a set (vector) of coordinates and d i  is the descriptor vector associated with the p i , with n indicating the cardinality of the attributed set description X A  of peptide X. The cardinality of the description X A  corresponds to the length of the peptide (i.e., the number of positions) or, in general, to the number of unique descriptors in the descriptor sequence representation. A unified descriptor sequence representation of the peptides as a sequence of descriptor vectors is used to derive attributed set descriptions X A . 
         [0025]    While the descriptor vectors in general may be of unequal length, in the matrix form (equal-sized vectors) of this representation (“feature-spatial-position matrix”), the rows are indexed by features (e.g., individual amino acids, strings of amino acids, k-mers, physicochemical properties, peptide-MHC interaction features, etc), while the columns correspond to their spatial positions (coordinates). This is illustrated in  FIG. 3 . 
         [0026]    In this descriptor sequence representation, each position in the peptide is described by a feature vector, with features derived from the amino acid occupying this position/or from a set of amino acids (e.g., a k-mer starting at this position or a window of amino acids centered at this position) and/or amino acids present in the MHC protein molecule and interacting with the amino acids in the peptide. 
         [0027]    We define three types of basic descriptors/feature vectors used to construct “feature-position” peptide representations: binary, real-valued, and discrete. These basic descriptors are also used by the kernel functions to measure similarity between individual positions, amino acids, or strings of amino acids. 
         [0028]    The purpose of a descriptor is to capture relevant information (e.g., physicochemical properties) that can be used by the kernel functions to differentiate peptides (binding, non-binding, immunogenic, etc). 
         [0029]    A simple binary descriptor of an amino acid is a binary indicator vector with zeros at all positions except for one position corresponding to the amino acid which is set to one. An example of the binary matrix representation of the peptide is given in  FIG. 4A . 
         [0030]    A real-valued descriptor of an amino acid is a quantitative descriptor encoding (1) relevant properties of amino acids, e.g., their physicochemical properties, and/or (2) interaction features (such as binding energy) between the amino acids in the peptide and in the MHC molecule. An example of the real-valued descriptor sequence representation of a peptide using 5-dim physicochemical amino acid descriptors is given in  FIG. 4B . 
         [0031]    A discrete (or discretized) descriptor of an amino acid or strings of amino acid (k-mer) can, for instance, encode a set of “similar” amino acids or a set of “similar” k-mers, where the set of similar k-mers can be defined as the set of k-mer at a small Hamming distance or with a small substitution or alignment-based distance. Another example of such descriptor is a binary Hamming encoding of amino acids or k-mers.  FIG. 4 c    shows one such example of a discrete encoding of a peptide. 
         [0032]    We define kernel functions for peptides based on peptide descriptor sequence representations (such as in  FIG. 4 ). The kernel functions for peptide sequences X and Y have the following general form: 
         [0000]    
       
         
           
             
               
                 
                   
                     K 
                      
                     
                       ( 
                       
                         X 
                         , 
                         Y 
                       
                       ) 
                     
                   
                   = 
                     
                    
                   
                     K 
                      
                     
                       ( 
                       
                         
                           M 
                            
                           
                             ( 
                             X 
                             ) 
                           
                         
                         , 
                         
                           M 
                            
                           
                             ( 
                             Y 
                             ) 
                           
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     K 
                      
                     
                       ( 
                       
                         
                           X 
                           A 
                         
                         , 
                         
                           Y 
                           A 
                         
                       
                       ) 
                     
                   
                 
               
             
             
               
                 
                   = 
                     
                    
                   
                     
                       ∑ 
                       
                         i 
                         X 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         ∑ 
                         
                           j 
                           Y 
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           
                             k 
                             p 
                           
                            
                           
                             ( 
                             
                               
                                 p 
                                 
                                   i 
                                   Y 
                                 
                                 X 
                               
                               , 
                               
                                 p 
                                 
                                   j 
                                   Y 
                                 
                                 Y 
                               
                             
                             ) 
                           
                         
                          
                         
                           
                             k 
                             d 
                           
                            
                           
                             ( 
                             
                               
                                 d 
                                 
                                   i 
                                   X 
                                 
                                 X 
                               
                               , 
                               
                                 d 
                                 
                                   j 
                                   Y 
                                 
                                 Y 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
             
           
         
       
     
         [0033]    where M(•) is a descriptor sequence (e.g., spatial feature matrix) representation of a peptide, X A  (Y A ) is an attributed set corresponding to M(X) (M(Y)), k d  (•,•), k p (•,•), are kernel functions on descriptors and context/positions, respectively, and i X , i Y  index elements of the attributed sets X A , Y A . 
         [0034]    The kernel function (Eq. 9) captures high-order interactions between amino acids/positions by considering essentially all possible products of features encoded in descriptors d of two or more positions. The feature map corresponding to this kernel is composed of individual feature maps capturing interactions between particular combinations of the positions. The interaction maps between different positions p a  and p b  are weighted by the position/context kernel function k p (P a ,P b ) 
         [0035]    A number of kernel functions for descriptor sequence (e.g., matrix) forms M(•) is described below. 
         [0036]    Kernel Functions for Descriptor Sequences 
         [0037]    Exact-Position (Singleton) Kernel Function 
         [0038]    Using an appropriate kernel function k d(•,•)  on the descriptors d i , with the Kronecker delta kernel function on the coordinates p i =i, the exact-position kernel function on peptides X and Y with descriptor-position matrix representation is defined as 
         [0000]    
       
         
           
             
               
                 
                   
                     K 
                      
                     
                       ( 
                       
                         X 
                         , 
                         Y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         1 
                       
                       
                         i 
                         = 
                         
                           n 
                           X 
                         
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         ∑ 
                         
                           j 
                           = 
                           1 
                         
                         
                           j 
                           = 
                           
                             n 
                             Y 
                           
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           δ 
                            
                           
                             ( 
                             
                               i 
                               , 
                               j 
                             
                             ) 
                           
                         
                          
                         
                           
                             k 
                             d 
                           
                            
                           
                             ( 
                             
                               
                                 d 
                                 i 
                                 X 
                               
                               , 
                               
                                 d 
                                 j 
                                 Y 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                     . 
                     
                         
                     
                      
                     KEP 
                   
                   ) 
                 
               
             
           
         
       
     
         [0039]    This kernel function computes similarity between peptides X and Y by comparing descriptors with the same coordinates in both peptides. 
         [0040]    Descriptor-Position-Set Kernel Function 
         [0041]    Using binary, real-valued, or discrete descriptors d i  and defining p i  to be a set of coordinates associated with each unique descriptor, a position-set kernel is defined as 
         [0000]    
       
         
           
             
               
                 
                   
                     K 
                      
                     
                       ( 
                       
                         X 
                         , 
                         Y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         X 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         ∑ 
                         
                           j 
                           Y 
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           
                             k 
                             p 
                           
                            
                           
                             ( 
                             
                               
                                 p 
                                 
                                   i 
                                   Y 
                                 
                                 X 
                               
                               , 
                               
                                 p 
                                 
                                   j 
                                   Y 
                                 
                                 Y 
                               
                             
                             ) 
                           
                         
                          
                         
                           
                             k 
                             d 
                           
                            
                           
                             ( 
                             
                               
                                 d 
                                 
                                   i 
                                   X 
                                 
                                 X 
                               
                               , 
                               
                                 d 
                                 
                                   j 
                                   Y 
                                 
                                 Y 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                     . 
                     
                         
                     
                      
                     KDPS 
                   
                   ) 
                 
               
             
           
         
       
     
         [0042]    where k p  (•,•) and k d  (•,•) are appropriate kernel functions on the sets of coordinates/positions and on the descriptors, and i X  and i Y  index elements of attributed sets X A  and Y A . This kernel function computes similarity over features and their respective positional distributions. 
         [0043]    Depending on the choice of the descriptors and the resulting descriptor-position matrix, the position-set kernel function implements Hamming-distance based (using discrete k-mer mutational neighborhood descriptors), or non-Hamming (general) comparison between strings of amino acids in the peptides. 
         [0044]    For instance, Hamming-based mismatch kernel between amino acid strings (k-mers) can be obtained using linear kernel function k d  (•,•)=(d α ,d β ) with descriptors d α =(d α (β)) βεΣ,     k    for amino acid string α,|α|=k defined as 
         [0000]    
       
         
           
             
               
                 d 
                 α 
               
                
               
                 ( 
                 β 
                 ) 
               
             
             = 
             
               { 
               
                 
                   
                     
                       1 
                       , 
                     
                   
                   
                     
                       
                         ifh 
                          
                         
                           ( 
                           
                             α 
                             , 
                             β 
                           
                           ) 
                         
                       
                       ≤ 
                       m 
                     
                   
                 
                 
                   
                     
                       0 
                       , 
                     
                   
                   
                     otherwise 
                   
                 
               
             
           
         
       
     
         [0045]    where h(•,•) is a Hamming distance between amino acid strings, m is the maximum number of allowed mismatches. 
         [0046]    Context Kernel Function 
         [0047]    Using binary descriptors d i  for each position i, d i (j)=1 if j=X i  and d i (j)=0, otherwise, we form the context descriptor c i  for each coordinate i as 
         [0000]    
       
         
           
             
               
                 
                   
                     c 
                     i 
                   
                   = 
                   
                     
                       ∑ 
                       
                         j 
                         = 
                         
                           i 
                           - 
                           
                             w 
                             L 
                           
                         
                       
                       
                         j 
                         = 
                         
                           i 
                           + 
                           
                             w 
                             R 
                           
                         
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         w 
                          
                         
                           ( 
                           
                             i 
                             - 
                             j 
                           
                           ) 
                         
                       
                        
                       
                         d 
                         j 
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                     . 
                     
                         
                     
                      
                     CONTEXT 
                   
                   ) 
                 
               
             
           
         
       
     
         [0048]    where the weighting function w(i−j) quantifies contribution of the neighboring positions j according to their distance from i. The weighting function w(•), for instance, can be defined as follows 
         [0000]    
       
         
           
             
               w 
                
               
                 ( 
                 
                   i 
                   - 
                   j 
                 
                 ) 
               
             
             = 
             
               
                 1 
                 
                   
                      
                     
                       i 
                       - 
                       j 
                     
                      
                   
                   α 
                 
               
               + 
               β 
             
           
         
       
     
         [0049]    with (α,β)-parametrization, where α describes the decay rate and β is a constant added to all weights. Using β&gt;0 effectively takes into account even distant neighbors when forming the context descriptor c. 
         [0050]    The kernel between peptides is then defined as 
         [0000]    
       
         
           
             
               
                 
                   
                     K 
                      
                     
                       ( 
                       
                         X 
                         , 
                         Y 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         i 
                         X 
                       
                     
                      
                     
                         
                     
                      
                     
                       
                         ∑ 
                         
                           j 
                           Y 
                         
                       
                        
                       
                           
                       
                        
                       
                         
                           δ 
                            
                           
                             ( 
                             
                               
                                 i 
                                 X 
                               
                               , 
                               
                                 j 
                                 Y 
                               
                             
                             ) 
                           
                         
                          
                         
                           
                             k 
                             c 
                           
                            
                           
                             ( 
                             
                               
                                 c 
                                 i 
                                 X 
                               
                               , 
                               
                                 c 
                                 j 
                                 y 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   
                     EQ 
                     . 
                     
                         
                     
                      
                     KCONTEXT 
                   
                   ) 
                 
               
             
           
         
       
     
         [0051]    where k c (c 1 ,c 2 ) is an appropriate kernel function on the context descriptors. 
         [0052]    The kernel function k c  (•,•) on the context descriptors can be defined as an inner product 
         [0000]        k   c ( c   1   ,c   2 )=&lt; c   1   ,c   2 &gt; 
         [0000]    or, in general, as similarity-transformed tensor product (i.e. Frobenius product between the similarity matrix and the tensor product of the context descriptors) 
         [0000]        k   c ( c   1   ,c   2 )= tr (( c   1 {circle around (x)} c   2 ) S ) 
         [0053]    where S is an appropriate similarity matrix for elements of the context descriptors. 
         [0054]    The similarity matrix S can be defined according to AA similarity matrices (e.g., BLOSUM of AAindex) by using these matrices to compute entries of S, for example as S i,j =&lt;AA i ,AA j &gt; or exp(−γd(AA i −AA j )), where AA i  is the ith row of the AA similarity matrix. 
         [0055]    Property Kernel. 
         [0056]    As the importance of various attributes for peptide classification varies, the similarity computation for two peptides X and Y can be expanded by individually measuring similarity for each attribute a=1, . . . , P along peptide chains x a   1 , x a   2 , . . . , x a   n , y a   1 , y a   2 , . . . , y a   n , instead of using vector-based measure of similarity (e.g, Euclidean distance Σ a=1   p (x a   i −y a   j ) 2 ) between positions in the peptide chain. 
         [0057]    To more accurately model similarities between peptides represented in descriptor sequence form (i.e. as a sequence of vectors of physicochemical amino acid attributes and/or peptide-MHC residue interaction features), sequences of each attribute values can be compared along the peptide chain with peptide similarity defined as cumulative similarity across these attributes. 
         [0058]    We then define a property kernel to be a dot-product between vectors of individual property similarity scores 
         [0000]        K ( X,Y )=&lt; k   1 ( X,Y ), k   2 ( X,Y ), . . . , k   p ( X,Y ), k   1 ( X,Y ), k   2 ( X,Y ), . . . , k   p ( x,y ))   (EQ.KPROP)
 
         [0059]    where 
         [0060]    k a (X,Y), a=1, . . . , P is a similarity score for attribute a=1, . . . , P, e.g., one of the descriptor-sequence kernel described above. 
         [0061]    The individual scores k a (X,Y) capture similarity of peptides X and Y with respect to the corresponding attribute/property a along the peptide chain. The dot-product between vectors of individual scores captures overall similarity between peptides X and Y across properties a=1, . . . , P. 
         [0062]    Kernel Functions for Descriptors and Position Distributions 
         [0063]    Position Kernels 
         [0064]    (α,β)-kernel between sets of positions. Kernel functions k p (•,•) on position sets p i  and p j  are defined as a set kernel 
         [0000]    
       
         
           
             
               
                 k 
                 p 
               
                
               
                 ( 
                 
                   
                     p 
                     i 
                   
                   , 
                   
                     p 
                     j 
                   
                 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   i 
                   ∈ 
                   
                     p 
                     i 
                   
                 
               
                
               
                   
               
                
               
                 
                   ∑ 
                   
                     j 
                     ∈ 
                     
                       p 
                       j 
                     
                   
                 
                  
                 
                     
                 
                  
                 
                   k 
                    
                   
                     ( 
                     
                       i 
                       , 
                       
                         j 
                         | 
                         α 
                       
                       , 
                       β 
                     
                     ) 
                   
                 
               
             
           
         
       
       
         
           where 
         
       
       
         
           
             
               k 
                
               
                 ( 
                 
                   i 
                   , 
                   
                     j 
                     | 
                     α 
                   
                   , 
                   β 
                 
                 ) 
               
             
             = 
             
               
                 
                   1 
                   
                     
                        
                       
                         i 
                         - 
                         j 
                       
                        
                     
                     α 
                   
                 
                 + 
                 β 
               
               = 
               
                 
                   exp 
                    
                   
                     ( 
                     
                       
                         - 
                         α 
                       
                        
                       
                           
                       
                        
                       
                         log 
                          
                         
                           ( 
                           
                              
                             
                               i 
                               - 
                               j 
                             
                              
                           
                           ) 
                         
                       
                     
                     ) 
                   
                 
                 + 
                 β 
               
             
           
         
       
     
         [0065]    is a kernel function on pairs of position coordinates (i,j). 
         [0066]    The position set kernel function above assigns weights to interactions between positions (i,j) according to k(i,j|α,β). 
         [0067]    RBF-kernel between sets of positions. Similarly to (α,β)-kernel above, kernel function k p (•,•) between position sets can be defined using RBF kernel as 
         [0000]    
       
         
           
             
               
                 k 
                 p 
               
                
               
                 ( 
                 
                   
                     p 
                     i 
                   
                   , 
                   
                     p 
                     j 
                   
                 
                 ) 
               
             
             = 
             
               
                 ∑ 
                 
                   i 
                   ∈ 
                   
                     p 
                     i 
                   
                 
               
                
               
                   
               
                
               
                 
                   ∑ 
                   
                     j 
                     ∈ 
                     
                       p 
                       j 
                     
                   
                 
                  
                 
                     
                 
                  
                 
                   exp 
                    
                   
                     ( 
                     
                       - 
                       
                         
                           
                             γ 
                             p 
                           
                            
                           
                             ( 
                             
                               i 
                               - 
                               j 
                             
                             ) 
                           
                         
                         2 
                       
                     
                     ) 
                   
                 
               
             
           
         
       
     
         [0068]    Descriptor Kernels 
         [0069]    The descriptor kernel function (e.g., RBF or polynomial, EQ.FIX) between two descriptors d i =(d 1   i , d 2   i , . . . , d R   i ) and d j =(d 1   j , d 2   j , . . . , d R   j ) induces high-order (i.e. products-of-features) interaction features (such as d i     1   , d i     2   , . . . , d i     p    for polynomial of degree p) between positions/attributes. 
         [0070]    Using real-valued descriptors (e.g., vectors of physicochemical attributes), with RBF or polynomial kernel function on descriptors, the k d (d α ,d β ) is defined as 
         [0000]      exp(−γ d   ∥d   α   −d   β ∥)
 
         [0000]    where γ d  is an appropriately chosen weight parameter, or 
         [0000]      (&lt; d   α   ,d   β   &gt;+c ) p    
         [0000]    where p is the degree (interaction order) parameter and c is a parameter controlling contribution of the lower order terms. 
         [0071]    Non-Linear Extensions 
         [0072]    For a kernel K(•,•) its non-linear polynomial extension is defined as 
         [0000]        K   poly ( X,Y|p,c )=( K ( X,Y )+ c ) p    
         [0073]    where p is the degree of the polynomial and c is the constant weighting contributions of lower order terms with respect to higher order terms. To capture higher-order interactions between features describing the peptide sequence, a polynomial expansion of the first-order feature set 
         [0000]        x =( x   1   ,x   2   , . . . ,x   n ), 
         [0000]    e.g., by adding second-order terms 
         [0000]        x   2 =( x   1   ,x   2   , . . . ,x   n   ,x   1   x   2   ,x   1   x   3   , . . . ,x   1   x   n   ,x   2   x   3   ,x   2   x   4   , . . . ,x   2   x   n   , . . . ,x   n −1 x   n )
 
         [0000]    can be used. In general, the inner-product (x p ,y p ) between two expanded feature sets x p  and y p  with p-order terms can then be computed (approximately) as 
         [0000]      (( x,y )+ c ) p    
         [0074]    where x and y are first-order feature vectors describing peptides X and Y. 
         [0075]    For example, using binary descriptors d i  for each position i, p-order interactions between peptide positions can be captured with the following polynomial kernel 
         [0000]      (( d   X   d   Y )+ c ) p    
         [0000]    where d X =d 1 d 2  . . . d nX  is a peptide descriptor vector (obtained by joining descriptor vectors over all positions in the descriptor sequence matrix form ( FIG. 4A ). 
         [0076]      FIG. 5  shows the placement of the computational method in the machine learning pipeline for training and prediction. The design of the kernel functions here is such that it constructs descriptor sequence (e.g., spatial feature-context matrix) representations and computes the degree-of-similarity values between peptides based on both the feature similarity (e.g., similarity of individual amino acids, strings of amino acids, or peptide-MHC interactions) and the similarity of the context (e.g., feature location/coordinate, or a set of neighboring features such as amino acids, peptide-MHC residue interaction features, etc) in which these features occur. Using both feature and context similarities, the method models the key aspects in peptide-MHC binding: high-order interactions between positions/amino acid residues/MHC molecule and their physicochemical properties. 
         [0077]    The invention may be implemented in hardware, firmware or software, or a combination of the three. Preferably the invention is implemented in a computer program executed on a programmable computer having a processor, a data storage system, volatile and non-volatile memory and/or storage elements, at least one input device and at least one output device. 
         [0078]    Each computer program is tangibly stored in a machine-readable storage media or device (e.g., program memory or magnetic disk) readable by a general or special purpose programmable computer, for configuring and controlling operation of a computer when the storage media or device is read by the computer to perform the procedures described herein. The inventive system may also be considered to be embodied in a computer-readable storage medium, configured with a computer program, where the storage medium so configured causes a computer to operate in a specific and predefined manner to perform the functions described herein. 
         [0079]    The invention has been described herein in considerable detail in order to comply with the patent Statutes and to provide those skilled in the art with the information needed to apply the novel principles and to construct and use such specialized components as are required. However, it is to be understood that the invention can be carried out by specifically different equipment and devices, and that various modifications, both as to the equipment details and operating procedures, can be accomplished without departing from the scope of the invention itself.