GAN-CNN for MHC peptide binding prediction

Abstract

The invention discloses a method for training a generative adversarial network (GAN) in combination with a convolutional neural network (CNN). The GAN and the CNN may be trained using biological data, such as protein interaction data. The CNN may be used to identify new data as positive or negative. Methods for synthesizing polypeptides associated with new protein interaction data identified as positive are disclosed.

Description

[0001] This application is a divisional application of the invention patent application with the application date of February 18, 2019, application number 201980025487.X, and name “GAN-CNN for MHC Peptide Binding Prediction”.

[0002] CROSS-REFERENCE TO RELATED APPLICATIONS

[0003] This application claims the benefit of U.S. Provisional Application No. 62 / 631,710, filed February 17, 2018, which is hereby incorporated by reference in its entirety. Background Art

[0004] One of the biggest problems facing the use of machine learning is the lack of large annotated datasets. Annotation of data is not only expensive and time consuming, but also highly dependent on the availability of expert observers. The limited amount of training data can inhibit the performance of supervised machine learning algorithms, which typically require very large amounts of data to train to avoid overfitting. To date, a lot of work has been done to extract as much information as possible from the available data. One area that has been particularly affected by the lack of large annotated datasets is the analysis of biological data, such as protein interaction data. The ability to predict how proteins may interact is invaluable for the identification of new therapeutics.

[0005] Advances in immunotherapy are advancing rapidly and are providing new drugs that modulate a patient's immune system to help fight disease, including cancer, autoimmune diseases, and infections. For example, checkpoint inhibitor molecules, such as PD-1 and ligands for PD-1, have been identified and are being used to develop drugs that inhibit or stimulate signaling through PD-1 and thereby modulate a patient's immune system. These new drugs are very effective in some cases, but not in all cases. In approximately 80% of cancer patients, one reason is that their tumors do not have enough cancer antigens to attract T cells.

[0006] Targeting individual tumor-specific mutations is attractive because these specific mutations generate tumor-specific peptides (called neoantigens) that are new to the immune system and do not exist in normal tissues. Compared with tumor-associated self-antigens, neoantigens trigger T cell responses in the thymus that are not affected by host central tolerance and also produce less toxicity from autoimmune reactions against non-malignant cells (Nature Biotechnology 35, 97 (2017)).

[0007] The key issue in new epitope discovery is that the mutated protein is processed by the proteasome into 8- to 11-residue peptides, shuttled to the endoplasmic reticulum by the transporter associated with antigen processing (TAP), and loaded onto the newly synthesized class I major histocompatibility complex (MHC-I) to be recognized by CD8+ T cells (Nature Biotechnology 35, 97 (2017)).

[0008] Computational methods for predicting the interaction of peptides with MHC-I are known in the art. Although some computational methods focus on predicting events occurring during antigen processing (e.g., NetChop) and peptide transport (e.g., NetCTL), most work focuses on modeling peptide binding to MHC-I molecules. Neural network-based methods (such as NetMHC) are used to predict antigen sequences that produce epitopes that match the grooves of the patient's MHC-I molecules. Other filters can be applied to deprioritize hypothetical proteins and measure whether the mutated amino acids may be toward the outside of the MHC (towards the T cell receptor) or reduce the affinity of the epitope to the MHC-I molecule itself (Nature Biotechnology 35, 97 (2017)).

[0009] There are many reasons why these predictions may be incorrect. Sequencing has introduced amplification biases and technical errors in the reads used as starting material for peptides. Modeling epitope processing and presentation must also take into account the fact that humans have about 5,000 alleles encoding MHC-I molecules, with a single patient expressing up to six of them, all with different epitope affinities. Methods (such as NetMHC) typically require 50-100 experimentally determined peptide binding assays for a specific allele to build a model with sufficient accuracy. However, due to the lack of such data for many MHC alleles, "pan-specific" methods (capable of predicting binders based on whether MHC alleles with similar contact environments have similar binding specificities) are gaining attention.

[0010] Therefore, there is a need for improved systems and methods for generating data sets, particularly biological data sets, for machine learning applications. Peptide binding prediction techniques may benefit from such improved systems and methods. Therefore, it is an object of the present invention to provide computer-implemented systems and methods with improved capabilities for generating data sets for training machine learning applications to make predictions, including predictions of peptide binding to MHC-I. Summary of the invention

[0011] It is to be understood that both the following general description and the following detailed description are exemplary and explanatory only and are not restrictive.

[0012] Disclosed are methods and systems for training a generative adversarial network (GAN), the methods and systems comprising: generating increasingly accurate positive simulated data by a GAN generator until a GAN discriminator classifies the positive simulated data as positive, presenting the positive simulated data, positive real data, and negative real data to a convolutional neural network (CNN) until the CNN classifies each type of data as positive or negative, presenting the positive real data and the negative real data to the CNN to generate a prediction score, making an assay based on the prediction score (regardless of whether the GAN is trained), and outputting the GAN and the CNN. The method may be repeated until the GAN is satisfactorily trained. The positive simulated data, the positive real data, and the negative real data include biological data. The biological data may include protein-protein interaction data. The biological data may include polypeptide-MHC-I interaction data. The positive simulated data may include positive simulated polypeptide-MHC-I interaction data, the positive real data includes positive real polypeptide-MHC-I interaction data, and the negative real data includes negative real polypeptide-MHC-I interaction data.

[0013] Other advantages will be partially set forth in the following description or may be learned through practice. Said advantages will be realized and obtained by means of the elements and combinations particularly pointed out in the appended claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] The accompanying drawings, which are incorporated in and constitute a part of this specification, illustrate embodiments and, together with the description, serve to explain the principles of the methods and systems:

[0015] Figure 1 is a flowchart of the instance method.

[0016] Figure 2 is an exemplary flow chart illustrating a portion of the process of predicting peptide binding, including generating and training a GAN model.

[0017] Figure 3 is an exemplary flow chart illustrating a portion of the process of predicting peptide binding, including using a trained GAN model to generate data and training a CNN model.

[0018] Figure 4 is an exemplary flow chart illustrating a portion of a process for predicting peptide binding, including completing training a CNN model and using the trained CNN model to generate prediction values ​​for peptide binding.

[0019] Figure 5A is an exemplary data flow diagram of a typical GAN.

[0020] Figure 5B is an exemplary data flow diagram of the GAN generator.

[0021] Figure 6 is an exemplary block diagram of a portion of the processing stages included in a generator used in a GAN.

[0022] Figure 7 is an exemplary block diagram of a portion of the processing stages included in a generator used in a GAN.

[0023] Figure 8 is an exemplary block diagram of a portion of the processing stages included in a discriminator used in a GAN.

[0024] Fig. 9 is an exemplary block diagram of a portion of the processing stages included in a discriminator used in a GAN.

[0025] Fig.10 is a flowchart of the instance method.

[0026] Fig.11 is an exemplary block diagram of a computer system in which the processes and structures involved in predicting peptide binding can be implemented.

[0027] Fig.12 is a table showing the results of the specified prediction model for predicting proteins that bind to the MHC-I protein complex for the specified HLA allele.

[0028] Fig.13A is a table showing data for comparing prediction models.

[0029] Fig. 13B Here is a bar graph comparing the AUC of our implementation of the same CNN architecture with that of Vang’s paper.

[0030] Fig. 13C is a bar graph comparing the described implementation to existing systems.

[0031] Fig.14 is a table showing the deviance obtained by selecting a deviance test set.

[0032] Fig.15 is a line plot of SRCC vs. test size, which shows that the smaller the test size, the better the SRRC.

[0033] Fig.16A is a table showing data for comparing Adam and RMSprop neural networks.

[0034] Fig. 16B is a histogram comparing the AUC between neural networks trained by Adam and RMSprop optimizers.

[0035] Fig. 16Cis a histogram comparing the SRCC between neural networks trained by Adam and RMSprop optimizers.

[0036] Fig.17 is a table showing that a mixture of fake and real data obtains better predictions than fake data alone. DETAILED DESCRIPTION

[0037] Before disclosing and describing the method and system of the present invention, it should be understood that the method and system are not limited to specific methods, specific components or specific embodiments. It should also be understood that the terminology used herein is only for the purpose of describing specific embodiments and is not intended to be limiting.

[0038] As used in the specification and the appended claims, the singular forms of the words "a", "an", and "the" include plural referents unless the context clearly dictates otherwise. In this article, ranges can be expressed as from "about" one particular value and / or to "about" another particular value. When expressing such a range, another embodiment includes from the one particular value and / or to another particular value. Similarly, when a numerical value is expressed as an approximation by using the antecedent "about", it should be understood that the particular value constitutes another embodiment. It should be further understood that the endpoints of each range are important to and independent of the other endpoint.

[0039] "Optional" or "optionally" means that the subsequently described event or circumstance may or may not occur, and that the description includes instances where said event or circumstance occurs and instances where it does not.

[0040] Throughout the description and claims of this specification, the word "comprising" and variations of the word such as "containing" mean "including but not limited to", and are not intended to exclude, for example, other components, integers or steps. "Exemplary" means "an example" and is not intended to express a preferred or ideal embodiment. "For example" is not used in a limiting sense, but for explanation purposes.

[0041] It should be understood that the method and system are not limited to the specific methods, protocols and reagents described, as they may vary. It should also be understood that the terminology used herein is only for the purpose of describing specific embodiments and is not intended to limit the scope of the method and system, which will only be limited by the appended claims.

[0042] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as those commonly understood by those skilled in the art to which the methods and systems belong. Although any methods and materials similar or equivalent to those described herein can be used in the practice or test of the present invention, particularly useful methods, equipment and materials are as described herein. The publications cited herein and the materials cited therein are hereby expressly incorporated by reference. Nothing herein should be construed as admitting that the present methods and systems are not entitled to be disclosed prior to such disclosure by virtue of prior invention. It is not admitted that any reference constitutes prior art. The discussion of the references states what the author states, and the applicant reserves the right to question the accuracy and relevance of the cited documents. It will be clearly understood that although many publications are mentioned herein, such reference does not constitute an admission that any of these documents form part of the common general knowledge in the art.

[0043] Components that can be used to perform methods and systems are disclosed. These and other components are disclosed herein, and it should be understood that when combinations, subsets, interactions, groupings, etc. of these components are disclosed, although specific references to each of these different individual and collective combination arrangements may not be explicitly disclosed, for all methods and systems, each is specifically contemplated and described herein. This applies to all embodiments of the application, including but not limited to steps in the method. Therefore, if there are multiple additional steps that can be performed, it should be understood that each of these additional steps can be performed using any specific embodiment or combination of embodiments of the method.

[0044] The present method and system may be understood more readily by reference to the following detailed description of the preferred embodiments and the examples included therein and to the drawings and their preceding and following descriptions.

[0045] The method and system may take the form of an all-hardware implementation, an all-software implementation, or an implementation that combines software and hardware implementations. In addition, the method and system may take the form of a computer program product on a computer-readable storage medium, which has computer-readable program instructions (e.g., computer software) contained in the storage medium. More specifically, the method and system may take the form of web-implemented computer software. Any suitable computer-readable storage medium may be utilized, including a hard disk, a CD-ROM, an optical storage device, or a magnetic storage device.

[0046] Embodiments of the method and system are described below with reference to block diagrams and flowchart illustrations of the method, system, apparatus, and computer program product. It should be understood that each block of the block diagram and flowchart illustration, and combinations of blocks in the block diagram and flowchart illustration, respectively, can be implemented by computer program instructions. These computer program instructions can be loaded onto a general-purpose computer, a special-purpose computer, or other programmable data processing device to produce a machine, so that the instructions executed on the computer or other programmable data processing device produce instructions for implementing the process. Figure 1 The way to specify the functions in one or more boxes.

[0047] These computer program instructions may also be stored in a computer-readable memory, which may instruct a computer or other programmable data processing device to function in a specific manner so that the instructions stored in the computer-readable memory produce instructions including those for implementing the process. Figure 1 The computer program instructions can also be loaded into a computer or other programmable data processing device to cause a series of operation steps to be executed on the computer or other programmable device to produce a computer-implemented process, so that the instructions executed on the computer or other programmable device provide the instructions for implementing the process. Figure 1 Steps to specify a function in one or more boxes.

[0048] Therefore, the blocks of the block diagrams and flow charts support combinations of modes for performing specified functions, combinations of steps for performing specified functions, and program instruction means for performing specified functions. It should also be understood that each block of the block diagrams and flow charts and combinations of blocks in the block diagrams and flow charts can be implemented by a computer system based on dedicated hardware that performs the specified functions or steps, or a combination of dedicated hardware and computer instructions.

[0049] I. Definitions

[0050] The abbreviation "SRCC" refers to the Spearman rank correlation coefficient (SRCC) calculation.

[0051] The term "ROC curve" refers to the receiver operating characteristic curve.

[0052] The abbreviation "CNN" refers to Convolutional Neural Network.

[0053] The abbreviation “GAN” stands for Generative Adversarial Network.

[0054] The term "HLA" refers to human leukocyte antigen. The HLA system or complex is a complex of genes that encodes the major histocompatibility complex (MHC) proteins of humans. The major HLA class I genes are HLA-A, HLA-B, and HLA-C, while HLA-E, HLA-F, and HLA-G are minor genes.

[0055] The term "MHC I" or "Major Histocompatibility Complex I" refers to a group of cell surface proteins composed of an α chain with three domains - α1, α2 and α3. The α3 domain is a transmembrane domain, while the α1 and α2 domains are responsible for forming the peptide binding groove.

[0056] "Polypeptide-MHC I interaction" refers to the binding of a polypeptide in the peptide binding groove of MHC I.

[0057] As used herein, "biological data" refers to any data derived from measuring the biological conditions of humans, animals or other organisms (including microorganisms, viruses, plants and other living organisms). Measurements can be made by any test, assay or observation known to doctors, scientists, diagnosticians, etc. Biological data may include, but are not limited to, DNA sequences, RNA sequences, protein sequences, protein interactions, clinical tests and observations, physical and chemical measurements, genome assays, proteome assays, drug levels, hormone and immunology test results, neurochemical or neurophysical measurements, mineral and vitamin level assays, genetic and family histories, and other assays that provide insight into the state of one or more individuals being examined. In this article, the use of the term "data" is interchangeable with "biological data".

[0058] II. Systems for Predicting Peptide Binding

[0059] One embodiment of the present invention provides a system for predicting the binding of peptides to MHC-I, the system having a generative adversarial network (GAN)-convolutional neural network (CNN) framework, also referred to as a deep convolutional generative adversarial network. The GAN contains a CNN discriminator and a CNN generator, and can train existing peptide-MHC-I binding data. The disclosed GAN-CNN system has several advantages over existing systems for predicting peptide-MHC-I binding, including but not limited to the ability to train for unlimited alleles and better prediction performance. Although described herein for predicting the binding of peptides to MHC-I, the methods and systems of the present invention are not limited thereto. The prediction of the binding of peptides to MHC-I is provided as an example application of the improved GAN-CNN system described herein. The improved GAN-CNN system is suitable for generating a variety of biological data for various prediction results.

[0060] A. Exemplary Neural Network Systems and Methods

[0061] Figure 1 100 is a flow chart of an example method. Starting from step 110, the generator of the GAN (see Figure 5A504) to generate increasingly accurate positive simulation data. The positive simulation data may include biological data, such as protein interaction data (e.g., binding affinity). Binding affinity is an example of a measure of the strength of a binding interaction between a biological molecule (e.g., protein, DNA, drug, etc.) and a biological molecule (e.g., protein, DNA, drug, etc.). Binding affinity can be expressed numerically as half the maximum inhibitory concentration value (IC 50 ). Smaller numbers indicate higher affinity. Peptides with IC50 values ​​<50 nM are considered high affinity, <500 nM are medium affinity, and <5000 nM are low affinity. 50 Can be converted to binding categories, such as binding (1) or not binding (-1).

[0062] The positive simulation data may include positive simulation polypeptide-MHC-I interaction data. Generating positive simulation polypeptide-MHC-I interaction data may be based at least in part on real polypeptide-MHC-I interaction data. Protein interaction data may include a binding affinity score (e.g., IC) representing the likelihood of two proteins binding. 50, binding category). Protein interaction data (such as polypeptide-MHC-I interaction data) can be received from, for example, a plurality of databases: the databases such as PepBDB, PepBind, the Protein Data Bank, the Biomolecular Interaction Network Database (BIND), Cellzome (Heidelberg, Germany), the Database of Interacting Proteins (DIP), Dana-Farber Cancer Institute (Boston, MA, USA), the Human Protein Reference Database (HPRD), Hybrigenics (Paris, France), IntAct of the European Bioinformatics Institute (EMBL-EBI, Hinxton, UK), the Molecular Interactions (MINT, Rome, Italy) database, the Protein-Protein Interaction Database (PPID, Edinburgh, UK), and the search tool for retrieving interacting genes / proteins (STRING, EMBL, Heidelberg, Germany), etc. Protein interaction data can be stored in a data structure, and the data structure includes one or more of the instructions of a specific polypeptide sequence and the interaction (e.g., the interaction between a polypeptide sequence and MHC-I) of a polypeptide. In one embodiment, the data structure can conform to the HUPO PSI molecular interaction (PSIMI) format, and the format can include one or more entries, wherein the entry describes one or more protein interactions. The data structure can indicate the source of the entry, for example, a data provider. The release number and the release date assigned by the data provider can be indicated. The availability list can provide a statement about data availability. The experimental list can indicate an experimental description including at least one set of experimental parameters (usually associated with a single publication). In large-scale experiments, usually only one parameter (usually bait (protein of concern)) changes in a series of experiments. The PSIMI format can indicate both constant parameters (e.g., experimental techniques) and variable parameters (e.g., bait). The interactor list can indicate a group of interactors (e.g., proteins, small molecules, etc.) participating in the interaction. Protein interactors elements can indicate the "normal" form of proteins that are typically present in databases such as Swiss-Prot and TrEMBL, which can include data such as names, cross-references, organisms, and amino acid sequences. An interaction list can indicate one or more interaction elements. Each interaction can indicate an availability description (a description of data availability) and a description of the experimental conditions under which availability has been determined. Interactions can also indicate confidence attributes. Different metrics for the confidence of interactions have been developed, for example, parallel homology validation methods and protein interaction maps (PIM) biological scores.Each interaction may indicate a participant list containing two or more protein participant elements (i.e., proteins participating in the interaction). Each protein participant element may include a description of the molecule in its native form and / or a specific form of the molecule participating in the interaction. A feature list may indicate sequence features of the protein, such as binding domains or post-translational modifications associated with the interaction. A role may be indicated that describes a specific role of the protein in the experiment—for example, whether the protein is bait or prey. Some or all of the foregoing elements may be stored in a data structure. An example data structure may be an XML file, such as:.

[0063] <entry>

[0064] <interactorlist>

[0065] <Interactor id="Succinate>

[0066] <names>

[0067] <shortlabel> Succinate< / shortlabel>

[0068] <fullname> Succinate< / fullname>

[0069] < / names>

[0070]

[0071] < / interactorlist>

[0072]

[0073] GANs may include, for example, deep convolutional GANs (DCGANs). Figure 5A , showing an example of the basic structure of a GAN. GAN is essentially a method of training a neural network. GAN typically contains two independent neural networks that work independently and can act as opponents, namely a discriminator 502 and a generator 504. The discriminator 502 can be a neural network that will be trained using training data generated by the generator 504. The discriminator 502 may include a classifier 506, which may be trained to perform the task of distinguishing between data samples. The generator 504 may generate random data samples similar to real samples, but the random data samples may be generated to include, or may be modified to include features that appear to be pseudo-samples or artificial samples. The neural network including the discriminator 502 and the generator 504 may typically be implemented by a multi-layer network consisting of multiple processing layers, such as dense processing, batch normalization processing, activation processing, input reconstruction processing, Gaussian filtering processing, Gaussian noise processing, two-dimensional convolution, and two-dimensional upsampling. This is described below Figure 6 – Fig. 9 is shown in more detail.

[0074] For example, classifier 506 can be designed to identify data samples that indicate various characteristics. Generator 504 can include an adversary function 508 that can use almost, but not quite, correct data samples to generate data designed to deceive discriminator 502. For example, this can be done by randomly picking legitimate samples from training set 510 (latent space) and synthesizing data samples (data space) by randomly changing features, such as by adding random noise 512. The generator network G can be thought of as a mapping from some latent space to data space. This can be formally expressed as G: G(z)R |x| , where z R |x| is a sample from the latent space, x R |x| are samples from the data space, and |·| denotes the dimension.

[0075] The discriminator network D can be thought of as a mapping from data space to the probability that the data (e.g., a peptide) comes from a real dataset rather than a generated (pseudo or artificial) dataset. This can be formally expressed as: D: D(x)(0;1). During training, the discriminator 502 can be presented by a randomizer 514, which has legitimate data samples 516 from real training data, and a random mixture of pseudo or artificial (e.g., simulated) data samples generated by the generator 504. For each data sample, the discriminator 502 can attempt to identify legitimate and pseudo or artificial inputs, resulting in a result 518. For example, for a fixed generator G, the discriminator D can be trained to classify data (e.g., a peptide) as coming from the training data (real, close to 1) or from the fixed generator (simulated, close to 0). For each data sample, the discriminator 502 can further attempt to identify positive inputs or negative inputs (regardless of whether the input is simulated or real), resulting in a result 518.

[0076] According to a series of results 518, both the discriminator 502 and the generator 504 can try to fine-tune their parameters to improve their operation. For example, if the discriminator 502 makes a correct prediction, the generator 504 can update its parameters to generate better simulated samples to deceive the discriminator 502. If the discriminator 502 makes an incorrect prediction, the discriminator 502 can learn from its mistakes to avoid similar mistakes. Therefore, the update of the discriminator 502 and the generator 504 can involve a feedback process. The feedback process can be continuous or incremental. The generator 504 and the discriminator 502 can be iteratively executed to optimize data generation and data classification. In the incremental feedback process, the state of the generator 504 is frozen, and the discriminator 502 is trained until the balance is established and the training of the discriminator 502 is optimized. For example, for the frozen state of a given generator 504, the discriminator 502 can be trained so that it is optimized relative to the state of the generator 504. This optimized state of the discriminator 502 can then be frozen, and the generator 504 can be trained to reduce the accuracy of the discriminator to a certain predetermined threshold. The state of the generator 504 can then be frozen, and the discriminator 502 can be trained, and so on.

[0077] In a continuous feedback process, instead of training the discriminator until its state is optimized, the discriminator can be trained only once or for a small number of iterations, and the generator can be updated simultaneously with the discriminator.

[0078] If the generated simulated dataset distribution can completely match the real dataset distribution, the discriminator will be maximally confused and unable to distinguish between real and fake samples (predicting 0.5 for all inputs).

[0079] return Figure 1 110, can be performed (e.g., by generator 504) to generate more and more accurate positive simulation polypeptide-MHC-I interaction data, until the discriminator 502 of GAN classifies the positive simulation polypeptide-MHC-I interaction data as positive. In another aspect, can be performed (e.g., by generator 504) to generate more and more accurate positive simulation polypeptide-MHC-I interaction data, until the discriminator 502 of GAN classifies the positive simulation polypeptide-MHC-I interaction data as positive. For example, generator 504 can generate more and more accurate positive simulation polypeptide-MHC-I interaction data by generating a first simulated data set including positive simulation polypeptide-MHC-I interaction for MHC alleles. The first simulated data set can be generated according to one or more GAN parameters. GAN parameters can include, for example, allele type (e.g., HLA-A, HLA-B, HLA-C or their subtypes), allele length (e.g., about 8 to 12 amino acids, about 9 to 11 amino acids), generation category, model complexity, learning rate, batch size or one or more of another parameter.

[0080] Figure 5B is an exemplary data flow diagram of a GAN generator configured to generate positive simulated polypeptide-MHC-I interaction data for MHC alleles. Figure 5B As shown, a Gaussian noise vector can be input into a generator of an output distribution matrix. The input noise sampled from the Gaussian provides variability that mimics different binding modes. The output distribution matrix represents the probability distribution of selecting each amino acid for each position in the peptide sequence. The distribution matrix can be normalized to eliminate selections that are unlikely to provide a binding signal, and a specific peptide sequence can be sampled from the normalized distribution matrix.

[0081] Then, the first simulated data set can be combined with positive real polypeptide interaction data and / or negative real polypeptide interaction data (or a combination thereof) for MHC alleles to generate a GAN training set. Discriminator 502 can then determine (e.g., according to a decision boundary) whether the polypeptide-MHC-I interaction for MHC alleles in the GAN training data set is positive or negative and / or simulated or real. Depending on the accuracy of the determination performed by discriminator 502 (e.g., whether discriminator 502 correctly identifies polypeptide-MHC-I interactions as positive or negative and / or simulated or real), one or more GAN parameters or decision boundaries can be adjusted. For example, one or more GAN parameters of the decision boundary can be adjusted to optimize discriminator 502, thereby increasing the possibility of giving positive real polypeptide-MHC-I interaction data with high probability, giving positive simulated polypeptide-MHC-I interaction data with low probability, and / or giving negative real polypeptide-MHC-I interaction data with low probability. One or more GAN parameters of the decision boundary may be adjusted to optimize the generator 504 to increase the probability that positively simulated polypeptide-MHC-I interaction data will be scored highly.

[0082] The process of generating a first simulated data set, combining the first data set with positive real polypeptide interaction data and / or negative real polypeptide interaction data to generate a GAN training data set, determining by the discriminator, and adjusting the GAN parameters and / or the decision boundary can be repeated until a first stopping criterion is met. For example, whether the first stopping criterion is met can be determined by evaluating a gradient descent expression for the generator 504. For another example, whether the first stopping criterion is met can be determined by evaluating a mean square error (MSE) function:

[0083]

[0084] As another example, whether the first stopping criterion is met can be determined by evaluating whether the gradient is large enough to continue meaningful training. Because the generator 504 is updated by the back-propagation algorithm, each layer of the generator will have one or more gradients. For example, if a graph has 2 layers and each layer has 3 nodes, then Figure 1 The output is 1-dimensional (scalar), and the data is 2-dimensional. In this figure, the first layer has 2*3=6 edges (w111, w112, w121, w122, w131, w132), which are connected to the data, and w111*data1+w112*data2=net11, and the S-shaped activation function can be used to obtain the output o11=S-shaped (net11), and similarly o12 and o13 can be obtained, which form the output of the first layer; the second layer has 3*3=9 edges (w211, w212, w213, w221, w222, w223, w231, w232, w233), which are connected to the output of the first layer, and the output of the second layer is o21, o22, o23, which is connected to the final output with 3 edges, namely w311, w312, w313.

[0085] Each w in this graph has a gradient (an instruction on how to update w, essentially a number to increase) which can be calculated by an algorithm called backpropagation, which follows the idea of ​​changing the parameters in the direction that the loss (MSE) decreases, i.e.:

[0086]

[0087] Where E is the MSE error, w ij is the i-th parameter of the j-th layer. j is the output of layer j, net j is the product result before activation on the jth layer. And if for w ij , value de / dw ij (gradient) is not large enough, the result is that the training does not bring w of generator 504 ij changes and training should be stopped.

[0088] Then, after the GAN discriminator 502 classifies the positive simulation data (e.g., positive simulation polypeptide-MHC-I interaction data) as positive and / or true, in step 120, the positive simulation data, positive true data and / or negative true data (or a combination thereof) can be presented to the CNN until the CNN classifies each type of data as positive or negative. The positive simulation data, positive true data and / or negative true data can include biological data. The positive simulation data can include positive simulation polypeptide-MHC-I interaction data. The positive true data can include positive true polypeptide-MHC-I interaction data. The negative true data can include negative true polypeptide-MHC-I interaction data. The classified data can include polypeptide-MHC-I interaction data. Each of the positive simulation polypeptide-MHC-I interaction data, the positive true polypeptide-MHC-I interaction data and the negative true polypeptide-MHC-I interaction data can be associated with a selected allele. For example, the selected allele can be selected from A0201, A202, A203, B2703, B2705 and a combination thereof.

[0089] Presenting the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the CNN may include, for example, generating a second simulated data set according to the GAN parameter set by the generator 504, wherein the second simulated data set includes positive simulated polypeptide-MHC-I interactions for the MHC alleles. The second simulated data set may be combined with the positive real polypeptide interaction data and / or the negative real polypeptide interaction data (or a combination thereof) for the MHC alleles to generate a CNN training data set.

[0090] The CNN training data set can then be presented to the CNN to train the CNN. The CNN can then classify the polypeptide-MHC-I interaction as positive or negative based on one or more CNN parameters. This can include performing a convolution procedure, performing a non-linear (e.g., ReLu) procedure, performing a pooling or subsampling procedure, and / or performing a classification (e.g., fully connected layer) procedure by the CNN.

[0091] Based on the accuracy of the classification performed by the CNN, one or more CNN parameters can be adjusted. The process of generating a second simulated data set, generating a CNN training data set, classifying polypeptide-MHC-I interactions, and adjusting one or more CNN parameters can be repeated until a second stopping criterion is met. For example, whether the second stopping criterion is met can be determined by evaluating a mean square error (MSE) function.

[0092] Then, in step 130, the positive real data and / or the negative real data can be presented to the CNN to generate a prediction score. The positive real data and / or the negative real data can include biological data, such as binding affinity data. The positive real data can include positive real polypeptide-MHC-I interaction data. The negative real data can include negative real polypeptide-MHC-I interaction data. The prediction score can be a binding affinity score. The prediction score can include the probability that the positive real polypeptide-MHC-I interaction data is classified as positive polypeptide-MHC-I interaction data. This can include presenting the real data set to the CNN, and the CNN classifying the polypeptide-MHC-I interaction for the MHC allele as positive or negative according to the CNN parameters.

[0093] At step 140, it may be determined whether the GAN is trained based on the prediction scores. This may include determining whether the GAN is trained by determining the accuracy of the CNN based on the prediction scores. For example, if a third stopping criterion is met, the GAN may be determined to be trained. Determining whether the third stopping criterion is met may include determining whether an area under the curve (AUC) function is met. Determining whether the GAN is trained may include comparing one or more prediction scores to a threshold. If the GAN is determined to be trained in step 140, the GAN may optionally be output in step 150. If the GAN is not determined to be trained, the GAN may return to step 110.

[0094] After training the CNN and GAN, a data set (e.g., an unclassified data set) can be presented to the CNN. The data set can include unclassified biological data, such as unclassified protein interaction data. The biological data can include multiple candidate polypeptide-MHC-I interactions. The CNN can generate predicted binding affinities and / or classify each candidate polypeptide-MHC-I interaction as positive or negative. Then, polypeptides can be synthesized using those interactions that are classified as positive candidate polypeptide-MHC-I interactions. For example, a polypeptide can include a tumor-specific antigen. For another example, a polypeptide can include an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

[0095] A more detailed exemplary flowchart of the prediction process 200 using a generative adversarial network (GAN) is shown in Figure 2 – Figure 4 202-214 usually correspond to Figure 1 110 shown. Process 200 may begin at 202, where GAN training is set, for example, by setting a plurality of parameters 204-214 to control GAN ​​training 216. Examples of parameters that may be set may include allele type 204, allele length 206, generation category 208, model complexity 210, learning rate 212, and batch size 214. Allele type parameters 204 may provide the ability to specify one or more allele types to be included in the GAN process. Examples of these allele types may include Fig.12 For example, a specified allele may include Fig.12 A0201, A0202, A0203, B2703, B2705, etc. are shown. Allele length parameters 206 can provide the ability to specify the length of peptides that can bind to each specified allele type 204. Examples of these lengths are shown in Figure 13. For example, for A0201, the specified length is shown as 9 or 10, for A0202, the specified length is shown as 9, for A0203, the specified length is shown as 9 or 10, for B2705, the specified length is shown as 9, and so on. Generation category parameters 208 can provide the ability to specify the category of data to be generated during GAN training 216. For example, a binding / non-binding category can be specified. A set of parameters corresponding to model complexity 210 can provide the ability to specify aspects of the complexity of the model to be used during GAN training 216. Examples of these aspects can include the number of layers, the number of nodes per layer, the window size of each convolutional layer, etc. The learning rate parameters 212 may provide the ability to specify one or more rates at which the learning process performed in the GAN training 216 converges. Examples of these learning rate parameters may include 0.0015, 0.015, 0.01, which are unitless values ​​that specify relative learning rates. The batch size parameters 214 may provide the ability to specify the batch size of the training data 218 to be processed during the GAN training 216. Examples of these batch sizes may include batches with 64 or 128 data samples. The GAN training setup process 202 may collect the training parameters 204-214, process them to be compatible with the GAN training 216, and input the processed parameters to the GAN training 216 or store the processed parameters in an appropriate file or location for use by the GAN training 216.

[0096] At 216, GAN training may begin. 216-228 also generally correspond to Figure 1 110 shown in . GAN training 216 can ingest training data 218, for example, in batches specified by batch size parameter 214. Training data 218 can include data representing peptides with different binding affinity names (binding or not binding) for MHC-I protein complexes encoded by different allele types (such as HLA allele types, etc.). For example, these training data can include information related to positive / negative MHC-peptide interaction frames and selections. The training data can include one or more of positive simulated polypeptide-MHC-I interaction data, positive real polypeptide-MHC-I interaction data, and / or negative real polypeptide-MHC-I interaction data.

[0097] At 220, a gradient descent process can be applied to the ingested training data 218. Gradient descent is an iterative process that performs machine learning (such as finding the minimum or local minimum of a function). For example, in order to find the minimum or local minimum of a function using gradient descent, the variable value is updated with a step size proportional to the negative value of the function gradient (or approximate gradient) at the current point. For machine learning, gradient descent can be used to search the parameter space. Different gradient descent strategies can find different "targets" in the parameter space, thereby limiting the prediction error to an acceptable level. In multiple embodiments, the gradient descent process can adapt the learning rate to the input parameters, for example, performing larger updates to infrequent parameters and smaller updates to frequent parameters. These embodiments can be suitable for processing sparse data. For example, a gradient descent strategy called RMSprop can provide improved performance for peptide binding data sets.

[0098] At 221, a loss metric may be applied to measure the loss or "cost" of the process. Examples of these loss metrics may include mean squared error or cross entropy.

[0099] At 222, it can be determined whether an exit criterion for gradient descent has been triggered. Since gradient descent is an iterative process, criteria can be specified to determine when the iterative process should stop to indicate that the generator 228 is able to generate positive simulated polypeptide-MHC-I interaction data that is classified as positive and / or true by the discriminator 226. At 222, if it is determined that the exit criterion for gradient descent has not been triggered, the process can return to 220 and the gradient descent process continues. At 222, if it is determined that the exit criterion for gradient descent has been triggered, the process can continue to 224, where the discriminator 226 and the generator 228 can be trained, for example as described in reference Figure 5A At 224, trained models for the discriminator 226 and the generator 228 may be stored. These stored models may include data defining the structure and coefficients of the models that make up the discriminator 226 and the generator 228. The stored models provide the ability to generate artificial data using the generator 228 and to identify data using the discriminator 226, and provide accurate and useful results from the discriminator 226 and the generator 228 after appropriate training.

[0100] The process may then proceed to 230-238, which generally correspond to Figure 1 120 shown in . At 230-238, the generated data samples (e.g., positive simulated polypeptide-MHC-I interaction data) can be generated using the trained generator 228. For example, at 230, the GAN generation process can be set, for example, by setting multiple parameters 232, 234 to control the GAN generation 236. Examples of parameters that can be set can include a generation size 232 and a sampling size 234. The generation size parameter 232 can provide the ability to specify the size of the data set to be generated. For example, the generated (positive simulated polypeptide-MHC-I interaction data) data set size can be set to 2.5 times the size of the real data (positive real polypeptide-MHC-I interaction data and / or negative real polypeptide-MHC-I interaction data). In this example, if the original real data in the batch is 64, the corresponding generated simulated data in the batch is 160. The sampling size parameter 234 can provide the ability to specify the sampling size to be used to generate the data set. For example, the parameter can be specified as a truncation percentage selected for 20 amino acids in the last layer of the generator. As an example, the 90th percentile norm means that all points less than the 90th percentile will be set to 0, and the remaining points can be normalized using a normalization function (such as a normalized exponential (softmax) function). At 236, the trained generator 228 can be used to generate a data set 236 that can be used to train a CNN model.

[0101] At 240, the simulated data samples 238 generated by the trained generator 228 and the real data samples from the original data set can be mixed to form a new training data set 240, such as generally corresponding to Figure 1 120 shown in . Training data 240 may include one or more of positive simulated polypeptide-MHC-I interaction data, positive real polypeptide-MHC-I interaction data and / or negative real polypeptide-MHC-I interaction data. At 242-262, a convolutional neural network (CNN) classifier model 262 may be trained using the mixed training data 240. At 242, CNN training may be set, for example, by setting multiple parameters 244-252 to control CNN training 254. Examples of parameters that may be set may include allele type 244, allele length 246, model complexity 248, learning rate 250, and batch size 252. Allele type parameters 244 may provide the ability to specify one or more allele types as included in the CNN processing. Examples of these allele types may include Fig.12 For example, a specified allele may include Fig.12 A0201, A0202, B2703, B2705, etc. are shown. Allele length parameters 246 can provide the ability to specify the length of a peptide that can bind to each specified allele type 244. Examples of these lengths are Fig.13A As shown. For example, for A0201, the specified length is shown as 9 or 10, for A0202, the specified length is shown as 9, for B2705, the specified length is shown as 9, and so on. The set of parameters corresponding to model complexity 248 can provide the ability to specify aspects of the complexity of the model to be used during CNN training 254. Examples of these aspects can include the number of layers, the number of nodes per layer, the window size of each convolutional layer, etc. The learning rate parameter 250 can provide the ability to specify one or more ratios at which the learning process performed in CNN training 254 converges. Examples of these learning rate parameters can include 0.001, which is a unitless parameter that specifies a relative learning rate. The batch size parameter 252 can provide the ability to specify the batch size of the training data 240 to be processed during CNN training 254. For example, if the training data set is divided into 100 equal parts, the batch size can be an integer form of training data size (train_data_size) / 100. The CNN training setup process 242 may collect the training parameters 244 - 252 , process them to be compatible with the CNN training 254 , and input the processed parameters into the CNN training 254 or store the processed parameters in an appropriate file or location for use by the CNN training 254 .

[0102] At 254, CNN training can begin. CNN training 254 can ingest training data 240, for example, in batches specified by batch size parameter 252. At 256, a gradient descent process can be applied to the ingested training data 240. As described above, gradient descent is an iterative process that performs machine learning (such as finding the minimum or local minimum of a function). For example, a gradient descent strategy called RMSprop can provide improved performance for a peptide binding dataset.

[0103] At 257, a loss metric may be applied to measure the loss or “cost” of the process. Examples of these loss metrics may include mean squared error or cross entropy.

[0104] At 258, it can be determined whether the exit criteria for gradient descent have been triggered. Since gradient descent is an iterative process, criteria can be specified to determine when the iterative process should stop. At 258, if it is determined that the exit criteria for gradient descent have not been triggered, the process can return to 256, and the gradient descent process continues. At 258, if it is determined that the exit criteria for gradient descent have been triggered (this indicates that gCNN is able to classify positive (real or simulated) polypeptide-MHC-I interaction data as positive and / or classify negative real polypeptide-MHC-I interaction data as negative), the process can proceed to 260, wherein the CNN classifier model 262 can be stored as a CNN classifier model 262. These stored models can include data defining the structure and coefficients of the CNN classifier model 262. The stored model provides the ability to classify the peptide binding of the input data sample using the CNN classifier model 262, and after appropriate training, provides accurate and useful results from the CNN classifier model 262. At 264, CNN training ends.

[0105] At 266-280, the trained convolutional neural network (CNN) classifier model 262 can be used to provide and evaluate predictions based on test data (the test data can include one or more of positive true polypeptide-MHC-I interaction data and / or negative true polypeptide-MHC-I interaction data) to measure the performance of the overall GAN ​​model, such as generally corresponding to Figure 1 130 shown in . At 270, the GAN exit criteria can be set, for example, by setting a plurality of parameters 272-276 to control the evaluation process 266. Examples of parameters that can be set can include accuracy of prediction parameters 272, prediction confidence parameters 274, and loss parameters 276. The accuracy of the prediction parameters 272 can provide the ability to specify the accuracy of the predictions to be provided by the evaluation 266. For example, the accuracy threshold for predicting a true positive class can be greater than or equal to 0.9. The prediction confidence parameter 274 can provide the ability to specify the confidence level (e.g., softmax normalization) of the predictions to be provided by the evaluation 266. For example, the confidence threshold for predicting a pseudo or artificial class can be set to a value such as greater than or equal to 0.4, and for a true negative class, a value greater than or equal to 0.6. The GAN exit criteria setup process 270 may collect training parameters 272-276, process them to be compatible with the GAN prediction evaluation 266, and input the processed parameters to the GAN prediction evaluation 266 or store the processed parameters in an appropriate file or location for use by the GAN prediction evaluation 266. At 266, the GAN prediction evaluation may be started. The GAN prediction evaluation 266 may ingest test data 268.

[0106] At 267, a measurement of the area under the receiver operating characteristic (ROC) curve (AUC) can be performed. AUC is a normalized measure of classification performance. AUC measures the likelihood that given two random points (one from the positive class and one from the negative class), the classifier will rank the point from the positive class before the point from the negative class. In effect, it measures the performance of the ranking. AUC holds that the more predicted classes are all mixed together (in the classifier output space), the worse the classifier. ROC uses a moving boundary to scan the classifier output space. At each point scanned, the false positive rate (FPR) and true positive rate (TPR) are recorded (as a normalized measure). The greater the difference between the two values, the fewer points are mixed, and the better the classification of the values. After all FPR and TPR pairs are obtained, they can be sorted and the ROC curve can be plotted. AUC is the area under the curve.

[0107] At 278, it may be determined whether an exit criterion for gradient descent has been triggered, typically corresponding to Figure 1 140 in. Since gradient descent is an iterative process, criteria may be specified to determine when the iterative process should stop. At 278, if it is determined that the exit criteria for the evaluation process 266 are not triggered, the process may return to 220, and the training process 220-264 and the evaluation process 266 of the GAN continue. Thus, when the exit criteria are not triggered, the process will return to the GAN training (usually corresponding to returning to Figure 1 At 278, if it is determined that the exit criteria for the evaluation process 266 have been triggered (which indicates that the CNN has classified positive true polypeptide-MHC-I interaction data as positive and / or negative true polypeptide-MHC-I interaction data as negative), the process can continue to 280, where the prediction evaluation process and process 200 ends, which generally corresponds to Figure 1 of 150.

[0108] An example of an implementation of the internal processing structure of the generator 228 is as follows Figure 6 – Figure 7 As shown. In this example, each processing block can perform the indicated processing type and can be performed in the order shown. Note that this is just an example. In multiple embodiments, the type of processing performed and the order in which the processing is performed can be modified.

[0109] Go to Figure 6 to Figure 7 , which describe example processing flows for generator 228. The processing flows are examples only and are not meant to be limiting. The processing included in generator 228 may begin in a dense processing 602 manner, where input data is input into a feedforward neural layer to estimate the spatial variation of the density of the input data. At 604, a batch normalization process may be performed. For example, the normalization process may include adjusting measurements of different scales to a common scale and adjusting the entire probability distribution of data values ​​to align. This normalization may provide an improvement in convergence speed because the original (deep) neural network is sensitive to changes in each layer at the beginning, and the directional parameters are optimized to be able to transfer due to attempts to reduce the error of outliers at the beginning. Batch normalization regularizes these transfers, so they are faster. At 606, an activation process may be performed. For example, the activation process may include tanh, sigmoid function, ReLU (rectified linear unit), or step function, etc. For example, if the input is less than 0, the output of the ReLU is 0, otherwise it is the original input. Compared with other activation functions, it is simpler (less computationally intensive), so it can provide accelerated training. At 608, an input reconstruction process may be performed. For example, such a process may help convert the shape (size) of the input into a target shape that may be accepted as a legitimate input in the next step. At 610, a Gaussian filtering process may be performed. Filtering is a regularization technique used to reduce overfitting of a neural network based on specific training data. Filtering may be performed by removing neural network nodes that may cause or worsen overfitting. Gaussian filtering may use a Gaussian distribution to determine which nodes to remove. This process may provide noise in the form of filtering, but may maintain the mean and variance of the input to their original values ​​according to a Gaussian distribution to ensure self-normalization properties even after filtering.

[0110] At 612, Gaussian noise processing can be performed. Gaussian noise is statistical noise, and its probability density function (PDF) is equal to the probability density function of a normal distribution or a Gaussian distribution. Gaussian noise processing can include adding noise to the data to prevent the model from learning small (usually tiny) changes in the data, thereby improving the robustness to model overfitting. This process can improve prediction accuracy. At 614, a two-dimensional (2D) convolution process can be performed. 2D convolution is an extension of 1D convolution, which is completed by convolving the horizontal and vertical directions simultaneously in a two-dimensional spatial domain, and can provide data smoothing. This process can use multiple moving filters to scan all partial inputs. Each filter can be regarded as a parameter-sharing neural layer, which counts the occurrence of a certain feature (matching filter parameter values) at all positions on the feature map. At 616, a second batch normalization process can be performed. At 618, a second activation process can be performed, at 620, a second Gaussian filtering process can be performed, and at 622, a 2D upsampling process can be performed. The upsampling process may convert the input from the original shape to a desired (mostly larger) shape. For example, resampling or interpolation may be used. For example, the input may be rescaled to a desired size, and interpolation (such as bilinear interpolation) may be used to calculate the value of each point. At 624, a second Gaussian noise process may be performed, and at 626, a two-dimensional (2D) convolution process may be performed.

[0111] continue Figure 7 , at 628, a third batch normalization process may be performed, at 630, a third activation process may be performed, at 632, a third Gaussian filtering process may be performed, and at 634, a third Gaussian noise process may be performed. At 636, a second two-dimensional (2D) convolution process may be performed, and at 638, a fourth batch normalization process may be performed. The activation process may be performed after 638 and before 640. At 640, a fourth Gaussian filtering process may be performed.

[0112] At 642, a fourth Gaussian noise process may be performed, at 644, a third two-dimensional (2D) convolution process may be performed, and at 646, a fifth batch normalization process may be performed. At 648, a fifth Gaussian filtering process may be performed, at 650, a fifth Gaussian noise process may be performed, and at 652, a fourth activation process may be performed. The activation process may use a sigmoid activation function that maps an input from [-infinity, infinity] to an output of [0,1]. Typical data recognition systems may use an activation function in the last layer. However, because of the classification nature of the present technology, the sigmoid function may provide improved MHC binding predictions. The sigmoid function is more powerful than ReLU and may provide a suitable probability output. For example, in this classification problem, the output may be desired as a probability. However, since the sigmoid function may be much slower than ReLU or tanh, it may be undesirable to use the sigmoid function for the previous activation layer for performance reasons. However, because the last dense layer is more directly related to the final output, using the sigmoid function in the activation layer may significantly improve convergence compared to ReLU.

[0113] At 654, a second input reconstruction process may be performed to shape the output into data dimensions (which should later be able to be fed to the discriminator).

[0114] An example of an implementation of the processing flow of the discriminator 226 is as follows Figure 8 – Fig. 9 . The process flow is merely an example and is not meant to be limiting. In this example, each processing block may perform the indicated processing type and may be performed in the order shown. Note that this is merely an example. In various embodiments, the type of processing performed and the order in which the processing is performed may be modified.

[0115] Go to Figure 8 , the processing included in the discriminator 226 can start with a one-dimensional (1D) convolution process 802, which can obtain an input signal, apply a 1D convolution filter on the input, and generate an output. At 804, a batch normalization process can be performed, and at 806, an activation process can be performed. For example, a leaky rectified linear unit (RELU) process can be used to perform the activation process. RELU is a type of activation function for a node or neuron in a neural network. When the node is inactive (the input is less than 0), the leaky RELU can allow a small non-zero gradient. ReLU has a problem called "death", in which when the input of the activation function has a large negative deviation, it always outputs 0. When this happens, the model stops learning. Leaky ReLU solves this problem by providing a uniform non-zero gradient when it is inactive. For example, for x<0, f(x)=α*x, for x>=0, f(x)=x. At 808, an input reconstruction process can be performed, and at 810, a 2D upsampling process can be performed.

[0116] Optionally, at 812, Gaussian noise processing may be performed, at 814, a two-dimensional (2D) convolution processing may be performed, at 816, a second batch normalization processing may be performed, at 818, a second activation processing may be performed, at 820, a second 2D upsampling processing may be performed, at 822, a second 2D convolution processing may be performed, at 824, a third batch normalization processing may be performed, and at 826, a third activation processing may be performed.

[0117] continue Fig. 9 , at 828, a third 2D convolution process may be performed, at 830, a fourth batch normalization process may be performed, at 832, a fourth activation process may be performed, at 834, a fourth 2D convolution process may be performed, at 836, a fifth batch normalization process may be performed, at 838, a fifth activation process may be performed, and at 840, a data flattening process may be performed. For example, the data flattening process may include combining data from different tables or data sets to form a single or reduced number of tables or data sets. At 842, a dense process may be performed. At 844, a sixth activation process may be performed, at 846, a second dense process may be performed, at 848, a sixth batch normalization process may be performed, and at 850, a seventh activation process may be performed.

[0118] The sigmoid function can be used instead of leaky ReLU as the activation function for the last two dense layers. The sigmoid is more powerful than the leaky ReLU and can provide reasonable probabilistic outputs (for example, in classification problems, the output as a probability is desired). However, the sigmoid function is slower than the leaky ReLU, and not all layers need to use the sigmoid. However, because the last two dense layers are more directly related to the final output, the sigmoid significantly improves convergence compared to the leaky ReLU. In multiple embodiments, two dense layers (or fully connected neural network layers) 842 and 846 can be used to obtain sufficient complexity to transform their inputs. Specifically, the complexity of a dense layer may not be enough to convert the convolution result into the discriminator output space, although it may be sufficient for use in the generator 228.

[0119] In one embodiment, a method for using a neural network (e.g., CNN) to classify inputs according to a previous training process is disclosed. The neural network can generate a prediction score, and therefore the input biological data can be classified as successful or unsuccessful according to a neural network previously trained for a set of successful and unsuccessful biological data including the prediction score. The prediction score can be a binding affinity score. The neural network can be used to generate a predicted binding affinity score. The binding affinity score can represent the possibility of a single biomolecule (e.g., protein, DNA, drug, etc.) binding to another biomolecule (e.g., protein, DNA, drug, etc.) with a numerical value. The predicted binding affinity score can represent the possibility of a peptide (e.g., MHC) binding to another peptide with a numerical value. However, to date, due to the inability to robustly predict at least when training a neural network for a small amount of data, machine learning techniques cannot be applied.

[0120] The described method and system solve this problem by using a combination of features to make predictions more robustly. The first feature is to train the neural network using an extended training set of biological data. The extended training set is developed by training a GAN to generate simulated biological data. The extended training set is then used to train the neural network (e.g., using stochastic learning with back propagation, which is a type of machine learning algorithm that uses the gradient of a mathematical loss function to adjust the weights of the network). Unfortunately, the introduction of an extended training set can increase false positives when classifying biological data. Therefore, the second feature of the described method and system is to minimize these false positives by performing an iterative training algorithm as needed, wherein the GAN further participates in generating an updated simulated training set containing higher quality simulated data, and the neural network is retrained using the updated training set. This feature combination provides a robust prediction model that can predict the success of certain biological data (e.g., binding affinity scores) while limiting the number of false positives.

[0121] The data set may include unclassified biological data, such as unclassified protein interaction data. Unclassified biological data may include data about a protein for which a binding affinity score associated with another protein is not available. The biological data may include multiple candidate protein-protein interactions, such as candidate protein-MHC-I interaction data. The CNN may generate a prediction score representing the binding affinity and / or classify each candidate polypeptide-MHC-I interaction as positive or negative.

[0122] In one embodiment, if Fig.10 As shown, a computer-implemented method 1000 for training a neural network for binding affinity prediction may include collecting a set of positive biological data and negative biological data from a database at 1010. The biological data may include protein-protein interaction data. The protein-protein interaction data may include one or more of a sequence of a first protein, a sequence of a second protein, an identifier of a first protein, an identifier of a second protein, and / or a binding affinity score, etc. In one embodiment, the binding affinity score may be 1, which indicates successful binding (e.g., positive biological data), or -1, which indicates unsuccessful binding (e.g., negative biological data).

[0123] The computer-implemented method 1000 may include applying a generative adversarial network (GAN) to the positive biological dataset to generate a simulated positive biological dataset at 1020. Applying the GAN to the positive biological dataset to generate the simulated positive biological dataset may include generating increasingly accurate positive simulated biological data by the GAN generator until the GAN discriminator classifies the positive simulated biological data as positive.

[0124] The computer-implemented method 1000 may include generating, at 1030 , a first training set including the collected positive biological data set, the simulated positive biological data set, and the negative biological data set.

[0125] The computer-implemented method 1000 may include training the neural network in a first phase using the first training set at 1040. Training the neural network in the first phase using the first training set may include presenting positive simulated biological data, positive biological data, and negative biological data to a convolutional neural network (CNN) until the CNN is configured to classify the biological data as positive or negative.

[0126] The computer-implemented method 1000 may include generating a second training set for a second training phase by reapplying the GAN to generate additional simulated positive biological data at 1050. The second training set may be generated based on presenting the positive biological data and the negative biological data to the CNN, thereby generating a prediction score and determining that the prediction score is inaccurate. The prediction score may be a binding affinity score. An inaccurate prediction score indicates that the CNN is not fully trained, which can be traced back to the GAN being incompletely trained. Therefore, one or more iterations of the GAN generator may be performed to generate increasingly accurate positive simulated biological data until the GAN discriminator classifies the positive simulated biological data as positive to generate additional simulated positive biological data. The second training set may include positive biological data, simulated positive biological data, and negative biological data.

[0127] The computer-implemented method 1000 may include training the neural network in a second phase using the second training set at 1060. Training the neural network in the second phase using the second training set may include presenting positive biological data, simulated positive biological data, and negative biological data to the CNN until the CNN is configured to classify the biological data as positive or negative.

[0128] Once the CNN is fully trained, new biological data can be presented to the CNN. The new biological data can include protein-protein interaction data. The protein-protein interaction data can include one or more of a sequence of a first protein, a sequence of a second protein, an identifier of the first protein, and / or an identifier of the second protein, etc. The CNN can analyze the new biological data and generate a prediction score (e.g., a predicted binding affinity) representing a prediction of successful or unsuccessful binding.

[0129] In one exemplary aspect, the method and system may be used in Fig.11 The disclosed methods and systems may be implemented on computer 1101 as shown and described below. Similarly, the disclosed methods and systems may utilize one or more computers to perform one or more functions at one or more locations. Fig.11 is a block diagram showing an exemplary operating environment for performing the disclosed method. The exemplary operating environment is merely an example of an operating environment and is not intended to impose any limitation on the scope of use or functionality of the operating environment structure. The operating environment should not be interpreted as having any dependency or requirement on any component or combination of components shown in the exemplary operating environment.

[0130] The present method and system can be operated with many other general or special computing system environments or configurations. Examples of well-known computing systems, environments and / or configurations that may be suitable for use with the system and method include, but are not limited to, personal computers, server computers, laptop devices, and multiprocessor systems. Additional examples include set-top boxes, programmable consumer electronics, network PCs, minicomputers, mainframe computers, distributed computing environments including any of the above systems or devices, and the like.

[0131] The processing of the disclosed methods and systems can be performed by software components. The disclosed systems and methods can be described in the general context of computer executable instructions (e.g., program modules) executed by one or more computers or other devices. Typically, program modules include computer code, routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types. The disclosed methods can also be practiced in a grid-based distributed computing environment, where tasks are performed by remote processing devices connected through a communication network. In a distributed computing environment, program modules can be located in local and remote computer storage media including memory storage devices.

[0132] Furthermore, those skilled in the art will appreciate that the systems and methods disclosed herein may be implemented by a general purpose computing device in the form of a computer 1101. Components of the computer 1101 may include, but are not limited to, one or more processors 1103, a system memory 1112, and a system bus 1113 that couples various system components including the one or more processors 1103 to the system memory 1112. The system may utilize parallel computing.

[0133] The system bus 1113 represents one or more of several possible types of bus structures, including a memory bus or memory controller, a peripheral bus, an accelerated graphics port, or a local bus using any of a variety of bus architectures. For example, such architectures may include an Industry Standard Architecture (ISA) bus, a Micro Channel Architecture (MCA) bus, an Enhanced ISA (EISA) bus, a Video Electronics Standards Association (VESA) local bus, an Accelerated Graphics Port (AGP) bus, and a Peripheral Component Interconnect (PCI), PCI-Express bus, a Personal Computer Memory Card Industry Association (PCMCIA), a Universal Serial Bus (USB), and the like. The bus 1113 and all buses specified in this specification may also be implemented by wired or wireless network connections, and each subsystem, including one or more processors 1103, a mass storage device 1104, an operating system 1105, classification software 1106 (e.g., GAN, CNN), classification data 1107 (e.g., "real" or "simulated" data, including positive simulated polypeptide-MHC-I interaction data, positive real polypeptide-MHC-I interaction data and / or negative real polypeptide-MHC-I interaction data), a network adapter 1108, a system memory 1112, an input / output interface 1110, a display adapter 1109, a display device 1111, and a human-computer interface 1102, may be included in one or more remote computing devices 1114a, b, c at physically separate locations, and the remote computing devices are connected by this form of bus, which actually implements a fully distributed system.

[0134] Computer 1101 typically includes a variety of computer-readable media. Exemplary computer-readable media can be any available media that can be accessed by computer 1101, and include, for example and not meant to be limiting, volatile and non-volatile media, removable and non-removable media. System memory 1112 includes computer-readable media in the form of volatile memory, such as random access memory (RAM), and / or computer-readable media in the form of non-volatile memory, such as read-only memory (ROM). System memory 1112 typically contains data such as classification data 1107 and / or program modules such as operating system 1105 and classification software 1106, which are immediately accessible and / or currently operated by one or more processors 1103.

[0135] In another aspect, the computer 1101 may also include other removable / non-removable, volatile / non-volatile computer storage media. For example, Fig.11 A mass storage device 1104 is shown and may provide non-volatile storage of computer code, computer readable instructions, data structures, program modules, and other data for the computer 1101. For example, and not meant to be limiting, the mass storage device 1104 may be a hard disk, a removable magnetic disk, a removable optical disk, a magnetic tape cassette or other magnetic storage device, a flash memory card, a CD-ROM, a digital versatile disk (DVD) or other optical storage, a random access memory (RAM), a read-only memory (ROM), an electrically erasable programmable read-only memory (EEPROM), and the like.

[0136] Optionally, any number of program modules may be stored on the mass storage device 1104, including, for example, an operating system 1105 and classification software 1106. Each of the operating system 1105 and classification software 1106 (or some combination thereof) may include programming elements and classification software 1106. Classification data 1107 may also be stored on the mass storage device 1104. The classification data 1107 may be stored in any one or more databases known in the art. Examples of such databases include Access, SQL Server, mySQL, PostgreSQL, etc. The database can be centralized or distributed across multiple systems.

[0137] In another aspect, a user may enter commands and information into the computer 1101 via an input device (not shown). Examples of such input devices include, but are not limited to, a keyboard, a pointing device (e.g., a "mouse"), a microphone, a joystick, a scanner, tactile input devices such as gloves and other body coverings, etc. These and other input devices may be connected to the one or more processors 1103 via a human machine interface 1102 coupled to the system bus 1113, but may be connected by other interface and bus structures, such as a parallel port, a game port, an IEEE 1394 port (also known as a FireWire port), a serial port, or a Universal Serial Bus (USB).

[0138] In yet another aspect, the display device 1111 may also be connected to the system bus 1113 via an interface such as a display adapter 1109. It is contemplated that the computer 1101 may have more than one display adapter 1109, and the computer 1101 may have more than one display device 1111. For example, the display device 1111 may be a monitor, an LCD (liquid crystal display), or a projector. In addition to the display device 1111, other output peripherals may include components such as speakers (not shown) and printers (not shown), which may be connected to the computer 1101 via an input / output interface 1110. Any steps and / or results of the method may be output to an output device in any form. Such output may be any form of visual reproduction, including but not limited to text, graphics, animation, audio, tactile, etc. The display 1111 and the computer 1101 may be part of one device or may be an independent device.

[0139] The computer 1101 can operate in a networked environment using a logical connection with one or more remote computing devices 1114a, b, c. For example, the remote computing device can be a personal computer, a portable computer, a smart phone, a server, a router, a network computer, a peer device or other public network node, etc. The logical connection between the computer 1101 and the remote computing device 1114a, b, c can be carried out via a network 1115, such as a local area network (LAN) and / or a general wide area network (WAN). Such network connections can be carried out through a network adapter 1108. The network adapter 1108 can be implemented in a wired and wireless environment. Such a networked environment is conventional and common in a home, an office, an enterprise-wide computer network, an intranet, and the Internet.

[0140] For the purpose of illustration, application programs and other executable program components such as operating system 1105 are described herein in discrete box form, but it should be recognized that such programs and components reside in different storage components of computing device 1101 at different times and are executed by one or more processors 1103 of the computer. The implementation of classification software 1106 can be stored on or transmitted through some form of computer-readable medium. Any of the disclosed methods can be executed by computer-readable instructions contained on computer-readable media. Computer-readable media can be any available media that can be accessed by a computer. By way of example and not intended to be limiting, computer-readable media may include "computer storage media" and "communication media". "Computer storage media" includes volatile and non-volatile, removable and non-removable media implemented in any method or technology for storing information such as computer-readable instructions, data structures, program modules or other data. Exemplary computer storage media include, but are not limited to, RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, digital versatile disk (DVD) or other optical storage, cassettes, tapes, disk storage or other magnetic storage devices, or any other media that can be used to store the desired information and can be accessed by a computer.

[0141] The method and system can use artificial intelligence technology, such as machine learning and iterative learning. Examples of such technology include, but are not limited to, expert systems, case-based reasoning, Bayesian networks, behavior-based artificial intelligence, neural networks, fuzzy systems, evolutionary computing (e.g., genetic algorithms), swarm intelligence (e.g., ant algorithms), and hybrid intelligent systems (e.g., expert reasoning rules generated by neural networks or production rules from statistical learning).

[0142] The following examples are presented to provide a person of ordinary skill in the art with a complete disclosure and description of how to prepare and evaluate the compounds, compositions, articles, devices and / or methods claimed herein, and are intended to be purely exemplary and not intended to limit the scope of the methods and systems. Every effort has been made to ensure the accuracy of the values ​​(e.g., amounts, temperatures, etc.), but some errors and deviations should be accounted for. Unless otherwise indicated, parts are parts by weight, temperatures are expressed in ° C or at ambient temperature, and pressures are equal to or close to atmospheric pressure.

[0143] B.HLA alleles

[0144] The disclosed system can be trained for an unlimited number of HLA alleles. Data on peptide binding to MHC-I protein complexes encoded by HLA alleles are known in the art and can be obtained from databases including, but not limited to, IEDB, AntiJen, MHCBN, SYFPEITHI, and the like.

[0145] In one embodiment, the disclosed systems and methods improve the predictability of peptide binding to MHC-I protein complexes encoded by HLA alleles: A0201, A0202, B0702, B2703, B2705, B5701, A0203, A0206, A6802, and combinations thereof. For example, 1028790 is a test set of A0201, A0202, A0203, A0206, A6802.

[0146]

[0147] Predictability may be improved over existing neural systems including but not limited to NetMHCpan, MHCflurry, sNeubula, and PSSM.

[0148] III. Therapeutic Agents

[0149] The disclosed systems and methods can be used to identify peptides that bind to MHC-I of T cells and target cells. In one embodiment, the peptide is a tumor-specific peptide, a viral peptide, or a peptide displayed on the MHC-I of a target cell. The target cell can be a tumor cell, a cancer cell, or a virus-infected cell. Peptides are typically displayed on antigen presenting cells, which then present the peptide antigens to CD8+ cells, such as cytotoxic T cells. The binding of peptide antigens to T cells activates or stimulates T cells. Therefore, one embodiment provides a vaccine, such as a cancer vaccine containing one or more peptides identified using the systems and methods disclosed herein.

[0150] Another embodiment provides an antibody or antigen-binding fragment thereof that binds to a peptide, a peptide antigen-MHC-I complex, or both.

[0151] Although specific embodiments of the present invention have been described, those skilled in the art will appreciate that there are other embodiments that are equivalent to the described embodiments. It is therefore to be understood that the present invention is not limited to the specific embodiments shown, but is limited only by the scope of the appended claims.

[0152] Example

[0153] Example 1: Evaluation of existing prediction models

[0154] The prediction models NetMHCpan, sNebula, MHCflurry, CNN, and PSSM were evaluated. The area under the ROC curve was used as a performance measure. A value of 1 indicates good performance, a value of 0 indicates poor performance, and a value of 0.5 is equivalent to random guessing. Table 1 shows the models and the data used.

[0155] Table 1: Various models used to predict peptide binding to the MHC-I protein complex encoded by a given allele

[0156] NetMHCpan Paired Learning Neural Networks sNebula Pairwise Similarity Kernel SVM MHCflurry The whole of the neural network CNN Convolutional Neural Networks PSSM Position weight matrix

[0157] Fig.12 Evaluation data is shown, which shows that the CNN trained as described in this paper outperforms other models in most test cases, including the current state of the art NetMHCpan. Fig.12 AUC heatmaps are shown indicating the results of applying the state-of-the-art model and the presently described method ("CNN_ours") to the same 15 test datasets. Fig.12 In the chart, a diagonal line from the lower left corner to the upper right corner generally represents a higher value, the thinner the line, the higher the value, and the thicker the line, the lower the value. A diagonal line from the lower right corner to the upper left corner generally represents a lower value, the thinner the line, the lower the value, and the thicker the line, the higher the value.

[0158] Example 2: Problems with the CNN model

[0159] CNN training involves many random processes (e.g., random processes involved in mini-batch data provisioning, gradient filtering, noise generation, etc.), so reproducibility of the training process may be problematic. For example, Fig.12 showed that the Vang ("Keeling") AUC cannot be perfectly reproduced when the exact same algorithm is implemented on the exact same data. Vang et al., HLA class I binding prediction via convolutional neural networks, Bioinformatics, Sep 1;33(17):2658-2665 (2017).

[0160] Generally speaking, CNN is not as complex as other deep learning frameworks such as deep neural networks due to its parameter sharing nature, however, it is still a complex algorithm.

[0161] Standard CNN extracts features from data through a fixed-size window, but binding information on peptides may not be encoded with equal lengths. In this disclosure, as indicated by the biological research, one type of binding mechanism occurs on the scale of 7 amino acids on the peptide chain, and a window size of 7 may be used, and while the window size performs well, it may not be sufficient to explain other types of binding factors in all HLA binding problems.

[0162] Figure 13A-13C The differences between the various models are shown. Fig.13A 15 test datasets from the IEDB weekly release of HLA binding data are shown. We mark test_id as a unique ID for all 15 test datasets. IEDB is the IEDB data release ID, and in one IEDB release you can have multiple different sub-datasets involving different HLA classes. HLA is the type of HLA that binds to the peptide. Length is the length of the peptide that binds to the HLA. Test size is the number of records we have in this test set. Training size is the number of records we have in this training set. Bind_prop is the ratio of binding to the sum of binding and non-binding in the training dataset, we list it here to measure the skewness of the training data. Bind_size is the number of bindings in the training dataset, we use it to calculate bind_prop.

[0163] Figure 13B-Figure 13C shows the difficulty of reproducing CNN implementations. In terms of differences between models, Figure 13B-Figure 13C The model difference is 0. Figure 13B-Figure 13C It turns out that the implementation of Adam does not match the published results.

[0164] Example 3: Dataset Bias

[0165] A training / test split was performed. The training / test split is a measure designed to avoid overfitting, however, whether or not the measure is valid can depend on the data selected. Regardless of whether the same MHC gene allele (A*02:01) is tested, the performance differences between the models are significant. This shows the AUC bias obtained by selecting a biased test set, Fig.14 The results obtained using the described method for a biased training / test set are shown in column "CNN*1", which shows the performance ratio Fig.12 The shown is worse. Fig.14 In the chart, a diagonal line from the lower left corner to the upper right corner generally represents a higher value, the thinner the line, the higher the value, and the thicker the line, the lower the value. A diagonal line from the lower right corner to the upper left corner generally represents a lower value, the thinner the line, the lower the value, and the thicker the line, the higher the value.

[0166] Example 4: SRCC Deviation

[0167] The best Spearman rank correlation coefficient (SRCC) was selected among the five models tested and compared with the normalized data size. Fig.15 It is shown that the smaller the test size, the better the SRRC. SRCC measures the disorder between the predicted ranks and the label ranks. The larger the test size, the greater the probability of destroying the rank order.

[0168] Example 5: Gradient Descent Comparison

[0169] Adam and RMSprop are compared. Adam is an algorithm for optimization of stochastic objective functions based on first-order gradients, which is based on adaptive estimation of low-order moments. RMSprop (for root mean square propagation) is also a method that adapts the learning rate for each parameter.

[0170] Fig.16A – Fig. 16C It is shown that RMSprop obtains improvements on most datasets compared to Adam. Adam is a momentum-based optimizer that actively changes parameters at the beginning compared to RMSprop. The improvement may be related to: 1) Since the discriminator guides the entire GAN training process, if it follows the momentum and actively updates its parameters, the generator will end up in a suboptimal state; 2) Peptide data is different from images, and fewer errors in generation can be tolerated. Slight differences in 9 to 30 positions can significantly change the binding results, while the entire pixel of the image can change, but will remain in the same category of images. Adam tends to explore further in the parameter area, but this means that each position in the area is lighter; while RMSprop stays at each point longer and can find subtle changes in parameters that point to significant improvements in the final output of the discriminator, and transfer this knowledge to the generator to generate better simulated peptides.

[0171] Example 5: Format of peptide training

[0172] Table 2 shows example MHC-I interaction data. Peptides with different binding affinities for the indicated HLA alleles are shown. Peptides are indicated as binding (1) or non-binding (-1). Binding categories range from half maximal inhibitory concentration (IC 50 ) is converted. The predicted output is IC 50 The unit is given in nM. The smaller the number, the higher the affinity. IC 50 Peptides with values ​​<50 nM are considered high affinity, <500 nM are medium affinity, and <5000 nM are low affinity. Most known epitopes have high or medium affinity. Some epitopes have low affinity. Known T cell epitopes have IC 50 The values ​​were all less than 5000nM.

[0173] Table 2: Peptides against identified HLA alleles. Peptides are shown to bind or not bind to the MHC-I protein complex encoded by the HLA allele.

[0174] Peptides HLA Combine categories AAAAAAAALY (SEQ ID NO: 1) A829:02 1 AAAAALQAK (SEQ ID NO: 2) A*03:01 1 AAAAALWL (SEQ ID NO: 3) C*16:01 1 AAAAARAAL (SEQ ID NO:4) B*14:02 -1 AAAAEEEEE (SEQ ID NO: 5) A*02:01 -1 AAAAFEAAL (SEQ ID NO:6) B*48:01 1 AAAAPYAGW (SEQ ID NO:7) B*58:01 1 AAAARAAAL (SEQ ID NO:8) B*14:02 1 AAAATCALV (SEQ ID NO:9) A*02:01 1 AAAATCALV (SEQ ID NO:9) A*02:02 1 AAAATCALV (SEQ ID NO:9) A*02:03 1 AAAATCALV (SEQ ID NO:9) A*02:06 1 AAAATCALV (SEQ ID NO:9) A*68:02 1 AAADAAAAL (SEQ ID NO: 10) C*03:04 1 AAADFAHAE (SEQ ID NO: 11) B*44:03 -1 AAADPKVAF (SEQ ID NO: 12) C*16:01 1

[0175] Example 6: GAN Comparison

[0176] Fig.17 It is shown that a mixture of simulated (e.g., artificial, fake) positive data, real positive data, and real negative data produces better predictions than either the individual positive and real negative data or the simulated positive and real negative data. The results of the described method are shown in the column "CNN" and the two columns "GAN-CNN". Fig.17 In the figure, the diagonal line from the bottom left to the top right generally represents higher values, the thinner the line, the higher the value, and the thicker the line, the lower the value. The diagonal line from the bottom right to the top left generally represents lower values, the thinner the line, the lower the value, and the thicker the line, the higher the value. GAN improves the performance of A0201 for all test sets. Since the binding information is encoded spatially, the use of information extractors (e.g., CNN+skip-gram embedding) is well suited for peptide data. The data generated from the public GAN can be seen as a way of "interpolation", which helps to make the data distribution smoother and make the model easier to learn. In addition, the loss function of the GAN allows the GAN to generate bright samples instead of blue ordinary samples, which is different from classical methods such as variational autoencoders. Since there are many potential chemical binding modes, averaging different modes to the midpoint will be suboptimal, so even if the GAN can overfit and face mode collapse problems, it will better model the mode.

[0177] The disclosed method outperforms prior art systems in part due to the use of different training data. The disclosed method outperforms the use of only true positive and true negative data because the generator can boost the frequency of some weak binding signals, which increases the frequency of some binding modes, and balances the weights of different binding modes in the training data set, making the model easier to learn.

[0178] The disclosed method outperforms the use of only pseudo positive and true negative data because the pseudo positive class has a mode collapse problem, meaning that it cannot represent the combined mode of the entire population; similar to inputting true positive and true negative data into the model as training data, but it reduces the number of training samples, resulting in the model having less data available for learning.

[0179] exist Fig.17 In the data structure, the following columns are used: test_id: a unique ID of a test set, used to distinguish the test set; IEDB: the ID of the dataset on the IEDB database; HLA: the allele type of the complex bound to the peptide; Length: the number of amino acids in the peptide; Test_size: how many observations are there in the test dataset; Train_size: how many observations are there in the training dataset; Bind_prop: the proportion of binding in the training dataset; Bind_size: the number of bindings in the training dataset.

[0180] Unless otherwise expressly stated, it is not intended that any method described herein be construed as requiring that its steps be performed in a particular order. Therefore, in the event that a method claim does not actually list the order in which its steps are to be followed, or in the absence of other specific statements in the claims or specification limiting the steps to a particular order, it is not intended that an order can be inferred in any respect. This applies to any possible non-explicit basis for interpretation, including: logical issues regarding the arrangement of steps or operational flow; plain meaning derived from grammatical composition or punctuation; the number or type of embodiments described in the specification.

[0181] Although the present invention has been described in the foregoing specification with respect to certain embodiments of the invention and many details have been presented for the purpose of illustration, it will be apparent to those skilled in the art that the present invention is susceptible to other embodiments and that certain details described herein may be modified considerably without departing from the basic principles of the invention.

[0182] All references cited herein are incorporated by reference in their entirety. The present invention may be embodied in other specific forms without departing from the spirit or essential attributes thereof, and therefore, reference should be made to the appended claims, rather than to the foregoing specification, to indicate the scope of the invention.

[0183] Exemplary embodiments

[0184] Embodiment 1. A method for training a generative adversarial network (GAN), the method comprising: generating increasingly accurate positive simulated polypeptide-MHC-I interaction data by a GAN generator until a GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive; presenting the positive simulated polypeptide-MHC-I interaction data, positive real polypeptide-MHC-I interaction data, and negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative; presenting the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate a prediction score; determining that the GAN is trained according to the prediction score; and outputting the GAN and the CNN.

[0185] Embodiment 2. A method as described in embodiment 1, wherein generating the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as real includes: generating a first simulated data set by the GAN generator according to a set of GAN parameters, the first simulated data set including simulated positive polypeptide-MHC-I interactions for MHC alleles; combining the first simulated data set with the positive real polypeptide-MHC-I interactions for the MHC alleles and the negative real polypeptide-MHC-I interactions for the MHC alleles to generate a GAN training data set; determining by the discriminator whether the polypeptide-MHC-I interaction for the MHC allele in the GAN training data set is simulated positive, real positive or real negative according to a decision boundary; adjusting by the discriminator one or more of the set of GAN parameters or the decision boundary according to the determined accuracy; and repeating ad until a first stopping criterion is met.

[0186] Embodiment 3. A method as described in embodiment 2, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are presented to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, comprising: generating a second simulated data set by the GAN generator according to the set of GAN parameter sets, the second simulated data set comprising simulated positive polypeptide-MHC-I interactions for the HLA alleles; presenting the second simulated data set, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative; The positive true polypeptide-MHC-I interactions for the MHC allele and the negative true polypeptide-MHC-I interactions for the MHC allele are combined to generate a CNN training dataset; the CNN training dataset is presented to the convolutional neural network (CNN); the polypeptide-MHC-I interactions for the MHC allele in the CNN training dataset are classified as positive or negative by the CNN according to a set of CNN parameters; one or more of the set of CNN parameters are adjusted by the CNN according to the accuracy of the classification; and hj is repeated until a second stopping criterion is met.

[0187] Embodiment 4. A method as described in embodiment 3, wherein presenting the positive true polypeptide-MHC-I interaction data and the negative true polypeptide-MHC-I interaction data to the CNN to generate a prediction score includes: the CNN classifies the polypeptide-MHC-I interaction for the MHC allele as positive or negative according to the set of CNN parameter sets.

[0188] Embodiment 5. A method as described in Embodiment 4, wherein determining that the GAN is trained based on the prediction score includes: determining the accuracy of the classification by the CNN, wherein when (if) the accuracy of the classification meets a third stopping criterion, outputting the GAN and the CNN.

[0189] Embodiment 6. A method as described in Embodiment 4, wherein determining that the GAN is trained based on the prediction score includes: determining the accuracy of the classification by the CNN, wherein when (if) the accuracy of the classification does not meet a third stopping criterion, returning to step a.

[0190] Embodiment 7. A method as described in Embodiment 2, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate or batch size.

[0191] Embodiment 8. The method of embodiment 2, wherein the MHC allele is an HLA allele.

[0192] Embodiment 9. A method as described in Embodiment 8, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C or their subtypes.

[0193] Embodiment 10. A method as described in Embodiment 8, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0194] Embodiment 11. A method as described in Embodiment 8, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0195] Embodiment 12. The method as described in embodiment 1 also includes: presenting a data set to the CNN, wherein the data set includes multiple candidate polypeptide-MHC-I interactions; classifying each of the multiple candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction by the CNN; and synthesizing the polypeptide from the candidate polypeptide-MHC-I interactions classified as positive polypeptide-MHC-I interactions.

[0196] Embodiment 13. A polypeptide produced by the method of embodiment 12.

[0197] Embodiment 14. The method of Embodiment 12, wherein the polypeptide is a tumor-specific antigen.

[0198] Embodiment 15. The method of embodiment 12, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

[0199] Embodiment 16. A method as described in embodiment 1, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0200] Embodiment 17. The method of embodiment 16, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705, and combinations thereof.

[0201] Embodiment 18. A method as described in embodiment 1, wherein generating the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive includes evaluating a gradient descent expression for the GAN generator.

[0202] Embodiment 19. A method as described in embodiment 1, wherein generating the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive includes: iteratively executing (e.g., optimizing) the GAN discriminator to increase the possibility of giving a high probability to the positive real polypeptide-MHC-I interaction data, a low probability to the positive simulated polypeptide-MHC-I interaction data, and a low probability to the negative real polypeptide-MHC-I interaction data; and iteratively executing (e.g., optimizing) the GAN generator to increase the probability of the positive simulated polypeptide-MHC-I interaction data being scored highly.

[0203] Embodiment 20. A method as described in embodiment 1, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are presented to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, including: performing a convolution procedure; performing a nonlinear (ReLU) procedure; performing a pooling or subsampling procedure; and performing a classification (fully connected layer) procedure.

[0204] Embodiment 21. A method as described in Embodiment 1, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0205] Embodiment 22. A method as described in Embodiment 2, wherein the first stopping criterion includes evaluating a mean square error (MSE) function.

[0206] Embodiment 23. A method as described in Embodiment 3, wherein the second stopping criterion includes evaluating a mean square error (MSE) function.

[0207] Embodiment 24. A method as described in embodiment 5 or 6, wherein the third stopping criterion includes evaluating the area under the curve (AUC) function.

[0208] Embodiment 25. A method as described in embodiment 1, wherein the prediction score is the probability of positive true polypeptide-MHC-I interaction data being classified as positive polypeptide-MHC-I interaction data.

[0209] Embodiment 26. A method as described in Embodiment 1, wherein determining that the GAN is trained based on the prediction scores includes comparing one or more of the prediction scores to a threshold.

[0210] Embodiment 27. A method for training a generative adversarial network (GAN), the method comprising: generating increasingly accurate positive simulated polypeptide-MHC-I interaction data by a GAN generator until a GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, presenting the positive simulated polypeptide-MHC-I interaction data, positive real polypeptide-MHC-I interaction data, and negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, presenting the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate a prediction score, and determining that the GAN is untrained based on the prediction score; repeating ac until the GAN is determined to be trained based on the prediction score; and outputting the GAN and the CNN.

[0211] Embodiment 28. A method as described in embodiment 27, wherein generating the increasingly accurate positive simulated polypeptide-MHC-I interaction data by the GAN generator until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive includes: generating a first simulated data set by the GAN generator according to a set of GAN parameters, the first simulated data set including simulated positive polypeptide-MHC-I interactions for MHC alleles; combining the first simulated data set with the positive real polypeptide-MHC-I interactions for the MHC alleles and the negative real polypeptide-MHC-I interactions for the MHC alleles to generate a GAN training data set; determining by the discriminator whether the positive polypeptide-MHC-I interactions for the MHC alleles in the GAN training data set are simulated positive, real positive or real negative according to a decision boundary; adjusting by the discriminator one or more of the set of GAN parameters or the decision boundary according to the determined accuracy; and repeating gj until a first stopping criterion is met.

[0212] Embodiment 29. A method as described in embodiment 28, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are presented to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, comprising: generating a second simulated data set by the GAN generator according to the set of GAN parameter sets, the second simulated data set comprising simulated positive polypeptide-MHC-I interactions for the MHC alleles; presenting the second simulated data set, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative. The known positive polypeptide-MHC-I interactions for the MHC allele and the known negative polypeptide-MHC-I interactions for the MHC allele are combined to generate a CNN training data set; the CNN training data set is presented to the convolutional neural network (CNN); the polypeptide-MHC-I interactions for the MHC allele in the CNN training data set are classified as positive or negative by the CNN according to a set of CNN parameters; one or more of the set of CNN parameters are adjusted by the CNN according to the accuracy of the classification; and np is repeated until a second stopping criterion is met.

[0213] Embodiment 30. A method as described in embodiment 29, wherein presenting the positive true polypeptide-MHC-I interaction data and the negative true polypeptide-MHC-I interaction data to the CNN to generate the prediction score includes: the CNN classifies the polypeptide-MHC-I interaction for the MHC allele as positive or negative according to the set of CNN parameter sets.

[0214] Embodiment 31. A method as described in Embodiment 30, wherein determining that the GAN is trained based on the prediction score includes: determining the accuracy of the classification by the CNN, wherein when (if) the accuracy of the classification meets a third stopping criterion, outputting the GAN and the CNN.

[0215] Embodiment 32. A method as described in Embodiment 31, wherein determining that the GAN is trained based on the prediction score includes: determining the accuracy of the classification by the CNN, wherein when (if) the accuracy of the classification does not meet a third stopping criterion, returning to step a.

[0216] Embodiment 33. A method as described in Embodiment 28, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate or batch size.

[0217] Embodiment 34. A method as described in Embodiment 33, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C or their subtypes.

[0218] Embodiment 35. A method as described in Embodiment 33, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0219] Embodiment 36. A method as described in Embodiment 35, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0220] Embodiment 37. The method as described in Embodiment 27 also includes: presenting a data set to the CNN, wherein the data set includes multiple candidate polypeptide-MHC-I interactions; classifying each of the multiple candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction by the CNN; and synthesizing the polypeptide from the candidate polypeptide-MHC-I interactions classified as positive polypeptide-MHC-I interactions.

[0221] Embodiment 38. A polypeptide produced by the method of embodiment 37.

[0222] Embodiment 39. The method of Embodiment 37, wherein the polypeptide is a tumor-specific antigen.

[0223] Embodiment 40. The method of embodiment 37, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

[0224] Embodiment 41. A method as described in Embodiment 27, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0225] Embodiment 42. The method of embodiment 41, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705, and combinations thereof.

[0226] Embodiment 43. A method as described in Embodiment 27, wherein generating the increasingly accurate positive simulated polypeptide-MHC-I interaction data by the GAN generator until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive includes evaluating a gradient descent expression for the GAN generator.

[0227] Embodiment 44. A method as described in embodiment 27, wherein generating the increasingly accurate positive simulated polypeptide-MHC-I interaction data by the GAN generator until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive includes: iteratively executing (e.g., optimizing) the GAN discriminator to increase the possibility of giving a high probability to the positive real polypeptide-MHC-I interaction data, giving a low probability to the positive simulated polypeptide-MHC-I interaction, and giving a low probability to the negative real polypeptide-MHC-I interaction data; and iteratively executing (e.g., optimizing) the GAN generator to increase the probability of the positive simulated polypeptide-MHC-I interaction data being scored highly.

[0228] Embodiment 45. A method as described in embodiment 27, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are presented to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, including: performing a convolution procedure; performing a non-linear (ReLU) procedure; performing a pooling or subsampling procedure; and performing a classification (fully connected layer) procedure.

[0229] Embodiment 46. A method as described in Embodiment 27, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0230] Embodiment 47. A method as described in Embodiment 28, wherein the first stopping criterion includes evaluating a mean square error (MSE) function.

[0231] Embodiment 48. A method as described in Embodiment 27, wherein the second stopping criterion includes evaluating a mean square error (MSE) function.

[0232] Embodiment 49. A method as described in embodiment 31 or 32, wherein the third stopping criterion includes evaluating the area under the curve (AUC) function.

[0233] Embodiment 50. A method as described in Embodiment 27, wherein the prediction score is the probability of positive true polypeptide-MHC-I interaction data being classified as positive polypeptide-MHC-I interaction data.

[0234] Embodiment 51. A method as described in Embodiment 27, wherein determining that the GAN is trained based on the prediction scores includes comparing one or more of the prediction scores to a threshold.

[0235] Embodiment 52. A method for training a generative adversarial network (GAN), the method comprising: generating a first simulated data set by a GAN generator according to a set of GAN parameters, the first simulated data set comprising simulated positive polypeptide-MHC-I interactions for MHC alleles; combining the first simulated data set with positive real polypeptide-MHC-I interactions and negative real polypeptide-MHC-I interactions for the MHC alleles; determining by a discriminator whether the positive polypeptide-MHC-I interactions for the MHC alleles in the GAN training data set are positive or negative according to a decision boundary; adjusting by the discriminator one or more of the set of GAN parameters or the decision boundary according to the accuracy of the determination; repeating ad until a first stopping criterion is met; generating by the GAN generator a second simulated data set according to the set of GAN parameters, the second simulated data set comprising simulated positive polypeptide-MHC-I interactions for the MHC alleles; combining the second simulated data set with the positive real polypeptide-MHC-I interactions and the negative real polypeptide-MHC-I interactions to generate a CNN training data set; combining the A CNN training data set is presented to a convolutional neural network (CNN); the CNN classifies the polypeptide-MHC-I interaction for the MHC allele in the CNN training data set as positive or negative according to a set of CNN parameters; one or more of the set of CNN parameters are adjusted according to the accuracy of the classification of the polypeptide-MHC-I interaction for the MHC allele in the CNN training data set by the CNN; hj is repeated until a second stopping criterion is met; the positive true polypeptide-MHC-I interaction data and the negative true polypeptide-MHC-I interaction data are presented to the CNN; the CNN classifies the polypeptide-MHC-I interaction for the MHC allele as positive or negative according to the set of CNN parameters; and the accuracy of the classification of the polypeptide-MHC-I interaction for the MHC allele by the CNN is determined, wherein when (if) the accuracy of the classification meets a third stopping criterion, the GAN and the CNN are output, wherein when (if) the accuracy of the classification does not meet the third stopping criterion, return to step a.

[0236] Embodiment 53. A method as described in Embodiment 52, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate or batch size.

[0237] Embodiment 54. The method of embodiment 52, wherein the MHC allele is an HLA allele.

[0238] Embodiment 55. A method as described in Embodiment 54, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C or their subtypes.

[0239] Embodiment 56. A method as described in Embodiment 54, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0240] Embodiment 57. A method as described in Embodiment 54, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0241] Embodiment 58. The method as described in Embodiment 52 also includes: presenting a data set to the CNN, wherein the data set includes multiple candidate polypeptide-MHC-I interactions; classifying each of the multiple candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction by the CNN; and synthesizing the polypeptide from the candidate polypeptide-MHC-I interactions classified as positive polypeptide-MHC-I interactions.

[0242] Embodiment 59. A polypeptide produced by the method of embodiment 58.

[0243] Embodiment 60. The method of Embodiment 58, wherein the polypeptide is a tumor-specific antigen.

[0244] Embodiment 61. A method as described in Embodiment 58, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected human leukocyte antigen (HLA) allele.

[0245] Embodiment 62. A method as described in Embodiment 52, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0246] Embodiment 63. A method as described in Embodiment 62, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705 and combinations thereof.

[0247] Embodiment 64. A method as described in Embodiment 52, wherein repeating ad until the first stopping criterion is met includes evaluating a gradient descent expression for the GAN generator.

[0248] Embodiment 65. A method as described in embodiment 52, wherein repeating ad until the first stopping criterion is met includes: iteratively executing (e.g., optimizing) the GAN discriminator to increase the possibility of giving a high probability to the positive real polypeptide-MHC-I interaction data, a low probability to the positive simulated polypeptide-MHC-I interaction data, and a low probability to the negative real polypeptide-MHC-I interaction data; and iteratively executing (e.g., optimizing) the GAN generator to increase the probability of positive simulated polypeptide-MHC-I interaction data being scored highly.

[0249] Embodiment 66. A method as described in Embodiment 52, wherein presenting the CNN training data set to the CNN includes: performing a convolution procedure; performing a non-linear (ReLU) procedure; performing a pooling or subsampling procedure; and performing a classification (fully connected layer) procedure.

[0250] Embodiment 67. A method as described in Embodiment 52, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0251] Embodiment 68. A method as described in Embodiment 52, wherein the first stopping criterion includes evaluating a mean square error (MSE) function.

[0252] Embodiment 69. A method as described in Embodiment 52, wherein the second stopping criterion includes evaluating a mean square error (MSE) function.

[0253] Embodiment 70. A method as described in Embodiment 52, wherein the third stopping criterion includes evaluating the area under the curve (AUC) function.

[0254] Embodiment 71. A method, comprising: training a convolutional neural network (CNN) according to the method described in Embodiment 1; presenting a data set to the CNN, wherein the data set comprises a plurality of candidate polypeptide-MHC-I interactions; classifying each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction by the CNN; and synthesizing polypeptides associated with the candidate polypeptide-MHC-I interactions classified as positive polypeptide-MHC-I interactions.

[0255] Embodiment 72. A method as described in Embodiment 71, wherein the CNN is trained according to one or more GAN parameters, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate or batch size.

[0256] Embodiment 73. A method as described in Embodiment 72, wherein the allele type is an HLA allele type.

[0257] Embodiment 74. A method as described in Embodiment 73, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C or their subtypes.

[0258] Embodiment 75. A method as described in Embodiment 73, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0259] Embodiment 76. A method as described in Embodiment 73, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0260] Embodiment 77. A polypeptide produced by the method of embodiment 71.

[0261] Embodiment 78. The method of Embodiment 71, wherein the polypeptide is a tumor-specific antigen.

[0262] Embodiment 79. A method as described in Embodiment 71, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected human leukocyte antigen (HLA) allele.

[0263] Embodiment 80. A method as described in Embodiment 71, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0264] Embodiment 81. The method of embodiment 80, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705, and combinations thereof.

[0265] Embodiment 82. A method as described in Embodiment 71, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0266] Embodiment 83. A device for training a generative adversarial network (GAN), the device comprising: one or more processors; and a memory storing processor-executable instructions, which, when executed by the one or more processors, cause the device to: generate increasingly accurate positive simulated polypeptide-MHC-I interaction data until a GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive; present the positive simulated polypeptide-MHC-I interaction data, positive real polypeptide-MHC-I interaction data, and negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative; present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate a prediction score; determine that the GAN is trained based on the prediction score; and output the GAN and the CNN.

[0267] Embodiment 84. An apparatus as described in Embodiment 83, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: generate a first simulated data set according to a set of GAN parameters, the first simulated data set comprising simulated positive polypeptide-MHC-I interactions for MHC alleles The method comprises the steps of: combining the first simulated data set with the positive real polypeptide-MHC-I interaction for the MHC allele and the negative real polypeptide-MHC-I interaction for the MHC allele to generate a GAN training data set; receiving information from a discriminator, wherein the discriminator is configured to determine whether the positive polypeptide-MHC-I interaction for the MHC allele in the GAN training data set is positive or negative according to a decision boundary; adjusting one or more of the set of GAN parameters or the decision boundary according to the accuracy of the information from the discriminator; and repeating ad until a first stopping criterion is met.

[0268] Embodiment 85. An apparatus as described in Embodiment 84, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the apparatus to: generate a second simulated data set according to the set of GAN parameters, the second simulated data set comprising simulated positive polypeptide-MHC-I for the MHC allele C-I interaction; combining the second simulated data set with the positive real polypeptide-MHC-I interaction data for the MHC allele and the negative real polypeptide-MHC-I interaction data for the MHC allele to generate a CNN training data set; presenting the CNN training data set to a convolutional neural network (CNN); receiving training information from the CNN, wherein the CNN is configured to determine the training information by: classifying the polypeptide-MHC-I interactions for the MHC allele in the CNN training data set as positive or negative according to a set of CNN parameters; adjusting one or more of the set of GAN parameters according to the accuracy of the training information; and repeating hj until a second stopping criterion is met.

[0269] Embodiment 86. An apparatus as described in Embodiment 85, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to present the positive true polypeptide-MHC-I interaction data and the negative true polypeptide-MHC-I interaction data to the CNN to generate a prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: classify the polypeptide-MHC-I interaction for the MHC allele as positive or negative based on the set of CNN parameters.

[0270] Embodiment 87. An apparatus as described in Embodiment 86, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the apparatus to determine the accuracy of the classification of the polypeptide-MHC-I interaction as positive or negative for the MHC allele, and when (if) the accuracy of the classification meets a third stopping criterion, output the GAN and the CNN.

[0271] Embodiment 88. An apparatus as described in Embodiment 86, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to determine the accuracy of the classification of the polypeptide-MHC-I interaction as positive or negative for the MHC allele, and when (if) the accuracy of the classification does not meet a third stopping criterion, return to step a.

[0272] Embodiment 89. An apparatus as described in Embodiment 84, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0273] Embodiment 90. The device of Embodiment 89, wherein the HLA allele type comprises one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

[0274] Embodiment 91. An apparatus as described in Embodiment 89, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0275] Embodiment 92. An apparatus as described in Embodiment 89, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0276] Embodiment 93. An apparatus as described in Embodiment 83, wherein the processor executable instructions, when executed by the one or more processors, further cause the apparatus to: present a data set to the CNN, wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is further configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize the polypeptide from the candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction by the CNN.

[0277] Embodiment 94. A polypeptide produced by the device as described in Embodiment 93.

[0278] Embodiment 95. The device of Embodiment 93, wherein the polypeptide is a tumor-specific antigen.

[0279] Embodiment 96. A device as described in Embodiment 93, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected human leukocyte antigen (HLA) allele.

[0280] Embodiment 97. An apparatus as described in Embodiment 83, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0281] Embodiment 98. An apparatus as described in Embodiment 97, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705 and combinations thereof.

[0282] Embodiment 99. An apparatus as described in Embodiment 83, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to generate the increasingly accurate positive mimic polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimic polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the apparatus to evaluate a gradient descent expression for the GAN generator.

[0283] Embodiment 100. An apparatus as described in embodiment 83, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to iteratively execute (e.g., optimize) the GAN discriminator to increase the likelihood of giving a high probability to positive real polypeptide-MHC-I interaction data, a low probability to the positive simulated polypeptide-MHC-I interaction data, and a low probability to the negative simulated polypeptide-MHC-I interaction data; and iteratively execute (e.g., optimize) the GAN generator to increase the probability of the positive simulated polypeptide-MHC-I interaction data being scored highly.

[0284] Embodiment 101. The apparatus of embodiment 83, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative real, the processor-executable instructions further comprising processor-executable instructions that, when executed by the one or more processors, cause the apparatus to: perform a convolution procedure;

[0285] Perform a nonlinear (ReLU) procedure; perform a pooling or subsampling procedure; and perform a classification (fully connected layer) procedure.

[0286] Embodiment 102. An apparatus as described in Embodiment 83, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0287] Embodiment 103. An apparatus as described in Embodiment 84, wherein the first stopping criterion includes an evaluation of a mean square error (MSE) function.

[0288] Embodiment 104. An apparatus as described in Embodiment 85, wherein the second stopping criterion includes an evaluation of a mean square error (MSE) function.

[0289] Embodiment 105. A device as described in embodiment 87 or 88, wherein the third stopping criterion includes an evaluation of the area under the curve (AUC) function.

[0290] Embodiment 106. An apparatus as described in Embodiment 83, wherein the prediction score is the probability that positive true polypeptide-MHC-I interaction data is classified as positive polypeptide-MHC-I interaction data.

[0291] Embodiment 107. An apparatus as described in embodiment 83, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to determine that the GAN is trained based on the prediction scores, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to compare one or more of the prediction scores to a threshold.

[0292] Embodiment 108. An apparatus for training a generative adversarial network (GAN), the apparatus comprising:

[0293] one or more processors; and

[0294] A memory storing processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: generate increasingly accurate positive simulated polypeptide-MHC-I interaction data until a GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive; present the positive simulated polypeptide-MHC-I interaction data, positive real polypeptide-MHC-I interaction data, and negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative; present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate a prediction score; determine that the GAN is untrained based on the prediction score; repeat ac until the GAN is determined to be trained based on the prediction score; and output the GAN and the CNN.

[0295] Embodiment 109. An apparatus as described in embodiment 108, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: generate a first simulated data set according to a set of GAN parameters, the first simulated data set comprising simulated positive polypeptide-MHC for MHC alleles -I interaction; combining the first simulated data set with the positive real polypeptide-MHC-I interaction for the MHC allele and the positive real polypeptide-MHC-I interaction for the MHC allele to generate a GAN training data set; receiving information from a discriminator, wherein the discriminator is configured to determine whether the positive polypeptide-MHC-I interaction for the MHC allele in the GAN training data set is positive or negative; adjusting one or more of the set of GAN parameters or the decision boundaries according to the accuracy of the information from the discriminator; and repeating ij until a first stopping criterion is met.

[0296] Embodiment 110. An apparatus as described in Embodiment 109, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the apparatus to: generate a second simulated data set according to the set of GAN parameters, the second simulated data set comprising the positive simulated polypeptide-MHC-I interaction data for the MHC alleles; The method comprises the steps of: 1. simulating positive polypeptide-MHC-I interactions for a gene; combining the second simulated data set with the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to generate a CNN training data set; presenting the CNN training data set to the convolutional neural network (CNN); receiving information from the CNN, wherein the CNN is configured to determine the information by: classifying the polypeptide-MHC-I interactions for the MHC allele in the CNN training data set as positive or negative according to a set of CNN parameters; adjusting one or more of the set of CNN parameters according to the accuracy of the information from the CNN; and repeating np until a second stopping criterion is met.

[0297] Embodiment 111. An apparatus as described in embodiment 110, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN, wherein the CNN is also configured to classify the polypeptide-MHC-I interaction for the MHC allele as positive or negative according to the set of CNN parameters.

[0298] Embodiment 112. An apparatus as described in embodiment 111, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: determine the accuracy of the classification by the CNN; determine that the accuracy of the classification satisfies a third stopping criterion; and in response to determining that the accuracy of the classification satisfies the third stopping criterion, output the GAN and the CNN.

[0299] Embodiment 113. An apparatus as described in Embodiment 112, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: determine the accuracy of the classification by the CNN; determine that the accuracy of the classification does not meet a third stopping criterion; and in response to determining that the accuracy of the classification does not meet the third stopping criterion, return to step a.

[0300] Embodiment 114. An apparatus as described in Embodiment 109, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0301] Embodiment 115. The device of Embodiment 109, wherein the MHC allele is an HLA allele.

[0302] Embodiment 116. A device as described in Embodiment 115, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

[0303] Embodiment 117. A device as described in Embodiment 115, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0304] Embodiment 118. A device as described in Embodiment 115, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0305] Embodiment 119. An apparatus as described in Embodiment 108, wherein the processor executable instructions, when executed by the one or more processors, further cause the apparatus to: present a data set to the CNN, wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is further configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize the polypeptide from the candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction by the CNN.

[0306] Embodiment 120. A polypeptide produced by the device as described in embodiment 119.

[0307] Embodiment 121. A device as described in Embodiment 119, wherein the polypeptide is a tumor-specific antigen.

[0308] Embodiment 122. A device as described in Embodiment 119, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected human leukocyte antigen (HLA) allele.

[0309] Embodiment 123. An apparatus as described in Embodiment 108, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0310] Embodiment 124. An apparatus as described in Embodiment 123, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705 and combinations thereof.

[0311] Embodiment 125. An apparatus as described in embodiment 108, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to generate the increasingly accurate positive mimic polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimic polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the apparatus to evaluate a gradient descent expression for the GAN generator.

[0312] Embodiment 126. An apparatus as described in embodiment 108, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to iteratively execute (e.g., optimize) the GAN discriminator to increase the likelihood of giving a high probability to positive real polypeptide-MHC-I interaction data, a low probability to the positive simulated polypeptide-MHC-I interaction data, and a low probability to the negative simulated polypeptide-MHC-I interaction data; and iteratively execute (e.g., optimize) the GAN generator to increase the probability of the positive simulated polypeptide-MHC-I interaction data being scored highly.

[0313] Embodiment 127. An apparatus as described in embodiment 108, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: execute a convolution procedure; execute a nonlinear (ReLU) procedure; execute a pooling or subsampling procedure; and execute a classification (fully connected layer) procedure.

[0314] Embodiment 128. An apparatus as described in Embodiment 108, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0315] Embodiment 129. An apparatus as described in Embodiment 109, wherein the first stopping criterion includes an evaluation of a mean square error (MSE) function.

[0316] Embodiment 130. An apparatus as described in Embodiment 108, wherein the second stopping criterion includes an evaluation of a mean square error (MSE) function.

[0317] Embodiment 131. A device as described in embodiment 112 or 113, wherein the third stopping criterion comprises an evaluation of the area under the curve (AUC) function.

[0318] Embodiment 132. An apparatus as described in Embodiment 108, wherein the prediction score is the probability that positive true polypeptide-MHC-I interaction data is classified as positive polypeptide-MHC-I interaction data.

[0319] Embodiment 133. A device as described in embodiment 108, wherein the processor-executable instructions, when executed by the one or more processors, cause the device to determine that the GAN is trained based on the prediction scores, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the device to compare one or more of the prediction scores to a threshold.

[0320] Embodiment 134. An apparatus for training a generative adversarial network (GAN), the apparatus comprising: one or more processors; and a memory storing processor-executable instructions, the processor-executable instructions, when executed by the one or more processors, causing the apparatus to: generate a first simulated data set according to a set of GAN parameters, the first simulated data set comprising simulated positive polypeptide-MHC-I interactions for an MHC allele; combine the first simulated data set with positive real polypeptide-MHC-I interactions for the MHC allele and negative real polypeptide-MHC-I interactions for the MHC allele to generate a GAN training data set; receive information from a discriminator, wherein the discriminator is configured to determine whether the positive polypeptide-MHC-I interactions for the MHC allele in the GAN training data set are positive or negative according to a decision boundary; adjust one or more of the set of GAN parameters or the decision boundary according to the accuracy of the information from the discriminator;

[0321] Repeating ad until a first stopping criterion is met; generating a second simulated data set by the GAN generator according to the set of GAN parameters, the second simulated data set comprising simulated positive polypeptide-MHC-I interactions for the MHC allele; combining the second simulated data set with the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data for the MHC allele to generate a CNN training data set; presenting the CNN training data set to a convolutional neural network (CNN); receiving training information from the CNN, wherein the CNN is configured to determine the training information by: classifying the polypeptide-MHC-I interactions for the MHC allele in the CNN training data set as positive or negative according to a set of CNN parameters; The method comprises the steps of: adjusting one or more of the set of GAN parameters according to the accuracy of the training information; repeating hj until a second stopping criterion is met; presenting the CNN with the positive true polypeptide-MHC-I interaction for the MHC allele and the negative true polypeptide-MHC-I interaction for the MHC allele; receiving training information from the CNN, wherein the CNN is configured to determine the training information by: classifying the polypeptide-MHC-I interaction for the MHC allele as positive or negative according to the set of CNN parameters; and determining the accuracy of the training information, wherein when (if) the accuracy of the training information meets a third stopping criterion, outputting the GAN and the CNN, wherein when (if) the accuracy of the training information does not meet the third stopping criterion, returning to step a.

[0322] Embodiment 135. An apparatus as described in Embodiment 134, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0323] Embodiment 136. A device as described in Embodiment 134, wherein the MHC allele is an HLA allele.

[0324] Embodiment 137. A device as described in Embodiment 136, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

[0325] Embodiment 138. An apparatus as described in Embodiment 136, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0326] Embodiment 139. An apparatus as described in Embodiment 136, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0327] Embodiment 140. An apparatus as described in Embodiment 134, wherein the processor executable instructions, when executed by the one or more processors, further cause the apparatus to: present a data set to the CNN, wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is further configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize the polypeptide from the candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction by the CNN.

[0328] Embodiment 141. A polypeptide produced by the device as described in Embodiment 140.

[0329] Embodiment 142. A device as described in Embodiment 140, wherein the polypeptide is a tumor-specific antigen.

[0330] Embodiment 143. The device of Embodiment 140, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by an MHC allele.

[0331] Embodiment 144. An apparatus as described in Embodiment 134, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0332] Embodiment 145. An apparatus as described in Embodiment 144, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705 and combinations thereof.

[0333] Embodiment 146. An apparatus as described in embodiment 134, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to repeat ad until the first stopping criterion is met, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to evaluate a gradient descent expression for the GAN generator.

[0334] Embodiment 147. An apparatus as described in Embodiment 134, wherein the processor-executable instructions, when executed by the one or more processors, cause the apparatus to repeat ad until the first stopping criterion is met, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the apparatus to: iteratively execute (e.g., optimize) the GAN discriminator to increase the likelihood of giving a high probability to positive real polypeptide-MHC-I interaction data, a low probability to the positive simulated polypeptide-MHC-I interaction data, and a low probability to the negative simulated polypeptide-MHC-I interaction data; and iteratively execute (e.g., optimize) the GAN generator to increase the probability that the positive simulated polypeptide-MHC-I interaction data is scored highly.

[0335] Embodiment 148. A device as described in embodiment 134, wherein the processor-executable instructions, when executed by the one or more processors, cause the device to present the CNN training data set to the CNN, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the device to: execute a convolution procedure; execute a nonlinearity (ReLU) procedure; execute a pooling or subsampling procedure; and execute a classification (fully connected layer) procedure.

[0336] Embodiment 149. An apparatus as described in Embodiment 134, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0337] Embodiment 150. An apparatus as described in embodiment 134, wherein the first stopping criterion includes an evaluation of a mean square error (MSE) function.

[0338] Embodiment 151. An apparatus as described in Embodiment 134, wherein the second stopping criterion includes an evaluation of a mean square error (MSE) function.

[0339] Embodiment 152. A device as described in Embodiment 134, wherein the third stopping criterion includes an evaluation of an area under the curve (AUC) function.

[0340] Embodiment 153. A device, comprising: one or more processors; and a memory storing processor-executable instructions, which, when executed by the one or more processors, cause the device to: train a convolutional neural network (CNN) in the same manner as the device described in Embodiment 83; present a data set to the CNN, wherein the data set comprises a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize polypeptides associated with candidate polypeptide-MHC-I interactions classified as positive polypeptide-MHC-I interactions by the CNN.

[0341] Embodiment 154. A device as described in embodiment 153, wherein the CNN is trained according to one or more GAN parameters, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0342] Embodiment 155. A device as described in Embodiment 154, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C or their subtypes.

[0343] Embodiment 156. A device as described in Embodiment 154, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0344] Embodiment 157. An apparatus as described in Embodiment 155, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0345] Embodiment 158. A polypeptide produced by the device as described in embodiment 153.

[0346] Embodiment 159. A device as described in Embodiment 153, wherein the polypeptide is a tumor-specific antigen.

[0347] Embodiment 160. The device of Embodiment 153, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

[0348] Embodiment 161. An apparatus as described in Embodiment 153, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0349] Embodiment 162. An apparatus as described in Embodiment 161, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705 and combinations thereof.

[0350] Embodiment 163. An apparatus as described in Embodiment 153, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0351] Embodiment 164. A non-transitory computer-readable medium for training a generative adversarial network (GAN), the non-transitory computer-readable medium storing processor-executable instructions, which, when executed by one or more processors, cause the one or more processors to: generate increasingly accurate positive simulated polypeptide-MHC-I interaction data until a GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive; present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative; present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate a prediction score; determine that the GAN is trained based on the prediction score; and output the GAN and the CNN.

[0352] Embodiment 165. The non-transitory computer-readable medium of Embodiment 164, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, the processor-executable instructions further causing the one or more processors to: generate a first simulated data set according to a set of GAN parameters, the first simulated data set comprising simulated positive polypeptide-MHC-I interactions for MHC alleles; The first simulated data set is combined with the positive real polypeptide-MHC-I interaction for the MHC allele and the negative real polypeptide-MHC-I interaction for the MHC allele to generate a GAN training data set; receiving information from a discriminator, wherein the discriminator is configured to determine whether the positive polypeptide-MHC-I interaction for the MHC allele in the GAN training data set is positive or negative according to a decision boundary; adjusting one or more of the set of GAN parameters or the decision boundary according to the accuracy of the information from the discriminator; and repeating ad until a first stopping criterion is met.

[0353] Embodiment 166. A non-transitory computer-readable medium as described in Embodiment 165, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the one or more processors to: generate a second simulated data set according to the set of GAN parameters, the second simulated data set comprising for The method comprises the steps of: simulating positive polypeptide-MHC-I interactions for the MHC allele; combining the second simulated data set with the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data for the MHC allele to generate a CNN training data set; presenting the CNN training data set to a convolutional neural network (CNN); receiving training information from the CNN, wherein the CNN is configured to determine the training information by: classifying the polypeptide-MHC-I interactions for the MHC allele in the CNN training data set as positive or negative according to a set of CNN parameters; adjusting one or more of the set of GAN parameters according to the accuracy of the training information; and repeating hj until a second stopping criterion is met.

[0354] Embodiment 167. A non-transitory computer-readable medium as described in Embodiment 166, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate a prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN, wherein the CNN is also configured to classify the polypeptide-MHC-I interaction for the MHC allele as positive or negative based on the set of CNN parameters.

[0355] Embodiment 168. A non-transitory computer-readable medium as described in Embodiment 167, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the one or more processors to determine the accuracy of the classification of the polypeptide-MHC-I interaction as positive or negative for the MHC allele, and when (if) the accuracy of the classification meets a third stopping criterion, output the GAN and the CNN.

[0356] Embodiment 169. A non-transitory computer-readable medium as described in Embodiment 167, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to determine the accuracy of the classification of the polypeptide-MHC-I interaction as positive or negative for the MHC allele, and when (if) the accuracy of the classification does not meet a third stopping criterion, return to step a.

[0357] Embodiment 170. A non-transitory computer-readable medium as described in Embodiment 165, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0358] Embodiment 171. The non-transitory computer-readable medium of Embodiment 165, wherein the MHC allele is an HLA allele.

[0359] Embodiment 172. The non-transitory computer-readable medium of Embodiment 171, wherein the HLA allele type comprises one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

[0360] Embodiment 173. A non-transitory computer-readable medium as described in Embodiment 171, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0361] Embodiment 174. The non-transitory computer-readable medium of Embodiment 171, wherein the HLA allele is from about 9 to about 11 amino acids in length.

[0362] Embodiment 175. A non-transitory computer-readable medium as described in Embodiment 164, wherein the processor-executable instructions, when executed by the one or more processors, further cause the one or more processors to: present a data set to the CNN, wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is further configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize the polypeptide from the candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction by the CNN.

[0363] Embodiment 176. A polypeptide produced by a non-transitory computer readable medium as described in embodiment 175.

[0364] Embodiment 177. The non-transitory computer-readable medium of Embodiment 175, wherein the polypeptide is a tumor-specific antigen.

[0365] Embodiment 178. The non-transitory computer-readable medium of Embodiment 175, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

[0366] Embodiment 179. A non-transitory computer-readable medium as described in Embodiment 164, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0367] Embodiment 180. The non-transitory computer-readable medium of Embodiment 179, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705, and combinations thereof.

[0368] Embodiment 181. A non-transitory computer-readable medium as described in Embodiment 164, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to generate the increasingly accurate positive mimetic polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimetic polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the one or more processors to evaluate a gradient descent expression for the GAN generator.

[0369] Embodiment 182. A non-transitory computer-readable medium as described in Embodiment 164, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: iteratively execute (e.g., optimize) the GAN discriminator to increase the likelihood of giving a high probability to positive real polypeptide-MHC-I interaction data and a low probability to the positive simulated polypeptide-MHC-I interaction data; and iteratively execute (e.g., optimize) the GAN generator to increase the probability that the positive simulated polypeptide-MHC-I interaction data is scored highly.

[0370] Embodiment 183. A non-transitory computer-readable medium as described in Embodiment 164, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative real, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: execute a convolution procedure; execute a nonlinear (ReLU) procedure; execute a pooling or subsampling procedure; and execute a classification (fully connected layer) procedure.

[0371] Embodiment 184. A non-transitory computer-readable medium as described in Embodiment 164, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0372] Embodiment 185. A non-transitory computer-readable medium as described in Embodiment 165, wherein the first stopping criterion includes an evaluation of a mean square error (MSE) function.

[0373] Embodiment 186. A non-transitory computer-readable medium as described in Embodiment 166, wherein the second stopping criterion includes an evaluation of a mean square error (MSE) function.

[0374] Embodiment 187. A non-transitory computer-readable medium as described in Embodiment 168 or 169, wherein the third stopping criterion comprises an evaluation of an area under the curve (AUC) function.

[0375] Embodiment 188. The non-transitory computer-readable medium of Embodiment 164, wherein the prediction score is a probability that positive true polypeptide-MHC-I interaction data is classified as positive polypeptide-MHC-I interaction data.

[0376] Embodiment 189. A non-transitory computer-readable medium as described in Embodiment 164, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to determine that the GAN is trained based on the prediction scores, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to compare one or more of the prediction scores to a threshold.

[0377] Embodiment 190. A non-transitory computer-readable medium for training a generative adversarial network (GAN), the non-transitory computer-readable medium storing processor-executable instructions, which, when executed by one or more processors, cause the one or more processors to: generate increasingly accurate positive simulated polypeptide-MHC-I interaction data until a GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive; present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to a convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative; present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate a prediction score; determine that the GAN is untrained based on the prediction score; repeat ac until the GAN is determined to be trained based on the prediction score; and output the GAN and the CNN.

[0378] Embodiment 191. A non-transitory computer-readable medium as described in Embodiment 190, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: generate a first simulated data set according to a set of GAN parameters, the first simulated data set comprising a first set of parameters for MHC alleles The method comprises the steps of: 1. simulating positive polypeptide-MHC-I interactions for the MHC allele; combining the first simulated data set with the positive real polypeptide-MHC-I interactions for the MHC allele and the negative real polypeptide-MHC-I interactions for the MHC allele to generate a GAN training data set; receiving information from a discriminator, wherein the discriminator is configured to determine whether the positive polypeptide-MHC-I interactions for the MHC allele in the GAN training data set are positive or negative; adjusting one or more of the set of GAN parameters or the decision boundaries according to the accuracy of the information from the discriminator; and repeating until a first stopping criterion is met.

[0379] Embodiment 192. A non-transitory computer-readable medium as described in Embodiment 191, wherein the processor-executable instructions, when executed by the one or more processors, cause the device to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the one or more processors to: generate a second simulated data set according to the set of GAN parameters, the second simulated data set comprising a first set of parameters for the MHC The method comprises the steps of: simulating positive polypeptide-MHC-I interactions for a MHC allele; combining the second simulated data set with the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data for the MHC allele to generate a CNN training data set; presenting the CNN training data set to the convolutional neural network (CNN); receiving information from the CNN, wherein the CNN is configured to determine the information by: classifying the polypeptide-MHC-I interactions for the MHC allele in the CNN training data set as positive or negative according to a set of CNN parameters; adjusting one or more of the set of GAN parameters according to the accuracy of the information from the CNN; and repeating lp until a second stopping criterion is met.

[0380] Embodiment 193. A non-transitory computer-readable medium as described in Embodiment 192, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN to generate the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: present the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data to the CNN, wherein the CNN is also configured to classify the polypeptide-MHC-I interaction for the MHC allele as positive or negative based on the set of CNN parameters.

[0381] Embodiment 194. A non-transitory computer-readable medium as described in Embodiment 193, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: determine the accuracy of the classification by the CNN; determine that the accuracy of the classification satisfies a third stopping criterion; and in response to determining that the accuracy of the classification satisfies the third stopping criterion, output the GAN and the CNN.

[0382] Embodiment 195. A non-transitory computer-readable medium as described in Embodiment 194, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to determine that the GAN is trained based on the prediction score, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: determine the accuracy of the classification by the CNN; determine that the accuracy of the classification does not meet a third stopping criterion; and in response to determining that the accuracy of the classification does not meet the third stopping criterion, return to step a.

[0383] Embodiment 196. A non-transitory computer-readable medium as described in Embodiment 191, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0384] Embodiment 197. The non-transitory computer-readable medium of Embodiment 191, wherein the MHC allele is an HLA allele.

[0385] Embodiment 198. The non-transitory computer-readable medium of Embodiment 197, wherein the HLA allele type comprises one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

[0386] Embodiment 199. A non-transitory computer-readable medium as described in Embodiment 197, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0387] Embodiment 200. A non-transitory computer-readable medium as described in Embodiment 197, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0388] Embodiment 201. A non-transitory computer-readable medium as described in Embodiment 190, wherein the processor-executable instructions, when executed by the one or more processors, further cause the one or more processors to: present a data set to the CNN, wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is further configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize the polypeptide from the candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction by the CNN.

[0389] Embodiment 202. A polypeptide produced by a non-transitory computer readable medium as described in embodiment 201.

[0390] Embodiment 203. The non-transitory computer-readable medium of Embodiment 201, wherein the polypeptide is a tumor-specific antigen.

[0391] Embodiment 204. The non-transitory computer-readable medium of Embodiment 201, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

[0392] Embodiment 205. A non-transitory computer-readable medium as described in Embodiment 190, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0393] Embodiment 206. The non-transitory computer-readable medium of Embodiment 205, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705, and combinations thereof.

[0394] Embodiment 207. A non-transitory computer-readable medium as described in Embodiment 190, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to generate the increasingly accurate positive mimetic polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimetic polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions that, when executed by the one or more processors, cause the one or more processors to evaluate a gradient descent expression for the GAN generator.

[0395] Embodiment 208. A non-transitory computer-readable medium as described in Embodiment 190, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to generate the increasingly accurate positive simulated polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive simulated polypeptide-MHC-I interaction data as positive, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: iteratively execute (e.g., optimize) the GAN discriminator to increase the likelihood of giving a high probability to positive real polypeptide-MHC-I interaction data, a low probability to the positive simulated polypeptide-MHC-I interaction data, and a low probability to the negative simulated polypeptide-MHC-I interaction data; and iteratively execute (e.g., optimize) the GAN generator to increase the probability that the positive simulated polypeptide-MHC-I interaction data is scored highly.

[0396] Embodiment 209. A non-transitory computer-readable medium as described in Embodiment 190, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to present the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the polypeptide-MHC-I interaction data as positive or negative, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: execute a convolution procedure; execute a nonlinear (ReLU) procedure; execute a pooling or subsampling procedure; and execute a classification (fully connected layer) procedure.

[0397] Embodiment 210. A non-transitory computer-readable medium as described in Embodiment 190, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0398] Embodiment 211. A non-transitory computer-readable medium as described in Embodiment 191, wherein the first stopping criterion includes an evaluation of a mean square error (MSE) function.

[0399] Embodiment 212. A non-transitory computer-readable medium as described in embodiment 190, wherein the second stopping criterion includes an evaluation of a mean square error (MSE) function.

[0400] Embodiment 213. A non-transitory computer-readable medium as described in Embodiment 194 or 195, wherein the third stopping criterion comprises an evaluation of an area under the curve (AUC) function.

[0401] Embodiment 214. A non-transitory computer-readable medium as described in Embodiment 190, wherein the prediction score is the probability of positive true polypeptide-MHC-I interaction data being classified as positive polypeptide-MHC-I interaction data.

[0402] Embodiment 215. A non-transitory computer-readable medium as described in Embodiment 190, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to determine that the GAN is trained based on the prediction scores, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to compare one or more of the prediction scores to a threshold.

[0403] Embodiment 216. A non-transitory computer-readable medium for training a generative adversarial network (GAN), the non-transitory computer-readable medium storing processor-executable instructions, the processor-executable instructions, when executed by one or more processors, causing the one or more processors to: generate a first simulated data set according to a set of GAN parameters, the first simulated data set comprising simulated positive polypeptide-MHC-I interactions for an MHC allele; compare the first simulated data set with the positive real polypeptide-MHC-I interactions for the MHC allele and the negative real polypeptide-MHC-I interactions for the MHC allele; The invention relates to a method for generating a CNN training data set; receiving information from a discriminator, wherein the discriminator is configured to determine whether the positive polypeptide-MHC-I interaction for the MHC allele in the GAN training data set is positive or negative according to a decision boundary; adjusting one or more of the set of GAN parameters or the decision boundary according to the accuracy of the information from the discriminator; repeating ad until a first stopping criterion is met; generating a second simulated data set by the GAN generator according to the set of GAN parameters, wherein the second simulated data set includes simulated positive polypeptide-MHC-I interaction for the MHC allele. The method comprises the steps of: combining the second simulated data set with the positive real polypeptide-MHC-I interaction data and the negative real polypeptide-MHC-I interaction data for the MHC allele to generate a CNN training data set; presenting the CNN training data set to a convolutional neural network (CNN); receiving training information from the CNN, wherein the CNN is configured to determine the training information by: classifying the polypeptide-MHC-I interaction for the MHC allele in the CNN training data set as positive or negative according to a set of CNN parameters; adjusting the set of G parameters according to the accuracy of the training information; and one or more of the GAN parameters; repeating hj until a second stopping criterion is met; presenting the positive true polypeptide-MHC-I interaction data and the negative true polypeptide-MHC-I interaction data to the CNN; receiving training information from the CNN, wherein the CNN is configured to determine the training information by: classifying the polypeptide-MHC-I interaction for the MHC allele as positive or negative according to the set of CNN parameters; and determining the accuracy of the training information, wherein when (if) the accuracy of the training information meets a third stopping criterion, outputting the GAN and the CNN,

[0404] Wherein when (if) the accuracy of the training information does not meet the third stopping criterion, return to step a.

[0405] Embodiment 217. A non-transitory computer-readable medium as described in Embodiment 216, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0406] Embodiment 218. The non-transitory computer-readable medium of Embodiment 216, wherein the MHC allele is an HLA allele.

[0407] Embodiment 219. A non-transitory computer-readable medium as described in Embodiment 218, wherein the HLA allele type comprises one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

[0408] Embodiment 220. A non-transitory computer-readable medium as described in Embodiment 218, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0409] Embodiment 221. A non-transitory computer-readable medium as described in Embodiment 218, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0410] Embodiment 222. A non-transitory computer-readable medium as described in Embodiment 216, wherein the processor-executable instructions, when executed by the one or more processors, further cause the one or more processors to: present a data set to the CNN, wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is further configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize the polypeptide from the candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction by the CNN.

[0411] Embodiment 223. A polypeptide produced by a non-transitory computer readable medium as described in Embodiment 222.

[0412] Embodiment 224. The non-transitory computer-readable medium of Embodiment 222, wherein the polypeptide is a tumor-specific antigen.

[0413] Embodiment 225. The non-transitory computer-readable medium of Embodiment 222, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

[0414] Embodiment 226. A non-transitory computer-readable medium as described in Embodiment 216, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0415] Embodiment 227. The non-transitory computer-readable medium of Embodiment 226, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705, and combinations thereof.

[0416] Embodiment 228. A non-transitory computer-readable medium as described in embodiment 216, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to repeat ad until the first stopping criterion is met, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to evaluate a gradient descent expression for the GAN generator.

[0417] Embodiment 229. A non-transitory computer-readable medium as described in Embodiment 216, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to repeat ad until the first stopping criterion is met, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: iteratively execute (e.g., optimize) the GAN discriminator to increase the likelihood of giving a high probability to positive real polypeptide-MHC-I interaction data, a low probability to the positive simulated polypeptide-MHC-I interaction data, and a low probability to the negative simulated polypeptide-MHC-I interaction data; and iteratively execute (e.g., optimize) the GAN generator to increase the probability that the positive simulated polypeptide-MHC-I interaction data is scored highly.

[0418] Embodiment 230. A non-transitory computer-readable medium as described in Embodiment 216, wherein the processor-executable instructions, when executed by the one or more processors, cause the one or more processors to present the CNN training data set to the CNN, and the processor-executable instructions also include processor-executable instructions, which, when executed by the one or more processors, cause the one or more processors to: execute a convolution program; execute a non-linear (ReLU) program; execute a pooling or subsampling program; and execute a classification (fully connected layer) program.

[0419] Embodiment 231. A non-transitory computer-readable medium as described in Embodiment 216, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).

[0420] Embodiment 232. A non-transitory computer-readable medium as described in Embodiment 216, wherein the first stopping criterion includes an evaluation of a mean square error (MSE) function.

[0421] Embodiment 233. A non-transitory computer-readable medium as described in Embodiment 216, wherein the second stopping criterion includes an evaluation of a mean square error (MSE) function.

[0422] Embodiment 234. A non-transitory computer-readable medium as described in Embodiment 216, wherein the third stopping criterion includes an evaluation of an area under the curve (AUC) function.

[0423] Embodiment 235. A non-transitory computer-readable medium for training a generative adversarial network (GAN), the non-transitory computer-readable medium storing processor-executable instructions, which, when executed by one or more processors, cause the one or more processors to: train a convolutional neural network (CNN) in the same manner as the apparatus described in Embodiment 83; present a data set to the CNN, wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is configured to classify each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; and synthesize polypeptides associated with candidate polypeptide-MHC-I interactions classified as positive polypeptide-MHC-I interactions by the CNN.

[0424] Embodiment 236. A non-transitory computer-readable medium as described in Embodiment 235, wherein the CNN is trained according to one or more GAN parameters, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

[0425] Embodiment 237. A non-transitory computer-readable medium as described in Embodiment 236, wherein the HLA allele type includes one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

[0426] Embodiment 238. A non-transitory computer-readable medium as described in Embodiment 236, wherein the HLA allele length is from about 8 to about 12 amino acids.

[0427] Embodiment 239. A non-transitory computer-readable medium as described in Embodiment 236, wherein the HLA allele length is from about 9 to about 11 amino acids.

[0428] Embodiment 240. A polypeptide produced by a non-transitory computer readable medium as described in embodiment 235.

[0429] Embodiment 241. The non-transitory computer-readable medium of Embodiment 235, wherein the polypeptide is a tumor-specific antigen.

[0430] Embodiment 242. The non-transitory computer-readable medium of Embodiment 235, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected human leukocyte antigen (HLA) allele.

[0431] Embodiment 243. A non-transitory computer-readable medium as described in Embodiment 235, wherein the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data are associated with selected alleles.

[0432] Embodiment 244. The non-transitory computer-readable medium of Embodiment 243, wherein the selected allele is selected from A0201, A0202, A0203, B2703, B2705, and combinations thereof.

[0433] Embodiment 245. A non-transitory computer-readable medium as described in Embodiment 235, wherein the GAN comprises a deep convolutional GAN ​​(DCGAN).< / entry>

Claims

1. A computer-implemented method for training a generative adversarial network (GAN), comprising: a. generating increasingly accurate positive simulated data by a computing device via a GAN generator until a GAN discriminator classifies the positive simulated data as positive; b. presenting the positive simulated data, positive real data, and negative real data to a convolutional neural network (CNN) by the computing device until the CNN classifies each type of data as positive or negative; c. presenting the positive true data and the negative true data to the CNN by the computing device to generate a prediction score; as well as d. Determining, by the computing device, whether the GAN is trained or untrained according to the prediction score, and when the GAN is untrained, repeating steps ac until determining that the GAN is trained according to the prediction score.

2. A computer-implemented method as described in claim 1, wherein the positive simulated data includes positive simulated polypeptide-major histocompatibility complex class I (MHC-I) interaction data, the positive real data includes positive real polypeptide-MHC-I interaction data, and the negative real data includes negative real polypeptide-MHC-I interaction data.

3. The computer-implemented method of claim 2, wherein generating the increasingly accurate positive mimicking polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimicking polypeptide-MHC-I interaction data as real comprises: e. generating, by the GAN generator according to a set of GAN parameters, a first simulated data set, wherein the first simulated data set includes simulated positive polypeptide-MHC-I interactions for MHC alleles; f. combining the first simulated dataset with the positive real polypeptide-MHC-I interactions for the MHC alleles and the negative real polypeptide-MHC-I interactions for the MHC alleles to generate a GAN training dataset; g. determining by a discriminator whether the corresponding polypeptide-MHC-I interaction for the MHC allele in the GAN training data set is simulated positive, true positive or true negative according to a decision boundary; h. adjusting, by the discriminator, one or more of the set of GAN parameters or the decision boundary according to the determined accuracy; and i. Repeat steps eh until the first stopping criterion is met.

4. The computer-implemented method of claim 3, wherein presenting the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the corresponding polypeptide-MHC-I interaction data as positive or negative comprises: j. generating, by the GAN generator according to the set of GAN parameters, a second simulated data set, wherein the second simulated data set includes simulated positive polypeptide-MHC-I interactions for the MHC allele; k. combining the second simulated data set, the positive real polypeptide-MHC-I interactions for the MHC alleles, and the negative real polypeptide-MHC-I interactions for the MHC alleles to generate a CNN training data set; l. presenting the CNN training data set to the convolutional neural network (CNN); m. classifying, by the CNN according to a set of CNN parameters, the corresponding polypeptide-MHC-I interactions for the MHC alleles in the CNN training dataset as positive or negative; n. adjusting one or more of the set of CNN parameters by the CNN according to the accuracy of the classification; and o. Repeat steps ln until the second stopping criterion is met.

5. The method of claim 4, wherein presenting the positive true polypeptide-MHC-I interaction data and the negative true polypeptide-MHC-I interaction data to the CNN to generate a prediction score comprises: The corresponding polypeptide-MHC-I interaction for the MHC allele is classified as positive or negative by the CNN according to the set of CNN parameters.

6. The computer-implemented method of claim 5, wherein determining whether the GAN is trained based on the prediction score comprises: The accuracy of the classification is determined by the CNN, wherein when the accuracy of the classification satisfies a third stopping criterion, the GAN and the CNN are output.

7. The computer-implemented method of claim 5, wherein determining whether the GAN is trained based on the prediction score comprises: The accuracy of the classification is determined by the CNN, wherein when the accuracy of the classification does not meet a third stopping criterion, returning to step a.

8. The computer-implemented method of claim 3, wherein the GAN parameters include one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

9. The computer-implemented method of claim 8, wherein the allele type comprises one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

10. The computer-implemented method of claim 2, further comprising: presenting a dataset to the CNN, wherein the dataset comprises a plurality of candidate polypeptide-MHC-I interactions; classifying, by the CNN, each of the plurality of candidate polypeptide-MHC-I interactions as a positive or negative polypeptide-MHC-I interaction; as well as A polypeptide is synthesized from the candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction.

11. The computer-implemented method of claim 10, wherein the polypeptide is a tumor-specific antigen.

12. The computer-implemented method of claim 10, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

13. The computer-implemented method of claim 2, wherein generating the increasingly accurate positive mimicking polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimicking polypeptide-MHC-I interaction data as positive comprises: iteratively executing the GAN discriminator to increase the likelihood of giving a high probability to positive true peptide-MHC-I interaction data, a low probability to the positive simulated peptide-MHC-I interaction data, and a low probability to the negative true peptide-MHC-I interaction data; as well as The GAN generator is iteratively executed to increase the probability that the positive simulated peptide-MHC-I interaction data is rated highly.

14. An apparatus configured to perform the method according to any one of claims 1-13.

15. A computer readable medium (CRM) configured to perform the method according to any one of claims 1-13.

16. A computer-implemented method for classifying data, comprising: presenting, by a computing device, a data set to a convolutional neural network (CNN), wherein the data set includes a plurality of candidate polypeptide-MHC-I interactions, wherein the CNN is trained based on positive simulated polypeptide-major histocompatibility complex class I (MHC-I) interaction data, positive real polypeptide-MHC-I interaction data, and negative real polypeptide-MHC-I interaction data; as well as At least one candidate polypeptide-MHC-I interaction among the plurality of candidate polypeptide-MHC-I interactions is classified as positive or negative by the CNN.

17. The computer-implemented method of claim 16, further comprising: a. generating positive simulated peptide-MHC-I interaction data via a GAN generator until a GAN discriminator classifies the positive simulated peptide-MHC-I interaction data as positive; b. presenting the positive simulated peptide-MHC-I interaction data, the positive real peptide-MHC-I interaction data, and the negative real peptide-MHC-I interaction data to the CNN until the CNN classifies each type of data as positive or negative; c. presenting the test data including the test positive true polypeptide-MHC-I interaction data and the test negative true polypeptide-MHC-I interaction data to the CNN to generate a prediction score; as well as d. Determine whether the GAN generator is trained or untrained according to the prediction score, and when the GAN generator is untrained, repeat steps ac until it is determined that the GAN generator is trained according to the prediction score.

18. The computer-implemented method of claim 17, wherein generating the positive mimicking polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimicking polypeptide-MHC-I interaction data as positive comprises: e. generating, by the GAN generator according to a set of GAN parameters, a first simulated data set, wherein the first simulated data set includes simulated positive polypeptide-MHC-I interaction data for MHC alleles; f. combining the first simulated data set with the positive real polypeptide-MHC-I interaction data for the MHC allele and the negative real polypeptide-MHC-I interaction data for the MHC allele to generate a GAN training data set; g. determining by a discriminator whether the corresponding polypeptide-MHC-I interaction for the MHC allele in the GAN training data set is simulated positive, true positive or true negative according to a decision boundary; h. adjusting, by the discriminator, one or more of the set of GAN parameters or the decision boundary according to the determined accuracy; and i. Repeat steps eh until the first stopping criterion is met.

19. The computer-implemented method of claim 18, wherein presenting the positive simulated polypeptide-MHC-I interaction data, the positive real polypeptide-MHC-I interaction data, and the negative real polypeptide-MHC-I interaction data to the convolutional neural network (CNN) until the CNN classifies the corresponding polypeptide-MHC-I interaction data as positive or negative comprises: j. generating, by the GAN generator according to the set of GAN parameters, a second simulated data set, wherein the second simulated data set comprises simulated positive polypeptide-MHC-I interaction data for the MHC allele; k. combining the second simulated data set, the positive real polypeptide-MHC-I interaction data for the MHC allele, and the negative real polypeptide-MHC-I interaction data for the MHC allele to generate a CNN training data set; l. presenting the CNN training data set to the convolutional neural network (CNN); m. classifying, by the CNN according to a set of CNN parameters, the corresponding polypeptide-MHC-I interactions for the MHC alleles in the CNN training dataset as positive or negative; n. adjusting one or more of the set of CNN parameters by the CNN according to the accuracy of the classification; and o. Repeat steps ln until the second stopping criterion is met.

20. The computer-implemented method of claim 19, wherein presenting test data comprising test positive true polypeptide-MHC-I interaction data and test negative true polypeptide-MHC-I interaction data to the CNN to generate a prediction score comprises: The corresponding polypeptide-MHC-I interaction for the MHC allele is classified as positive or negative by the CNN according to the set of CNN parameters.

21. The computer-implemented method of claim 20, wherein determining whether the GAN generator is trained based on the prediction score comprises: The accuracy of the classification is determined by the CNN, wherein when the accuracy of the classification satisfies a third stopping criterion, the GAN generator and the CNN are output.

22. The computer-implemented method of claim 20, wherein determining whether the GAN generator is trained based on the prediction score comprises: The accuracy of the classification is determined by the CNN, wherein when the accuracy of the classification does not meet a third stopping criterion, returning to step a.

23. The computer-implemented method of claim 18, wherein the set of GAN parameters comprises one or more of allele type, allele length, generation category, model complexity, learning rate, or batch size.

24. The computer-implemented method of claim 23, wherein the allele type comprises one or more of HLA-A, HLA-B, HLA-C, or subtypes thereof.

25. The computer-implemented method of claim 16, further comprising: A polypeptide is synthesized from the at least one candidate polypeptide-MHC-I interaction classified as a positive polypeptide-MHC-I interaction.

26. The computer-implemented method of claim 25, wherein the polypeptide is a tumor-specific antigen.

27. The computer-implemented method of claim 25, wherein the polypeptide comprises an amino acid sequence that specifically binds to an MHC-I protein encoded by a selected MHC allele.

28. The computer-implemented method of claim 17, wherein generating positive mimicking polypeptide-MHC-I interaction data until the GAN discriminator classifies the positive mimicking polypeptide-MHC-I interaction data as positive comprises: iteratively executing the GAN discriminator to increase the likelihood of giving a high probability to positive true peptide-MHC-I interaction data, a low probability to the positive simulated peptide-MHC-I interaction data, and a low probability to the negative true peptide-MHC-I interaction data; as well as The GAN generator is iteratively executed to increase the probability that the positive simulated peptide-MHC-I interaction data is rated highly.

29. An apparatus configured to perform the method of any one of claims 16-24 and 28.

30. A computer readable medium (CRM) configured to perform the method of any of claims 16-24 and 28.

Images